@livestore/common 0.5.0-dev.0 → 0.5.0-dev.1

package/src/leader-thread/LeaderSyncProcessor.ts

@@ -15,6 +15,7 @@ import {
   Option,
   Predicate,
   Queue,
+  Random,
   ReadonlyArray,
   References,
   Result,
@@ -49,8 +50,7 @@ import {
   StaleRebaseGenerationError,
 } from './RejectedPushError.ts'
 import type { ShutdownChannel } from './shutdown-channel.ts'
-import type { InitialBlockingSyncContext } from './types.ts'
-import { LeaderThreadCtx } from './types.ts'
+import type { InitialBlockingSyncContext, MaterializeEvent } from './types.ts'
 
 export const TypeId = '~@livestore/common/LeaderSyncProcessor' as const
 export type TypeId = typeof TypeId
@@ -120,14 +120,15 @@ export interface Service {
   readonly boot: Effect.Effect<
     { initialLeaderHead: EventSequenceNumber.Client.Composite },
     never,
-    LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient
+    Scope.Scope | HttpClient.HttpClient
   >
   readonly syncState: Subscribable.Subscribable<SyncState.SyncState>
 }
 
 interface Options {
   readonly schema: LiveStoreSchema
-  readonly dbState: SqliteDb
+  /** Complete runtime capabilities supplied before the processor is constructed. */
+  readonly runtime: Runtime
   readonly initialBlockingSyncContext: InitialBlockingSyncContext
   /** Initial sync state rehydrated from the persisted eventlog or initial sync state */
   readonly initialSyncState: SyncState.SyncState
@@ -197,16 +198,33 @@ interface Options {
   readonly testing: {
     readonly delays?: {
       readonly localPushProcessing?: Effect.Effect<void>
+      readonly backendPullReconnect?: (fallbackMs: number) => number
     }
     readonly hooks?: {
       readonly localPushAdmitted?: (events: ReadonlyArray<LiveStoreEvent.Client.EncodedWithMeta>) => Effect.Effect<void>
+      /** Observes connectivity after the offline wait has subscribed, allowing tests to synchronize without sleeps. */
+      readonly backendPullReconnectWait?: (state: { isConnected: boolean; fallbackMs: number }) => Effect.Effect<void>
     }
   }
 }
 
+/**
+ * Runtime capabilities used by sync processing. Keeping these explicit prevents the processor from
+ * depending on the outward-facing leader aggregate that contains the processor itself.
+ */
+interface Runtime {
+  readonly dbState: SqliteDb
+  readonly dbEventlog: SqliteDb
+  readonly materializeEvent: MaterializeEvent
+  readonly syncBackend: SyncBackend.SyncBackend | undefined
+  readonly shutdownChannel: ShutdownChannel
+  readonly devtoolsLatch: Latch.Latch | undefined
+  readonly span: Tracer.Span | undefined
+}
+
 export const make = Effect.fnUntraced(function* ({
   schema,
-  dbState,
+  runtime,
   initialBlockingSyncContext,
   initialSyncState,
   onError,
@@ -216,6 +234,7 @@ export const make = Effect.fnUntraced(function* ({
   testing,
 }: Options) {
   const stateHead = yield* StateHead.StateHead
+  const { dbState, dbEventlog, devtoolsLatch, materializeEvent, shutdownChannel, span, syncBackend } = runtime
   const syncBackendPushQueue = yield* TxQueue.unbounded<LiveStoreEvent.Client.EncodedWithMeta>()
   const localPushBatchSize = params.localPushBatchSize ?? 10
   const backendPushBatchSize = params.backendPushBatchSize ?? 50
@@ -226,17 +245,7 @@ export const make = Effect.fnUntraced(function* ({
     schema.eventsDefsMap.get(eventEncoded.name)?.options.clientOnly ?? false
 
   const connectedClientSessionPullQueues = yield* makePullQueueSet
-
-  // This context depends on data from `boot`, we should find a better implementation to avoid this ref indirection.
-  const ctxRef = {
-    current: undefined as
-      | undefined
-      | {
-          span: Tracer.Span
-          devtoolsLatch: Latch.Latch | undefined
-          services: Context.Context<LeaderThreadCtx>
-        },
-  }
+  const materializeEventsBatch = makeMaterializeEventsBatch({ dbState, dbEventlog, materializeEvent })
 
   type LocalPushQueueItem = [
     event: LiveStoreEvent.Client.EncodedWithMeta,
@@ -311,7 +320,7 @@ export const make = Effect.fnUntraced(function* ({
 
         // Since the rebase generation might have changed since enqueuing, we need to filter out items with older generation
         // It's important that we filter after acquiring the localPushBackendPullMutex, otherwise we might filter with the old generation
-        const [droppedItems, filteredItems] = ReadonlyArray.partition(batchItems, (batchItem) =>
+        const [filteredItems, droppedItems] = ReadonlyArray.partition(batchItems, (batchItem) =>
           batchItem[0].seqNum.rebaseGeneration >= currentRebaseGeneration
             ? Result.succeed(batchItem)
             : Result.fail(batchItem),
@@ -381,7 +390,7 @@ export const make = Effect.fnUntraced(function* ({
             const remainingLocalPushes = yield* snapshotTxQueue(localPushesQueue)
             if (LS_DEV === true && remainingLocalPushes.length > 0) {
               console.log('localPushesQueue is not empty', remainingLocalPushes.length)
-              // oxlint-disable-next-line eslint(no-debugger) -- intentional breakpoint for unexpected queue state
+              // oxlint-disable-next-line no-debugger -- intentional breakpoint for unexpected queue state
               debugger
             }
 
@@ -458,13 +467,13 @@ export const make = Effect.fnUntraced(function* ({
 
   const backgroundBackendPulling = Effect.fn('@livestore/common:LeaderSyncProcessor:backend-pulling')(function* ({
     restartBackendPushing,
+    onPullSuccess,
   }: {
     restartBackendPushing: (
       filteredRebasedPending: ReadonlyArray<LiveStoreEvent.Client.EncodedWithMeta>,
-    ) => Effect.Effect<void, never, LeaderThreadCtx | HttpClient.HttpClient>
+    ) => Effect.Effect<void, never, HttpClient.HttpClient>
+    onPullSuccess: () => void
   }) {
-    const { syncBackend, dbState: db, dbEventlog, schema } = yield* LeaderThreadCtx
-
     if (syncBackend === undefined) return
 
     let pullMutexHeld = false
@@ -482,8 +491,8 @@ export const make = Effect.fnUntraced(function* ({
       pageInfo: SyncBackend.PullResPageInfo,
     ) =>
       Effect.gen(function* () {
-        if (ctxRef.current?.devtoolsLatch !== undefined) {
-          yield* ctxRef.current.devtoolsLatch.await
+        if (devtoolsLatch !== undefined) {
+          yield* devtoolsLatch.await
         }
 
         if (newEvents.length === 0) {
@@ -540,7 +549,7 @@ export const make = Effect.fnUntraced(function* ({
 
             if (mergeResult.rollbackEvents.length > 0) {
               yield* rollback({
-                dbState: db,
+                dbState,
                 dbEventlog,
                 eventNumsToRollback: mergeResult.rollbackEvents.map((_) => _.seqNum),
               })
@@ -576,12 +585,12 @@ export const make = Effect.fnUntraced(function* ({
                   EventSequenceNumber.Client.isEqual(event.seqNum, confirmedEvent.seqNum),
                 ),
               )
-              yield* Eventlog.updateSyncMetadata(confirmedNewEvents).pipe(Effect.orDieDebugger)
+              yield* Eventlog.updateSyncMetadataForDb(dbEventlog, confirmedNewEvents).pipe(Effect.orDieDebugger)
             }
           }
 
           // Removes the changeset rows which are no longer needed as we'll never have to rollback beyond this point
-          trimChangesetRows(db, newBackendHead)
+          trimChangesetRows(dbState, newBackendHead)
 
           // The backend merge may advance or rebase the authoritative head. Realign the admission
           // fence now so newly arriving pushes are validated against that history, not the pre-pull head.
@@ -605,7 +614,9 @@ export const make = Effect.fnUntraced(function* ({
       })
 
     const syncState = yield* Effect.fromNullishOr(yield* SubscriptionRef.get(syncStateSref)).pipe(Effect.orDieDebugger)
-    const cursorInfo = yield* Eventlog.getSyncBackendCursorInfo({ remoteHead: syncState.upstreamHead.global })
+    const cursorInfo = yield* Eventlog.getSyncBackendCursorInfoForDb(dbEventlog, {
+      remoteHead: syncState.upstreamHead.global,
+    })
 
     const hashMaterializerResult = makeMaterializerHash({ schema, dbState })
 
@@ -613,6 +624,8 @@ export const make = Effect.fnUntraced(function* ({
       // TODO only take from queue while connected
       Stream.tap(({ batch, pageInfo }) =>
         Effect.gen(function* () {
+          // Any response (including an empty batch) proves backend contact, even with stale connectivity.
+          onPullSuccess()
           // NOTE we only want to take process events when the sync backend is connected
           // (e.g. needed for simulating being offline)
           // TODO remove when there's a better way to handle this in stream above
@@ -642,7 +655,6 @@ export const make = Effect.fnUntraced(function* ({
   })
 
   const backgroundBackendPushing = Effect.gen(function* () {
-    const { syncBackend } = yield* LeaderThreadCtx
     if (syncBackend === undefined) return
 
     while (true) {
@@ -652,8 +664,8 @@ export const make = Effect.fnUntraced(function* ({
 
       yield* SubscriptionRef.waitUntil(syncBackend.isConnected, (isConnected) => isConnected === true)
 
-      if (ctxRef.current?.devtoolsLatch !== undefined) {
-        yield* ctxRef.current.devtoolsLatch.await
+      if (devtoolsLatch !== undefined) {
+        yield* devtoolsLatch.await
       }
 
       yield* Effect.spanEvent('backend-push', {
@@ -732,14 +744,14 @@ export const make = Effect.fnUntraced(function* ({
         }).pipe(Effect.uninterruptible),
       )
 
-      yield* Effect.all(deferreds.map(Deferred.await))
+      yield* Effect.forEach(deferreds, Deferred.await)
     }).pipe(
       Effect.withSpan('@livestore/common:LeaderSyncProcessor:push', {
         attributes: {
           batchSize: newEvents.length,
           batch: TRACE_VERBOSE === true ? newEvents : undefined,
         },
-        links: ctxRef.current?.span !== undefined ? [{ span: ctxRef.current.span, attributes: {} }] : undefined,
+        links: span !== undefined ? [{ span, attributes: {} }] : undefined,
       }),
     )
 
@@ -747,16 +759,6 @@ export const make = Effect.fnUntraced(function* ({
     [TypeId]: TypeId,
     // Starts various background loops
     boot: Effect.gen(function* () {
-      const span = yield* Effect.currentSpan.pipe(Effect.orDie)
-      const { devtools, shutdownChannel } = yield* LeaderThreadCtx
-      const services = yield* Effect.context<LeaderThreadCtx>()
-
-      ctxRef.current = {
-        span,
-        devtoolsLatch: devtools.enabled === true ? devtools.syncBackendLatch : undefined,
-        services,
-      }
-
       /** State transitions need to happen atomically, so we use a Ref to track the state */
       yield* SubscriptionRef.set(syncStateSref, initialSyncState)
 
@@ -772,7 +774,7 @@ export const make = Effect.fnUntraced(function* ({
       }
 
       const handleBackendIdMismatchError = (error: BackendIdMismatchError) =>
-        handleBackendIdMismatch({ error, onBackendIdMismatch, shutdownChannel })
+        handleBackendIdMismatch({ error, onBackendIdMismatch, shutdownChannel, dbEventlog, dbState })
 
       const maybeShutdownOnError = (cause: Cause.Cause<UnknownError | MaterializeError>) =>
         Effect.gen(function* () {
@@ -803,7 +805,12 @@ export const make = Effect.fnUntraced(function* ({
 
       yield* FiberHandle.run(backendPushingFiberHandle, backendPushingEffect)
 
+      let offlinePullFallbackMs = 1_000
+
       yield* backgroundBackendPulling({
+        onPullSuccess: () => {
+          offlinePullFallbackMs = 1_000
+        },
         restartBackendPushing: (filteredRebasedPending) =>
           Effect.gen(function* () {
             // Stop current pushing fiber
@@ -817,10 +824,34 @@ export const make = Effect.fnUntraced(function* ({
             yield* FiberHandle.run(backendPushingFiberHandle, backendPushingEffect)
           }),
       }).pipe(
+        Effect.tapError((error) => {
+          if (error._tag !== 'IsOfflineError' || syncBackend === undefined) return Effect.void
+          const isConnected = syncBackend.isConnected
+          return Effect.gen(function* () {
+            // Wake immediately on reconnection. Probe on a capped fallback timer if connectivity is stale.
+            const jitter = yield* Random.nextBetween(0.8, 1.2)
+            const fallbackMs =
+              testing.delays?.backendPullReconnect?.(offlinePullFallbackMs * jitter) ?? offlinePullFallbackMs * jitter
+            offlinePullFallbackMs = Math.min(offlinePullFallbackMs * 2, 30_000)
+            // A stale initial true is not a reconnect. Watch false→true even while the fallback timer is pending.
+            const waitHook = testing.hooks?.backendPullReconnectWait
+            const changes = SubscriptionRef.changes(isConnected)
+            const observedChanges =
+              waitHook === undefined
+                ? changes
+                : changes.pipe(Stream.tap((value) => waitHook({ isConnected: value, fallbackMs })))
+            const reconnected = yield* observedChanges.pipe(
+              Stream.dropWhile((value) => value === true),
+              Stream.filter((value) => value === true),
+              Stream.runHead,
+              Effect.as(true),
+              Effect.timeoutOrElse({ duration: fallbackMs, orElse: () => Effect.succeed(false) }),
+            )
+            if (reconnected === true) offlinePullFallbackMs = 1_000
+          })
+        }),
         Effect.retry({
-          // Retry pulling when we've lost connection to the sync backend
-          // We're using `until` with a refinement instead of `while` to narrow `IsOfflineError` out of the error type.
-          // See https://github.com/Effect-TS/effect/issues/6122
+          // The unbounded offline-only retry keeps IsOfflineError out of the terminal error channel.
           until: (error): error is Exclude<typeof error, IsOfflineError> => error._tag !== 'IsOfflineError',
         }),
         Effect.catchTag('BackendIdMismatchError', handleBackendIdMismatchError),
@@ -875,12 +906,7 @@ export const make = Effect.fnUntraced(function* ({
       ),
     pull: ({ cursor }) =>
       Effect.gen(function* () {
-        const queue = yield* Effect.fromNullishOr(ctxRef.current?.services).pipe(
-          Effect.orDieDebugger,
-          Effect.flatMap((services) =>
-            connectedClientSessionPullQueues.makeQueue(cursor).pipe(Effect.provide(services)),
-          ),
-        )
+        const queue = yield* connectedClientSessionPullQueues.makeQueue(cursor)
         return Stream.fromQueue(queue)
       }).pipe(Stream.unwrap),
     /*
@@ -897,11 +923,7 @@ export const make = Effect.fnUntraced(function* ({
         - full new state db snapshot in the "rebase" case
           - downside: importing the snapshot is expensive
       */
-    pullQueue: ({ cursor }) =>
-      Effect.fromNullishOr(ctxRef.current?.services).pipe(
-        Effect.orDieDebugger,
-        Effect.flatMap((services) => connectedClientSessionPullQueues.makeQueue(cursor).pipe(Effect.provide(services))),
-      ),
+    pullQueue: ({ cursor }) => connectedClientSessionPullQueues.makeQueue(cursor),
     syncState: Subscribable.make({
       get: SubscriptionRef.get(syncStateSref).pipe(Effect.flatMap(Effect.fromNullishOr), Effect.orDieDebugger),
       changes: SubscriptionRef.changes(syncStateSref).pipe(Stream.filter(Predicate.isNotUndefined)),
@@ -911,46 +933,50 @@ export const make = Effect.fnUntraced(function* ({
 
 export const layer = (options: Options) => Layer.effect(LeaderSyncProcessor, make(options))
 
-type MaterializeEventsBatch = (_: {
-  batchItems: ReadonlyArray<LiveStoreEvent.Client.EncodedWithMeta>
-}) => Effect.Effect<void, MaterializeError, LeaderThreadCtx>
-
 // TODO how to handle errors gracefully
-const materializeEventsBatch: MaterializeEventsBatch = ({ batchItems }) =>
-  Effect.gen(function* () {
-    const { dbState: db, dbEventlog, materializeEvent } = yield* LeaderThreadCtx
+const makeMaterializeEventsBatch =
+  ({
+    dbState,
+    dbEventlog,
+    materializeEvent,
+  }: {
+    dbState: SqliteDb
+    dbEventlog: SqliteDb
+    materializeEvent: MaterializeEvent
+  }) =>
+  ({ batchItems }: { batchItems: ReadonlyArray<LiveStoreEvent.Client.EncodedWithMeta> }) =>
+    Effect.gen(function* () {
+      // NOTE We always start a transaction to ensure consistency between db and eventlog (even for single-item batches)
+      dbState.execute('BEGIN TRANSACTION', undefined) // Start the transaction
+      dbEventlog.execute('BEGIN TRANSACTION', undefined) // Start the transaction
 
-    // NOTE We always start a transaction to ensure consistency between db and eventlog (even for single-item batches)
-    db.execute('BEGIN TRANSACTION', undefined) // Start the transaction
-    dbEventlog.execute('BEGIN TRANSACTION', undefined) // Start the transaction
+      yield* Effect.addFinalizer((exit) =>
+        Effect.gen(function* () {
+          if (Exit.isSuccess(exit) === true) return
 
-    yield* Effect.addFinalizer((exit) =>
-      Effect.gen(function* () {
-        if (Exit.isSuccess(exit) === true) return
+          // Rollback in case of an error
+          dbState.execute('ROLLBACK', undefined)
+          dbEventlog.execute('ROLLBACK', undefined)
+        }),
+      )
+
+      for (let i = 0; i < batchItems.length; i++) {
+        const { sessionChangeset, hash } = yield* materializeEvent(batchItems[i]!)
+        batchItems[i]!.meta.sessionChangeset = sessionChangeset
+        batchItems[i]!.meta.materializerHashLeader = hash
+      }
 
-        // Rollback in case of an error
-        db.execute('ROLLBACK', undefined)
-        dbEventlog.execute('ROLLBACK', undefined)
+      dbState.execute('COMMIT', undefined) // Commit the transaction
+      dbEventlog.execute('COMMIT', undefined) // Commit the transaction
+    }).pipe(
+      Effect.uninterruptible,
+      Effect.scoped,
+      Effect.withSpan('@livestore/common:LeaderSyncProcessor:materializeEventItems', {
+        attributes: { batchSize: batchItems.length },
       }),
+      Effect.tapCauseLogPretty,
     )
 
-    for (let i = 0; i < batchItems.length; i++) {
-      const { sessionChangeset, hash } = yield* materializeEvent(batchItems[i]!)
-      batchItems[i]!.meta.sessionChangeset = sessionChangeset
-      batchItems[i]!.meta.materializerHashLeader = hash
-    }
-
-    db.execute('COMMIT', undefined) // Commit the transaction
-    dbEventlog.execute('COMMIT', undefined) // Commit the transaction
-  }).pipe(
-    Effect.uninterruptible,
-    Effect.scoped,
-    Effect.withSpan('@livestore/common:LeaderSyncProcessor:materializeEventItems', {
-      attributes: { batchSize: batchItems.length },
-    }),
-    Effect.tapCauseLogPretty,
-  )
-
 const trimChangesetRows = (db: SqliteDb, newHead: EventSequenceNumber.Client.Composite) => {
   // Since we're using the session changeset rows to query for the current head,
   // we're keeping at least one row for the current head, and thus are using `<` instead of `<=`
@@ -960,11 +986,7 @@ const trimChangesetRows = (db: SqliteDb, newHead: EventSequenceNumber.Client.Com
 interface PullQueueSet {
   makeQueue: (
     cursor: EventSequenceNumber.Client.Composite,
-  ) => Effect.Effect<
-    Queue.Queue<{ payload: typeof SyncState.PayloadUpstream.Type }>,
-    never,
-    Scope.Scope | LeaderThreadCtx
-  >
+  ) => Effect.Effect<Queue.Queue<{ payload: typeof SyncState.PayloadUpstream.Type }>, never, Scope.Scope>
   offer: (item: {
     payload: typeof SyncState.PayloadUpstream.Type
     leaderHead: EventSequenceNumber.Client.Composite
@@ -1176,13 +1198,15 @@ const handleBackendIdMismatch = Effect.fn('@livestore/common:LeaderSyncProcessor
   error,
   onBackendIdMismatch,
   shutdownChannel,
+  dbEventlog,
+  dbState,
 }: {
   error: BackendIdMismatchError
   onBackendIdMismatch: 'reset' | 'shutdown' | 'ignore'
   shutdownChannel: ShutdownChannel
+  dbEventlog: SqliteDb
+  dbState: SqliteDb
 }) {
-  const { dbEventlog, dbState } = yield* LeaderThreadCtx
-
   if (onBackendIdMismatch === 'reset') {
     yield* Effect.logWarning(
       'Sync backend identity changed (backend was reset). Clearing local storage and shutting down.',

package/src/leader-thread/eventlog.ts

@@ -258,9 +258,13 @@ export const insertIntoEventlog = (
   })
 
 export const updateSyncMetadata = (items: ReadonlyArray<LiveStoreEvent.Client.EncodedWithMeta>) =>
-  Effect.gen(function* () {
-    const { dbEventlog } = yield* LeaderThreadCtx
+  LeaderThreadCtx.pipe(Effect.flatMap(({ dbEventlog }) => updateSyncMetadataForDb(dbEventlog, items)))
 
+export const updateSyncMetadataForDb = (
+  dbEventlog: SqliteDb,
+  items: ReadonlyArray<LiveStoreEvent.Client.EncodedWithMeta>,
+) =>
+  Effect.gen(function* () {
     // TODO try to do this in a single query
     for (let i = 0; i < items.length; i++) {
       const event = items[i]!
@@ -277,10 +281,14 @@ export const updateSyncMetadata = (items: ReadonlyArray<LiveStoreEvent.Client.En
     }
   })
 
-export const getSyncBackendCursorInfo = ({ remoteHead }: { remoteHead: EventSequenceNumber.Global.Type }) =>
-  Effect.gen(function* () {
-    const { dbEventlog } = yield* LeaderThreadCtx
+export const getSyncBackendCursorInfo = (args: { remoteHead: EventSequenceNumber.Global.Type }) =>
+  LeaderThreadCtx.pipe(Effect.flatMap(({ dbEventlog }) => getSyncBackendCursorInfoForDb(dbEventlog, args)))
 
+export const getSyncBackendCursorInfoForDb = (
+  dbEventlog: SqliteDb,
+  { remoteHead }: { remoteHead: EventSequenceNumber.Global.Type },
+) =>
+  Effect.gen(function* () {
     if (remoteHead === EventSequenceNumber.Client.ROOT.global) return Option.none()
 
     const EventlogQuerySchema = Schema.Struct({

package/src/leader-thread/leader-worker-devtools.ts

@@ -42,7 +42,7 @@ export const bootDevtools = Effect.fn('@livestore/common:leader-thread:devtools:
   }).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
 
   const bootResult = yield* options.boot.pipe(
-    Effect.map(Option.some),
+    Effect.asSome,
     Effect.catchIf(isDevtoolsViteNotInstalledError, (error) =>
       Effect.logWarning(`[@livestore/devtools] ${error.message} Devtools will be disabled.`).pipe(
         Effect.as(Option.none()),

package/src/leader-thread/make-leader-thread-layer.ts

@@ -31,11 +31,12 @@ import type * as StateHead from '../StateHead.ts'
 import type { SyncBackend, SyncOptions } from '../sync/sync.ts'
 import { SyncState } from '../sync/syncstate.ts'
 import { sql } from '../util.ts'
+import { configureConnection } from './connection.ts'
 import * as Eventlog from './eventlog.ts'
 import { bootDevtools } from './leader-worker-devtools.ts'
 import * as LeaderSyncProcessor from './LeaderSyncProcessor.ts'
 import { makeMaterializeEvent } from './materialize-event.ts'
-import { recreateDb } from './recreate-db.ts'
+import { hasCompletedState, recreateDb } from './recreate-db.ts'
 import type { ShutdownChannel } from './shutdown-channel.ts'
 import type {
   DevtoolsContext,
@@ -64,14 +65,17 @@ export interface MakeLeaderThreadLayerParams {
   params?: {
     localPushBatchSize?: number
     backendPushBatchSize?: number
+    stateRebuildBatchSize?: number
   }
   testing?: {
     syncProcessor?: {
       delays?: {
         localPushProcessing?: Effect.Effect<void>
+        backendPullReconnect?: (fallbackMs: number) => number
       }
       hooks?: {
         localPushAdmitted?: (events: ReadonlyArray<LiveStoreEvent.Client.EncodedWithMeta>) => Effect.Effect<void>
+        backendPullReconnectWait?: (state: { isConnected: boolean; fallbackMs: number }) => Effect.Effect<void>
       }
     }
   }
@@ -99,9 +103,7 @@ export const makeLeaderThreadLayer = ({
 > =>
   Effect.gen(function* () {
     const syncPayloadDecoded =
-      syncPayloadEncoded === undefined
-        ? undefined
-        : yield* Schema.decodeUnknownEffect(syncPayloadSchema)(syncPayloadEncoded)
+      syncPayloadEncoded === undefined ? undefined : yield* Schema.decodeEffect(syncPayloadSchema)(syncPayloadEncoded)
 
     const bootStatusQueue = yield* Effect.acquireRelease(Queue.unbounded<BootStatus>(), Queue.shutdown)
 
@@ -112,8 +114,20 @@ export const makeLeaderThreadLayer = ({
 
     const dbEventlogMissing = !hasEventlogTables(dbEventlog)
 
-    // Either happens on initial boot or if schema changes
-    const dbStateMissing = !hasStateTables(dbState)
+    const stateNeedsRebuild = !hasCompletedState(dbState)
+
+    if (stateNeedsRebuild === true) {
+      // Import also clears hook-created objects while preserving the open connection.
+      yield* Effect.acquireUseRelease(
+        makeSqliteDb({ _tag: 'in-memory' }),
+        (emptyDb) =>
+          configureConnection(emptyDb, { foreignKeys: false }).pipe(
+            Effect.andThen(Effect.sync(() => dbState.import(emptyDb))),
+            UnknownError.mapToUnknownError,
+          ),
+        (emptyDb) => Effect.sync(() => emptyDb.close()),
+      )
+    }
 
     yield* Eventlog.initEventlogDb(dbEventlog)
 
@@ -171,13 +185,39 @@ export const makeLeaderThreadLayer = ({
     // Recreate state database if needed BEFORE creating sync processor
     // This ensures all system tables exist before any queries are made
     const { migrationsReport } =
-      dbStateMissing === true
-        ? yield* recreateDb({ dbState, dbEventlog, schema, bootStatusQueue, materializeEvent })
+      stateNeedsRebuild === true
+        ? yield* recreateDb({
+            dbState,
+            dbEventlog,
+            schema,
+            bootStatusQueue,
+            materializeEvent,
+            ...omitUndefineds({ stateRebuildBatchSize: params?.stateRebuildBatchSize }),
+          })
         : { migrationsReport: { migrations: [] } }
 
+    const devtoolsContext =
+      devtoolsOptions.enabled === true
+        ? {
+            enabled: true as const,
+            syncBackendLatch: yield* Latch.make(true),
+            syncBackendLatchState: yield* SubscriptionRef.make<{ latchClosed: boolean }>({ latchClosed: false }),
+          }
+        : { enabled: false as const }
+
+    const span = yield* Effect.currentSpan.pipe(Effect.option, Effect.map(Option.getOrUndefined))
+
     const syncProcessor = yield* LeaderSyncProcessor.make({
       schema,
-      dbState,
+      runtime: {
+        dbState,
+        dbEventlog,
+        materializeEvent,
+        syncBackend,
+        shutdownChannel,
+        devtoolsLatch: devtoolsContext.enabled === true ? devtoolsContext.syncBackendLatch : undefined,
+        span,
+      },
       initialSyncState: getInitialSyncState({ dbEventlog, dbState, dbEventlogMissing }),
       initialBlockingSyncContext,
       onError: syncOptions?.onSyncError ?? 'ignore',
@@ -199,15 +239,6 @@ export const makeLeaderThreadLayer = ({
       Queue.shutdown,
     )
 
-    const devtoolsContext =
-      devtoolsOptions.enabled === true
-        ? {
-            enabled: true as const,
-            syncBackendLatch: yield* Latch.make(true),
-            syncBackendLatchState: yield* SubscriptionRef.make<{ latchClosed: boolean }>({ latchClosed: false }),
-          }
-        : { enabled: false as const }
-
     const networkStatus = yield* makeNetworkStatusSubscribable({ syncBackend, devtoolsContext })
 
     const ctx = {
@@ -256,11 +287,6 @@ const hasEventlogTables = (db: SqliteDb) => {
   return ReadonlyArray.every(SystemTables.eventlogSystemTables, (_) => tableNames.has(_.sqliteDef.name))
 }
 
-const hasStateTables = (db: SqliteDb) => {
-  const tableNames = new Set(db.select<{ name: string }>(sql`select name from sqlite_master`).map((_) => _.name))
-  return ReadonlyArray.every(SystemTables.stateSystemTables, (_) => tableNames.has(_.sqliteDef.name))
-}
-
 const getInitialSyncState = ({
   dbEventlog,
   dbState,