@livestore/common 0.3.1 → 0.3.2-dev.0

package/src/leader-thread/eventlog.ts

@@ -14,7 +14,7 @@ import {
 import { migrateTable } from '../schema-management/migrations.js'
 import { insertRow, updateRows } from '../sql-queries/sql-queries.js'
 import type { PreparedBindValues } from '../util.js'
-import { prepareBindValues, sql } from '../util.js'
+import { sql } from '../util.js'
 import { execSql } from './connection.js'
 import type { InitialSyncInfo } from './types.js'
 import { LeaderThreadCtx } from './types.js'
@@ -40,68 +40,78 @@ export const initEventlogDb = (dbEventlog: SqliteDb) =>
     )
   })
 
-/** Exclusive of the "since event" */
-export const getEventsSince = (
-  since: EventSequenceNumber.EventSequenceNumber,
-): Effect.Effect<ReadonlyArray<LiveStoreEvent.EncodedWithMeta>, never, LeaderThreadCtx> =>
-  Effect.gen(function* () {
-    const { dbEventlog, dbState } = yield* LeaderThreadCtx
-
-    const query = eventlogMetaTable.where('seqNumGlobal', '>=', since.global).asSql()
-    const pendingEventsRaw = dbEventlog.select(query.query, prepareBindValues(query.bindValues, query.query))
-    const pendingEvents = Schema.decodeUnknownSync(eventlogMetaTable.rowSchema.pipe(Schema.Array))(pendingEventsRaw)
-
-    const sessionChangesetRows = sessionChangesetMetaTable.where('seqNumGlobal', '>=', since.global).asSql()
-    const sessionChangesetRowsRaw = dbState.select(
-      sessionChangesetRows.query,
-      prepareBindValues(sessionChangesetRows.bindValues, sessionChangesetRows.query),
-    )
-    const sessionChangesetRowsDecoded = Schema.decodeUnknownSync(
-      sessionChangesetMetaTable.rowSchema.pipe(Schema.Array),
-    )(sessionChangesetRowsRaw)
-
-    return pendingEvents
-      .map((eventlogEvent) => {
-        const sessionChangeset = sessionChangesetRowsDecoded.find(
-          (readModelEvent) =>
-            readModelEvent.seqNumGlobal === eventlogEvent.seqNumGlobal &&
-            readModelEvent.seqNumClient === eventlogEvent.seqNumClient,
-        )
-        return LiveStoreEvent.EncodedWithMeta.make({
-          name: eventlogEvent.name,
-          args: eventlogEvent.argsJson,
-          seqNum: { global: eventlogEvent.seqNumGlobal, client: eventlogEvent.seqNumClient },
-          parentSeqNum: { global: eventlogEvent.parentSeqNumGlobal, client: eventlogEvent.parentSeqNumClient },
-          clientId: eventlogEvent.clientId,
-          sessionId: eventlogEvent.sessionId,
-          meta: {
-            sessionChangeset:
-              sessionChangeset && sessionChangeset.changeset !== null
-                ? {
-                    _tag: 'sessionChangeset' as const,
-                    data: sessionChangeset.changeset,
-                    debug: sessionChangeset.debug,
-                  }
-                : { _tag: 'unset' as const },
-            syncMetadata: eventlogEvent.syncMetadataJson,
-            materializerHashLeader: Option.none(),
-            materializerHashSession: Option.none(),
-          },
-        })
+/**
+ * Exclusive of the "since event"
+ * Also queries the state db in order to get the SQLite session changeset data.
+ */
+export const getEventsSince = ({
+  dbEventlog,
+  dbState,
+  since,
+}: {
+  dbEventlog: SqliteDb
+  dbState: SqliteDb
+  since: EventSequenceNumber.EventSequenceNumber
+}): ReadonlyArray<LiveStoreEvent.EncodedWithMeta> => {
+  const pendingEvents = dbEventlog.select(eventlogMetaTable.where('seqNumGlobal', '>=', since.global))
+
+  const sessionChangesetRowsDecoded = dbState.select(
+    sessionChangesetMetaTable.where('seqNumGlobal', '>=', since.global),
+  )
+
+  return pendingEvents
+    .map((eventlogEvent) => {
+      const sessionChangeset = sessionChangesetRowsDecoded.find(
+        (readModelEvent) =>
+          readModelEvent.seqNumGlobal === eventlogEvent.seqNumGlobal &&
+          readModelEvent.seqNumClient === eventlogEvent.seqNumClient,
+      )
+      return LiveStoreEvent.EncodedWithMeta.make({
+        name: eventlogEvent.name,
+        args: eventlogEvent.argsJson,
+        seqNum: {
+          global: eventlogEvent.seqNumGlobal,
+          client: eventlogEvent.seqNumClient,
+          rebaseGeneration: eventlogEvent.seqNumRebaseGeneration,
+        },
+        parentSeqNum: {
+          global: eventlogEvent.parentSeqNumGlobal,
+          client: eventlogEvent.parentSeqNumClient,
+          rebaseGeneration: eventlogEvent.parentSeqNumRebaseGeneration,
+        },
+        clientId: eventlogEvent.clientId,
+        sessionId: eventlogEvent.sessionId,
+        meta: {
+          sessionChangeset:
+            sessionChangeset && sessionChangeset.changeset !== null
+              ? {
+                  _tag: 'sessionChangeset' as const,
+                  data: sessionChangeset.changeset,
+                  debug: sessionChangeset.debug,
+                }
+              : { _tag: 'unset' as const },
+          syncMetadata: eventlogEvent.syncMetadataJson,
+          materializerHashLeader: Option.none(),
+          materializerHashSession: Option.none(),
+        },
       })
-      .filter((_) => EventSequenceNumber.compare(_.seqNum, since) > 0)
-      .sort((a, b) => EventSequenceNumber.compare(a.seqNum, b.seqNum))
-  })
+    })
+    .filter((_) => EventSequenceNumber.compare(_.seqNum, since) > 0)
+    .sort((a, b) => EventSequenceNumber.compare(a.seqNum, b.seqNum))
+}
 
 export const getClientHeadFromDb = (dbEventlog: SqliteDb): EventSequenceNumber.EventSequenceNumber => {
   const res = dbEventlog.select<{
     seqNumGlobal: EventSequenceNumber.GlobalEventSequenceNumber
     seqNumClient: EventSequenceNumber.ClientEventSequenceNumber
+    seqNumRebaseGeneration: number
   }>(
-    sql`select seqNumGlobal, seqNumClient from ${EVENTLOG_META_TABLE} order by seqNumGlobal DESC, seqNumClient DESC limit 1`,
+    sql`select seqNumGlobal, seqNumClient, seqNumRebaseGeneration from ${EVENTLOG_META_TABLE} order by seqNumGlobal DESC, seqNumClient DESC limit 1`,
   )[0]
 
-  return res ? { global: res.seqNumGlobal, client: res.seqNumClient } : EventSequenceNumber.ROOT
+  return res
+    ? { global: res.seqNumGlobal, client: res.seqNumClient, rebaseGeneration: res.seqNumRebaseGeneration }
+    : EventSequenceNumber.ROOT
 }
 
 export const getBackendHeadFromDb = (dbEventlog: SqliteDb): EventSequenceNumber.GlobalEventSequenceNumber =>
@@ -145,8 +155,10 @@ export const insertIntoEventlog = (
         values: {
           seqNumGlobal: eventEncoded.seqNum.global,
           seqNumClient: eventEncoded.seqNum.client,
+          seqNumRebaseGeneration: eventEncoded.seqNum.rebaseGeneration,
           parentSeqNumGlobal: eventEncoded.parentSeqNum.global,
           parentSeqNumClient: eventEncoded.parentSeqNum.client,
+          parentSeqNumRebaseGeneration: eventEncoded.parentSeqNum.rebaseGeneration,
           name: eventEncoded.name,
           argsJson: eventEncoded.args ?? {},
           clientId,
@@ -156,6 +168,8 @@ export const insertIntoEventlog = (
         },
       }),
     )
+
+    dbEventlog.debug.head = eventEncoded.seqNum
   })
 
 export const updateSyncMetadata = (items: ReadonlyArray<LiveStoreEvent.EncodedWithMeta>) =>
@@ -178,7 +192,11 @@ export const updateSyncMetadata = (items: ReadonlyArray<LiveStoreEvent.EncodedWi
     }
   })
 
-export const getSyncBackendCursorInfo = (remoteHead: EventSequenceNumber.GlobalEventSequenceNumber) =>
+export const getSyncBackendCursorInfo = ({
+  remoteHead,
+}: {
+  remoteHead: EventSequenceNumber.GlobalEventSequenceNumber
+}) =>
   Effect.gen(function* () {
     const { dbEventlog } = yield* LeaderThreadCtx
 
@@ -195,7 +213,11 @@ export const getSyncBackendCursorInfo = (remoteHead: EventSequenceNumber.GlobalE
     ).pipe(Effect.andThen(Schema.decode(EventlogQuerySchema)), Effect.map(Option.flatten), Effect.orDie)
 
     return Option.some({
-      cursor: { global: remoteHead, client: EventSequenceNumber.clientDefault },
+      cursor: {
+        global: remoteHead,
+        client: EventSequenceNumber.clientDefault,
+        rebaseGeneration: EventSequenceNumber.rebaseGenerationDefault,
+      },
       metadata: syncMetadataOption,
     }) satisfies InitialSyncInfo
   }).pipe(Effect.withSpan('@livestore/common:eventlog:getSyncBackendCursorInfo', { attributes: { remoteHead } }))

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

@@ -48,9 +48,8 @@ export const bootDevtools = (options: DevtoolsOptions) =>
               )
 
           const syncState = yield* syncProcessor.syncState
-          const mergeCounter = syncProcessor.getMergeCounter()
 
-          yield* syncProcessor.pull({ cursor: { mergeCounter, eventNum: syncState.localHead } }).pipe(
+          yield* syncProcessor.pull({ cursor: syncState.localHead }).pipe(
             Stream.tap(({ payload }) => sendMessage(Devtools.Leader.SyncPull.make({ payload, liveStoreVersion }))),
             Stream.runDrain,
             Effect.forkScoped,

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

@@ -1,16 +1,18 @@
+import { shouldNeverHappen } from '@livestore/utils'
 import type { HttpClient, Schema, 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, SqliteDb, SqliteError } from '../adapter-types.js'
 import { UnexpectedError } from '../adapter-types.js'
 import type * as Devtools from '../devtools/mod.js'
 import type { LiveStoreSchema } from '../schema/mod.js'
-import { LiveStoreEvent } from '../schema/mod.js'
+import { EventSequenceNumber, LiveStoreEvent } from '../schema/mod.js'
 import type { InvalidPullError, IsOfflineError, SyncOptions } from '../sync/sync.js'
+import { SyncState } from '../sync/syncstate.js'
 import { sql } from '../util.js'
 import * as Eventlog from './eventlog.js'
-import { bootDevtools } from './leader-worker-devtools.js'
 import { makeLeaderSyncProcessor } from './LeaderSyncProcessor.js'
+import { bootDevtools } from './leader-worker-devtools.js'
 import { makeMaterializeEvent } from './materialize-event.js'
 import { recreateDb } from './recreate-db.js'
 import type { ShutdownChannel } from './shutdown-channel.js'
@@ -89,10 +91,8 @@ export const makeLeaderThreadLayer = ({
 
     const syncProcessor = yield* makeLeaderSyncProcessor({
       schema,
-      dbEventlogMissing,
-      dbEventlog,
       dbState,
-      dbStateMissing,
+      initialSyncState: getInitialSyncState({ dbEventlog, dbState, dbEventlogMissing }),
       initialBlockingSyncContext,
       onError: syncOptions?.onSyncError ?? 'ignore',
       params: {
@@ -158,6 +158,48 @@ export const makeLeaderThreadLayer = ({
     Layer.unwrapScoped,
   )
 
+const getInitialSyncState = ({
+  dbEventlog,
+  dbState,
+  dbEventlogMissing,
+}: {
+  dbEventlog: SqliteDb
+  dbState: SqliteDb
+  dbEventlogMissing: boolean
+}) => {
+  const initialBackendHead = dbEventlogMissing
+    ? EventSequenceNumber.ROOT.global
+    : Eventlog.getBackendHeadFromDb(dbEventlog)
+
+  const initialLocalHead = dbEventlogMissing ? EventSequenceNumber.ROOT : Eventlog.getClientHeadFromDb(dbEventlog)
+
+  if (initialBackendHead > initialLocalHead.global) {
+    return shouldNeverHappen(
+      `During boot the backend head (${initialBackendHead}) should never be greater than the local head (${initialLocalHead.global})`,
+    )
+  }
+
+  return SyncState.make({
+    localHead: initialLocalHead,
+    upstreamHead: {
+      global: initialBackendHead,
+      client: EventSequenceNumber.clientDefault,
+      rebaseGeneration: EventSequenceNumber.rebaseGenerationDefault,
+    },
+    pending: dbEventlogMissing
+      ? []
+      : Eventlog.getEventsSince({
+          dbEventlog,
+          dbState,
+          since: {
+            global: initialBackendHead,
+            client: EventSequenceNumber.clientDefault,
+            rebaseGeneration: initialLocalHead.rebaseGeneration,
+          },
+        }),
+  })
+}
+
 const makeInitialBlockingSyncContext = ({
   initialSyncOptions,
   bootStatusQueue,
@@ -223,11 +265,13 @@ const bootLeaderThread = ({
   LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient
 > =>
   Effect.gen(function* () {
-    const { dbEventlog, bootStatusQueue, syncProcessor } = yield* LeaderThreadCtx
+    const { dbEventlog, bootStatusQueue, syncProcessor, schema, materializeEvent, dbState } = yield* LeaderThreadCtx
 
     yield* Eventlog.initEventlogDb(dbEventlog)
 
-    const { migrationsReport } = dbStateMissing ? yield* recreateDb : { migrationsReport: { migrations: [] } }
+    const { migrationsReport } = dbStateMissing
+      ? yield* recreateDb({ dbState, dbEventlog, schema, bootStatusQueue, materializeEvent })
+      : { migrationsReport: { migrations: [] } }
 
     // NOTE the sync processor depends on the dbs being initialized properly
     const { initialLeaderHead } = yield* syncProcessor.boot

package/src/leader-thread/materialize-event.ts

@@ -74,6 +74,8 @@ export const makeMaterializeEvent = ({
           yield* execSqlPrepared(dbState, statementSql, bindValues)
         }
 
+        dbState.debug.head = eventEncoded.seqNum
+
         const changeset = session.changeset()
         session.finish()
 
@@ -86,6 +88,7 @@ export const makeMaterializeEvent = ({
             values: {
               seqNumGlobal: eventEncoded.seqNum.global,
               seqNumClient: eventEncoded.seqNum.client,
+              seqNumRebaseGeneration: eventEncoded.seqNum.rebaseGeneration,
               // NOTE the changeset will be empty (i.e. null) for no-op events
               changeset: changeset ?? null,
               debug: LS_DEV ? execArgsArr : null,
@@ -149,7 +152,11 @@ export const rollback = ({
         sql`SELECT * FROM ${SystemTables.SESSION_CHANGESET_META_TABLE} WHERE (seqNumGlobal, seqNumClient) IN (${eventNumsToRollback.map((id) => `(${id.global}, ${id.client})`).join(', ')})`,
       )
       .map((_) => ({
-        seqNum: { global: _.seqNumGlobal, client: _.seqNumClient },
+        seqNum: {
+          global: _.seqNumGlobal,
+          client: _.seqNumClient,
+          rebaseGeneration: -1, // unused in this code path
+        },
         changeset: _.changeset,
         debug: _.debug,
       }))

package/src/leader-thread/mod.ts

@@ -5,3 +5,4 @@ export * from './leader-worker-devtools.js'
 export * from './make-leader-thread-layer.js'
 export * as Eventlog from './eventlog.js'
 export * from './materialize-event.js'
+export * from './recreate-db.js'

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

@@ -1,108 +1,116 @@
 import { casesHandled } from '@livestore/utils'
-import type { HttpClient } from '@livestore/utils/effect'
 import { Effect, Queue } from '@livestore/utils/effect'
 
-import type { InvalidPullError, IsOfflineError, MigrationHooks, MigrationsReport, SqliteError } from '../index.js'
+import type { MigrationsReport } from '../defs.js'
+import type { BootStatus, MigrationHooks, SqliteDb, SqliteError } from '../index.js'
 import { migrateDb, rematerializeFromEventlog, UnexpectedError } from '../index.js'
+import type { LiveStoreSchema } from '../schema/mod.js'
 import { configureConnection } from './connection.js'
-import { LeaderThreadCtx } from './types.js'
-
-export const recreateDb: Effect.Effect<
-  { migrationsReport: MigrationsReport },
-  UnexpectedError | SqliteError | IsOfflineError | InvalidPullError,
-  LeaderThreadCtx | HttpClient.HttpClient
-> = Effect.gen(function* () {
-  const { dbState, dbEventlog, schema, bootStatusQueue, materializeEvent } = yield* LeaderThreadCtx
-
-  const migrationOptions = schema.state.sqlite.migrations
-  let migrationsReport: MigrationsReport
-
-  yield* Effect.addFinalizer(
-    Effect.fn('recreateDb:finalizer')(function* (ex) {
-      if (ex._tag === 'Failure') dbState.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 tmpDb = yield* makeSqliteDb({ _tag: 'in-memory' })
-  const tmpDb = dbState
-  yield* configureConnection(tmpDb, { foreignKeys: true })
-
-  const initDb = (hooks: Partial<MigrationHooks> | undefined) =>
-    Effect.gen(function* () {
-      yield* Effect.tryAll(() => hooks?.init?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
-
-      const migrationsReport = yield* migrateDb({
-        db: tmpDb,
-        schema,
-        onProgress: ({ done, total }) =>
-          Queue.offer(bootStatusQueue, { stage: 'migrating', progress: { done, total } }),
+import type { MaterializeEvent } from './types.js'
+
+export const recreateDb = ({
+  dbState,
+  dbEventlog,
+  schema,
+  bootStatusQueue,
+  materializeEvent,
+}: {
+  dbState: SqliteDb
+  dbEventlog: SqliteDb
+  schema: LiveStoreSchema
+  bootStatusQueue: Queue.Queue<BootStatus>
+  materializeEvent: MaterializeEvent
+}): Effect.Effect<{ migrationsReport: MigrationsReport }, UnexpectedError | SqliteError> =>
+  Effect.gen(function* () {
+    const migrationOptions = schema.state.sqlite.migrations
+    let migrationsReport: MigrationsReport
+
+    yield* Effect.addFinalizer(
+      Effect.fn('recreateDb:finalizer')(function* (ex) {
+        if (ex._tag === 'Failure') dbState.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 tmpDb = yield* makeSqliteDb({ _tag: 'in-memory' })
+    const tmpDb = dbState
+    yield* configureConnection(tmpDb, { foreignKeys: true })
+
+    const initDb = (hooks: Partial<MigrationHooks> | undefined) =>
+      Effect.gen(function* () {
+        yield* Effect.tryAll(() => hooks?.init?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
+
+        const migrationsReport = yield* migrateDb({
+          db: tmpDb,
+          schema,
+          onProgress: ({ done, total }) =>
+            Queue.offer(bootStatusQueue, { stage: 'migrating', progress: { done, total } }),
+        })
+
+        yield* Effect.tryAll(() => hooks?.pre?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
+
+        return { migrationsReport, tmpDb }
       })
 
-      yield* Effect.tryAll(() => hooks?.pre?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
+    switch (migrationOptions.strategy) {
+      case 'auto': {
+        const hooks = migrationOptions.hooks
+        const initResult = yield* initDb(hooks)
 
-      return { migrationsReport, tmpDb }
-    })
+        migrationsReport = initResult.migrationsReport
 
-  switch (migrationOptions.strategy) {
-    case 'auto': {
-      const hooks = migrationOptions.hooks
-      const initResult = yield* initDb(hooks)
+        yield* rematerializeFromEventlog({
+          // db: initResult.tmpDb,
+          dbEventlog,
+          schema,
+          materializeEvent,
+          onProgress: ({ done, total }) =>
+            Queue.offer(bootStatusQueue, { stage: 'rehydrating', progress: { done, total } }),
+        })
 
-      migrationsReport = initResult.migrationsReport
+        yield* Effect.tryAll(() => hooks?.post?.(initResult.tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
-      yield* rematerializeFromEventlog({
-        // db: initResult.tmpDb,
-        dbEventlog,
-        schema,
-        materializeEvent,
-        onProgress: ({ done, total }) =>
-          Queue.offer(bootStatusQueue, { stage: 'rehydrating', progress: { done, total } }),
-      })
+        break
+      }
+      case 'manual': {
+        const oldDbData = dbState.export()
 
-      yield* Effect.tryAll(() => hooks?.post?.(initResult.tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
-
-      break
-    }
-    case 'manual': {
-      const oldDbData = dbState.export()
+        migrationsReport = { migrations: [] }
 
-      migrationsReport = { migrations: [] }
+        const newDbData = yield* Effect.tryAll(() => migrationOptions.migrate(oldDbData)).pipe(
+          UnexpectedError.mapToUnexpectedError,
+        )
 
-      const newDbData = yield* Effect.tryAll(() => migrationOptions.migrate(oldDbData)).pipe(
-        UnexpectedError.mapToUnexpectedError,
-      )
+        tmpDb.import(newDbData)
 
-      tmpDb.import(newDbData)
+        // TODO validate schema
 
-      // TODO validate schema
-
-      break
-    }
-    default: {
-      casesHandled(migrationOptions)
+        break
+      }
+      default: {
+        casesHandled(migrationOptions)
+      }
     }
-  }
-
-  // TODO bring back
-  // Import the temporary in-memory database into the persistent database
-  // 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 = tmpDb.export()
-
-  // 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'),
-  Effect.withPerformanceMeasure('@livestore/common:leader-thread:recreateDb'),
-)
+
+    // TODO bring back
+    // Import the temporary in-memory database into the persistent database
+    // 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 = tmpDb.export()
+
+    // 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'),
+    Effect.withPerformanceMeasure('@livestore/common:leader-thread:recreateDb'),
+  )

package/src/leader-thread/types.ts

@@ -12,13 +12,13 @@ import type {
 import { Context, Schema } from '@livestore/utils/effect'
 import type { MeshNode } from '@livestore/webmesh'
 
-import type { LeaderPullCursor, SqliteError } from '../adapter-types.js'
+import type { MigrationsReport } from '../defs.js'
+import type { SqliteError } from '../errors.js'
 import type {
   BootStatus,
   Devtools,
   LeaderAheadError,
   MakeSqliteDb,
-  MigrationsReport,
   PersistenceInfo,
   SqliteDb,
   SyncBackend,
@@ -136,16 +136,12 @@ export type InitialBlockingSyncContext = {
 export interface LeaderSyncProcessor {
   /** Used by client sessions to subscribe to upstream sync state changes */
   pull: (args: {
-    cursor: LeaderPullCursor
-  }) => Stream.Stream<{ payload: typeof SyncState.PayloadUpstream.Type; mergeCounter: number }, UnexpectedError>
+    cursor: EventSequenceNumber.EventSequenceNumber
+  }) => Stream.Stream<{ payload: typeof SyncState.PayloadUpstream.Type }, UnexpectedError>
   /** The `pullQueue` API can be used instead of `pull` when more convenient */
   pullQueue: (args: {
-    cursor: LeaderPullCursor
-  }) => Effect.Effect<
-    Queue.Queue<{ payload: typeof SyncState.PayloadUpstream.Type; mergeCounter: number }>,
-    UnexpectedError,
-    Scope.Scope
-  >
+    cursor: EventSequenceNumber.EventSequenceNumber
+  }) => Effect.Effect<Queue.Queue<{ payload: typeof SyncState.PayloadUpstream.Type }>, UnexpectedError, Scope.Scope>
 
   /** Used by client sessions to push events to the leader thread */
   push: (
@@ -173,5 +169,4 @@ export interface LeaderSyncProcessor {
     LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient
   >
   syncState: Subscribable.Subscribable<SyncState.SyncState>
-  getMergeCounter: () => number
 }

package/src/make-client-session.ts

@@ -39,7 +39,7 @@ export const makeClientSession = <R>({
   sessionId: string
   isLeader: boolean
   lockStatus: SubscriptionRef.SubscriptionRef<LockStatus>
-  leaderThread: ClientSessionLeaderThreadProxy
+  leaderThread: ClientSessionLeaderThreadProxy.ClientSessionLeaderThreadProxy
   sqliteDb: SqliteDb
   connectWebmeshNode: (args: {
     webmeshNode: Webmesh.MeshNode
@@ -133,4 +133,4 @@ export const makeClientSession = <R>({
       shutdown,
       debugInstanceId,
     } satisfies ClientSession
-  })
+  }).pipe(Effect.withSpan('@livestore/common:make-client-session'))

package/src/rematerialize-from-eventlog.ts

@@ -56,8 +56,16 @@ This likely means the schema has changed in an incompatible way.
         )
 
         const eventEncoded = LiveStoreEvent.EncodedWithMeta.make({
-          seqNum: { global: row.seqNumGlobal, client: row.seqNumClient },
-          parentSeqNum: { global: row.parentSeqNumGlobal, client: row.parentSeqNumClient },
+          seqNum: {
+            global: row.seqNumGlobal,
+            client: row.seqNumClient,
+            rebaseGeneration: row.seqNumRebaseGeneration,
+          },
+          parentSeqNum: {
+            global: row.parentSeqNumGlobal,
+            client: row.parentSeqNumClient,
+            rebaseGeneration: row.parentSeqNumRebaseGeneration,
+          },
           name: row.name,
           args,
           clientId: row.clientId,

package/src/schema/EventDef.ts

@@ -28,7 +28,9 @@ export type EventDef<TName extends string, TType, TEncoded = TType, TDerived ext
   }
 
   /** Helper function to construct a partial event */
-  (args: TType): {
+  (
+    args: TType,
+  ): {
     name: TName
     args: TType
   }
@@ -194,14 +196,14 @@ export type Materializer<TEventDef extends EventDef.AnyWithoutFn = EventDef.AnyW
 ) => SingleOrReadonlyArray<MaterializerResult>
 
 export const defineMaterializer = <TEventDef extends EventDef.AnyWithoutFn>(
-  eventDef: TEventDef,
+  _eventDef: TEventDef,
   materializer: Materializer<TEventDef>,
 ): Materializer<TEventDef> => {
   return materializer
 }
 
 export const materializers = <TInputRecord extends Record<string, EventDef.AnyWithoutFn>>(
-  eventDefRecord: TInputRecord,
+  _eventDefRecord: TInputRecord,
   handlers: {
     [TEventName in TInputRecord[keyof TInputRecord]['name'] as Extract<
       TInputRecord[keyof TInputRecord],