@pol-studios/powersync 1.0.0

package/dist/chunk-CFCK2LHI.js

@@ -0,0 +1,1002 @@
+import {
+  HEALTH_CHECK_INTERVAL_MS,
+  HEALTH_CHECK_TIMEOUT_MS,
+  LATENCY_DEGRADED_THRESHOLD_MS,
+  MAX_CONSECUTIVE_FAILURES,
+  STATUS_NOTIFY_THROTTLE_MS,
+  STORAGE_KEY_METRICS,
+  STORAGE_KEY_PAUSED,
+  STORAGE_KEY_SYNC_MODE
+} from "./chunk-NPNBGCRC.js";
+import {
+  classifyError,
+  generateFailureId
+} from "./chunk-CHRTN5PF.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
+};
+
+// src/sync/status-tracker.ts
+var SyncStatusTracker = class _SyncStatusTracker {
+  storage;
+  logger;
+  notifyThrottleMs;
+  onStatusChange;
+  _state;
+  _pendingMutations = [];
+  _lastNotifyTime = 0;
+  _notifyTimer = null;
+  _listeners = /* @__PURE__ */ new Set();
+  _syncModeListeners = /* @__PURE__ */ new Set();
+  // Force next upload flag for "Sync Now" functionality
+  _forceNextUpload = false;
+  // Track download progress separately to preserve it when offline
+  _lastProgress = null;
+  // Failed transaction tracking
+  _failedTransactions = [];
+  _maxStoredFailures = 50;
+  _failureTTLMs = 24 * 60 * 60 * 1e3;
+  // 24 hours
+  _failureListeners = /* @__PURE__ */ new Set();
+  // Completed transaction tracking
+  _completedTransactions = [];
+  _maxCompletedHistory = 20;
+  _completedListeners = /* @__PURE__ */ new Set();
+  constructor(storage, logger, options = {}) {
+    this.storage = storage;
+    this.logger = logger;
+    this.notifyThrottleMs = options.notifyThrottleMs ?? STATUS_NOTIFY_THROTTLE_MS;
+    this.onStatusChange = options.onStatusChange;
+    this._state = {
+      status: { ...DEFAULT_SYNC_STATUS },
+      syncMode: "push-pull",
+      lastUpdated: /* @__PURE__ */ new Date()
+    };
+  }
+  // ─── Initialization ────────────────────────────────────────────────────────
+  /**
+   * Initialize the tracker by loading persisted state.
+   * Includes migration from old isPaused boolean to new syncMode.
+   */
+  async init() {
+    try {
+      const modeValue = await this.storage.getItem(STORAGE_KEY_SYNC_MODE);
+      if (modeValue && ["push-pull", "pull-only", "offline"].includes(modeValue)) {
+        this._state.syncMode = modeValue;
+        this.logger.debug("[StatusTracker] Loaded sync mode:", this._state.syncMode);
+      } else {
+        const pausedValue = await this.storage.getItem(STORAGE_KEY_PAUSED);
+        if (pausedValue === "true") {
+          this._state.syncMode = "offline";
+          await this.storage.setItem(STORAGE_KEY_SYNC_MODE, "offline");
+          this.logger.debug("[StatusTracker] Migrated isPaused=true to syncMode=offline");
+        } else {
+          this._state.syncMode = "push-pull";
+        }
+        await this.storage.removeItem(STORAGE_KEY_PAUSED);
+      }
+    } catch (err) {
+      this.logger.warn("[StatusTracker] Failed to load sync mode:", err);
+    }
+  }
+  /**
+   * Dispose the tracker and clear timers.
+   */
+  dispose() {
+    if (this._notifyTimer) {
+      clearTimeout(this._notifyTimer);
+      this._notifyTimer = null;
+    }
+    this._listeners.clear();
+    this._syncModeListeners.clear();
+    this._failureListeners.clear();
+    this._completedListeners.clear();
+  }
+  // ─── Status Getters ────────────────────────────────────────────────────────
+  /**
+   * Get the current sync status.
+   */
+  getStatus() {
+    const baseStatus = this._state.status;
+    const status = {
+      ...baseStatus,
+      failedTransactions: this._failedTransactions,
+      hasUploadErrors: this._failedTransactions.length > 0,
+      permanentErrorCount: this._failedTransactions.filter((f) => f.isPermanent).length
+    };
+    if (this._state.syncMode === "offline" && this._lastProgress) {
+      return {
+        ...status,
+        downloadProgress: this._lastProgress
+      };
+    }
+    return status;
+  }
+  // ─── Sync Mode Getters ────────────────────────────────────────────────────────
+  /**
+   * Get the current sync mode.
+   */
+  getSyncMode() {
+    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.
+   */
+  canUpload() {
+    return this._state.syncMode === "push-pull";
+  }
+  /**
+   * Check if downloads are allowed based on current sync mode.
+   */
+  canDownload() {
+    return this._state.syncMode !== "offline";
+  }
+  /**
+   * Set the force next upload flag for "Sync Now" functionality.
+   */
+  setForceNextUpload(force) {
+    this._forceNextUpload = force;
+    this.logger.debug("[StatusTracker] Force next upload set to:", force);
+  }
+  /**
+   * Clear the force next upload flag.
+   * Should be called after all pending uploads have been processed.
+   */
+  clearForceNextUpload() {
+    if (this._forceNextUpload) {
+      this._forceNextUpload = false;
+      this.logger.debug("[StatusTracker] Force next upload flag cleared");
+    }
+  }
+  /**
+   * Check if upload should proceed, considering force flag.
+   * 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.
+   */
+  shouldUpload() {
+    if (this._forceNextUpload) {
+      return true;
+    }
+    return this._state.syncMode === "push-pull";
+  }
+  /**
+   * Get pending mutations.
+   */
+  getPendingMutations() {
+    return this._pendingMutations;
+  }
+  /**
+   * Get pending mutation count.
+   */
+  getPendingCount() {
+    return this._pendingMutations.length;
+  }
+  // ─── Status Updates ────────────────────────────────────────────────────────
+  /**
+   * Handle a raw status update from PowerSync.
+   */
+  handleStatusChange(rawStatus) {
+    const progress = rawStatus.downloadProgress;
+    const dataFlow = rawStatus.dataFlowStatus;
+    let downloadProgress = null;
+    if (progress && progress.totalOperations && progress.totalOperations > 0) {
+      downloadProgress = {
+        current: progress.downloadedOperations ?? 0,
+        target: progress.totalOperations,
+        percentage: Math.round((progress.downloadedFraction ?? 0) * 100)
+      };
+      this._lastProgress = downloadProgress;
+    }
+    const newStatus = {
+      connected: rawStatus.connected ?? false,
+      connecting: rawStatus.connecting ?? false,
+      hasSynced: rawStatus.hasSynced ?? false,
+      lastSyncedAt: rawStatus.lastSyncedAt ?? null,
+      uploading: dataFlow?.uploading ?? false,
+      downloading: dataFlow?.downloading ?? false,
+      downloadProgress,
+      // These are computed from _failedTransactions in getStatus()
+      failedTransactions: [],
+      hasUploadErrors: false,
+      permanentErrorCount: 0
+    };
+    const changed = this._hasStatusChanged(newStatus);
+    this._state = {
+      status: newStatus,
+      syncMode: this._state.syncMode,
+      lastUpdated: /* @__PURE__ */ new Date()
+    };
+    if (changed) {
+      this._notifyListeners();
+    }
+  }
+  /**
+   * Update pending mutations from a CRUD transaction.
+   */
+  updatePendingMutations(mutations) {
+    this._pendingMutations = mutations;
+  }
+  /**
+   * Valid sync modes for runtime validation.
+   */
+  static VALID_SYNC_MODES = ["push-pull", "pull-only", "offline"];
+  /**
+   * Set the sync mode.
+   */
+  async setSyncMode(mode) {
+    if (!_SyncStatusTracker.VALID_SYNC_MODES.includes(mode)) {
+      this.logger.warn("[StatusTracker] Invalid sync mode, ignoring:", mode);
+      return;
+    }
+    if (this._state.syncMode === mode) return;
+    const previousMode = this._state.syncMode;
+    this._state.syncMode = mode;
+    try {
+      await this.storage.setItem(STORAGE_KEY_SYNC_MODE, mode);
+      this.logger.info("[StatusTracker] Sync mode changed:", previousMode, "->", mode);
+    } catch (err) {
+      this.logger.warn("[StatusTracker] Failed to persist sync mode:", err);
+    }
+    for (const listener of this._syncModeListeners) {
+      try {
+        listener(mode);
+      } catch (err) {
+        this.logger.warn("[StatusTracker] Sync mode listener error:", err);
+      }
+    }
+    this._notifyListeners(true);
+  }
+  /**
+   * Set paused state.
+   * @deprecated Use setSyncMode() instead
+   */
+  async setPaused(paused) {
+    await this.setSyncMode(paused ? "offline" : "push-pull");
+  }
+  // ─── Subscriptions ─────────────────────────────────────────────────────────
+  /**
+   * Subscribe to status changes.
+   * @returns Unsubscribe function
+   */
+  onStatusUpdate(listener) {
+    this._listeners.add(listener);
+    listener(this.getStatus());
+    return () => {
+      this._listeners.delete(listener);
+    };
+  }
+  /**
+   * Subscribe to sync mode changes.
+   * @returns Unsubscribe function
+   */
+  onSyncModeChange(listener) {
+    this._syncModeListeners.add(listener);
+    listener(this._state.syncMode);
+    return () => {
+      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.
+   */
+  recordTransactionFailure(entries, error, isPermanent, affectedEntityIds, affectedTables) {
+    const now = /* @__PURE__ */ new Date();
+    const entryIds = entries.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;
+    });
+    if (existingIndex !== -1) {
+      const existing = this._failedTransactions[existingIndex];
+      this._failedTransactions[existingIndex] = {
+        ...existing,
+        error,
+        retryCount: existing.retryCount + 1,
+        lastFailedAt: now,
+        isPermanent
+      };
+    } else {
+      const newFailure = {
+        id: generateFailureId(entries),
+        entries,
+        error,
+        retryCount: 1,
+        firstFailedAt: now,
+        lastFailedAt: now,
+        isPermanent,
+        affectedEntityIds,
+        affectedTables
+      };
+      this._failedTransactions.push(newFailure);
+      if (this._failedTransactions.length > this._maxStoredFailures) {
+        this._failedTransactions.sort(
+          (a, b) => a.firstFailedAt.getTime() - b.firstFailedAt.getTime()
+        );
+        this._failedTransactions = this._failedTransactions.slice(-this._maxStoredFailures);
+      }
+    }
+    this._notifyFailureListeners();
+    this._notifyListeners();
+  }
+  /**
+   * Clear a specific failure by ID.
+   */
+  clearFailure(failureId) {
+    const initialLength = this._failedTransactions.length;
+    this._failedTransactions = this._failedTransactions.filter((f) => f.id !== failureId);
+    if (this._failedTransactions.length !== initialLength) {
+      this._notifyFailureListeners();
+      this._notifyListeners();
+    }
+  }
+  /**
+   * Clear all failures.
+   */
+  clearAllFailures() {
+    if (this._failedTransactions.length === 0) return;
+    this._failedTransactions = [];
+    this._notifyFailureListeners();
+    this._notifyListeners();
+  }
+  /**
+   * Get failures affecting a specific entity.
+   */
+  getFailuresForEntity(entityId) {
+    return this._failedTransactions.filter(
+      (f) => f.affectedEntityIds.includes(entityId)
+    );
+  }
+  /**
+   * Get all failed transactions.
+   */
+  getFailedTransactions() {
+    return [...this._failedTransactions];
+  }
+  /**
+   * Check if there are any upload errors.
+   */
+  hasUploadErrors() {
+    return this._failedTransactions.length > 0;
+  }
+  /**
+   * Get count of permanent errors.
+   */
+  getPermanentErrorCount() {
+    return this._failedTransactions.filter((f) => f.isPermanent).length;
+  }
+  /**
+   * Subscribe to failure changes.
+   * @returns Unsubscribe function
+   */
+  onFailureChange(listener) {
+    this._failureListeners.add(listener);
+    listener(this.getFailedTransactions());
+    return () => {
+      this._failureListeners.delete(listener);
+    };
+  }
+  /**
+   * Clean up stale failures (older than TTL).
+   */
+  cleanupStaleFailures() {
+    const cutoff = Date.now() - this._failureTTLMs;
+    const initialLength = this._failedTransactions.length;
+    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._notifyFailureListeners();
+      this._notifyListeners();
+    }
+  }
+  // ─── Completed Transaction Tracking ────────────────────────────────────────
+  /**
+   * Record a successfully completed transaction.
+   * 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 id = `completed_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+    const completed = {
+      id,
+      entries,
+      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._notifyCompletedListeners();
+    this.logger.debug(
+      `[StatusTracker] Recorded completed transaction: ${completed.id} (${entries.length} entries)`
+    );
+  }
+  /**
+   * Get all completed transactions.
+   */
+  getCompletedTransactions() {
+    return [...this._completedTransactions];
+  }
+  /**
+   * Clear completed transaction history.
+   */
+  clearCompletedHistory() {
+    if (this._completedTransactions.length === 0) return;
+    this._completedTransactions = [];
+    this._notifyCompletedListeners();
+    this.logger.debug("[StatusTracker] Cleared completed transaction history");
+  }
+  /**
+   * Subscribe to completed transaction changes.
+   * @returns Unsubscribe function
+   */
+  onCompletedChange(listener) {
+    this._completedListeners.add(listener);
+    listener(this.getCompletedTransactions());
+    return () => {
+      this._completedListeners.delete(listener);
+    };
+  }
+  // ─── Private Methods ───────────────────────────────────────────────────────
+  _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;
+  }
+  _notifyListeners(forceImmediate = false) {
+    const now = Date.now();
+    const timeSinceLastNotify = now - this._lastNotifyTime;
+    if (this._notifyTimer) {
+      clearTimeout(this._notifyTimer);
+      this._notifyTimer = null;
+    }
+    const notify = () => {
+      this._lastNotifyTime = Date.now();
+      const status = this.getStatus();
+      this.onStatusChange?.(status);
+      for (const listener of this._listeners) {
+        try {
+          listener(status);
+        } catch (err) {
+          this.logger.warn("[StatusTracker] Listener error:", err);
+        }
+      }
+    };
+    if (forceImmediate || timeSinceLastNotify >= this.notifyThrottleMs) {
+      notify();
+    } else {
+      const delay = this.notifyThrottleMs - timeSinceLastNotify;
+      this._notifyTimer = setTimeout(notify, delay);
+    }
+  }
+  _notifyFailureListeners() {
+    const failures = this.getFailedTransactions();
+    for (const listener of this._failureListeners) {
+      try {
+        listener(failures);
+      } catch (err) {
+        this.logger.warn("[StatusTracker] Failure listener error:", err);
+      }
+    }
+  }
+  _notifyCompletedListeners() {
+    const completed = this.getCompletedTransactions();
+    for (const listener of this._completedListeners) {
+      try {
+        listener(completed);
+      } catch (err) {
+        this.logger.warn("[StatusTracker] Completed listener error:", err);
+      }
+    }
+  }
+};
+
+// src/sync/metrics-collector.ts
+var MetricsCollector = class {
+  storage;
+  logger;
+  storageKey;
+  persistMetrics;
+  onMetricsChange;
+  _metrics;
+  _listeners = /* @__PURE__ */ new Set();
+  _initialized = false;
+  // Track active sync for timing
+  _syncStartTime = null;
+  _wasSyncing = false;
+  constructor(storage, logger, options = {}) {
+    this.storage = storage;
+    this.logger = logger;
+    this.storageKey = options.storageKey ?? STORAGE_KEY_METRICS;
+    this.persistMetrics = options.persistMetrics ?? true;
+    this.onMetricsChange = options.onMetricsChange;
+    this._metrics = { ...DEFAULT_SYNC_METRICS };
+  }
+  // ─── Initialization ────────────────────────────────────────────────────────
+  /**
+   * Initialize the collector by loading persisted metrics.
+   */
+  async init() {
+    if (this._initialized) return;
+    try {
+      const stored = await this.storage.getItem(this.storageKey);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        if (parsed.lastError?.timestamp) {
+          parsed.lastError.timestamp = new Date(parsed.lastError.timestamp);
+        }
+        this._metrics = { ...DEFAULT_SYNC_METRICS, ...parsed };
+        this.logger.debug("[MetricsCollector] Loaded persisted metrics");
+      }
+    } catch (err) {
+      this.logger.warn("[MetricsCollector] Failed to load metrics:", err);
+    }
+    this._initialized = true;
+  }
+  /**
+   * Dispose the collector.
+   */
+  dispose() {
+    this._listeners.clear();
+  }
+  // ─── Getters ───────────────────────────────────────────────────────────────
+  /**
+   * Get current sync metrics.
+   */
+  getMetrics() {
+    return { ...this._metrics };
+  }
+  // ─── Recording ─────────────────────────────────────────────────────────────
+  /**
+   * Record a completed sync operation.
+   */
+  async recordSync(data) {
+    const { durationMs, success, operationsDownloaded, operationsUploaded, error } = data;
+    const totalSyncs = this._metrics.totalSyncs + 1;
+    const successfulSyncs = this._metrics.successfulSyncs + (success ? 1 : 0);
+    const failedSyncs = this._metrics.failedSyncs + (success ? 0 : 1);
+    let averageSyncDuration = this._metrics.averageSyncDuration;
+    if (success) {
+      if (averageSyncDuration !== null) {
+        averageSyncDuration = (averageSyncDuration * (successfulSyncs - 1) + durationMs) / successfulSyncs;
+      } else {
+        averageSyncDuration = durationMs;
+      }
+    }
+    const bytesPerOp = 100;
+    const downloaded = (operationsDownloaded ?? 0) * bytesPerOp;
+    const uploaded = (operationsUploaded ?? 0) * bytesPerOp;
+    let lastError = this._metrics.lastError;
+    if (!success && error) {
+      const errorType = classifyError(error);
+      lastError = {
+        type: errorType,
+        message: error.message,
+        userMessage: error.message,
+        // Use original message as user message for metrics
+        timestamp: /* @__PURE__ */ new Date(),
+        isPermanent: false
+      };
+    }
+    this._metrics = {
+      totalSyncs,
+      successfulSyncs,
+      failedSyncs,
+      lastSyncDuration: durationMs,
+      averageSyncDuration: averageSyncDuration !== null ? Math.round(averageSyncDuration) : null,
+      totalDataDownloaded: this._metrics.totalDataDownloaded + downloaded,
+      totalDataUploaded: this._metrics.totalDataUploaded + uploaded,
+      lastError
+    };
+    await this._persist();
+    this._notifyListeners();
+  }
+  /**
+   * Record a sync error without a full sync operation.
+   */
+  async recordError(error) {
+    this._metrics = {
+      ...this._metrics,
+      failedSyncs: this._metrics.failedSyncs + 1,
+      lastError: {
+        type: classifyError(error),
+        message: error.message,
+        userMessage: error.message,
+        // Use original message as user message for metrics
+        timestamp: /* @__PURE__ */ new Date(),
+        isPermanent: false
+      }
+    };
+    await this._persist();
+    this._notifyListeners();
+  }
+  /**
+   * Record an upload operation.
+   */
+  async recordUpload(operationCount) {
+    const bytesPerOp = 100;
+    this._metrics = {
+      ...this._metrics,
+      totalDataUploaded: this._metrics.totalDataUploaded + operationCount * bytesPerOp
+    };
+    await this._persist();
+    this._notifyListeners();
+  }
+  /**
+   * Clear all metrics and start fresh.
+   */
+  async reset() {
+    this._metrics = { ...DEFAULT_SYNC_METRICS };
+    await this._persist();
+    this._notifyListeners();
+  }
+  // ─── Sync Timing Helpers ───────────────────────────────────────────────────
+  /**
+   * Called when sync starts (downloading becomes true).
+   */
+  markSyncStart() {
+    if (!this._wasSyncing) {
+      this._syncStartTime = Date.now();
+      this._wasSyncing = true;
+    }
+  }
+  /**
+   * Called when sync ends (downloading becomes false).
+   * Returns the duration if a sync was in progress.
+   */
+  markSyncEnd() {
+    if (this._wasSyncing && this._syncStartTime !== null) {
+      const duration = Date.now() - this._syncStartTime;
+      this._syncStartTime = null;
+      this._wasSyncing = false;
+      return duration;
+    }
+    return null;
+  }
+  /**
+   * Check if sync is currently in progress.
+   */
+  isSyncInProgress() {
+    return this._wasSyncing;
+  }
+  // ─── Subscriptions ─────────────────────────────────────────────────────────
+  /**
+   * Subscribe to metrics changes.
+   * @returns Unsubscribe function
+   */
+  onMetricsUpdate(listener) {
+    this._listeners.add(listener);
+    listener(this.getMetrics());
+    return () => {
+      this._listeners.delete(listener);
+    };
+  }
+  // ─── Private Methods ───────────────────────────────────────────────────────
+  async _persist() {
+    if (!this.persistMetrics) return;
+    try {
+      await this.storage.setItem(this.storageKey, JSON.stringify(this._metrics));
+    } catch (err) {
+      this.logger.warn("[MetricsCollector] Failed to persist metrics:", err);
+    }
+  }
+  _notifyListeners() {
+    const metrics = this.getMetrics();
+    this.onMetricsChange?.(metrics);
+    for (const listener of this._listeners) {
+      try {
+        listener(metrics);
+      } catch (err) {
+        this.logger.warn("[MetricsCollector] Listener error:", err);
+      }
+    }
+  }
+};
+
+// src/sync/health-monitor.ts
+var HealthMonitor = class {
+  logger;
+  checkIntervalMs;
+  checkTimeoutMs;
+  degradedThresholdMs;
+  maxConsecutiveFailures;
+  onHealthChange;
+  _db = null;
+  _health;
+  _intervalId = null;
+  _listeners = /* @__PURE__ */ new Set();
+  _running = false;
+  _paused = false;
+  constructor(logger, options = {}) {
+    this.logger = logger;
+    this.checkIntervalMs = options.checkIntervalMs ?? HEALTH_CHECK_INTERVAL_MS;
+    this.checkTimeoutMs = options.checkTimeoutMs ?? HEALTH_CHECK_TIMEOUT_MS;
+    this.degradedThresholdMs = options.degradedThresholdMs ?? LATENCY_DEGRADED_THRESHOLD_MS;
+    this.maxConsecutiveFailures = options.maxConsecutiveFailures ?? MAX_CONSECUTIVE_FAILURES;
+    this.onHealthChange = options.onHealthChange;
+    this._health = { ...DEFAULT_CONNECTION_HEALTH };
+  }
+  // ─── Lifecycle ─────────────────────────────────────────────────────────────
+  /**
+   * Set the database instance to monitor.
+   */
+  setDatabase(db) {
+    this._db = db;
+    if (!db) {
+      this._updateHealth({
+        status: "disconnected",
+        latency: null,
+        lastHealthCheck: /* @__PURE__ */ new Date(),
+        consecutiveFailures: 0,
+        reconnectAttempts: this._health.reconnectAttempts
+      });
+    }
+  }
+  /**
+   * Start the health monitor.
+   */
+  start() {
+    if (this._running) return;
+    this.logger.info("[HealthMonitor] Starting");
+    this._running = true;
+    this._checkHealth();
+    this._intervalId = setInterval(() => {
+      if (!this._paused) {
+        this._checkHealth();
+      }
+    }, this.checkIntervalMs);
+  }
+  /**
+   * Stop the health monitor.
+   */
+  stop() {
+    if (!this._running) return;
+    this.logger.info("[HealthMonitor] Stopping");
+    this._running = false;
+    if (this._intervalId) {
+      clearInterval(this._intervalId);
+      this._intervalId = null;
+    }
+  }
+  /**
+   * Pause health checks temporarily.
+   */
+  pause() {
+    this._paused = true;
+    this._updateHealth({
+      ...this._health,
+      status: "disconnected"
+    });
+  }
+  /**
+   * Resume health checks.
+   */
+  resume() {
+    this._paused = false;
+    this._checkHealth();
+  }
+  /**
+   * Dispose the monitor and clear all resources.
+   */
+  dispose() {
+    this.stop();
+    this._listeners.clear();
+  }
+  // ─── Getters ───────────────────────────────────────────────────────────────
+  /**
+   * Get current connection health.
+   */
+  getHealth() {
+    return { ...this._health };
+  }
+  /**
+   * Check if the monitor is running.
+   */
+  isRunning() {
+    return this._running;
+  }
+  // ─── Manual Checks ─────────────────────────────────────────────────────────
+  /**
+   * Perform an immediate health check.
+   * @returns The result of the health check
+   */
+  async checkNow() {
+    return this._checkHealth();
+  }
+  /**
+   * Record a reconnection attempt.
+   */
+  recordReconnectAttempt() {
+    this._updateHealth({
+      ...this._health,
+      reconnectAttempts: this._health.reconnectAttempts + 1
+    });
+  }
+  /**
+   * Reset reconnection attempts counter (call on successful connection).
+   */
+  resetReconnectAttempts() {
+    if (this._health.reconnectAttempts > 0) {
+      this._updateHealth({
+        ...this._health,
+        reconnectAttempts: 0
+      });
+    }
+  }
+  // ─── Subscriptions ─────────────────────────────────────────────────────────
+  /**
+   * Subscribe to health changes.
+   * @returns Unsubscribe function
+   */
+  onHealthUpdate(listener) {
+    this._listeners.add(listener);
+    listener(this.getHealth());
+    return () => {
+      this._listeners.delete(listener);
+    };
+  }
+  // ─── Private Methods ───────────────────────────────────────────────────────
+  async _checkHealth() {
+    if (!this._db || this._paused) {
+      return {
+        success: false,
+        error: new Error("Database not available or paused"),
+        timestamp: /* @__PURE__ */ new Date()
+      };
+    }
+    const startTime = Date.now();
+    const timestamp = /* @__PURE__ */ new Date();
+    try {
+      await this._withTimeout(
+        this._db.get("SELECT 1"),
+        this.checkTimeoutMs
+      );
+      const latencyMs = Date.now() - startTime;
+      const status = latencyMs < this.degradedThresholdMs ? "healthy" : "degraded";
+      this._updateHealth({
+        status,
+        latency: latencyMs,
+        lastHealthCheck: timestamp,
+        consecutiveFailures: 0,
+        reconnectAttempts: this._health.reconnectAttempts
+      });
+      return {
+        success: true,
+        latencyMs,
+        timestamp
+      };
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.logger.warn("[HealthMonitor] Health check failed:", error.message);
+      const consecutiveFailures = this._health.consecutiveFailures + 1;
+      const status = consecutiveFailures >= this.maxConsecutiveFailures ? "disconnected" : "degraded";
+      this._updateHealth({
+        status,
+        latency: null,
+        lastHealthCheck: timestamp,
+        consecutiveFailures,
+        reconnectAttempts: this._health.reconnectAttempts
+      });
+      return {
+        success: false,
+        error,
+        timestamp
+      };
+    }
+  }
+  _updateHealth(health) {
+    const changed = this._hasHealthChanged(health);
+    this._health = health;
+    if (changed) {
+      this._notifyListeners();
+    }
+  }
+  _hasHealthChanged(newHealth) {
+    const old = this._health;
+    return old.status !== newHealth.status || old.latency !== newHealth.latency || old.consecutiveFailures !== newHealth.consecutiveFailures || old.reconnectAttempts !== newHealth.reconnectAttempts;
+  }
+  _notifyListeners() {
+    const health = this.getHealth();
+    this.onHealthChange?.(health);
+    for (const listener of this._listeners) {
+      try {
+        listener(health);
+      } catch (err) {
+        this.logger.warn("[HealthMonitor] Listener error:", err);
+      }
+    }
+  }
+  _withTimeout(promise, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`Health check timeout after ${timeoutMs}ms`));
+      }, timeoutMs);
+      promise.then(
+        (result) => {
+          clearTimeout(timer);
+          resolve(result);
+        },
+        (error) => {
+          clearTimeout(timer);
+          reject(error);
+        }
+      );
+    });
+  }
+};
+
+export {
+  DEFAULT_SYNC_STATUS,
+  DEFAULT_CONNECTION_HEALTH,
+  DEFAULT_SYNC_METRICS,
+  DEFAULT_SYNC_CONFIG,
+  SyncStatusTracker,
+  MetricsCollector,
+  HealthMonitor
+};
+//# sourceMappingURL=chunk-CFCK2LHI.js.map