@pol-studios/powersync 1.0.25 → 1.0.32

package/dist/{chunk-55DKCJV4.js → chunk-2RDWLXJW.js}

@@ -1,8 +1,6 @@
 import {
-  DEFAULT_CONNECTION_HEALTH,
-  DEFAULT_SYNC_METRICS,
-  DEFAULT_SYNC_STATUS
-} from "./chunk-24RDMMCL.js";
+  LOCAL_TABLE_NAMES
+} from "./chunk-OGUFUZSY.js";
 import {
   HEALTH_CHECK_INTERVAL_MS,
   HEALTH_CHECK_TIMEOUT_MS,
@@ -19,15 +17,52 @@ import {
   generateFailureId
 } from "./chunk-I2AYMY5O.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 STORAGE_KEY_COMPLETED_TRANSACTIONS = "@pol-powersync:completed_transactions";
-var STORAGE_KEY_FAILED_TRANSACTIONS = "@pol-powersync:failed_transactions";
 var MAX_COMPLETED_TRANSACTIONS = 1e3;
 var SyncStatusTracker = class _SyncStatusTracker {
   storage;
   logger;
   notifyThrottleMs;
   onStatusChange;
+  // PowerSync database for local-only table persistence
+  _db = null;
   _state;
   _pendingMutations = [];
   _lastNotifyTime = 0;
@@ -73,10 +108,89 @@ var SyncStatusTracker = class _SyncStatusTracker {
       lastUpdated: /* @__PURE__ */ new Date()
     };
   }
+  // ─── Database Setup ─────────────────────────────────────────────────────────
+  // Flag to prevent operations during initialization
+  _dbInitializing = false;
+  _dbReady = false;
+  // Track persistence errors for degraded mode detection
+  _persistenceErrorCount = 0;
+  _maxPersistenceErrors = 5;
+  /**
+   * Set the PowerSync database instance AND initialize transactions atomically.
+   * This prevents race conditions between setDatabase() and initTransactions().
+   *
+   * @param db - The PowerSync database instance
+   * @returns Promise that resolves when initialization is complete
+   */
+  async setDatabaseAndInit(db) {
+    if (this._dbInitializing) {
+      this.logger.warn("[StatusTracker] Database initialization already in progress");
+      return;
+    }
+    this._dbInitializing = true;
+    this._dbReady = false;
+    this._db = db;
+    this.logger.debug("[StatusTracker] Database set, initializing transactions...");
+    try {
+      await this.initTransactions();
+      this._dbReady = true;
+      this.logger.debug("[StatusTracker] Database ready for local-only table persistence");
+    } finally {
+      this._dbInitializing = false;
+    }
+  }
+  /**
+   * Set the PowerSync database instance for local-only table persistence.
+   * @deprecated Use setDatabaseAndInit() instead to avoid race conditions.
+   */
+  setDatabase(db) {
+    this._db = db;
+    this.logger.debug("[StatusTracker] Database set for local-only table persistence");
+  }
+  /**
+   * Get the PowerSync database instance.
+   */
+  getDatabase() {
+    return this._db;
+  }
+  /**
+   * Check if the database is ready for persistence operations.
+   */
+  isDatabaseReady() {
+    return this._dbReady && this._db !== null;
+  }
+  /**
+   * Check if persistence is in a degraded state (too many errors).
+   */
+  isPersistenceDegraded() {
+    return this._persistenceErrorCount >= this._maxPersistenceErrors;
+  }
+  /**
+   * Track a persistence error and log if we enter degraded mode.
+   */
+  _trackPersistenceError(operation, error) {
+    this._persistenceErrorCount++;
+    this.logger.warn(`[StatusTracker] Persistence error (${this._persistenceErrorCount}/${this._maxPersistenceErrors}):`, operation, error);
+    if (this._persistenceErrorCount === this._maxPersistenceErrors) {
+      this.logger.error("[StatusTracker] Persistence degraded - too many errors. Transaction history may not persist.");
+    }
+  }
+  /**
+   * Reset persistence error count (e.g., after successful operation).
+   */
+  _resetPersistenceErrors() {
+    if (this._persistenceErrorCount > 0) {
+      this._persistenceErrorCount = 0;
+      this.logger.debug("[StatusTracker] Persistence recovered");
+    }
+  }
   // ─── Initialization ────────────────────────────────────────────────────────
   /**
    * Initialize the tracker by loading persisted state.
    * Includes migration from old isPaused boolean to new syncMode.
+   *
+   * Note: Transaction data is loaded from SQLite after the database is set.
+   * Call initTransactions() after setDatabase() to load transaction history.
    */
   async init() {
     try {
@@ -105,46 +219,81 @@ var SyncStatusTracker = class _SyncStatusTracker {
     } catch (err) {
       this.logger.warn("[StatusTracker] Failed to load auto-offline flag:", err);
     }
+  }
+  /**
+   * Initialize transactions from SQLite local-only tables.
+   * Must be called after setDatabase() has been called.
+   */
+  async initTransactions() {
+    if (!this._db) {
+      this.logger.warn("[StatusTracker] Cannot init transactions: database not set");
+      return;
+    }
+    await this._loadCompletedTransactionsFromDb();
+    await this._loadFailedTransactionsFromDb();
+    this.cleanupStaleFailures();
+  }
+  /**
+   * Load completed transactions from SQLite local-only table.
+   */
+  async _loadCompletedTransactionsFromDb() {
+    if (!this._db) return;
     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");
-      }
+      const rows = await this._db.getAll(`SELECT * FROM ${LOCAL_TABLE_NAMES.COMPLETED_TRANSACTIONS} ORDER BY completedAt DESC LIMIT ?`, [MAX_COMPLETED_TRANSACTIONS]);
+      this._completedTransactions = rows.map((row) => {
+        const entries = JSON.parse(row.entries);
+        const remappedEntries = entries.map((e) => this.remapEntry(e)).filter((e) => e !== null);
+        return {
+          id: row.id,
+          entries: remappedEntries,
+          affectedEntityIds: JSON.parse(row.affectedEntityIds),
+          affectedTables: JSON.parse(row.affectedTables),
+          completedAt: new Date(row.completedAt)
+        };
+      }).filter((item) => !isNaN(item.completedAt.getTime()) && item.entries.length > 0);
+      this._resetPersistenceErrors();
+      this.logger.debug("[StatusTracker] Loaded", this._completedTransactions.length, "completed transactions from SQLite");
     } catch (err) {
-      this.logger.warn("[StatusTracker] Failed to load completed transactions:", err);
+      this._trackPersistenceError("loadCompletedTransactions", err);
+      this.logger.warn("[StatusTracker] Failed to load completed transactions from SQLite:", err);
     }
+  }
+  /**
+   * Load failed transactions from SQLite local-only table.
+   */
+  async _loadFailedTransactionsFromDb() {
+    if (!this._db) return;
     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");
-      }
+      const rows = await this._db.getAll(`SELECT * FROM ${LOCAL_TABLE_NAMES.FAILED_TRANSACTIONS} ORDER BY lastFailedAt DESC`);
+      this._failedTransactions = rows.map((row) => {
+        const entries = JSON.parse(row.entries);
+        const remappedEntries = entries.map((e) => this.remapEntry(e)).filter((e) => e !== null);
+        const error = {
+          type: row.errorType,
+          message: row.errorMessage,
+          userMessage: row.errorUserMessage,
+          timestamp: new Date(row.errorTimestamp),
+          isPermanent: row.errorIsPermanent === 1,
+          pgCode: row.errorPgCode ?? void 0
+        };
+        return {
+          id: row.id,
+          entries: remappedEntries,
+          error,
+          affectedEntityIds: JSON.parse(row.affectedEntityIds),
+          affectedTables: JSON.parse(row.affectedTables),
+          retryCount: row.retryCount,
+          isPermanent: row.isPermanent === 1,
+          firstFailedAt: new Date(row.firstFailedAt),
+          lastFailedAt: new Date(row.lastFailedAt)
+        };
+      }).filter((item) => !isNaN(item.firstFailedAt.getTime()) && !isNaN(item.lastFailedAt.getTime()) && item.entries.length > 0);
+      this._resetPersistenceErrors();
+      this.logger.debug("[StatusTracker] Loaded", this._failedTransactions.length, "failed transactions from SQLite");
     } catch (err) {
-      this.logger.warn("[StatusTracker] Failed to load failed transactions:", err);
+      this._trackPersistenceError("loadFailedTransactions", err);
+      this.logger.warn("[StatusTracker] Failed to load failed transactions from SQLite:", err);
     }
-    this.cleanupStaleFailures();
   }
   /**
    * Dispose the tracker and clear timers.
@@ -194,6 +343,73 @@ var SyncStatusTracker = class _SyncStatusTracker {
   getSyncMode() {
     return this._state.syncMode;
   }
+  /**
+   * Get the reason why uploads are currently blocked.
+   * Returns 'none' if uploads are ready to proceed.
+   *
+   * Priority order (first match wins):
+   * 1. offline_mode - User explicitly chose offline mode
+   * 2. auto_offline - System went offline automatically (network loss with auto-offline flag)
+   * 3. pull_only_mode - Pull-only mode active
+   * 4. network_unreachable - No internet connection
+   * 5. disconnected - PowerSync not connected
+   * 6. connecting - PowerSync is connecting
+   * 7. uploading - Actively uploading
+   * 8. none - Ready to sync
+   */
+  getUploadBlockReason() {
+    const status = this._state.status;
+    const syncMode = this._state.syncMode;
+    if (syncMode === "offline") {
+      if (this._isAutoOffline) {
+        return "auto_offline";
+      }
+      return "offline_mode";
+    }
+    if (syncMode === "pull-only") {
+      return "pull_only_mode";
+    }
+    if (!this._networkReachable) {
+      return "network_unreachable";
+    }
+    if (!status.connected && !status.connecting) {
+      return "disconnected";
+    }
+    if (status.connecting) {
+      return "connecting";
+    }
+    if (status.uploading) {
+      return "uploading";
+    }
+    return "none";
+  }
+  /**
+   * Get a human-readable description of why uploads are blocked.
+   * Returns null if uploads are not blocked.
+   */
+  getUploadBlockDescription() {
+    const reason = this.getUploadBlockReason();
+    switch (reason) {
+      case "offline_mode":
+        return "Offline mode is enabled";
+      case "auto_offline":
+        return "Went offline due to network loss";
+      case "pull_only_mode":
+        return "Pull-only mode is active";
+      case "network_unreachable":
+        return "No internet connection";
+      case "disconnected":
+        return "Not connected to sync service";
+      case "connecting":
+        return "Connecting to sync service";
+      case "uploading":
+        return "Upload in progress";
+      case "none":
+        return null;
+      default:
+        return null;
+    }
+  }
   /**
    * Check if uploads are allowed based on current sync mode and network reachability.
    */
@@ -418,34 +634,42 @@ var SyncStatusTracker = class _SyncStatusTracker {
       const existingIds = f.entries.map((e) => e.id).sort().join(",");
       return existingIds === entryIds;
     });
+    let failedTransaction;
     if (existingIndex !== -1) {
       const existing = this._failedTransactions[existingIndex];
-      this._failedTransactions[existingIndex] = {
+      const newRetryCount = existing.retryCount + 1;
+      failedTransaction = {
         ...existing,
         error,
-        retryCount: existing.retryCount + 1,
+        retryCount: newRetryCount,
         lastFailedAt: now,
         isPermanent
       };
+      this._failedTransactions[existingIndex] = failedTransaction;
     } else {
-      const newFailure = {
+      const retryCount = preserveMetadata?.retryCount ?? 1;
+      failedTransaction = {
         id: generateFailureId(normalizedEntries),
         entries: normalizedEntries,
         error,
-        retryCount: preserveMetadata?.retryCount ?? 1,
+        retryCount,
         firstFailedAt: preserveMetadata?.firstFailedAt ?? now,
         lastFailedAt: now,
         isPermanent,
         affectedEntityIds,
         affectedTables
       };
-      this._failedTransactions.push(newFailure);
+      this._failedTransactions.push(failedTransaction);
       if (this._failedTransactions.length > this._maxStoredFailures) {
         this._failedTransactions.sort((a, b) => a.firstFailedAt.getTime() - b.firstFailedAt.getTime());
+        const removed = this._failedTransactions.slice(0, this._failedTransactions.length - this._maxStoredFailures);
         this._failedTransactions = this._failedTransactions.slice(-this._maxStoredFailures);
+        for (const r of removed) {
+          void this._deleteFailedTransaction(r.id);
+        }
       }
     }
-    this._schedulePersist();
+    void this._insertFailedTransaction(failedTransaction);
     this._notifyFailureListeners();
     this._notifyListeners();
   }
@@ -456,20 +680,40 @@ 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();
+      void this._deleteFailedTransaction(failureId);
       this._notifyFailureListeners();
       this._notifyListeners();
     }
   }
   /**
-   * Clear all failures.
-   */
-  clearAllFailures() {
-    if (this._failedTransactions.length === 0) return;
-    this._failedTransactions = [];
-    this._schedulePersist();
-    this._notifyFailureListeners();
-    this._notifyListeners();
+   * Clear failures for successfully synced entries.
+   * Removes any failed transaction that contains entries with the given IDs.
+   *
+   * This is called when `onTransactionSuccess` fires - if any entry in a failed
+   * transaction has now succeeded, we remove that entire failure record.
+   *
+   * @param entryIds - Array of CrudEntry.id values that succeeded
+   */
+  clearSuccessfulEntries(entryIds) {
+    if (entryIds.length === 0 || this._failedTransactions.length === 0) return;
+    const entryIdSet = new Set(entryIds);
+    const removedIds = [];
+    this._failedTransactions = this._failedTransactions.filter((failure) => {
+      const hasSuccessfulEntry = failure.entries.some((entry) => entryIdSet.has(entry.id));
+      if (hasSuccessfulEntry) {
+        removedIds.push(failure.id);
+        return false;
+      }
+      return true;
+    });
+    if (removedIds.length > 0) {
+      this.logger.debug(`[StatusTracker] Cleared ${removedIds.length} failures for successful entries`);
+      for (const id of removedIds) {
+        void this._deleteFailedTransaction(id);
+      }
+      this._notifyFailureListeners();
+      this._notifyListeners();
+    }
   }
   /**
    * Remove a failed transaction from tracking and return its entries.
@@ -488,8 +732,8 @@ var SyncStatusTracker = class _SyncStatusTracker {
       return null;
     }
     this._failedTransactions = this._failedTransactions.filter((f) => f.id !== failureId);
+    void this._deleteFailedTransaction(failureId);
     this._notifyFailureListeners();
-    this._schedulePersist();
     this.logger.info("[StatusTracker] Retrieved failure for retry:", failureId, "entries:", failure.entries.length);
     return failure.entries;
   }
@@ -533,11 +777,19 @@ var SyncStatusTracker = class _SyncStatusTracker {
    */
   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._schedulePersist();
+    const removedIds = [];
+    this._failedTransactions = this._failedTransactions.filter((f) => {
+      if (f.lastFailedAt.getTime() <= cutoff) {
+        removedIds.push(f.id);
+        return false;
+      }
+      return true;
+    });
+    if (removedIds.length > 0) {
+      this.logger.debug(`[StatusTracker] Cleaned up ${removedIds.length} stale failures`);
+      for (const id of removedIds) {
+        void this._deleteFailedTransaction(id);
+      }
       this._notifyFailureListeners();
       this._notifyListeners();
     }
@@ -563,7 +815,8 @@ var SyncStatusTracker = class _SyncStatusTracker {
     if (this._completedTransactions.length > MAX_COMPLETED_TRANSACTIONS) {
       this._completedTransactions = this._completedTransactions.slice(0, MAX_COMPLETED_TRANSACTIONS);
     }
-    this._schedulePersist();
+    void this._insertCompletedTransaction(completed);
+    void this._enforceCompletedTransactionsLimit();
     this._notifyCompletedListeners();
     this.logger.debug(`[StatusTracker] Recorded completed transaction: ${completed.id} (${entries.length} entries)`);
   }
@@ -579,7 +832,7 @@ var SyncStatusTracker = class _SyncStatusTracker {
   clearCompletedHistory() {
     if (this._completedTransactions.length === 0) return;
     this._completedTransactions = [];
-    this._schedulePersist();
+    void this._deleteAllCompletedTransactions();
     this._notifyCompletedListeners();
     this.logger.debug("[StatusTracker] Cleared completed transaction history");
   }
@@ -590,7 +843,7 @@ var SyncStatusTracker = class _SyncStatusTracker {
     const initialLength = this._completedTransactions.length;
     this._completedTransactions = this._completedTransactions.filter((c) => c.id !== completedId);
     if (this._completedTransactions.length !== initialLength) {
-      this._schedulePersist();
+      void this._deleteCompletedTransaction(completedId);
       this._notifyCompletedListeners();
       this.logger.debug("[StatusTracker] Cleared completed transaction:", completedId);
     }
@@ -631,27 +884,100 @@ var SyncStatusTracker = class _SyncStatusTracker {
     return this._lastNotificationTime;
   }
   // ─── Private Methods ───────────────────────────────────────────────────────
+  // ─── SQLite Persistence Methods ─────────────────────────────────────────────
   /**
-   * Schedule a debounced persist operation.
-   * This prevents race conditions from multiple rapid persist calls.
+   * Insert a completed transaction into SQLite.
    */
-  _schedulePersist() {
-    if (this._persistDebounceTimer) {
-      clearTimeout(this._persistDebounceTimer);
+  async _insertCompletedTransaction(transaction) {
+    if (!this._db) {
+      this.logger.warn("[StatusTracker] Cannot persist completed transaction: database not set");
+      return;
+    }
+    try {
+      await this._db.execute(`INSERT OR REPLACE INTO ${LOCAL_TABLE_NAMES.COMPLETED_TRANSACTIONS}
+         (id, entries, affectedEntityIds, affectedTables, completedAt)
+         VALUES (?, ?, ?, ?, ?)`, [transaction.id, JSON.stringify(transaction.entries), JSON.stringify(transaction.affectedEntityIds), JSON.stringify(transaction.affectedTables), transaction.completedAt.toISOString()]);
+      this._resetPersistenceErrors();
+    } catch (err) {
+      this._trackPersistenceError("insertCompletedTransaction", err);
+      this.logger.warn("[StatusTracker] Failed to insert completed transaction:", err);
+    }
+  }
+  /**
+   * Delete a completed transaction from SQLite.
+   */
+  async _deleteCompletedTransaction(id) {
+    if (!this._db) return;
+    try {
+      await this._db.execute(`DELETE FROM ${LOCAL_TABLE_NAMES.COMPLETED_TRANSACTIONS} WHERE id = ?`, [id]);
+      this._resetPersistenceErrors();
+    } catch (err) {
+      this._trackPersistenceError("deleteCompletedTransaction", err);
+      this.logger.warn("[StatusTracker] Failed to delete completed transaction:", err);
+    }
+  }
+  /**
+   * Delete all completed transactions from SQLite.
+   */
+  async _deleteAllCompletedTransactions() {
+    if (!this._db) return;
+    try {
+      await this._db.execute(`DELETE FROM ${LOCAL_TABLE_NAMES.COMPLETED_TRANSACTIONS}`);
+      this._resetPersistenceErrors();
+    } catch (err) {
+      this._trackPersistenceError("deleteAllCompletedTransactions", err);
+      this.logger.warn("[StatusTracker] Failed to delete all completed transactions:", err);
     }
-    this._persistDebounceTimer = setTimeout(() => {
-      this._persistDebounceTimer = null;
-      this._persistTransactions();
-    }, 100);
   }
   /**
-   * Persist completed and failed transactions to storage.
+   * Insert a failed transaction into SQLite.
    */
-  async _persistTransactions() {
+  async _insertFailedTransaction(transaction) {
+    if (!this._db) {
+      this.logger.warn("[StatusTracker] Cannot persist failed transaction: database not set");
+      return;
+    }
+    try {
+      await this._db.execute(`INSERT OR REPLACE INTO ${LOCAL_TABLE_NAMES.FAILED_TRANSACTIONS}
+         (id, entries, errorType, errorMessage, errorUserMessage, errorPgCode, errorTimestamp, errorIsPermanent,
+          affectedEntityIds, affectedTables, retryCount, isPermanent, firstFailedAt, lastFailedAt)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [transaction.id, JSON.stringify(transaction.entries), transaction.error.type, transaction.error.message, transaction.error.userMessage, transaction.error.pgCode ?? null, transaction.error.timestamp.toISOString(), transaction.error.isPermanent ? 1 : 0, JSON.stringify(transaction.affectedEntityIds), JSON.stringify(transaction.affectedTables), transaction.retryCount, transaction.isPermanent ? 1 : 0, transaction.firstFailedAt.toISOString(), transaction.lastFailedAt.toISOString()]);
+      this._resetPersistenceErrors();
+    } catch (err) {
+      this._trackPersistenceError("insertFailedTransaction", err);
+      this.logger.warn("[StatusTracker] Failed to insert failed transaction:", err);
+    }
+  }
+  /**
+   * Delete a failed transaction from SQLite.
+   */
+  async _deleteFailedTransaction(id) {
+    if (!this._db) return;
     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))]);
+      await this._db.execute(`DELETE FROM ${LOCAL_TABLE_NAMES.FAILED_TRANSACTIONS} WHERE id = ?`, [id]);
+      this._resetPersistenceErrors();
     } catch (err) {
-      this.logger.warn("[StatusTracker] Failed to persist transactions:", err);
+      this._trackPersistenceError("deleteFailedTransaction", err);
+      this.logger.warn("[StatusTracker] Failed to delete failed transaction:", err);
+    }
+  }
+  /**
+   * Enforce the max completed transactions limit in SQLite.
+   * Removes oldest entries beyond the limit.
+   */
+  async _enforceCompletedTransactionsLimit() {
+    if (!this._db) return;
+    try {
+      await this._db.execute(`DELETE FROM ${LOCAL_TABLE_NAMES.COMPLETED_TRANSACTIONS}
+         WHERE id NOT IN (
+           SELECT id FROM ${LOCAL_TABLE_NAMES.COMPLETED_TRANSACTIONS}
+           ORDER BY completedAt DESC
+           LIMIT ?
+         )`, [MAX_COMPLETED_TRANSACTIONS]);
+      this._resetPersistenceErrors();
+    } catch (err) {
+      this._trackPersistenceError("enforceCompletedTransactionsLimit", err);
+      this.logger.warn("[StatusTracker] Failed to enforce completed transactions limit:", err);
     }
   }
   _hasStatusChanged(newStatus) {
@@ -1237,8 +1563,12 @@ var HealthMonitor = class {
 };
 
 export {
+  DEFAULT_SYNC_STATUS,
+  DEFAULT_CONNECTION_HEALTH,
+  DEFAULT_SYNC_METRICS,
+  DEFAULT_SYNC_CONFIG,
   SyncStatusTracker,
   MetricsCollector,
   HealthMonitor
 };
-//# sourceMappingURL=chunk-55DKCJV4.js.map
+//# sourceMappingURL=chunk-2RDWLXJW.js.map