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

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, MakeSynchronousDatabase, SqliteError, SynchronousDatabase } from '../adapter-types.js'
+import type { BootStatus, MakeSqliteDb, 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'
@@ -15,27 +15,33 @@ import { makeLeaderSyncProcessor } from './LeaderSyncProcessor.js'
 import { makePullQueueSet } from './pull-queue-set.js'
 import { recreateDb } from './recreate-db.js'
 import type { ShutdownChannel } from './shutdown-channel.js'
-import type { DevtoolsOptions, InitialBlockingSyncContext, InitialSyncOptions, ShutdownState } from './types.js'
+import type {
+  DevtoolsOptions,
+  InitialBlockingSyncContext,
+  InitialSyncOptions,
+  LeaderSqliteDb,
+  ShutdownState,
+} from './types.js'
 import { LeaderThreadCtx } from './types.js'
 
 export const makeLeaderThreadLayer = ({
   schema,
   storeId,
   clientId,
-  makeSyncDb,
+  makeSqliteDb,
   syncOptions,
-  db,
-  dbLog,
+  dbReadModel,
+  dbMutationLog,
   devtoolsOptions,
   shutdownChannel,
 }: {
   storeId: string
   clientId: string
   schema: LiveStoreSchema
-  makeSyncDb: MakeSynchronousDatabase
+  makeSqliteDb: MakeSqliteDb
   syncOptions: SyncOptions | undefined
-  db: SynchronousDatabase
-  dbLog: SynchronousDatabase
+  dbReadModel: LeaderSqliteDb
+  dbMutationLog: LeaderSqliteDb
   devtoolsOptions: DevtoolsOptions
   shutdownChannel: ShutdownChannel
 }): Layer.Layer<LeaderThreadCtx, UnexpectedError, Scope.Scope | HttpClient.HttpClient> =>
@@ -44,7 +50,8 @@ export const makeLeaderThreadLayer = ({
 
     // TODO do more validation here than just checking the count of tables
     // Either happens on initial boot or if schema changes
-    const dbMissing = db.select<{ count: number }>(sql`select count(*) as count from sqlite_master`)[0]!.count === 0
+    const dbMissing =
+      dbReadModel.select<{ count: number }>(sql`select count(*) as count from sqlite_master`)[0]!.count === 0
 
     const syncBackend = syncOptions === undefined ? undefined : yield* syncOptions.makeBackend({ storeId, clientId })
 
@@ -53,20 +60,33 @@ export const makeLeaderThreadLayer = ({
       bootStatusQueue,
     })
 
-    const syncProcessor = yield* makeLeaderSyncProcessor({ schema, dbMissing, dbLog, initialBlockingSyncContext })
+    const syncProcessor = yield* makeLeaderSyncProcessor({
+      schema,
+      dbMissing,
+      dbMutationLog,
+      initialBlockingSyncContext,
+    })
 
     const extraIncomingMessagesQueue = yield* Queue.unbounded<Devtools.MessageToAppLeader>().pipe(
       Effect.acquireRelease(Queue.shutdown),
     )
 
+    const devtoolsContext = devtoolsOptions.enabled
+      ? {
+          enabled: true as const,
+          syncBackendPullLatch: yield* Effect.makeLatch(true),
+          syncBackendPushLatch: yield* Effect.makeLatch(true),
+        }
+      : { enabled: false as const }
+
     const ctx = {
       schema,
       bootStatusQueue,
       storeId,
       clientId,
-      db,
-      dbLog,
-      makeSyncDb,
+      dbReadModel,
+      dbMutationLog,
+      makeSqliteDb,
       mutationEventSchema: MutationEvent.makeMutationEventSchema(schema),
       shutdownStateSubRef: yield* SubscriptionRef.make<ShutdownState>('running'),
       shutdownChannel,
@@ -74,6 +94,7 @@ export const makeLeaderThreadLayer = ({
       syncProcessor,
       connectedClientSessionPullQueues: yield* makePullQueueSet,
       extraIncomingMessagesQueue,
+      devtools: devtoolsContext,
     } satisfies typeof LeaderThreadCtx.Service
 
     // @ts-expect-error For debugging purposes
@@ -156,17 +177,17 @@ const bootLeaderThread = ({
   LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient
 > =>
   Effect.gen(function* () {
-    const { dbLog, bootStatusQueue, syncProcessor } = yield* LeaderThreadCtx
+    const { dbMutationLog, bootStatusQueue, syncProcessor } = yield* LeaderThreadCtx
 
     yield* migrateTable({
-      db: dbLog,
+      db: dbMutationLog,
       behaviour: 'create-if-not-exists',
       tableAst: mutationLogMetaTable.sqliteDef.ast,
       skipMetaTable: true,
     })
 
     yield* migrateTable({
-      db: dbLog,
+      db: dbMutationLog,
       behaviour: 'create-if-not-exists',
       tableAst: syncStatusTable.sqliteDef.ast,
       skipMetaTable: true,
@@ -174,7 +195,7 @@ const bootLeaderThread = ({
 
     // Create sync status row if it doesn't exist
     yield* execSql(
-      dbLog,
+      dbMutationLog,
       sql`INSERT INTO ${SYNC_STATUS_TABLE} (head)
           SELECT ${EventId.ROOT.global}
           WHERE NOT EXISTS (SELECT 1 FROM ${SYNC_STATUS_TABLE})`,

package/src/leader-thread/mutationlog.ts

@@ -1,6 +1,6 @@
 import { Effect, Schema } from '@livestore/utils/effect'
 
-import type { SynchronousDatabase } from '../adapter-types.js'
+import type { SqliteDb } from '../adapter-types.js'
 import * as EventId from '../schema/EventId.js'
 import type * as MutationEvent from '../schema/MutationEvent.js'
 import { MUTATION_LOG_META_TABLE, mutationLogMetaTable, SYNC_STATUS_TABLE } from '../schema/system-tables.js'
@@ -11,10 +11,10 @@ export const getMutationEventsSince = (
   since: EventId.EventId,
 ): Effect.Effect<ReadonlyArray<MutationEvent.AnyEncoded>, never, LeaderThreadCtx> =>
   Effect.gen(function* () {
-    const { dbLog } = yield* LeaderThreadCtx
+    const { dbMutationLog } = yield* LeaderThreadCtx
 
     const query = mutationLogMetaTable.query.where('idGlobal', '>=', since.global).asSql()
-    const pendingMutationEventsRaw = dbLog.select(query.query, prepareBindValues(query.bindValues, query.query))
+    const pendingMutationEventsRaw = dbMutationLog.select(query.query, prepareBindValues(query.bindValues, query.query))
     const pendingMutationEvents = Schema.decodeUnknownSync(mutationLogMetaTable.schema.pipe(Schema.Array))(
       pendingMutationEventsRaw,
     )
@@ -29,18 +29,18 @@ export const getMutationEventsSince = (
       .filter((_) => EventId.compare(_.id, since) > 0)
   })
 
-export const getLocalHeadFromDb = (dbLog: SynchronousDatabase): EventId.EventId => {
-  const res = dbLog.select<{ idGlobal: EventId.GlobalEventId; idLocal: EventId.LocalEventId }>(
+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`,
   )[0]
 
   return res ? { global: res.idGlobal, local: res.idLocal } : EventId.ROOT
 }
 
-export const getBackendHeadFromDb = (dbLog: SynchronousDatabase): EventId.GlobalEventId =>
-  dbLog.select<{ head: EventId.GlobalEventId }>(sql`select head from ${SYNC_STATUS_TABLE}`)[0]?.head ??
+export const getBackendHeadFromDb = (dbMutationLog: SqliteDb): EventId.GlobalEventId =>
+  dbMutationLog.select<{ head: EventId.GlobalEventId }>(sql`select head from ${SYNC_STATUS_TABLE}`)[0]?.head ??
   EventId.ROOT.global
 
 // TODO use prepared statements
-export const updateBackendHead = (dbLog: SynchronousDatabase, head: EventId.EventId) =>
-  dbLog.execute(sql`UPDATE ${SYNC_STATUS_TABLE} SET head = ${head.global}`)
+export const updateBackendHead = (dbMutationLog: SqliteDb, head: EventId.EventId) =>
+  dbMutationLog.execute(sql`UPDATE ${SYNC_STATUS_TABLE} SET head = ${head.global}`)

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

@@ -12,56 +12,56 @@ export const recreateDb: Effect.Effect<
   UnexpectedError | SqliteError | IsOfflineError | InvalidPullError,
   LeaderThreadCtx | HttpClient.HttpClient
 > = Effect.gen(function* () {
-  const { db, dbLog, makeSyncDb, schema, bootStatusQueue } = yield* LeaderThreadCtx
+  const { dbReadModel, dbMutationLog, schema, bootStatusQueue } = yield* LeaderThreadCtx
 
   const migrationOptions = schema.migrationOptions
 
   yield* Effect.addFinalizer(
     Effect.fn('recreateDb:finalizer')(function* (ex) {
-      if (ex._tag === 'Failure') db.destroy()
+      if (ex._tag === 'Failure') dbReadModel.destroy()
     }),
   )
 
   // NOTE to speed up the operations below, we're creating a temporary in-memory database
   // and later we'll overwrite the persisted database with the new data
   // TODO bring back this optimization
-  // const tmpSyncDb = yield* makeSyncDb({ _tag: 'in-memory' })
-  const tmpSyncDb = db
-  yield* configureConnection(tmpSyncDb, { fkEnabled: true })
+  // const tmpDb = yield* makeSqliteDb({ _tag: 'in-memory' })
+  const tmpDb = dbReadModel
+  yield* configureConnection(tmpDb, { fkEnabled: true })
 
   const initDb = (hooks: Partial<MigrationHooks> | undefined) =>
     Effect.gen(function* () {
-      yield* Effect.tryAll(() => hooks?.init?.(tmpSyncDb)).pipe(UnexpectedError.mapToUnexpectedError)
+      yield* Effect.tryAll(() => hooks?.init?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
       yield* migrateDb({
-        db: tmpSyncDb,
+        db: tmpDb,
         schema,
         onProgress: ({ done, total }) =>
           Queue.offer(bootStatusQueue, { stage: 'migrating', progress: { done, total } }),
       })
 
-      initializeSingletonTables(schema, tmpSyncDb)
+      initializeSingletonTables(schema, tmpDb)
 
-      yield* Effect.tryAll(() => hooks?.pre?.(tmpSyncDb)).pipe(UnexpectedError.mapToUnexpectedError)
+      yield* Effect.tryAll(() => hooks?.pre?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
-      return tmpSyncDb
+      return tmpDb
     })
 
   switch (migrationOptions.strategy) {
     case 'from-mutation-log': {
       const hooks = migrationOptions.hooks
-      const tmpSyncDb = yield* initDb(hooks)
+      const tmpDb = yield* initDb(hooks)
 
       yield* rehydrateFromMutationLog({
-        db: tmpSyncDb,
-        logDb: dbLog,
+        db: tmpDb,
+        logDb: dbMutationLog,
         schema,
         migrationOptions,
         onProgress: ({ done, total }) =>
           Queue.offer(bootStatusQueue, { stage: 'rehydrating', progress: { done, total } }),
       })
 
-      yield* Effect.tryAll(() => hooks?.post?.(tmpSyncDb)).pipe(UnexpectedError.mapToUnexpectedError)
+      yield* Effect.tryAll(() => hooks?.post?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
       break
     }
@@ -76,13 +76,13 @@ export const recreateDb: Effect.Effect<
       break
     }
     case 'manual': {
-      const oldDbData = db.export()
+      const oldDbData = dbReadModel.export()
 
       const newDbData = yield* Effect.tryAll(() => migrationOptions.migrate(oldDbData)).pipe(
         UnexpectedError.mapToUnexpectedError,
       )
 
-      tmpSyncDb.import(newDbData)
+      tmpDb.import(newDbData)
 
       // TODO validate schema
 
@@ -95,17 +95,17 @@ export const recreateDb: Effect.Effect<
 
   // TODO bring back
   // Import the temporary in-memory database into the persistent database
-  // yield* Effect.sync(() => db.import(tmpSyncDb)).pipe(
+  // yield* Effect.sync(() => db.import(tmpDb)).pipe(
   //   Effect.withSpan('@livestore/common:leader-thread:recreateDb:import'),
   // )
 
   // TODO maybe bring back re-using this initial snapshot to avoid calling `.export()` again
   // We've disabled this for now as it made the code too complex, as we often run syncing right after
   // so the snapshot is no longer up to date
-  // const snapshotFromTmpDb = tmpSyncDb.export()
+  // const snapshotFromTmpDb = tmpDb.export()
 
   // TODO bring back
-  // tmpSyncDb.close()
+  // tmpDb.close()
 }).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'),

package/src/leader-thread/types.ts

@@ -16,10 +16,10 @@ import type {
   BootStatus,
   Devtools,
   InvalidPushError,
-  MakeSynchronousDatabase,
+  MakeSqliteDb,
   PersistenceInfo,
+  SqliteDb,
   SyncBackend,
-  SynchronousDatabase,
   UnexpectedError,
 } from '../index.js'
 import type { EventId, LiveStoreSchema, MutationEvent } from '../schema/mod.js'
@@ -56,8 +56,8 @@ export type InitialSyncInfo = Option.Option<{
 //   | { _tag: 'Recreate'; snapshotRef: Ref.Ref<Uint8Array | undefined>; syncInfo: InitialSyncInfo }
 //   | { _tag: 'Reuse'; syncInfo: InitialSyncInfo }
 
-export type LeaderDatabase = SynchronousDatabase<{ dbPointer: number; persistenceInfo: PersistenceInfo }>
-export type PersistenceInfoPair = { db: PersistenceInfo; mutationLog: PersistenceInfo }
+export type LeaderSqliteDb = SqliteDb<{ dbPointer: number; persistenceInfo: PersistenceInfo }>
+export type PersistenceInfoPair = { readModel: PersistenceInfo; mutationLog: PersistenceInfo }
 
 export type DevtoolsOptions =
   | {
@@ -65,7 +65,7 @@ export type DevtoolsOptions =
     }
   | {
       enabled: true
-      makeContext: Effect.Effect<
+      makeBootContext: Effect.Effect<
         {
           devtoolsWebChannel: WebChannel.WebChannel<Devtools.MessageToAppLeader, Devtools.MessageFromAppLeader>
           persistenceInfo: PersistenceInfoPair
@@ -75,25 +75,39 @@ export type DevtoolsOptions =
       >
     }
 
+export type DevtoolsContext =
+  | {
+      enabled: true
+      syncBackendPullLatch: Effect.Latch
+      syncBackendPushLatch: Effect.Latch
+    }
+  | {
+      enabled: false
+    }
+
 export class LeaderThreadCtx extends Context.Tag('LeaderThreadCtx')<
   LeaderThreadCtx,
   {
     schema: LiveStoreSchema
     storeId: string
     clientId: string
-    makeSyncDb: MakeSynchronousDatabase
-    db: LeaderDatabase
-    dbLog: LeaderDatabase
+    makeSqliteDb: MakeSqliteDb
+    dbReadModel: LeaderSqliteDb
+    dbMutationLog: LeaderSqliteDb
     bootStatusQueue: Queue.Queue<BootStatus>
     // TODO we should find a more elegant way to handle cases which need this ref for their implementation
     shutdownStateSubRef: SubscriptionRef.SubscriptionRef<ShutdownState>
     shutdownChannel: ShutdownChannel
     mutationEventSchema: MutationEvent.ForMutationDefRecord<any>
-    // devtools: DevtoolsContext
+    devtools: DevtoolsContext
     syncBackend: SyncBackend | undefined
     syncProcessor: LeaderSyncProcessor
     connectedClientSessionPullQueues: PullQueueSet
-    /** e.g. used for `store.__dev` APIs */
+    /**
+     * e.g. used for `store._dev` APIs
+     *
+     * This is currently separated from `.devtools` as it also needs to work when devtools are disabled
+     */
     extraIncomingMessagesQueue: Queue.Queue<Devtools.MessageToAppLeader>
   }
 >() {}

package/src/rehydrate-from-mutationlog.ts

@@ -1,7 +1,7 @@
 import { memoizeByRef, shouldNeverHappen } from '@livestore/utils'
 import { Chunk, Effect, Option, Schema, Stream } from '@livestore/utils/effect'
 
-import { type MigrationOptionsFromMutationLog, type SynchronousDatabase, UnexpectedError } from './adapter-types.js'
+import { type MigrationOptionsFromMutationLog, type SqliteDb, UnexpectedError } from './adapter-types.js'
 import { makeApplyMutation } from './leader-thread/apply-mutation.js'
 import type { LiveStoreSchema, MutationDef, MutationEvent, MutationLogMetaRow } from './schema/mod.js'
 import { EventId, MUTATION_LOG_META_TABLE } from './schema/mod.js'
@@ -16,8 +16,8 @@ export const rehydrateFromMutationLog = ({
   migrationOptions,
   onProgress,
 }: {
-  logDb: SynchronousDatabase
-  db: SynchronousDatabase
+  logDb: SqliteDb
+  db: SqliteDb
   schema: LiveStoreSchema
   migrationOptions: MigrationOptionsFromMutationLog
   onProgress: (_: { done: number; total: number }) => Effect.Effect<void>

package/src/schema-management/common.ts

@@ -1,4 +1,4 @@
-import type { SynchronousDatabase } from '../adapter-types.js'
+import type { SqliteDb } from '../adapter-types.js'
 import type { ParamsObject } from '../util.js'
 import { prepareBindValues } from '../util.js'
 
@@ -6,7 +6,7 @@ import { prepareBindValues } from '../util.js'
 // will require proper scope-aware cleanup etc (for testing and apps with multiple LiveStore instances)
 // const cachedStmts = new Map<string, PreparedStatement>()
 
-export const dbExecute = (db: SynchronousDatabase, queryStr: string, bindValues?: ParamsObject) => {
+export const dbExecute = (db: SqliteDb, queryStr: string, bindValues?: ParamsObject) => {
   // let stmt = cachedStmts.get(queryStr)
   // if (!stmt) {
   const stmt = db.prepare(queryStr)
@@ -20,7 +20,7 @@ export const dbExecute = (db: SynchronousDatabase, queryStr: string, bindValues?
   stmt.finalize()
 }
 
-export const dbSelect = <T>(db: SynchronousDatabase, queryStr: string, bindValues?: ParamsObject) => {
+export const dbSelect = <T>(db: SqliteDb, queryStr: string, bindValues?: ParamsObject) => {
   // let stmt = cachedStmts.get(queryStr)
   // if (!stmt) {
   const stmt = db.prepare(queryStr)

package/src/schema-management/migrations.ts

@@ -2,7 +2,7 @@ import { SqliteAst, SqliteDsl } from '@livestore/db-schema'
 import { memoizeByStringifyArgs } from '@livestore/utils'
 import { Effect, Schema as EffectSchema } from '@livestore/utils/effect'
 
-import type { SynchronousDatabase } from '../adapter-types.js'
+import type { SqliteDb } from '../adapter-types.js'
 import type { LiveStoreSchema } from '../schema/mod.js'
 import type { SchemaMetaRow, SchemaMutationsMetaRow } from '../schema/system-tables.js'
 import {
@@ -19,7 +19,7 @@ import { validateSchema } from './validate-mutation-defs.js'
 
 const getMemoizedTimestamp = memoizeByStringifyArgs(() => new Date().toISOString())
 
-export const makeSchemaManager = (db: SynchronousDatabase): Effect.Effect<SchemaManager> =>
+export const makeSchemaManager = (db: SqliteDb): Effect.Effect<SchemaManager> =>
   Effect.gen(function* () {
     yield* migrateTable({
       db,
@@ -51,7 +51,7 @@ export const migrateDb = ({
   schema,
   onProgress,
 }: {
-  db: SynchronousDatabase
+  db: SqliteDb
   schema: LiveStoreSchema
   onProgress?: (opts: { done: number; total: number }) => Effect.Effect<void>
 }) =>
@@ -116,7 +116,7 @@ export const migrateTable = ({
   behaviour,
   skipMetaTable = false,
 }: {
-  db: SynchronousDatabase
+  db: SqliteDb
   tableAst: SqliteAst.Table
   schemaHash?: number
   behaviour: 'drop-and-recreate' | 'create-if-not-exists'

package/src/sync/ClientSessionSyncProcessor.ts

@@ -1,9 +1,9 @@
 import { LS_DEV, shouldNeverHappen, TRACE_VERBOSE } from '@livestore/utils'
-import type { Scope } from '@livestore/utils/effect'
+import type { Runtime, Scope } from '@livestore/utils/effect'
 import { Effect, Schema, Stream } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 
-import type { ClientSessionLeaderThreadProxy, UnexpectedError } from '../adapter-types.js'
+import type { ClientSession, UnexpectedError } from '../adapter-types.js'
 import * as EventId from '../schema/EventId.js'
 import { type LiveStoreSchema } from '../schema/mod.js'
 import * as MutationEvent from '../schema/MutationEvent.js'
@@ -20,18 +20,16 @@ import { SyncState, updateSyncState } from './syncstate.js'
  */
 export const makeClientSessionSyncProcessor = ({
   schema,
-  initialLeaderHead,
-  pushToLeader,
-  pullFromLeader,
+  clientSession,
+  runtime,
   applyMutation,
   rollback,
   refreshTables,
   span,
 }: {
   schema: LiveStoreSchema
-  initialLeaderHead: EventId.EventId
-  pushToLeader: (batch: ReadonlyArray<MutationEvent.AnyEncoded>) => void
-  pullFromLeader: ClientSessionLeaderThreadProxy['mutations']['pull']
+  clientSession: ClientSession
+  runtime: Runtime.Runtime<Scope.Scope>
   applyMutation: (
     mutationEventDecoded: MutationEvent.PartialAnyDecoded,
     options: { otelContext: otel.Context; withChangeset: boolean },
@@ -47,8 +45,8 @@ export const makeClientSessionSyncProcessor = ({
 
   const syncStateRef = {
     current: new SyncState({
-      localHead: initialLeaderHead,
-      upstreamHead: initialLeaderHead,
+      localHead: clientSession.leaderThread.mutations.initialMutationEventId,
+      upstreamHead: clientSession.leaderThread.mutations.initialMutationEventId,
       pending: [],
       // TODO init rollbackTail from leader to be ready for backend rebasing
       rollbackTail: [],
@@ -103,7 +101,9 @@ export const makeClientSessionSyncProcessor = ({
     }
 
     // console.debug('pushToLeader', encodedMutationEvents.length, ...encodedMutationEvents.map((_) => _.toJSON()))
-    pushToLeader(encodedMutationEvents)
+    clientSession.leaderThread.mutations
+      .push(encodedMutationEvents)
+      .pipe(Effect.tapCauseLogPretty, Effect.provide(runtime), Effect.runFork)
 
     return { writeTables }
   }
@@ -111,10 +111,13 @@ export const makeClientSessionSyncProcessor = ({
   const otelContext = otel.trace.setSpan(otel.context.active(), span)
 
   const boot: ClientSessionSyncProcessor['boot'] = Effect.gen(function* () {
-    yield* pullFromLeader.pipe(
+    yield* clientSession.leaderThread.mutations.pull.pipe(
       Stream.tap(({ payload, remaining }) =>
         Effect.gen(function* () {
           // console.log('pulled payload from leader', { payload, remaining })
+          if (clientSession.devtools.enabled) {
+            yield* clientSession.devtools.pullLatch.await
+          }
 
           const updateResult = updateSyncState({
             syncState: syncStateRef.current,
@@ -155,7 +158,9 @@ export const makeClientSessionSyncProcessor = ({
               }
             }
 
-            pushToLeader(updateResult.newSyncState.pending)
+            clientSession.leaderThread.mutations
+              .push(updateResult.newSyncState.pending)
+              .pipe(Effect.tapCauseLogPretty, Effect.provide(runtime), Effect.runFork)
           } else {
             span.addEvent('pull:advance', {
               payloadTag: payload._tag,

package/src/version.ts

@@ -2,7 +2,7 @@
 // import packageJson from '../package.json' with { type: 'json' }
 // export const liveStoreVersion = packageJson.version
 
-export const liveStoreVersion = '0.3.0-dev.10' as const
+export const liveStoreVersion = '0.3.0-dev.11' as const
 
 /**
  * This version number is incremented whenever the internal storage format changes in a breaking way.