@livestore/common 0.4.0-dev.20 → 0.4.0-dev.22

package/src/devtools/devtools-messages-client-session.ts

@@ -107,6 +107,17 @@ export class Ping extends LSDClientSessionReqResMessage('LSD.ClientSession.Ping'
 
 export class Pong extends LSDClientSessionReqResMessage('LSD.ClientSession.Pong', {}) {}
 
+/**
+ * Sent by the app when DevTools version doesn't match.
+ * Contains the app's actual version so DevTools can display a meaningful error.
+ */
+export class VersionMismatch extends LSDClientSessionReqResMessage('LSD.ClientSession.VersionMismatch', {
+  /** The version running in the app */
+  appVersion: Schema.String,
+  /** The version that was sent by DevTools (that caused the mismatch) */
+  receivedVersion: Schema.String,
+}) {}
+
 export class Disconnect extends LSDClientSessionChannelMessage('LSD.ClientSession.Disconnect', {}) {}
 
 export const MessageToApp = Schema.Union(
@@ -136,6 +147,7 @@ export const MessageFromApp = Schema.Union(
   LiveQueriesRes,
   Disconnect,
   Pong,
+  VersionMismatch,
   SyncHeadRes,
 ).annotations({ identifier: 'LSD.ClientSession.MessageFromApp' })
 

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

@@ -1,13 +1,17 @@
 import { Schema } from '@livestore/utils/effect'
 
-import { liveStoreVersion as pkgVersion } from '../version.ts'
-
 export { NetworkStatus } from '../sync/sync-backend.ts'
 
 export const requestId = Schema.String
 export const clientId = Schema.String
 export const sessionId = Schema.String
-export const liveStoreVersion = Schema.Literal(pkgVersion)
+/**
+ * Version field for devtools messages.
+ * Uses Schema.String to accept messages from any version (backwards/forwards compatible).
+ * Version checking happens at the application layer after message parsing succeeds,
+ * allowing DevTools to respond with a proper VersionMismatch error instead of silent rejection.
+ */
+export const liveStoreVersion = Schema.String
 
 export const LSDMessage = <Tag extends string, Fields extends Schema.Struct.Fields>(tag: Tag, fields: Fields) =>
   Schema.TaggedStruct(tag, {

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

@@ -77,6 +77,7 @@ export class SnapshotRes extends LSDReqResMessage('LSD.Leader.SnapshotRes', {
 export const LoadDatabaseFile = LeaderReqResMessage('LSD.Leader.LoadDatabaseFile', {
   payload: {
     data: Transferable.Uint8Array as Schema.Schema<Uint8Array<ArrayBuffer>>,
+    batchId: Schema.optional(Schema.String),
   },
   success: {},
   error: {
@@ -110,6 +111,17 @@ export class Ping extends LSDReqResMessage('LSD.Leader.Ping', {}) {}
 
 export class Pong extends LSDReqResMessage('LSD.Leader.Pong', {}) {}
 
+/**
+ * Sent by the app when DevTools version doesn't match.
+ * Contains the app's actual version so DevTools can display a meaningful error.
+ */
+export class VersionMismatch extends LSDReqResMessage('LSD.Leader.VersionMismatch', {
+  /** The version running in the app */
+  appVersion: Schema.String,
+  /** The version that was sent by DevTools (that caused the mismatch) */
+  receivedVersion: Schema.String,
+}) {}
+
 export class Disconnect extends LSDReqResMessage('LSD.Leader.Disconnect', {}) {}
 
 export const SetSyncLatch = LeaderReqResMessage('LSD.Leader.SetSyncLatch', {
@@ -180,6 +192,7 @@ export const MessageFromApp = Schema.Union(
   NetworkStatusRes,
   CommitEventRes,
   Pong,
+  VersionMismatch,
   DatabaseFileInfoRes,
   SyncHistoryRes,
   SyncingInfoRes,

package/src/leader-thread/LeaderSyncProcessor.ts

@@ -37,6 +37,11 @@ import { rollback } from './materialize-event.ts'
 import type { InitialBlockingSyncContext, LeaderSyncProcessor } from './types.ts'
 import { LeaderThreadCtx } from './types.ts'
 
+// WORKAROUND: @effect/opentelemetry mis-parses `Span.addEvent(name, attributes)` and treats the attributes object as a
+// time input, causing `TypeError: {} is not iterable` at runtime.
+// Upstream: https://github.com/Effect-TS/effect/pull/5929
+// TODO: simplify back to the 2-arg overload once the upstream fix is released and adopted.
+
 type LocalPushQueueItem = [
   event: LiveStoreEvent.Client.EncodedWithMeta,
   deferred: Deferred.Deferred<void, LeaderAheadError> | undefined,
@@ -90,10 +95,43 @@ export const makeLeaderSyncProcessor = ({
   onError: 'shutdown' | 'ignore'
   params: {
     /**
+     * Maximum number of local events to process per batch cycle.
+     *
+     * This controls how many events from client sessions are applied to the local state
+     * in a single iteration before yielding to allow potential backend pulls.
+     *
+     * **Trade-offs:**
+     * - **Lower values (1-5):** More responsive to remote updates since pull processing can
+     *   interleave more frequently. Better for high-conflict scenarios where rebases are common.
+     *   Slightly higher per-event overhead due to more frequent transaction commits.
+     *
+     * - **Higher values (10-50+):** Better throughput for bulk local writes as more events are
+     *   batched into a single transaction. However, may delay remote update processing and
+     *   increase rebase complexity if many local events queue up during a slow pull.
+     *
+     * - **Very high values (100+):** Risk of starvation for pull processing if local pushes
+     *   arrive continuously. May cause larger rollbacks during rebases. Not recommended
+     *   unless you have a write-heavy workload with minimal remote synchronization.
+     *
      * @default 10
      */
     localPushBatchSize?: number
     /**
+     * Maximum number of events to push to the sync backend per batch.
+     *
+     * This controls how many events are sent in a single push request to the remote server.
+     *
+     * **Trade-offs:**
+     * - **Lower values (1-10):** Lower latency for each push operation. Faster feedback on
+     *   push success/failure. Slightly higher network overhead due to more requests.
+     *
+     * - **Higher values (50-100):** Better network efficiency by amortizing request overhead.
+     *   Preferred for high-throughput scenarios. May increase latency to first confirmation.
+     *
+     * - **Very high values (200+):** Risk of hitting server request size limits or timeouts.
+     *   A single failed request loses the entire batch (will be retried). May cause memory
+     *   pressure if events accumulate faster than they can be pushed.
+     *
      * @default 50
      */
     backendPushBatchSize?: number
@@ -111,8 +149,8 @@ export const makeLeaderSyncProcessor = ({
 }): Effect.Effect<LeaderSyncProcessor, UnknownError, Scope.Scope> =>
   Effect.gen(function* () {
     const syncBackendPushQueue = yield* BucketQueue.make<LiveStoreEvent.Client.EncodedWithMeta>()
-    const localPushBatchSize = params.localPushBatchSize ?? 1
-    const backendPushBatchSize = params.backendPushBatchSize ?? 2
+    const localPushBatchSize = params.localPushBatchSize ?? 10
+    const backendPushBatchSize = params.backendPushBatchSize ?? 50
 
     const syncStateSref = yield* SubscriptionRef.make<SyncState.SyncState | undefined>(undefined)
 
@@ -443,10 +481,14 @@ const backgroundApplyLocalPushes = ({
       )
 
       if (droppedItems.length > 0) {
-        otelSpan?.addEvent(`push:drop-old-generation`, {
-          droppedCount: droppedItems.length,
-          currentRebaseGeneration,
-        })
+        otelSpan?.addEvent(
+          `push:drop-old-generation`,
+          {
+            droppedCount: droppedItems.length,
+            currentRebaseGeneration,
+          },
+          undefined,
+        )
 
         /**
          * Dropped pushes may still have a deferred awaiting completion.
@@ -484,20 +526,28 @@ const backgroundApplyLocalPushes = ({
 
       switch (mergeResult._tag) {
         case 'unknown-error': {
-          otelSpan?.addEvent(`push:unknown-error`, {
-            batchSize: newEvents.length,
-            newEvents: TRACE_VERBOSE ? JSON.stringify(newEvents) : undefined,
-          })
+          otelSpan?.addEvent(
+            `push:unknown-error`,
+            {
+              batchSize: newEvents.length,
+              newEvents: TRACE_VERBOSE ? JSON.stringify(newEvents) : undefined,
+            },
+            undefined,
+          )
           return yield* new UnknownError({ cause: mergeResult.message })
         }
         case 'rebase': {
           return shouldNeverHappen('The leader thread should never have to rebase due to a local push')
         }
         case 'reject': {
-          otelSpan?.addEvent(`push:reject`, {
-            batchSize: newEvents.length,
-            mergeResult: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
-          })
+          otelSpan?.addEvent(
+            `push:reject`,
+            {
+              batchSize: newEvents.length,
+              mergeResult: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
+            },
+            undefined,
+          )
 
           // TODO: how to test this?
           const nextRebaseGeneration = currentRebaseGeneration + 1
@@ -552,10 +602,14 @@ const backgroundApplyLocalPushes = ({
         leaderHead: mergeResult.newSyncState.localHead,
       })
 
-      otelSpan?.addEvent(`push:advance`, {
-        batchSize: newEvents.length,
-        mergeResult: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
-      })
+      otelSpan?.addEvent(
+        `push:advance`,
+        {
+          batchSize: newEvents.length,
+          mergeResult: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
+        },
+        undefined,
+      )
 
       // Don't sync client-local events
       const filteredBatch = mergeResult.newEvents.filter((eventEncoded) => {
@@ -686,10 +740,14 @@ const backgroundBackendPulling = ({
         if (mergeResult._tag === 'reject') {
           return shouldNeverHappen('The leader thread should never reject upstream advances')
         } else if (mergeResult._tag === 'unknown-error') {
-          otelSpan?.addEvent(`pull:unknown-error`, {
-            newEventsCount: newEvents.length,
-            newEvents: TRACE_VERBOSE ? JSON.stringify(newEvents) : undefined,
-          })
+          otelSpan?.addEvent(
+            `pull:unknown-error`,
+            {
+              newEventsCount: newEvents.length,
+              newEvents: TRACE_VERBOSE ? JSON.stringify(newEvents) : undefined,
+            },
+            undefined,
+          )
           return yield* new UnknownError({ cause: mergeResult.message })
         }
 
@@ -698,12 +756,16 @@ const backgroundBackendPulling = ({
         Eventlog.updateBackendHead(dbEventlog, newBackendHead)
 
         if (mergeResult._tag === 'rebase') {
-          otelSpan?.addEvent(`pull:rebase[${mergeResult.newSyncState.localHead.rebaseGeneration}]`, {
-            newEventsCount: newEvents.length,
-            newEvents: TRACE_VERBOSE ? JSON.stringify(newEvents) : undefined,
-            rollbackCount: mergeResult.rollbackEvents.length,
-            mergeResult: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
-          })
+          otelSpan?.addEvent(
+            `pull:rebase[${mergeResult.newSyncState.localHead.rebaseGeneration}]`,
+            {
+              newEventsCount: newEvents.length,
+              newEvents: TRACE_VERBOSE ? JSON.stringify(newEvents) : undefined,
+              rollbackCount: mergeResult.rollbackEvents.length,
+              mergeResult: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
+            },
+            undefined,
+          )
 
           const globalRebasedPendingEvents = mergeResult.newSyncState.pending.filter((event) => {
             const eventDef = schema.eventsDefsMap.get(event.name)
@@ -724,10 +786,14 @@ const backgroundBackendPulling = ({
             leaderHead: mergeResult.newSyncState.localHead,
           })
         } else {
-          otelSpan?.addEvent(`pull:advance`, {
-            newEventsCount: newEvents.length,
-            mergeResult: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
-          })
+          otelSpan?.addEvent(
+            `pull:advance`,
+            {
+              newEventsCount: newEvents.length,
+              mergeResult: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
+            },
+            undefined,
+          )
 
           // Ensure push fiber is active after advance by restarting with current pending (non-client) events
           const globalPendingEvents = mergeResult.newSyncState.pending.filter((event) => {
@@ -837,10 +903,14 @@ const backgroundBackendPushing = ({
         yield* devtoolsLatch.await
       }
 
-      otelSpan?.addEvent('backend-push', {
-        batchSize: queueItems.length,
-        batch: TRACE_VERBOSE ? JSON.stringify(queueItems) : undefined,
-      })
+      otelSpan?.addEvent(
+        'backend-push',
+        {
+          batchSize: queueItems.length,
+          batch: TRACE_VERBOSE ? JSON.stringify(queueItems) : undefined,
+        },
+        undefined,
+      )
 
       // Push with declarative retry/backoff using Effect schedules
       // - Exponential backoff starting at 1s and doubling (1s, 2s, 4s, 8s, 16s, 30s ...)
@@ -867,15 +937,19 @@ const backgroundBackendPushing = ({
 
         const retries = iteration.recurrence
         if (retries > 0 && pushResult._tag === 'Right') {
-          otelSpan?.addEvent('backend-push-retry-success', { retries, batchSize: queueItems.length })
+          otelSpan?.addEvent('backend-push-retry-success', { retries, batchSize: queueItems.length }, undefined)
         }
 
         if (pushResult._tag === 'Left') {
-          otelSpan?.addEvent('backend-push-error', {
-            error: pushResult.left.toString(),
-            retries,
-            batchSize: queueItems.length,
-          })
+          otelSpan?.addEvent(
+            'backend-push-error',
+            {
+              error: pushResult.left.toString(),
+              retries,
+              batchSize: queueItems.length,
+            },
+            undefined,
+          )
           const error = pushResult.left
           if (
             error._tag === 'IsOfflineError' ||

package/src/leader-thread/eventlog.ts

@@ -1,6 +1,5 @@
 import { LS_DEV, shouldNeverHappen } from '@livestore/utils'
-import { Effect, Option, Schema } from '@livestore/utils/effect'
-
+import { Chunk, Effect, Option, Schema } from '@livestore/utils/effect'
 import type { SqliteDb } from '../adapter-types.ts'
 import * as EventSequenceNumber from '../schema/EventSequenceNumber/mod.ts'
 import * as LiveStoreEvent from '../schema/LiveStoreEvent/mod.ts'
@@ -16,8 +15,8 @@ import { insertRow, updateRows } from '../sql-queries/sql-queries.ts'
 import type { PreparedBindValues } from '../util.ts'
 import { sql } from '../util.ts'
 import { execSql } from './connection.ts'
-import type { InitialSyncInfo } from './types.ts'
-import { LeaderThreadCtx } from './types.ts'
+import type { InitialSyncInfo, StreamEventsOptions } from './types.ts'
+import { LeaderThreadCtx, STREAM_EVENTS_BATCH_SIZE_DEFAULT } from './types.ts'
 
 export const initEventlogDb = (dbEventlog: SqliteDb) =>
   Effect.gen(function* () {
@@ -100,6 +99,83 @@ export const getEventsSince = ({
     .sort((a, b) => EventSequenceNumber.Client.compare(a.seqNum, b.seqNum))
 }
 
+export const getEventsFromEventlog = ({
+  dbEventlog,
+  options,
+}: {
+  dbEventlog: SqliteDb
+  options: StreamEventsOptions
+}): Effect.Effect<Chunk.Chunk<LiveStoreEvent.Client.Encoded>> =>
+  Effect.gen(function* () {
+    const since = options.since ?? EventSequenceNumber.Client.ROOT
+    const batchSize = options.batchSize ?? STREAM_EVENTS_BATCH_SIZE_DEFAULT
+
+    const makeQuery = () => {
+      let query = eventlogMetaTable.where('seqNumGlobal', '>', since.global)
+
+      if (options.until) {
+        query = query.where('seqNumGlobal', '<=', options.until.global)
+      }
+
+      if (options.filter && options.filter.length > 0) {
+        query = query.where({ name: { op: 'IN', value: options.filter } })
+      }
+
+      if (options.clientIds && options.clientIds.length > 0) {
+        query = query.where({ clientId: { op: 'IN', value: options.clientIds } })
+      }
+
+      if (options.sessionIds && options.sessionIds.length > 0) {
+        query = query.where({ sessionId: { op: 'IN', value: options.sessionIds } })
+      }
+
+      if (options.includeClientOnly !== true) {
+        query = query.where('seqNumClient', '<=', EventSequenceNumber.Client.DEFAULT)
+      }
+
+      return query
+        .orderBy([
+          { col: 'seqNumGlobal', direction: 'asc' },
+          { col: 'seqNumClient', direction: 'asc' },
+        ])
+        .limit(batchSize)
+    }
+
+    const eventlogEvents = yield* Effect.sync(() => dbEventlog.select(makeQuery()))
+
+    if (eventlogEvents.length === 0) {
+      return Chunk.empty<LiveStoreEvent.Client.Encoded>()
+    }
+
+    const spanAttributes = {
+      'livestore.eventLog.since': since.global,
+      'livestore.eventLog.until': options.until?.global,
+    }
+
+    return yield* Effect.sync(() => {
+      const encodedEvents = eventlogEvents.map((eventlogEvent) => {
+        return LiveStoreEvent.Client.Encoded.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,
+        })
+      })
+
+      return Chunk.fromIterable(encodedEvents)
+    }).pipe(Effect.withSpan('@livestore/common:eventlog:getEventsFromEventlog', { attributes: spanAttributes }))
+  })
+
 export const getClientHeadFromDb = (dbEventlog: SqliteDb): EventSequenceNumber.Client.Composite => {
   const res = dbEventlog.select<{
     seqNumGlobal: EventSequenceNumber.Global.Type

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

@@ -94,6 +94,22 @@ const listenToDevtools = ({
     type RequestId = string
     const handledRequestIds = new Set<RequestId>()
 
+    type LoadDatabaseKind = 'state' | 'eventlog'
+    const loadDatabaseBatchTracker = new Map<string, Set<LoadDatabaseKind>>()
+
+    const registerBatchProgress = (batchId: string, kind: LoadDatabaseKind) => {
+      const entry = loadDatabaseBatchTracker.get(batchId) ?? new Set<LoadDatabaseKind>()
+      entry.add(kind)
+      loadDatabaseBatchTracker.set(batchId, entry)
+      const finished = entry.has('state') && entry.has('eventlog')
+
+      if (finished) {
+        loadDatabaseBatchTracker.delete(batchId)
+      }
+
+      return finished
+    }
+
     yield* incomingMessages.pipe(
       Stream.tap((decodedEvent) =>
         Effect.gen(function* () {
@@ -122,6 +138,17 @@ const listenToDevtools = ({
 
           switch (decodedEvent._tag) {
             case 'LSD.Leader.Ping': {
+              // Check version mismatch and respond with VersionMismatch if versions don't match
+              if (decodedEvent.liveStoreVersion !== liveStoreVersion) {
+                yield* sendMessage(
+                  Devtools.Leader.VersionMismatch.make({
+                    ...reqPayload,
+                    appVersion: liveStoreVersion,
+                    receivedVersion: decodedEvent.liveStoreVersion,
+                  }),
+                )
+                return
+              }
               yield* sendMessage(Devtools.Leader.Pong.make({ ...reqPayload }))
               return
             }
@@ -133,7 +160,7 @@ const listenToDevtools = ({
               return
             }
             case 'LSD.Leader.LoadDatabaseFile.Request': {
-              const { data } = decodedEvent
+              const { data, batchId } = decodedEvent
 
               const handleLoadDb = Effect.gen(function* () {
                 const tableNames = yield* Effect.acquireRelease(makeSqliteDb({ _tag: 'in-memory' }), (db) =>
@@ -148,25 +175,44 @@ const listenToDevtools = ({
                   ),
                 )
 
+                let databaseKind: LoadDatabaseKind | undefined
+
                 if (tableNames.has(SystemTables.EVENTLOG_META_TABLE)) {
-                  // Is eventlog db
+                  databaseKind = 'eventlog'
                   yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
                   yield* Effect.try(() => void dbEventlog.import(data))
-                  yield* Effect.try(() => void dbState.destroy())
+
+                  if (batchId === undefined) {
+                    yield* Effect.try(() => void dbState.destroy())
+                  }
                 } else if (
                   tableNames.has(SystemTables.SCHEMA_META_TABLE) &&
                   tableNames.has(SystemTables.SCHEMA_EVENT_DEFS_META_TABLE)
                 ) {
-                  // Is state db
+                  databaseKind = 'state'
                   yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
                   yield* Effect.try(() => void dbState.import(data))
-                  yield* Effect.try(() => void dbEventlog.destroy())
+
+                  if (batchId === undefined) {
+                    yield* Effect.try(() => void dbEventlog.destroy())
+                  }
                 } else {
                   return yield* Effect.fail({ _tag: 'unsupported-database' } as const)
                 }
 
+                const resolvedDatabaseKind = databaseKind
+                if (resolvedDatabaseKind === undefined) {
+                  return yield* Effect.fail({ _tag: 'unsupported-database' } as const)
+                }
+
+                const shouldShutdown =
+                  batchId === undefined ? true : registerBatchProgress(batchId, resolvedDatabaseKind)
+
                 yield* sendMessage(Devtools.Leader.LoadDatabaseFile.Success.make({ ...reqPayload }))
-                yield* shutdownChannel.send(IntentionalShutdownCause.make({ reason: 'devtools-import' }))
+
+                if (shouldShutdown) {
+                  yield* shutdownChannel.send(IntentionalShutdownCause.make({ reason: 'devtools-import' }))
+                }
               })
 
               yield* handleLoadDb.pipe(

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

@@ -55,6 +55,8 @@ export interface MakeLeaderThreadLayerParams {
   dbEventlog: LeaderSqliteDb
   devtoolsOptions: DevtoolsOptions
   shutdownChannel: ShutdownChannel
+  /** Boot warning to emit (e.g., OPFS unavailable in private browsing) */
+  bootWarning?: BootStatus
   params?: {
     localPushBatchSize?: number
     backendPushBatchSize?: number
@@ -80,6 +82,7 @@ export const makeLeaderThreadLayer = ({
   dbEventlog,
   devtoolsOptions,
   shutdownChannel,
+  bootWarning,
   params,
   testing,
 }: MakeLeaderThreadLayerParams): Layer.Layer<LeaderThreadCtx, UnknownError, Scope.Scope | HttpClient.HttpClient> =>
@@ -89,6 +92,11 @@ export const makeLeaderThreadLayer = ({
 
     const bootStatusQueue = yield* Queue.unbounded<BootStatus>().pipe(Effect.acquireRelease(Queue.shutdown))
 
+    // Emit boot warning if present (e.g., OPFS unavailable in private browsing)
+    if (bootWarning !== undefined) {
+      yield* Queue.offer(bootStatusQueue, bootWarning)
+    }
+
     const dbEventlogMissing = !hasEventlogTables(dbEventlog)
 
     // Either happens on initial boot or if schema changes

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

@@ -3,6 +3,7 @@ import { Effect, Option, ReadonlyArray, Schema } from '@livestore/utils/effect'
 
 import { MaterializeError, MaterializerHashMismatchError, type SqliteDb } from '../adapter-types.ts'
 import { getExecStatementsFromMaterializer, hashMaterializerResults } from '../materializer-helper.ts'
+import { logDeprecationWarnings } from '../schema/EventDef/deprecated.ts'
 import type { LiveStoreSchema } from '../schema/mod.ts'
 import { EventSequenceNumber, resolveEventDef, SystemTables, UNKNOWN_EVENT_SCHEMA_HASH } from '../schema/mod.ts'
 import { insertRow } from '../sql-queries/index.ts'
@@ -62,6 +63,9 @@ export const makeMaterializeEvent = ({
 
         const { eventDef, materializer } = resolution
 
+        // Log deprecation warnings for deprecated events/fields
+        yield* logDeprecationWarnings(eventDef, eventEncoded.args as Record<string, unknown>)
+
         const execArgsArr = getExecStatementsFromMaterializer({
           eventDef,
           materializer,

package/src/leader-thread/mod.ts

@@ -5,4 +5,5 @@ export * from './make-leader-thread-layer.ts'
 export * from './materialize-event.ts'
 export * from './recreate-db.ts'
 export * as ShutdownChannel from './shutdown-channel.ts'
+export * from './stream-events.ts'
 export * from './types.ts'