@livestore/common 0.4.0-dev.0 → 0.4.0-dev.10

package/src/schema/state/sqlite/table-def.ts

@@ -1,13 +1,16 @@
-import { type Nullable, shouldNeverHappen, type Writeable } from '@livestore/utils'
+import { type Nullable, shouldNeverHappen } from '@livestore/utils'
 import { Option, Schema, SchemaAST, type Types } from '@livestore/utils/effect'
 
-import { AutoIncrement, ColumnType, Default, PrimaryKeyId, Unique } from './column-annotations.ts'
+import { getColumnDefForSchema, schemaFieldsToColumns } from './column-def.ts'
 import { SqliteDsl } from './db-schema/mod.ts'
 import type { QueryBuilder } from './query-builder/mod.ts'
 import { makeQueryBuilder, QueryBuilderAstSymbol, QueryBuilderTypeId } from './query-builder/mod.ts'
 
 export const { blob, boolean, column, datetime, integer, isColumnDefinition, json, real, text } = SqliteDsl
 
+// Re-export the column definition function
+export { getColumnDefForSchema }
+
 export type StateType = 'singleton' | 'dynamic'
 
 export type DefaultSqliteTableDef = SqliteDsl.TableDefinition<string, SqliteDsl.Columns>
@@ -218,7 +221,7 @@ export function table<
     ) as SqliteDsl.Columns
     additionalIndexes = []
   } else if ('schema' in args) {
-    const result = schemaFieldsToColumns(SchemaAST.getPropertySignatures(args.schema.ast))
+    const result = schemaFieldsToColumns(Schema.getResolvedPropertySignatures(args.schema))
     columns = result.columns
 
     // We'll set tableName first, then use it for index names
@@ -378,12 +381,13 @@ export declare namespace SchemaToColumns {
   export type ColumnDefForType<TEncoded, TType> = SqliteDsl.ColumnDefinition<TEncoded, TType>
 
   // Create columns type from schema Type and Encoded
-  export type FromTypes<TType, TEncoded> = TType extends Record<string, any>
-    ? TEncoded extends Record<string, any>
-      ? {
-          [K in keyof TType & keyof TEncoded]: ColumnDefForType<TEncoded[K], TType[K]>
-        }
-      : SqliteDsl.Columns
+  export type FromTypes<TType, TEncoded> = TEncoded extends Record<string, any>
+    ? {
+        [K in keyof TEncoded]-?: ColumnDefForType<
+          TEncoded[K],
+          TType extends Record<string, any> ? (K extends keyof TType ? TType[K] : TEncoded[K]) : TEncoded[K]
+        >
+      }
     : SqliteDsl.Columns
 }
 
@@ -398,256 +402,3 @@ export declare namespace TableDefInput {
     SchemaToColumns.FromTypes<TType, TEncoded>
   >
 }
-
-/**
- * Checks if a property signature has a specific annotation, checking both
- * the property signature itself and its type AST.
- */
-const hasPropertyAnnotation = <T>(
-  propertySignature: SchemaAST.PropertySignature,
-  annotationId: symbol,
-): Option.Option<T> => {
-  // When using Schema.optional(Schema.String).pipe(withPrimaryKey) in a struct,
-  // the annotation ends up on a PropertySignatureDeclaration, not the Union type
-  // Check if this is a PropertySignatureDeclaration with annotations
-  if ('annotations' in propertySignature && propertySignature.annotations) {
-    const annotation = SchemaAST.getAnnotation<T>(annotationId)(propertySignature as any)
-    if (Option.isSome(annotation)) {
-      return annotation
-    }
-  }
-
-  // Otherwise check the type AST
-  return SchemaAST.getAnnotation<T>(annotationId)(propertySignature.type)
-}
-
-/**
- * Maps schema property signatures to SQLite column definitions.
- * Returns both columns and unique column names for index creation.
- */
-const schemaFieldsToColumns = (
-  propertySignatures: ReadonlyArray<SchemaAST.PropertySignature>,
-): { columns: SqliteDsl.Columns; uniqueColumns: string[] } => {
-  const columns: SqliteDsl.Columns = {}
-  const uniqueColumns: string[] = []
-
-  for (const prop of propertySignatures) {
-    if (typeof prop.name === 'string') {
-      // Create a schema from the AST
-      const fieldSchema = Schema.make(prop.type)
-      // Check if property has primary key annotation
-      const hasPrimaryKey = hasPropertyAnnotation<boolean>(prop, PrimaryKeyId).pipe(Option.getOrElse(() => false))
-      // Check if property has unique annotation
-      const hasUnique = hasPropertyAnnotation<boolean>(prop, Unique).pipe(Option.getOrElse(() => false))
-
-      columns[prop.name] = schemaFieldToColumn(fieldSchema, prop, hasPrimaryKey)
-
-      if (hasUnique) {
-        uniqueColumns.push(prop.name)
-      }
-    }
-  }
-
-  return { columns, uniqueColumns }
-}
-
-/**
- * Converts a schema field and its property signature to a SQLite column definition.
- */
-const schemaFieldToColumn = (
-  fieldSchema: Schema.Schema.AnyNoContext,
-  propertySignature: SchemaAST.PropertySignature,
-  forceHasPrimaryKey?: boolean,
-): SqliteDsl.ColumnDefinition.Any => {
-  // Determine column type based on schema type
-  const columnDef = getColumnDefForSchema(fieldSchema, propertySignature)
-
-  // Create a new object with appropriate properties
-  const result: Writeable<SqliteDsl.ColumnDefinition.Any> = {
-    columnType: columnDef.columnType,
-    schema: columnDef.schema,
-    default: columnDef.default,
-    nullable: columnDef.nullable,
-    primaryKey: columnDef.primaryKey,
-    autoIncrement: columnDef.autoIncrement,
-  }
-
-  // Set primaryKey property explicitly
-  if (forceHasPrimaryKey || columnDef.primaryKey) {
-    result.primaryKey = true
-  } else {
-    result.primaryKey = false
-  }
-
-  // Check for invalid primary key + nullable combination
-  if (result.primaryKey && (propertySignature.isOptional || columnDef.nullable)) {
-    return shouldNeverHappen(
-      `Primary key columns cannot be nullable. Found nullable primary key for column. ` +
-        `Either remove the primary key annotation or use a non-nullable schema.`,
-    )
-  }
-
-  // Set nullable property explicitly
-  if (propertySignature.isOptional) {
-    result.nullable = true
-  } else if (columnDef.nullable) {
-    result.nullable = true
-  } else {
-    result.nullable = false
-  }
-
-  // Only add autoIncrement if it's true
-  if (columnDef.autoIncrement) {
-    result.autoIncrement = true
-  }
-
-  return result as SqliteDsl.ColumnDefinition.Any
-}
-
-/**
- * Maps a schema to a SQLite column definition, respecting column annotations.
- */
-export const getColumnDefForSchema = (
-  schema: Schema.Schema.AnyNoContext,
-  propertySignature?: SchemaAST.PropertySignature,
-): SqliteDsl.ColumnDefinition.Any => {
-  const ast = schema.ast
-
-  // Check for annotations
-  const hasPrimaryKey = propertySignature
-    ? hasPropertyAnnotation<boolean>(propertySignature, PrimaryKeyId).pipe(Option.getOrElse(() => false))
-    : SchemaAST.getAnnotation<boolean>(PrimaryKeyId)(ast).pipe(Option.getOrElse(() => false))
-
-  const hasAutoIncrement = propertySignature
-    ? hasPropertyAnnotation<boolean>(propertySignature, AutoIncrement).pipe(Option.getOrElse(() => false))
-    : SchemaAST.getAnnotation<boolean>(AutoIncrement)(ast).pipe(Option.getOrElse(() => false))
-
-  const defaultValue = propertySignature
-    ? hasPropertyAnnotation<unknown>(propertySignature, Default)
-    : SchemaAST.getAnnotation<unknown>(Default)(ast)
-
-  /** Adds annotations to a column definition if they are present. */
-  const withAnnotationsIfNeeded = (columnDef: SqliteDsl.ColumnDefinition.Any): SqliteDsl.ColumnDefinition.Any => {
-    const result = { ...columnDef }
-
-    if (hasPrimaryKey) {
-      result.primaryKey = true
-    }
-
-    if (hasAutoIncrement) {
-      result.autoIncrement = true
-    }
-
-    if (Option.isSome(defaultValue)) {
-      result.default = Option.some(defaultValue.value)
-    }
-
-    return result
-  }
-
-  // Check for custom column type annotation
-  const columnTypeAnnotation = SchemaAST.getAnnotation<SqliteDsl.FieldColumnType>(ColumnType)(ast)
-  if (Option.isSome(columnTypeAnnotation)) {
-    const columnType = columnTypeAnnotation.value
-    let columnDef: SqliteDsl.ColumnDefinition.Any
-    switch (columnType) {
-      case 'text':
-        columnDef = SqliteDsl.text()
-        break
-      case 'integer':
-        columnDef = SqliteDsl.integer()
-        break
-      case 'real':
-        columnDef = SqliteDsl.real()
-        break
-      case 'blob':
-        columnDef = SqliteDsl.blob()
-        break
-      default:
-        return shouldNeverHappen(`Unsupported column type annotation: ${columnType}`)
-    }
-
-    return withAnnotationsIfNeeded(columnDef)
-  }
-
-  // Check for refinements (e.g., Schema.Int)
-  if (SchemaAST.isRefinement(ast)) {
-    // Check if this is specifically Schema.Int by looking at the identifier annotation
-    const identifier = SchemaAST.getIdentifierAnnotation(ast).pipe(Option.getOrElse(() => ''))
-    if (identifier === 'Int') {
-      return withAnnotationsIfNeeded(SqliteDsl.integer())
-    }
-    // For other refinements, check the underlying type
-    return getColumnDefForSchema(Schema.make(ast.from), propertySignature)
-  }
-
-  // Check for string types
-  if (SchemaAST.isStringKeyword(ast)) {
-    return withAnnotationsIfNeeded(SqliteDsl.text())
-  }
-
-  // Check for number types
-  if (SchemaAST.isNumberKeyword(ast)) {
-    return withAnnotationsIfNeeded(SqliteDsl.real())
-  }
-
-  // Check for boolean types
-  if (SchemaAST.isBooleanKeyword(ast)) {
-    return withAnnotationsIfNeeded(SqliteDsl.boolean())
-  }
-
-  // Check for unions (like optional or nullable)
-  if (SchemaAST.isUnion(ast)) {
-    // Check if this union contains null or undefined (making it nullable/optional)
-    let hasNull = false
-    let hasUndefined = false
-    let nonNullableType: SchemaAST.AST | undefined
-
-    for (const type of ast.types) {
-      if (SchemaAST.isUndefinedKeyword(type)) {
-        hasUndefined = true
-      } else if (SchemaAST.isLiteral(type) && type.literal === null) {
-        hasNull = true
-      } else {
-        nonNullableType = type
-      }
-    }
-
-    // If we found a non-nullable type, use it for the column definition
-    if (nonNullableType) {
-      const innerSchema = Schema.make(nonNullableType)
-      const innerColumnDef = getColumnDefForSchema(innerSchema, propertySignature)
-
-      // If the union contains null or undefined, mark as nullable
-      if (hasNull || hasUndefined) {
-        return withAnnotationsIfNeeded({
-          ...innerColumnDef,
-          nullable: true,
-        })
-      }
-
-      return withAnnotationsIfNeeded(innerColumnDef)
-    }
-  }
-
-  // Check for Date types
-  if (SchemaAST.isTransformation(ast)) {
-    // Try to map the transformation's target type
-    return getColumnDefForSchema(Schema.make(ast.to), propertySignature)
-  }
-
-  // Check for literal types
-  if (SchemaAST.isLiteral(ast)) {
-    const value = ast.literal
-    if (typeof value === 'string') {
-      return withAnnotationsIfNeeded(SqliteDsl.text())
-    } else if (typeof value === 'number') {
-      return withAnnotationsIfNeeded(SqliteDsl.real())
-    } else if (typeof value === 'boolean') {
-      return withAnnotationsIfNeeded(SqliteDsl.boolean())
-    }
-  }
-
-  // Default to JSON column for complex types
-  return withAnnotationsIfNeeded(SqliteDsl.json({ schema }))
-}

package/src/schema/unknown-events.ts

@@ -0,0 +1,131 @@
+import { Effect } from '@livestore/utils/effect'
+
+import { UnknownEventError } from '../errors.ts'
+import type { EventDef, Materializer } from './EventDef.ts'
+import type * as LiveStoreEvent from './LiveStoreEvent.ts'
+import type { LiveStoreSchema } from './schema.ts'
+
+export type UnknownEventContext = {
+  readonly event: Pick<LiveStoreEvent.AnyEncoded, 'name' | 'args' | 'seqNum' | 'clientId' | 'sessionId'>
+  readonly reason: 'event-definition-missing' | 'materializer-missing'
+  readonly operation: string
+}
+
+export namespace UnknownEvents {
+  export type HandlingStrategy = 'warn' | 'fail' | 'ignore' | 'callback'
+
+  export type Callback = (
+    context: UnknownEventContext,
+    error: UnknownEventError,
+  ) => Effect.SyncOrPromiseOrEffect<void, unknown, never>
+
+  export type HandlingConfig =
+    | { readonly strategy: 'warn' }
+    | { readonly strategy: 'ignore' }
+    | { readonly strategy: 'fail' }
+    | { readonly strategy: 'callback'; readonly onUnknownEvent: Callback }
+
+  export type Reason = UnknownEventContext['reason']
+
+  export type ResolveContext = Omit<UnknownEventContext, 'reason'>
+
+  export type Resolved =
+    | {
+        readonly _tag: 'known'
+        readonly eventDef: EventDef.AnyWithoutFn
+        readonly materializer: Materializer
+      }
+    | {
+        readonly _tag: 'unknown'
+        readonly reason: Reason
+      }
+}
+
+const DEFAULT_UNKNOWN_EVENT_HANDLING: UnknownEvents.HandlingConfig = { strategy: 'warn' }
+
+export const normalizeUnknownEventHandling = (
+  input: UnknownEvents.HandlingConfig | undefined,
+): UnknownEvents.HandlingConfig => input ?? DEFAULT_UNKNOWN_EVENT_HANDLING
+
+const handleUnknownEvent = ({
+  schema,
+  context,
+}: {
+  schema: LiveStoreSchema
+  context: UnknownEventContext
+}): Effect.Effect<void, UnknownEventError> =>
+  Effect.gen(function* () {
+    const config = schema.unknownEventHandling
+    const error = new UnknownEventError(context)
+
+    switch (config.strategy) {
+      case 'fail': {
+        return yield* Effect.fail(error)
+      }
+      case 'warn': {
+        yield* Effect.logWarning('@livestore/common:schema:unknown-event', context)
+        return
+      }
+      case 'ignore': {
+        return
+      }
+      case 'callback': {
+        const callback = config.onUnknownEvent
+
+        yield* Effect.tryAll<void>(() => callback(context, error)).pipe(
+          Effect.catchAll((cause) =>
+            Effect.logWarning('@livestore/common:schema:unknown-event:callback-error', {
+              event: context.event,
+              reason: context.reason,
+              operation: context.operation,
+              cause,
+            }),
+          ),
+        )
+        return
+      }
+    }
+  })
+
+/**
+ * Resolves the runtime event definition + materializer for a given event name.
+ *
+ * Behaviour is intentionally split across the result and error channels:
+ * - For `'fail'` handling, we surface an `UnknownEventError` via the failure channel so
+ *   callers can convert it into the appropriate domain error (for example `MaterializeError`).
+ * - For all other strategies (`warn`, `ignore`, `callback`) we succeed with an
+ *   `{ _tag: 'unknown' }` value, signalling that the caller should skip the event while
+ *   continuing normal processing.
+ */
+export const resolveEventDef = (
+  schema: LiveStoreSchema,
+  context: UnknownEvents.ResolveContext,
+): Effect.Effect<UnknownEvents.Resolved, UnknownEventError> =>
+  Effect.gen(function* () {
+    const eventName = context.event.name
+    const eventDef = schema.eventsDefsMap.get(eventName)
+    if (eventDef === undefined) {
+      yield* handleUnknownEvent({
+        schema,
+        context: {
+          event: context.event,
+          reason: 'event-definition-missing',
+          operation: context.operation,
+        },
+      })
+      return { _tag: 'unknown', reason: 'event-definition-missing' }
+    }
+    const materializer = schema.state.materializers.get(eventName)
+    if (materializer === undefined) {
+      yield* handleUnknownEvent({
+        schema,
+        context: {
+          event: context.event,
+          reason: 'materializer-missing',
+          operation: context.operation,
+        },
+      })
+      return { _tag: 'unknown', reason: 'materializer-missing' }
+    }
+    return { _tag: 'known', eventDef, materializer }
+  })

package/src/sql-queries/sql-query-builder.ts

@@ -1,3 +1,4 @@
+import { omitUndefineds } from '@livestore/utils'
 import type { SqliteDsl } from '../schema/state/sqlite/db-schema/mod.ts'
 import type { BindValues } from './sql-queries.ts'
 import * as SqlQueries from './sql-queries.ts'
@@ -16,7 +17,7 @@ export const makeSqlQueryBuilder = <TSchema extends SqliteDsl.DbSchema>(schema:
     limit?: number
   }): [string, BindValues, TTableName] => {
     const columns = schema[tableName]!.columns
-    const [stmt, bindValues] = SqlQueries.findManyRows({ columns, tableName, where, limit })
+    const [stmt, bindValues] = SqlQueries.findManyRows({ columns, tableName, where, ...omitUndefineds({ limit }) })
     return [stmt, bindValues, tableName]
   }
 

package/src/sync/ClientSessionSyncProcessor.ts

@@ -13,12 +13,13 @@ import {
   Stream,
   Subscribable,
 } from '@livestore/utils/effect'
-import * as otel from '@opentelemetry/api'
+import type * as otel from '@opentelemetry/api'
 
-import { type ClientSession, SyncError, type UnexpectedError } from '../adapter-types.ts'
+import { type ClientSession, UnexpectedError } from '../adapter-types.ts'
+import type { MaterializeError } from '../errors.ts'
 import * as EventSequenceNumber from '../schema/EventSequenceNumber.ts'
 import * as LiveStoreEvent from '../schema/LiveStoreEvent.ts'
-import { getEventDef, type LiveStoreSchema } from '../schema/mod.ts'
+import type { LiveStoreSchema } from '../schema/mod.ts'
 import * as SyncState from './syncstate.ts'
 
 /**
@@ -51,16 +52,19 @@ export const makeClientSessionSyncProcessor = ({
   clientSession: ClientSession
   runtime: Runtime.Runtime<Scope.Scope>
   materializeEvent: (
-    eventDecoded: LiveStoreEvent.AnyDecoded,
-    options: { otelContext: otel.Context; withChangeset: boolean; materializerHashLeader: Option.Option<number> },
-  ) => {
-    writeTables: Set<string>
-    sessionChangeset:
-      | { _tag: 'sessionChangeset'; data: Uint8Array<ArrayBuffer>; debug: any }
-      | { _tag: 'no-op' }
-      | { _tag: 'unset' }
-    materializerHash: Option.Option<number>
-  }
+    eventEncoded: LiveStoreEvent.EncodedWithMeta,
+    options: { withChangeset: boolean; materializerHashLeader: Option.Option<number> },
+  ) => Effect.Effect<
+    {
+      writeTables: Set<string>
+      sessionChangeset:
+        | { _tag: 'sessionChangeset'; data: Uint8Array<ArrayBuffer>; debug: any }
+        | { _tag: 'no-op' }
+        | { _tag: 'unset' }
+      materializerHash: Option.Option<number>
+    },
+    MaterializeError
+  >
   rollback: (changeset: Uint8Array<ArrayBuffer>) => void
   refreshTables: (tables: Set<string>) => void
   span: otel.Span
@@ -91,23 +95,26 @@ export const makeClientSessionSyncProcessor = ({
     }),
   }
 
-  /** Only used for debugging / observability, it's not relied upon for correctness of the sync processor. */
+  /** Only used for debugging / observability / testing, it's not relied upon for correctness of the sync processor. */
   const syncStateUpdateQueue = Queue.unbounded<SyncState.SyncState>().pipe(Effect.runSync)
   const isClientEvent = (eventEncoded: LiveStoreEvent.EncodedWithMeta) =>
-    getEventDef(schema, eventEncoded.name).eventDef.options.clientOnly
+    schema.eventsDefsMap.get(eventEncoded.name)?.options.clientOnly ?? false
 
   /** We're queuing push requests to reduce the number of messages sent to the leader by batching them */
   const leaderPushQueue = BucketQueue.make<LiveStoreEvent.EncodedWithMeta>().pipe(Effect.runSync)
 
-  const push: ClientSessionSyncProcessor['push'] = (batch, { otelContext }) => {
+  const push: ClientSessionSyncProcessor['push'] = Effect.fn('client-session-sync-processor:push')(function* (batch) {
     // TODO validate batch
 
     let baseEventSequenceNumber = syncStateRef.current.localHead
     const encodedEventDefs = batch.map(({ name, args }) => {
-      const eventDef = getEventDef(schema, name)
+      const eventDef = schema.eventsDefsMap.get(name)
+      if (eventDef === undefined) {
+        return shouldNeverHappen(`No event definition found for \`${name}\`.`)
+      }
       const nextNumPair = EventSequenceNumber.nextPair({
         seqNum: baseEventSequenceNumber,
-        isClient: eventDef.eventDef.options.clientOnly,
+        isClient: eventDef.options.clientOnly,
       })
       baseEventSequenceNumber = nextNumPair.seqNum
       return new LiveStoreEvent.EncodedWithMeta(
@@ -128,33 +135,35 @@ export const makeClientSessionSyncProcessor = ({
       isEqualEvent: LiveStoreEvent.isEqualEncoded,
     })
 
+    yield* Effect.annotateCurrentSpan({
+      batchSize: encodedEventDefs.length,
+      mergeResultTag: mergeResult._tag,
+      eventCounts: encodedEventDefs.reduce<Record<string, number>>((acc, event) => {
+        acc[event.name] = (acc[event.name] ?? 0) + 1
+        return acc
+      }, {}),
+      ...(TRACE_VERBOSE && { mergeResult: JSON.stringify(mergeResult) }),
+    })
+
     if (mergeResult._tag === 'unexpected-error') {
       return shouldNeverHappen('Unexpected error in client-session-sync-processor', mergeResult.message)
     }
 
-    span.addEvent('local-push', {
-      batchSize: encodedEventDefs.length,
-      mergeResult: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
-    })
-
     if (mergeResult._tag !== 'advance') {
       return shouldNeverHappen(`Expected advance, got ${mergeResult._tag}`)
     }
 
     syncStateRef.current = mergeResult.newSyncState
-    syncStateUpdateQueue.offer(mergeResult.newSyncState).pipe(Effect.runSync)
+    yield* syncStateUpdateQueue.offer(mergeResult.newSyncState)
 
     // Materialize events to state
     const writeTables = new Set<string>()
     for (const event of mergeResult.newEvents) {
-      // TODO avoid encoding and decoding here again
-      const decodedEventDef = Schema.decodeSync(eventSchema)(event)
       const {
         writeTables: newWriteTables,
         sessionChangeset,
         materializerHash,
-      } = materializeEvent(decodedEventDef, {
-        otelContext,
+      } = yield* materializeEvent(event, {
         withChangeset: true,
         materializerHashLeader: Option.none(),
       })
@@ -167,10 +176,10 @@ export const makeClientSessionSyncProcessor = ({
 
     // Trigger push to leader
     // console.debug('pushToLeader', encodedEventDefs.length, ...encodedEventDefs.map((_) => _.toJSON()))
-    BucketQueue.offerAll(leaderPushQueue, encodedEventDefs).pipe(Effect.runSync)
+    yield* BucketQueue.offerAll(leaderPushQueue, encodedEventDefs)
 
     return { writeTables }
-  }
+  })
 
   const debugInfo = {
     rebaseCount: 0,
@@ -178,8 +187,6 @@ export const makeClientSessionSyncProcessor = ({
     rejectCount: 0,
   }
 
-  const otelContext = otel.trace.setSpan(otel.context.active(), span)
-
   const boot: ClientSessionSyncProcessor['boot'] = Effect.gen(function* () {
     if (confirmUnsavedChanges && typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
       const onBeforeUnload = (event: BeforeUnloadEvent) => {
@@ -229,13 +236,12 @@ export const makeClientSessionSyncProcessor = ({
           })
 
           if (mergeResult._tag === 'unexpected-error') {
-            return yield* new SyncError({ cause: mergeResult.message })
+            return yield* new UnexpectedError({ cause: mergeResult.message })
           } else if (mergeResult._tag === 'reject') {
             return shouldNeverHappen('Unexpected reject in client-session-sync-processor', mergeResult)
           }
 
           syncStateRef.current = mergeResult.newSyncState
-          yield* syncStateUpdateQueue.offer(mergeResult.newSyncState)
 
           if (mergeResult._tag === 'rebase') {
             span.addEvent('merge:pull:rebase', {
@@ -244,7 +250,6 @@ export const makeClientSessionSyncProcessor = ({
               newEventsCount: mergeResult.newEvents.length,
               rollbackCount: mergeResult.rollbackEvents.length,
               res: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
-              rebaseGeneration: mergeResult.newSyncState.localHead.rebaseGeneration,
             })
 
             debugInfo.rebaseCount++
@@ -294,18 +299,19 @@ export const makeClientSessionSyncProcessor = ({
             debugInfo.advanceCount++
           }
 
-          if (mergeResult.newEvents.length === 0) return
+          if (mergeResult.newEvents.length === 0) {
+            // If there are no new events, we need to update the sync state as well
+            yield* syncStateUpdateQueue.offer(mergeResult.newSyncState)
+            return
+          }
 
           const writeTables = new Set<string>()
           for (const event of mergeResult.newEvents) {
-            // TODO apply changeset if available (will require tracking of write tables as well)
-            const decodedEventDef = Schema.decodeSync(eventSchema)(event)
             const {
               writeTables: newWriteTables,
               sessionChangeset,
               materializerHash,
-            } = materializeEvent(decodedEventDef, {
-              otelContext,
+            } = yield* materializeEvent(event, {
               withChangeset: true,
               materializerHashLeader: event.meta.materializerHashLeader,
             })
@@ -318,6 +324,9 @@ export const makeClientSessionSyncProcessor = ({
           }
 
           refreshTables(writeTables)
+
+          // We're only triggering the sync state update after all events have been materialized
+          yield* syncStateUpdateQueue.offer(mergeResult.newSyncState)
         }).pipe(
           Effect.tapCauseLogPretty,
           Effect.catchAllCause((cause) => clientSession.shutdown(Exit.failCause(cause))),
@@ -364,10 +373,7 @@ export const makeClientSessionSyncProcessor = ({
 export interface ClientSessionSyncProcessor {
   push: (
     batch: ReadonlyArray<LiveStoreEvent.PartialAnyDecoded>,
-    options: { otelContext: otel.Context },
-  ) => {
-    writeTables: Set<string>
-  }
+  ) => Effect.Effect<{ writeTables: Set<string> }, MaterializeError>
   boot: Effect.Effect<void, UnexpectedError, Scope.Scope>
   /**
    * Only used for debugging / observability.
@@ -388,11 +394,11 @@ const SIMULATION_ENABLED = true
 // Warning: High values for the simulation params can lead to very long test runs since those get multiplied with the number of events
 export const ClientSessionSyncProcessorSimulationParams = Schema.Struct({
   pull: Schema.Struct({
-    '1_before_leader_push_fiber_interrupt': Schema.Int.pipe(Schema.between(0, 25)),
-    '2_before_leader_push_queue_clear': Schema.Int.pipe(Schema.between(0, 25)),
-    '3_before_rebase_rollback': Schema.Int.pipe(Schema.between(0, 25)),
-    '4_before_leader_push_queue_offer': Schema.Int.pipe(Schema.between(0, 25)),
-    '5_before_leader_push_fiber_run': Schema.Int.pipe(Schema.between(0, 25)),
+    '1_before_leader_push_fiber_interrupt': Schema.Int.pipe(Schema.between(0, 15)),
+    '2_before_leader_push_queue_clear': Schema.Int.pipe(Schema.between(0, 15)),
+    '3_before_rebase_rollback': Schema.Int.pipe(Schema.between(0, 15)),
+    '4_before_leader_push_queue_offer': Schema.Int.pipe(Schema.between(0, 15)),
+    '5_before_leader_push_fiber_run': Schema.Int.pipe(Schema.between(0, 15)),
   }),
 })
 type ClientSessionSyncProcessorSimulationParams = typeof ClientSessionSyncProcessorSimulationParams.Type