refactor: simplify restoration transaction cleanup

- Consolidate restorationTransactions.delete() to single point
- Improve comments on restoration transaction purpose

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: KyleAMathews

packages/offline-transactions/src/OfflineExecutor.ts

@@ -486,35 +486,37 @@ export class OfflineExecutor {
     )
   }
 
-  // Clean up restoration transaction when offline transaction completes or fails
   private cleanupRestorationTransaction(
     transactionId: string,
-    shouldRollback: boolean = false,
+    shouldRollback = false,
   ): void {
     const restorationTx = this.restorationTransactions.get(transactionId)
-    if (!restorationTx) return
+    if (!restorationTx) {
+      return
+    }
+
+    this.restorationTransactions.delete(transactionId)
 
     if (shouldRollback) {
-      // Rollback the restoration transaction to remove optimistic state
       restorationTx.rollback()
-    } else {
-      // Mark as completed so recomputeOptimisticState removes it from consideration
-      // The actual data will come from the sync
-      restorationTx.setState(`completed`)
-
-      // Manually remove from each collection's transaction map and recompute
-      const touchedCollections = new Set<string>()
-      for (const mutation of restorationTx.mutations) {
-        const collectionId = mutation.collection.id
-        if (!touchedCollections.has(collectionId)) {
-          touchedCollections.add(collectionId)
-          mutation.collection._state.transactions.delete(restorationTx.id)
-          mutation.collection._state.recomputeOptimisticState(false)
-        }
-      }
+      return
     }
 
-    this.restorationTransactions.delete(transactionId)
+    // Mark as completed so recomputeOptimisticState removes it from consideration.
+    // The actual data will come from the sync.
+    restorationTx.setState(`completed`)
+
+    // Remove from each collection's transaction map and recompute
+    const touchedCollections = new Set<string>()
+    for (const mutation of restorationTx.mutations) {
+      const collectionId = mutation.collection.id
+      if (touchedCollections.has(collectionId)) {
+        continue
+      }
+      touchedCollections.add(collectionId)
+      mutation.collection._state.transactions.delete(restorationTx.id)
+      mutation.collection._state.recomputeOptimisticState(false)
+    }
   }
 
   async removeFromOutbox(id: string): Promise<void> {

packages/offline-transactions/src/executor/TransactionExecutor.ts

@@ -248,50 +248,44 @@ export class TransactionExecutor {
   }
 
   /**
-   * Restore optimistic state from loaded transactions
+   * Restore optimistic state from loaded transactions.
    * Creates internal transactions to hold the mutations so the collection's
-   * state manager can show optimistic data while waiting for sync
+   * state manager can show optimistic data while waiting for sync.
    */
   private restoreOptimisticState(
     transactions: Array<OfflineTransaction>,
   ): void {
     for (const offlineTx of transactions) {
-      if (offlineTx.mutations.length === 0) continue
+      if (offlineTx.mutations.length === 0) {
+        continue
+      }
 
-      // Create a restoration transaction that will never commit
-      // Its only purpose is to hold the mutations for optimistic state display
+      // Create a restoration transaction that holds mutations for optimistic state display.
+      // It will never commit - the real mutation is handled by the offline executor.
       const restorationTx = createTransaction({
         id: offlineTx.id,
         autoCommit: false,
-        mutationFn: async () => {
-          // This mutation function should never be called
-          // The real mutation is handled by the offline executor
-        },
+        mutationFn: async () => {},
       })
 
-      // Apply mutations to the restoration transaction
       restorationTx.applyMutations(offlineTx.mutations)
 
       // Register with each affected collection's state manager
       const touchedCollections = new Set<string>()
       for (const mutation of offlineTx.mutations) {
         const collectionId = mutation.collection.id
-        if (!touchedCollections.has(collectionId)) {
-          touchedCollections.add(collectionId)
-
-          // Register the transaction with the collection's state manager
-          mutation.collection._state.transactions.set(
-            restorationTx.id,
-            restorationTx,
-          )
-
-          // Recompute optimistic state to show the restored data
-          mutation.collection._state.recomputeOptimisticState(true)
+        if (touchedCollections.has(collectionId)) {
+          continue
         }
+        touchedCollections.add(collectionId)
+
+        mutation.collection._state.transactions.set(
+          restorationTx.id,
+          restorationTx,
+        )
+        mutation.collection._state.recomputeOptimisticState(true)
       }
 
-      // Store the restoration transaction so we can clean it up when the
-      // offline transaction completes
       this.offlineExecutor.registerRestorationTransaction(
         offlineTx.id,
         restorationTx,