@tanstack/db-sqlite-persistence-core 0.4.7 → 0.4.9

package/README.md

@@ -172,10 +172,23 @@ semantics.
 After a mutating RPC transport failure, replay is allowed only while the
 requester can prove the same non-null leader id and term still own the route.
 If either value was unknown for the first attempt, or either value changes,
-the request rejects with `IndeterminateCommitError` and requires application
-reconciliation. Coordinators never retry an indeterminate mutation against an
+the direct request rejects with `IndeterminateCommitError` and requires
+application reconciliation. Coordinators never retry that mutation against an
 unknown or replacement leader.
 
+A source sync transaction has a separate exact-ID reconciliation path. The
+persisted wrapper holds its applied receipt while an elected coordinator and
+SQLite adapter check the transaction under the writer lock. An existing ID
+acknowledges the original durable position. An absent ID permits one application
+only if the durable row version and reset epoch equal the wrapper's pre-send
+snapshot; another durable write may carry newer row values or an opaque source
+cursor and cannot be overwritten safely. On a certified result the wrapper
+fulfills the receipt in the same sync run and the coordinator invalidates peers,
+including a peer that missed the original notification. An uncertified result
+retains `IndeterminateCommitError` and terminal source failure. Custom adapters
+and coordinators without this optional operation keep that terminal behavior.
+One generated `txId` identifies one immutable source transaction payload.
+
 `SingleProcessCoordinator` also implements the complete route. It is always
 leader and has no cross-process transport, but it applies the transaction to
 the resolved adapter registered for the specific collection. The Browser and
@@ -278,13 +291,22 @@ separate from the accepted-transaction precedence rule.
 ### Atomic resume snapshots
 
 Persistence adapters implement
-`loadResumeSnapshot(collectionId, options)` to let a sync source certify a
+`loadResumeSnapshot(target, options)` to let a sync source certify a
 persisted resume baseline. One call must read rows, collection metadata, stream
 position, reset epoch, and key-set evidence from the same atomic database
 snapshot. `includeRows: false` requests the same certification data without
 materializing rows; `requiredIndexSignatures` carries the indexes needed by a
 row-bearing snapshot.
 
+The adapter's data methods require an explicit `PersistedStorageTarget`. Use
+`{ kind: 'eager', collectionId }` for an eager Collection, or
+`{ kind: 'managed', storageCollectionId, claimId }` for a claimed on-demand
+persisted cache generation. A bare string ID is rejected. The managed target
+checks the claim even after its generation has been collected from SQLite;
+choosing an eager target explicitly may reuse the same ID. Claim and
+rotation methods take the logical Collection ID; renewal takes the physical
+storage ID and release takes the claim ID.
+
 `PersistedKeySetEvidence.status` has three states:
 
 - `consistent`: the persisted rows match the adapter's durable expected-key
@@ -294,6 +316,13 @@ row-bearing snapshot.
 - `unknown`: the adapter has no authoritative pre-migration key set and does
   not claim completeness.
 
+A no-write election can reserve a greater durable term and reset its sequence
+to zero without changing persisted rows or the source resume cursor. The
+persisted wrapper keeps an already certified resume baseline across that
+transition only when the atomic snapshot has the same row version and reset
+epoch. A committed write or schema reset requires fresh certification and
+cannot inherit the earlier baseline merely because the key set still matches.
+
 The method is required because the versioned `metadata.persistence` capability
 always carries hydration, durable row scanning, certification, evidence, and
 generation ownership as one complete bundle. Sync wrappers must forward the

package/dist/cjs/broadcast-coordinator.cjs

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const db = require("@tanstack/db");
+const committedTxAnchor = require("./committed-tx-anchor.cjs");
 const errors = require("./errors.cjs");
 const remoteSubsetWire = require("./remote-subset-wire.cjs");
 const remoteSubsetOwner = require("./remote-subset-owner.cjs");
+const persisted = require("./persisted.cjs");
 const HEARTBEAT_INTERVAL_MS = 3e3;
 const LEADERSHIP_RETRY_DELAY_MS = 200;
 const RPC_TIMEOUT_MS = 1e4;
@@ -13,10 +15,16 @@ const REMOTE_SUBSET_REPLAY_RETRY_ATTEMPTS = 2;
 const RPC_DEDUPE_RETENTION_MS = 6e4;
 const WRITER_LOCK_BUSY_RETRY_MS = 50;
 const WRITER_LOCK_MAX_RETRIES = 20;
+function requireDurableElection(adapter) {
+  if (typeof adapter.reserveLeadershipTerm !== `function`) {
+    throw new errors.InvalidPersistenceAdapterError(`reserveLeadershipTerm`);
+  }
+}
 class BroadcastCollectionCoordinator {
   constructor(options) {
     this.nodeId = db.safeRandomUUID();
     this.collectionAdapters = /* @__PURE__ */ new Map();
+    this.collectionClaimIds = /* @__PURE__ */ new Map();
     this.remoteSubsetOwners = /* @__PURE__ */ new Map();
     this.remoteSubsetIds = /* @__PURE__ */ new Map();
     this.outboundRemoteSubsetAcquisitions = /* @__PURE__ */ new Map();
@@ -29,6 +37,7 @@ class BroadcastCollectionCoordinator {
     this.appliedEnvelopePruneTimer = null;
     this.rejectDisposed = null;
     this.disposed = false;
+    if (options.adapter) requireDurableElection(options.adapter);
     this.dbName = options.dbName;
     this.coordinatorName = options.coordinatorName;
     this.defaultAdapter = options.adapter ?? null;
@@ -67,11 +76,18 @@ class BroadcastCollectionCoordinator {
    * Called by a host persistence factory to wire the internally-created adapter.
    */
   setAdapter(adapter) {
+    requireDurableElection(adapter);
     this.defaultAdapter = adapter;
   }
   /** Register the persistence adapter that owns one collection. */
-  setAdapterForCollection(collectionId, adapter) {
+  setAdapterForCollection(collectionId, adapter, cacheGenerationClaimId) {
+    requireDurableElection(adapter);
     this.collectionAdapters.set(collectionId, adapter);
+    if (cacheGenerationClaimId) {
+      this.collectionClaimIds.set(collectionId, cacheGenerationClaimId);
+    } else {
+      this.collectionClaimIds.delete(collectionId);
+    }
   }
   registerRemoteSubsetOwner(collectionId, owner) {
     if (this.remoteSubsetOwners.has(collectionId)) {
@@ -215,10 +231,29 @@ class BroadcastCollectionCoordinator {
     }
     try {
       await acquisition.release;
+    } catch (error) {
+      this.scheduleRemoteSubsetReleaseRetry(acquisition, options);
+      throw error;
     } finally {
       acquisition.release = null;
     }
   }
+  scheduleRemoteSubsetReleaseRetry(acquisition, options) {
+    const key = remoteSubsetAcquisitionKey(
+      acquisition.collectionId,
+      acquisition.acquisitionId
+    );
+    if (this.isDisposed() || this.outboundRemoteSubsetAcquisitions.get(key) !== acquisition || acquisition.retryTimer !== null) {
+      return;
+    }
+    acquisition.retryTimer = setTimeout(() => {
+      acquisition.retryTimer = null;
+      void this.requestReleaseRemoteSubset(
+        acquisition.collectionId,
+        options
+      ).catch(() => void 0);
+    }, RPC_RETRY_DELAY_MS);
+  }
   async acquireRemoteSubset(acquisition) {
     if (acquisition.inFlight) return acquisition.inFlight;
     const route = { localOwner: false };
@@ -278,7 +313,9 @@ class BroadcastCollectionCoordinator {
     try {
       await work;
       acquired = true;
-      this.cancelRemoteSubsetReplayRetry(acquisition);
+      if (!acquisition.releaseRequested) {
+        this.cancelRemoteSubsetReplayRetry(acquisition);
+      }
     } finally {
       if (acquisition.inFlight === work) acquisition.inFlight = null;
       const current = this.collections.get(acquisition.collectionId);
@@ -295,21 +332,34 @@ class BroadcastCollectionCoordinator {
       }
     }
   }
-  async requestEnsurePersistedIndex(collectionId, signature, spec, scopedAdapter, localEnsureCompleted = false) {
+  async requestEnsurePersistedIndex(collectionId, signature, spec, scopedAdapter, localEnsureCompleted = false, cacheGenerationClaimId) {
     if (this.isLeader(collectionId)) {
       if (localEnsureCompleted) return;
-      await (scopedAdapter ?? this.requireAdapter(collectionId)).ensureIndex(
-        collectionId,
-        signature,
-        spec
-      );
+      const adapter = scopedAdapter ?? this.requireAdapter(collectionId);
+      if (cacheGenerationClaimId) {
+        await adapter.ensureIndex(
+          persisted.managedStorageTarget(collectionId, cacheGenerationClaimId),
+          signature,
+          spec,
+          {
+            cacheGenerationClaimId
+          }
+        );
+      } else {
+        await adapter.ensureIndex(
+          persisted.eagerStorageTarget(collectionId),
+          signature,
+          spec
+        );
+      }
       return;
     }
     const response = await this.sendRPC(collectionId, {
       type: `rpc:ensurePersistedIndex:req`,
       rpcId: db.safeRandomUUID(),
       signature,
-      spec
+      spec,
+      cacheGenerationClaimId
     });
     if (!response.ok) {
       throw new Error(
@@ -317,7 +367,7 @@ class BroadcastCollectionCoordinator {
       );
     }
   }
-  async requestApplyLocalMutations(collectionId, mutations) {
+  async requestApplyLocalMutations(collectionId, mutations, cacheGenerationClaimId) {
     const initialRoute = this.waitForInitialRoute(collectionId);
     if (initialRoute) await initialRoute;
     if (this.isLeader(collectionId)) {
@@ -325,14 +375,16 @@ class BroadcastCollectionCoordinator {
         type: `rpc:applyLocalMutations:req`,
         rpcId: db.safeRandomUUID(),
         envelopeId: db.safeRandomUUID(),
-        mutations
+        mutations,
+        cacheGenerationClaimId
       });
     }
     return this.sendRPC(collectionId, {
       type: `rpc:applyLocalMutations:req`,
       rpcId: db.safeRandomUUID(),
       envelopeId: db.safeRandomUUID(),
-      mutations
+      mutations,
+      cacheGenerationClaimId
     });
   }
   async requestApplyCommittedTx(collectionId, tx, scopedAdapter) {
@@ -349,14 +401,39 @@ class BroadcastCollectionCoordinator {
     }
     return this.sendRPC(collectionId, request);
   }
-  async pullSince(collectionId, fromRowVersion, scopedAdapter) {
+  async reconcileCommittedTx(collectionId, tx, anchor, scopedAdapter) {
+    const initialRoute = this.waitForInitialRoute(collectionId);
+    if (initialRoute) await initialRoute;
+    let response;
+    for (let attempt = 0; attempt <= RPC_RETRY_ATTEMPTS; attempt++) {
+      if (attempt > 0) await sleep(RPC_RETRY_DELAY_MS * attempt);
+      const request = {
+        type: `rpc:reconcileCommittedTx:req`,
+        rpcId: db.safeRandomUUID(),
+        tx,
+        anchor
+      };
+      response = this.isLeader(collectionId) ? await this.handleReconcileCommittedTx(
+        collectionId,
+        request,
+        scopedAdapter
+      ) : await this.sendRPC(
+        collectionId,
+        request
+      );
+      if (response.ok || response.code !== `NOT_LEADER`) return response;
+    }
+    return response;
+  }
+  async pullSince(collectionId, fromRowVersion, scopedAdapter, cacheGenerationClaimId) {
     if (this.isLeader(collectionId)) {
       return this.handlePullSince(
         collectionId,
         {
           type: `rpc:pullSince:req`,
           rpcId: db.safeRandomUUID(),
-          fromRowVersion
+          fromRowVersion,
+          cacheGenerationClaimId
         },
         scopedAdapter
       );
@@ -364,7 +441,8 @@ class BroadcastCollectionCoordinator {
     return this.sendRPC(collectionId, {
       type: `rpc:pullSince:req`,
       rpcId: db.safeRandomUUID(),
-      fromRowVersion
+      fromRowVersion,
+      cacheGenerationClaimId
     });
   }
   // -----------------------------------------------------------------------
@@ -397,6 +475,7 @@ class BroadcastCollectionCoordinator {
     this.channel.close();
     this.collections.clear();
     this.collectionAdapters.clear();
+    this.collectionClaimIds.clear();
     for (const collectionId of this.remoteSubsetOwners.keys()) {
       this.releaseInboundRemoteSubsetAcquisitions(collectionId);
     }
@@ -454,16 +533,24 @@ class BroadcastCollectionCoordinator {
           }
           try {
             const adapter = this.requireAdapter(collectionId);
-            if (adapter.getStreamPosition) {
-              const pos = await adapter.getStreamPosition(collectionId);
-              state.latestTerm = pos.latestTerm;
-              state.latestSeq = pos.latestSeq;
-              state.latestRowVersion = pos.latestRowVersion;
-            }
+            const reserveTerm = adapter.reserveLeadershipTerm;
+            if (!reserveTerm)
+              throw new errors.InvalidPersistenceAdapterError(`reserveLeadershipTerm`);
+            const pos = await this.withWriterLock(() => {
+              const claimId = this.collectionClaimIds.get(collectionId);
+              return reserveTerm.call(
+                adapter,
+                claimId ? persisted.managedStorageTarget(collectionId, claimId) : persisted.eagerStorageTarget(collectionId),
+                state.latestTerm,
+                { cacheGenerationClaimId: claimId }
+              );
+            });
+            state.latestTerm = pos.latestTerm;
+            state.latestSeq = pos.latestSeq;
+            state.latestRowVersion = pos.latestRowVersion;
             if (this.isDisposed() || !this.participatesInLeadership(state) || this.collections.get(collectionId) !== state || abortController.signal.aborted || state.lockAbortController !== abortController) {
               return;
             }
-            state.latestTerm++;
             state.isLeader = true;
             state.leaderId = this.nodeId;
             this.notifyRouteWaiters(state);
@@ -604,6 +691,7 @@ class BroadcastCollectionCoordinator {
     this.releaseLeadership(collectionId, state);
     this.collections.delete(collectionId);
     this.collectionAdapters.delete(collectionId);
+    this.collectionClaimIds.delete(collectionId);
     const prefix = `${JSON.stringify([collectionId]).slice(0, -1)},`;
     for (const key of this.appliedEnvelopes.keys()) {
       if (key.startsWith(prefix)) this.appliedEnvelopes.delete(key);
@@ -720,6 +808,7 @@ class BroadcastCollectionCoordinator {
       const heartbeat = payload;
       if (typeof heartbeat.leaderId === `string` && typeof heartbeat.term === `number` && typeof heartbeat.latestSeq === `number` && typeof heartbeat.latestRowVersion === `number`) {
         const state2 = this.getOrCreateCollectionState(envelope.collectionId);
+        if (state2.isLeader) return;
         if (heartbeat.term < state2.latestTerm) return;
         const changedLeader = state2.leaderId !== heartbeat.leaderId;
         state2.leaderId = heartbeat.leaderId;
@@ -900,6 +989,8 @@ class BroadcastCollectionCoordinator {
         return this.handleApplyLocalMutations(collectionId, request);
       case `rpc:applyCommittedTx:req`:
         return this.handleApplyCommittedTx(collectionId, request);
+      case `rpc:reconcileCommittedTx:req`:
+        return this.handleReconcileCommittedTx(collectionId, request);
       case `rpc:pullSince:req`:
         return this.handlePullSince(collectionId, request);
     }
@@ -1014,10 +1105,7 @@ class BroadcastCollectionCoordinator {
     acquisition.released = true;
     acquisition.release = (async () => {
       try {
-        await acquisition.load;
-      } catch {
-      }
-      try {
+        await acquisition.admitted;
         if (acquisition.transferred) {
           await remoteSubsetOwner.unloadRemoteSubsetOwner(acquisition.owner, acquisition.options);
         }
@@ -1133,6 +1221,7 @@ class BroadcastCollectionCoordinator {
       owner: options.owner,
       options: options.options,
       load: Promise.resolve(),
+      admitted: Promise.resolve(),
       transferred: false,
       released: false,
       terminalRelease: false,
@@ -1140,6 +1229,10 @@ class BroadcastCollectionCoordinator {
     };
     this.releasedRemoteSubsetAcquisitionTimes.delete(key);
     this.inboundRemoteSubsetAcquisitions.set(key, acquisition);
+    let resolveAdmission;
+    acquisition.admitted = new Promise((resolve) => {
+      resolveAdmission = resolve;
+    });
     let resolveLoad;
     let rejectLoad;
     acquisition.load = new Promise((resolve, reject) => {
@@ -1152,6 +1245,8 @@ class BroadcastCollectionCoordinator {
       void Promise.resolve(load).then(resolveLoad, rejectLoad);
     } catch (error) {
       rejectLoad(error);
+    } finally {
+      resolveAdmission();
     }
     try {
       await acquisition.load;
@@ -1176,10 +1271,23 @@ class BroadcastCollectionCoordinator {
     }
   }
   async handleEnsurePersistedIndex(collectionId, request) {
-    await this.withScheduledWriterLock(
-      collectionId,
-      (adapter) => adapter.ensureIndex(collectionId, request.signature, request.spec)
-    );
+    await this.withScheduledWriterLock(collectionId, (adapter) => {
+      if (request.cacheGenerationClaimId) {
+        return adapter.ensureIndex(
+          persisted.managedStorageTarget(collectionId, request.cacheGenerationClaimId),
+          request.signature,
+          request.spec,
+          {
+            cacheGenerationClaimId: request.cacheGenerationClaimId
+          }
+        );
+      }
+      return adapter.ensureIndex(
+        persisted.eagerStorageTarget(collectionId),
+        request.signature,
+        request.spec
+      );
+    });
     return {
       type: `rpc:ensurePersistedIndex:res`,
       rpcId: request.rpcId,
@@ -1208,6 +1316,11 @@ class BroadcastCollectionCoordinator {
     });
   }
   async applyLocalMutationsOnce(collectionId, request) {
+    if (this.collectionClaimIds.has(collectionId) && !request.cacheGenerationClaimId) {
+      throw new errors.InvalidPersistedCollectionConfigError(
+        `A managed local mutation requires a persisted cache claim`
+      );
+    }
     const state = this.collections.get(collectionId);
     if (!state || !state.isLeader) {
       return {
@@ -1233,6 +1346,7 @@ class BroadcastCollectionCoordinator {
     }
     const pendingTx = {
       txId: db.safeRandomUUID(),
+      cacheGenerationClaimId: request.cacheGenerationClaimId,
       mutations: request.mutations.map((m) => ({
         type: m.type,
         key: m.key,
@@ -1393,6 +1507,10 @@ class BroadcastCollectionCoordinator {
       }
     );
     this.pruneAppliedEnvelopes();
+    this.publishCommittedTx(collectionId, state, tx);
+    return response;
+  }
+  publishCommittedTx(collectionId, state, tx, forceReload = false) {
     const committedBase = {
       type: `tx:committed`,
       term: tx.term,
@@ -1400,9 +1518,10 @@ class BroadcastCollectionCoordinator {
       txId: tx.txId,
       latestRowVersion: tx.rowVersion
     };
-    const committedPayload = tx.truncate ? {
+    const committedPayload = tx.truncate || forceReload ? {
       ...committedBase,
-      requiresFullReload: true
+      requiresFullReload: true,
+      ...forceReload ? { reconciliationReload: true } : {}
     } : {
       ...committedBase,
       requiresFullReload: false,
@@ -1426,24 +1545,123 @@ class BroadcastCollectionCoordinator {
     for (const subscriber of state.subscribers) {
       subscriber(committed);
     }
+  }
+  async handleReconcileCommittedTx(collectionId, request, scopedAdapter) {
+    const state = this.collections.get(collectionId);
+    const notLeader = () => ({
+      type: `rpc:reconcileCommittedTx:res`,
+      rpcId: request.rpcId,
+      ok: false,
+      code: `NOT_LEADER`,
+      error: `not the leader for ${collectionId}`
+    });
+    if (!state?.isLeader) return notLeader();
+    if (!committedTxAnchor.isValidCommittedTxAnchor(request.anchor) || !hasReconciliationTxPayload(request.tx)) {
+      return {
+        type: `rpc:reconcileCommittedTx:res`,
+        rpcId: request.rpcId,
+        ok: false,
+        code: `UNDETERMINED`,
+        error: `the source transaction has no valid durable proof`
+      };
+    }
+    const expectedTerm = state.latestTerm;
+    const result = await this.withScheduledWriterLock(
+      collectionId,
+      async (adapter) => {
+        const candidate = this.nextPersistedTxIfLeader(
+          collectionId,
+          state,
+          expectedTerm,
+          request.tx
+        );
+        if (candidate === null) return null;
+        if (!adapter.reconcileCommittedTx) return { kind: `unknown` };
+        try {
+          const reconciled = await adapter.reconcileCommittedTx(
+            candidate.cacheGenerationClaimId ? persisted.managedStorageTarget(
+              collectionId,
+              candidate.cacheGenerationClaimId
+            ) : persisted.eagerStorageTarget(collectionId),
+            candidate,
+            request.anchor
+          );
+          if (reconciled.kind !== `unknown`) {
+            state.latestRowVersion = Math.max(
+              state.latestRowVersion,
+              reconciled.latestRowVersion
+            );
+            if (reconciled.kind === `applied-now`) {
+              state.latestSeq = reconciled.committed.seq;
+            }
+          }
+          return reconciled;
+        } catch (error) {
+          throw errors.toPersistedCollectionDurabilityError(collectionId, error);
+        }
+      },
+      scopedAdapter
+    );
+    if (result === null) return notLeader();
+    if (result.kind === `unknown`) {
+      return {
+        type: `rpc:reconcileCommittedTx:res`,
+        rpcId: request.rpcId,
+        ok: false,
+        code: `UNDETERMINED`,
+        error: `the durable outcome cannot be certified`
+      };
+    }
+    const current = {
+      term: state.latestTerm,
+      seq: state.latestSeq,
+      rowVersion: state.latestRowVersion
+    };
+    const response = {
+      type: `rpc:reconcileCommittedTx:res`,
+      rpcId: request.rpcId,
+      ok: true,
+      alreadyApplied: result.kind === `already-applied`,
+      committed: result.committed
+    };
+    if (!this.isDisposed() && this.collections.get(collectionId) === state) {
+      this.publishCommittedTx(
+        collectionId,
+        state,
+        result.kind === `already-applied` ? { ...request.tx, ...current } : { ...request.tx, ...result.committed },
+        result.kind === `already-applied`
+      );
+    }
     return response;
   }
+  nextPersistedTxIfLeader(collectionId, state, expectedTerm, pendingTx) {
+    if (this.isDisposed() || this.collections.get(collectionId) !== state || !state.isLeader || state.leaderId !== this.nodeId || state.latestTerm !== expectedTerm) {
+      return null;
+    }
+    return {
+      ...pendingTx,
+      term: state.latestTerm,
+      seq: state.latestSeq + 1,
+      rowVersion: state.latestRowVersion + 1
+    };
+  }
   async applyDurablyAtNextStreamPosition(collectionId, state, pendingTx, scopedAdapter) {
     const expectedTerm = state.latestTerm;
     return this.withScheduledWriterLock(
       collectionId,
       async (adapter) => {
-        if (this.isDisposed() || this.collections.get(collectionId) !== state || !state.isLeader || state.leaderId !== this.nodeId || state.latestTerm !== expectedTerm) {
-          return null;
-        }
-        const tx = {
-          ...pendingTx,
-          term: state.latestTerm,
-          seq: state.latestSeq + 1,
-          rowVersion: state.latestRowVersion + 1
-        };
+        const tx = this.nextPersistedTxIfLeader(
+          collectionId,
+          state,
+          expectedTerm,
+          pendingTx
+        );
+        if (tx === null) return null;
         try {
-          await adapter.applyCommittedTx(collectionId, tx);
+          await adapter.applyCommittedTx(
+            tx.cacheGenerationClaimId ? persisted.managedStorageTarget(collectionId, tx.cacheGenerationClaimId) : persisted.eagerStorageTarget(collectionId),
+            tx
+          );
         } catch (error) {
           throw errors.toPersistedCollectionDurabilityError(collectionId, error);
         }
@@ -1468,7 +1686,13 @@ class BroadcastCollectionCoordinator {
         requiresFullReload: true
       };
     }
-    const result = await adapter.pullSince(collectionId, request.fromRowVersion);
+    const result = await adapter.pullSince(
+      request.cacheGenerationClaimId ? persisted.managedStorageTarget(collectionId, request.cacheGenerationClaimId) : persisted.eagerStorageTarget(collectionId),
+      request.fromRowVersion,
+      {
+        cacheGenerationClaimId: request.cacheGenerationClaimId
+      }
+    );
     if (result.requiresFullReload) {
       return {
         type: `rpc:pullSince:res`,
@@ -1584,12 +1808,18 @@ function isRPCRequest(payload) {
     case `rpc:ensurePersistedIndex:req`:
     case `rpc:applyLocalMutations:req`:
     case `rpc:applyCommittedTx:req`:
+    case `rpc:reconcileCommittedTx:req`:
     case `rpc:pullSince:req`:
       return true;
     default:
       return false;
   }
 }
+function hasReconciliationTxPayload(value) {
+  if (!value || typeof value !== `object`) return false;
+  const tx = value;
+  return typeof tx.txId === `string` && Array.isArray(tx.mutations);
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -1663,6 +1893,15 @@ function createRPCErrorResponse(request, cause) {
         code: `CONFLICT`,
         error
       };
+    case `rpc:reconcileCommittedTx:req`:
+      return {
+        type: `rpc:reconcileCommittedTx:res`,
+        rpcId: request.rpcId,
+        ok: false,
+        code: cause instanceof errors.PersistedCollectionDurabilityError ? `PERSISTENCE_ERROR` : `UNDETERMINED`,
+        error,
+        ...cause instanceof errors.PersistedCollectionDurabilityError ? toSafeDurabilityDetails(cause) : {}
+      };
     case `rpc:pullSince:req`:
       return {
         type: `rpc:pullSince:res`,