@livestore/common 0.0.0-snapshot-aed277ba0960f72b8d464508961ab4aec1881230 → 0.0.0-snapshot-7bcbc24bb8873481e482d982636957f0c1f791f6

package/src/leader-thread/LeaderSyncProcessor.ts

@@ -1,4 +1,4 @@
-import { isNotUndefined, shouldNeverHappen, TRACE_VERBOSE } from '@livestore/utils'
+import { isNotUndefined, LS_DEV, shouldNeverHappen, TRACE_VERBOSE } from '@livestore/utils'
 import type { HttpClient, Scope, Tracer } from '@livestore/utils/effect'
 import {
   BucketQueue,
@@ -32,7 +32,7 @@ import * as SyncState from '../sync/syncstate.js'
 import { sql } from '../util.js'
 import { makeApplyMutation } from './apply-mutation.js'
 import { execSql } from './connection.js'
-import { getBackendHeadFromDb, getLocalHeadFromDb, getMutationEventsSince, updateBackendHead } from './mutationlog.js'
+import { getBackendHeadFromDb, getClientHeadFromDb, getMutationEventsSince, updateBackendHead } from './mutationlog.js'
 import type { InitialBlockingSyncContext, InitialSyncInfo, LeaderSyncProcessor } from './types.js'
 import { LeaderThreadCtx } from './types.js'
 
@@ -83,7 +83,7 @@ export const makeLeaderSyncProcessor = ({
 
     const isLocalEvent = (mutationEventEncoded: MutationEvent.EncodedWithMeta) => {
       const mutationDef = schema.mutations.get(mutationEventEncoded.mutation)!
-      return mutationDef.options.localOnly
+      return mutationDef.options.clientOnly
     }
 
     // This context depends on data from `boot`, we should find a better implementation to avoid this ref indirection.
@@ -93,8 +93,7 @@ export const makeLeaderSyncProcessor = ({
         | {
             otelSpan: otel.Span | undefined
             span: Tracer.Span
-            devtoolsPullLatch: Effect.Latch | undefined
-            devtoolsPushLatch: Effect.Latch | undefined
+            devtoolsLatch: Effect.Latch | undefined
           },
     }
 
@@ -107,10 +106,6 @@ export const makeLeaderSyncProcessor = ({
         // TODO validate batch
         if (newEvents.length === 0) return
 
-        if (ctxRef.current?.devtoolsPushLatch !== undefined) {
-          yield* ctxRef.current.devtoolsPushLatch.await
-        }
-
         const waitForProcessing = options?.waitForProcessing ?? false
 
         if (waitForProcessing) {
@@ -137,18 +132,24 @@ export const makeLeaderSyncProcessor = ({
         }),
       )
 
-    const pushPartial: LeaderSyncProcessor['pushPartial'] = (mutationEventEncoded_) =>
+    const pushPartial: LeaderSyncProcessor['pushPartial'] = ({
+      mutationEvent: partialMutationEvent,
+      clientId,
+      sessionId,
+    }) =>
       Effect.gen(function* () {
         const syncState = yield* syncStateSref
         if (syncState === undefined) return shouldNeverHappen('Not initialized')
 
         const mutationDef =
-          schema.mutations.get(mutationEventEncoded_.mutation) ??
-          shouldNeverHappen(`Unknown mutation: ${mutationEventEncoded_.mutation}`)
+          schema.mutations.get(partialMutationEvent.mutation) ??
+          shouldNeverHappen(`Unknown mutation: ${partialMutationEvent.mutation}`)
 
         const mutationEventEncoded = new MutationEvent.EncodedWithMeta({
-          ...mutationEventEncoded_,
-          ...EventId.nextPair(syncState.localHead, mutationDef.options.localOnly),
+          ...partialMutationEvent,
+          clientId,
+          sessionId,
+          ...EventId.nextPair(syncState.localHead, mutationDef.options.clientOnly),
         })
 
         yield* push([mutationEventEncoded])
@@ -164,12 +165,11 @@ export const makeLeaderSyncProcessor = ({
         ctxRef.current = {
           otelSpan,
           span,
-          devtoolsPullLatch: devtools.enabled ? devtools.syncBackendPullLatch : undefined,
-          devtoolsPushLatch: devtools.enabled ? devtools.syncBackendPushLatch : undefined,
+          devtoolsLatch: devtools.enabled ? devtools.syncBackendLatch : undefined,
         }
 
         const initialBackendHead = dbMissing ? EventId.ROOT.global : getBackendHeadFromDb(dbMutationLog)
-        const initialLocalHead = dbMissing ? EventId.ROOT : getLocalHeadFromDb(dbMutationLog)
+        const initialLocalHead = dbMissing ? EventId.ROOT : getClientHeadFromDb(dbMutationLog)
 
         if (initialBackendHead > initialLocalHead.global) {
           return shouldNeverHappen(
@@ -179,14 +179,14 @@ export const makeLeaderSyncProcessor = ({
 
         const pendingMutationEvents = yield* getMutationEventsSince({
           global: initialBackendHead,
-          local: EventId.localDefault,
+          client: EventId.clientDefault,
         }).pipe(Effect.map(ReadonlyArray.map((_) => new MutationEvent.EncodedWithMeta(_))))
 
         const initialSyncState = new SyncState.SyncState({
           pending: pendingMutationEvents,
           // On the leader we don't need a rollback tail beyond `pending` items
           rollbackTail: [],
-          upstreamHead: { global: initialBackendHead, local: EventId.localDefault },
+          upstreamHead: { global: initialBackendHead, client: EventId.clientDefault },
           localHead: initialLocalHead,
         })
 
@@ -196,10 +196,10 @@ export const makeLeaderSyncProcessor = ({
         // Rehydrate sync queue
         if (pendingMutationEvents.length > 0) {
           const filteredBatch = pendingMutationEvents
-            // Don't sync localOnly mutations
+            // Don't sync clientOnly mutations
             .filter((mutationEventEncoded) => {
               const mutationDef = schema.mutations.get(mutationEventEncoded.mutation)!
-              return mutationDef.options.localOnly === false
+              return mutationDef.options.clientOnly === false
             })
 
           yield* BucketQueue.offerAll(syncBackendQueue, filteredBatch)
@@ -220,7 +220,12 @@ export const makeLeaderSyncProcessor = ({
 
         yield* FiberHandle.run(
           backendPushingFiberHandle,
-          backgroundBackendPushing({ dbReady, syncBackendQueue, otelSpan }).pipe(Effect.tapCauseLogPretty),
+          backgroundBackendPushing({
+            dbReady,
+            syncBackendQueue,
+            otelSpan,
+            devtoolsLatch: ctxRef.current?.devtoolsLatch,
+          }).pipe(Effect.tapCauseLogPretty),
         )
 
         yield* backgroundBackendPulling({
@@ -239,7 +244,12 @@ export const makeLeaderSyncProcessor = ({
               // Restart pushing fiber
               yield* FiberHandle.run(
                 backendPushingFiberHandle,
-                backgroundBackendPushing({ dbReady, syncBackendQueue, otelSpan }).pipe(Effect.tapCauseLogPretty),
+                backgroundBackendPushing({
+                  dbReady,
+                  syncBackendQueue,
+                  otelSpan,
+                  devtoolsLatch: ctxRef.current?.devtoolsLatch,
+                }).pipe(Effect.tapCauseLogPretty),
               )
             }),
           syncStateSref,
@@ -247,8 +257,10 @@ export const makeLeaderSyncProcessor = ({
           pullLatch,
           otelSpan,
           initialBlockingSyncContext,
-          devtoolsPullLatch: ctxRef.current?.devtoolsPullLatch,
+          devtoolsLatch: ctxRef.current?.devtoolsLatch,
         }).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
+
+        return { initialLeaderHead: initialLocalHead }
       }).pipe(Effect.withSpanScoped('@livestore/common:leader-thread:syncing'))
 
     return {
@@ -357,10 +369,10 @@ const backgroundApplyLocalPushes = ({
         updateResult: TRACE_VERBOSE ? JSON.stringify(updateResult) : undefined,
       })
 
-      // Don't sync localOnly mutations
+      // Don't sync clientOnly mutations
       const filteredBatch = updateResult.newEvents.filter((mutationEventEncoded) => {
         const mutationDef = schema.mutations.get(mutationEventEncoded.mutation)!
-        return mutationDef.options.localOnly === false
+        return mutationDef.options.clientOnly === false
       })
 
       yield* BucketQueue.offerAll(syncBackendQueue, filteredBatch)
@@ -431,7 +443,7 @@ const backgroundBackendPulling = ({
   syncStateSref,
   localPushesLatch,
   pullLatch,
-  devtoolsPullLatch,
+  devtoolsLatch,
   initialBlockingSyncContext,
 }: {
   dbReady: Deferred.Deferred<void>
@@ -444,7 +456,7 @@ const backgroundBackendPulling = ({
   syncStateSref: SubscriptionRef.SubscriptionRef<SyncState.SyncState | undefined>
   localPushesLatch: Effect.Latch
   pullLatch: Effect.Latch
-  devtoolsPullLatch: Effect.Latch | undefined
+  devtoolsLatch: Effect.Latch | undefined
   initialBlockingSyncContext: InitialBlockingSyncContext
 }) =>
   Effect.gen(function* () {
@@ -466,8 +478,8 @@ const backgroundBackendPulling = ({
       Effect.gen(function* () {
         if (newEvents.length === 0) return
 
-        if (devtoolsPullLatch !== undefined) {
-          yield* devtoolsPullLatch.await
+        if (devtoolsLatch !== undefined) {
+          yield* devtoolsLatch.await
         }
 
         // Prevent more local pushes from being processed until this pull is finished
@@ -507,7 +519,7 @@ const backgroundBackendPulling = ({
 
           const filteredRebasedPending = updateResult.newSyncState.pending.filter((mutationEvent) => {
             const mutationDef = schema.mutations.get(mutationEvent.mutation)!
-            return mutationDef.options.localOnly === false
+            return mutationDef.options.clientOnly === false
           })
           yield* restartBackendPushing(filteredRebasedPending)
 
@@ -592,9 +604,9 @@ const rollback = ({
   Effect.gen(function* () {
     const rollbackEvents = db
       .select<SessionChangesetMetaRow>(
-        sql`SELECT * FROM ${SESSION_CHANGESET_META_TABLE} WHERE (idGlobal, idLocal) IN (${eventIdsToRollback.map((id) => `(${id.global}, ${id.local})`).join(', ')})`,
+        sql`SELECT * FROM ${SESSION_CHANGESET_META_TABLE} WHERE (idGlobal, idClient) IN (${eventIdsToRollback.map((id) => `(${id.global}, ${id.client})`).join(', ')})`,
       )
-      .map((_) => ({ id: { global: _.idGlobal, local: _.idLocal }, changeset: _.changeset, debug: _.debug }))
+      .map((_) => ({ id: { global: _.idGlobal, client: _.idClient }, changeset: _.changeset, debug: _.debug }))
       .toSorted((a, b) => EventId.compare(a.id, b.id))
 
     // Apply changesets in reverse order
@@ -607,12 +619,12 @@ const rollback = ({
 
     // Delete the changeset rows
     db.execute(
-      sql`DELETE FROM ${SESSION_CHANGESET_META_TABLE} WHERE (idGlobal, idLocal) IN (${eventIdsToRollback.map((id) => `(${id.global}, ${id.local})`).join(', ')})`,
+      sql`DELETE FROM ${SESSION_CHANGESET_META_TABLE} WHERE (idGlobal, idClient) IN (${eventIdsToRollback.map((id) => `(${id.global}, ${id.client})`).join(', ')})`,
     )
 
     // Delete the mutation log rows
     dbMutationLog.execute(
-      sql`DELETE FROM ${MUTATION_LOG_META_TABLE} WHERE (idGlobal, idLocal) IN (${eventIdsToRollback.map((id) => `(${id.global}, ${id.local})`).join(', ')})`,
+      sql`DELETE FROM ${MUTATION_LOG_META_TABLE} WHERE (idGlobal, idClient) IN (${eventIdsToRollback.map((id) => `(${id.global}, ${id.client})`).join(', ')})`,
     )
   }).pipe(
     Effect.withSpan('@livestore/common:leader-thread:syncing:rollback', {
@@ -632,12 +644,12 @@ const getCursorInfo = (remoteHead: EventId.GlobalEventId) =>
 
     const syncMetadataOption = yield* Effect.sync(() =>
       dbMutationLog.select<{ syncMetadataJson: string }>(
-        sql`SELECT syncMetadataJson FROM ${MUTATION_LOG_META_TABLE} WHERE idGlobal = ${remoteHead} ORDER BY idLocal ASC LIMIT 1`,
+        sql`SELECT syncMetadataJson FROM ${MUTATION_LOG_META_TABLE} WHERE idGlobal = ${remoteHead} ORDER BY idClient ASC LIMIT 1`,
       ),
     ).pipe(Effect.andThen(Schema.decode(MutationlogQuerySchema)), Effect.map(Option.flatten), Effect.orDie)
 
     return Option.some({
-      cursor: { global: remoteHead, local: EventId.localDefault },
+      cursor: { global: remoteHead, client: EventId.clientDefault },
       metadata: syncMetadataOption,
     }) satisfies InitialSyncInfo
   }).pipe(Effect.withSpan('@livestore/common:leader-thread:syncing:getCursorInfo', { attributes: { remoteHead } }))
@@ -646,10 +658,12 @@ const backgroundBackendPushing = ({
   dbReady,
   syncBackendQueue,
   otelSpan,
+  devtoolsLatch,
 }: {
   dbReady: Deferred.Deferred<void>
   syncBackendQueue: BucketQueue.BucketQueue<MutationEvent.EncodedWithMeta>
   otelSpan: otel.Span | undefined
+  devtoolsLatch: Effect.Latch | undefined
 }) =>
   Effect.gen(function* () {
     const { syncBackend, dbMutationLog } = yield* LeaderThreadCtx
@@ -665,6 +679,10 @@ const backgroundBackendPushing = ({
 
       yield* SubscriptionRef.waitUntil(syncBackend.isConnected, (isConnected) => isConnected === true)
 
+      if (devtoolsLatch !== undefined) {
+        yield* devtoolsLatch.await
+      }
+
       otelSpan?.addEvent('backend-push', {
         batchSize: queueItems.length,
         batch: TRACE_VERBOSE ? JSON.stringify(queueItems) : undefined,
@@ -674,6 +692,9 @@ const backgroundBackendPushing = ({
       const pushResult = yield* syncBackend.push(queueItems.map((_) => _.toGlobal())).pipe(Effect.either)
 
       if (pushResult._tag === 'Left') {
+        if (LS_DEV) {
+          yield* Effect.logDebug('backend-push-error', { error: pushResult.left.toString() })
+        }
         otelSpan?.addEvent('backend-push-error', { error: pushResult.left.toString() })
         // wait for interrupt caused by background pulling which will then restart pushing
         return yield* Effect.never
@@ -689,7 +710,7 @@ const backgroundBackendPushing = ({
           ...updateRows({
             tableName: MUTATION_LOG_META_TABLE,
             columns: mutationLogMetaTable.sqliteDef.columns,
-            where: { idGlobal: mutationEventEncoded.id.global, idLocal: mutationEventEncoded.id.local },
+            where: { idGlobal: mutationEventEncoded.id.global, idClient: mutationEventEncoded.id.client },
             updateValues: { syncMetadataJson: metadata[i]! },
           }),
         )

package/src/leader-thread/apply-mutation.ts

@@ -79,7 +79,7 @@ export const makeApplyMutation: Effect.Effect<ApplyMutation, never, Scope.Scope
             columns: sessionChangesetMetaTable.sqliteDef.columns,
             values: {
               idGlobal: mutationEventEncoded.id.global,
-              idLocal: mutationEventEncoded.id.local,
+              idClient: mutationEventEncoded.id.client,
               // NOTE the changeset will be empty (i.e. null) for no-op mutations
               changeset: changeset ?? null,
               debug: execArgsArr,
@@ -92,7 +92,13 @@ export const makeApplyMutation: Effect.Effect<ApplyMutation, never, Scope.Scope
         // write to mutation_log
         const excludeFromMutationLog = shouldExcludeMutationFromLog(mutationName, mutationEventEncoded)
         if (skipMutationLog === false && excludeFromMutationLog === false) {
-          yield* insertIntoMutationLog(mutationEventEncoded, dbMutationLog, mutationDefSchemaHashMap)
+          yield* insertIntoMutationLog(
+            mutationEventEncoded,
+            dbMutationLog,
+            mutationDefSchemaHashMap,
+            mutationEventEncoded.clientId,
+            mutationEventEncoded.sessionId,
+          )
         } else {
           //   console.debug('[@livestore/common:leader-thread] skipping mutation log write', mutation, statementSql, bindValues)
         }
@@ -101,7 +107,7 @@ export const makeApplyMutation: Effect.Effect<ApplyMutation, never, Scope.Scope
           attributes: {
             mutationName: mutationEventEncoded.mutation,
             mutationId: mutationEventEncoded.id,
-            'span.label': `(${mutationEventEncoded.id.global},${mutationEventEncoded.id.local}) ${mutationEventEncoded.mutation}`,
+            'span.label': `(${mutationEventEncoded.id.global},${mutationEventEncoded.id.client}) ${mutationEventEncoded.mutation}`,
           },
         }),
         // Effect.logDuration('@livestore/common:leader-thread:applyMutation'),
@@ -113,6 +119,8 @@ const insertIntoMutationLog = (
   mutationEventEncoded: MutationEvent.AnyEncoded,
   dbMutationLog: SqliteDb,
   mutationDefSchemaHashMap: Map<string, number>,
+  clientId: string,
+  sessionId: string | undefined,
 ) =>
   Effect.gen(function* () {
     const mutationName = mutationEventEncoded.mutation
@@ -127,11 +135,13 @@ const insertIntoMutationLog = (
         columns: mutationLogMetaTable.sqliteDef.columns,
         values: {
           idGlobal: mutationEventEncoded.id.global,
-          idLocal: mutationEventEncoded.id.local,
+          idClient: mutationEventEncoded.id.client,
           parentIdGlobal: mutationEventEncoded.parentId.global,
-          parentIdLocal: mutationEventEncoded.parentId.local,
+          parentIdClient: mutationEventEncoded.parentId.client,
           mutation: mutationEventEncoded.mutation,
           argsJson: mutationEventEncoded.args ?? {},
+          clientId,
+          sessionId: sessionId ?? null,
           schemaHash: mutationDefSchemaHash,
           syncMetadataJson: Option.none(),
         },

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

@@ -38,18 +38,7 @@ export const bootDevtools = (options: DevtoolsOptions) =>
     const pullQueue = yield* connectedClientSessionPullQueues.makeQueue(localHead)
 
     yield* Stream.fromQueue(pullQueue).pipe(
-      Stream.tap((msg) =>
-        Effect.gen(function* () {
-          if (msg.payload._tag === 'upstream-advance') {
-            for (const mutationEventEncoded of msg.payload.newEvents) {
-              // TODO refactor with push semantics
-              yield* sendMessage(Devtools.Leader.MutationBroadcast.make({ mutationEventEncoded, liveStoreVersion }))
-            }
-          } else {
-            yield* Effect.logWarning('TODO implement rebases in devtools')
-          }
-        }),
-      ),
+      Stream.tap((msg) => sendMessage(Devtools.Leader.SyncPull.make({ payload: msg.payload, liveStoreVersion }))),
       Stream.runDrain,
       Effect.forkScoped,
     )
@@ -80,6 +69,7 @@ const listenToDevtools = ({
       shutdownChannel,
       syncProcessor,
       clientId,
+      devtools,
     } = yield* LeaderThreadCtx
 
     type RequestId = string
@@ -158,7 +148,7 @@ const listenToDevtools = ({
 
               return
             }
-            case 'LSD.Leader.ResetAllDataReq': {
+            case 'LSD.Leader.ResetAllData.Request': {
               const { mode } = decodedEvent
 
               yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
@@ -169,7 +159,7 @@ const listenToDevtools = ({
                 dbMutationLog.destroy()
               }
 
-              yield* sendMessage(Devtools.Leader.ResetAllDataRes.make({ ...reqPayload }))
+              yield* sendMessage(Devtools.Leader.ResetAllData.Response.make({ ...reqPayload }))
 
               yield* shutdownChannel.send(IntentionalShutdownCause.make({ reason: 'devtools-reset' })) ?? Effect.void
 
@@ -203,7 +193,11 @@ const listenToDevtools = ({
               return
             }
             case 'LSD.Leader.RunMutationReq': {
-              yield* syncProcessor.pushPartial(decodedEvent.mutationEventEncoded)
+              yield* syncProcessor.pushPartial({
+                mutationEvent: decodedEvent.mutationEventEncoded,
+                clientId: `devtools-${clientId}`,
+                sessionId: undefined,
+              })
 
               yield* sendMessage(Devtools.Leader.RunMutationRes.make({ ...reqPayload }))
 
@@ -257,11 +251,14 @@ const listenToDevtools = ({
                 // This is probably the same "flaky databrowser loading" bug as we're seeing in the playwright tests
                 yield* Effect.sleep(1000)
 
-                yield* syncBackend.isConnected.changes.pipe(
-                  Stream.tap((isConnected) =>
+                yield* Stream.zipLatest(
+                  syncBackend.isConnected.changes,
+                  devtools.enabled ? devtools.syncBackendLatchState.changes : Stream.make({ latchClosed: false }),
+                ).pipe(
+                  Stream.tap(([isConnected, { latchClosed }]) =>
                     sendMessage(
                       Devtools.Leader.NetworkStatusRes.make({
-                        networkStatus: { isConnected, timestampMs: Date.now() },
+                        networkStatus: { isConnected, timestampMs: Date.now(), latchClosed },
                         ...reqPayload,
                       }),
                     ),
@@ -310,8 +307,25 @@ const listenToDevtools = ({
 
               return
             }
+            case 'LSD.Leader.SetSyncLatch.Request': {
+              const { closeLatch } = decodedEvent
+
+              if (devtools.enabled === false) return
+
+              if (closeLatch === true) {
+                yield* devtools.syncBackendLatch.close
+              } else {
+                yield* devtools.syncBackendLatch.open
+              }
+
+              yield* SubscriptionRef.set(devtools.syncBackendLatchState, { latchClosed: closeLatch })
+
+              yield* sendMessage(Devtools.Leader.SetSyncLatch.Response.make({ ...reqPayload }))
+
+              return
+            }
             default: {
-              yield* Effect.logWarning(`TODO implement ${decodedEvent._tag}`, decodedEvent)
+              yield* Effect.logWarning(`TODO implement devtools message`, decodedEvent)
             }
           }
         }).pipe(Effect.withSpan(`@livestore/common:leader-thread:onDevtoolsMessage:${decodedEvent._tag}`)),

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

@@ -1,7 +1,7 @@
 import type { HttpClient, Scope } from '@livestore/utils/effect'
 import { Deferred, Effect, Layer, Queue, SubscriptionRef } from '@livestore/utils/effect'
 
-import type { BootStatus, MakeSqliteDb, SqliteError } from '../adapter-types.js'
+import type { BootStatus, MakeSqliteDb, MigrationsReport, SqliteError } from '../adapter-types.js'
 import { UnexpectedError } from '../adapter-types.js'
 import type * as Devtools from '../devtools/index.js'
 import type { LiveStoreSchema } from '../schema/mod.js'
@@ -74,8 +74,8 @@ export const makeLeaderThreadLayer = ({
     const devtoolsContext = devtoolsOptions.enabled
       ? {
           enabled: true as const,
-          syncBackendPullLatch: yield* Effect.makeLatch(true),
-          syncBackendPushLatch: yield* Effect.makeLatch(true),
+          syncBackendLatch: yield* Effect.makeLatch(true),
+          syncBackendLatchState: yield* SubscriptionRef.make<{ latchClosed: boolean }>({ latchClosed: false }),
         }
       : { enabled: false as const }
 
@@ -95,6 +95,8 @@ export const makeLeaderThreadLayer = ({
       connectedClientSessionPullQueues: yield* makePullQueueSet,
       extraIncomingMessagesQueue,
       devtools: devtoolsContext,
+      // State will be set during `bootLeaderThread`
+      initialState: {} as any as LeaderThreadCtx['Type']['initialState'],
     } satisfies typeof LeaderThreadCtx.Service
 
     // @ts-expect-error For debugging purposes
@@ -102,7 +104,11 @@ export const makeLeaderThreadLayer = ({
 
     const layer = Layer.succeed(LeaderThreadCtx, ctx)
 
-    yield* bootLeaderThread({ dbMissing, initialBlockingSyncContext, devtoolsOptions }).pipe(Effect.provide(layer))
+    ctx.initialState = yield* bootLeaderThread({
+      dbMissing,
+      initialBlockingSyncContext,
+      devtoolsOptions,
+    }).pipe(Effect.provide(layer))
 
     return layer
   }).pipe(
@@ -172,7 +178,7 @@ const bootLeaderThread = ({
   initialBlockingSyncContext: InitialBlockingSyncContext
   devtoolsOptions: DevtoolsOptions
 }): Effect.Effect<
-  void,
+  LeaderThreadCtx['Type']['initialState'],
   UnexpectedError | SqliteError | IsOfflineError | InvalidPullError,
   LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient
 > =>
@@ -206,19 +212,33 @@ const bootLeaderThread = ({
 
     // We're already starting pulling from the sync backend concurrently but wait until the db is ready before
     // processing any incoming mutations
-    yield* syncProcessor.boot({ dbReady })
+    const { initialLeaderHead } = yield* syncProcessor.boot({ dbReady })
 
+    let migrationsReport: MigrationsReport
     if (dbMissing) {
-      yield* recreateDb
+      const recreateResult = yield* recreateDb
+      migrationsReport = recreateResult.migrationsReport
+    } else {
+      migrationsReport = { migrations: [] }
     }
 
     yield* Deferred.succeed(dbReady, void 0)
 
     if (initialBlockingSyncContext.blockingDeferred !== undefined) {
-      yield* initialBlockingSyncContext.blockingDeferred
+      // Provides a syncing status right away before the first pull response comes in
+      yield* Queue.offer(bootStatusQueue, {
+        stage: 'syncing',
+        progress: { done: 0, total: -1 },
+      })
+
+      yield* initialBlockingSyncContext.blockingDeferred.pipe(
+        Effect.withSpan('@livestore/common:leader-thread:initial-sync-blocking'),
+      )
     }
 
     yield* Queue.offer(bootStatusQueue, { stage: 'done' })
 
     yield* bootDevtools(devtoolsOptions).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
+
+    return { migrationsReport, leaderHead: initialLeaderHead }
   })

package/src/leader-thread/mutationlog.ts

@@ -23,18 +23,20 @@ export const getMutationEventsSince = (
       .map((_) => ({
         mutation: _.mutation,
         args: _.argsJson,
-        id: { global: _.idGlobal, local: _.idLocal },
-        parentId: { global: _.parentIdGlobal, local: _.parentIdLocal },
+        id: { global: _.idGlobal, client: _.idClient },
+        parentId: { global: _.parentIdGlobal, client: _.parentIdClient },
+        clientId: _.clientId,
+        sessionId: _.sessionId ?? undefined,
       }))
       .filter((_) => EventId.compare(_.id, since) > 0)
   })
 
-export const getLocalHeadFromDb = (dbMutationLog: SqliteDb): EventId.EventId => {
-  const res = dbMutationLog.select<{ idGlobal: EventId.GlobalEventId; idLocal: EventId.LocalEventId }>(
-    sql`select idGlobal, idLocal from ${MUTATION_LOG_META_TABLE} order by idGlobal DESC, idLocal DESC limit 1`,
+export const getClientHeadFromDb = (dbMutationLog: SqliteDb): EventId.EventId => {
+  const res = dbMutationLog.select<{ idGlobal: EventId.GlobalEventId; idClient: EventId.ClientEventId }>(
+    sql`select idGlobal, idClient from ${MUTATION_LOG_META_TABLE} order by idGlobal DESC, idClient DESC limit 1`,
   )[0]
 
-  return res ? { global: res.idGlobal, local: res.idLocal } : EventId.ROOT
+  return res ? { global: res.idGlobal, client: res.idClient } : EventId.ROOT
 }
 
 export const getBackendHeadFromDb = (dbMutationLog: SqliteDb): EventId.GlobalEventId =>

package/src/leader-thread/recreate-db.ts

@@ -2,19 +2,20 @@ import { casesHandled } from '@livestore/utils'
 import type { HttpClient } from '@livestore/utils/effect'
 import { Effect, Queue } from '@livestore/utils/effect'
 
-import type { InvalidPullError, IsOfflineError, MigrationHooks, SqliteError } from '../index.js'
+import type { InvalidPullError, IsOfflineError, MigrationHooks, MigrationsReport, SqliteError } from '../index.js'
 import { initializeSingletonTables, migrateDb, rehydrateFromMutationLog, UnexpectedError } from '../index.js'
 import { configureConnection } from './connection.js'
 import { LeaderThreadCtx } from './types.js'
 
 export const recreateDb: Effect.Effect<
-  void,
+  { migrationsReport: MigrationsReport },
   UnexpectedError | SqliteError | IsOfflineError | InvalidPullError,
   LeaderThreadCtx | HttpClient.HttpClient
 > = Effect.gen(function* () {
   const { dbReadModel, dbMutationLog, schema, bootStatusQueue } = yield* LeaderThreadCtx
 
   const migrationOptions = schema.migrationOptions
+  let migrationsReport: MigrationsReport
 
   yield* Effect.addFinalizer(
     Effect.fn('recreateDb:finalizer')(function* (ex) {
@@ -33,7 +34,7 @@ export const recreateDb: Effect.Effect<
     Effect.gen(function* () {
       yield* Effect.tryAll(() => hooks?.init?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
-      yield* migrateDb({
+      const migrationsReport = yield* migrateDb({
         db: tmpDb,
         schema,
         onProgress: ({ done, total }) =>
@@ -44,16 +45,18 @@ export const recreateDb: Effect.Effect<
 
       yield* Effect.tryAll(() => hooks?.pre?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
-      return tmpDb
+      return { migrationsReport, tmpDb }
     })
 
   switch (migrationOptions.strategy) {
     case 'from-mutation-log': {
       const hooks = migrationOptions.hooks
-      const tmpDb = yield* initDb(hooks)
+      const initResult = yield* initDb(hooks)
+
+      migrationsReport = initResult.migrationsReport
 
       yield* rehydrateFromMutationLog({
-        db: tmpDb,
+        db: initResult.tmpDb,
         logDb: dbMutationLog,
         schema,
         migrationOptions,
@@ -61,23 +64,27 @@ export const recreateDb: Effect.Effect<
           Queue.offer(bootStatusQueue, { stage: 'rehydrating', progress: { done, total } }),
       })
 
-      yield* Effect.tryAll(() => hooks?.post?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
+      yield* Effect.tryAll(() => hooks?.post?.(initResult.tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
       break
     }
     case 'hard-reset': {
       const hooks = migrationOptions.hooks
-      const tmpInMemoryDb = yield* initDb(hooks)
+      const initResult = yield* initDb(hooks)
+
+      migrationsReport = initResult.migrationsReport
 
       // The database is migrated but empty now, so nothing else to do
 
-      yield* Effect.tryAll(() => hooks?.post?.(tmpInMemoryDb)).pipe(UnexpectedError.mapToUnexpectedError)
+      yield* Effect.tryAll(() => hooks?.post?.(initResult.tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
       break
     }
     case 'manual': {
       const oldDbData = dbReadModel.export()
 
+      migrationsReport = { migrations: [] }
+
       const newDbData = yield* Effect.tryAll(() => migrationOptions.migrate(oldDbData)).pipe(
         UnexpectedError.mapToUnexpectedError,
       )
@@ -106,6 +113,8 @@ export const recreateDb: Effect.Effect<
 
   // TODO bring back
   // tmpDb.close()
+
+  return { migrationsReport }
 }).pipe(
   Effect.scoped, // NOTE we're closing the scope here so finalizers are called when the effect is done
   Effect.withSpan('@livestore/common:leader-thread:recreateDb'),