fix: preserve persisted Query writes across overlapping refetches - #2002

What changes

A persisted Query Collection can lose a newer result when a refetch replaces a result that SQLite has not applied yet. An awaited writeUpsert() inside a mutation handler can also stall behind an earlier refetch. This change lets accepted source writes complete and keeps their durable order.

onUpdate: async ({ collection }) => {
  await collection.utils.writeUpsert(serverRow)
  return { refetch: false }
}

This handler now settles when an earlier source write is waiting for the same mutation. The later write reaches SQLite after the earlier write.

How it works

Query Collection keeps a result alive after its source commit starts. A later result can replace its ownership without aborting that accepted commit. Reconciliation also deletes a retired row by key when the row has not reached the synced store yet.

The persistence wrapper now records a queued immediate source write. That write lets core publish an earlier committed source transaction while the mutation remains active. The wrapper still applies the two writes to SQLite in FIFO order. The change adds no public API.

Checks and limits

• The Query ownership oracle passes all 167 cases. It covers two handler timing cuts, refetch and direct-write successors, row turnover, cleanup, and optimistic snapshots.
• The persistence suite passes 258 tests with one existing todo. Its updated witness checks successful receipts and durable write order.
• The real Node SQLite suite passes all 12 tests. It checks an awaited immediate write behind a pending normal source write.
• The core optimistic and reused-row suites pass all 36 tests. Type checks pass for core, persistence, and Node SQLite. Query Collection type checking still reports missing optional Electric and E2E dependencies in this checkout.

The controlled Query oracle covers the reported refetch timing. The Node test covers the handler path with real SQLite. An Expo host timing test and a Node host test of the exact two-refetch schedule remain open in the oracle coverage map.

Fixes #1990.

Summary by CodeRabbit

• Bug Fixes
  • Refetches overlapping persisted writes now preserve accepted query results instead of reverting them.
  • Overlapping writes complete in order, keeping the latest data consistent in the collection and SQLite storage.
  • Mutation-handler writes can complete while an earlier source write is pending, with both writes retaining FIFO durability order.
  • The Query cache updates when a queued write is applied, so it reflects the latest committed data.
  • Index failures reject dependent mutations without persisting their rows; publication-listener failures no longer prevent queued writes from settling.