@livestore/common 0.3.0-dev.11 → 0.3.0-dev.12

package/src/devtools/devtools-messages-leader.ts

@@ -1,15 +1,20 @@
 import { Schema, Transferable } from '@livestore/utils/effect'
 
-import { NetworkStatus } from '../adapter-types.js'
+import { NetworkStatus, UnexpectedError } from '../adapter-types.js'
+import { EventId } from '../schema/mod.js'
 import * as MutationEvent from '../schema/MutationEvent.js'
-import { Disconnect, LSDMessage, LSDReqResMessage, Ping, Pong } from './devtools-messages-common.js'
+import {
+  LeaderReqResMessage,
+  liveStoreVersion,
+  LSDMessage,
+  LSDReqResMessage,
+  requestId,
+} from './devtools-messages-common.js'
 
 export class ResetAllDataReq extends LSDReqResMessage('LSD.Leader.ResetAllDataReq', {
   mode: Schema.Literal('all-data', 'only-app-db'),
 }) {}
 
-export class ResetAllDataRes extends LSDReqResMessage('LSD.Leader.ResetAllDataRes', {}) {}
-
 export class DatabaseFileInfoReq extends LSDReqResMessage('LSD.Leader.DatabaseFileInfoReq', {}) {}
 
 export class DatabaseFileInfo extends Schema.Struct({
@@ -47,6 +52,13 @@ export class SyncHistoryRes extends LSDReqResMessage('LSD.Leader.SyncHistoryRes'
   metadata: Schema.Option(Schema.JsonValue),
 }) {}
 
+export class SyncHeadSubscribe extends LSDReqResMessage('LSD.Leader.SyncHeadSubscribe', {}) {}
+export class SyncHeadUnsubscribe extends LSDReqResMessage('LSD.Leader.SyncHeadUnsubscribe', {}) {}
+export class SyncHeadRes extends LSDReqResMessage('LSD.Leader.SyncHeadRes', {
+  local: EventId.EventId,
+  upstream: EventId.EventId,
+}) {}
+
 export class SnapshotReq extends LSDReqResMessage('LSD.Leader.SnapshotReq', {}) {}
 
 export class SnapshotRes extends LSDReqResMessage('LSD.Leader.SnapshotRes', {
@@ -79,11 +91,55 @@ export class MutationLogRes extends LSDReqResMessage('LSD.Leader.MutationLogRes'
   mutationLog: Transferable.Uint8Array,
 }) {}
 
-export const MessageToAppLeader = Schema.Union(
+export class Ping extends LSDReqResMessage('LSD.Leader.Ping', {}) {}
+
+export class Pong extends LSDReqResMessage('LSD.Leader.Pong', {}) {}
+
+export class Disconnect extends LSDReqResMessage('LSD.Leader.Disconnect', {}) {}
+
+export const SetSyncLatch = LeaderReqResMessage('LSD.Leader.SetSyncLatch', {
+  payload: {
+    closeLatch: Schema.Boolean,
+  },
+  success: {},
+})
+
+export const ResetAllData = LeaderReqResMessage('LSD.Leader.ResetAllData', {
+  payload: {
+    mode: Schema.Literal('all-data', 'only-app-db'),
+  },
+  success: {},
+})
+
+// TODO move to `Schema.TaggedRequest` once new RPC is ready https://github.com/Effect-TS/effect/pull/4362
+export class DatabaseFileInfo_ extends Schema.TaggedRequest<DatabaseFileInfo_>()('LSD.Leader.DatabaseFileInfo', {
+  payload: {
+    requestId,
+    liveStoreVersion,
+  },
+  success: DatabaseFileInfo,
+  failure: UnexpectedError,
+}) {}
+
+export class NetworkStatus_ extends Schema.TaggedRequest<NetworkStatus_>()('LSD.Leader.NetworkStatus', {
+  payload: {
+    requestId,
+    liveStoreVersion,
+  },
+  success: NetworkStatus,
+  failure: UnexpectedError,
+}) {}
+
+export const MessageToApp_ = Schema.Union(DatabaseFileInfo_, NetworkStatus_)
+
+export type MessageToApp_ = typeof MessageToApp_.Type
+//
+
+export const MessageToApp = Schema.Union(
   SnapshotReq,
   LoadDatabaseFileReq,
   MutationLogReq,
-  ResetAllDataReq,
+  ResetAllData.Request,
   NetworkStatusSubscribe,
   NetworkStatusUnsubscribe,
   Disconnect,
@@ -93,15 +149,17 @@ export const MessageToAppLeader = Schema.Union(
   SyncHistorySubscribe,
   SyncHistoryUnsubscribe,
   SyncingInfoReq,
-).annotations({ identifier: 'LSD.MessageToAppLeader' })
+  SyncHeadSubscribe,
+  SyncHeadUnsubscribe,
+  SetSyncLatch.Request,
+).annotations({ identifier: 'LSD.Leader.MessageToApp' })
 
-export type MessageToAppLeader = typeof MessageToAppLeader.Type
+export type MessageToApp = typeof MessageToApp.Type
 
-export const MessageFromAppLeader = Schema.Union(
+export const MessageFromApp = Schema.Union(
   SnapshotRes,
   LoadDatabaseFileRes,
   MutationLogRes,
-  ResetAllDataRes,
   Disconnect,
   MutationBroadcast,
   NetworkStatusRes,
@@ -110,6 +168,9 @@ export const MessageFromAppLeader = Schema.Union(
   DatabaseFileInfoRes,
   SyncHistoryRes,
   SyncingInfoRes,
-).annotations({ identifier: 'LSD.MessageFromAppLeader' })
+  SyncHeadRes,
+  ResetAllData.Response,
+  SetSyncLatch.Response,
+).annotations({ identifier: 'LSD.Leader.MessageFromApp' })
 
-export type MessageFromAppLeader = typeof MessageFromAppLeader.Type
+export type MessageFromApp = typeof MessageFromApp.Type

package/src/devtools/devtools-messages.ts

@@ -1,3 +1,3 @@
-export * from './devtools-messages-client-session.js'
-export * from './devtools-messages-leader.js'
+export * as ClientSession from './devtools-messages-client-session.js'
+export * as Leader from './devtools-messages-leader.js'
 export * from './devtools-messages-common.js'

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,
@@ -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) {
@@ -164,8 +159,7 @@ 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)
@@ -220,7 +214,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 +238,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 +251,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 {
@@ -431,7 +437,7 @@ const backgroundBackendPulling = ({
   syncStateSref,
   localPushesLatch,
   pullLatch,
-  devtoolsPullLatch,
+  devtoolsLatch,
   initialBlockingSyncContext,
 }: {
   dbReady: Deferred.Deferred<void>
@@ -444,7 +450,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 +472,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
@@ -646,10 +652,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 +673,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 +686,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

package/src/leader-thread/connection.ts

@@ -12,13 +12,58 @@ namespace WaSqlite {
   export type SQLiteError = any
 }
 
-export const configureConnection = (sqliteDb: SqliteDb, { fkEnabled }: { fkEnabled: boolean }) =>
+type ConnectionOptions = {
+  /**
+   * The database connection locking mode.
+   *
+   * @remarks
+   *
+   * This **option is ignored** when used on an **in-memory database** as they can only operate in exclusive locking mode.
+   * In-memory databases can’t share state between connections (unless using a
+   * {@link https://www.sqlite.org/sharedcache.html#shared_cache_and_in_memory_databases|shared cache}),
+   * making concurrent access impossible. This is functionally equivalent to exclusive locking.
+   *
+   * @defaultValue
+   * The default is `"NORMAL"` unless it was unless overridden at compile-time using `SQLITE_DEFAULT_LOCKING_MODE`.
+   *
+   * @see {@link https://www.sqlite.org/pragma.html#pragma_locking_mode|`locking_mode` pragma}
+   */
+  lockingMode?: 'NORMAL' | 'EXCLUSIVE'
+
+  /**
+   * Whether to enforce foreign key constraints.
+   *
+   * @privateRemarks
+   *
+   * We require a value for this option to minimize future problems, as the default value might change in future
+   * versions of SQLite.
+   *
+   * @see {@link https://www.sqlite.org/pragma.html#pragma_foreign_keys|`foreign_keys` pragma}
+   */
+  foreignKeys: boolean
+}
+
+export const configureConnection = (sqliteDb: SqliteDb, { foreignKeys, lockingMode }: ConnectionOptions) =>
   execSql(
     sqliteDb,
+    // We use the WAL journal mode is significantly faster in most scenarios than the traditional rollback journal mode.
+    // It specifically significantly improves write performance. However, when using the WAL journal mode, transactions
+    // that involve changes against multiple ATTACHed databases are atomic for each database but are not atomic
+    // across all databases as a set. Additionally, it is not possible to change the page size after entering WAL mode,
+    // whether on an empty database or by using VACUUM or the backup API. To change the page size, we must switch to the
+    // rollback journal mode.
+    //
+    // When connected to an in-memory database, the WAL journal mode option is ignored because an in-memory database can
+    // only be in either the MEMORY or OFF options. By default, an in-memory database is in the MEMORY option, which
+    // means that it stores the rollback journal in volatile RAM. This saves disk I/O but at the expense of safety and
+    // integrity. If the thread using SQLite crashes in the middle of a transaction, then the database file will very
+    // likely go corrupt.
     sql`
+    -- disable WAL until we have it working properly
+    -- PRAGMA journal_mode=WAL;
     PRAGMA page_size=8192;
-    PRAGMA journal_mode=MEMORY;
-    ${fkEnabled ? sql`PRAGMA foreign_keys='ON';` : sql`PRAGMA foreign_keys='OFF';`}
+    PRAGMA foreign_keys=${foreignKeys ? 'ON' : 'OFF'};
+    ${lockingMode === undefined ? '' : sql`PRAGMA locking_mode=${lockingMode};`}
   `,
     {},
   )

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

@@ -5,7 +5,7 @@ import { MUTATION_LOG_META_TABLE, SCHEMA_META_TABLE, SCHEMA_MUTATIONS_META_TABLE
 import type { DevtoolsOptions, PersistenceInfoPair } from './types.js'
 import { LeaderThreadCtx } from './types.js'
 
-type SendMessageToDevtools = (message: Devtools.MessageFromAppLeader) => Effect.Effect<void>
+type SendMessageToDevtools = (message: Devtools.Leader.MessageFromApp) => Effect.Effect<void>
 
 // TODO bind scope to the webchannel lifetime
 export const bootDevtools = (options: DevtoolsOptions) =>
@@ -43,7 +43,7 @@ export const bootDevtools = (options: DevtoolsOptions) =>
           if (msg.payload._tag === 'upstream-advance') {
             for (const mutationEventEncoded of msg.payload.newEvents) {
               // TODO refactor with push semantics
-              yield* sendMessage(Devtools.MutationBroadcast.make({ mutationEventEncoded, liveStoreVersion }))
+              yield* sendMessage(Devtools.Leader.MutationBroadcast.make({ mutationEventEncoded, liveStoreVersion }))
             }
           } else {
             yield* Effect.logWarning('TODO implement rebases in devtools')
@@ -66,7 +66,7 @@ const listenToDevtools = ({
   sendMessage,
   persistenceInfo,
 }: {
-  incomingMessages: Stream.Stream<Devtools.MessageToAppLeader>
+  incomingMessages: Stream.Stream<Devtools.Leader.MessageToApp>
   sendMessage: SendMessageToDevtools
   persistenceInfo?: PersistenceInfoPair
 }) =>
@@ -79,6 +79,8 @@ const listenToDevtools = ({
       shutdownStateSubRef,
       shutdownChannel,
       syncProcessor,
+      clientId,
+      devtools,
     } = yield* LeaderThreadCtx
 
     type RequestId = string
@@ -89,22 +91,22 @@ const listenToDevtools = ({
         Effect.gen(function* () {
           // yield* Effect.logDebug('[@livestore/common:leader-thread:devtools] incomingMessage', decodedEvent)
 
-          if (decodedEvent._tag === 'LSD.Disconnect') {
+          if (decodedEvent._tag === 'LSD.Leader.Disconnect') {
             return
           }
 
           const { requestId } = decodedEvent
-          const reqPayload = { requestId, liveStoreVersion }
+          const reqPayload = { requestId, liveStoreVersion, clientId }
 
           switch (decodedEvent._tag) {
-            case 'LSD.Ping': {
-              yield* sendMessage(Devtools.Pong.make({ ...reqPayload }))
+            case 'LSD.Leader.Ping': {
+              yield* sendMessage(Devtools.Leader.Pong.make({ ...reqPayload }))
               return
             }
             case 'LSD.Leader.SnapshotReq': {
               const snapshot = dbReadModel.export()
 
-              yield* sendMessage(Devtools.SnapshotRes.make({ snapshot, ...reqPayload }))
+              yield* sendMessage(Devtools.Leader.SnapshotRes.make({ snapshot, ...reqPayload }))
 
               return
             }
@@ -125,7 +127,9 @@ const listenToDevtools = ({
                 tmpDb.close()
               } catch (e) {
                 yield* Effect.logError(`Error importing database file`, e)
-                yield* sendMessage(Devtools.LoadDatabaseFileRes.make({ ...reqPayload, status: 'unsupported-file' }))
+                yield* sendMessage(
+                  Devtools.Leader.LoadDatabaseFileRes.make({ ...reqPayload, status: 'unsupported-file' }),
+                )
 
                 return
               }
@@ -143,17 +147,19 @@ const listenToDevtools = ({
 
                 dbMutationLog.destroy()
               } else {
-                yield* sendMessage(Devtools.LoadDatabaseFileRes.make({ ...reqPayload, status: 'unsupported-database' }))
+                yield* sendMessage(
+                  Devtools.Leader.LoadDatabaseFileRes.make({ ...reqPayload, status: 'unsupported-database' }),
+                )
                 return
               }
 
-              yield* sendMessage(Devtools.LoadDatabaseFileRes.make({ ...reqPayload, status: 'ok' }))
+              yield* sendMessage(Devtools.Leader.LoadDatabaseFileRes.make({ ...reqPayload, status: 'ok' }))
 
               yield* shutdownChannel.send(IntentionalShutdownCause.make({ reason: 'devtools-import' })) ?? Effect.void
 
               return
             }
-            case 'LSD.Leader.ResetAllDataReq': {
+            case 'LSD.Leader.ResetAllData.Request': {
               const { mode } = decodedEvent
 
               yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
@@ -164,7 +170,7 @@ const listenToDevtools = ({
                 dbMutationLog.destroy()
               }
 
-              yield* sendMessage(Devtools.ResetAllDataRes.make({ ...reqPayload }))
+              yield* sendMessage(Devtools.Leader.ResetAllData.Response.make({ ...reqPayload }))
 
               yield* shutdownChannel.send(IntentionalShutdownCause.make({ reason: 'devtools-reset' })) ?? Effect.void
 
@@ -181,7 +187,7 @@ const listenToDevtools = ({
               const mutationLogFileSize = dbMutationLog.select<{ size: number }>(dbSizeQuery, undefined)[0]!.size
 
               yield* sendMessage(
-                Devtools.DatabaseFileInfoRes.make({
+                Devtools.Leader.DatabaseFileInfoRes.make({
                   readModel: { fileSize: dbFileSize, persistenceInfo: persistenceInfo.readModel },
                   mutationLog: { fileSize: mutationLogFileSize, persistenceInfo: persistenceInfo.mutationLog },
                   ...reqPayload,
@@ -193,14 +199,14 @@ const listenToDevtools = ({
             case 'LSD.Leader.MutationLogReq': {
               const mutationLog = dbMutationLog.export()
 
-              yield* sendMessage(Devtools.MutationLogRes.make({ mutationLog, ...reqPayload }))
+              yield* sendMessage(Devtools.Leader.MutationLogRes.make({ mutationLog, ...reqPayload }))
 
               return
             }
             case 'LSD.Leader.RunMutationReq': {
               yield* syncProcessor.pushPartial(decodedEvent.mutationEventEncoded)
 
-              yield* sendMessage(Devtools.RunMutationRes.make({ ...reqPayload }))
+              yield* sendMessage(Devtools.Leader.RunMutationRes.make({ ...reqPayload }))
 
               return
             }
@@ -213,7 +219,7 @@ const listenToDevtools = ({
                   Stream.map((_) => _.batch),
                   Stream.flattenIterables,
                   Stream.tap(({ mutationEventEncoded, metadata }) =>
-                    sendMessage(Devtools.SyncHistoryRes.make({ mutationEventEncoded, metadata, ...reqPayload })),
+                    sendMessage(Devtools.Leader.SyncHistoryRes.make({ mutationEventEncoded, metadata, ...reqPayload })),
                   ),
                   Stream.runDrain,
                   Effect.acquireRelease(() => Effect.log('syncHistorySubscribe done')),
@@ -234,12 +240,12 @@ const listenToDevtools = ({
               return
             }
             case 'LSD.Leader.SyncingInfoReq': {
-              const syncingInfo = Devtools.SyncingInfo.make({
+              const syncingInfo = Devtools.Leader.SyncingInfo.make({
                 enabled: syncBackend !== undefined,
                 metadata: {},
               })
 
-              yield* sendMessage(Devtools.SyncingInfoRes.make({ syncingInfo, ...reqPayload }))
+              yield* sendMessage(Devtools.Leader.SyncingInfoRes.make({ syncingInfo, ...reqPayload }))
 
               return
             }
@@ -252,11 +258,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.NetworkStatusRes.make({
-                        networkStatus: { isConnected, timestampMs: Date.now() },
+                      Devtools.Leader.NetworkStatusRes.make({
+                        networkStatus: { isConnected, timestampMs: Date.now(), latchClosed },
                         ...reqPayload,
                       }),
                     ),
@@ -277,6 +286,54 @@ const listenToDevtools = ({
 
               return
             }
+            case 'LSD.Leader.SyncHeadSubscribe': {
+              const { requestId } = decodedEvent
+
+              yield* syncProcessor.syncState.changes.pipe(
+                Stream.tap((syncState) =>
+                  sendMessage(
+                    Devtools.Leader.SyncHeadRes.make({
+                      local: syncState.localHead,
+                      upstream: syncState.upstreamHead,
+                      ...reqPayload,
+                    }),
+                  ),
+                ),
+                Stream.runDrain,
+                Effect.interruptible,
+                Effect.tapCauseLogPretty,
+                FiberMap.run(subscriptionFiberMap, requestId),
+              )
+
+              return
+            }
+            case 'LSD.Leader.SyncHeadUnsubscribe': {
+              const { requestId } = decodedEvent
+
+              yield* FiberMap.remove(subscriptionFiberMap, requestId)
+
+              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 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'
@@ -67,15 +67,15 @@ export const makeLeaderThreadLayer = ({
       initialBlockingSyncContext,
     })
 
-    const extraIncomingMessagesQueue = yield* Queue.unbounded<Devtools.MessageToAppLeader>().pipe(
+    const extraIncomingMessagesQueue = yield* Queue.unbounded<Devtools.Leader.MessageToApp>().pipe(
       Effect.acquireRelease(Queue.shutdown),
     )
 
     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,10 +212,14 @@ 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)
@@ -221,4 +231,6 @@ const bootLeaderThread = ({
     yield* Queue.offer(bootStatusQueue, { stage: 'done' })
 
     yield* bootDevtools(devtoolsOptions).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
+
+    return { migrationsReport, leaderHead: initialLeaderHead }
   })