@livestore/common 0.4.0-dev.21 → 0.4.0-dev.23

package/src/leader-thread/RejectedPushError.ts

@@ -0,0 +1,106 @@
+/**
+ * Push validation errors returned by {@link LeaderSyncProcessor.push}.
+ *
+ * All three errors share a common {@link RejectedPushErrorTypeId} so consumers can catch the
+ * family as a group via {@link isRejectedPushError} instead of matching individual tags.
+ * Recovery is the same in every case: the client should rebase and retry.
+ *
+ * @module
+ */
+import { Predicate, Schema } from '@livestore/utils/effect'
+
+import { EventSequenceNumber } from '../schema/mod.ts'
+
+export const RejectedPushErrorTypeId = '~@livestore/common/RejectedPushError' as const
+
+/**
+ * A pushed batch of events failed validation because its sequence numbers are not strictly increasing.
+ *
+ * @remarks
+ *
+ * This is a defensive check — callers are expected to construct monotonic event batches.
+ * The client should rebase and retry.
+ */
+export class NonMonotonicBatchError extends Schema.TaggedError<NonMonotonicBatchError>(
+  `${RejectedPushErrorTypeId}/NonMonotonicBatchError`,
+)(
+  'NonMonotonicBatchError',
+  {
+    /** The sequence number that broke the monotonic invariant (i.e. the one that is >= the next). */
+    precedingSeqNum: EventSequenceNumber.Client.Composite,
+    /** The sequence number that was expected to be greater than `precedingSeqNum`. */
+    violatingSeqNum: EventSequenceNumber.Client.Composite,
+    /** The index in the batch where the violation occurred. */
+    violationIndex: Schema.Number,
+    /** The session that produced the malformed batch. */
+    sessionId: Schema.String,
+  },
+) {
+  readonly [RejectedPushErrorTypeId] = RejectedPushErrorTypeId
+
+  override get message(): string {
+    return `Pushed events' sequence numbers are not strictly increasing at index ${this.violationIndex} (session ${this.sessionId}): ${EventSequenceNumber.Client.toString(this.precedingSeqNum)} >= ${EventSequenceNumber.Client.toString(this.violatingSeqNum)}`
+  }
+}
+
+/**
+ * A pushed batch of events failed validation because its rebase generation is older than the leader's current rebase generation.
+ *
+ * @remarks
+ *
+ * This happens when events were enqueued before a backend-pull-triggered rebase incremented the generation.
+ */
+export class StaleRebaseGenerationError extends Schema.TaggedError<StaleRebaseGenerationError>(
+  `${RejectedPushErrorTypeId}/StaleRebaseGenerationError`,
+)(
+  'StaleRebaseGenerationError',
+  {
+    /** The leader's current rebase generation. */
+    currentRebaseGeneration: Schema.Number,
+    /** The rebase generation carried by the dropped events. */
+    providedRebaseGeneration: Schema.Number,
+    /** The session that produced the stale batch. */
+    sessionId: Schema.String,
+  },
+) {
+  readonly [RejectedPushErrorTypeId] = RejectedPushErrorTypeId
+
+  override get message(): string {
+    return `Pushed events have stale rebase generation (session ${this.sessionId}): expected >= ${this.currentRebaseGeneration}, got ${this.providedRebaseGeneration}`
+  }
+}
+
+/**
+ * A pushed batch of events was rejected because the leader's push head has already advanced
+ * past the batch's first event.
+ *
+ * @remarks
+ *
+ * This occurs when another client session (or a backend pull) has pushed events that the current
+ * session hasn't seen yet.
+ */
+export class LeaderAheadError extends Schema.TaggedError<LeaderAheadError>(
+  `${RejectedPushErrorTypeId}/LeaderAheadError`,
+)('LeaderAheadError', {
+  minimumExpectedNum: EventSequenceNumber.Client.Composite,
+  providedNum: EventSequenceNumber.Client.Composite,
+  /** The session that produced the stale batch. */
+  sessionId: Schema.String,
+}) {
+  readonly [RejectedPushErrorTypeId] = RejectedPushErrorTypeId
+
+  override get message(): string {
+    return `Leader push head is ahead of batch (session ${this.sessionId}): expected > ${EventSequenceNumber.Client.toString(this.minimumExpectedNum)}, got ${EventSequenceNumber.Client.toString(this.providedNum)}`
+  }
+}
+
+export const RejectedPushError = Schema.Union(
+  LeaderAheadError,
+  NonMonotonicBatchError,
+  StaleRebaseGenerationError,
+)
+
+export type RejectedPushError = typeof RejectedPushError.Type
+
+export const isRejectedPushError = (u: unknown): u is RejectedPushError =>
+  Predicate.hasProperty(u, RejectedPushErrorTypeId)

package/src/leader-thread/connection.ts

@@ -62,7 +62,7 @@ export const configureConnection = (sqliteDb: SqliteDb, { foreignKeys, lockingMo
     -- disable WAL until we have it working properly
     -- PRAGMA journal_mode=WAL;
     PRAGMA page_size=8192;
-    PRAGMA foreign_keys=${foreignKeys ? 'ON' : 'OFF'};
+    PRAGMA foreign_keys=${foreignKeys === true ? 'ON' : 'OFF'};
     ${lockingMode === undefined ? '' : sql`PRAGMA locking_mode=${lockingMode};`}
   `,
     {},

package/src/leader-thread/eventlog.ts

@@ -1,6 +1,8 @@
 import { LS_DEV, shouldNeverHappen } from '@livestore/utils'
 import { Chunk, Effect, Option, Schema } from '@livestore/utils/effect'
+
 import type { SqliteDb } from '../adapter-types.ts'
+import { migrateTable } from '../schema-management/migrations.ts'
 import * as EventSequenceNumber from '../schema/EventSequenceNumber/mod.ts'
 import * as LiveStoreEvent from '../schema/LiveStoreEvent/mod.ts'
 import {
@@ -10,7 +12,6 @@ import {
   SYNC_STATUS_TABLE,
 } from '../schema/state/sqlite/system-tables/eventlog-tables.ts'
 import { sessionChangesetMetaTable } from '../schema/state/sqlite/system-tables/state-tables.ts'
-import { migrateTable } from '../schema-management/migrations.ts'
 import { insertRow, updateRows } from '../sql-queries/sql-queries.ts'
 import type { PreparedBindValues } from '../util.ts'
 import { sql } from '../util.ts'
@@ -58,13 +59,14 @@ export const getEventsSince = ({
     sessionChangesetMetaTable.where('seqNumGlobal', '>=', since.global),
   )
 
+  // Create a Map for O(1) lookup instead of O(n) find
+  const sessionChangesetMap = new Map(
+    sessionChangesetRowsDecoded.map((row) => [`${row.seqNumGlobal}:${row.seqNumClient}`, row]),
+  )
+
   return pendingEvents
     .map((eventlogEvent) => {
-      const sessionChangeset = sessionChangesetRowsDecoded.find(
-        (readModelEvent) =>
-          readModelEvent.seqNumGlobal === eventlogEvent.seqNumGlobal &&
-          readModelEvent.seqNumClient === eventlogEvent.seqNumClient,
-      )
+      const sessionChangeset = sessionChangesetMap.get(`${eventlogEvent.seqNumGlobal}:${eventlogEvent.seqNumClient}`)
       return LiveStoreEvent.Client.EncodedWithMeta.make({
         name: eventlogEvent.name,
         args: eventlogEvent.argsJson,
@@ -82,7 +84,7 @@ export const getEventsSince = ({
         sessionId: eventlogEvent.sessionId,
         meta: {
           sessionChangeset:
-            sessionChangeset && sessionChangeset.changeset !== null
+            sessionChangeset !== undefined && sessionChangeset.changeset !== null
               ? {
                   _tag: 'sessionChangeset' as const,
                   data: sessionChangeset.changeset,
@@ -96,7 +98,7 @@ export const getEventsSince = ({
       })
     })
     .filter((_) => EventSequenceNumber.Client.compare(_.seqNum, since) > 0)
-    .sort((a, b) => EventSequenceNumber.Client.compare(a.seqNum, b.seqNum))
+    .toSorted((a, b) => EventSequenceNumber.Client.compare(a.seqNum, b.seqNum))
 }
 
 export const getEventsFromEventlog = ({
@@ -113,19 +115,19 @@ export const getEventsFromEventlog = ({
     const makeQuery = () => {
       let query = eventlogMetaTable.where('seqNumGlobal', '>', since.global)
 
-      if (options.until) {
+      if (options.until !== undefined) {
         query = query.where('seqNumGlobal', '<=', options.until.global)
       }
 
-      if (options.filter && options.filter.length > 0) {
+      if (options.filter !== undefined && options.filter.length > 0) {
         query = query.where({ name: { op: 'IN', value: options.filter } })
       }
 
-      if (options.clientIds && options.clientIds.length > 0) {
+      if (options.clientIds !== undefined && options.clientIds.length > 0) {
         query = query.where({ clientId: { op: 'IN', value: options.clientIds } })
       }
 
-      if (options.sessionIds && options.sessionIds.length > 0) {
+      if (options.sessionIds !== undefined && options.sessionIds.length > 0) {
         query = query.where({ sessionId: { op: 'IN', value: options.sessionIds } })
       }
 
@@ -185,7 +187,7 @@ export const getClientHeadFromDb = (dbEventlog: SqliteDb): EventSequenceNumber.C
     sql`select seqNumGlobal, seqNumClient, seqNumRebaseGeneration from ${EVENTLOG_META_TABLE} order by seqNumGlobal DESC, seqNumClient DESC limit 1`,
   )[0]
 
-  return res
+  return res !== undefined
     ? { global: res.seqNumGlobal, client: res.seqNumClient, rebaseGeneration: res.seqNumRebaseGeneration }
     : EventSequenceNumber.Client.ROOT
 }
@@ -215,7 +217,7 @@ export const insertIntoEventlog = (
 ) =>
   Effect.gen(function* () {
     // Check history consistency during LS_DEV
-    if (LS_DEV && eventEncoded.parentSeqNum.global !== EventSequenceNumber.Client.ROOT.global) {
+    if (LS_DEV === true && eventEncoded.parentSeqNum.global !== EventSequenceNumber.Client.ROOT.global) {
       const parentEventExists =
         dbEventlog.select<{ count: number }>(
           `SELECT COUNT(*) as count FROM ${EVENTLOG_META_TABLE} WHERE seqNumGlobal = ? AND seqNumClient = ?`,

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

@@ -8,63 +8,91 @@ import { LeaderThreadCtx } from './types.ts'
 
 type SendMessageToDevtools = (message: Devtools.Leader.MessageFromApp) => Effect.Effect<void>
 
-// TODO bind scope to the webchannel lifetime
-export const bootDevtools = (options: DevtoolsOptions) =>
-  Effect.gen(function* () {
-    if (options.enabled === false) {
-      return
-    }
-
-    const { syncProcessor, extraIncomingMessagesQueue, clientId, storeId } = yield* LeaderThreadCtx
-
-    yield* listenToDevtools({
-      incomingMessages: Stream.fromQueue(extraIncomingMessagesQueue),
-      sendMessage: () => Effect.void,
-    }).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
+/**
+ * Type guard for DevtoolsViteNotInstalledError.
+ * This error is defined in @livestore/adapter-node but we need to handle it here.
+ */
+const isDevtoolsViteNotInstalledError = (
+  error: unknown,
+): error is { _tag: 'DevtoolsViteNotInstalledError'; message: string } =>
+  typeof error === 'object' && error !== null && '_tag' in error && error._tag === 'DevtoolsViteNotInstalledError'
 
-    const { node, persistenceInfo, mode } = yield* options.boot
-
-    yield* node.listenForChannel.pipe(
-      Stream.filter(
-        (res) =>
-          Devtools.isChannelName.devtoolsClientLeader(res.channelName, { storeId, clientId }) && res.mode === mode,
-      ),
-      Stream.tap(({ channelName, source }) =>
-        Effect.gen(function* () {
-          const channel = yield* node.makeChannel({
-            target: source,
-            channelName,
-            schema: { listen: Devtools.Leader.MessageToApp, send: Devtools.Leader.MessageFromApp },
-            mode,
-          })
-
-          const sendMessage: SendMessageToDevtools = (message) =>
-            channel
-              .send(message)
-              .pipe(
-                Effect.withSpan('@livestore/common:leader-thread:devtools:sendToDevtools'),
-                Effect.interruptible,
-                Effect.ignoreLogged,
-              )
-
-          const syncState = yield* syncProcessor.syncState
-
-          yield* syncProcessor.pull({ cursor: syncState.localHead }).pipe(
-            Stream.tap(({ payload }) => sendMessage(Devtools.Leader.SyncPull.make({ payload, liveStoreVersion }))),
-            Stream.runDrain,
-            Effect.forkScoped,
-          )
-
-          yield* listenToDevtools({
-            incomingMessages: channel.listen.pipe(Stream.flatten(), Stream.orDie),
-            sendMessage,
-            persistenceInfo,
-          })
-        }).pipe(Effect.tapCauseLogPretty, Effect.forkScoped),
+// TODO bind scope to the webchannel lifetime
+export const bootDevtools = Effect.fn('@livestore/common:leader-thread:devtools:boot')(function* (
+  options: DevtoolsOptions,
+) {
+  if (options.enabled === false) {
+    return
+  }
+
+  const { syncProcessor, extraIncomingMessagesQueue, clientId, storeId } = yield* LeaderThreadCtx
+
+  yield* listenToDevtools({
+    incomingMessages: Stream.fromQueue(extraIncomingMessagesQueue),
+    sendMessage: () => Effect.void,
+  }).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
+
+  const bootResult = yield* options.boot.pipe(
+    Effect.map(Option.some),
+    Effect.catchIf(isDevtoolsViteNotInstalledError, (error) =>
+      Effect.logWarning(`[@livestore/devtools] ${error.message} Devtools will be disabled.`).pipe(
+        Effect.as(Option.none()),
       ),
-      Stream.runDrain,
-    )
-  }).pipe(Effect.withSpan('@livestore/common:leader-thread:devtools:boot'))
+    ),
+    Effect.catchAllCause((cause) =>
+      Effect.logWarning(
+        `[@livestore/devtools] Failed to start devtools server. Devtools will be disabled.`,
+        cause,
+      ).pipe(Effect.as(Option.none())),
+    ),
+  )
+
+  if (Option.isNone(bootResult) === true) {
+    return
+  }
+
+  const { node, persistenceInfo, mode } = bootResult.value
+
+  yield* node.listenForChannel.pipe(
+    Stream.filter(
+      (res) => Devtools.isChannelName.devtoolsClientLeader(res.channelName, { storeId, clientId }) && res.mode === mode,
+    ),
+    Stream.tap(({ channelName, source }) =>
+      Effect.gen(function* () {
+        const channel = yield* node.makeChannel({
+          target: source,
+          channelName,
+          schema: { listen: Devtools.Leader.MessageToApp, send: Devtools.Leader.MessageFromApp },
+          mode,
+        })
+
+        const sendMessage: SendMessageToDevtools = (message) =>
+          channel
+            .send(message)
+            .pipe(
+              Effect.withSpan('@livestore/common:leader-thread:devtools:sendToDevtools'),
+              Effect.interruptible,
+              Effect.ignoreLogged,
+            )
+
+        const syncState = yield* syncProcessor.syncState
+
+        yield* syncProcessor.pull({ cursor: syncState.localHead }).pipe(
+          Stream.tap(({ payload }) => sendMessage(Devtools.Leader.SyncPull.make({ payload, liveStoreVersion }))),
+          Stream.runDrain,
+          Effect.forkScoped,
+        )
+
+        yield* listenToDevtools({
+          incomingMessages: channel.listen.pipe(Stream.flatten(), Stream.orDie),
+          sendMessage,
+          persistenceInfo,
+        })
+      }).pipe(Effect.tapCauseLogPretty, Effect.forkScoped),
+    ),
+    Stream.runDrain,
+  )
+})
 
 const listenToDevtools = ({
   incomingMessages,
@@ -103,7 +131,7 @@ const listenToDevtools = ({
       loadDatabaseBatchTracker.set(batchId, entry)
       const finished = entry.has('state') && entry.has('eventlog')
 
-      if (finished) {
+      if (finished === true) {
         loadDatabaseBatchTracker.delete(batchId)
       }
 
@@ -129,7 +157,7 @@ const listenToDevtools = ({
           // So far I could only observe this problem with webmesh proxy channels (e.g. for Expo)
           // Proof: https://share.cleanshot.com/V9G87B0B
           // Also see `store/devtools.ts` for same problem
-          if (handledRequestIds.has(requestId)) {
+          if (handledRequestIds.has(requestId) === true) {
             // yield* Effect.logWarning(`Duplicate message`, decodedEvent)
             return
           }
@@ -138,6 +166,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
             }
@@ -166,24 +205,24 @@ const listenToDevtools = ({
 
                 let databaseKind: LoadDatabaseKind | undefined
 
-                if (tableNames.has(SystemTables.EVENTLOG_META_TABLE)) {
+                if (tableNames.has(SystemTables.EVENTLOG_META_TABLE) === true) {
                   databaseKind = 'eventlog'
                   yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
-                  yield* Effect.try(() => void dbEventlog.import(data))
+                  yield* Effect.try(() => dbEventlog.import(data))
 
                   if (batchId === undefined) {
-                    yield* Effect.try(() => void dbState.destroy())
+                    yield* Effect.try(() => dbState.destroy())
                   }
                 } else if (
-                  tableNames.has(SystemTables.SCHEMA_META_TABLE) &&
-                  tableNames.has(SystemTables.SCHEMA_EVENT_DEFS_META_TABLE)
+                  tableNames.has(SystemTables.SCHEMA_META_TABLE) === true &&
+                  tableNames.has(SystemTables.SCHEMA_EVENT_DEFS_META_TABLE) === true
                 ) {
                   databaseKind = 'state'
                   yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
-                  yield* Effect.try(() => void dbState.import(data))
+                  yield* Effect.try(() => dbState.import(data))
 
                   if (batchId === undefined) {
-                    yield* Effect.try(() => void dbEventlog.destroy())
+                    yield* Effect.try(() => dbEventlog.destroy())
                   }
                 } else {
                   return yield* Effect.fail({ _tag: 'unsupported-database' } as const)
@@ -199,7 +238,7 @@ const listenToDevtools = ({
 
                 yield* sendMessage(Devtools.Leader.LoadDatabaseFile.Success.make({ ...reqPayload }))
 
-                if (shouldShutdown) {
+                if (shouldShutdown === true) {
                   yield* shutdownChannel.send(IntentionalShutdownCause.make({ reason: 'devtools-import' }))
                 }
               })
@@ -341,7 +380,9 @@ const listenToDevtools = ({
 
                 yield* Stream.zipLatest(
                   syncBackend.isConnected.changes,
-                  devtools.enabled ? devtools.syncBackendLatchState.changes : Stream.make({ latchClosed: false }),
+                  devtools.enabled === true
+                    ? devtools.syncBackendLatchState.changes
+                    : Stream.make({ latchClosed: false }),
                 ).pipe(
                   Stream.tap(([isConnected, { latchClosed }]) =>
                     sendMessage(

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

@@ -1,5 +1,5 @@
-import { Effect, Stream, SubscriptionRef } from '@livestore/utils/effect'
 import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { Effect, Stream, SubscriptionRef } from '@livestore/utils/effect'
 
 import { makeMockSyncBackend } from '../sync/mock-sync-backend.ts'
 import type { SyncBackend } from '../sync/sync.ts'

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

@@ -12,19 +12,19 @@ import {
   Subscribable,
   SubscriptionRef,
 } from '@livestore/utils/effect'
+
 import {
   type BootStatus,
   type MakeSqliteDb,
   type MaterializerHashMismatchError,
   type SqliteDb,
-  type SqliteError,
   UnknownError,
 } from '../adapter-types.ts'
 import type { MigrationsReport } from '../defs.ts'
 import type * as Devtools from '../devtools/mod.ts'
 import type { LiveStoreSchema } from '../schema/mod.ts'
 import { EventSequenceNumber, LiveStoreEvent, SystemTables } from '../schema/mod.ts'
-import type { InvalidPullError, IsOfflineError, SyncBackend, SyncOptions } from '../sync/sync.ts'
+import type { SyncBackend, SyncOptions } from '../sync/sync.ts'
 import { SyncState } from '../sync/syncstate.ts'
 import { sql } from '../util.ts'
 import * as Eventlog from './eventlog.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
@@ -148,9 +156,10 @@ export const makeLeaderThreadLayer = ({
 
     // Recreate state database if needed BEFORE creating sync processor
     // This ensures all system tables exist before any queries are made
-    const { migrationsReport } = dbStateMissing
-      ? yield* recreateDb({ dbState, dbEventlog, schema, bootStatusQueue, materializeEvent })
-      : { migrationsReport: { migrations: [] } }
+    const { migrationsReport } =
+      dbStateMissing === true
+        ? yield* recreateDb({ dbState, dbEventlog, schema, bootStatusQueue, materializeEvent })
+        : { migrationsReport: { migrations: [] } }
 
     const syncProcessor = yield* makeLeaderSyncProcessor({
       schema,
@@ -158,6 +167,7 @@ export const makeLeaderThreadLayer = ({
       initialSyncState: getInitialSyncState({ dbEventlog, dbState, dbEventlogMissing }),
       initialBlockingSyncContext,
       onError: syncOptions?.onSyncError ?? 'ignore',
+      onBackendIdMismatch: syncOptions?.onBackendIdMismatch ?? 'reset',
       livePull: syncOptions?.livePull ?? true,
       params: {
         ...omitUndefineds({
@@ -174,13 +184,14 @@ export const makeLeaderThreadLayer = ({
       Effect.acquireRelease(Queue.shutdown),
     )
 
-    const devtoolsContext = devtoolsOptions.enabled
-      ? {
-          enabled: true as const,
-          syncBackendLatch: yield* Effect.makeLatch(true),
-          syncBackendLatchState: yield* SubscriptionRef.make<{ latchClosed: boolean }>({ latchClosed: false }),
-        }
-      : { enabled: false as const }
+    const devtoolsContext =
+      devtoolsOptions.enabled === true
+        ? {
+            enabled: true as const,
+            syncBackendLatch: yield* Effect.makeLatch(true),
+            syncBackendLatchState: yield* SubscriptionRef.make<{ latchClosed: boolean }>({ latchClosed: false }),
+          }
+        : { enabled: false as const }
 
     const networkStatus = yield* makeNetworkStatusSubscribable({ syncBackend, devtoolsContext })
 
@@ -239,7 +250,7 @@ const hasStateTables = (db: SqliteDb) => {
 
 const isSubsetOf = (a: Set<string>, b: Set<string>): boolean => {
   for (const item of a) {
-    if (!b.has(item)) {
+    if (b.has(item) === false) {
       return false
     }
   }
@@ -256,13 +267,11 @@ const getInitialSyncState = ({
   dbState: SqliteDb
   dbEventlogMissing: boolean
 }) => {
-  const initialBackendHead = dbEventlogMissing
-    ? EventSequenceNumber.Client.ROOT.global
-    : Eventlog.getBackendHeadFromDb(dbEventlog)
+  const initialBackendHead =
+    dbEventlogMissing === true ? EventSequenceNumber.Client.ROOT.global : Eventlog.getBackendHeadFromDb(dbEventlog)
 
-  const initialLocalHead = dbEventlogMissing
-    ? EventSequenceNumber.Client.ROOT
-    : Eventlog.getClientHeadFromDb(dbEventlog)
+  const initialLocalHead =
+    dbEventlogMissing === true ? EventSequenceNumber.Client.ROOT : Eventlog.getClientHeadFromDb(dbEventlog)
 
   if (initialBackendHead > initialLocalHead.global) {
     return shouldNeverHappen(
@@ -277,17 +286,18 @@ const getInitialSyncState = ({
       client: EventSequenceNumber.Client.DEFAULT,
       rebaseGeneration: EventSequenceNumber.Client.REBASE_GENERATION_DEFAULT,
     },
-    pending: dbEventlogMissing
-      ? []
-      : Eventlog.getEventsSince({
-          dbEventlog,
-          dbState,
-          since: {
-            global: initialBackendHead,
-            client: EventSequenceNumber.Client.DEFAULT,
-            rebaseGeneration: initialLocalHead.rebaseGeneration,
-          },
-        }),
+    pending:
+      dbEventlogMissing === true
+        ? []
+        : Eventlog.getEventsSince({
+            dbEventlog,
+            dbState,
+            since: {
+              global: initialBackendHead,
+              client: EventSequenceNumber.Client.DEFAULT,
+              rebaseGeneration: initialLocalHead.rebaseGeneration,
+            },
+          }),
   })
 }
 
@@ -352,7 +362,7 @@ const bootLeaderThread = ({
   devtoolsOptions: DevtoolsOptions
 }): Effect.Effect<
   LeaderThreadCtx['Type']['initialState'],
-  UnknownError | SqliteError | IsOfflineError | InvalidPullError | MaterializerHashMismatchError,
+  UnknownError | MaterializerHashMismatchError,
   LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient
 > =>
   Effect.gen(function* () {

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,
@@ -69,7 +73,7 @@ export const makeMaterializeEvent = ({
           event: { decoded: undefined, encoded: eventEncoded },
         })
 
-        const materializerHash = isDevEnv() ? Option.some(hashMaterializerResults(execArgsArr)) : Option.none()
+        const materializerHash = isDevEnv() === true ? Option.some(hashMaterializerResults(execArgsArr)) : Option.none()
 
         if (
           materializerHash._tag === 'Some' &&
@@ -115,7 +119,7 @@ export const makeMaterializeEvent = ({
               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,
+              debug: LS_DEV === true ? execArgsArr : null,
             },
           }),
         )
@@ -140,11 +144,11 @@ export const makeMaterializeEvent = ({
         }
 
         return {
-          sessionChangeset: changeset
+          sessionChangeset: changeset !== undefined
             ? {
                 _tag: 'sessionChangeset' as const,
                 data: changeset,
-                debug: LS_DEV ? execArgsArr : null,
+                debug: LS_DEV === true ? execArgsArr : null,
               }
             : { _tag: 'no-op' as const },
           hash: materializerHash,

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

@@ -31,7 +31,7 @@ export const recreateDb = ({
 }): Effect.Effect<{ migrationsReport: MigrationsReport }, UnknownError | MaterializeError | SqliteError> =>
   Effect.gen(function* () {
     const migrationOptions = schema.state.sqlite.migrations
-    let migrationsReport: MigrationsReport
+    let migrationsReport: MigrationsReport = { migrations: [] }
 
     yield* Effect.addFinalizer(
       Effect.fn('recreateDb:finalizer')(function* (ex) {