@livestore/common 0.3.0-dev.9 → 0.3.1-dev.0

package/src/leader-thread/types.ts

@@ -1,45 +1,40 @@
 import type {
   Deferred,
   Effect,
-  Fiber,
   HttpClient,
   Option,
   Queue,
   Scope,
+  Stream,
   Subscribable,
   SubscriptionRef,
-  WebChannel,
 } from '@livestore/utils/effect'
 import { Context, Schema } from '@livestore/utils/effect'
+import type { MeshNode } from '@livestore/webmesh'
 
+import type { LeaderPullCursor, SqliteError } from '../adapter-types.js'
 import type {
   BootStatus,
   Devtools,
-  InvalidPushError,
-  MakeSynchronousDatabase,
+  LeaderAheadError,
+  MakeSqliteDb,
+  MigrationsReport,
   PersistenceInfo,
+  SqliteDb,
   SyncBackend,
-  SynchronousDatabase,
   UnexpectedError,
 } from '../index.js'
-import type { EventId, LiveStoreSchema, MutationEvent } from '../schema/mod.js'
+import type { EventSequenceNumber, LiveStoreEvent, LiveStoreSchema } from '../schema/mod.js'
 import type * as SyncState from '../sync/syncstate.js'
 import type { ShutdownChannel } from './shutdown-channel.js'
 
 export type ShutdownState = 'running' | 'shutting-down'
 
-export class OuterWorkerCtx extends Context.Tag('OuterWorkerCtx')<
-  OuterWorkerCtx,
-  {
-    innerFiber: Fiber.RuntimeFiber<any, any>
-  }
->() {}
-
 export const InitialSyncOptionsSkip = Schema.TaggedStruct('Skip', {})
 export type InitialSyncOptionsSkip = typeof InitialSyncOptionsSkip.Type
 
 export const InitialSyncOptionsBlocking = Schema.TaggedStruct('Blocking', {
-  timeout: Schema.DurationFromMillis,
+  timeout: Schema.Union(Schema.DurationFromMillis, Schema.Number),
 })
 
 export type InitialSyncOptionsBlocking = typeof InitialSyncOptionsBlocking.Type
@@ -48,7 +43,7 @@ export const InitialSyncOptions = Schema.Union(InitialSyncOptionsSkip, InitialSy
 export type InitialSyncOptions = typeof InitialSyncOptions.Type
 
 export type InitialSyncInfo = Option.Option<{
-  cursor: EventId.EventId
+  cursor: EventSequenceNumber.EventSequenceNumber
   metadata: Option.Option<Schema.JsonValue>
 }>
 
@@ -56,8 +51,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 = { state: PersistenceInfo; eventlog: PersistenceInfo }
 
 export type DevtoolsOptions =
   | {
@@ -65,53 +60,94 @@ export type DevtoolsOptions =
     }
   | {
       enabled: true
-      makeContext: Effect.Effect<
+      boot: Effect.Effect<
         {
-          devtoolsWebChannel: WebChannel.WebChannel<Devtools.MessageToAppLeader, Devtools.MessageFromAppLeader>
+          node: MeshNode
           persistenceInfo: PersistenceInfoPair
+          mode: 'proxy' | 'direct'
         },
         UnexpectedError,
-        Scope.Scope
+        Scope.Scope | HttpClient.HttpClient | LeaderThreadCtx
       >
     }
 
+export type DevtoolsContext =
+  | {
+      enabled: true
+      // syncBackendPullLatch: Effect.Latch
+      // syncBackendPushLatch: Effect.Latch
+      syncBackendLatch: Effect.Latch
+      syncBackendLatchState: SubscriptionRef.SubscriptionRef<{ latchClosed: boolean }>
+    }
+  | {
+      enabled: false
+    }
+
 export class LeaderThreadCtx extends Context.Tag('LeaderThreadCtx')<
   LeaderThreadCtx,
   {
     schema: LiveStoreSchema
     storeId: string
     clientId: string
-    makeSyncDb: MakeSynchronousDatabase
-    db: LeaderDatabase
-    dbLog: LeaderDatabase
+    makeSqliteDb: MakeSqliteDb
+    dbState: LeaderSqliteDb
+    dbEventlog: 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
+    eventSchema: LiveStoreEvent.ForEventDefRecord<any>
+    devtools: DevtoolsContext
     syncBackend: SyncBackend | undefined
     syncProcessor: LeaderSyncProcessor
-    connectedClientSessionPullQueues: PullQueueSet
-    /** e.g. used for `store.__dev` APIs */
-    extraIncomingMessagesQueue: Queue.Queue<Devtools.MessageToAppLeader>
+    materializeEvent: MaterializeEvent
+    initialState: {
+      leaderHead: EventSequenceNumber.EventSequenceNumber
+      migrationsReport: MigrationsReport
+    }
+    /**
+     * 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.Leader.MessageToApp>
   }
 >() {}
 
+export type MaterializeEvent = (
+  eventEncoded: LiveStoreEvent.EncodedWithMeta,
+  options?: {
+    /** Needed for rematerializeFromEventlog */
+    skipEventlog?: boolean
+  },
+) => Effect.Effect<
+  { sessionChangeset: { _tag: 'sessionChangeset'; data: Uint8Array; debug: any } | { _tag: 'no-op' } },
+  SqliteError | UnexpectedError
+>
+
 export type InitialBlockingSyncContext = {
   blockingDeferred: Deferred.Deferred<void> | undefined
   update: (_: { remaining: number; processed: number }) => Effect.Effect<void>
 }
 
-export type PullQueueItem = {
-  payload: SyncState.PayloadUpstream
-  remaining: number
-}
-
 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>
+  /** 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
+  >
+
+  /** Used by client sessions to push events to the leader thread */
   push: (
     /** `batch` needs to follow the same rules as `batch` in `SyncBackend.push` */
-    batch: ReadonlyArray<MutationEvent.EncodedWithMeta>,
+    batch: ReadonlyArray<LiveStoreEvent.EncodedWithMeta>,
     options?: {
       /**
        * If true, the effect will only finish when the local push has been processed (i.e. succeeded or was rejected).
@@ -119,18 +155,20 @@ export interface LeaderSyncProcessor {
        */
       waitForProcessing?: boolean
     },
-  ) => Effect.Effect<void, InvalidPushError>
+  ) => Effect.Effect<void, LeaderAheadError>
 
-  pushPartial: (mutationEvent: MutationEvent.PartialAnyEncoded) => Effect.Effect<void, UnexpectedError, LeaderThreadCtx>
-  boot: (args: {
-    dbReady: Deferred.Deferred<void>
-  }) => Effect.Effect<void, UnexpectedError, LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient>
+  /** Currently only used by devtools which don't provide their own event numbers */
+  pushPartial: (args: {
+    event: LiveStoreEvent.PartialAnyEncoded
+    clientId: string
+    sessionId: string
+  }) => Effect.Effect<void, UnexpectedError>
+
+  boot: Effect.Effect<
+    { initialLeaderHead: EventSequenceNumber.EventSequenceNumber },
+    UnexpectedError,
+    LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient
+  >
   syncState: Subscribable.Subscribable<SyncState.SyncState>
-}
-
-export interface PullQueueSet {
-  makeQueue: (
-    since: EventId.EventId,
-  ) => Effect.Effect<Queue.Queue<PullQueueItem>, UnexpectedError, Scope.Scope | LeaderThreadCtx>
-  offer: (item: PullQueueItem) => Effect.Effect<void, UnexpectedError, LeaderThreadCtx>
+  getMergeCounter: () => number
 }

package/src/make-client-session.ts

@@ -0,0 +1,136 @@
+import type { Scope, SubscriptionRef } from '@livestore/utils/effect'
+import { Effect, Stream } from '@livestore/utils/effect'
+import * as Webmesh from '@livestore/webmesh'
+
+import type {
+  AdapterArgs,
+  ClientSession,
+  ClientSessionLeaderThreadProxy,
+  LockStatus,
+  SqliteDb,
+  UnexpectedError,
+} from './adapter-types.js'
+import * as Devtools from './devtools/mod.js'
+import { liveStoreVersion } from './version.js'
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __debugWebmeshNode: any
+}
+
+export const makeClientSession = <R>({
+  storeId,
+  clientId,
+  sessionId,
+  isLeader,
+  devtoolsEnabled,
+  connectDevtoolsToStore,
+  lockStatus,
+  leaderThread,
+  schema,
+  sqliteDb,
+  shutdown,
+  connectWebmeshNode,
+  webmeshMode,
+  registerBeforeUnload,
+  debugInstanceId,
+}: AdapterArgs & {
+  clientId: string
+  sessionId: string
+  isLeader: boolean
+  lockStatus: SubscriptionRef.SubscriptionRef<LockStatus>
+  leaderThread: ClientSessionLeaderThreadProxy
+  sqliteDb: SqliteDb
+  connectWebmeshNode: (args: {
+    webmeshNode: Webmesh.MeshNode
+    sessionInfo: Devtools.SessionInfo.SessionInfo
+  }) => Effect.Effect<void, UnexpectedError, Scope.Scope | R>
+  webmeshMode: 'direct' | 'proxy'
+  registerBeforeUnload: (onBeforeUnload: () => void) => () => void
+}): Effect.Effect<ClientSession, never, Scope.Scope | R> =>
+  Effect.gen(function* () {
+    const devtools: ClientSession['devtools'] = devtoolsEnabled
+      ? { enabled: true, pullLatch: yield* Effect.makeLatch(true), pushLatch: yield* Effect.makeLatch(true) }
+      : { enabled: false }
+
+    if (devtoolsEnabled) {
+      yield* Effect.gen(function* () {
+        const webmeshNode = yield* Webmesh.makeMeshNode(
+          Devtools.makeNodeName.client.session({ storeId, clientId, sessionId }),
+        )
+
+        globalThis.__debugWebmeshNode = webmeshNode
+
+        const schemaAlias = schema.devtools.alias
+        const sessionInfo = Devtools.SessionInfo.SessionInfo.make({
+          storeId,
+          clientId,
+          sessionId,
+          schemaAlias,
+          isLeader,
+        })
+
+        yield* connectWebmeshNode({ webmeshNode, sessionInfo })
+
+        const sessionInfoBroadcastChannel = yield* Devtools.makeSessionInfoBroadcastChannel(webmeshNode)
+
+        yield* Devtools.SessionInfo.provideSessionInfo({
+          webChannel: sessionInfoBroadcastChannel,
+          sessionInfo,
+        }).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
+
+        yield* webmeshNode.listenForChannel.pipe(
+          Stream.filter(
+            (res) =>
+              Devtools.isChannelName.devtoolsClientSession(res.channelName, { storeId, clientId, sessionId }) &&
+              res.mode === webmeshMode,
+          ),
+          Stream.tap(
+            Effect.fnUntraced(
+              function* ({ channelName, source }) {
+                const clientSessionDevtoolsChannel = yield* webmeshNode.makeChannel({
+                  target: source,
+                  channelName,
+                  schema: { listen: Devtools.ClientSession.MessageToApp, send: Devtools.ClientSession.MessageFromApp },
+                  mode: webmeshMode,
+                })
+
+                const sendDisconnect = clientSessionDevtoolsChannel
+                  .send(Devtools.ClientSession.Disconnect.make({ clientId, liveStoreVersion, sessionId }))
+                  .pipe(Effect.orDie)
+
+                // Disconnect on shutdown (e.g. when switching stores)
+                yield* Effect.addFinalizer(() => sendDisconnect)
+
+                // Disconnect on before unload
+                yield* Effect.acquireRelease(
+                  Effect.sync(() => registerBeforeUnload(() => sendDisconnect.pipe(Effect.runFork))),
+                  (unsub) => Effect.sync(() => unsub()),
+                )
+
+                yield* connectDevtoolsToStore(clientSessionDevtoolsChannel)
+              },
+              Effect.tapCauseLogPretty,
+              Effect.forkScoped,
+            ),
+          ),
+          Stream.runDrain,
+        )
+      }).pipe(
+        Effect.withSpan('@livestore/common:make-client-session:devtools'),
+        Effect.tapCauseLogPretty,
+        Effect.forkScoped,
+      )
+    }
+
+    return {
+      sqliteDb,
+      leaderThread,
+      devtools,
+      lockStatus,
+      clientId,
+      sessionId,
+      shutdown,
+      debugInstanceId,
+    } satisfies ClientSession
+  })

package/src/materializer-helper.ts

@@ -0,0 +1,138 @@
+import { isNil, isReadonlyArray } from '@livestore/utils'
+import { Schema } from '@livestore/utils/effect'
+
+import type { SqliteDb } from './adapter-types.js'
+import { SessionIdSymbol } from './adapter-types.js'
+import type { EventDef, Materializer, MaterializerContextQuery, MaterializerResult } from './schema/EventDef.js'
+import type * as LiveStoreEvent from './schema/LiveStoreEvent.js'
+import type { QueryBuilder } from './schema/state/sqlite/query-builder/api.js'
+import { isQueryBuilder } from './schema/state/sqlite/query-builder/api.js'
+import { getResultSchema } from './schema/state/sqlite/query-builder/impl.js'
+import { type BindValues } from './sql-queries/sql-queries.js'
+import type { ParamsObject, PreparedBindValues } from './util.js'
+import { prepareBindValues } from './util.js'
+
+export const getExecArgsFromEvent = ({
+  eventDef,
+  materializer,
+  db,
+  event,
+}: {
+  eventDef: EventDef.AnyWithoutFn
+  materializer: Materializer
+  db: SqliteDb
+  /** Both encoded and decoded events are supported to reduce the number of times we need to decode/encode */
+  event:
+    | {
+        decoded: LiveStoreEvent.AnyDecoded | LiveStoreEvent.PartialAnyDecoded
+        encoded: undefined
+      }
+    | {
+        decoded: undefined
+        encoded: LiveStoreEvent.AnyEncoded | LiveStoreEvent.PartialAnyEncoded
+      }
+}): ReadonlyArray<{
+  statementSql: string
+  bindValues: PreparedBindValues
+  writeTables: ReadonlySet<string> | undefined
+}> => {
+  const eventArgsDecoded =
+    event.decoded === undefined ? Schema.decodeUnknownSync(eventDef.schema)(event.encoded!.args) : event.decoded.args
+
+  const eventArgsEncoded = isNil(event.decoded?.args)
+    ? undefined
+    : Schema.encodeUnknownSync(eventDef.schema)(event.decoded!.args)
+
+  const query: MaterializerContextQuery = (
+    rawQueryOrQueryBuilder:
+      | {
+          query: string
+          bindValues: ParamsObject
+        }
+      | QueryBuilder.Any,
+  ) => {
+    if (isQueryBuilder(rawQueryOrQueryBuilder)) {
+      const { query, bindValues } = rawQueryOrQueryBuilder.asSql()
+      const rawResults = db.select(query, prepareBindValues(bindValues, query))
+      const resultSchema = getResultSchema(rawQueryOrQueryBuilder)
+      return Schema.decodeSync(resultSchema)(rawResults)
+    } else {
+      const { query, bindValues } = rawQueryOrQueryBuilder
+      return db.select(query, prepareBindValues(bindValues, query))
+    }
+  }
+
+  const res = materializer(eventArgsDecoded, {
+    eventDef,
+    query,
+    // TODO properly implement this
+    currentFacts: new Map(),
+  })
+
+  const statementRes = mapMaterializerResult(res)
+
+  return statementRes.map((statementRes) => {
+    const statementSql = statementRes.sql
+
+    const bindValues = typeof statementRes === 'string' ? eventArgsEncoded : statementRes.bindValues
+
+    const writeTables = typeof statementRes === 'string' ? undefined : statementRes.writeTables
+
+    return { statementSql, bindValues: prepareBindValues(bindValues ?? {}, statementSql), writeTables }
+  })
+}
+
+const mapMaterializerResult = (
+  materializerResult: MaterializerResult | ReadonlyArray<MaterializerResult>,
+): ReadonlyArray<{
+  sql: string
+  bindValues: BindValues
+  writeTables: ReadonlySet<string> | undefined
+}> => {
+  if (isReadonlyArray(materializerResult)) {
+    return materializerResult.flatMap(mapMaterializerResult)
+  }
+  if (isQueryBuilder(materializerResult)) {
+    const { query, bindValues } = materializerResult.asSql()
+    return [{ sql: query, bindValues: bindValues as BindValues, writeTables: undefined }]
+  } else if (typeof materializerResult === 'string') {
+    return [{ sql: materializerResult, bindValues: {} as BindValues, writeTables: undefined }]
+  } else {
+    return [
+      {
+        sql: materializerResult.sql,
+        bindValues: materializerResult.bindValues,
+        writeTables: materializerResult.writeTables,
+      },
+    ]
+  }
+}
+
+// NOTE we should explore whether there is a more elegant solution
+// e.g. by leveraging the schema to replace the sessionIdSymbol
+export const replaceSessionIdSymbol = (
+  bindValues: Record<string, unknown> | ReadonlyArray<unknown>,
+  sessionId: string,
+) => {
+  deepReplaceValue(bindValues, SessionIdSymbol, sessionId)
+}
+
+const deepReplaceValue = <S, R>(input: any, searchValue: S, replaceValue: R): void => {
+  if (Array.isArray(input)) {
+    for (const i in input) {
+      if (input[i] === searchValue) {
+        input[i] = replaceValue
+      } else {
+        deepReplaceValue(input[i], searchValue, replaceValue)
+      }
+    }
+  } else if (typeof input === 'object' && input !== null) {
+    for (const key in input) {
+      if (input[key] === searchValue) {
+        input[key] = replaceValue
+      } else {
+        deepReplaceValue(input[key], searchValue, replaceValue)
+      }
+    }
+  }
+}

package/src/otel.ts

@@ -18,3 +18,11 @@ export const provideOtel =
       Effect.provide(TracingLive),
     )
   }
+
+export const getDurationMsFromSpan = (span: otel.Span): number => {
+  const durationHr: [seconds: number, nanos: number] = (span as any)._duration
+  return durationHr[0] * 1000 + durationHr[1] / 1_000_000
+}
+
+export const getStartTimeHighResFromSpan = (span: otel.Span): DOMHighResTimeStamp =>
+  (span as any)._performanceStartTime as DOMHighResTimeStamp

package/src/rematerialize-from-eventlog.ts

@@ -0,0 +1,117 @@
+import { memoizeByRef } from '@livestore/utils'
+import { Chunk, Effect, Option, Schema, Stream } from '@livestore/utils/effect'
+
+import { type SqliteDb, UnexpectedError } from './adapter-types.js'
+import type { MaterializeEvent } from './leader-thread/mod.js'
+import type { EventDef, LiveStoreSchema } from './schema/mod.js'
+import { EventSequenceNumber, getEventDef, LiveStoreEvent, SystemTables } from './schema/mod.js'
+import type { PreparedBindValues } from './util.js'
+import { sql } from './util.js'
+
+export const rematerializeFromEventlog = ({
+  dbEventlog,
+  // TODO re-use this db when bringing back the boot in-memory db implementation
+  // db,
+  schema,
+  onProgress,
+  materializeEvent,
+}: {
+  dbEventlog: SqliteDb
+  // db: SqliteDb
+  schema: LiveStoreSchema
+  onProgress: (_: { done: number; total: number }) => Effect.Effect<void>
+  materializeEvent: MaterializeEvent
+}) =>
+  Effect.gen(function* () {
+    const eventsCount = dbEventlog.select<{ count: number }>(
+      `SELECT COUNT(*) AS count FROM ${SystemTables.EVENTLOG_META_TABLE}`,
+    )[0]!.count
+
+    const hashEvent = memoizeByRef((event: EventDef.AnyWithoutFn) => Schema.hash(event.schema))
+
+    const processEvent = (row: SystemTables.EventlogMetaRow) =>
+      Effect.gen(function* () {
+        const eventDef = getEventDef(schema, row.name)
+
+        if (hashEvent(eventDef.eventDef) !== row.schemaHash) {
+          yield* Effect.logWarning(
+            `Schema hash mismatch for event definition ${row.name}. Trying to materialize event anyway.`,
+          )
+        }
+
+        const args = JSON.parse(row.argsJson)
+
+        // Checking whether the schema has changed in an incompatible way
+        yield* Schema.decodeUnknown(eventDef.eventDef.schema)(args).pipe(
+          Effect.mapError((cause) =>
+            UnexpectedError.make({
+              cause,
+              note: `\
+There was an error during rematerializing from the eventlog while decoding
+the persisted event args for event definition "${row.name}".
+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 },
+          name: row.name,
+          args,
+          clientId: row.clientId,
+          sessionId: row.sessionId,
+        })
+
+        yield* materializeEvent(eventEncoded, { skipEventlog: true })
+      }).pipe(Effect.withSpan(`@livestore/common:rematerializeFromEventlog:processEvent`))
+
+    const CHUNK_SIZE = 100
+
+    const stmt = dbEventlog.prepare(sql`\
+SELECT * FROM ${SystemTables.EVENTLOG_META_TABLE} 
+WHERE seqNumGlobal > $seqNumGlobal OR (seqNumGlobal = $seqNumGlobal AND seqNumClient > $seqNumClient)
+ORDER BY seqNumGlobal ASC, seqNumClient ASC
+LIMIT ${CHUNK_SIZE}
+`)
+
+    let processedEvents = 0
+
+    yield* Stream.unfoldChunk<
+      Chunk.Chunk<SystemTables.EventlogMetaRow> | { _tag: 'Initial ' },
+      SystemTables.EventlogMetaRow
+    >({ _tag: 'Initial ' }, (item) => {
+      // End stream if no more rows
+      if (Chunk.isChunk(item) && item.length === 0) return Option.none()
+
+      const lastId = Chunk.isChunk(item)
+        ? Chunk.last(item).pipe(
+            Option.map((_) => ({ global: _.seqNumGlobal, client: _.seqNumClient })),
+            Option.getOrElse(() => EventSequenceNumber.ROOT),
+          )
+        : EventSequenceNumber.ROOT
+      const nextItem = Chunk.fromIterable(
+        stmt.select<SystemTables.EventlogMetaRow>({
+          $seqNumGlobal: lastId?.global,
+          $seqNumClient: lastId?.client,
+        } as any as PreparedBindValues),
+      )
+      const prevItem = Chunk.isChunk(item) ? item : Chunk.empty()
+      return Option.some([prevItem, nextItem])
+    }).pipe(
+      Stream.bufferChunks({ capacity: 2 }),
+      Stream.tap((row) =>
+        Effect.gen(function* () {
+          yield* processEvent(row)
+
+          processedEvents++
+          yield* onProgress({ done: processedEvents, total: eventsCount })
+        }),
+      ),
+      Stream.runDrain,
+    )
+  }).pipe(
+    Effect.withPerformanceMeasure('@livestore/common:rematerializeFromEventlog'),
+    Effect.withSpan('@livestore/common:rematerializeFromEventlog'),
+  )