Fix: Skip all optimistic state from persisting transactions, not just synced keys

The previous fix only skipped re-applying optimistic state for keys that were
just synced. This failed when the key itself changed (e.g., temp ID -1234 →
server ID 1000), because changedKeys.has(mutation.key) would return false.

Now we skip re-applying optimistic state for ALL mutations in persisting
transactions. This ensures that when a mutation handler writes server data
via sync functions, that data becomes visible immediately without being
masked by stale optimistic state.

This fixes the issue where temp IDs would persist even after the server
returned real IDs.

Co-authored-by: Sam Willis <[email protected]>

Author: github-actions[bot]

packages/db/src/collection/state.ts

@@ -669,22 +669,20 @@ export class CollectionStateManager<
       // after the truncate snapshot are preserved.
       for (const transaction of this.transactions.values()) {
         if (![`completed`, `failed`].includes(transaction.state)) {
+          // Skip re-applying optimistic state for persisting transactions entirely
+          // (not just for changed keys). When a transaction is persisting, its mutation
+          // handler may write server data via sync functions. That synced data should be
+          // visible immediately, not masked by stale optimistic state.
+          // EXCEPT during truncate operations where optimistic state should always be preserved.
+          if (!hasTruncateSync && transaction.state === `persisting`) {
+            continue
+          }
+
           for (const mutation of transaction.mutations) {
             if (
               this.isThisCollection(mutation.collection) &&
               mutation.optimistic
             ) {
-              // Skip re-applying optimistic state for persisting transactions
-              // if the mutation key was just synced (prevents overwriting fresh server data)
-              // EXCEPT during truncate operations where optimistic state should always be preserved
-              if (
-                !hasTruncateSync &&
-                transaction.state === `persisting` &&
-                changedKeys.has(mutation.key)
-              ) {
-                continue
-              }
-
               switch (mutation.type) {
                 case `insert`:
                 case `update`: