@tanstack/db-sqlite-persistence-core 0.2.21 → 0.4.0

package/dist/esm/persisted.js

@@ -1,19 +1,87 @@
-import { safeRandomUUID, withCollectionConfigFactory, SyncTransactionAbortedError, compileSingleRowExpression, toBooleanPredicate } from "@tanstack/db";
-import { InvalidPersistedCollectionCoordinatorError, InvalidPersistedCollectionConfigError, InvalidSyncConfigError, InvalidPersistedStorageKeyError, InvalidPersistedStorageKeyEncodingError, InvalidPersistenceAdapterError } from "./errors.js";
+import { safeRandomUUID, withCollectionConfigFactory, SyncTransactionAbortedError, getLoadSubsetDemandKey, compileSingleRowExpression, toBooleanPredicate, SYNC_PERSISTENCE_VERSION, SYNC_PERSISTENCE_PROTOCOL, PERSISTED_READINESS, NoPendingSyncTransactionCommitError, NoPendingSyncTransactionWriteError } from "@tanstack/db";
+import { InvalidPersistedCollectionConfigError, DuplicateRemoteSubsetOwnerError, toPersistedCollectionDurabilityError, InvalidPersistedCollectionCoordinatorError, InvalidSyncConfigError, InvalidPersistedStorageKeyError, InvalidPersistedStorageKeyEncodingError, PersistedCollectionDurabilityError, InvalidPersistenceAdapterError } from "./errors.js";
+import { serializeSQLiteBigInt } from "./sqlite-value.js";
+import { toTransportedLoadSubsetOptions, toProcessLocalLoadSubsetOptions } from "./remote-subset-wire.js";
+import { reportRemoteSubsetOwnerError, unloadRemoteSubsetOwner } from "./remote-subset-owner.js";
+const SQLITE_DRIVER_SHARED_LOGICAL_SCHEDULING_KEY = /* @__PURE__ */ Symbol.for(
+  `tanstack-db.sqlite-driver-supports-shared-logical-scheduling`
+);
+function forwardSQLiteDriverSharedLogicalScheduling(source, wrapper) {
+  const key = source[SQLITE_DRIVER_SHARED_LOGICAL_SCHEDULING_KEY];
+  if (key) {
+    Object.defineProperty(
+      wrapper,
+      SQLITE_DRIVER_SHARED_LOGICAL_SCHEDULING_KEY,
+      { value: key }
+    );
+  }
+  return wrapper;
+}
+class PersistedReadinessTracker {
+  constructor(networkTimeoutMs) {
+    this.networkTimeoutMs = networkTimeoutMs;
+    this.snapshot = { status: `loading` };
+    this.listeners = /* @__PURE__ */ new Set();
+    this.getSnapshot = () => this.snapshot;
+    this.getOrStartNetworkDeadline = () => {
+      return this.networkDeadlineAt ??= Date.now() + this.networkTimeoutMs;
+    };
+    this.subscribe = (listener) => {
+      this.listeners.add(listener);
+      return () => this.listeners.delete(listener);
+    };
+  }
+  set(snapshot) {
+    const deadlineRestarted = snapshot.status === `loading` && this.networkDeadlineAt !== void 0;
+    if (deadlineRestarted) {
+      this.networkDeadlineAt = Date.now() + this.networkTimeoutMs;
+    }
+    if (this.snapshot.status === snapshot.status && this.snapshot.error === snapshot.error && !deadlineRestarted) {
+      return;
+    }
+    this.snapshot = snapshot;
+    for (const listener of this.listeners) listener();
+  }
+}
+const DEFAULT_NETWORK_TIMEOUT_MS = 3e3;
+const MAX_TIMER_TIMEOUT_MS = 2147483647;
+function getNetworkTimeoutMs(initialRender) {
+  if (initialRender === void 0) return void 0;
+  const strategy = initialRender.strategy;
+  if (strategy !== `network-first`) {
+    throw new InvalidPersistedCollectionConfigError(
+      `initialRender.strategy must be "network-first"`
+    );
+  }
+  const timeoutMs = initialRender.networkTimeoutMs ?? DEFAULT_NETWORK_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0 || timeoutMs > MAX_TIMER_TIMEOUT_MS) {
+    throw new InvalidPersistedCollectionConfigError(
+      `initialRender.networkTimeoutMs must be between 0 and ${MAX_TIMER_TIMEOUT_MS}`
+    );
+  }
+  return timeoutMs;
+}
 const REQUIRED_COORDINATOR_METHODS = [
   `getNodeId`,
   `subscribe`,
   `publish`,
   `isLeader`,
   `ensureLeadership`,
-  `requestEnsurePersistedIndex`
+  `requestEnsureRemoteSubset`,
+  `requestReleaseRemoteSubset`,
+  `registerRemoteSubsetOwner`,
+  `requestEnsurePersistedIndex`,
+  `requestApplyCommittedTx`
 ];
-const REQUIRED_ADAPTER_METHODS = [`loadSubset`, `applyCommittedTx`, `ensureIndex`];
+const REQUIRED_ADAPTER_METHODS = [`loadSubset`, `loadResumeSnapshot`, `applyCommittedTx`, `ensureIndex`];
 const TARGETED_INVALIDATION_KEY_LIMIT = 128;
 const DEFAULT_DB_NAME = `tanstack-db`;
 const REMOTE_ENSURE_RETRY_DELAY_MS = 50;
 class SingleProcessCoordinator {
   constructor(nodeId = safeRandomUUID()) {
+    this.collectionAdapters = /* @__PURE__ */ new Map();
+    this.remoteSubsetOwners = /* @__PURE__ */ new Map();
+    this.remoteSubsetAcquisitions = /* @__PURE__ */ new Map();
     this.nodeId = nodeId;
   }
   getNodeId() {
@@ -30,10 +98,105 @@ class SingleProcessCoordinator {
   }
   async ensureLeadership() {
   }
-  async requestEnsureRemoteSubset() {
+  async requestEnsureRemoteSubset(collectionId, options) {
+    const transported = toTransportedLoadSubsetOptions(options);
+    const localOptions = toProcessLocalLoadSubsetOptions(options, transported);
+    const owner = this.remoteSubsetOwners.get(collectionId);
+    if (!owner) {
+      throw new InvalidPersistedCollectionConfigError(
+        `SingleProcessCoordinator has no remote subset owner configured for collection "${collectionId}"`
+      );
+    }
+    let acquisitions = this.remoteSubsetAcquisitions.get(collectionId);
+    if (!acquisitions) {
+      acquisitions = /* @__PURE__ */ new Map();
+      this.remoteSubsetAcquisitions.set(collectionId, acquisitions);
+    }
+    const existing = acquisitions.get(options);
+    if (existing) {
+      await existing.load;
+      return;
+    }
+    let resolveLoad;
+    let rejectLoad;
+    const load = new Promise((resolve, reject) => {
+      resolveLoad = resolve;
+      rejectLoad = reject;
+    });
+    acquisitions.set(options, { owner, options: localOptions, load });
+    try {
+      const ownerLoad = owner(localOptions);
+      void Promise.resolve(ownerLoad).then(resolveLoad, (error) => {
+        reportRemoteSubsetOwnerError(owner, error);
+        rejectLoad(error);
+      });
+    } catch (error) {
+      reportRemoteSubsetOwnerError(owner, error);
+      rejectLoad(error);
+    }
+    await load;
+  }
+  async requestReleaseRemoteSubset(collectionId, options) {
+    const acquisitions = this.remoteSubsetAcquisitions.get(collectionId);
+    const acquisition = acquisitions?.get(options);
+    if (!acquisition) return;
+    acquisitions.delete(options);
+    if (acquisitions.size === 0) {
+      this.remoteSubsetAcquisitions.delete(collectionId);
+    }
+    try {
+      await acquisition.load;
+    } catch {
+    }
+    await unloadRemoteSubsetOwner(acquisition.owner, acquisition.options);
+  }
+  registerRemoteSubsetOwner(collectionId, owner) {
+    if (this.remoteSubsetOwners.has(collectionId)) {
+      throw new DuplicateRemoteSubsetOwnerError(collectionId);
+    }
+    this.remoteSubsetOwners.set(collectionId, owner);
+    return () => {
+      if (this.remoteSubsetOwners.get(collectionId) !== owner) return;
+      const acquisitions = this.remoteSubsetAcquisitions.get(collectionId);
+      this.remoteSubsetAcquisitions.delete(collectionId);
+      this.remoteSubsetOwners.delete(collectionId);
+      for (const acquisition of acquisitions?.values() ?? []) {
+        void (async () => {
+          try {
+            await acquisition.load;
+          } catch {
+          }
+          await unloadRemoteSubsetOwner(owner, acquisition.options);
+        })().catch(() => void 0);
+      }
+    };
   }
   async requestEnsurePersistedIndex() {
   }
+  setAdapterForCollection(collectionId, adapter) {
+    this.collectionAdapters.set(collectionId, adapter);
+  }
+  async requestApplyCommittedTx(collectionId, tx) {
+    const adapter = this.collectionAdapters.get(collectionId);
+    if (!adapter) {
+      throw new InvalidPersistedCollectionConfigError(
+        `SingleProcessCoordinator has no persistence adapter configured for collection "${collectionId}"`
+      );
+    }
+    try {
+      await adapter.applyCommittedTx(collectionId, tx);
+    } catch (error) {
+      throw toPersistedCollectionDurabilityError(collectionId, error);
+    }
+    return {
+      type: `rpc:applyCommittedTx:res`,
+      rpcId: safeRandomUUID(),
+      ok: true,
+      term: tx.term,
+      seq: tx.seq,
+      latestRowVersion: tx.rowVersion
+    };
+  }
   pullSince() {
     return Promise.resolve({
       type: `rpc:pullSince:res`,
@@ -63,25 +226,38 @@ function validatePersistenceAdapter(adapter) {
     }
   }
 }
-function resolvePersistence(persistence) {
+function resolvePersistence(persistence, collectionId) {
   validatePersistenceAdapter(persistence.adapter);
   const coordinator = persistence.coordinator ?? new SingleProcessCoordinator();
+  if (coordinator instanceof SingleProcessCoordinator) {
+    coordinator.setAdapterForCollection(collectionId, persistence.adapter);
+  }
   validatePersistedCollectionCoordinator(coordinator);
   return {
     ...persistence,
     coordinator
   };
 }
-function resolvePersistenceForMode(persistence, mode) {
+function resolvePersistenceForMode(persistence, mode, collectionId) {
   const modeSpecificPersistence = persistence.resolvePersistenceForMode?.(mode);
-  return resolvePersistence(modeSpecificPersistence ?? persistence);
+  return resolvePersistence(
+    modeSpecificPersistence ?? persistence,
+    collectionId
+  );
 }
 function resolvePersistenceForCollection(persistence, options) {
   const collectionSpecificPersistence = persistence.resolvePersistenceForCollection?.(options);
   if (collectionSpecificPersistence) {
-    return resolvePersistence(collectionSpecificPersistence);
+    return resolvePersistence(
+      collectionSpecificPersistence,
+      options.collectionId
+    );
   }
-  return resolvePersistenceForMode(persistence, options.mode);
+  return resolvePersistenceForMode(
+    persistence,
+    options.mode,
+    options.collectionId
+  );
 }
 function hasOwnSyncKey(options) {
   return Object.prototype.hasOwnProperty.call(options, `sync`);
@@ -98,14 +274,47 @@ function isValidSyncConfig(value) {
 class ApplyMutex {
   constructor() {
     this.queue = Promise.resolve();
+    this.pending = 0;
+  }
+  reserve() {
+    const runImmediately = this.pending === 0;
+    const predecessor = this.queue;
+    this.pending++;
+    let releaseReservation;
+    const reservation = new Promise((resolve) => {
+      releaseReservation = resolve;
+    });
+    this.queue = runImmediately ? reservation : predecessor.then(() => reservation);
+    let used = false;
+    return {
+      run: (task) => {
+        if (used) {
+          return Promise.reject(
+            new Error(`an apply-mutex reservation can only run once`)
+          );
+        }
+        used = true;
+        let taskPromise;
+        if (runImmediately) {
+          try {
+            taskPromise = Promise.resolve(task());
+          } catch (error) {
+            taskPromise = Promise.reject(error);
+          }
+        } else {
+          taskPromise = predecessor.then(() => task());
+        }
+        const markComplete = () => {
+          this.pending--;
+          releaseReservation();
+        };
+        void taskPromise.then(markComplete, markComplete);
+        return taskPromise;
+      }
+    };
   }
-  async run(task) {
-    const taskPromise = this.queue.then(() => task());
-    this.queue = taskPromise.then(
-      () => void 0,
-      () => void 0
-    );
-    return taskPromise;
+  run(task) {
+    return this.reserve().run(task);
   }
 }
 function toStableSerializable(value) {
@@ -118,7 +327,7 @@ function toStableSerializable(value) {
     case `boolean`:
       return value;
     case `bigint`:
-      return value.toString();
+      return serializeSQLiteBigInt(value);
     case `function`:
     case `symbol`:
     case `undefined`:
@@ -163,15 +372,6 @@ function toStableSerializable(value) {
 function stableSerialize(value) {
   return JSON.stringify(toStableSerializable(value) ?? null);
 }
-function normalizeSubsetOptionsForKey(options) {
-  return {
-    where: toStableSerializable(options.where),
-    orderBy: toStableSerializable(options.orderBy),
-    limit: options.limit,
-    cursor: toStableSerializable(options.cursor),
-    offset: options.offset
-  };
-}
 function normalizeSyncFnResult(result) {
   if (typeof result === `function`) {
     return { cleanup: result };
@@ -207,38 +407,52 @@ function toPersistedMutationEnvelope(mutation) {
   };
 }
 class PersistedCollectionRuntime {
-  constructor(mode, collectionId, persistence, syncMode, dbName) {
+  constructor(mode, collectionId, persistence, syncMode, dbName, persistedReadiness) {
     this.mode = mode;
     this.collectionId = collectionId;
     this.persistence = persistence;
     this.syncMode = syncMode;
     this.dbName = dbName;
+    this.persistedReadiness = persistedReadiness;
     this.applyMutex = new ApplyMutex();
     this.activeSubsets = /* @__PURE__ */ new Map();
+    this.hydrationSequence = 0;
+    this.resetSequence = 0;
     this.pendingRemoteSubsetEnsures = /* @__PURE__ */ new Map();
     this.queuedHydrationTransactions = [];
     this.queuedTxCommitted = [];
-    this.subscriptionIds = /* @__PURE__ */ new WeakMap();
+    this.requestIds = /* @__PURE__ */ new WeakMap();
+    this.hydratedDemands = /* @__PURE__ */ new Set();
     this.collection = null;
     this.syncControls = {
       begin: null,
       write: null,
       commit: null,
       truncate: null,
-      metadata: null
+      metadata: null,
+      markError: null
     };
-    this.started = false;
     this.startupMetadataPromise = null;
     this.startPromise = null;
+    this.hasAttemptedStartup = false;
+    this.resumeBaselinePromise = null;
+    this.resumeCertificationPromise = null;
+    this.resumeGenerationOwner = /* @__PURE__ */ Symbol(`persisted resume generation owner`);
+    this.lifecycleGeneration = 0;
     this.internalApplyDepth = 0;
+    this.sourcePublicationWaitDepth = 0;
     this.appliedReceiptSequence = 0;
+    this.syncErrorReported = false;
     this.pendingAppliedReceipts = /* @__PURE__ */ new Map();
-    this.isHydrating = false;
+    this.hydratingGeneration = null;
     this.coordinatorUnsubscribe = null;
+    this.remoteSubsetOwnerUnsubscribe = null;
     this.indexAddedUnsubscribe = null;
     this.indexRemovedUnsubscribe = null;
     this.remoteEnsureRetryTimer = null;
-    this.nextSubscriptionId = 0;
+    this.nextRequestId = 0;
+    this.startupSettled = false;
+    this.sourceTruncateGeneration = 0;
     this.latestTerm = 0;
     this.latestSeq = 0;
     this.latestRowVersion = 0;
@@ -247,12 +461,34 @@ class PersistedCollectionRuntime {
     this.localRowVersion = 0;
   }
   setSyncControls(syncControls) {
+    this.advanceLifecycle();
+    this.syncErrorReported = false;
+    this.reportedSyncError = void 0;
     const commit = syncControls.commit;
     this.syncControls = {
       ...syncControls,
       commit: commit ? (signal) => this.trackAppliedReceipt(commit(signal)) : null
     };
   }
+  reportSyncError(error) {
+    const markError = this.syncControls.markError;
+    if (this.syncErrorReported) return this.reportedSyncError;
+    if (!markError) return error;
+    this.syncErrorReported = true;
+    this.reportedSyncError = error;
+    try {
+      markError(error);
+    } catch {
+    }
+    return error;
+  }
+  registerRemoteSubsetOwner(owner) {
+    this.remoteSubsetOwnerUnsubscribe?.();
+    this.remoteSubsetOwnerUnsubscribe = this.persistence.coordinator.registerRemoteSubsetOwner(
+      this.collectionId,
+      owner
+    );
+  }
   trackAppliedReceipt(receipt) {
     const sequence = ++this.appliedReceiptSequence;
     if (receipt === true) {
@@ -277,11 +513,54 @@ class PersistedCollectionRuntime {
       write: null,
       commit: null,
       truncate: null,
-      metadata: null
+      metadata: null,
+      markError: null
     };
   }
   isHydratingNow() {
-    return this.isHydrating;
+    return this.hydratingGeneration === this.lifecycleGeneration;
+  }
+  getActiveHydrationContext() {
+    return this.activeHydrationContext;
+  }
+  getHydrationSequence() {
+    return this.hydrationSequence;
+  }
+  getCurrentTerminalFailure() {
+    const failure = this.terminalFailure;
+    return failure?.lifecycleGeneration === this.lifecycleGeneration ? failure : void 0;
+  }
+  getLifecycleGeneration() {
+    return this.lifecycleGeneration;
+  }
+  throwIfLifecycleReplaced(lifecycleGeneration) {
+    if (lifecycleGeneration !== this.lifecycleGeneration) {
+      throw new SyncTransactionAbortedError();
+    }
+  }
+  throwIfTerminal() {
+    const failure = this.getCurrentTerminalFailure();
+    if (failure) throw failure.error;
+  }
+  markTerminalFailure(error, lifecycleGeneration = this.lifecycleGeneration) {
+    if (lifecycleGeneration !== this.lifecycleGeneration) {
+      return error;
+    }
+    const existing = this.getCurrentTerminalFailure();
+    if (existing) {
+      return existing.error;
+    }
+    this.terminalFailure = { lifecycleGeneration, error };
+    this.persistedReadiness?.set({ status: `error`, error });
+    this.pendingRemoteSubsetEnsures.clear();
+    this.queuedTxCommitted.length = 0;
+    if (this.remoteEnsureRetryTimer !== null) {
+      clearTimeout(this.remoteEnsureRetryTimer);
+      this.remoteEnsureRetryTimer = null;
+    }
+    this.rejectQueuedHydrationTransactions(error);
+    this.reportSyncError(error);
+    return error;
   }
   isApplyingInternally() {
     return this.internalApplyDepth > 0;
@@ -299,70 +578,233 @@ class PersistedCollectionRuntime {
       isLeader: this.persistence.coordinator.isLeader(this.collectionId)
     };
   }
+  runInHydrationScope(task, adapter = this.persistence.adapter) {
+    if (adapter.runInHydrationScope) {
+      return adapter.runInHydrationScope(task);
+    }
+    return Promise.resolve().then(() => task(adapter));
+  }
   async ensureStarted() {
+    this.throwIfTerminal();
     if (this.startPromise) {
       return this.startPromise;
     }
-    this.startPromise = this.startInternal();
+    const lifecycleGeneration = this.lifecycleGeneration;
+    const isRestart = this.hasAttemptedStartup;
+    this.hasAttemptedStartup = true;
+    let resolveStartupMetadata;
+    let rejectStartupMetadata;
+    this.startupMetadataPromise = new Promise((resolve, reject) => {
+      resolveStartupMetadata = resolve;
+      rejectStartupMetadata = reject;
+    });
+    void this.startupMetadataPromise.catch(() => void 0);
+    this.startPromise = (async () => {
+      const loadStartupMetadata = async (adapter) => {
+        if (lifecycleGeneration !== this.lifecycleGeneration) {
+          resolveStartupMetadata();
+          return false;
+        }
+        try {
+          await this.loadStartupMetadataInternal(lifecycleGeneration, adapter);
+          return lifecycleGeneration === this.lifecycleGeneration;
+        } catch (error) {
+          rejectStartupMetadata(error);
+          throw error;
+        }
+      };
+      let startup;
+      const scheduleStartupAsOneHydrate = this.persistence.adapter.runInHydrationScope !== void 0 && (!isRestart || (this.persistence.adapter.isHydrationScopeScheduled?.() ?? true));
+      if (scheduleStartupAsOneHydrate) {
+        startup = await this.applyMutex.run(async () => {
+          const result = await this.runInHydrationScope(async (adapter) => {
+            if (!await loadStartupMetadata(adapter)) return void 0;
+            return this.startInternal(
+              lifecycleGeneration,
+              adapter,
+              resolveStartupMetadata
+            );
+          });
+          if (lifecycleGeneration === this.lifecycleGeneration) {
+            await this.flushQueuedTxCommittedUnsafe();
+          }
+          return result;
+        });
+      } else {
+        if (await loadStartupMetadata(this.persistence.adapter)) {
+          if (this.persistence.adapter.isHydrationScopeScheduled?.()) {
+            startup = await this.applyMutex.run(async () => {
+              const result = await this.runInHydrationScope(
+                (adapter) => this.startInternal(
+                  lifecycleGeneration,
+                  adapter,
+                  resolveStartupMetadata
+                )
+              );
+              if (lifecycleGeneration === this.lifecycleGeneration) {
+                await this.flushQueuedTxCommittedUnsafe();
+              }
+              return result;
+            });
+          } else {
+            startup = await this.startInternal(
+              lifecycleGeneration,
+              this.persistence.adapter,
+              resolveStartupMetadata
+            );
+            if (lifecycleGeneration === this.lifecycleGeneration) {
+              await this.flushQueuedTxCommittedUnsafe();
+            }
+          }
+        }
+      }
+      if (startup !== void 0 && lifecycleGeneration === this.lifecycleGeneration) {
+        await this.requestCoordinatorPersistedIndexes(
+          startup.indexBootstrapSnapshot,
+          startup.completedLocalIndexSignatures
+        );
+        if (startup.appliedCursor !== void 0 && lifecycleGeneration === this.lifecycleGeneration) {
+          await this.waitForAppliedReceiptsAfter(startup.appliedCursor);
+        }
+      }
+      if (lifecycleGeneration === this.lifecycleGeneration) {
+        this.startupSettled = true;
+        this.persistedReadiness?.set({ status: `ready` });
+      }
+      resolveStartupMetadata();
+    })().catch((error) => {
+      rejectStartupMetadata(error);
+      throw this.markTerminalFailure(error, lifecycleGeneration);
+    });
+    void this.startPromise.catch(() => void 0);
     return this.startPromise;
   }
+  ensureResumeBaselineHydrated() {
+    this.throwIfTerminal();
+    if (this.resumeBaselinePromise) {
+      return this.resumeBaselinePromise;
+    }
+    const lifecycleGeneration = this.lifecycleGeneration;
+    this.resumeBaselinePromise = (async () => {
+      await this.ensureStarted();
+      if (lifecycleGeneration !== this.lifecycleGeneration) return;
+      if (this.syncMode !== `on-demand`) return;
+      const appliedCursor = await this.applyMutex.run(async () => {
+        const result = await this.runInHydrationScope(
+          (adapter) => this.hydrateBaseline(lifecycleGeneration, adapter)
+        );
+        if (lifecycleGeneration === this.lifecycleGeneration) {
+          await this.flushQueuedTxCommittedUnsafe();
+        }
+        return result;
+      });
+      if (appliedCursor !== void 0 && lifecycleGeneration === this.lifecycleGeneration) {
+        await this.waitForAppliedReceiptsAfter(appliedCursor);
+      }
+    })().catch((error) => {
+      throw this.markTerminalFailure(error, lifecycleGeneration);
+    });
+    return this.resumeBaselinePromise;
+  }
+  ensureResumeBaselineCertified() {
+    if (this.resumeCertificationPromise) {
+      return this.resumeCertificationPromise;
+    }
+    const lifecycleGeneration = this.lifecycleGeneration;
+    this.resumeCertificationPromise = (async () => {
+      await this.ensureStarted();
+      if (lifecycleGeneration !== this.lifecycleGeneration) return;
+      const snapshot = await this.persistence.adapter.loadResumeSnapshot(
+        this.collectionId,
+        {
+          requiredIndexSignatures: this.getRequiredIndexSignatures(),
+          includeRows: false
+        }
+      );
+      if (lifecycleGeneration !== this.lifecycleGeneration) return;
+      this.bindResumeSnapshotEvidence(snapshot);
+    })();
+    return this.resumeCertificationPromise;
+  }
+  getKeySetEvidence() {
+    return this.persistedKeySetEvidence;
+  }
+  getResumeGenerationOwner() {
+    return this.resumeGenerationOwner;
+  }
+  async hydrateBaseline(lifecycleGeneration, adapter) {
+    if (lifecycleGeneration !== this.lifecycleGeneration) return void 0;
+    const baseline = {};
+    this.activeSubsets.set(this.getSubsetKey(baseline), baseline);
+    const appliedCursor = this.appliedReceiptSequence;
+    await this.hydrateSubsetUnsafe(
+      baseline,
+      {
+        requestRemoteEnsure: false,
+        lifecycleGeneration,
+        bindKeySetEvidence: true
+      },
+      adapter
+    );
+    return lifecycleGeneration === this.lifecycleGeneration ? appliedCursor : void 0;
+  }
   async ensureStartupMetadataLoaded() {
+    this.throwIfTerminal();
     if (this.startupMetadataPromise) {
       return this.startupMetadataPromise;
     }
-    this.startupMetadataPromise = this.loadStartupMetadataInternal();
+    void this.ensureStarted();
     return this.startupMetadataPromise;
   }
-  async startInternal() {
-    if (this.started) {
-      return;
-    }
-    this.started = true;
-    await this.ensureStartupMetadataLoaded();
+  async startInternal(lifecycleGeneration, adapter, onStartupMetadataLoaded) {
+    if (lifecycleGeneration !== this.lifecycleGeneration) return void 0;
     const indexBootstrapSnapshot = this.collection?.getIndexMetadata() ?? [];
     this.attachIndexLifecycleListeners();
-    await this.bootstrapPersistedIndexes(indexBootstrapSnapshot);
-    if (this.syncMode !== `on-demand`) {
-      this.activeSubsets.set(this.getSubsetKey({}), {});
-      const appliedCursor = this.appliedReceiptSequence;
-      await this.applyMutex.run(
-        () => this.hydrateSubsetUnsafe({}, { requestRemoteEnsure: false })
-      );
-      await this.waitForAppliedReceiptsAfter(appliedCursor);
-    }
-  }
-  async loadStartupMetadataInternal() {
-    if (this.persistence.adapter.getStreamPosition) {
-      const position = await this.persistence.adapter.getStreamPosition(
-        this.collectionId
-      );
-      this.observeStreamPosition(
-        position.latestTerm,
-        position.latestSeq,
-        position.latestRowVersion
-      );
-    }
-    await this.loadCollectionMetadataIntoCollection();
-  }
-  async loadCollectionMetadataIntoCollection() {
-    const collectionMetadata = await this.loadCollectionMetadataSnapshot();
-    this.replaceCollectionMetadataSnapshot(collectionMetadata);
+    const completedLocalIndexSignatures = await this.bootstrapPersistedIndexes(
+      indexBootstrapSnapshot,
+      adapter
+    );
+    if (lifecycleGeneration !== this.lifecycleGeneration) return void 0;
+    onStartupMetadataLoaded();
+    const appliedCursor = this.syncMode !== `on-demand` ? await this.hydrateBaseline(lifecycleGeneration, adapter) : void 0;
+    return lifecycleGeneration === this.lifecycleGeneration ? {
+      appliedCursor,
+      indexBootstrapSnapshot,
+      completedLocalIndexSignatures
+    } : void 0;
+  }
+  async loadStartupMetadataInternal(lifecycleGeneration, adapter) {
+    const snapshot = await adapter.loadResumeSnapshot(this.collectionId, {
+      includeRows: false
+    });
+    if (lifecycleGeneration !== this.lifecycleGeneration) return;
+    this.persistedResumeGeneration = this.getResumeSnapshotGeneration(snapshot);
+    this.persistedKeySetEvidence = snapshot.keySet;
+    this.observeStreamPosition(
+      snapshot.latestTerm,
+      snapshot.latestSeq,
+      snapshot.latestRowVersion
+    );
+    const applied = this.replaceCollectionMetadataSnapshot(
+      snapshot.collectionMetadata
+    );
+    if (applied !== true) await applied;
   }
-  async loadCollectionMetadataSnapshot() {
-    if (!this.persistence.adapter.loadCollectionMetadata) {
+  async loadCollectionMetadataSnapshot(adapter) {
+    if (!adapter.loadCollectionMetadata) {
       return [];
     }
-    return this.persistence.adapter.loadCollectionMetadata(this.collectionId);
+    return adapter.loadCollectionMetadata(this.collectionId);
   }
   replaceCollectionMetadataSnapshot(collectionMetadata) {
     if (!this.syncControls.begin || !this.syncControls.commit || !this.syncControls.metadata) {
-      return;
+      return true;
     }
     const nextMetadata = new Map(
       collectionMetadata.map(({ key, value }) => [key, value])
     );
     const currentKeys = this.syncControls.metadata.collection.list().map(({ key }) => key);
-    this.withInternalApply(() => {
+    return this.withInternalApply(() => {
       this.syncControls.begin?.({ immediate: true });
       currentKeys.forEach((key) => {
         if (!nextMetadata.has(key)) {
@@ -372,49 +814,182 @@ class PersistedCollectionRuntime {
       nextMetadata.forEach((value, key) => {
         this.syncControls.metadata?.collection.set(key, value);
       });
-      this.syncControls.commit?.();
+      return this.syncControls.commit?.() ?? true;
     });
   }
   async loadSubset(options, upstreamLoadSubset) {
-    this.activeSubsets.set(this.getSubsetKey(options), options);
+    this.throwIfTerminal();
+    const lifecycleGeneration = this.lifecycleGeneration;
+    const subsetKey = this.getSubsetKey(options);
+    const truncateGeneration = this.sourceTruncateGeneration;
+    const routeRemoteDemandDuringHydration = this.canRouteRemoteDemandThroughCoordinator();
+    this.activeSubsets.set(subsetKey, options);
     const appliedCursor = this.appliedReceiptSequence;
-    await this.applyMutex.run(
-      () => this.hydrateSubsetUnsafe(options, {
-        requestRemoteEnsure: this.mode === `sync-present`
-      })
-    );
-    await this.waitForAppliedReceiptsAfter(appliedCursor);
-    if (upstreamLoadSubset) {
+    try {
+      await this.applyMutex.run(async () => {
+        try {
+          await this.runInHydrationScope(
+            (adapter) => this.hydrateSubsetUnsafe(
+              options,
+              {
+                requestRemoteEnsure: this.mode === `sync-present` && !routeRemoteDemandDuringHydration,
+                lifecycleGeneration,
+                requestLocalLoadFailure: true,
+                rejectBufferedReplayFailure: true
+              },
+              adapter
+            )
+          );
+        } finally {
+          if (lifecycleGeneration === this.lifecycleGeneration && !this.getCurrentTerminalFailure()) {
+            await this.flushQueuedTxCommittedUnsafe();
+          }
+        }
+      });
+      if (lifecycleGeneration !== this.lifecycleGeneration) return;
+      await this.waitForAppliedReceiptsAfter(appliedCursor);
+    } catch (error) {
+      if (this.activeSubsets.get(subsetKey) === options) {
+        this.activeSubsets.delete(subsetKey);
+      }
+      throw error;
+    }
+    if (options.signal?.aborted || this.activeSubsets.get(this.getSubsetKey(options)) !== options) {
+      return;
+    }
+    if (this.canRouteRemoteDemandThroughCoordinator()) {
       try {
-        await upstreamLoadSubset(options);
+        await this.persistence.coordinator.requestEnsureRemoteSubset(
+          this.collectionId,
+          options
+        );
       } catch (error) {
         if (options.signal?.aborted || typeof error === `object` && error !== null && `name` in error && error.name === `AbortError`) {
           this.pendingRemoteSubsetEnsures.delete(this.getSubsetKey(options));
           throw error;
         }
-        console.warn(`Failed to trigger remote subset load:`, error);
         this.queueRemoteSubsetEnsure(options);
+        throw error;
+      }
+      return;
+    }
+    if (truncateGeneration === this.sourceTruncateGeneration && this.activeSubsets.get(subsetKey) === options) {
+      this.hydratedDemands.add(getLoadSubsetDemandKey(options));
+    }
+    if (upstreamLoadSubset) {
+      try {
+        await upstreamLoadSubset(options);
+      } catch (error) {
+        this.noteUpstreamLoadFailure(options, error);
+        throw error;
       }
     }
   }
+  loadHydratedSubset(options, upstreamLoadSubset) {
+    const failure = this.getCurrentTerminalFailure();
+    if (failure) return Promise.reject(failure.error);
+    if (!this.startupSettled || this.isHydratingNow() || this.canRouteRemoteDemandThroughCoordinator() || options.refetch === true || !this.hydratedDemands.has(getLoadSubsetDemandKey(options))) {
+      return;
+    }
+    this.activeSubsets.set(this.getSubsetKey(options), options);
+    let result;
+    try {
+      result = upstreamLoadSubset?.(options) ?? true;
+    } catch (error) {
+      this.noteUpstreamLoadFailure(options, error);
+      return Promise.reject(error);
+    }
+    if (result === true) {
+      return true;
+    }
+    return result.then(
+      () => {
+        this.queueRemoteSubsetEnsure(options);
+      },
+      (error) => {
+        this.noteUpstreamLoadFailure(options, error);
+        throw error;
+      }
+    );
+  }
+  noteUpstreamLoadFailure(options, error) {
+    if (options.signal?.aborted || typeof error === `object` && error !== null && `name` in error && error.name === `AbortError`) {
+      this.pendingRemoteSubsetEnsures.delete(this.getSubsetKey(options));
+      return;
+    }
+    console.warn(`Failed to trigger remote subset load:`, error);
+    this.queueRemoteSubsetEnsure(options);
+  }
+  noteSourceTruncate() {
+    this.sourceTruncateGeneration++;
+    this.hydratedDemands.clear();
+  }
   unloadSubset(options, upstreamUnloadSubset) {
-    this.activeSubsets.delete(this.getSubsetKey(options));
-    this.pendingRemoteSubsetEnsures.delete(this.getSubsetKey(options));
-    upstreamUnloadSubset?.(options);
+    const subsetKey = this.getSubsetKey(options);
+    this.activeSubsets.delete(subsetKey);
+    this.pendingRemoteSubsetEnsures.delete(subsetKey);
+    const demandKey = getLoadSubsetDemandKey(options);
+    const stillActive = Array.from(this.activeSubsets.values()).some(
+      (active) => getLoadSubsetDemandKey(active) === demandKey
+    );
+    if (!stillActive) this.hydratedDemands.delete(demandKey);
+    if (this.mode === `sync-present`) {
+      void this.persistence.coordinator.requestReleaseRemoteSubset(this.collectionId, options).catch((error) => {
+        this.reportSyncError(error);
+      });
+    }
+    if (upstreamUnloadSubset) {
+      try {
+        const result = upstreamUnloadSubset(options);
+        void Promise.resolve(result).catch((error) => {
+          this.reportSyncError(error);
+        });
+      } catch (error) {
+        this.reportSyncError(error);
+      }
+    }
   }
   async forceReloadSubset(options) {
-    this.activeSubsets.set(this.getSubsetKey(options), options);
-    await this.applyMutex.run(
-      () => this.hydrateSubsetUnsafe(options, { requestRemoteEnsure: false })
-    );
+    this.throwIfTerminal();
+    const lifecycleGeneration = this.lifecycleGeneration;
+    await this.applyMutex.run(async () => {
+      await this.runInHydrationScope(
+        (adapter) => this.hydrateSubsetUnsafe(
+          options,
+          {
+            requestRemoteEnsure: false,
+            lifecycleGeneration,
+            rejectBufferedReplayFailure: true
+          },
+          adapter
+        )
+      );
+      if (lifecycleGeneration === this.lifecycleGeneration) {
+        await this.flushQueuedTxCommittedUnsafe();
+      }
+    });
   }
   queueHydrationBufferedTransaction(transaction) {
+    const failure = this.getCurrentTerminalFailure();
+    if (failure) {
+      transaction.rejectApplied?.(failure.error);
+      return;
+    }
     this.queuedHydrationTransactions.push(transaction);
   }
-  async persistAndBroadcastExternalSyncTransaction(transaction) {
-    await this.applyMutex.run(
-      () => this.persistAndBroadcastExternalSyncTransactionUnsafe(transaction)
-    );
+  applyHydrationBufferedTransaction(transaction) {
+    const failure = this.getCurrentTerminalFailure();
+    if (failure) return Promise.reject(failure.error);
+    if (transaction.beginOptions?.immediate && this.sourcePublicationWaitDepth > 0) {
+      return Promise.reject(
+        new InvalidPersistedCollectionConfigError(
+          `immediate persisted source replay cannot enter while an earlier source publication is waiting`
+        )
+      );
+    }
+    return this.applyMutex.run(async () => {
+      await this.applyBufferedSyncTransactionUnsafe(transaction);
+    });
   }
   normalizeSyncWriteMessage(message) {
     if (!this.collection) {
@@ -426,10 +1001,6 @@ class PersistedCollectionRuntime {
       const key2 = message.key;
       const previousValue = this.collection.get(key2) ?? {};
       return {
-        forwardMessage: {
-          type: `delete`,
-          key: key2
-        },
         operation: {
           type: `delete`,
           key: key2,
@@ -441,10 +1012,6 @@ class PersistedCollectionRuntime {
       const key2 = this.collection.getKeyFromItem(message.value);
       const previousValue = this.collection.get(key2) ?? message.value;
       return {
-        forwardMessage: {
-          type: `delete`,
-          key: key2
-        },
         operation: {
           type: `delete`,
           key: key2,
@@ -454,11 +1021,6 @@ class PersistedCollectionRuntime {
     }
     const key = this.collection.getKeyFromItem(message.value);
     return {
-      forwardMessage: {
-        type: `update`,
-        value: message.value,
-        metadata: message.metadata
-      },
       operation: {
         type: `update`,
         key,
@@ -467,25 +1029,45 @@ class PersistedCollectionRuntime {
       }
     };
   }
-  async persistAndConfirmCollectionMutations(mutations) {
+  async persistAndConfirmCollectionMutations(mutations, lifecycleGeneration = this.lifecycleGeneration) {
+    this.throwIfTerminal();
+    this.throwIfLifecycleReplaced(lifecycleGeneration);
     if (mutations.length === 0) {
       return;
     }
-    await this.applyMutex.run(async () => {
-      const acceptedMutationIds = await this.persistCollectionMutationsUnsafe(mutations);
-      const acceptedMutationIdSet = new Set(acceptedMutationIds);
-      const acceptedMutations = mutations.filter(
-        (mutation) => acceptedMutationIdSet.has(mutation.mutationId)
-      );
-      if (acceptedMutations.length !== mutations.length) {
-        throw new Error(
-          `persistence coordinator accepted ${acceptedMutations.length} of ${mutations.length} mutations; partial acceptance is not supported`
+    try {
+      await this.applyMutex.run(async () => {
+        await this.ensureStartupMetadataLoaded();
+        this.throwIfLifecycleReplaced(lifecycleGeneration);
+        const acceptedMutationIds = await this.persistCollectionMutationsUnsafe(
+          mutations,
+          lifecycleGeneration
+        );
+        this.throwIfLifecycleReplaced(lifecycleGeneration);
+        const acceptedMutationIdSet = new Set(acceptedMutationIds);
+        const acceptedMutations = mutations.filter(
+          (mutation) => acceptedMutationIdSet.has(mutation.mutationId)
         );
+        if (acceptedMutations.length !== mutations.length) {
+          throw new Error(
+            `persistence coordinator accepted ${acceptedMutations.length} of ${mutations.length} mutations; partial acceptance is not supported`
+          );
+        }
+        try {
+          await this.confirmMutationsSyncUnsafe(acceptedMutations);
+        } catch (error) {
+          throw this.markTerminalFailure(error, lifecycleGeneration);
+        }
+      });
+    } catch (error) {
+      if (error instanceof PersistedCollectionDurabilityError) {
+        throw this.markTerminalFailure(error, lifecycleGeneration);
       }
-      this.confirmMutationsSyncUnsafe(acceptedMutations);
-    });
+      throw error;
+    }
   }
   async acceptTransactionMutations(transaction) {
+    this.throwIfTerminal();
     const collectionMutations = this.filterMutationsForCollection(
       transaction.mutations
     );
@@ -495,11 +1077,34 @@ class PersistedCollectionRuntime {
     await this.persistAndConfirmCollectionMutations(collectionMutations);
   }
   cleanup() {
-    this.coordinatorUnsubscribe?.();
+    this.advanceLifecycle();
+    const remoteReleases = [];
+    const failures = [];
+    const attempt = (callback) => {
+      try {
+        callback();
+      } catch (error) {
+        failures.push(error);
+      }
+    };
+    if (this.mode === `sync-present`) {
+      for (const options of this.activeSubsets.values()) {
+        attempt(() => {
+          remoteReleases.push(
+            this.persistence.coordinator.requestReleaseRemoteSubset(this.collectionId, options).catch((error) => {
+              this.reportSyncError(error);
+            })
+          );
+        });
+      }
+    }
+    attempt(() => this.coordinatorUnsubscribe?.());
     this.coordinatorUnsubscribe = null;
-    this.indexAddedUnsubscribe?.();
+    attempt(() => this.remoteSubsetOwnerUnsubscribe?.());
+    this.remoteSubsetOwnerUnsubscribe = null;
+    attempt(() => this.indexAddedUnsubscribe?.());
     this.indexAddedUnsubscribe = null;
-    this.indexRemovedUnsubscribe?.();
+    attempt(() => this.indexRemovedUnsubscribe?.());
     this.indexRemovedUnsubscribe = null;
     if (this.remoteEnsureRetryTimer !== null) {
       clearTimeout(this.remoteEnsureRetryTimer);
@@ -507,12 +1112,36 @@ class PersistedCollectionRuntime {
     }
     this.pendingRemoteSubsetEnsures.clear();
     this.activeSubsets.clear();
+    this.hydratedDemands.clear();
     for (const transaction of this.queuedHydrationTransactions) {
       transaction.rejectApplied?.(new SyncTransactionAbortedError());
     }
     this.queuedHydrationTransactions.length = 0;
     this.queuedTxCommitted.length = 0;
     this.clearSyncControls();
+    this.collection = null;
+    return Promise.all(remoteReleases).then(() => {
+      if (failures.length === 1) throw failures[0];
+      if (failures.length > 1) {
+        throw new AggregateError(failures, `Persistence cleanup failed`, {
+          cause: failures[0]
+        });
+      }
+    });
+  }
+  advanceLifecycle() {
+    this.lifecycleGeneration++;
+    this.persistedReadiness?.set({ status: `loading` });
+    this.startupSettled = false;
+    this.hydratedDemands.clear();
+    this.startupMetadataPromise = null;
+    this.startPromise = null;
+    this.resumeBaselinePromise = null;
+    this.terminalFailure = void 0;
+    this.resumeCertificationPromise = null;
+    this.persistedKeySetEvidence = void 0;
+    this.persistedResumeGeneration = void 0;
+    this.resumeGenerationOwner = /* @__PURE__ */ Symbol(`persisted resume generation owner`);
   }
   withInternalApply(task) {
     this.internalApplyDepth++;
@@ -528,8 +1157,8 @@ class PersistedCollectionRuntime {
     }
     return this.collection.getIndexMetadata().map((metadata) => metadata.signature);
   }
-  loadSubsetRowsUnsafe(options) {
-    return this.persistence.adapter.loadSubset(this.collectionId, options, {
+  loadSubsetRowsUnsafe(options, adapter) {
+    return adapter.loadSubset(this.collectionId, options, {
       requiredIndexSignatures: this.getRequiredIndexSignatures()
     });
   }
@@ -543,27 +1172,184 @@ class PersistedCollectionRuntime {
     );
   }
   async scanPersistedRows(options) {
+    this.throwIfTerminal();
     return this.applyMutex.run(() => this.scanPersistedRowsUnsafe(options));
   }
-  async hydrateSubsetUnsafe(options, config) {
-    this.isHydrating = true;
+  async hydrateSubsetUnsafe(options, config, adapter) {
+    let rowsLoaded = false;
+    let replayFailure;
+    const resetSequence = this.resetSequence;
+    this.hydrationSequence++;
+    const hydrationContext = { suppliedRowKeys: /* @__PURE__ */ new Set() };
+    this.activeHydrationContext = hydrationContext;
     try {
-      const rows = await this.loadSubsetRowsUnsafe(options);
-      this.applyRowsToCollection(rows);
+      this.throwIfTerminal();
+      this.hydratingGeneration = config.lifecycleGeneration;
+      try {
+        let rows;
+        if (config.bindKeySetEvidence) {
+          const snapshot = await adapter.loadResumeSnapshot(this.collectionId, {
+            requiredIndexSignatures: this.getRequiredIndexSignatures(),
+            includeRows: true
+          });
+          rows = snapshot.rows;
+          if (config.lifecycleGeneration !== this.lifecycleGeneration) return;
+          if (resetSequence !== this.resetSequence) return;
+          this.bindResumeSnapshotEvidence(snapshot);
+        } else {
+          rows = await this.loadSubsetRowsUnsafe(options, adapter);
+        }
+        rowsLoaded = true;
+        if (config.lifecycleGeneration !== this.lifecycleGeneration) return;
+        if (resetSequence !== this.resetSequence) return;
+        if (!config.bindKeySetEvidence || this.persistedKeySetEvidence?.status !== `incompatible`) {
+          for (const row of rows) {
+            hydrationContext.suppliedRowKeys.add(row.key);
+          }
+          const applied = this.applyRowsToCollection(rows);
+          if (applied !== true) await applied;
+        }
+      } finally {
+        if (this.activeHydrationContext === hydrationContext && this.hydratingGeneration === config.lifecycleGeneration) {
+          this.hydratingGeneration = null;
+        }
+      }
+      if (config.lifecycleGeneration !== this.lifecycleGeneration) return;
+      replayFailure = await this.flushQueuedHydrationTransactionsUnsafe(adapter);
+      if (config.lifecycleGeneration !== this.lifecycleGeneration) return;
+      if (config.requestRemoteEnsure && !replayFailure) {
+        this.queueRemoteSubsetEnsure(options);
+      }
+    } catch (error) {
+      if (config.requestLocalLoadFailure && !rowsLoaded) {
+        this.hydratingGeneration = config.lifecycleGeneration;
+        try {
+          await this.recoverBufferedTransactionsAfterLocalLoadFailureUnsafe(
+            config.lifecycleGeneration,
+            adapter
+          );
+        } catch (baselineError) {
+          const terminalError = this.markTerminalFailure(
+            baselineError,
+            config.lifecycleGeneration
+          );
+          throw terminalError;
+        } finally {
+          if (this.hydratingGeneration === config.lifecycleGeneration) {
+            this.hydratingGeneration = null;
+          }
+        }
+        throw error;
+      }
+      throw this.markTerminalFailure(error, config.lifecycleGeneration);
     } finally {
-      this.isHydrating = false;
+      if (this.activeHydrationContext === hydrationContext) {
+        this.activeHydrationContext = void 0;
+      }
+    }
+    if (replayFailure && config.rejectBufferedReplayFailure) {
+      throw replayFailure.reason;
     }
-    await this.flushQueuedHydrationTransactionsUnsafe();
-    await this.flushQueuedTxCommittedUnsafe();
-    if (config.requestRemoteEnsure) {
-      this.queueRemoteSubsetEnsure(options);
+  }
+  async recoverBufferedTransactionsAfterLocalLoadFailureUnsafe(lifecycleGeneration, adapter) {
+    let snapshotRows;
+    const recoveredPresence = /* @__PURE__ */ new Map();
+    let snapshotInvalidatedByTruncate = false;
+    while (this.queuedHydrationTransactions.length > 0) {
+      const transaction = this.queuedHydrationTransactions.shift();
+      if (!transaction) continue;
+      try {
+        this.throwIfLifecycleReplaced(lifecycleGeneration);
+        const baselineRows = /* @__PURE__ */ new Map();
+        const transactionPresence = /* @__PURE__ */ new Map();
+        const transactionStartsWithTruncate = transaction.truncate;
+        const getPresence = (key) => {
+          const known = transactionPresence.get(key);
+          if (known !== void 0) return known;
+          if (transactionStartsWithTruncate) {
+            transactionPresence.set(key, `absent`);
+            return `absent`;
+          }
+          const recovered = recoveredPresence.get(key);
+          if (recovered !== void 0) {
+            transactionPresence.set(key, recovered);
+            return recovered;
+          }
+          const present = this.collection?._hasHydratedKey(key) === true ? `present` : snapshotInvalidatedByTruncate ? `absent` : `unknown`;
+          transactionPresence.set(key, present);
+          return present;
+        };
+        if (!transaction.signal?.aborted) {
+          for (const [index, operation] of transaction.operations.entries()) {
+            const key = operation.key;
+            if (operation.type === `update` && transaction.partialUpdateOperationIndexes.has(index) && getPresence(key) === `unknown`) {
+              if (snapshotRows === void 0) {
+                const snapshot = await adapter.loadResumeSnapshot(
+                  this.collectionId,
+                  {
+                    requiredIndexSignatures: this.getRequiredIndexSignatures(),
+                    includeRows: true
+                  }
+                );
+                this.throwIfLifecycleReplaced(lifecycleGeneration);
+                if (transaction.signal?.aborted) break;
+                snapshotRows = new Map(
+                  snapshot.rows.map((row) => [row.key, row])
+                );
+              }
+              const baseline = snapshotRows.get(key);
+              if (baseline === void 0) {
+                transactionPresence.set(key, `absent`);
+              } else {
+                baselineRows.set(key, baseline);
+                transactionPresence.set(key, `present`);
+              }
+            }
+            transactionPresence.set(
+              key,
+              operation.type === `delete` ? `absent` : `present`
+            );
+          }
+          if (baselineRows.size > 0) {
+            if (!transaction.signal?.aborted) {
+              transaction.prependHydrationRows([...baselineRows.values()]);
+            }
+          }
+        }
+        const transactionOutcome = await this.applyBufferedSyncTransactionUnsafe(transaction, adapter);
+        if (transactionOutcome.applied) {
+          if (transaction.truncate) {
+            snapshotInvalidatedByTruncate = true;
+            recoveredPresence.clear();
+          }
+          for (const operation of transaction.operations) {
+            recoveredPresence.set(
+              operation.key,
+              operation.type === `delete` ? `absent` : `present`
+            );
+          }
+        }
+      } catch (error) {
+        transaction.rejectApplied?.(error);
+        for (const abandoned of this.queuedHydrationTransactions) {
+          abandoned.rejectApplied?.(error);
+        }
+        this.queuedHydrationTransactions.length = 0;
+        throw error;
+      }
+    }
+  }
+  rejectQueuedHydrationTransactions(error) {
+    for (const transaction of this.queuedHydrationTransactions) {
+      transaction.rejectApplied?.(error);
     }
+    this.queuedHydrationTransactions.length = 0;
   }
   applyRowsToCollection(rows) {
     if (!this.syncControls.begin || !this.syncControls.write || !this.syncControls.commit) {
-      return;
+      return true;
     }
-    this.withInternalApply(() => {
+    return this.withInternalApply(() => {
       this.syncControls.begin?.({ immediate: true });
       for (const row of rows) {
         if (this.collection?._hasHydratedKey(row.key)) {
@@ -575,18 +1361,41 @@ class PersistedCollectionRuntime {
           metadata: row.metadata
         });
       }
-      this.syncControls.commit?.();
+      return this.syncControls.commit?.() ?? true;
     });
   }
+  getResumeSnapshotGeneration(snapshot) {
+    return {
+      latestTerm: snapshot.latestTerm,
+      latestSeq: snapshot.latestSeq,
+      latestRowVersion: snapshot.latestRowVersion,
+      resetEpoch: snapshot.resetEpoch
+    };
+  }
+  isExpectedResumeGeneration(generation) {
+    const expected = this.persistedResumeGeneration;
+    return expected !== void 0 && expected.latestTerm === generation.latestTerm && expected.latestSeq === generation.latestSeq && expected.latestRowVersion === generation.latestRowVersion && expected.resetEpoch === generation.resetEpoch;
+  }
+  bindResumeSnapshotEvidence(snapshot) {
+    const generation = this.getResumeSnapshotGeneration(snapshot);
+    const previousEvidenceStatus = this.persistedKeySetEvidence?.status;
+    const mayAcceptUnownedGeneration = this.mode === `sync-present` && previousEvidenceStatus !== `consistent` && previousEvidenceStatus !== `incompatible` || this.mode === `sync-absent` && previousEvidenceStatus === `consistent` && snapshot.keySet?.status === `consistent`;
+    this.observeStreamPosition(
+      snapshot.latestTerm,
+      snapshot.latestSeq,
+      snapshot.latestRowVersion
+    );
+    this.persistedKeySetEvidence = this.isExpectedResumeGeneration(generation) || mayAcceptUnownedGeneration ? snapshot.keySet : { status: `incompatible` };
+  }
   replaceCollectionSnapshot(rows, collectionMetadata) {
     if (!this.syncControls.begin || !this.syncControls.write || !this.syncControls.commit || !this.syncControls.metadata) {
-      return;
+      return true;
     }
     const nextMetadata = new Map(
       collectionMetadata.map(({ key, value }) => [key, value])
     );
     const currentKeys = this.syncControls.metadata.collection.list().map(({ key }) => key);
-    this.withInternalApply(() => {
+    return this.withInternalApply(() => {
       this.syncControls.begin?.({ immediate: true });
       this.syncControls.truncate?.();
       for (const row of rows) {
@@ -604,17 +1413,22 @@ class PersistedCollectionRuntime {
       nextMetadata.forEach((value, key) => {
         this.syncControls.metadata?.collection.set(key, value);
       });
-      this.syncControls.commit?.();
+      return this.syncControls.commit?.() ?? true;
     });
   }
-  async flushQueuedHydrationTransactionsUnsafe() {
+  async flushQueuedHydrationTransactionsUnsafe(adapter) {
+    let operationFailure;
     while (this.queuedHydrationTransactions.length > 0) {
       const transaction = this.queuedHydrationTransactions.shift();
       if (!transaction) {
         continue;
       }
       try {
-        await this.applyBufferedSyncTransactionUnsafe(transaction);
+        const outcome = await this.applyBufferedSyncTransactionUnsafe(
+          transaction,
+          adapter
+        );
+        operationFailure ??= outcome.hydrationFailure;
       } catch (error) {
         transaction.rejectApplied?.(error);
         for (const abandoned of this.queuedHydrationTransactions) {
@@ -624,103 +1438,126 @@ class PersistedCollectionRuntime {
         throw error;
       }
     }
+    return operationFailure;
   }
-  async applyBufferedSyncTransactionUnsafe(transaction) {
-    if (transaction.signal?.aborted) {
-      transaction.rejectApplied?.(new SyncTransactionAbortedError());
-      return;
-    }
-    const { begin, write, commit, truncate, metadata } = this.syncControls;
-    if (!begin || !write || !commit) {
-      transaction.rejectApplied?.(new SyncTransactionAbortedError());
-      return;
-    }
-    const applyToCollection = () => {
-      begin();
-      if (transaction.truncate) {
-        truncate?.();
-      }
-      for (const operation of transaction.operations) {
-        if (operation.type === `delete`) {
-          write({
-            type: `delete`,
-            key: operation.key
-          });
-        } else {
-          write({
-            type: `update`,
-            value: operation.value,
-            metadata: operation.metadata
-          });
-        }
-      }
-      for (const [key, metadataWrite] of transaction.rowMetadataWrites) {
-        if (metadataWrite.type === `delete`) {
-          metadata?.row.delete(key);
-        } else {
-          metadata?.row.set(key, metadataWrite.value);
-        }
-      }
-      for (const [key, metadataWrite] of transaction.collectionMetadataWrites) {
-        if (metadataWrite.type === `delete`) {
-          metadata?.collection.delete(key);
-        } else {
-          metadata?.collection.set(key, metadataWrite.value);
-        }
-      }
-      return commit(transaction.signal);
-    };
+  async applyBufferedSyncTransactionUnsafe(transaction, scopedAdapter) {
+    this.throwIfTerminal();
+    this.throwIfLifecycleReplaced(transaction.lifecycleGeneration);
+    const abortedBeforeApplication = transaction.signal?.aborted === true;
+    let abortedDuringApplication = false;
+    let applicationReturned = false;
     try {
-      const applied = transaction.internal ? this.withInternalApply(applyToCollection) : applyToCollection();
+      const applied = transaction.internal ? this.withInternalApply(transaction.applyToCollection) : transaction.applyToCollection();
+      applicationReturned = true;
+      abortedDuringApplication = transaction.signal?.aborted === true;
       if (applied !== true) {
-        await applied;
+        this.sourcePublicationWaitDepth++;
+        try {
+          await applied;
+        } finally {
+          this.sourcePublicationWaitDepth--;
+        }
       }
+      this.throwIfLifecycleReplaced(transaction.lifecycleGeneration);
       if (!transaction.internal) {
-        await this.persistAndBroadcastExternalSyncTransactionUnsafe(transaction);
+        await this.persistAndBroadcastExternalSyncTransactionUnsafe(
+          transaction,
+          scopedAdapter
+        );
       }
       transaction.resolveApplied?.();
+      return { applied: true };
     } catch (error) {
-      transaction.rejectApplied?.(error);
-      throw error;
+      if (!applicationReturned) {
+        abortedDuringApplication = transaction.signal?.aborted === true;
+      }
+      const aborted = transaction.signal?.aborted || error instanceof SyncTransactionAbortedError;
+      const shouldFailStop = aborted && transaction.shouldFailStopOnAbort?.() === true;
+      const terminalError = this.classifyBufferedTransactionFailure(
+        transaction,
+        error
+      );
+      transaction.rejectApplied?.(terminalError);
+      if (aborted && !shouldFailStop && transaction.rejectApplied) {
+        return {
+          applied: false,
+          hydrationFailure: !abortedBeforeApplication && abortedDuringApplication ? { reason: terminalError } : void 0
+        };
+      }
+      throw terminalError;
+    }
+  }
+  classifyBufferedTransactionFailure(transaction, error) {
+    if (error instanceof PersistedCollectionDurabilityError) {
+      return this.markTerminalFailure(error, transaction.lifecycleGeneration);
+    }
+    const aborted = transaction.signal?.aborted || error instanceof SyncTransactionAbortedError;
+    if (aborted && transaction.shouldFailStopOnAbort?.() !== true) {
+      return error;
     }
+    return this.markTerminalFailure(error, transaction.lifecycleGeneration);
   }
-  async persistAndBroadcastExternalSyncTransactionUnsafe(transaction) {
+  async persistAndBroadcastExternalSyncTransactionUnsafe(transaction, scopedAdapter) {
     if (transaction.internal) {
       return;
     }
-    const streamPosition = this.nextLocalStreamPosition();
+    this.throwIfLifecycleReplaced(transaction.lifecycleGeneration);
     if (!transaction.truncate && transaction.operations.length === 0 && transaction.rowMetadataWrites.size === 0 && transaction.collectionMetadataWrites.size === 0) {
-      this.publishTxCommittedEvent(
-        this.createTxCommittedPayload({
-          term: streamPosition.term,
-          seq: streamPosition.seq,
-          txId: safeRandomUUID(),
-          latestRowVersion: streamPosition.rowVersion,
-          changedRows: [],
-          deletedKeys: [],
-          requiresFullReload: true
-        })
-      );
       return;
     }
+    const streamPosition = this.nextLocalStreamPosition();
     const tx = this.createPersistedTxFromOperations(transaction, streamPosition);
-    await this.persistence.adapter.applyCommittedTx(this.collectionId, tx);
-    this.publishTxCommittedEvent(
-      this.createTxCommittedPayload({
-        term: tx.term,
-        seq: tx.seq,
-        txId: tx.txId,
-        latestRowVersion: tx.rowVersion,
-        requiresFullReload: transaction.truncate,
-        changedRows: transaction.operations.filter((operation) => operation.type === `update`).map((operation) => ({
-          key: operation.key,
-          value: operation.value
-        })),
-        deletedKeys: transaction.operations.filter((operation) => operation.type === `delete`).map((operation) => operation.key),
-        rowMetadataMutations: tx.rowMetadataMutations,
-        collectionMetadataMutations: tx.collectionMetadataMutations
-      })
+    const response = await this.persistence.coordinator.requestApplyCommittedTx(
+      this.collectionId,
+      tx,
+      // A hydration-scoped adapter is already inside the shared scheduler.
+      // Ordinary source commits pass no scoped adapter so the coordinator
+      // enters that scheduler before taking the database-wide writer lock.
+      scopedAdapter
+    );
+    if (!response.ok) {
+      if (response.code === `PERSISTENCE_ERROR`) {
+        const error = new PersistedCollectionDurabilityError(
+          `Failed to durably persist collection "${this.collectionId}": ${response.error}`,
+          {
+            cause: response,
+            code: response.sourceCode ?? response.code,
+            path: response.path
+          }
+        );
+        throw error;
+      }
+      throw new Error(
+        `failed to apply external sync transaction through coordinator: ${response.error}`
+      );
+    }
+    if (transaction.lifecycleGeneration !== this.lifecycleGeneration) return;
+    this.observeStreamPosition(
+      response.term,
+      response.seq,
+      response.latestRowVersion
     );
+    if (transaction.expectedResumeGenerationOwner === this.resumeGenerationOwner && this.persistedResumeGeneration !== void 0) {
+      this.persistedResumeGeneration = {
+        ...this.persistedResumeGeneration,
+        latestTerm: response.term,
+        latestSeq: response.seq,
+        latestRowVersion: response.latestRowVersion
+      };
+    }
+  }
+  async applyCommittedTx(tx, lifecycleGeneration) {
+    this.throwIfTerminal();
+    this.throwIfLifecycleReplaced(lifecycleGeneration);
+    try {
+      await this.persistence.adapter.applyCommittedTx(this.collectionId, tx);
+    } catch (error) {
+      throw this.markTerminalFailure(
+        toPersistedCollectionDurabilityError(this.collectionId, error),
+        lifecycleGeneration
+      );
+    }
+    this.throwIfLifecycleReplaced(lifecycleGeneration);
   }
   createPersistedTxFromOperations(transaction, streamPosition) {
     return {
@@ -785,11 +1622,11 @@ class PersistedCollectionRuntime {
       })
     };
   }
-  confirmMutationsSyncUnsafe(mutations) {
+  async confirmMutationsSyncUnsafe(mutations) {
     if (!this.syncControls.begin || !this.syncControls.write || !this.syncControls.commit) {
       return;
     }
-    this.withInternalApply(() => {
+    const applied = this.withInternalApply(() => {
       this.syncControls.begin?.({ immediate: true });
       for (const mutation of mutations) {
         if (mutation.type === `delete`) {
@@ -804,8 +1641,11 @@ class PersistedCollectionRuntime {
           });
         }
       }
-      this.syncControls.commit?.();
+      return this.syncControls.commit?.() ?? true;
     });
+    if (applied !== true) {
+      await applied;
+    }
   }
   filterMutationsForCollection(mutations) {
     const collection = this.collection;
@@ -816,7 +1656,8 @@ class PersistedCollectionRuntime {
       return mutation.collection.id === this.collectionId;
     });
   }
-  async persistCollectionMutationsUnsafe(mutations) {
+  async persistCollectionMutationsUnsafe(mutations, lifecycleGeneration) {
+    this.throwIfLifecycleReplaced(lifecycleGeneration);
     if (this.persistence.coordinator.requestApplyLocalMutations) {
       const envelopeMutations = mutations.map(
         (mutation) => toPersistedMutationEnvelope(
@@ -827,7 +1668,19 @@ class PersistedCollectionRuntime {
         this.collectionId,
         envelopeMutations
       );
+      this.throwIfLifecycleReplaced(lifecycleGeneration);
       if (!response.ok) {
+        if (response.code === `PERSISTENCE_ERROR`) {
+          const error = new PersistedCollectionDurabilityError(
+            `Failed to durably persist collection "${this.collectionId}": ${response.error}`,
+            {
+              cause: response,
+              code: response.sourceCode ?? response.code,
+              path: response.path
+            }
+          );
+          throw error;
+        }
         throw new Error(
           `failed to apply local mutations through coordinator: ${response.error}`
         );
@@ -855,7 +1708,8 @@ class PersistedCollectionRuntime {
     }
     const streamPosition = this.nextLocalStreamPosition();
     const tx = this.createPersistedTxFromMutations(mutations, streamPosition);
-    await this.persistence.adapter.applyCommittedTx(this.collectionId, tx);
+    await this.applyCommittedTx(tx, lifecycleGeneration);
+    this.throwIfLifecycleReplaced(lifecycleGeneration);
     this.publishTxCommittedEvent(
       this.createTxCommittedPayload({
         term: tx.term,
@@ -945,28 +1799,30 @@ class PersistedCollectionRuntime {
     };
   }
   getSubsetKey(options) {
-    const subscription = options.subscription;
-    if (subscription && typeof subscription === `object`) {
-      const existingId = this.subscriptionIds.get(subscription);
-      if (existingId) {
-        return existingId;
-      }
-      this.nextSubscriptionId++;
-      const id = `sub:${this.nextSubscriptionId}`;
-      this.subscriptionIds.set(subscription, id);
-      return id;
+    let id = this.requestIds.get(options);
+    if (id === void 0) {
+      id = `request:${++this.nextRequestId}`;
+      this.requestIds.set(options, id);
+    }
+    return id;
+  }
+  canRouteRemoteDemandThroughCoordinator() {
+    if (this.getCurrentTerminalFailure() || this.mode !== `sync-present` || this.persistence.coordinator instanceof SingleProcessCoordinator) {
+      return false;
     }
-    return `opts:${stableSerialize(normalizeSubsetOptionsForKey(options))}`;
+    return !this.persistence.coordinator.isLeader(this.collectionId) || this.remoteSubsetOwnerUnsubscribe !== null;
   }
   queueRemoteSubsetEnsure(options) {
-    if (this.mode !== `sync-present` || !this.persistence.coordinator.requestEnsureRemoteSubset || this.activeSubsets.get(this.getSubsetKey(options)) !== options) {
+    if (options.signal?.aborted || !this.canRouteRemoteDemandThroughCoordinator() || this.activeSubsets.get(this.getSubsetKey(options)) !== options) {
       return;
     }
-    this.pendingRemoteSubsetEnsures.set(this.getSubsetKey(options), options);
+    const subsetKey = this.getSubsetKey(options);
+    if (this.activeSubsets.get(subsetKey) !== options) return;
+    this.pendingRemoteSubsetEnsures.set(subsetKey, options);
     void this.flushPendingRemoteSubsetEnsures();
   }
   scheduleRemoteEnsureRetry() {
-    if (this.mode !== `sync-present` || !this.persistence.coordinator.requestEnsureRemoteSubset) {
+    if (this.getCurrentTerminalFailure() || this.mode !== `sync-present` || this.persistence.coordinator instanceof SingleProcessCoordinator) {
       return;
     }
     if (this.pendingRemoteSubsetEnsures.size === 0 || this.remoteEnsureRetryTimer !== null) {
@@ -978,7 +1834,7 @@ class PersistedCollectionRuntime {
     }, REMOTE_ENSURE_RETRY_DELAY_MS);
   }
   async flushPendingRemoteSubsetEnsures() {
-    if (this.mode !== `sync-present` || !this.persistence.coordinator.requestEnsureRemoteSubset) {
+    if (this.getCurrentTerminalFailure() || this.mode !== `sync-present` || this.persistence.coordinator instanceof SingleProcessCoordinator) {
       return;
     }
     if (this.remoteEnsureRetryTimer !== null) {
@@ -986,6 +1842,10 @@ class PersistedCollectionRuntime {
       this.remoteEnsureRetryTimer = null;
     }
     for (const [subsetKey, options] of this.pendingRemoteSubsetEnsures) {
+      if (options.signal?.aborted || this.activeSubsets.get(subsetKey) !== options) {
+        this.pendingRemoteSubsetEnsures.delete(subsetKey);
+        continue;
+      }
       try {
         await this.persistence.coordinator.requestEnsureRemoteSubset(
           this.collectionId,
@@ -993,7 +1853,11 @@ class PersistedCollectionRuntime {
         );
         this.pendingRemoteSubsetEnsures.delete(subsetKey);
       } catch (error) {
-        console.warn(`Failed to ensure remote subset:`, error);
+        if (options.signal?.aborted || this.activeSubsets.get(subsetKey) !== options) {
+          this.pendingRemoteSubsetEnsures.delete(subsetKey);
+        } else {
+          console.warn(`Failed to ensure remote subset:`, error);
+        }
       }
     }
     this.scheduleRemoteEnsureRetry();
@@ -1002,6 +1866,10 @@ class PersistedCollectionRuntime {
     if (this.coordinatorUnsubscribe) {
       return;
     }
+    this.persistence.coordinator.setAdapterForCollection?.(
+      this.collectionId,
+      this.persistence.adapter
+    );
     this.coordinatorUnsubscribe = this.persistence.coordinator.subscribe(
       this.collectionId,
       (message) => {
@@ -1013,15 +1881,22 @@ class PersistedCollectionRuntime {
     if (message.collectionId !== this.collectionId) {
       return;
     }
+    if (this.getCurrentTerminalFailure()) {
+      return;
+    }
     const { payload } = message;
+    const lifecycleGeneration = this.lifecycleGeneration;
     const isSelf = message.senderId === this.persistence.coordinator.getNodeId();
     if (isTxCommittedPayload(payload)) {
-      if (this.isHydrating) {
-        this.queuedTxCommitted.push(payload);
+      if (this.isHydratingNow()) {
+        this.queuedTxCommitted.push({
+          txCommitted: payload,
+          lifecycleGeneration
+        });
         return;
       }
-      void this.applyMutex.run(() => this.processCommittedTxUnsafe(payload)).catch((error) => {
-        console.warn(`Failed to process tx:committed message:`, error);
+      void this.applyMutex.run(() => this.processCommittedTxUnsafe(payload, lifecycleGeneration)).catch((error) => {
+        this.markTerminalFailure(error, lifecycleGeneration);
       });
       return;
     }
@@ -1029,8 +1904,15 @@ class PersistedCollectionRuntime {
       return;
     }
     if (isCollectionResetPayload(payload)) {
-      void this.applyMutex.run(() => this.truncateAndReloadUnsafe()).catch((error) => {
-        console.warn(`Failed to process collection reset message:`, error);
+      void this.applyMutex.run(async () => {
+        await this.runInHydrationScope(
+          (adapter) => this.truncateAndReloadUnsafe(adapter, lifecycleGeneration)
+        );
+        if (lifecycleGeneration === this.lifecycleGeneration) {
+          await this.flushQueuedTxCommittedUnsafe();
+        }
+      }).catch((error) => {
+        this.markTerminalFailure(error, lifecycleGeneration);
       });
     }
   }
@@ -1040,10 +1922,14 @@ class PersistedCollectionRuntime {
       if (!queued) {
         continue;
       }
-      await this.processCommittedTxUnsafe(queued);
+      await this.processCommittedTxUnsafe(
+        queued.txCommitted,
+        queued.lifecycleGeneration
+      );
     }
   }
-  async processCommittedTxUnsafe(txCommitted) {
+  async processCommittedTxUnsafe(txCommitted, lifecycleGeneration = this.lifecycleGeneration) {
+    if (lifecycleGeneration !== this.lifecycleGeneration) return;
     if (txCommitted.term < this.latestTerm) {
       return;
     }
@@ -1054,7 +1940,8 @@ class PersistedCollectionRuntime {
     const hasGapAcrossTerms = txCommitted.term > this.latestTerm && txCommitted.seq > 1;
     const hasGap = hasGapInCurrentTerm || hasGapAcrossTerms;
     if (hasGap) {
-      await this.recoverFromSeqGapUnsafe();
+      await this.recoverFromSeqGapUnsafe(lifecycleGeneration);
+      if (lifecycleGeneration !== this.lifecycleGeneration) return;
       if (txCommitted.term < this.latestTerm || txCommitted.term === this.latestTerm && txCommitted.seq <= this.latestSeq) {
         return;
       }
@@ -1064,70 +1951,109 @@ class PersistedCollectionRuntime {
       txCommitted.seq,
       txCommitted.latestRowVersion
     );
-    await this.invalidateFromCommittedTxUnsafe(txCommitted);
+    await this.invalidateFromCommittedTxUnsafe(
+      txCommitted,
+      this.persistence.adapter
+    );
+    if (lifecycleGeneration === this.lifecycleGeneration) {
+      await this.flushQueuedTxCommittedUnsafe();
+    }
   }
-  async recoverFromSeqGapUnsafe() {
+  async recoverFromSeqGapUnsafe(lifecycleGeneration) {
+    if (lifecycleGeneration !== this.lifecycleGeneration) return;
     if (this.persistence.coordinator.pullSince && this.latestRowVersion >= 0) {
+      let pullResponse;
       try {
-        const pullResponse = await this.persistence.coordinator.pullSince(
+        pullResponse = await this.persistence.coordinator.pullSince(
           this.collectionId,
           this.latestRowVersion
         );
+      } catch (error) {
+        console.warn(`Failed pullSince recovery attempt:`, error);
+      }
+      if (pullResponse) {
+        if (lifecycleGeneration !== this.lifecycleGeneration) return;
         if (pullResponse.ok) {
           this.observeStreamPosition(
             pullResponse.latestTerm,
             pullResponse.latestSeq,
             pullResponse.latestRowVersion
           );
-          if (pullResponse.requiresFullReload || !pullResponse.deltas) {
-            await this.reloadActiveSubsetsUnsafe();
+          if (pullResponse.requiresFullReload) {
+            await this.runInHydrationScope(
+              (adapter) => this.reloadActiveSubsetsUnsafe(adapter)
+            );
             return;
           }
-          for (const delta of pullResponse.deltas) {
-            await this.invalidateFromCommittedTxUnsafe({
-              type: `tx:committed`,
-              term: pullResponse.latestTerm,
-              seq: pullResponse.latestSeq,
-              txId: delta.txId,
-              latestRowVersion: delta.latestRowVersion,
-              requiresFullReload: false,
-              changedRows: delta.changedRows,
-              deletedKeys: delta.deletedKeys,
-              rowMetadataMutations: delta.rowMetadataMutations,
-              collectionMetadataMutations: delta.collectionMetadataMutations
-            });
+          const deltas = pullResponse.deltas;
+          if (!deltas) {
+            await this.runInHydrationScope(
+              (adapter) => this.reloadActiveSubsetsUnsafe(adapter)
+            );
+            return;
           }
+          await this.runInHydrationScope(async (adapter) => {
+            for (const delta of deltas) {
+              if (lifecycleGeneration !== this.lifecycleGeneration) return;
+              await this.invalidateFromCommittedTxUnsafe(
+                {
+                  type: `tx:committed`,
+                  term: pullResponse.latestTerm,
+                  seq: pullResponse.latestSeq,
+                  txId: delta.txId,
+                  latestRowVersion: delta.latestRowVersion,
+                  requiresFullReload: false,
+                  changedRows: delta.changedRows,
+                  deletedKeys: delta.deletedKeys,
+                  rowMetadataMutations: delta.rowMetadataMutations,
+                  collectionMetadataMutations: delta.collectionMetadataMutations
+                },
+                adapter
+              );
+              if (lifecycleGeneration !== this.lifecycleGeneration) return;
+            }
+          });
           return;
         }
-      } catch (error) {
-        console.warn(`Failed pullSince recovery attempt:`, error);
       }
     }
-    await this.truncateAndReloadUnsafe();
+    if (lifecycleGeneration !== this.lifecycleGeneration) return;
+    await this.runInHydrationScope(
+      (adapter) => this.truncateAndReloadUnsafe(adapter, lifecycleGeneration)
+    );
     if (this.mode === `sync-present`) {
       for (const options of this.activeSubsets.values()) {
         this.queueRemoteSubsetEnsure(options);
       }
     }
   }
-  async truncateAndReloadUnsafe() {
+  async truncateAndReloadUnsafe(adapter, lifecycleGeneration = this.lifecycleGeneration) {
+    if (lifecycleGeneration !== this.lifecycleGeneration) return;
+    this.hydratedDemands.clear();
+    this.resetSequence++;
     if (this.syncControls.begin && this.syncControls.commit) {
-      this.withInternalApply(() => {
+      const applied = this.withInternalApply(() => {
         this.syncControls.begin?.({ immediate: true });
         this.syncControls.truncate?.();
-        this.syncControls.commit?.();
+        return this.syncControls.commit?.() ?? true;
       });
+      if (applied !== true) await applied;
     }
-    await this.reloadActiveSubsetsUnsafe();
+    if (lifecycleGeneration !== this.lifecycleGeneration) return;
+    await this.reloadActiveSubsetsUnsafe(adapter);
   }
-  async invalidateFromCommittedTxUnsafe(txCommitted) {
+  async invalidateFromCommittedTxUnsafe(txCommitted, adapter) {
+    const reloadActiveSubsets = () => this.runInHydrationScope(
+      (scopedAdapter) => this.reloadActiveSubsetsUnsafe(scopedAdapter),
+      adapter
+    );
     if (txCommitted.requiresFullReload) {
-      await this.reloadActiveSubsetsUnsafe();
+      await reloadActiveSubsets();
       return;
     }
     const changedKeyCount = txCommitted.changedRows.length + txCommitted.deletedKeys.length;
     if (changedKeyCount > TARGETED_INVALIDATION_KEY_LIMIT) {
-      await this.reloadActiveSubsetsUnsafe();
+      await reloadActiveSubsets();
       return;
     }
     const hasPaginatedSubset = Array.from(this.activeSubsets.values()).some(
@@ -1137,13 +2063,13 @@ class PersistedCollectionRuntime {
       await this.applyTargetedInvalidationUnsafe(txCommitted);
       return;
     }
-    await this.reloadActiveSubsetsUnsafe();
+    await reloadActiveSubsets();
   }
   async applyTargetedInvalidationUnsafe(txCommitted) {
     const subsetEvaluators = Array.from(this.activeSubsets.values()).map(
       (opt) => opt.where ? compileSingleRowExpression(opt.where) : null
     );
-    this.withInternalApply(() => {
+    const applied = this.withInternalApply(() => {
       this.syncControls.begin?.({ immediate: true });
       for (const {
         key: changedKey,
@@ -1182,17 +2108,26 @@ class PersistedCollectionRuntime {
           );
         }
       });
-      this.syncControls.commit?.();
+      return this.syncControls.commit?.() ?? true;
     });
+    if (applied !== true) await applied;
   }
-  async reloadActiveSubsetsUnsafe() {
+  async reloadActiveSubsetsUnsafe(adapter) {
+    const lifecycleGeneration = this.lifecycleGeneration;
+    const truncateGeneration = this.sourceTruncateGeneration;
     const activeSubsetOptions = this.activeSubsets.size > 0 ? Array.from(this.activeSubsets.values()) : [{}];
-    this.isHydrating = true;
+    this.hydratedDemands.clear();
+    this.hydrationSequence++;
+    const hydrationContext = { suppliedRowKeys: /* @__PURE__ */ new Set() };
+    this.activeHydrationContext = hydrationContext;
+    this.hydratingGeneration = lifecycleGeneration;
     try {
       const mergedRows = /* @__PURE__ */ new Map();
-      const collectionMetadata = await this.loadCollectionMetadataSnapshot();
+      const collectionMetadata = await this.loadCollectionMetadataSnapshot(adapter);
+      if (lifecycleGeneration !== this.lifecycleGeneration) return;
       for (const options of activeSubsetOptions) {
-        const subsetRows = await this.loadSubsetRowsUnsafe(options);
+        const subsetRows = await this.loadSubsetRowsUnsafe(options, adapter);
+        if (lifecycleGeneration !== this.lifecycleGeneration) return;
         for (const row of subsetRows) {
           mergedRows.set(row.key, {
             value: row.value,
@@ -1200,7 +2135,10 @@ class PersistedCollectionRuntime {
           });
         }
       }
-      this.replaceCollectionSnapshot(
+      for (const key of mergedRows.keys()) {
+        hydrationContext.suppliedRowKeys.add(key);
+      }
+      const applied = this.replaceCollectionSnapshot(
         Array.from(mergedRows.entries()).map(([key, row]) => ({
           key,
           value: row.value,
@@ -1208,11 +2146,25 @@ class PersistedCollectionRuntime {
         })),
         collectionMetadata
       );
+      if (applied !== true) await applied;
     } finally {
-      this.isHydrating = false;
+      if (this.activeHydrationContext === hydrationContext && this.hydratingGeneration === lifecycleGeneration) {
+        this.hydratingGeneration = null;
+      }
+      if (this.activeHydrationContext === hydrationContext) {
+        this.activeHydrationContext = void 0;
+      }
+    }
+    if (lifecycleGeneration === this.lifecycleGeneration) {
+      await this.flushQueuedHydrationTransactionsUnsafe(adapter);
+      if (truncateGeneration === this.sourceTruncateGeneration && this.queuedTxCommitted.length === 0) {
+        for (const options of activeSubsetOptions) {
+          if (this.activeSubsets.get(this.getSubsetKey(options)) === options) {
+            this.hydratedDemands.add(getLoadSubsetDemandKey(options));
+          }
+        }
+      }
     }
-    await this.flushQueuedHydrationTransactionsUnsafe();
-    await this.flushQueuedTxCommittedUnsafe();
   }
   attachIndexLifecycleListeners() {
     if (!this.collection || this.indexAddedUnsubscribe || this.indexRemovedUnsubscribe) {
@@ -1228,14 +2180,26 @@ class PersistedCollectionRuntime {
       }
     );
   }
-  async bootstrapPersistedIndexes(indexMetadataSnapshot) {
+  async bootstrapPersistedIndexes(indexMetadataSnapshot, adapter = this.persistence.adapter) {
     const collection = this.collection;
     if (!collection && !indexMetadataSnapshot) {
-      return;
+      return /* @__PURE__ */ new Set();
     }
     const indexMetadata = indexMetadataSnapshot ?? collection?.getIndexMetadata() ?? [];
+    const completedLocalIndexSignatures = /* @__PURE__ */ new Set();
     for (const metadata of indexMetadata) {
-      await this.ensurePersistedIndex(metadata);
+      if (await this.ensureLocalPersistedIndex(metadata, adapter)) {
+        completedLocalIndexSignatures.add(metadata.signature);
+      }
+    }
+    return completedLocalIndexSignatures;
+  }
+  async requestCoordinatorPersistedIndexes(indexMetadata, completedLocalIndexSignatures) {
+    for (const metadata of indexMetadata) {
+      await this.requestCoordinatorPersistedIndex(
+        metadata,
+        completedLocalIndexSignatures.has(metadata.signature)
+      );
     }
   }
   buildPersistedIndexSpec(index) {
@@ -1248,22 +2212,36 @@ class PersistedCollectionRuntime {
       }
     };
   }
-  async ensurePersistedIndex(indexMetadata) {
+  async ensurePersistedIndex(indexMetadata, adapter = this.persistence.adapter) {
+    const completedLocally = await this.ensureLocalPersistedIndex(
+      indexMetadata,
+      adapter
+    );
+    await this.requestCoordinatorPersistedIndex(indexMetadata, completedLocally);
+  }
+  async ensureLocalPersistedIndex(indexMetadata, adapter) {
     const spec = this.buildPersistedIndexSpec(indexMetadata);
     try {
-      await this.persistence.adapter.ensureIndex(
+      await adapter.ensureIndex(
         this.collectionId,
         indexMetadata.signature,
         spec
       );
+      return true;
     } catch (error) {
       console.warn(`Failed to ensure persisted index in adapter:`, error);
+      return false;
     }
+  }
+  async requestCoordinatorPersistedIndex(indexMetadata, completedLocally) {
+    const spec = this.buildPersistedIndexSpec(indexMetadata);
     try {
       await this.persistence.coordinator.requestEnsurePersistedIndex(
         this.collectionId,
         indexMetadata.signature,
-        spec
+        spec,
+        completedLocally ? this.persistence.adapter : void 0,
+        completedLocally
       );
     } catch (error) {
       console.warn(
@@ -1286,65 +2264,327 @@ class PersistedCollectionRuntime {
     }
   }
 }
-function createWrappedSyncConfig(sourceSyncConfig, runtime) {
+function createWrappedSyncConfig(sourceSyncConfig, runtime, persistedReadiness) {
   return {
     ...sourceSyncConfig,
     sync: (params) => {
       const transactionStack = [];
+      const pendingPublicationTransactions = [];
       const getOpenTransaction = () => transactionStack[transactionStack.length - 1];
+      const settlePublicationAdmissionWaiters = (transaction, error) => {
+        const waiters = transaction.publicationAdmissionWaiters;
+        transaction.publicationAdmissionWaiters = void 0;
+        if (!waiters) return;
+        for (const waiter of waiters) {
+          if (error === void 0) waiter.resolve();
+          else waiter.reject(error);
+        }
+      };
+      const bindToCurrentHydration = (transaction) => {
+        if (transaction.internal || !runtime.isHydratingNow()) return;
+        const hydrationSequence = runtime.getHydrationSequence();
+        if (transaction.hydrationSequence !== void 0 && transaction.hydrationSequence !== hydrationSequence) {
+          throw new InvalidPersistedCollectionConfigError(
+            `a persisted sync transaction cannot cross a hydration cycle`
+          );
+        }
+        transaction.queuedBecauseHydrating = true;
+        transaction.hydrationSequence = hydrationSequence;
+        transaction.hydrationContext = runtime.getActiveHydrationContext();
+      };
+      const assertHydrationSequenceCurrent = (transaction) => {
+        if (transaction.hydrationSequence !== void 0 && transaction.hydrationSequence !== runtime.getHydrationSequence()) {
+          throw new InvalidPersistedCollectionConfigError(
+            `a persisted sync transaction cannot cross a hydration cycle`
+          );
+        }
+      };
+      const markPendingMetadataDependency = (transaction) => {
+        const openTransaction = getOpenTransaction();
+        if (openTransaction && !openTransaction.internal) {
+          transaction.hasDependentSuccessor = true;
+        }
+      };
+      const removePendingPublicationTransaction = (transaction) => {
+        const index = pendingPublicationTransactions.indexOf(transaction);
+        if (index !== -1) pendingPublicationTransactions.splice(index, 1);
+      };
+      const settlePendingTransaction = (transaction) => {
+        removePendingPublicationTransaction(transaction);
+      };
+      const settleRuntimeTransaction = (transaction, applied) => {
+        void applied.then(
+          () => settlePendingTransaction(transaction),
+          () => {
+            settlePendingTransaction(transaction);
+          }
+        );
+      };
+      const getPendingRowMetadataWrite = (key) => {
+        for (let index = pendingPublicationTransactions.length - 1; index >= 0; index--) {
+          const transaction = pendingPublicationTransactions[index];
+          const write = transaction.rowMetadataWrites.get(key);
+          if (write) {
+            markPendingMetadataDependency(transaction);
+            return { found: true, write };
+          }
+          if (transaction.truncate) {
+            markPendingMetadataDependency(transaction);
+            return {
+              found: true,
+              write: { type: `delete` }
+            };
+          }
+        }
+        return { found: false };
+      };
+      const getPendingCollectionMetadataWrite = (key) => {
+        for (let index = pendingPublicationTransactions.length - 1; index >= 0; index--) {
+          const transaction = pendingPublicationTransactions[index];
+          const write = transaction.collectionMetadataWrites.get(key);
+          if (write) {
+            markPendingMetadataDependency(transaction);
+            return { found: true, write };
+          }
+        }
+        return { found: false };
+      };
       let fullStartPromise = null;
+      let sourceResultPromise = null;
+      let resolveSourceResultAssigned;
+      const sourceResultAssigned = new Promise((resolve) => {
+        resolveSourceResultAssigned = resolve;
+      });
+      const startupState = { cleanedUp: false };
+      const isCleanedUp = () => startupState.cleanedUp;
       const acquisitions = /* @__PURE__ */ new Map();
+      const waitForPublicationAdmission = (transaction, options, acquisition) => {
+        if (options.signal?.aborted) {
+          return Promise.reject(
+            options.signal.reason ?? new SyncTransactionAbortedError()
+          );
+        }
+        return new Promise((resolve, reject) => {
+          const waiters = transaction.publicationAdmissionWaiters ?? (transaction.publicationAdmissionWaiters = /* @__PURE__ */ new Set());
+          let settled = false;
+          const settle = (action) => {
+            if (settled) return;
+            settled = true;
+            waiters.delete(waiter);
+            options.signal?.removeEventListener(`abort`, abort);
+            acquisition.cancelAdmissionWait = void 0;
+            action();
+          };
+          const waiter = {
+            resolve: () => settle(resolve),
+            reject: (error) => settle(() => reject(error))
+          };
+          const abort = () => waiter.reject(
+            options.signal?.reason ?? new SyncTransactionAbortedError()
+          );
+          waiters.add(waiter);
+          options.signal?.addEventListener(`abort`, abort, { once: true });
+          acquisition.cancelAdmissionWait = waiter.resolve;
+        });
+      };
+      const getTerminalFailure = () => runtime.getCurrentTerminalFailure();
+      const reportUpstreamError = (error) => {
+        if (persistedReadiness?.getSnapshot().status !== `loading`) {
+          runtime.reportSyncError(error);
+          return;
+        }
+        void (fullStartPromise ?? runtime.ensureStarted()).then(
+          () => {
+            if (!isCleanedUp() && !getTerminalFailure()) {
+              runtime.reportSyncError(error);
+            }
+          },
+          () => void 0
+        );
+      };
+      const createHandledRejection = (error) => {
+        const rejected = Promise.reject(error);
+        void rejected.catch(() => void 0);
+        return rejected;
+      };
+      const applyTransactionToCollection = (transaction, signal) => {
+        if (transaction.applicationReceipt !== void 0) {
+          return transaction.applicationReceipt;
+        }
+        try {
+          assertHydrationSequenceCurrent(transaction);
+          for (const key of transaction.deferredHydrationMetadataDeleteKeys) {
+            if (!transaction.hydrationContext?.suppliedRowKeys.has(key) && !transaction.rowMetadataWrites.has(key)) {
+              transaction.rowMetadataWrites.set(key, { type: `delete` });
+            }
+          }
+          transaction.deferredHydrationMetadataDeleteKeys.clear();
+          params.begin(
+            transaction.queuedBecauseHydrating ? { immediate: true } : transaction.beginOptions
+          );
+          if (transaction.truncate) params.truncate();
+          for (const operation of transaction.operations) {
+            if (operation.type === `delete`) {
+              params.write({ type: `delete`, key: operation.key });
+            } else {
+              params.write({
+                type: `update`,
+                value: operation.value,
+                metadata: operation.metadata
+              });
+            }
+          }
+          if (params.metadata) {
+            for (const [key, write] of transaction.rowMetadataWrites) {
+              if (write.type === `delete`) params.metadata.row.delete(key);
+              else params.metadata.row.set(key, write.value);
+            }
+            for (const [key, write] of transaction.collectionMetadataWrites) {
+              if (write.type === `delete`)
+                params.metadata.collection.delete(key);
+              else params.metadata.collection.set(key, write.value);
+            }
+          }
+          const applied = params.commit(signal);
+          transaction.applicationReceipt = applied;
+          if (applied === true) {
+            removePendingPublicationTransaction(transaction);
+          } else {
+            void applied.then(
+              () => removePendingPublicationTransaction(transaction),
+              () => removePendingPublicationTransaction(transaction)
+            );
+          }
+          return applied;
+        } catch (error) {
+          removePendingPublicationTransaction(transaction);
+          throw error;
+        }
+      };
       runtime.setSyncControls({
         begin: params.begin,
         write: params.write,
         commit: params.commit,
         truncate: params.truncate,
-        metadata: params.metadata ?? null
+        metadata: params.metadata ?? null,
+        markError: params.markError
       });
       runtime.setCollection(
         params.collection
       );
+      const persistenceCapability = {
+        protocol: SYNC_PERSISTENCE_PROTOCOL,
+        version: SYNC_PERSISTENCE_VERSION,
+        hydrateBaseline: async () => {
+          if (startupState.cleanedUp) return;
+          try {
+            await runtime.ensureResumeBaselineHydrated();
+          } catch (error) {
+            throw runtime.reportSyncError(error);
+          }
+        },
+        scanPersistedRows: (options) => startupState.cleanedUp ? Promise.resolve([]) : runtime.scanPersistedRows(options),
+        resumeSnapshot: {
+          certify: async () => {
+            if (startupState.cleanedUp) return;
+            try {
+              await runtime.ensureResumeBaselineCertified();
+            } catch (error) {
+              throw runtime.reportSyncError(error);
+            }
+          },
+          getKeySetEvidence: () => startupState.cleanedUp ? void 0 : runtime.getKeySetEvidence(),
+          expectCurrentCommit: () => {
+            if (startupState.cleanedUp) return;
+            const openTransaction = getOpenTransaction();
+            if (!openTransaction) {
+              throw new InvalidPersistedCollectionConfigError(
+                `resumeSnapshot.expectCurrentCommit must be called within an open sync transaction`
+              );
+            }
+            openTransaction.expectedResumeGenerationOwner = runtime.getResumeGenerationOwner();
+          }
+        }
+      };
       const wrappedParams = {
         ...params,
+        markError: reportUpstreamError,
         markReady: () => {
-          void (fullStartPromise ?? runtime.ensureStarted()).then(() => {
-            params.markReady();
-          }).catch((error) => {
-            console.warn(
-              `Failed persisted sync startup before markReady:`,
-              error
-            );
+          if (startupState.cleanedUp || getTerminalFailure()) return;
+          void (fullStartPromise ?? runtime.ensureStarted()).then(async () => {
+            if (isCleanedUp() || getTerminalFailure()) return;
+            await sourceResultAssigned;
+            try {
+              await sourceResultPromise;
+            } catch (error) {
+              reportUpstreamError(error);
+              return;
+            }
+            if (isCleanedUp() || getTerminalFailure()) return;
             params.markReady();
-          });
+          }).catch(() => void 0);
         },
         begin: (options) => {
+          if (startupState.cleanedUp) return void 0;
+          const terminalFailure = getTerminalFailure();
+          const internal = runtime.isApplyingInternally();
           const transaction = {
             operations: [],
+            partialUpdateOperationIndexes: /* @__PURE__ */ new Set(),
             rowMetadataWrites: /* @__PURE__ */ new Map(),
             collectionMetadataWrites: /* @__PURE__ */ new Map(),
+            deferredHydrationMetadataDeleteKeys: /* @__PURE__ */ new Set(),
             truncate: false,
-            internal: runtime.isApplyingInternally(),
-            queuedBecauseHydrating: !runtime.isApplyingInternally() && runtime.isHydratingNow()
+            internal,
+            lifecycleGeneration: runtime.getLifecycleGeneration(),
+            beginOptions: options,
+            operationKeys: /* @__PURE__ */ new Set(),
+            hasDependentSuccessor: false,
+            queuedBecauseHydrating: terminalFailure === void 0 && !internal && runtime.isHydratingNow(),
+            hydrationSequence: terminalFailure === void 0 && !internal ? runtime.getHydrationSequence() : void 0,
+            hydrationContext: terminalFailure === void 0 && !internal && runtime.isHydratingNow() ? runtime.getActiveHydrationContext() : void 0,
+            ...terminalFailure === void 0 ? {} : { terminalFailure }
           };
           transactionStack.push(transaction);
-          if (!transaction.queuedBecauseHydrating) {
-            params.begin(options);
-          }
         },
         write: (message) => {
-          const normalization = runtime.normalizeSyncWriteMessage(message);
+          if (startupState.cleanedUp) return;
           const openTransaction = getOpenTransaction();
-          if (!openTransaction) {
-            params.write(normalization.forwardMessage);
+          const terminalFailure = openTransaction?.terminalFailure ?? getTerminalFailure();
+          if (terminalFailure) {
+            if (openTransaction)
+              openTransaction.terminalFailure = terminalFailure;
             return;
           }
+          if (!openTransaction) {
+            throw new NoPendingSyncTransactionWriteError();
+          }
+          bindToCurrentHydration(openTransaction);
+          const normalization = runtime.normalizeSyncWriteMessage(message);
+          if (message.type === `update` && sourceSyncConfig.rowUpdateMode !== `full`) {
+            if (!openTransaction.internal) {
+              openTransaction.partialUpdateOperationIndexes.add(
+                openTransaction.operations.length
+              );
+            }
+            for (const pending of pendingPublicationTransactions) {
+              if (pending.truncate || pending.operationKeys.has(normalization.operation.key)) {
+                markPendingMetadataDependency(pending);
+              }
+            }
+          }
           openTransaction.operations.push(normalization.operation);
+          openTransaction.operationKeys.add(normalization.operation.key);
           if (normalization.operation.type === `delete`) {
             openTransaction.rowMetadataWrites.set(normalization.operation.key, {
               type: `delete`
             });
           } else if (message.type === `insert` && normalization.operation.metadata === void 0) {
-            if (!openTransaction.rowMetadataWrites.has(
+            if (openTransaction.queuedBecauseHydrating) {
+              openTransaction.deferredHydrationMetadataDeleteKeys.add(
+                normalization.operation.key
+              );
+            } else if (!openTransaction.rowMetadataWrites.has(
               normalization.operation.key
             )) {
               openTransaction.rowMetadataWrites.set(
@@ -1360,13 +2600,12 @@ function createWrappedSyncConfig(sourceSyncConfig, runtime) {
               value: normalization.operation.metadata
             });
           }
-          if (!openTransaction.queuedBecauseHydrating) {
-            params.write(normalization.forwardMessage);
-          }
         },
         metadata: params.metadata ? {
+          persistence: persistenceCapability,
           row: {
             get: (key) => {
+              if (startupState.cleanedUp) return void 0;
               const openTransaction = getOpenTransaction();
               const pendingWrite = openTransaction?.rowMetadataWrites.get(key);
               if (pendingWrite) {
@@ -1375,11 +2614,17 @@ function createWrappedSyncConfig(sourceSyncConfig, runtime) {
               if (openTransaction?.truncate) {
                 return void 0;
               }
+              const pending = getPendingRowMetadataWrite(key);
+              if (pending.found) {
+                return pending.write.type === `delete` ? void 0 : pending.write.value;
+              }
               return params.metadata.row.get(key);
             },
-            scanPersisted: (options) => runtime.scanPersistedRows(options),
             set: (key, value) => {
+              if (startupState.cleanedUp) return;
               const openTransaction = getOpenTransaction();
+              if (openTransaction?.terminalFailure ?? getTerminalFailure())
+                return;
               if (!openTransaction) {
                 throw new InvalidPersistedCollectionConfigError(
                   `metadata.row.set must be called within an open sync transaction`
@@ -1389,12 +2634,12 @@ function createWrappedSyncConfig(sourceSyncConfig, runtime) {
                 type: `set`,
                 value
               });
-              if (!openTransaction.queuedBecauseHydrating) {
-                params.metadata.row.set(key, value);
-              }
             },
             delete: (key) => {
+              if (startupState.cleanedUp) return;
               const openTransaction = getOpenTransaction();
+              if (openTransaction?.terminalFailure ?? getTerminalFailure())
+                return;
               if (!openTransaction) {
                 throw new InvalidPersistedCollectionConfigError(
                   `metadata.row.delete must be called within an open sync transaction`
@@ -1403,22 +2648,27 @@ function createWrappedSyncConfig(sourceSyncConfig, runtime) {
               openTransaction.rowMetadataWrites.set(key, {
                 type: `delete`
               });
-              if (!openTransaction.queuedBecauseHydrating) {
-                params.metadata.row.delete(key);
-              }
             }
           },
           collection: {
             get: (key) => {
+              if (startupState.cleanedUp) return void 0;
               const openTransaction = getOpenTransaction();
               const pendingWrite = openTransaction?.collectionMetadataWrites.get(key);
               if (pendingWrite) {
                 return pendingWrite.type === `delete` ? void 0 : pendingWrite.value;
               }
+              const pending = getPendingCollectionMetadataWrite(key);
+              if (pending.found) {
+                return pending.write.type === `delete` ? void 0 : pending.write.value;
+              }
               return params.metadata.collection.get(key);
             },
             set: (key, value) => {
+              if (startupState.cleanedUp) return;
               const openTransaction = getOpenTransaction();
+              if (openTransaction?.terminalFailure ?? getTerminalFailure())
+                return;
               if (!openTransaction) {
                 throw new InvalidPersistedCollectionConfigError(
                   `metadata.collection.set must be called within an open sync transaction`
@@ -1428,12 +2678,12 @@ function createWrappedSyncConfig(sourceSyncConfig, runtime) {
                 type: `set`,
                 value
               });
-              if (!openTransaction.queuedBecauseHydrating) {
-                params.metadata.collection.set(key, value);
-              }
             },
             delete: (key) => {
+              if (startupState.cleanedUp) return;
               const openTransaction = getOpenTransaction();
+              if (openTransaction?.terminalFailure ?? getTerminalFailure())
+                return;
               if (!openTransaction) {
                 throw new InvalidPersistedCollectionConfigError(
                   `metadata.collection.delete must be called within an open sync transaction`
@@ -1442,14 +2692,31 @@ function createWrappedSyncConfig(sourceSyncConfig, runtime) {
               openTransaction.collectionMetadataWrites.set(key, {
                 type: `delete`
               });
-              if (!openTransaction.queuedBecauseHydrating) {
-                params.metadata.collection.delete(key);
-              }
             },
             list: (prefix) => {
+              if (startupState.cleanedUp) return [];
               const merged = new Map(
                 params.metadata.collection.list().map(({ key, value }) => [key, value])
               );
+              const pendingOwners = /* @__PURE__ */ new Map();
+              for (const transaction of pendingPublicationTransactions) {
+                for (const [
+                  key,
+                  metadataWrite
+                ] of transaction.collectionMetadataWrites) {
+                  if (!prefix || key.startsWith(prefix)) {
+                    pendingOwners.set(key, transaction);
+                  }
+                  if (metadataWrite.type === `delete`) {
+                    merged.delete(key);
+                  } else {
+                    merged.set(key, metadataWrite.value);
+                  }
+                }
+              }
+              for (const owner of new Set(pendingOwners.values())) {
+                markPendingMetadataDependency(owner);
+              }
               const openTransaction = getOpenTransaction();
               if (openTransaction) {
                 for (const [
@@ -1471,29 +2738,92 @@ function createWrappedSyncConfig(sourceSyncConfig, runtime) {
           }
         } : void 0,
         truncate: () => {
+          if (startupState.cleanedUp) return;
+          runtime.noteSourceTruncate();
           const openTransaction = getOpenTransaction();
+          if (openTransaction?.terminalFailure ?? getTerminalFailure()) return;
           if (!openTransaction) {
-            params.truncate();
-            return;
+            throw new NoPendingSyncTransactionWriteError();
           }
           openTransaction.operations = [];
+          openTransaction.operationKeys.clear();
+          openTransaction.partialUpdateOperationIndexes.clear();
           openTransaction.rowMetadataWrites.clear();
+          openTransaction.deferredHydrationMetadataDeleteKeys.clear();
           openTransaction.truncate = true;
-          if (!openTransaction.queuedBecauseHydrating) {
-            params.truncate();
-          }
         },
         commit: (signal) => {
+          if (startupState.cleanedUp) return true;
           const openTransaction = transactionStack.pop();
+          const terminalFailure = openTransaction?.terminalFailure ?? getTerminalFailure();
+          if (terminalFailure) {
+            if (openTransaction) {
+              settlePendingTransaction(openTransaction);
+              settlePublicationAdmissionWaiters(
+                openTransaction,
+                terminalFailure.error
+              );
+            }
+            return createHandledRejection(terminalFailure.error);
+          }
           if (!openTransaction) {
-            return params.commit(signal);
+            throw new NoPendingSyncTransactionCommitError();
           }
-          if (openTransaction.queuedBecauseHydrating) {
-            if (signal?.aborted) {
-              const aborted = Promise.reject(new SyncTransactionAbortedError());
-              void aborted.catch(() => void 0);
-              return aborted;
-            }
+          if (openTransaction.internal) {
+            return applyTransactionToCollection(openTransaction, signal);
+          }
+          if (signal?.aborted) {
+            settlePendingTransaction(openTransaction);
+            const error = new SyncTransactionAbortedError();
+            settlePublicationAdmissionWaiters(openTransaction, error);
+            return createHandledRejection(error);
+          }
+          try {
+            bindToCurrentHydration(openTransaction);
+            assertHydrationSequenceCurrent(openTransaction);
+          } catch (error) {
+            settlePublicationAdmissionWaiters(openTransaction, error);
+            throw error;
+          }
+          const transaction = {
+            operations: openTransaction.operations,
+            partialUpdateOperationIndexes: openTransaction.partialUpdateOperationIndexes,
+            rowMetadataWrites: openTransaction.rowMetadataWrites,
+            collectionMetadataWrites: openTransaction.collectionMetadataWrites,
+            deferredHydrationMetadataDeleteKeys: openTransaction.deferredHydrationMetadataDeleteKeys,
+            hydrationContext: openTransaction.hydrationContext,
+            hydrationSequence: openTransaction.hydrationSequence,
+            truncate: openTransaction.truncate,
+            internal: false,
+            lifecycleGeneration: openTransaction.lifecycleGeneration,
+            beginOptions: openTransaction.beginOptions,
+            expectedResumeGenerationOwner: openTransaction.expectedResumeGenerationOwner,
+            signal,
+            prependHydrationRows: (rows) => {
+              const baselineOperations = rows.map(({ key, value, metadata }) => ({
+                type: `update`,
+                key,
+                value,
+                metadata
+              }));
+              openTransaction.operations = baselineOperations.concat(
+                openTransaction.operations
+              );
+              for (const { key, metadata } of rows) {
+                if (metadata !== void 0 && !openTransaction.rowMetadataWrites.has(key)) {
+                  openTransaction.rowMetadataWrites.set(key, {
+                    type: `set`,
+                    value: metadata
+                  });
+                }
+              }
+            },
+            applyToCollection: () => applyTransactionToCollection(openTransaction, signal),
+            shouldFailStopOnAbort: () => openTransaction.hasDependentSuccessor
+          };
+          openTransaction.signal = signal;
+          pendingPublicationTransactions.push(openTransaction);
+          if (openTransaction.queuedBecauseHydrating && runtime.isHydratingNow()) {
             let resolveApplied;
             let rejectApplied;
             const applied2 = new Promise((resolve, reject) => {
@@ -1502,66 +2832,118 @@ function createWrappedSyncConfig(sourceSyncConfig, runtime) {
             });
             void applied2.catch(() => void 0);
             runtime.queueHydrationBufferedTransaction({
-              operations: openTransaction.operations,
-              rowMetadataWrites: openTransaction.rowMetadataWrites,
-              collectionMetadataWrites: openTransaction.collectionMetadataWrites,
-              truncate: openTransaction.truncate,
-              internal: openTransaction.internal,
-              signal,
+              ...transaction,
               resolveApplied,
               rejectApplied
             });
+            settlePublicationAdmissionWaiters(openTransaction);
+            settleRuntimeTransaction(openTransaction, applied2);
             return applied2;
           }
-          const applied = params.commit(signal);
-          if (!openTransaction.internal) {
-            const persistAfterApplication = async () => {
-              if (applied !== true) await applied;
-              await runtime.persistAndBroadcastExternalSyncTransaction({
-                operations: openTransaction.operations,
-                rowMetadataWrites: openTransaction.rowMetadataWrites,
-                collectionMetadataWrites: openTransaction.collectionMetadataWrites,
-                truncate: openTransaction.truncate,
-                internal: false
-              });
-            };
-            const persisted = persistAfterApplication();
-            void persisted.catch(() => void 0);
-            return persisted;
+          let applied;
+          try {
+            applied = runtime.applyHydrationBufferedTransaction(transaction);
+          } catch (error) {
+            settlePublicationAdmissionWaiters(openTransaction, error);
+            throw error;
           }
+          settlePublicationAdmissionWaiters(openTransaction);
+          settleRuntimeTransaction(openTransaction, applied);
           return applied;
         }
       };
       let sourceResult = {};
-      const startupState = { cleanedUp: false };
+      let sourceResultSettled = false;
+      let activeSourceSyncEntry;
       fullStartPromise = runtime.ensureStarted();
-      const sourceResultPromise = (async () => {
+      void fullStartPromise.catch(() => void 0);
+      sourceResultPromise = (async () => {
         await runtime.ensureStartupMetadataLoaded();
         if (startupState.cleanedUp) {
+          sourceResultSettled = true;
           return sourceResult;
         }
-        sourceResult = normalizeSyncFnResult(
-          sourceSyncConfig.sync(wrappedParams)
-        );
+        let settleSourceSyncEntry;
+        activeSourceSyncEntry = new Promise((resolve) => {
+          settleSourceSyncEntry = resolve;
+        });
+        try {
+          sourceResult = normalizeSyncFnResult(
+            sourceSyncConfig.sync(wrappedParams)
+          );
+        } finally {
+          activeSourceSyncEntry = void 0;
+          settleSourceSyncEntry();
+        }
+        if (!startupState.cleanedUp && sourceResult.loadSubset) {
+          const loadSubset = async (options) => {
+            if (startupState.cleanedUp) {
+              throw new Error(`persisted sync source is no longer active`);
+            }
+            await sourceResult.loadSubset?.(
+              options
+            );
+          };
+          runtime.registerRemoteSubsetOwner(
+            Object.assign(loadSubset, {
+              unloadSubset: (options) => sourceResult.unloadSubset?.(
+                options
+              ),
+              onError: reportUpstreamError
+            })
+          );
+        }
+        sourceResultSettled = true;
         return sourceResult;
       })();
+      resolveSourceResultAssigned();
+      void sourceResultPromise.catch((error) => {
+        reportUpstreamError(error);
+      });
       return {
-        cleanup: () => {
+        cleanup: async () => {
           startupState.cleanedUp = true;
+          const sourceSyncEntry = activeSourceSyncEntry;
+          const cleanupError = new SyncTransactionAbortedError();
+          for (const acquisition of acquisitions.values()) {
+            acquisition.cancelAdmissionWait?.();
+          }
           acquisitions.clear();
-          sourceResult.cleanup?.();
-          runtime.cleanup();
-          runtime.clearSyncControls();
+          pendingPublicationTransactions.length = 0;
+          for (const transaction of transactionStack) {
+            settlePublicationAdmissionWaiters(transaction, cleanupError);
+          }
+          transactionStack.length = 0;
+          let sourceCleanup;
+          try {
+            sourceCleanup = sourceSyncEntry ? sourceSyncEntry.then(() => sourceResult.cleanup?.()) : Promise.resolve(sourceResult.cleanup?.());
+          } catch (error) {
+            sourceCleanup = Promise.reject(error);
+          }
+          let runtimeCleanup;
+          try {
+            runtimeCleanup = runtime.cleanup();
+          } catch (error) {
+            runtimeCleanup = Promise.reject(error);
+          }
+          const [sourceOutcome, runtimeOutcome] = await Promise.allSettled([
+            sourceCleanup,
+            runtimeCleanup
+          ]);
+          if (sourceOutcome.status === `rejected` && runtimeOutcome.status === `rejected`) {
+            throw new AggregateError(
+              [sourceOutcome.reason, runtimeOutcome.reason],
+              `Source cleanup and persistence runtime teardown both failed`,
+              { cause: sourceOutcome.reason }
+            );
+          }
+          if (sourceOutcome.status === `rejected`) throw sourceOutcome.reason;
+          if (runtimeOutcome.status === `rejected`) throw runtimeOutcome.reason;
         },
-        loadSubset: async (options) => {
+        loadSubset: (options) => {
           const acquisition = { forwarded: false };
           acquisitions.set(options, acquisition);
-          await fullStartPromise;
-          const resolvedSourceResult = await sourceResultPromise;
-          if (startupState.cleanedUp || acquisitions.get(options) !== acquisition) {
-            return;
-          }
-          return runtime.loadSubset(options, (loadOptions) => {
+          const forwardUpstream = (resolvedSourceResult, loadOptions) => {
             if (startupState.cleanedUp || acquisitions.get(options) !== acquisition) {
               return true;
             }
@@ -1573,10 +2955,42 @@ function createWrappedSyncConfig(sourceSyncConfig, runtime) {
               acquisition.forwarded = false;
               throw error;
             }
-          });
+          };
+          const openTransaction = getOpenTransaction();
+          const needsPublicationAdmission = openTransaction && !openTransaction.internal && openTransaction.beginOptions?.immediate;
+          const hydrated = sourceResultSettled && !needsPublicationAdmission ? runtime.loadHydratedSubset(
+            options,
+            (loadOptions) => forwardUpstream(sourceResult, loadOptions)
+          ) : void 0;
+          if (hydrated !== void 0) {
+            return hydrated;
+          }
+          return (async () => {
+            await fullStartPromise;
+            const resolvedSourceResult = await sourceResultPromise;
+            if (startupState.cleanedUp || acquisitions.get(options) !== acquisition) {
+              return;
+            }
+            const currentTransaction = getOpenTransaction();
+            if (currentTransaction && !currentTransaction.internal && currentTransaction.beginOptions?.immediate) {
+              await waitForPublicationAdmission(
+                currentTransaction,
+                options,
+                acquisition
+              );
+            }
+            if (options.signal?.aborted || acquisitions.get(options) !== acquisition) {
+              return;
+            }
+            return runtime.loadSubset(
+              options,
+              (loadOptions) => forwardUpstream(resolvedSourceResult, loadOptions)
+            );
+          })();
         },
         unloadSubset: (options) => {
           const acquisition = acquisitions.get(options);
+          acquisition?.cancelAdmissionWait?.();
           acquisitions.delete(options);
           runtime.unloadSubset(
             options,
@@ -1595,23 +3009,19 @@ function createLoopbackSyncConfig(runtime) {
         write: params.write,
         commit: params.commit,
         truncate: params.truncate,
-        metadata: params.metadata ?? null
+        metadata: params.metadata ?? null,
+        markError: params.markError
       });
       runtime.setCollection(
         params.collection
       );
       void runtime.ensureStarted().then(() => {
+        if (runtime.getCurrentTerminalFailure()) return;
         params.markReady();
-      }).catch((error) => {
-        console.warn(`Failed persisted loopback startup:`, error);
-        params.markReady();
-      });
+      }).catch(() => void 0);
       return {
-        cleanup: () => {
-          runtime.cleanup();
-          runtime.clearSyncControls();
-        },
-        loadSubset: (options) => runtime.loadSubset(options),
+        loadSubset: (options) => runtime.loadHydratedSubset(options) ?? runtime.loadSubset(options),
+        cleanup: () => runtime.cleanup(),
         unloadSubset: (options) => runtime.unloadSubset(options)
       };
     },
@@ -1626,13 +3036,24 @@ function persistedCollectionOptions(options) {
       `persistedCollectionOptions requires a persistence adapter`
     );
   }
+  const networkTimeoutMs = getNetworkTimeoutMs(options.initialRender);
+  if (networkTimeoutMs !== void 0 && options.syncMode === `on-demand`) {
+    throw new InvalidPersistedCollectionConfigError(
+      `network-first initial rendering requires eager persistence syncMode`
+    );
+  }
+  const persistedReadinessTracker = networkTimeoutMs !== void 0 ? new PersistedReadinessTracker(networkTimeoutMs) : void 0;
   if (hasOwnSyncKey(options)) {
     if (!isValidSyncConfig(options.sync)) {
       throw new InvalidSyncConfigError(
         `when the "sync" key is present it must provide a callable sync function`
       );
     }
-    const { schemaVersion: schemaVersion2, ...syncOptions } = options;
+    const {
+      schemaVersion: schemaVersion2,
+      initialRender: _initialRender2,
+      ...syncOptions
+    } = options;
     const collectionId2 = syncOptions.id ?? `persisted-collection:${safeRandomUUID()}`;
     const persistence2 = resolvePersistenceForCollection(
       syncOptions.persistence,
@@ -1647,13 +3068,19 @@ function persistedCollectionOptions(options) {
       collectionId2,
       persistence2,
       syncOptions.syncMode ?? `eager`,
-      collectionId2
+      collectionId2,
+      persistedReadinessTracker
     );
     const result2 = {
       ...syncOptions,
       id: collectionId2,
-      sync: createWrappedSyncConfig(syncOptions.sync, runtime2),
-      persistence: persistence2
+      sync: createWrappedSyncConfig(
+        syncOptions.sync,
+        runtime2,
+        persistedReadinessTracker
+      ),
+      persistence: persistence2,
+      ...persistedReadinessTracker ? { [PERSISTED_READINESS]: persistedReadinessTracker } : {}
     };
     return withCollectionConfigFactory(
       result2,
@@ -1663,7 +3090,11 @@ function persistedCollectionOptions(options) {
       })
     );
   }
-  const { schemaVersion, ...localOnlyOptions } = options;
+  const {
+    schemaVersion,
+    initialRender: _initialRender,
+    ...localOnlyOptions
+  } = options;
   const collectionId = localOnlyOptions.id ?? `persisted-collection:${safeRandomUUID()}`;
   const persistence = resolvePersistenceForCollection(
     localOnlyOptions.persistence,
@@ -1678,32 +3109,39 @@ function persistedCollectionOptions(options) {
     collectionId,
     persistence,
     localOnlyOptions.syncMode ?? `eager`,
-    localOnlyOptions.id ?? DEFAULT_DB_NAME
+    localOnlyOptions.id ?? DEFAULT_DB_NAME,
+    persistedReadinessTracker
   );
   const wrappedOnInsert = async (params) => {
+    const lifecycleGeneration = runtime.getLifecycleGeneration();
     const handlerResult = localOnlyOptions.onInsert ? await localOnlyOptions.onInsert(
       params
     ) : void 0;
     await runtime.persistAndConfirmCollectionMutations(
-      params.transaction.mutations
+      params.transaction.mutations,
+      lifecycleGeneration
     );
     return handlerResult ?? {};
   };
   const wrappedOnUpdate = async (params) => {
+    const lifecycleGeneration = runtime.getLifecycleGeneration();
     const handlerResult = localOnlyOptions.onUpdate ? await localOnlyOptions.onUpdate(
       params
     ) : void 0;
     await runtime.persistAndConfirmCollectionMutations(
-      params.transaction.mutations
+      params.transaction.mutations,
+      lifecycleGeneration
     );
     return handlerResult ?? {};
   };
   const wrappedOnDelete = async (params) => {
+    const lifecycleGeneration = runtime.getLifecycleGeneration();
     const handlerResult = localOnlyOptions.onDelete ? await localOnlyOptions.onDelete(
       params
     ) : void 0;
     await runtime.persistAndConfirmCollectionMutations(
-      params.transaction.mutations
+      params.transaction.mutations,
+      lifecycleGeneration
     );
     return handlerResult ?? {};
   };
@@ -1723,6 +3161,7 @@ function persistedCollectionOptions(options) {
     ...localOnlyOptions,
     id: collectionId,
     persistence,
+    ...persistedReadinessTracker ? { [PERSISTED_READINESS]: persistedReadinessTracker } : {},
     sync: createLoopbackSyncConfig(runtime),
     onInsert: wrappedOnInsert,
     onUpdate: wrappedOnUpdate,
@@ -1795,10 +3234,12 @@ function createPersistedTableName(collectionId, prefix = `c`) {
   return `${prefix}_${hashPart}_${lengthPart}`;
 }
 export {
+  SQLITE_DRIVER_SHARED_LOGICAL_SCHEDULING_KEY,
   SingleProcessCoordinator,
   createPersistedTableName,
   decodePersistedStorageKey,
   encodePersistedStorageKey,
+  forwardSQLiteDriverSharedLogicalScheduling,
   persistedCollectionOptions,
   validatePersistedCollectionCoordinator
 };