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

package/src/persisted.ts

@@ -1,18 +1,38 @@
 import {
+  NoPendingSyncTransactionCommitError,
+  NoPendingSyncTransactionWriteError,
+  PERSISTED_READINESS,
+  SYNC_PERSISTENCE_PROTOCOL,
+  SYNC_PERSISTENCE_VERSION,
   SyncTransactionAbortedError,
   compileSingleRowExpression,
+  getLoadSubsetDemandKey,
   safeRandomUUID,
   toBooleanPredicate,
   withCollectionConfigFactory,
 } from '@tanstack/db'
 import {
+  DuplicateRemoteSubsetOwnerError,
   InvalidPersistedCollectionConfigError,
   InvalidPersistedCollectionCoordinatorError,
   InvalidPersistedStorageKeyEncodingError,
   InvalidPersistedStorageKeyError,
   InvalidPersistenceAdapterError,
   InvalidSyncConfigError,
+  PersistedCollectionDurabilityError,
+  toPersistedCollectionDurabilityError,
 } from './errors'
+import { serializeSQLiteBigInt } from './sqlite-value'
+import {
+  toProcessLocalLoadSubsetOptions,
+  toTransportedLoadSubsetOptions,
+} from './remote-subset-wire'
+import {
+  reportRemoteSubsetOwnerError,
+  unloadRemoteSubsetOwner,
+} from './remote-subset-owner'
+import type { TransportedLoadSubsetOptions } from './remote-subset-wire'
+import type { RemoteSubsetOwner } from './remote-subset-owner'
 import type { StandardSchemaV1 } from '@standard-schema/spec'
 import type {
   ChangeMessageOrDeleteKeyMessage,
@@ -20,14 +40,20 @@ import type {
   CollectionConfig,
   CollectionIndexMetadata,
   DeleteMutationFnParams,
+  InferSchemaOutput,
   InsertMutationFnParams,
   LoadSubsetFn,
   LoadSubsetOptions,
   PendingMutation,
+  PersistedReadinessSnapshot,
+  PersistedReadinessSource,
   SyncAppliedReceipt,
   SyncConfig,
   SyncConfigRes,
   SyncMetadataApi,
+  SyncPersistenceCapabilityV1,
+  SyncPersistenceKeySetEvidence,
+  SyncPersistenceScanOptions,
   UpdateMutationFnParams,
   UtilsRecord,
 } from '@tanstack/db'
@@ -38,12 +64,20 @@ export type PersistedMutationEnvelope =
       type: `insert`
       key: string | number
       value: Record<string, unknown>
+      /** Persisted row metadata, not optimistic-transaction metadata. */
+      metadata?: unknown
+      /** Whether this envelope replaces or deletes the persisted row metadata. */
+      metadataChanged?: boolean
     }
   | {
       mutationId: string
       type: `update`
       key: string | number
       value: Record<string, unknown>
+      /** Persisted row metadata, not optimistic-transaction metadata. */
+      metadata?: unknown
+      /** Whether this envelope replaces or deletes the persisted row metadata. */
+      metadataChanged?: boolean
     }
   | {
       mutationId: string
@@ -96,7 +130,8 @@ export type TxCommitted = {
 export type EnsureRemoteSubsetRequest = {
   type: `rpc:ensureRemoteSubset:req`
   rpcId: string
-  options: LoadSubsetOptions
+  acquisitionId: string
+  options: TransportedLoadSubsetOptions
 }
 
 export type EnsureRemoteSubsetResponse =
@@ -104,12 +139,33 @@ export type EnsureRemoteSubsetResponse =
       type: `rpc:ensureRemoteSubset:res`
       rpcId: string
       ok: true
+      leaderId: string
     }
   | {
       type: `rpc:ensureRemoteSubset:res`
       rpcId: string
       ok: false
       error: string
+      retryable?: true
+    }
+
+export type ReleaseRemoteSubsetRequest = {
+  type: `rpc:releaseRemoteSubset:req`
+  rpcId: string
+  acquisitionId: string
+}
+
+export type ReleaseRemoteSubsetResponse =
+  | {
+      type: `rpc:releaseRemoteSubset:res`
+      rpcId: string
+      ok: true
+    }
+  | {
+      type: `rpc:releaseRemoteSubset:res`
+      rpcId: string
+      ok: false
+      error: string
     }
 
 export type ApplyLocalMutationsRequest = {
@@ -136,6 +192,48 @@ export type ApplyLocalMutationsResponse =
       code: `NOT_LEADER` | `VALIDATION_ERROR` | `CONFLICT` | `TIMEOUT`
       error: string
     }
+  | {
+      type: `rpc:applyLocalMutations:res`
+      rpcId: string
+      ok: false
+      code: `PERSISTENCE_ERROR`
+      error: string
+      sourceCode?: string | number
+      path?: string | ReadonlyArray<string | number>
+    }
+
+export type ApplyCommittedTxRequest = {
+  type: `rpc:applyCommittedTx:req`
+  rpcId: string
+  envelopeId: string
+  tx: PersistedTx
+}
+
+export type ApplyCommittedTxResponse =
+  | {
+      type: `rpc:applyCommittedTx:res`
+      rpcId: string
+      ok: true
+      term: number
+      seq: number
+      latestRowVersion: number
+    }
+  | {
+      type: `rpc:applyCommittedTx:res`
+      rpcId: string
+      ok: false
+      code: `NOT_LEADER` | `CONFLICT` | `TIMEOUT`
+      error: string
+    }
+  | {
+      type: `rpc:applyCommittedTx:res`
+      rpcId: string
+      ok: false
+      code: `PERSISTENCE_ERROR`
+      error: string
+      sourceCode?: string | number
+      path?: string | ReadonlyArray<string | number>
+    }
 
 export type PullSinceRequest = {
   type: `rpc:pullSince:req`
@@ -215,10 +313,32 @@ export type PersistedScannedRow<
   metadata?: unknown
 }
 
-export type PersistedRowScanOptions = {
-  metadataOnly?: boolean
+export type PersistedRowScanOptions = SyncPersistenceScanOptions
+
+export type PersistedKeySetEvidence = SyncPersistenceKeySetEvidence
+
+type PersistedResumeGeneration = {
+  latestTerm: number
+  latestSeq: number
+  latestRowVersion: number
+  resetEpoch: number
 }
 
+export type PersistencePullSinceResult =
+  | {
+      latestRowVersion: number
+      requiresFullReload: true
+    }
+  | {
+      latestRowVersion: number
+      requiresFullReload: false
+      changedKeys: Array<string | number>
+      deletedKeys: Array<string | number>
+      deltas?: Array<
+        ReplayableTxDelta<Record<string, unknown>, string | number>
+      >
+    }
+
 export type PersistedTx<
   T extends object = Record<string, unknown>,
   TKey extends string | number = string | number,
@@ -249,6 +369,21 @@ export type PersistedTx<
   collectionMetadataMutations?: Array<PersistedCollectionMetadataMutation>
 }
 
+/**
+ * Opaque identity shared by every adapter over the same physical SQLite driver.
+ * The core adapter uses it to serialize non-preemptible logical operations
+ * while alternating one regular operation between queued hydrations.
+ *
+ * Delegating drivers must forward this property before they are passed to a
+ * SQLite persistence adapter. A driver may also brand each returned Promise
+ * with the same key for late capability discovery, but a wrapper must return
+ * that exact Promise: discovering the key after a call cannot retroactively
+ * schedule the wrapper's first logical operation.
+ */
+export const SQLITE_DRIVER_SHARED_LOGICAL_SCHEDULING_KEY = Symbol.for(
+  `tanstack-db.sqlite-driver-supports-shared-logical-scheduling`,
+)
+
 export interface PersistenceAdapter {
   loadSubset: (
     collectionId: string,
@@ -261,6 +396,25 @@ export interface PersistenceAdapter {
       metadata?: unknown
     }>
   >
+  loadResumeSnapshot: (
+    collectionId: string,
+    ctx?: {
+      requiredIndexSignatures?: ReadonlyArray<string>
+      includeRows?: boolean
+    },
+  ) => Promise<{
+    rows: Array<{
+      key: string | number
+      value: Record<string, unknown>
+      metadata?: unknown
+    }>
+    keySet?: PersistedKeySetEvidence
+    collectionMetadata: Array<{ key: string; value: unknown }>
+    latestTerm: number
+    latestSeq: number
+    latestRowVersion: number
+    resetEpoch: number
+  }>
   applyCommittedTx: (collectionId: string, tx: PersistedTx) => Promise<void>
   loadCollectionMetadata?: (
     collectionId: string,
@@ -280,9 +434,41 @@ export interface PersistenceAdapter {
     latestSeq: number
     latestRowVersion: number
   }>
+  /**
+   * Runs one complete logical hydrate as a non-preemptible scheduler unit.
+   * The callback must use the supplied unscheduled adapter for all nested
+   * persistence work and must not retain it after the callback settles.
+   */
+  runInHydrationScope?: <T>(
+    task: (adapter: HydrationPersistenceAdapter) => Promise<T>,
+  ) => Promise<T>
+  /** Schedule one regular operation before it acquires external writer locks. */
+  runInRegularScope?: <T>(
+    task: (adapter: HydrationPersistenceAdapter) => Promise<T>,
+  ) => Promise<T>
+  /** Whether hydration scopes currently enter a shared driver scheduler. */
+  isHydrationScopeScheduled?: () => boolean
+}
+
+export type HydrationPersistenceAdapter = PersistenceAdapter & {
+  pullSince?: (
+    collectionId: string,
+    fromRowVersion: number,
+  ) => Promise<PersistencePullSinceResult>
+}
+
+export type { RemoteSubsetOwner } from './remote-subset-owner'
+
+type SingleProcessRemoteSubsetAcquisition = {
+  owner: RemoteSubsetOwner
+  options: TransportedLoadSubsetOptions
+  load: Promise<void>
 }
 
 export interface SQLiteDriver {
+  readonly [SQLITE_DRIVER_SHARED_LOGICAL_SCHEDULING_KEY]?: object
+  /** Host-specific limit on bound parameters in one query, when lower than SQLite's. */
+  readonly maxBoundParameters?: number
   exec: (sql: string) => Promise<void>
   query: <T>(
     sql: string,
@@ -297,8 +483,30 @@ export interface SQLiteDriver {
   ) => Promise<T>
 }
 
+/**
+ * Forwards a driver's shared logical scheduling identity to a transparent
+ * delegating driver before the wrapper is used by a persistence adapter.
+ */
+export function forwardSQLiteDriverSharedLogicalScheduling<
+  TDriver extends SQLiteDriver,
+>(source: SQLiteDriver, wrapper: TDriver): TDriver {
+  const key = source[SQLITE_DRIVER_SHARED_LOGICAL_SCHEDULING_KEY]
+  if (key) {
+    Object.defineProperty(
+      wrapper,
+      SQLITE_DRIVER_SHARED_LOGICAL_SCHEDULING_KEY,
+      { value: key },
+    )
+  }
+  return wrapper
+}
+
 export interface PersistedCollectionCoordinator {
   getNodeId: () => string
+  setAdapterForCollection?: (
+    collectionId: string,
+    adapter: PersistenceAdapter,
+  ) => void
   subscribe: (
     collectionId: string,
     onMessage: (message: ProtocolEnvelope<unknown>) => void,
@@ -306,22 +514,44 @@ export interface PersistedCollectionCoordinator {
   publish: (collectionId: string, message: ProtocolEnvelope<unknown>) => void
   isLeader: (collectionId: string) => boolean
   ensureLeadership: (collectionId: string) => Promise<void>
-  requestEnsureRemoteSubset?: (
+  requestEnsureRemoteSubset: (
+    collectionId: string,
+    options: LoadSubsetOptions,
+  ) => Promise<void>
+  requestReleaseRemoteSubset: (
     collectionId: string,
     options: LoadSubsetOptions,
   ) => Promise<void>
+  registerRemoteSubsetOwner: (
+    collectionId: string,
+    owner: RemoteSubsetOwner,
+  ) => () => void
+  /**
+   * Requests leader-side index creation. The scoped adapter is leader-local
+   * and is never serialized to a follower. `localEnsureCompleted` lets the
+   * built-in leader avoid repeating successful local work.
+   */
   requestEnsurePersistedIndex: (
     collectionId: string,
     signature: string,
     spec: PersistedIndexSpec,
+    scopedAdapter?: HydrationPersistenceAdapter,
+    localEnsureCompleted?: boolean,
   ) => Promise<void>
   requestApplyLocalMutations?: (
     collectionId: string,
     mutations: Array<PersistedMutationEnvelope>,
   ) => Promise<ApplyLocalMutationsResponse>
+  requestApplyCommittedTx: (
+    collectionId: string,
+    tx: PersistedTx,
+    scopedAdapter?: HydrationPersistenceAdapter,
+  ) => Promise<ApplyCommittedTxResponse>
+  /** The scoped adapter is leader-local and is never serialized to a follower. */
   pullSince?: (
     collectionId: string,
     fromRowVersion: number,
+    scopedAdapter?: HydrationPersistenceAdapter,
   ) => Promise<PullSinceResponse>
 }
 
@@ -352,9 +582,78 @@ export interface PersistedCollectionUtils extends UtilsRecord {
     mutations: Array<PendingMutation<Record<string, unknown>>>
   }) => Promise<void> | void
   getLeadershipState?: () => PersistedCollectionLeadershipState
+  /** Hydrate once without acquiring a new ongoing subset lease. */
   forceReloadSubset?: (options: LoadSubsetOptions) => Promise<void> | void
 }
 
+class PersistedReadinessTracker implements PersistedReadinessSource {
+  private snapshot: PersistedReadinessSnapshot = { status: `loading` }
+  private networkDeadlineAt: number | undefined
+  private readonly listeners = new Set<() => void>()
+
+  constructor(readonly networkTimeoutMs: number) {}
+
+  getSnapshot = (): PersistedReadinessSnapshot => this.snapshot
+
+  getOrStartNetworkDeadline = (): number => {
+    return (this.networkDeadlineAt ??= Date.now() + this.networkTimeoutMs)
+  }
+
+  subscribe = (listener: () => void): (() => void) => {
+    this.listeners.add(listener)
+    return () => this.listeners.delete(listener)
+  }
+
+  set(snapshot: PersistedReadinessSnapshot): void {
+    const deadlineRestarted =
+      snapshot.status === `loading` && this.networkDeadlineAt !== undefined
+    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()
+  }
+}
+
+export type PersistedInitialRenderOptions = {
+  strategy: `network-first`
+  /** Time to prefer network before restored rows may render; defaults to 3s. */
+  networkTimeoutMs?: number
+}
+
+const DEFAULT_NETWORK_TIMEOUT_MS = 3_000
+const MAX_TIMER_TIMEOUT_MS = 2_147_483_647
+
+function getNetworkTimeoutMs(
+  initialRender: PersistedInitialRenderOptions | undefined,
+): number | undefined {
+  if (initialRender === undefined) return undefined
+  const strategy = (initialRender as { strategy: unknown }).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
+}
+
 export type PersistedSyncWrappedOptions<
   T extends object,
   TKey extends string | number,
@@ -364,6 +663,8 @@ export type PersistedSyncWrappedOptions<
   sync: SyncConfig<T, TKey>
   persistence: PersistedCollectionPersistence
   schemaVersion?: number
+  /** Opt into network-first rendering with a persisted fallback. */
+  initialRender?: PersistedInitialRenderOptions
 }
 
 export type PersistedLocalOnlyOptions<
@@ -374,6 +675,8 @@ export type PersistedLocalOnlyOptions<
 > = Omit<CollectionConfig<T, TKey, TSchema, TUtils>, `sync`> & {
   persistence: PersistedCollectionPersistence
   schemaVersion?: number
+  /** Opt into network-first rendering with a persisted fallback. */
+  initialRender?: PersistedInitialRenderOptions
 }
 
 type PersistedSyncOptionsResult<
@@ -404,7 +707,11 @@ const REQUIRED_COORDINATOR_METHODS: ReadonlyArray<
     | `publish`
     | `isLeader`
     | `ensureLeadership`
+    | `requestEnsureRemoteSubset`
+    | `requestReleaseRemoteSubset`
+    | `registerRemoteSubsetOwner`
     | `requestEnsurePersistedIndex`
+    | `requestApplyCommittedTx`
   >
 > = [
   `getNodeId`,
@@ -412,15 +719,19 @@ const REQUIRED_COORDINATOR_METHODS: ReadonlyArray<
   `publish`,
   `isLeader`,
   `ensureLeadership`,
+  `requestEnsureRemoteSubset`,
+  `requestReleaseRemoteSubset`,
+  `registerRemoteSubsetOwner`,
   `requestEnsurePersistedIndex`,
+  `requestApplyCommittedTx`,
 ]
 
 const REQUIRED_ADAPTER_METHODS: ReadonlyArray<
   keyof Pick<
     PersistenceAdapter,
-    `loadSubset` | `applyCommittedTx` | `ensureIndex`
+    `loadSubset` | `loadResumeSnapshot` | `applyCommittedTx` | `ensureIndex`
   >
-> = [`loadSubset`, `applyCommittedTx`, `ensureIndex`]
+> = [`loadSubset`, `loadResumeSnapshot`, `applyCommittedTx`, `ensureIndex`]
 
 const TARGETED_INVALIDATION_KEY_LIMIT = 128
 const DEFAULT_DB_NAME = `tanstack-db`
@@ -439,6 +750,7 @@ type SyncControlFns<T extends object, TKey extends string | number> = {
   commit: ((signal?: AbortSignal) => SyncAppliedReceipt) | null
   truncate: (() => void) | null
   metadata: SyncMetadataApi<TKey> | null
+  markError: ((error: unknown) => void) | null
 }
 
 /**
@@ -447,6 +759,12 @@ type SyncControlFns<T extends object, TKey extends string | number> = {
  */
 export class SingleProcessCoordinator implements PersistedCollectionCoordinator {
   private readonly nodeId: string
+  private readonly collectionAdapters = new Map<string, PersistenceAdapter>()
+  private readonly remoteSubsetOwners = new Map<string, RemoteSubsetOwner>()
+  private readonly remoteSubsetAcquisitions = new Map<
+    string,
+    Map<LoadSubsetOptions, SingleProcessRemoteSubsetAcquisition>
+  >()
 
   constructor(nodeId: string = safeRandomUUID()) {
     this.nodeId = nodeId
@@ -468,10 +786,129 @@ export class SingleProcessCoordinator implements PersistedCollectionCoordinator
 
   public async ensureLeadership(): Promise<void> {}
 
-  public async requestEnsureRemoteSubset(): Promise<void> {}
+  public async requestEnsureRemoteSubset(
+    collectionId: string,
+    options: LoadSubsetOptions,
+  ): Promise<void> {
+    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 = new Map()
+      this.remoteSubsetAcquisitions.set(collectionId, acquisitions)
+    }
+    const existing = acquisitions.get(options)
+    if (existing) {
+      await existing.load
+      return
+    }
+
+    let resolveLoad!: () => void
+    let rejectLoad!: (error: unknown) => void
+    const load = new Promise<void>((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
+  }
+
+  public async requestReleaseRemoteSubset(
+    collectionId: string,
+    options: LoadSubsetOptions,
+  ): Promise<void> {
+    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 {
+      // Calling the owner transferred the lease even when its load rejected.
+    }
+    await unloadRemoteSubsetOwner(acquisition.owner, acquisition.options)
+  }
+
+  public registerRemoteSubsetOwner(
+    collectionId: string,
+    owner: RemoteSubsetOwner,
+  ): () => void {
+    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 {
+            // Calling the owner transferred the lease even when its load rejected.
+          }
+          await unloadRemoteSubsetOwner(owner, acquisition.options)
+        })().catch(() => undefined)
+      }
+    }
+  }
 
   public async requestEnsurePersistedIndex(): Promise<void> {}
 
+  public setAdapterForCollection(
+    collectionId: string,
+    adapter: PersistenceAdapter,
+  ): void {
+    this.collectionAdapters.set(collectionId, adapter)
+  }
+
+  public async requestApplyCommittedTx(
+    collectionId: string,
+    tx: PersistedTx,
+  ): Promise<ApplyCommittedTxResponse> {
+    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,
+    }
+  }
+
   public pullSince(): Promise<PullSinceResponse> {
     return Promise.resolve({
       type: `rpc:pullSince:res`,
@@ -508,10 +945,14 @@ function validatePersistenceAdapter(adapter: PersistenceAdapter): void {
 
 function resolvePersistence(
   persistence: PersistedCollectionPersistence,
+  collectionId: string,
 ): PersistedResolvedPersistence {
   validatePersistenceAdapter(persistence.adapter)
 
   const coordinator = persistence.coordinator ?? new SingleProcessCoordinator()
+  if (coordinator instanceof SingleProcessCoordinator) {
+    coordinator.setAdapterForCollection(collectionId, persistence.adapter)
+  }
   validatePersistedCollectionCoordinator(coordinator)
 
   return {
@@ -523,9 +964,13 @@ function resolvePersistence(
 function resolvePersistenceForMode(
   persistence: PersistedCollectionPersistence,
   mode: PersistedCollectionMode,
+  collectionId: string,
 ): PersistedResolvedPersistence {
   const modeSpecificPersistence = persistence.resolvePersistenceForMode?.(mode)
-  return resolvePersistence(modeSpecificPersistence ?? persistence)
+  return resolvePersistence(
+    modeSpecificPersistence ?? persistence,
+    collectionId,
+  )
 }
 
 function resolvePersistenceForCollection(
@@ -539,10 +984,17 @@ function resolvePersistenceForCollection(
   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: object): options is { sync: unknown } {
@@ -579,6 +1031,7 @@ type NormalizedSyncOperation<T extends object, TKey extends string | number> =
 
 type BufferedSyncTransaction<T extends object, TKey extends string | number> = {
   operations: Array<NormalizedSyncOperation<T, TKey>>
+  partialUpdateOperationIndexes: Set<number>
   rowMetadataWrites: Map<
     TKey,
     { type: `set`; value: unknown } | { type: `delete` }
@@ -587,44 +1040,95 @@ type BufferedSyncTransaction<T extends object, TKey extends string | number> = {
     string,
     { type: `set`; value: unknown } | { type: `delete` }
   >
+  deferredHydrationMetadataDeleteKeys: Set<TKey>
+  hydrationContext?: { suppliedRowKeys: Set<TKey> }
+  hydrationSequence?: number
   truncate: boolean
   internal: boolean
+  lifecycleGeneration: number
+  beginOptions?: { immediate?: boolean }
+  expectedResumeGenerationOwner?: symbol
   signal?: AbortSignal
+  prependHydrationRows: (
+    rows: Array<{ key: TKey; value: T; metadata?: unknown }>,
+  ) => void
+  applyToCollection: () => SyncAppliedReceipt
+  shouldFailStopOnAbort?: () => boolean
   resolveApplied?: () => void
   rejectApplied?: (error: unknown) => void
 }
 
-type OpenSyncTransaction<
-  T extends object,
-  TKey extends string | number,
-> = BufferedSyncTransaction<T, TKey> & {
+type OpenSyncTransaction<T extends object, TKey extends string | number> = Omit<
+  BufferedSyncTransaction<T, TKey>,
+  `applyToCollection` | `prependHydrationRows` | `shouldFailStopOnAbort`
+> & {
+  signal?: AbortSignal
+  applicationReceipt?: SyncAppliedReceipt
+  operationKeys: Set<TKey>
   queuedBecauseHydrating: boolean
+  hasDependentSuccessor: boolean
+  publicationAdmissionWaiters?: Set<{
+    resolve: () => void
+    reject: (error: unknown) => void
+  }>
+  terminalFailure?: { error: unknown }
 }
 
 type SyncWriteNormalization<T extends object, TKey extends string | number> = {
-  forwardMessage:
-    | {
-        type: `update`
-        value: T
-        metadata?: Record<string, unknown>
-      }
-    | {
-        type: `delete`
-        key: TKey
-      }
   operation: NormalizedSyncOperation<T, TKey>
 }
 
 class ApplyMutex {
   private queue: Promise<void> = Promise.resolve()
+  private pending = 0
 
-  async run<T>(task: () => Promise<T>): Promise<T> {
-    const taskPromise = this.queue.then(() => task())
-    this.queue = taskPromise.then(
-      () => undefined,
-      () => undefined,
-    )
-    return taskPromise
+  reserve(): {
+    run: <T>(task: () => Promise<T> | T) => Promise<T>
+  } {
+    const runImmediately = this.pending === 0
+    const predecessor = this.queue
+    this.pending++
+
+    let releaseReservation!: () => void
+    const reservation = new Promise<void>((resolve) => {
+      releaseReservation = resolve
+    })
+    this.queue = runImmediately
+      ? reservation
+      : predecessor.then(() => reservation)
+
+    let used = false
+    return {
+      run: <T>(task: () => Promise<T> | T): Promise<T> => {
+        if (used) {
+          return Promise.reject(
+            new Error(`an apply-mutex reservation can only run once`),
+          )
+        }
+        used = true
+
+        let taskPromise: Promise<T>
+        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
+      },
+    }
+  }
+
+  run<T>(task: () => Promise<T> | T): Promise<T> {
+    return this.reserve().run(task)
   }
 }
 
@@ -639,7 +1143,7 @@ function toStableSerializable(value: unknown): unknown {
     case `boolean`:
       return value
     case `bigint`:
-      return value.toString()
+      return serializeSQLiteBigInt(value)
     case `function`:
     case `symbol`:
     case `undefined`:
@@ -707,18 +1211,6 @@ function stableSerialize(value: unknown): string {
   return JSON.stringify(toStableSerializable(value) ?? null)
 }
 
-function normalizeSubsetOptionsForKey(
-  options: LoadSubsetOptions,
-): Record<string, unknown> {
-  return {
-    where: toStableSerializable(options.where),
-    orderBy: toStableSerializable(options.orderBy),
-    limit: options.limit,
-    cursor: toStableSerializable(options.cursor),
-    offset: options.offset,
-  }
-}
-
 function normalizeSyncFnResult(result: void | (() => void) | SyncConfigRes) {
   if (typeof result === `function`) {
     return { cleanup: result } satisfies SyncConfigRes
@@ -780,6 +1272,8 @@ function toPersistedMutationEnvelope(
       ? (mutation.original as Record<string, unknown>)
       : mutation.modified
 
+  // PendingMutation.metadata belongs to the optimistic transaction and is
+  // consumed by mutation handlers. It must not overwrite persisted row metadata.
   return {
     mutationId: mutation.mutationId,
     type: mutation.type,
@@ -794,6 +1288,10 @@ class PersistedCollectionRuntime<
 > {
   private readonly applyMutex = new ApplyMutex()
   private readonly activeSubsets = new Map<string, LoadSubsetOptions>()
+  private activeHydrationContext: { suppliedRowKeys: Set<TKey> } | undefined
+  private hydrationSequence = 0
+  // An unscheduled startup read may finish after a coordinator reset publishes.
+  private resetSequence = 0
   private readonly pendingRemoteSubsetEnsures = new Map<
     string,
     LoadSubsetOptions
@@ -801,8 +1299,12 @@ class PersistedCollectionRuntime<
   private readonly queuedHydrationTransactions: Array<
     BufferedSyncTransaction<T, TKey>
   > = []
-  private readonly queuedTxCommitted: Array<TxCommitted> = []
-  private readonly subscriptionIds = new WeakMap<object, string>()
+  private readonly queuedTxCommitted: Array<{
+    txCommitted: TxCommitted
+    lifecycleGeneration: number
+  }> = []
+  private readonly requestIds = new WeakMap<LoadSubsetOptions, string>()
+  private readonly hydratedDemands = new Set<string | undefined>()
 
   private collection: Collection<T, TKey, PersistedCollectionUtils> | null =
     null
@@ -812,19 +1314,35 @@ class PersistedCollectionRuntime<
     commit: null,
     truncate: null,
     metadata: null,
+    markError: null,
   }
-  private started = false
   private startupMetadataPromise: Promise<void> | null = null
   private startPromise: Promise<void> | null = null
+  private hasAttemptedStartup = false
+  private resumeBaselinePromise: Promise<void> | null = null
+  private resumeCertificationPromise: Promise<void> | null = null
+  private persistedKeySetEvidence: PersistedKeySetEvidence | undefined
+  private persistedResumeGeneration: PersistedResumeGeneration | undefined
+  private resumeGenerationOwner = Symbol(`persisted resume generation owner`)
+  private lifecycleGeneration = 0
   private internalApplyDepth = 0
+  private sourcePublicationWaitDepth = 0
   private appliedReceiptSequence = 0
+  private syncErrorReported = false
+  private reportedSyncError: unknown
   private readonly pendingAppliedReceipts = new Map<number, Promise<void>>()
-  private isHydrating = false
+  private hydratingGeneration: number | null = null
+  private terminalFailure:
+    | { lifecycleGeneration: number; error: unknown }
+    | undefined
   private coordinatorUnsubscribe: (() => void) | null = null
+  private remoteSubsetOwnerUnsubscribe: (() => void) | null = null
   private indexAddedUnsubscribe: (() => void) | null = null
   private indexRemovedUnsubscribe: (() => void) | null = null
   private remoteEnsureRetryTimer: ReturnType<typeof setTimeout> | null = null
-  private nextSubscriptionId = 0
+  private nextRequestId = 0
+  private startupSettled = false
+  private sourceTruncateGeneration = 0
 
   private latestTerm = 0
   private latestSeq = 0
@@ -839,9 +1357,14 @@ class PersistedCollectionRuntime<
     private readonly persistence: PersistedResolvedPersistence,
     private readonly syncMode: `eager` | `on-demand`,
     private readonly dbName: string,
+    private readonly persistedReadiness?: PersistedReadinessTracker,
   ) {}
 
   setSyncControls(syncControls: SyncControlFns<T, TKey>): void {
+    this.advanceLifecycle()
+    this.syncErrorReported = false
+    this.reportedSyncError = undefined
+
     const commit = syncControls.commit
     this.syncControls = {
       ...syncControls,
@@ -851,6 +1374,30 @@ class PersistedCollectionRuntime<
     }
   }
 
+  reportSyncError(error: unknown): unknown {
+    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 {
+      // Reporting must not replace the original asynchronous failure.
+    }
+    return error
+  }
+
+  registerRemoteSubsetOwner(owner: RemoteSubsetOwner): void {
+    this.remoteSubsetOwnerUnsubscribe?.()
+    this.remoteSubsetOwnerUnsubscribe =
+      this.persistence.coordinator.registerRemoteSubsetOwner(
+        this.collectionId,
+        owner,
+      )
+  }
+
   private trackAppliedReceipt(receipt: SyncAppliedReceipt): SyncAppliedReceipt {
     const sequence = ++this.appliedReceiptSequence
     if (receipt === true) {
@@ -870,18 +1417,75 @@ class PersistedCollectionRuntime<
     )
   }
 
-  clearSyncControls(): void {
+  private clearSyncControls(): void {
     this.syncControls = {
       begin: null,
       write: null,
       commit: null,
       truncate: null,
       metadata: null,
+      markError: null,
     }
   }
 
   isHydratingNow(): boolean {
-    return this.isHydrating
+    return this.hydratingGeneration === this.lifecycleGeneration
+  }
+
+  getActiveHydrationContext(): { suppliedRowKeys: Set<TKey> } | undefined {
+    return this.activeHydrationContext
+  }
+
+  getHydrationSequence(): number {
+    return this.hydrationSequence
+  }
+
+  getCurrentTerminalFailure(): { error: unknown } | undefined {
+    const failure = this.terminalFailure
+    return failure?.lifecycleGeneration === this.lifecycleGeneration
+      ? failure
+      : undefined
+  }
+
+  getLifecycleGeneration(): number {
+    return this.lifecycleGeneration
+  }
+
+  private throwIfLifecycleReplaced(lifecycleGeneration: number): void {
+    if (lifecycleGeneration !== this.lifecycleGeneration) {
+      throw new SyncTransactionAbortedError()
+    }
+  }
+
+  private throwIfTerminal(): void {
+    const failure = this.getCurrentTerminalFailure()
+    if (failure) throw failure.error
+  }
+
+  private markTerminalFailure(
+    error: unknown,
+    lifecycleGeneration = this.lifecycleGeneration,
+  ): unknown {
+    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(): boolean {
@@ -906,88 +1510,313 @@ class PersistedCollectionRuntime<
     }
   }
 
+  private runInHydrationScope<TResult>(
+    task: (adapter: HydrationPersistenceAdapter) => Promise<TResult>,
+    adapter: HydrationPersistenceAdapter = this.persistence.adapter,
+  ): Promise<TResult> {
+    if (adapter.runInHydrationScope) {
+      return adapter.runInHydrationScope(task)
+    }
+    return Promise.resolve().then(() => task(adapter))
+  }
+
   async ensureStarted(): Promise<void> {
+    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!: () => void
+    let rejectStartupMetadata!: (error: unknown) => void
+    this.startupMetadataPromise = new Promise<void>((resolve, reject) => {
+      resolveStartupMetadata = resolve
+      rejectStartupMetadata = reject
+    })
+    void this.startupMetadataPromise.catch(() => undefined)
+
+    this.startPromise = (async () => {
+      const loadStartupMetadata = async (
+        adapter: HydrationPersistenceAdapter,
+      ) => {
+        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:
+        | {
+            appliedCursor: number | undefined
+            indexBootstrapSnapshot: Array<CollectionIndexMetadata>
+            completedLocalIndexSignatures: Set<string>
+          }
+        | undefined
+      const scheduleStartupAsOneHydrate =
+        this.persistence.adapter.runInHydrationScope !== undefined &&
+        (!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 undefined
+            return this.startInternal(
+              lifecycleGeneration,
+              adapter,
+              resolveStartupMetadata,
+            )
+          })
+          if (lifecycleGeneration === this.lifecycleGeneration) {
+            await this.flushQueuedTxCommittedUnsafe()
+          }
+          return result
+        })
+      } else {
+        // Preserve the existing unscheduled-adapter lifecycle contract: a
+        // replacement upstream may start while stale hydration is settling.
+        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 !== undefined &&
+        lifecycleGeneration === this.lifecycleGeneration
+      ) {
+        await this.requestCoordinatorPersistedIndexes(
+          startup.indexBootstrapSnapshot,
+          startup.completedLocalIndexSignatures,
+        )
+        if (
+          startup.appliedCursor !== undefined &&
+          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(() => undefined)
     return this.startPromise
   }
 
-  async ensureStartupMetadataLoaded(): Promise<void> {
-    if (this.startupMetadataPromise) {
-      return this.startupMetadataPromise
+  ensureResumeBaselineHydrated(): Promise<void> {
+    this.throwIfTerminal()
+    if (this.resumeBaselinePromise) {
+      return this.resumeBaselinePromise
     }
 
-    this.startupMetadataPromise = this.loadStartupMetadataInternal()
-    return this.startupMetadataPromise
+    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 !== undefined &&
+        lifecycleGeneration === this.lifecycleGeneration
+      ) {
+        await this.waitForAppliedReceiptsAfter(appliedCursor)
+      }
+    })().catch((error) => {
+      throw this.markTerminalFailure(error, lifecycleGeneration)
+    })
+    return this.resumeBaselinePromise
   }
 
-  private async startInternal(): Promise<void> {
-    if (this.started) {
-      return
+  ensureResumeBaselineCertified(): Promise<void> {
+    if (this.resumeCertificationPromise) {
+      return this.resumeCertificationPromise
     }
 
-    this.started = true
+    const lifecycleGeneration = this.lifecycleGeneration
+    this.resumeCertificationPromise = (async () => {
+      await this.ensureStarted()
+      if (lifecycleGeneration !== this.lifecycleGeneration) return
 
-    await this.ensureStartupMetadataLoaded()
+      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
+  }
 
-    const indexBootstrapSnapshot = this.collection?.getIndexMetadata() ?? []
-    this.attachIndexLifecycleListeners()
-    await this.bootstrapPersistedIndexes(indexBootstrapSnapshot)
+  getKeySetEvidence(): PersistedKeySetEvidence | undefined {
+    return this.persistedKeySetEvidence
+  }
 
-    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)
-    }
+  getResumeGenerationOwner(): symbol {
+    return this.resumeGenerationOwner
   }
 
-  private async loadStartupMetadataInternal(): Promise<void> {
-    // Restore stream position from the database so that new mutations
-    // don't collide with previously applied transactions.
-    if (this.persistence.adapter.getStreamPosition) {
-      const position = await this.persistence.adapter.getStreamPosition(
-        this.collectionId,
-      )
-      this.observeStreamPosition(
-        position.latestTerm,
-        position.latestSeq,
-        position.latestRowVersion,
-      )
-    }
+  private async hydrateBaseline(
+    lifecycleGeneration: number,
+    adapter: HydrationPersistenceAdapter,
+  ): Promise<number | undefined> {
+    if (lifecycleGeneration !== this.lifecycleGeneration) return undefined
 
-    await this.loadCollectionMetadataIntoCollection()
+    // The baseline shares the unconstrained demand key. Its lease is never
+    // released, and every reload rereads it, so that coverage stays valid.
+    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
+      : undefined
   }
 
-  private async loadCollectionMetadataIntoCollection(): Promise<void> {
-    const collectionMetadata = await this.loadCollectionMetadataSnapshot()
-    this.replaceCollectionMetadataSnapshot(collectionMetadata)
+  async ensureStartupMetadataLoaded(): Promise<void> {
+    this.throwIfTerminal()
+    if (this.startupMetadataPromise) {
+      return this.startupMetadataPromise
+    }
+
+    void this.ensureStarted()
+    return this.startupMetadataPromise!
   }
 
-  private async loadCollectionMetadataSnapshot(): Promise<
-    Array<{ key: string; value: unknown }>
+  private async startInternal(
+    lifecycleGeneration: number,
+    adapter: HydrationPersistenceAdapter,
+    onStartupMetadataLoaded: () => void,
+  ): Promise<
+    | {
+        appliedCursor: number | undefined
+        indexBootstrapSnapshot: Array<CollectionIndexMetadata>
+        completedLocalIndexSignatures: Set<string>
+      }
+    | undefined
   > {
-    if (!this.persistence.adapter.loadCollectionMetadata) {
+    if (lifecycleGeneration !== this.lifecycleGeneration) return undefined
+
+    const indexBootstrapSnapshot = this.collection?.getIndexMetadata() ?? []
+    this.attachIndexLifecycleListeners()
+    const completedLocalIndexSignatures = await this.bootstrapPersistedIndexes(
+      indexBootstrapSnapshot,
+      adapter,
+    )
+    if (lifecycleGeneration !== this.lifecycleGeneration) return undefined
+
+    // Let the source run only once the startup hydrate is about to begin.
+    // Its first transaction must bind to that hydrate's sequence, not the
+    // sequence before index bootstrap yielded.
+    onStartupMetadataLoaded()
+    const appliedCursor =
+      this.syncMode !== `on-demand`
+        ? await this.hydrateBaseline(lifecycleGeneration, adapter)
+        : undefined
+    return lifecycleGeneration === this.lifecycleGeneration
+      ? {
+          appliedCursor,
+          indexBootstrapSnapshot,
+          completedLocalIndexSignatures,
+        }
+      : undefined
+  }
+
+  private async loadStartupMetadataInternal(
+    lifecycleGeneration: number,
+    adapter: HydrationPersistenceAdapter,
+  ): Promise<void> {
+    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
+  }
+
+  private async loadCollectionMetadataSnapshot(
+    adapter: HydrationPersistenceAdapter,
+  ): Promise<Array<{ key: string; value: unknown }>> {
+    if (!adapter.loadCollectionMetadata) {
       return []
     }
 
-    return this.persistence.adapter.loadCollectionMetadata(this.collectionId)
+    return adapter.loadCollectionMetadata(this.collectionId)
   }
 
   private replaceCollectionMetadataSnapshot(
     collectionMetadata: Array<{ key: string; value: unknown }>,
-  ): void {
+  ): SyncAppliedReceipt {
     if (
       !this.syncControls.begin ||
       !this.syncControls.commit ||
       !this.syncControls.metadata
     ) {
-      return
+      return true
     }
 
     const nextMetadata = new Map(
@@ -997,7 +1826,7 @@ class PersistedCollectionRuntime<
       .list()
       .map(({ key }) => key)
 
-    this.withInternalApply(() => {
+    return this.withInternalApply(() => {
       this.syncControls.begin?.({ immediate: true })
 
       currentKeys.forEach((key) => {
@@ -1010,7 +1839,7 @@ class PersistedCollectionRuntime<
         this.syncControls.metadata?.collection.set(key, value)
       })
 
-      this.syncControls.commit?.()
+      return this.syncControls.commit?.() ?? true
     })
   }
 
@@ -1018,19 +1847,62 @@ class PersistedCollectionRuntime<
     options: LoadSubsetOptions,
     upstreamLoadSubset?: LoadSubsetFn,
   ): Promise<void> {
-    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)
+    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 (upstreamLoadSubset) {
+    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 ||
@@ -1042,40 +1914,177 @@ class PersistedCollectionRuntime<
           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: LoadSubsetOptions,
+    upstreamLoadSubset?: LoadSubsetFn,
+  ): true | Promise<void> | undefined {
+    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: true | Promise<void>
+    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: unknown) => {
+        this.noteUpstreamLoadFailure(options, error)
+        throw error
+      },
+    )
+  }
+
+  private noteUpstreamLoadFailure(
+    options: LoadSubsetOptions,
+    error: unknown,
+  ): void {
+    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(): void {
+    this.sourceTruncateGeneration++
+    this.hydratedDemands.clear()
+  }
+
   unloadSubset(
     options: LoadSubsetOptions,
     upstreamUnloadSubset?: (options: LoadSubsetOptions) => void,
   ): void {
-    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 as unknown as (
+            options: LoadSubsetOptions,
+          ) => unknown
+        )(options)
+        void Promise.resolve(result).catch((error) => {
+          this.reportSyncError(error)
+        })
+      } catch (error) {
+        this.reportSyncError(error)
+      }
+    }
   }
 
   async forceReloadSubset(options: LoadSubsetOptions): Promise<void> {
-    this.activeSubsets.set(this.getSubsetKey(options), options)
-    await this.applyMutex.run(() =>
-      this.hydrateSubsetUnsafe(options, { requestRemoteEnsure: false }),
-    )
+    this.throwIfTerminal()
+    const lifecycleGeneration = this.lifecycleGeneration
+    // A one-shot refresh does not acquire an enduring subscription lease.
+    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: BufferedSyncTransaction<T, TKey>,
   ): void {
+    const failure = this.getCurrentTerminalFailure()
+    if (failure) {
+      transaction.rejectApplied?.(failure.error)
+      return
+    }
     this.queuedHydrationTransactions.push(transaction)
   }
 
-  async persistAndBroadcastExternalSyncTransaction(
+  applyHydrationBufferedTransaction(
     transaction: BufferedSyncTransaction<T, TKey>,
   ): Promise<void> {
-    await this.applyMutex.run(() =>
-      this.persistAndBroadcastExternalSyncTransactionUnsafe(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(
@@ -1092,10 +2101,6 @@ class PersistedCollectionRuntime<
       const previousValue = this.collection.get(key) ?? ({} as T)
 
       return {
-        forwardMessage: {
-          type: `delete`,
-          key,
-        },
         operation: {
           type: `delete`,
           key,
@@ -1111,10 +2116,6 @@ class PersistedCollectionRuntime<
       const previousValue = this.collection.get(key) ?? message.value
 
       return {
-        forwardMessage: {
-          type: `delete`,
-          key,
-        },
         operation: {
           type: `delete`,
           key,
@@ -1125,11 +2126,6 @@ class PersistedCollectionRuntime<
 
     const key = this.collection.getKeyFromItem(message.value)
     return {
-      forwardMessage: {
-        type: `update`,
-        value: message.value,
-        metadata: message.metadata,
-      },
       operation: {
         type: `update`,
         key,
@@ -1141,32 +2137,55 @@ class PersistedCollectionRuntime<
 
   async persistAndConfirmCollectionMutations(
     mutations: Array<PendingMutation<T>>,
+    lifecycleGeneration = this.lifecycleGeneration,
   ): Promise<void> {
+    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 () => {
+        // Startup metadata establishes the durable term/sequence boundary. A
+        // mutation admitted before it resolves must wait rather than allocate a
+        // default position that can collide with an already-applied transaction.
+        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),
         )
-      }
 
-      this.confirmMutationsSyncUnsafe(acceptedMutations)
-    })
+        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)
+      }
+      throw error
+    }
   }
 
   async acceptTransactionMutations(transaction: {
     mutations: Array<PendingMutation<Record<string, unknown>>>
   }): Promise<void> {
+    this.throwIfTerminal()
     const collectionMutations = this.filterMutationsForCollection(
       transaction.mutations,
     )
@@ -1178,14 +2197,42 @@ class PersistedCollectionRuntime<
     await this.persistAndConfirmCollectionMutations(collectionMutations)
   }
 
-  cleanup(): void {
-    this.coordinatorUnsubscribe?.()
+  cleanup(): Promise<void> {
+    this.advanceLifecycle()
+    const remoteReleases: Array<Promise<void>> = []
+    const failures: Array<unknown> = []
+    const attempt = (callback: () => void): void => {
+      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) {
@@ -1195,12 +2242,37 @@ 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],
+        })
+      }
+    })
+  }
+
+  private advanceLifecycle(): void {
+    this.lifecycleGeneration++
+    this.persistedReadiness?.set({ status: `loading` })
+    this.startupSettled = false
+    this.hydratedDemands.clear()
+    this.startupMetadataPromise = null
+    this.startPromise = null
+    this.resumeBaselinePromise = null
+    this.terminalFailure = undefined
+    this.resumeCertificationPromise = null
+    this.persistedKeySetEvidence = undefined
+    this.persistedResumeGeneration = undefined
+    this.resumeGenerationOwner = Symbol(`persisted resume generation owner`)
   }
 
   private withInternalApply<TResult>(task: () => TResult): TResult {
@@ -1224,8 +2296,9 @@ class PersistedCollectionRuntime<
 
   private loadSubsetRowsUnsafe(
     options: LoadSubsetOptions,
+    adapter: HydrationPersistenceAdapter,
   ): Promise<Array<{ key: TKey; value: T; metadata?: unknown }>> {
-    return this.persistence.adapter.loadSubset(this.collectionId, options, {
+    return adapter.loadSubset(this.collectionId, options, {
       requiredIndexSignatures: this.getRequiredIndexSignatures(),
     }) as Promise<Array<{ key: TKey; value: T; metadata?: unknown }>>
   }
@@ -1246,6 +2319,7 @@ class PersistedCollectionRuntime<
   async scanPersistedRows(
     options?: PersistedRowScanOptions,
   ): Promise<Array<PersistedScannedRow<T, TKey>>> {
+    this.throwIfTerminal()
     return this.applyMutex.run(() => this.scanPersistedRowsUnsafe(options))
   }
 
@@ -1253,37 +2327,249 @@ class PersistedCollectionRuntime<
     options: LoadSubsetOptions,
     config: {
       requestRemoteEnsure: boolean
+      lifecycleGeneration: number
+      bindKeySetEvidence?: boolean
+      requestLocalLoadFailure?: boolean
+      rejectBufferedReplayFailure?: boolean
     },
+    adapter: HydrationPersistenceAdapter,
   ): Promise<void> {
-    this.isHydrating = true
+    let rowsLoaded = false
+    let replayFailure: { reason: unknown } | undefined
+    const resetSequence = this.resetSequence
+    this.hydrationSequence++
+    const hydrationContext = { suppliedRowKeys: new Set<TKey>() }
+    this.activeHydrationContext = hydrationContext
     try {
-      const rows = await this.loadSubsetRowsUnsafe(options)
+      this.throwIfTerminal()
+      this.hydratingGeneration = config.lifecycleGeneration
+      try {
+        let rows: Array<{ key: TKey; value: T; metadata?: unknown }>
+        if (config.bindKeySetEvidence) {
+          const snapshot = await adapter.loadResumeSnapshot(this.collectionId, {
+            requiredIndexSignatures: this.getRequiredIndexSignatures(),
+            includeRows: true,
+          })
+          rows = snapshot.rows as Array<{
+            key: TKey
+            value: T
+            metadata?: unknown
+          }>
+          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
+        }
+      }
 
-      this.applyRowsToCollection(rows)
+      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) {
+        // Keep admitting source work to the hydration queue while recovery
+        // reconstructs any persisted baseline required by partial updates.
+        // The failed subset itself owns no rows, so recovery must evaluate
+        // each queued transaction against the durable snapshot at its exact
+        // FIFO cut instead of treating the snapshot as a successful load.
+        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 = undefined
+      }
+    }
+    if (replayFailure && config.rejectBufferedReplayFailure) {
+      throw replayFailure.reason
     }
+  }
+
+  private async recoverBufferedTransactionsAfterLocalLoadFailureUnsafe(
+    lifecycleGeneration: number,
+    adapter: HydrationPersistenceAdapter,
+  ): Promise<void> {
+    let snapshotRows:
+      | Map<TKey, { key: TKey; value: T; metadata?: unknown }>
+      | undefined
+    type RecoveryPresence = `present` | `absent` | `unknown`
+    const recoveredPresence = new Map<TKey, RecoveryPresence>()
+    let snapshotInvalidatedByTruncate = false
+
+    while (this.queuedHydrationTransactions.length > 0) {
+      const transaction = this.queuedHydrationTransactions.shift()
+      if (!transaction) continue
+
+      try {
+        this.throwIfLifecycleReplaced(lifecycleGeneration)
+        const baselineRows = new Map<
+          TKey,
+          { key: TKey; value: T; metadata?: unknown }
+        >()
+        const transactionPresence = new Map<TKey, RecoveryPresence>()
+        const transactionStartsWithTruncate = transaction.truncate
+        const getPresence = (key: TKey): RecoveryPresence => {
+          const known = transactionPresence.get(key)
+          if (known !== undefined) return known
+          if (transactionStartsWithTruncate) {
+            transactionPresence.set(key, `absent`)
+            return `absent`
+          }
+          const recovered = recoveredPresence.get(key)
+          if (recovered !== undefined) {
+            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 === undefined) {
+                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 as Array<{
+                      key: TKey
+                      value: T
+                      metadata?: unknown
+                    }>
+                  ).map((row) => [row.key, row]),
+                )
+              }
+              const baseline = snapshotRows.get(key)
+              if (baseline === undefined) {
+                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) {
+            // Fold the durable baseline into the dependent reservation. It
+            // must never become a separately observable publication: the
+            // partial source value and its unseen fields are one atomic row.
+            if (!transaction.signal?.aborted) {
+              transaction.prependHydrationRows([...baselineRows.values()])
+            }
+          }
+        }
 
-    await this.flushQueuedHydrationTransactionsUnsafe()
-    await this.flushQueuedTxCommittedUnsafe()
+        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
+      }
+    }
+  }
 
-    if (config.requestRemoteEnsure) {
-      this.queueRemoteSubsetEnsure(options)
+  private rejectQueuedHydrationTransactions(error: unknown): void {
+    for (const transaction of this.queuedHydrationTransactions) {
+      transaction.rejectApplied?.(error)
     }
+    this.queuedHydrationTransactions.length = 0
   }
 
   private applyRowsToCollection(
     rows: Array<{ key: TKey; value: T; metadata?: unknown }>,
-  ): void {
+  ): SyncAppliedReceipt {
     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) {
@@ -1297,21 +2583,81 @@ class PersistedCollectionRuntime<
         })
       }
 
-      this.syncControls.commit?.()
+      return this.syncControls.commit?.() ?? true
     })
   }
 
+  private getResumeSnapshotGeneration(snapshot: {
+    latestTerm: number
+    latestSeq: number
+    latestRowVersion: number
+    resetEpoch: number
+  }): PersistedResumeGeneration {
+    return {
+      latestTerm: snapshot.latestTerm,
+      latestSeq: snapshot.latestSeq,
+      latestRowVersion: snapshot.latestRowVersion,
+      resetEpoch: snapshot.resetEpoch,
+    }
+  }
+
+  private isExpectedResumeGeneration(
+    generation: PersistedResumeGeneration,
+  ): boolean {
+    const expected = this.persistedResumeGeneration
+    return (
+      expected !== undefined &&
+      expected.latestTerm === generation.latestTerm &&
+      expected.latestSeq === generation.latestSeq &&
+      expected.latestRowVersion === generation.latestRowVersion &&
+      expected.resetEpoch === generation.resetEpoch
+    )
+  }
+
+  private bindResumeSnapshotEvidence(snapshot: {
+    keySet?: PersistedKeySetEvidence
+    latestTerm: number
+    latestSeq: number
+    latestRowVersion: number
+    resetEpoch: number
+  }): void {
+    const generation = this.getResumeSnapshotGeneration(snapshot)
+    const previousEvidenceStatus = this.persistedKeySetEvidence?.status
+    // An uncertified sync baseline never authorized a persisted resume cursor,
+    // so a later atomic snapshot may replace its evidence while the source
+    // performs the already-required fresh snapshot. Local-only collections
+    // have no remote cursor to fence; a managed write may advance a still-
+    // consistent SQLite baseline during startup. Incompatible evidence remains
+    // fail-closed in both modes.
+    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` }
+  }
+
   private replaceCollectionSnapshot(
     rows: Array<{ key: TKey; value: T; metadata?: unknown }>,
     collectionMetadata: Array<{ key: string; value: unknown }>,
-  ): void {
+  ): SyncAppliedReceipt {
     if (
       !this.syncControls.begin ||
       !this.syncControls.write ||
       !this.syncControls.commit ||
       !this.syncControls.metadata
     ) {
-      return
+      return true
     }
 
     const nextMetadata = new Map(
@@ -1321,7 +2667,7 @@ class PersistedCollectionRuntime<
       .list()
       .map(({ key }) => key)
 
-    this.withInternalApply(() => {
+    return this.withInternalApply(() => {
       this.syncControls.begin?.({ immediate: true })
       this.syncControls.truncate?.()
 
@@ -1343,18 +2689,25 @@ class PersistedCollectionRuntime<
         this.syncControls.metadata?.collection.set(key, value)
       })
 
-      this.syncControls.commit?.()
+      return this.syncControls.commit?.() ?? true
     })
   }
 
-  private async flushQueuedHydrationTransactionsUnsafe(): Promise<void> {
+  private async flushQueuedHydrationTransactionsUnsafe(
+    adapter: HydrationPersistenceAdapter,
+  ): Promise<{ reason: unknown } | undefined> {
+    let operationFailure: { reason: unknown } | undefined
     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) {
@@ -1364,133 +2717,168 @@ class PersistedCollectionRuntime<
         throw error
       }
     }
+    return operationFailure
   }
 
   private async applyBufferedSyncTransactionUnsafe(
     transaction: BufferedSyncTransaction<T, TKey>,
-  ): Promise<void> {
-    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 = (): SyncAppliedReceipt => {
-      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)
-    }
+    scopedAdapter?: HydrationPersistenceAdapter,
+  ): Promise<{
+    applied: boolean
+    hydrationFailure?: { reason: unknown }
+  }> {
+    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()
+        ? 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 }
+              : undefined,
+        }
+      }
+      throw terminalError
     }
   }
 
+  private classifyBufferedTransactionFailure(
+    transaction: BufferedSyncTransaction<T, TKey>,
+    error: unknown,
+  ): unknown {
+    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)
+  }
+
   private async persistAndBroadcastExternalSyncTransactionUnsafe(
     transaction: BufferedSyncTransaction<T, TKey>,
+    scopedAdapter?: HydrationPersistenceAdapter,
   ): Promise<void> {
     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 as Record<string, unknown>,
-          })),
-        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 !== undefined
+    ) {
+      this.persistedResumeGeneration = {
+        ...this.persistedResumeGeneration,
+        latestTerm: response.term,
+        latestSeq: response.seq,
+        latestRowVersion: response.latestRowVersion,
+      }
+    }
+  }
+
+  private async applyCommittedTx(
+    tx: PersistedTx,
+    lifecycleGeneration: number,
+  ): Promise<void> {
+    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)
   }
 
   private createPersistedTxFromOperations(
@@ -1572,9 +2960,9 @@ class PersistedCollectionRuntime<
     }
   }
 
-  private confirmMutationsSyncUnsafe(
+  private async confirmMutationsSyncUnsafe(
     mutations: Array<PendingMutation<T>>,
-  ): void {
+  ): Promise<void> {
     if (
       !this.syncControls.begin ||
       !this.syncControls.write ||
@@ -1583,7 +2971,7 @@ class PersistedCollectionRuntime<
       return
     }
 
-    this.withInternalApply(() => {
+    const applied = this.withInternalApply(() => {
       this.syncControls.begin?.({ immediate: true })
 
       for (const mutation of mutations) {
@@ -1600,8 +2988,12 @@ class PersistedCollectionRuntime<
         }
       }
 
-      this.syncControls.commit?.()
+      return this.syncControls.commit?.() ?? true
     })
+
+    if (applied !== true) {
+      await applied
+    }
   }
 
   private filterMutationsForCollection(
@@ -1618,7 +3010,9 @@ class PersistedCollectionRuntime<
 
   private async persistCollectionMutationsUnsafe(
     mutations: Array<PendingMutation<T>>,
+    lifecycleGeneration: number,
   ): Promise<Array<string>> {
+    this.throwIfLifecycleReplaced(lifecycleGeneration)
     // When a coordinator with requestApplyLocalMutations is available, always
     // route through it — even on the leader tab. This ensures the coordinator's
     // seq/rowVersion counters stay in sync with actual writes. Without this,
@@ -1638,7 +3032,20 @@ class PersistedCollectionRuntime<
           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}`,
         )
@@ -1673,7 +3080,9 @@ class PersistedCollectionRuntime<
     // SingleProcessCoordinator). Apply directly and broadcast.
     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({
@@ -1808,39 +3217,54 @@ class PersistedCollectionRuntime<
   }
 
   private getSubsetKey(options: LoadSubsetOptions): string {
-    const subscription = options.subscription as object | undefined
-    if (subscription && typeof subscription === `object`) {
-      const existingId = this.subscriptionIds.get(subscription)
-      if (existingId) {
-        return existingId
-      }
+    // A subscription can own several independent acquisitions, including
+    // identical requests. Only releasing this options object ends its lease.
+    let id = this.requestIds.get(options)
+    if (id === undefined) {
+      id = `request:${++this.nextRequestId}`
+      this.requestIds.set(options, id)
+    }
+    return id
+  }
 
-      this.nextSubscriptionId++
-      const id = `sub:${this.nextSubscriptionId}`
-      this.subscriptionIds.set(subscription, id)
-      return id
+  private canRouteRemoteDemandThroughCoordinator(): boolean {
+    if (
+      this.getCurrentTerminalFailure() ||
+      this.mode !== `sync-present` ||
+      this.persistence.coordinator instanceof SingleProcessCoordinator
+    ) {
+      return false
     }
 
-    return `opts:${stableSerialize(normalizeSubsetOptionsForKey(options))}`
+    // A follower routes demand to the elected owner even when its own source
+    // cannot own acquisitions. Only an elected node needs a local owner.
+    return (
+      !this.persistence.coordinator.isLeader(this.collectionId) ||
+      this.remoteSubsetOwnerUnsubscribe !== null
+    )
   }
 
   private queueRemoteSubsetEnsure(options: LoadSubsetOptions): void {
     if (
-      this.mode !== `sync-present` ||
-      !this.persistence.coordinator.requestEnsureRemoteSubset ||
+      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()
   }
 
   private scheduleRemoteEnsureRetry(): void {
     if (
+      this.getCurrentTerminalFailure() ||
       this.mode !== `sync-present` ||
-      !this.persistence.coordinator.requestEnsureRemoteSubset
+      this.persistence.coordinator instanceof SingleProcessCoordinator
     ) {
       return
     }
@@ -1860,8 +3284,9 @@ class PersistedCollectionRuntime<
 
   private async flushPendingRemoteSubsetEnsures(): Promise<void> {
     if (
+      this.getCurrentTerminalFailure() ||
       this.mode !== `sync-present` ||
-      !this.persistence.coordinator.requestEnsureRemoteSubset
+      this.persistence.coordinator instanceof SingleProcessCoordinator
     ) {
       return
     }
@@ -1872,6 +3297,13 @@ class PersistedCollectionRuntime<
     }
 
     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,
@@ -1879,7 +3311,14 @@ 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)
+        }
       }
     }
 
@@ -1891,6 +3330,10 @@ class PersistedCollectionRuntime<
       return
     }
 
+    this.persistence.coordinator.setAdapterForCollection?.(
+      this.collectionId,
+      this.persistence.adapter,
+    )
     this.coordinatorUnsubscribe = this.persistence.coordinator.subscribe(
       this.collectionId,
       (message) => {
@@ -1903,23 +3346,30 @@ 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()
 
     // Allow tx:committed from self — the coordinator produces these on behalf
     // of both local and remote mutations. The seq dedup in
     // processCommittedTxUnsafe prevents double-processing of our own writes.
     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))
+        .run(() => this.processCommittedTxUnsafe(payload, lifecycleGeneration))
         .catch((error) => {
-          console.warn(`Failed to process tx:committed message:`, error)
+          this.markTerminalFailure(error, lifecycleGeneration)
         })
       return
     }
@@ -1931,9 +3381,16 @@ class PersistedCollectionRuntime<
 
     if (isCollectionResetPayload(payload)) {
       void this.applyMutex
-        .run(() => this.truncateAndReloadUnsafe())
+        .run(async () => {
+          await this.runInHydrationScope((adapter) =>
+            this.truncateAndReloadUnsafe(adapter, lifecycleGeneration),
+          )
+          if (lifecycleGeneration === this.lifecycleGeneration) {
+            await this.flushQueuedTxCommittedUnsafe()
+          }
+        })
         .catch((error) => {
-          console.warn(`Failed to process collection reset message:`, error)
+          this.markTerminalFailure(error, lifecycleGeneration)
         })
     }
   }
@@ -1944,13 +3401,18 @@ class PersistedCollectionRuntime<
       if (!queued) {
         continue
       }
-      await this.processCommittedTxUnsafe(queued)
+      await this.processCommittedTxUnsafe(
+        queued.txCommitted,
+        queued.lifecycleGeneration,
+      )
     }
   }
 
   private async processCommittedTxUnsafe(
     txCommitted: TxCommitted,
+    lifecycleGeneration = this.lifecycleGeneration,
   ): Promise<void> {
+    if (lifecycleGeneration !== this.lifecycleGeneration) return
     if (txCommitted.term < this.latestTerm) {
       return
     }
@@ -1970,7 +3432,8 @@ class PersistedCollectionRuntime<
     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 &&
@@ -1986,16 +3449,32 @@ class PersistedCollectionRuntime<
       txCommitted.latestRowVersion,
     )
 
-    await this.invalidateFromCommittedTxUnsafe(txCommitted)
+    await this.invalidateFromCommittedTxUnsafe(
+      txCommitted,
+      this.persistence.adapter,
+    )
+    if (lifecycleGeneration === this.lifecycleGeneration) {
+      await this.flushQueuedTxCommittedUnsafe()
+    }
   }
 
-  private async recoverFromSeqGapUnsafe(): Promise<void> {
+  private async recoverFromSeqGapUnsafe(
+    lifecycleGeneration: number,
+  ): Promise<void> {
+    if (lifecycleGeneration !== this.lifecycleGeneration) return
     if (this.persistence.coordinator.pullSince && this.latestRowVersion >= 0) {
+      let pullResponse: PullSinceResponse | undefined
       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(
@@ -2003,33 +3482,51 @@ class PersistedCollectionRuntime<
             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()) {
@@ -2038,30 +3535,46 @@ class PersistedCollectionRuntime<
     }
   }
 
-  private async truncateAndReloadUnsafe(): Promise<void> {
+  private async truncateAndReloadUnsafe(
+    adapter: HydrationPersistenceAdapter,
+    lifecycleGeneration = this.lifecycleGeneration,
+  ): Promise<void> {
+    if (lifecycleGeneration !== this.lifecycleGeneration) return
+    // A subscriber may reacquire reentrantly from the truncate commit.
+    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)
   }
 
   private async invalidateFromCommittedTxUnsafe(
     txCommitted: TxCommitted,
+    adapter: HydrationPersistenceAdapter,
   ): Promise<void> {
+    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
     }
 
@@ -2076,7 +3589,7 @@ class PersistedCollectionRuntime<
 
     // Has paginated subsets — fall back to full reload.
     // Targeted invalidation for paginated subsets is deferred to a future iteration.
-    await this.reloadActiveSubsetsUnsafe()
+    await reloadActiveSubsets()
   }
 
   private async applyTargetedInvalidationUnsafe(
@@ -2086,7 +3599,7 @@ class PersistedCollectionRuntime<
       (opt) => (opt.where ? compileSingleRowExpression(opt.where) : null),
     )
 
-    this.withInternalApply(() => {
+    const applied = this.withInternalApply(() => {
       this.syncControls.begin?.({ immediate: true })
 
       for (const {
@@ -2131,22 +3644,34 @@ class PersistedCollectionRuntime<
         }
       })
 
-      this.syncControls.commit?.()
+      return this.syncControls.commit?.() ?? true
     })
+    if (applied !== true) await applied
   }
 
-  private async reloadActiveSubsetsUnsafe(): Promise<void> {
+  private async reloadActiveSubsetsUnsafe(
+    adapter: HydrationPersistenceAdapter,
+  ): Promise<void> {
+    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: new Set<TKey>() }
+    this.activeHydrationContext = hydrationContext
+    this.hydratingGeneration = lifecycleGeneration
     try {
       const mergedRows = new Map<TKey, { value: T; metadata?: unknown }>()
-      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,
@@ -2155,7 +3680,11 @@ 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,
@@ -2163,12 +3692,34 @@ 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 = undefined
+      }
+    }
+    if (lifecycleGeneration === this.lifecycleGeneration) {
+      await this.flushQueuedHydrationTransactionsUnsafe(adapter)
+      // Coordinator commits queued during this hydrate are processed outside
+      // its scope. Leave the synchronous fast path closed until a later load
+      // if any such commit still needs to be applied.
+      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()
   }
 
   private attachIndexLifecycleListeners(): void {
@@ -2193,16 +3744,33 @@ class PersistedCollectionRuntime<
 
   private async bootstrapPersistedIndexes(
     indexMetadataSnapshot?: Array<CollectionIndexMetadata>,
-  ): Promise<void> {
+    adapter: HydrationPersistenceAdapter = this.persistence.adapter,
+  ): Promise<Set<string>> {
     const collection = this.collection
     if (!collection && !indexMetadataSnapshot) {
-      return
+      return new Set()
     }
 
     const indexMetadata =
       indexMetadataSnapshot ?? collection?.getIndexMetadata() ?? []
+    const completedLocalIndexSignatures = new Set<string>()
+    for (const metadata of indexMetadata) {
+      if (await this.ensureLocalPersistedIndex(metadata, adapter)) {
+        completedLocalIndexSignatures.add(metadata.signature)
+      }
+    }
+    return completedLocalIndexSignatures
+  }
+
+  private async requestCoordinatorPersistedIndexes(
+    indexMetadata: Array<CollectionIndexMetadata>,
+    completedLocalIndexSignatures: ReadonlySet<string>,
+  ): Promise<void> {
     for (const metadata of indexMetadata) {
-      await this.ensurePersistedIndex(metadata)
+      await this.requestCoordinatorPersistedIndex(
+        metadata,
+        completedLocalIndexSignatures.has(metadata.signature),
+      )
     }
   }
 
@@ -2221,24 +3789,47 @@ class PersistedCollectionRuntime<
 
   private async ensurePersistedIndex(
     indexMetadata: CollectionIndexMetadata,
+    adapter: HydrationPersistenceAdapter = this.persistence.adapter,
   ): Promise<void> {
+    const completedLocally = await this.ensureLocalPersistedIndex(
+      indexMetadata,
+      adapter,
+    )
+    await this.requestCoordinatorPersistedIndex(indexMetadata, completedLocally)
+  }
+
+  private async ensureLocalPersistedIndex(
+    indexMetadata: CollectionIndexMetadata,
+    adapter: HydrationPersistenceAdapter,
+  ): Promise<boolean> {
     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
     }
+  }
+
+  private async requestCoordinatorPersistedIndex(
+    indexMetadata: CollectionIndexMetadata,
+    completedLocally: boolean,
+  ): Promise<void> {
+    const spec = this.buildPersistedIndexSpec(indexMetadata)
 
     try {
       await this.persistence.coordinator.requestEnsurePersistedIndex(
         this.collectionId,
         indexMetadata.signature,
         spec,
+        completedLocally ? this.persistence.adapter : undefined,
+        completedLocally,
       )
     } catch (error) {
       console.warn(
@@ -2272,67 +3863,406 @@ function createWrappedSyncConfig<
 >(
   sourceSyncConfig: SyncConfig<T, TKey>,
   runtime: PersistedCollectionRuntime<T, TKey>,
+  persistedReadiness?: PersistedReadinessTracker,
 ): SyncConfig<T, TKey> {
   return {
     ...sourceSyncConfig,
     sync: (params) => {
       const transactionStack: Array<OpenSyncTransaction<T, TKey>> = []
+      const pendingPublicationTransactions: Array<
+        OpenSyncTransaction<T, TKey>
+      > = []
       const getOpenTransaction = () =>
         transactionStack[transactionStack.length - 1]
+      const settlePublicationAdmissionWaiters = (
+        transaction: OpenSyncTransaction<T, TKey>,
+        error?: unknown,
+      ) => {
+        const waiters = transaction.publicationAdmissionWaiters
+        transaction.publicationAdmissionWaiters = undefined
+        if (!waiters) return
+        for (const waiter of waiters) {
+          if (error === undefined) waiter.resolve()
+          else waiter.reject(error)
+        }
+      }
+      const bindToCurrentHydration = (
+        transaction: OpenSyncTransaction<T, TKey>,
+      ) => {
+        if (transaction.internal || !runtime.isHydratingNow()) return
+        const hydrationSequence = runtime.getHydrationSequence()
+        if (
+          transaction.hydrationSequence !== undefined &&
+          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: OpenSyncTransaction<T, TKey>,
+      ) => {
+        if (
+          transaction.hydrationSequence !== undefined &&
+          transaction.hydrationSequence !== runtime.getHydrationSequence()
+        ) {
+          throw new InvalidPersistedCollectionConfigError(
+            `a persisted sync transaction cannot cross a hydration cycle`,
+          )
+        }
+      }
+      const markPendingMetadataDependency = (
+        transaction: OpenSyncTransaction<T, TKey>,
+      ) => {
+        const openTransaction = getOpenTransaction()
+        if (openTransaction && !openTransaction.internal) {
+          transaction.hasDependentSuccessor = true
+        }
+      }
+      const removePendingPublicationTransaction = (
+        transaction: OpenSyncTransaction<T, TKey>,
+      ) => {
+        const index = pendingPublicationTransactions.indexOf(transaction)
+        if (index !== -1) pendingPublicationTransactions.splice(index, 1)
+      }
+      const settlePendingTransaction = (
+        transaction: OpenSyncTransaction<T, TKey>,
+      ) => {
+        removePendingPublicationTransaction(transaction)
+      }
+      const settleRuntimeTransaction = (
+        transaction: OpenSyncTransaction<T, TKey>,
+        applied: Promise<void>,
+      ) => {
+        void applied.then(
+          () => settlePendingTransaction(transaction),
+          () => {
+            settlePendingTransaction(transaction)
+          },
+        )
+      }
+      const getPendingRowMetadataWrite = (key: TKey) => {
+        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` as const },
+            }
+          }
+        }
+        return { found: false as const }
+      }
+      const getPendingCollectionMetadataWrite = (key: string) => {
+        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 as const }
+      }
       let fullStartPromise: Promise<void> | null = null
-      const acquisitions = new Map<LoadSubsetOptions, { forwarded: boolean }>()
+      let sourceResultPromise: Promise<SyncConfigRes> | null = null
+      let resolveSourceResultAssigned!: () => void
+      const sourceResultAssigned = new Promise<void>((resolve) => {
+        resolveSourceResultAssigned = resolve
+      })
+      const startupState = { cleanedUp: false }
+      const isCleanedUp = () => startupState.cleanedUp
+      type SubsetAcquisition = {
+        forwarded: boolean
+        cancelAdmissionWait?: () => void
+      }
+      const acquisitions = new Map<LoadSubsetOptions, SubsetAcquisition>()
+      const waitForPublicationAdmission = (
+        transaction: OpenSyncTransaction<T, TKey>,
+        options: LoadSubsetOptions,
+        acquisition: SubsetAcquisition,
+      ): Promise<void> => {
+        if (options.signal?.aborted) {
+          return Promise.reject(
+            options.signal.reason ?? new SyncTransactionAbortedError(),
+          )
+        }
+        return new Promise<void>((resolve, reject) => {
+          const waiters =
+            transaction.publicationAdmissionWaiters ??
+            (transaction.publicationAdmissionWaiters = new Set())
+          let settled = false
+          const settle = (action: () => void) => {
+            if (settled) return
+            settled = true
+            waiters.delete(waiter)
+            options.signal?.removeEventListener(`abort`, abort)
+            acquisition.cancelAdmissionWait = undefined
+            action()
+          }
+          const waiter = {
+            resolve: () => settle(resolve),
+            reject: (error: unknown) => 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: unknown) => {
+        if (persistedReadiness?.getSnapshot().status !== `loading`) {
+          runtime.reportSyncError(error)
+          return
+        }
+        // An early network error must not stop the live-query graph before
+        // the persisted baseline has published its rows.
+        void (fullStartPromise ?? runtime.ensureStarted()).then(
+          () => {
+            if (!isCleanedUp() && !getTerminalFailure()) {
+              runtime.reportSyncError(error)
+            }
+          },
+          () => undefined,
+        )
+      }
+      const createHandledRejection = (error: unknown): Promise<never> => {
+        const rejected = Promise.reject(error)
+        void rejected.catch(() => undefined)
+        return rejected
+      }
+      const applyTransactionToCollection = (
+        transaction: OpenSyncTransaction<T, TKey>,
+        signal?: AbortSignal,
+      ): SyncAppliedReceipt => {
+        if (transaction.applicationReceipt !== undefined) {
+          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()
+
+          // A buffered source replay is part of the hydrate that owns it.
+          // It must not wait for a mutation whose persistence is queued
+          // behind that hydrate's apply mutex.
+          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 as SyncControlFns<T, TKey>[`write`],
         commit: params.commit,
         truncate: params.truncate,
         metadata: params.metadata ?? null,
+        markError: params.markError,
       })
       runtime.setCollection(
         params.collection as Collection<T, TKey, PersistedCollectionUtils>,
       )
 
+      const persistenceCapability: SyncPersistenceCapabilityV1<TKey> = {
+        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 ? undefined : 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: () => {
+          if (startupState.cleanedUp || getTerminalFailure()) return
           void (fullStartPromise ?? runtime.ensureStarted())
-            .then(() => {
-              params.markReady()
-            })
-            .catch((error) => {
-              console.warn(
-                `Failed persisted sync startup before markReady:`,
-                error,
-              )
+            .then(async () => {
+              if (isCleanedUp() || getTerminalFailure()) return
+              await sourceResultAssigned
+              try {
+                await sourceResultPromise
+              } catch (error) {
+                reportUpstreamError(error)
+                return
+              }
+              if (isCleanedUp() || getTerminalFailure()) return
               params.markReady()
             })
+            .catch(() => undefined)
         },
         begin: (options?: { immediate?: boolean }) => {
+          if (startupState.cleanedUp) return undefined
+          const terminalFailure = getTerminalFailure()
+          const internal = runtime.isApplyingInternally()
           const transaction: OpenSyncTransaction<T, TKey> = {
             operations: [],
+            partialUpdateOperationIndexes: new Set(),
             rowMetadataWrites: new Map(),
             collectionMetadataWrites: new Map(),
+            deferredHydrationMetadataDeleteKeys: new Set(),
             truncate: false,
-            internal: runtime.isApplyingInternally(),
+            internal,
+            lifecycleGeneration: runtime.getLifecycleGeneration(),
+            beginOptions: options,
+            operationKeys: new Set(),
+            hasDependentSuccessor: false,
             queuedBecauseHydrating:
-              !runtime.isApplyingInternally() && runtime.isHydratingNow(),
+              terminalFailure === undefined &&
+              !internal &&
+              runtime.isHydratingNow(),
+            hydrationSequence:
+              terminalFailure === undefined && !internal
+                ? runtime.getHydrationSequence()
+                : undefined,
+            hydrationContext:
+              terminalFailure === undefined &&
+              !internal &&
+              runtime.isHydratingNow()
+                ? runtime.getActiveHydrationContext()
+                : undefined,
+            ...(terminalFailure === undefined ? {} : { terminalFailure }),
           }
           transactionStack.push(transaction)
-
-          if (!transaction.queuedBecauseHydrating) {
-            params.begin(options)
-          }
         },
         write: (message: ChangeMessageOrDeleteKeyMessage<T, TKey>) => {
-          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`,
@@ -2344,7 +4274,11 @@ function createWrappedSyncConfig<
             // Reset stale metadata for a fresh insert, but don't clobber an
             // explicit metadata write already queued for this key in the same
             // transaction (e.g. query reconcile stamps owners, then inserts).
-            if (
+            if (openTransaction.queuedBecauseHydrating) {
+              openTransaction.deferredHydrationMetadataDeleteKeys.add(
+                normalization.operation.key,
+              )
+            } else if (
               !openTransaction.rowMetadataWrites.has(
                 normalization.operation.key,
               )
@@ -2362,14 +4296,13 @@ function createWrappedSyncConfig<
               value: normalization.operation.metadata,
             })
           }
-          if (!openTransaction.queuedBecauseHydrating) {
-            params.write(normalization.forwardMessage)
-          }
         },
         metadata: params.metadata
           ? {
+              persistence: persistenceCapability,
               row: {
                 get: (key: TKey) => {
+                  if (startupState.cleanedUp) return undefined
                   const openTransaction = getOpenTransaction()
                   const pendingWrite =
                     openTransaction?.rowMetadataWrites.get(key)
@@ -2381,12 +4314,19 @@ function createWrappedSyncConfig<
                   if (openTransaction?.truncate) {
                     return undefined
                   }
+                  const pending = getPendingRowMetadataWrite(key)
+                  if (pending.found) {
+                    return pending.write.type === `delete`
+                      ? undefined
+                      : pending.write.value
+                  }
                   return params.metadata!.row.get(key)
                 },
-                scanPersisted: (options?: PersistedRowScanOptions) =>
-                  runtime.scanPersistedRows(options),
                 set: (key: TKey, value: unknown) => {
+                  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`,
@@ -2396,12 +4336,12 @@ function createWrappedSyncConfig<
                     type: `set`,
                     value,
                   })
-                  if (!openTransaction.queuedBecauseHydrating) {
-                    params.metadata!.row.set(key, value)
-                  }
                 },
                 delete: (key: TKey) => {
+                  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`,
@@ -2410,13 +4350,11 @@ function createWrappedSyncConfig<
                   openTransaction.rowMetadataWrites.set(key, {
                     type: `delete`,
                   })
-                  if (!openTransaction.queuedBecauseHydrating) {
-                    params.metadata!.row.delete(key)
-                  }
                 },
               },
               collection: {
                 get: (key: string) => {
+                  if (startupState.cleanedUp) return undefined
                   const openTransaction = getOpenTransaction()
                   const pendingWrite =
                     openTransaction?.collectionMetadataWrites.get(key)
@@ -2425,10 +4363,19 @@ function createWrappedSyncConfig<
                       ? undefined
                       : pendingWrite.value
                   }
+                  const pending = getPendingCollectionMetadataWrite(key)
+                  if (pending.found) {
+                    return pending.write.type === `delete`
+                      ? undefined
+                      : pending.write.value
+                  }
                   return params.metadata!.collection.get(key)
                 },
                 set: (key: string, value: unknown) => {
+                  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`,
@@ -2438,12 +4385,12 @@ function createWrappedSyncConfig<
                     type: `set`,
                     value,
                   })
-                  if (!openTransaction.queuedBecauseHydrating) {
-                    params.metadata!.collection.set(key, value)
-                  }
                 },
                 delete: (key: string) => {
+                  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`,
@@ -2452,16 +4399,36 @@ function createWrappedSyncConfig<
                   openTransaction.collectionMetadataWrites.set(key, {
                     type: `delete`,
                   })
-                  if (!openTransaction.queuedBecauseHydrating) {
-                    params.metadata!.collection.delete(key)
-                  }
                 },
                 list: (prefix?: string) => {
+                  if (startupState.cleanedUp) return []
                   const merged = new Map(
                     params
                       .metadata!.collection.list()
                       .map(({ key, value }) => [key, value]),
                   )
+                  const pendingOwners = new Map<
+                    string,
+                    OpenSyncTransaction<T, TKey>
+                  >()
+                  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 [
@@ -2487,35 +4454,114 @@ function createWrappedSyncConfig<
             }
           : undefined,
         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()
           // Intentionally preserve collectionMetadataWrites across truncate.
           // Callers (for example electric resume/reset handling) may stage
           // collection-scoped metadata before truncating row data, and those
           // writes must commit atomically with the truncate transaction.
           openTransaction.truncate = true
-          if (!openTransaction.queuedBecauseHydrating) {
-            params.truncate()
-          }
         },
         commit: (signal?: AbortSignal) => {
+          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(() => undefined)
-              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: Array<{ key: TKey; value: T; metadata?: unknown }>,
+            ) => {
+              const baselineOperations: Array<
+                NormalizedSyncOperation<T, TKey>
+              > = rows.map(({ key, value, metadata }) => ({
+                type: `update`,
+                key,
+                value,
+                metadata: metadata as Record<string, unknown> | undefined,
+              }))
+              openTransaction.operations = baselineOperations.concat(
+                openTransaction.operations,
+              )
+              for (const { key, metadata } of rows) {
+                if (
+                  metadata !== undefined &&
+                  !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!: () => void
             let rejectApplied!: (error: unknown) => void
             const applied = new Promise<void>((resolve, reject) => {
@@ -2524,76 +4570,142 @@ function createWrappedSyncConfig<
             })
             void applied.catch(() => undefined)
             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, applied)
             return applied
           }
 
-          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(() => undefined)
-            return persisted
+          let applied: Promise<void>
+          try {
+            applied = runtime.applyHydrationBufferedTransaction(transaction)
+          } catch (error) {
+            settlePublicationAdmissionWaiters(openTransaction, error)
+            throw error
           }
+          settlePublicationAdmissionWaiters(openTransaction)
+          settleRuntimeTransaction(openTransaction, applied)
           return applied
         },
       }
 
       let sourceResult: SyncConfigRes = {}
-      const startupState = { cleanedUp: false }
+      let sourceResultSettled = false
+      let activeSourceSyncEntry: Promise<void> | undefined
       fullStartPromise = runtime.ensureStarted()
-      const sourceResultPromise = (async () => {
+      // Startup can fail before the source reaches markReady or loadSubset,
+      // which are the two eventual consumers of this outer adopting promise.
+      // The runtime-owned inner promise still installs and reports the exact
+      // terminal failure; this observer only prevents the unused outer wrapper
+      // from becoming an unhandled rejection on that fail-stop path.
+      void fullStartPromise.catch(() => undefined)
+      sourceResultPromise = (async () => {
         await runtime.ensureStartupMetadataLoaded()
 
         if (startupState.cleanedUp) {
+          sourceResultSettled = true
           return sourceResult
         }
 
-        sourceResult = normalizeSyncFnResult(
-          sourceSyncConfig.sync(wrappedParams),
-        )
+        let settleSourceSyncEntry!: () => void
+        activeSourceSyncEntry = new Promise<void>((resolve) => {
+          settleSourceSyncEntry = resolve
+        })
+        try {
+          sourceResult = normalizeSyncFnResult(
+            sourceSyncConfig.sync(wrappedParams),
+          )
+        } finally {
+          activeSourceSyncEntry = undefined
+          settleSourceSyncEntry()
+        }
+        // Cleanup can reenter while the source sync function is still active.
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (!startupState.cleanedUp && sourceResult.loadSubset) {
+          const loadSubset = async (options: TransportedLoadSubsetOptions) => {
+            if (startupState.cleanedUp) {
+              throw new Error(`persisted sync source is no longer active`)
+            }
+            await sourceResult.loadSubset?.(
+              options as unknown as LoadSubsetOptions,
+            )
+          }
+          runtime.registerRemoteSubsetOwner(
+            Object.assign(loadSubset, {
+              unloadSubset: (options: TransportedLoadSubsetOptions) =>
+                sourceResult.unloadSubset?.(
+                  options as unknown as LoadSubsetOptions,
+                ),
+              onError: reportUpstreamError,
+            }),
+          )
+        }
+        sourceResultSettled = true
         return sourceResult
       })()
+      resolveSourceResultAssigned()
+      void sourceResultPromise.catch((error) => {
+        reportUpstreamError(error)
+      })
 
       return {
-        cleanup: () => {
+        cleanup: async () => {
           startupState.cleanedUp = true
+          // The optional source starts behind persistence metadata. If it
+          // reenters cleanup before returning, wait for that exact synchronous
+          // entry to publish its cleanup callback before sampling the result.
+          const sourceSyncEntry = activeSourceSyncEntry
+          const cleanupError = new SyncTransactionAbortedError()
+          for (const acquisition of acquisitions.values()) {
+            acquisition.cancelAdmissionWait?.()
+          }
           acquisitions.clear()
-          sourceResult.cleanup?.()
-          runtime.cleanup()
-          runtime.clearSyncControls()
-        },
-        loadSubset: async (options: LoadSubsetOptions) => {
-          const acquisition = { forwarded: false }
-          acquisitions.set(options, acquisition)
-          await fullStartPromise
-          const resolvedSourceResult = await sourceResultPromise
+          pendingPublicationTransactions.length = 0
+          for (const transaction of transactionStack) {
+            settlePublicationAdmissionWaiters(transaction, cleanupError)
+          }
+          transactionStack.length = 0
+          let sourceCleanup: Promise<void>
+          try {
+            sourceCleanup = sourceSyncEntry
+              ? sourceSyncEntry.then(() => sourceResult.cleanup?.())
+              : Promise.resolve(sourceResult.cleanup?.())
+          } catch (error) {
+            sourceCleanup = Promise.reject(error)
+          }
+          let runtimeCleanup: Promise<void>
+          try {
+            runtimeCleanup = runtime.cleanup()
+          } catch (error) {
+            runtimeCleanup = Promise.reject(error)
+          }
+          const [sourceOutcome, runtimeOutcome] = await Promise.allSettled([
+            sourceCleanup,
+            runtimeCleanup,
+          ])
           if (
-            startupState.cleanedUp ||
-            acquisitions.get(options) !== acquisition
+            sourceOutcome.status === `rejected` &&
+            runtimeOutcome.status === `rejected`
           ) {
-            return
+            throw new AggregateError(
+              [sourceOutcome.reason, runtimeOutcome.reason],
+              `Source cleanup and persistence runtime teardown both failed`,
+              { cause: sourceOutcome.reason },
+            )
           }
-          return runtime.loadSubset(options, (loadOptions) => {
+          if (sourceOutcome.status === `rejected`) throw sourceOutcome.reason
+          if (runtimeOutcome.status === `rejected`) throw runtimeOutcome.reason
+        },
+        loadSubset: (options: LoadSubsetOptions): true | Promise<void> => {
+          const acquisition = { forwarded: false }
+          acquisitions.set(options, acquisition)
+          const forwardUpstream = (
+            resolvedSourceResult: SyncConfigRes,
+            loadOptions: LoadSubsetOptions,
+          ): true | Promise<void> => {
             // Hydration is another async boundary. A release before this
             // point owns no upstream lease and must not start one later.
             if (
@@ -2605,15 +4717,67 @@ function createWrappedSyncConfig<
             if (!resolvedSourceResult.loadSubset) return true
             acquisition.forwarded = true
             try {
+              // Returning a promise transfers its lease even if it rejects.
+              // Only a synchronous throw leaves no upstream lease to release.
               return resolvedSourceResult.loadSubset(loadOptions)
             } catch (error) {
               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),
+                )
+              : undefined
+          if (hydrated !== undefined) {
+            return hydrated
+          }
+
+          return (async () => {
+            await fullStartPromise
+            const resolvedSourceResult = await sourceResultPromise
+            if (
+              startupState.cleanedUp ||
+              acquisitions.get(options) !== acquisition
+            ) {
+              return
+            }
+            const currentTransaction = getOpenTransaction()
+            // An immediate source transaction reserves its FIFO turn before
+            // subset hydration advances the generation it was built against.
+            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: LoadSubsetOptions) => {
           const acquisition = acquisitions.get(options)
+          acquisition?.cancelAdmissionWait?.()
           acquisitions.delete(options)
           runtime.unloadSubset(
             options,
@@ -2637,6 +4801,7 @@ function createLoopbackSyncConfig<
         commit: params.commit,
         truncate: params.truncate,
         metadata: params.metadata ?? null,
+        markError: params.markError,
       })
       runtime.setCollection(
         params.collection as Collection<T, TKey, PersistedCollectionUtils>,
@@ -2645,19 +4810,15 @@ function createLoopbackSyncConfig<
       void runtime
         .ensureStarted()
         .then(() => {
+          if (runtime.getCurrentTerminalFailure()) return
           params.markReady()
         })
-        .catch((error) => {
-          console.warn(`Failed persisted loopback startup:`, error)
-          params.markReady()
-        })
+        .catch(() => undefined)
 
       return {
-        cleanup: () => {
-          runtime.cleanup()
-          runtime.clearSyncControls()
-        },
-        loadSubset: (options: LoadSubsetOptions) => runtime.loadSubset(options),
+        loadSubset: (options: LoadSubsetOptions): true | Promise<void> =>
+          runtime.loadHydratedSubset(options) ?? runtime.loadSubset(options),
+        cleanup: () => runtime.cleanup(),
         unloadSubset: (options: LoadSubsetOptions) =>
           runtime.unloadSubset(options),
       }
@@ -2668,13 +4829,59 @@ function createLoopbackSyncConfig<
   }
 }
 
+export function persistedCollectionOptions<
+  TSchema extends StandardSchemaV1,
+  TKey extends string | number,
+  TUtils extends UtilsRecord = UtilsRecord,
+>(
+  options: PersistedSyncWrappedOptions<
+    InferSchemaOutput<TSchema>,
+    TKey,
+    TSchema,
+    TUtils
+  > & {
+    schema: TSchema
+  },
+): PersistedSyncOptionsResult<
+  InferSchemaOutput<TSchema>,
+  TKey,
+  TSchema,
+  TUtils
+> & {
+  schema: TSchema
+}
+
+export function persistedCollectionOptions<
+  TSchema extends StandardSchemaV1,
+  TKey extends string | number,
+  TUtils extends UtilsRecord = UtilsRecord,
+>(
+  options: PersistedLocalOnlyOptions<
+    InferSchemaOutput<TSchema>,
+    TKey,
+    TSchema,
+    TUtils
+  > & {
+    schema: TSchema
+  },
+): PersistedLocalOnlyOptionsResult<
+  InferSchemaOutput<TSchema>,
+  TKey,
+  TSchema,
+  TUtils
+> & {
+  schema: TSchema
+}
+
 export function persistedCollectionOptions<
   T extends object,
   TKey extends string | number,
   TSchema extends StandardSchemaV1 = never,
   TUtils extends UtilsRecord = UtilsRecord,
 >(
-  options: PersistedSyncWrappedOptions<T, TKey, TSchema, TUtils>,
+  options: PersistedSyncWrappedOptions<T, TKey, TSchema, TUtils> & {
+    schema?: never
+  },
 ): PersistedSyncOptionsResult<T, TKey, TSchema, TUtils>
 
 export function persistedCollectionOptions<
@@ -2683,7 +4890,9 @@ export function persistedCollectionOptions<
   TSchema extends StandardSchemaV1 = never,
   TUtils extends UtilsRecord = UtilsRecord,
 >(
-  options: PersistedLocalOnlyOptions<T, TKey, TSchema, TUtils>,
+  options: PersistedLocalOnlyOptions<T, TKey, TSchema, TUtils> & {
+    schema?: never
+  },
 ): PersistedLocalOnlyOptionsResult<T, TKey, TSchema, TUtils>
 
 export function persistedCollectionOptions<
@@ -2704,6 +4913,17 @@ export function persistedCollectionOptions<
     )
   }
 
+  const networkTimeoutMs = getNetworkTimeoutMs(options.initialRender)
+  if (networkTimeoutMs !== undefined && options.syncMode === `on-demand`) {
+    throw new InvalidPersistedCollectionConfigError(
+      `network-first initial rendering requires eager persistence syncMode`,
+    )
+  }
+  const persistedReadinessTracker =
+    networkTimeoutMs !== undefined
+      ? new PersistedReadinessTracker(networkTimeoutMs)
+      : undefined
+
   if (hasOwnSyncKey(options)) {
     if (!isValidSyncConfig(options.sync)) {
       throw new InvalidSyncConfigError(
@@ -2711,7 +4931,11 @@ export function persistedCollectionOptions<
       )
     }
 
-    const { schemaVersion, ...syncOptions } = options
+    const {
+      schemaVersion,
+      initialRender: _initialRender,
+      ...syncOptions
+    } = options
     const collectionId =
       syncOptions.id ?? `persisted-collection:${safeRandomUUID()}`
     const persistence = resolvePersistenceForCollection(
@@ -2729,13 +4953,21 @@ export function persistedCollectionOptions<
       persistence,
       syncOptions.syncMode ?? `eager`,
       collectionId,
+      persistedReadinessTracker,
     )
 
     const result = {
       ...syncOptions,
       id: collectionId,
-      sync: createWrappedSyncConfig<T, TKey>(syncOptions.sync, runtime),
+      sync: createWrappedSyncConfig<T, TKey>(
+        syncOptions.sync,
+        runtime,
+        persistedReadinessTracker,
+      ),
       persistence,
+      ...(persistedReadinessTracker
+        ? { [PERSISTED_READINESS]: persistedReadinessTracker }
+        : {}),
     }
 
     return withCollectionConfigFactory(
@@ -2744,11 +4976,15 @@ export function persistedCollectionOptions<
         persistedCollectionOptions({
           ...options,
           id: collectionId,
-        }) as typeof result,
+        } as never) as typeof result,
     )
   }
 
-  const { schemaVersion, ...localOnlyOptions } = options
+  const {
+    schemaVersion,
+    initialRender: _initialRender,
+    ...localOnlyOptions
+  } = options
   const collectionId =
     localOnlyOptions.id ?? `persisted-collection:${safeRandomUUID()}`
   const persistence = resolvePersistenceForCollection(
@@ -2765,11 +5001,13 @@ export function persistedCollectionOptions<
     persistence,
     localOnlyOptions.syncMode ?? `eager`,
     localOnlyOptions.id ?? DEFAULT_DB_NAME,
+    persistedReadinessTracker,
   )
 
   const wrappedOnInsert = async (
     params: InsertMutationFnParams<T, TKey, TUtils & PersistedCollectionUtils>,
   ) => {
+    const lifecycleGeneration = runtime.getLifecycleGeneration()
     const handlerResult = localOnlyOptions.onInsert
       ? await localOnlyOptions.onInsert(
           params as unknown as InsertMutationFnParams<T, TKey, TUtils>,
@@ -2778,6 +5016,7 @@ export function persistedCollectionOptions<
 
     await runtime.persistAndConfirmCollectionMutations(
       params.transaction.mutations as Array<PendingMutation<T>>,
+      lifecycleGeneration,
     )
 
     return handlerResult ?? {}
@@ -2786,6 +5025,7 @@ export function persistedCollectionOptions<
   const wrappedOnUpdate = async (
     params: UpdateMutationFnParams<T, TKey, TUtils & PersistedCollectionUtils>,
   ) => {
+    const lifecycleGeneration = runtime.getLifecycleGeneration()
     const handlerResult = localOnlyOptions.onUpdate
       ? await localOnlyOptions.onUpdate(
           params as unknown as UpdateMutationFnParams<T, TKey, TUtils>,
@@ -2794,6 +5034,7 @@ export function persistedCollectionOptions<
 
     await runtime.persistAndConfirmCollectionMutations(
       params.transaction.mutations as Array<PendingMutation<T>>,
+      lifecycleGeneration,
     )
 
     return handlerResult ?? {}
@@ -2802,6 +5043,7 @@ export function persistedCollectionOptions<
   const wrappedOnDelete = async (
     params: DeleteMutationFnParams<T, TKey, TUtils & PersistedCollectionUtils>,
   ) => {
+    const lifecycleGeneration = runtime.getLifecycleGeneration()
     const handlerResult = localOnlyOptions.onDelete
       ? await localOnlyOptions.onDelete(
           params as unknown as DeleteMutationFnParams<T, TKey, TUtils>,
@@ -2810,6 +5052,7 @@ export function persistedCollectionOptions<
 
     await runtime.persistAndConfirmCollectionMutations(
       params.transaction.mutations as Array<PendingMutation<T>>,
+      lifecycleGeneration,
     )
 
     return handlerResult ?? {}
@@ -2837,6 +5080,9 @@ export function persistedCollectionOptions<
     ...localOnlyOptions,
     id: collectionId,
     persistence,
+    ...(persistedReadinessTracker
+      ? { [PERSISTED_READINESS]: persistedReadinessTracker }
+      : {}),
     sync: createLoopbackSyncConfig(runtime),
     onInsert: wrappedOnInsert,
     onUpdate: wrappedOnUpdate,
@@ -2852,7 +5098,7 @@ export function persistedCollectionOptions<
       persistedCollectionOptions({
         ...options,
         id: collectionId,
-      }) as typeof result,
+      } as never) as typeof result,
   )
 }