@livestore/common 0.3.1-dev.0 → 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,66 +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,
-          },
-        })
+/**
+ * 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 =>
@@ -143,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,
@@ -154,6 +168,8 @@ export const insertIntoEventlog = (
         },
       }),
     )
+
+    dbEventlog.debug.head = eventEncoded.seqNum
   })
 
 export const updateSyncMetadata = (items: ReadonlyArray<LiveStoreEvent.EncodedWithMeta>) =>
@@ -176,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
 
@@ -193,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

@@ -1,8 +1,8 @@
-import { LS_DEV, shouldNeverHappen } from '@livestore/utils'
-import { Effect, ReadonlyArray, Schema } from '@livestore/utils/effect'
+import { isDevEnv, LS_DEV, shouldNeverHappen } from '@livestore/utils'
+import { Effect, Option, ReadonlyArray, Schema } from '@livestore/utils/effect'
 
-import type { SqliteDb } from '../adapter-types.js'
-import { getExecArgsFromEvent } from '../materializer-helper.js'
+import { type SqliteDb, UnexpectedError } from '../adapter-types.js'
+import { getExecStatementsFromMaterializer, hashMaterializerResults } from '../materializer-helper.js'
 import type { LiveStoreSchema } from '../schema/mod.js'
 import { EventSequenceNumber, getEventDef, SystemTables } from '../schema/mod.js'
 import { insertRow } from '../sql-queries/index.js'
@@ -13,13 +13,13 @@ import type { MaterializeEvent } from './types.js'
 
 export const makeMaterializeEvent = ({
   schema,
-  dbState: db,
+  dbState,
   dbEventlog,
 }: {
   schema: LiveStoreSchema
   dbState: SqliteDb
   dbEventlog: SqliteDb
-}): Effect.Effect<MaterializeEvent, never> =>
+}): Effect.Effect<MaterializeEvent, UnexpectedError> =>
   Effect.gen(function* () {
     const eventDefSchemaHashMap = new Map(
       // TODO Running `Schema.hash` can be a bottleneck for larger schemas. There is an opportunity to run this
@@ -35,13 +35,26 @@ export const makeMaterializeEvent = ({
         const eventName = eventEncoded.name
         const { eventDef, materializer } = getEventDef(schema, eventName)
 
-        const execArgsArr = getExecArgsFromEvent({
+        const execArgsArr = getExecStatementsFromMaterializer({
           eventDef,
           materializer,
-          db,
+          dbState,
           event: { decoded: undefined, encoded: eventEncoded },
         })
 
+        const materializerHash = isDevEnv() ? Option.some(hashMaterializerResults(execArgsArr)) : Option.none()
+
+        if (
+          materializerHash._tag === 'Some' &&
+          eventEncoded.meta.materializerHashSession._tag === 'Some' &&
+          eventEncoded.meta.materializerHashSession.value !== materializerHash.value
+        ) {
+          yield* UnexpectedError.make({
+            cause: `Materializer hash mismatch detected for event "${eventEncoded.name}".`,
+            note: `Please make sure your event materializer is a pure function without side effects.`,
+          })
+        }
+
         // NOTE we might want to bring this back if we want to debug no-op events
         // const makeExecuteOptions = (statementSql: string, bindValues: any) => ({
         //   onRowsChanged: (rowsChanged: number) => {
@@ -53,26 +66,29 @@ export const makeMaterializeEvent = ({
 
         // console.group('[@livestore/common:leader-thread:materializeEvent]', { eventName })
 
-        const session = db.session()
+        const session = dbState.session()
 
         for (const { statementSql, bindValues } of execArgsArr) {
           // console.debug(eventName, statementSql, bindValues)
           // TODO use cached prepared statements instead of exec
-          yield* execSqlPrepared(db, statementSql, bindValues)
+          yield* execSqlPrepared(dbState, statementSql, bindValues)
         }
 
+        dbState.debug.head = eventEncoded.seqNum
+
         const changeset = session.changeset()
         session.finish()
 
         // TODO use prepared statements
         yield* execSql(
-          db,
+          dbState,
           ...insertRow({
             tableName: SystemTables.SESSION_CHANGESET_META_TABLE,
             columns: SystemTables.sessionChangesetMetaTable.sqliteDef.columns,
             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,
@@ -107,6 +123,7 @@ export const makeMaterializeEvent = ({
                 debug: LS_DEV ? execArgsArr : null,
               }
             : { _tag: 'no-op' as const },
+          hash: materializerHash,
         }
       }).pipe(
         Effect.withSpan(`@livestore/common:leader-thread:materializeEvent`, {
@@ -135,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

@@ -4,3 +4,5 @@ export * as ShutdownChannel from './shutdown-channel.js'
 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'),
+  )