@livestore/common 0.3.0-dev.16 → 0.3.0-dev.17

package/src/sync/ClientSessionSyncProcessor.ts

@@ -1,6 +1,6 @@
 import { LS_DEV, shouldNeverHappen, TRACE_VERBOSE } from '@livestore/utils'
 import type { Runtime, Scope } from '@livestore/utils/effect'
-import { Effect, Queue, Schema, Stream, Subscribable } from '@livestore/utils/effect'
+import { BucketQueue, Effect, FiberHandle, Queue, Schema, Stream, Subscribable } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 
 import type { ClientSession, UnexpectedError } from '../adapter-types.js'
@@ -26,6 +26,7 @@ export const makeClientSessionSyncProcessor = ({
   rollback,
   refreshTables,
   span,
+  params,
 }: {
   schema: LiveStoreSchema
   clientSession: ClientSession
@@ -40,6 +41,9 @@ export const makeClientSessionSyncProcessor = ({
   rollback: (changeset: Uint8Array) => void
   refreshTables: (tables: Set<string>) => void
   span: otel.Span
+  params: {
+    leaderPushBatchSize: number
+  }
 }): ClientSessionSyncProcessor => {
   const mutationEventSchema = MutationEvent.makeMutationEventSchemaMemo(schema)
 
@@ -59,6 +63,9 @@ export const makeClientSessionSyncProcessor = ({
     return mutationDef.options.clientOnly
   }
 
+  /** We're queuing push requests to reduce the number of messages sent to the leader by batching them */
+  const leaderPushQueue = BucketQueue.make<MutationEvent.EncodedWithMeta>().pipe(Effect.runSync)
+
   const push: ClientSessionSyncProcessor['push'] = (batch, { otelContext }) => {
     // TODO validate batch
 
@@ -84,6 +91,10 @@ export const makeClientSessionSyncProcessor = ({
       isEqualEvent: MutationEvent.isEqualEncoded,
     })
 
+    if (updateResult._tag === 'unexpected-error') {
+      return shouldNeverHappen('Unexpected error in client-session-sync-processor', updateResult.cause)
+    }
+
     span.addEvent('local-push', {
       batchSize: encodedMutationEvents.length,
       updateResult: TRACE_VERBOSE ? JSON.stringify(updateResult) : undefined,
@@ -108,13 +119,17 @@ export const makeClientSessionSyncProcessor = ({
     }
 
     // console.debug('pushToLeader', encodedMutationEvents.length, ...encodedMutationEvents.map((_) => _.toJSON()))
-    clientSession.leaderThread.mutations
-      .push(encodedMutationEvents)
-      .pipe(Effect.tapCauseLogPretty, Effect.provide(runtime), Effect.runFork)
+    BucketQueue.offerAll(leaderPushQueue, encodedMutationEvents).pipe(Effect.runSync)
 
     return { writeTables }
   }
 
+  const debugInfo = {
+    rebaseCount: 0,
+    advanceCount: 0,
+    rejectCount: 0,
+  }
+
   const otelContext = otel.trace.setSpan(otel.context.active(), span)
 
   const boot: ClientSessionSyncProcessor['boot'] = Effect.gen(function* () {
@@ -133,6 +148,20 @@ export const makeClientSessionSyncProcessor = ({
       )
     }
 
+    const leaderPushingFiberHandle = yield* FiberHandle.make()
+
+    const backgroundLeaderPushing = Effect.gen(function* () {
+      const batch = yield* BucketQueue.takeBetween(leaderPushQueue, 1, params.leaderPushBatchSize)
+      yield* clientSession.leaderThread.mutations.push(batch).pipe(
+        Effect.catchTag('LeaderAheadError', () => {
+          debugInfo.rejectCount++
+          return BucketQueue.clear(leaderPushQueue)
+        }),
+      )
+    }).pipe(Effect.forever, Effect.interruptible, Effect.tapCauseLogPretty)
+
+    yield* FiberHandle.run(leaderPushingFiberHandle, backgroundLeaderPushing)
+
     yield* clientSession.leaderThread.mutations.pull.pipe(
       Stream.tap(({ payload, remaining }) =>
         Effect.gen(function* () {
@@ -148,9 +177,10 @@ export const makeClientSessionSyncProcessor = ({
             isEqualEvent: MutationEvent.isEqualEncoded,
           })
 
-          if (updateResult._tag === 'reject') {
-            debugger
-            throw new Error('TODO: implement reject in client-session-sync-queue for pull')
+          if (updateResult._tag === 'unexpected-error') {
+            return yield* Effect.fail(updateResult.cause)
+          } else if (updateResult._tag === 'reject') {
+            return shouldNeverHappen('Unexpected reject in client-session-sync-processor', updateResult)
           }
 
           syncStateRef.current = updateResult.newSyncState
@@ -165,11 +195,21 @@ export const makeClientSessionSyncProcessor = ({
               res: TRACE_VERBOSE ? JSON.stringify(updateResult) : undefined,
               remaining,
             })
+
+            debugInfo.rebaseCount++
+
+            yield* FiberHandle.clear(leaderPushingFiberHandle)
+
+            // Reset the leader push queue since we're rebasing and will push again
+            yield* BucketQueue.clear(leaderPushQueue)
+
+            yield* FiberHandle.run(leaderPushingFiberHandle, backgroundLeaderPushing)
+
             if (LS_DEV) {
               Effect.logDebug(
                 'pull:rebase: rollback',
                 updateResult.eventsToRollback.length,
-                ...updateResult.eventsToRollback.map((_) => _.toJSON()),
+                ...updateResult.eventsToRollback.slice(0, 10).map((_) => _.toJSON()),
               ).pipe(Effect.provide(runtime), Effect.runSync)
             }
 
@@ -181,9 +221,7 @@ export const makeClientSessionSyncProcessor = ({
               }
             }
 
-            clientSession.leaderThread.mutations
-              .push(updateResult.newSyncState.pending)
-              .pipe(Effect.tapCauseLogPretty, Effect.provide(runtime), Effect.runFork)
+            yield* BucketQueue.offerAll(leaderPushQueue, updateResult.newSyncState.pending)
           } else {
             span.addEvent('pull:advance', {
               payloadTag: payload._tag,
@@ -192,6 +230,8 @@ export const makeClientSessionSyncProcessor = ({
               res: TRACE_VERBOSE ? JSON.stringify(updateResult) : undefined,
               remaining,
             })
+
+            debugInfo.advanceCount++
           }
 
           if (updateResult.newEvents.length === 0) return
@@ -208,10 +248,14 @@ export const makeClientSessionSyncProcessor = ({
           }
 
           refreshTables(writeTables)
-        }),
+        }).pipe(
+          Effect.tapCauseLogPretty,
+          Effect.catchAllCause((cause) => Effect.sync(() => clientSession.shutdown(cause))),
+        ),
       ),
       Stream.runDrain,
       Effect.forever, // NOTE Whenever the leader changes, we need to re-start the stream
+      Effect.withSpan('client-session-sync-processor:pull'),
       Effect.tapCauseLogPretty,
       Effect.forkScoped,
     )
@@ -228,6 +272,21 @@ export const makeClientSessionSyncProcessor = ({
       }),
       changes: Stream.fromQueue(syncStateUpdateQueue),
     }),
+    debug: {
+      print: () =>
+        Effect.gen(function* () {
+          console.log('debugInfo', debugInfo)
+          console.log('syncState', syncStateRef.current)
+          const pushQueueSize = yield* BucketQueue.size(leaderPushQueue)
+          console.log('pushQueueSize', pushQueueSize)
+          const pushQueueItems = yield* BucketQueue.peekAll(leaderPushQueue)
+          console.log(
+            'pushQueueItems',
+            pushQueueItems.map((_) => _.toJSON()),
+          )
+        }).pipe(Effect.provide(runtime), Effect.runSync),
+      debugInfo: () => debugInfo,
+    },
   } satisfies ClientSessionSyncProcessor
 }
 
@@ -239,6 +298,12 @@ export interface ClientSessionSyncProcessor {
     writeTables: Set<string>
   }
   boot: Effect.Effect<void, UnexpectedError, Scope.Scope>
-
   syncState: Subscribable.Subscribable<SyncState.SyncState>
+  debug: {
+    print: () => void
+    debugInfo: () => {
+      rebaseCount: number
+      advanceCount: number
+    }
+  }
 }

package/src/sync/sync.ts

@@ -67,13 +67,16 @@ export class InvalidPushError extends Schema.TaggedError<InvalidPushError>()('In
       minimumExpectedId: Schema.Number,
       providedId: Schema.Number,
     }),
-    Schema.TaggedStruct('LeaderAhead', {
-      minimumExpectedId: EventId.EventId,
-      providedId: EventId.EventId,
-    }),
   ),
 }) {}
 
 export class InvalidPullError extends Schema.TaggedError<InvalidPullError>()('InvalidPullError', {
   message: Schema.String,
 }) {}
+
+export class LeaderAheadError extends Schema.TaggedError<LeaderAheadError>()('LeaderAheadError', {
+  minimumExpectedId: EventId.EventId,
+  providedId: EventId.EventId,
+  /** Generation number the client session should use for subsequent pushes */
+  // nextGeneration: Schema.Number,
+}) {}

package/src/sync/syncstate.test.ts

@@ -17,7 +17,7 @@ class TestEvent extends MutationEvent.EncodedWithMeta {
       parentId: EventId.make(parentId),
       mutation: 'a',
       args: payload,
-      meta: {},
+
       clientId: 'static-local-id',
       sessionId: undefined,
     })
@@ -87,7 +87,7 @@ describe('syncstate', () => {
           }
           expect(result.newSyncState.upstreamHead).toMatchObject(e_0_1_e_1_1.id)
           expect(result.newSyncState.localHead).toMatchObject(e_1_0_e_2_0.id)
-          expectEventArraysEqual(result.newEvents, [e_0_0_e_1_0, e_0_1_e_1_1])
+          expectEventArraysEqual(result.newEvents, [e_0_0_e_1_0, e_0_1_e_1_1, e_1_0_e_2_0])
           expectEventArraysEqual(result.eventsToRollback, [e_0_0, e_0_1, e_1_0])
         })
 
@@ -118,7 +118,7 @@ describe('syncstate', () => {
           }
           expect(result.newSyncState.upstreamHead).toMatchObject(e_0_1_e_1_0.id)
           expect(result.newSyncState.localHead).toMatchObject(e_1_0_e_2_0.id)
-          expectEventArraysEqual(result.newEvents, [e_0_1_e_1_0])
+          expectEventArraysEqual(result.newEvents, [e_0_1_e_1_0, e_1_0_e_2_0])
           expectEventArraysEqual(result.eventsToRollback, [e_0_1, e_1_0])
         })
 
@@ -148,12 +148,11 @@ describe('syncstate', () => {
             upstreamHead: EventId.ROOT,
             localHead: e_0_0.id,
           })
-          expect(() =>
-            run({
-              syncState,
-              payload: { _tag: 'upstream-rebase', rollbackUntil: e_0_0.id, newEvents: [e_1_0] },
-            }),
-          ).toThrow()
+          const result = run({
+            syncState,
+            payload: { _tag: 'upstream-rebase', rollbackUntil: e_0_0.id, newEvents: [e_1_0] },
+          })
+          expect(result).toMatchObject({ _tag: 'unexpected-error' })
         })
 
         it('should work for empty incoming', () => {
@@ -185,7 +184,8 @@ describe('syncstate', () => {
           upstreamHead: EventId.ROOT,
           localHead: e_0_0.id,
         })
-        expect(() => run({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_1, e_0_0] } })).toThrow()
+        const result = run({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_1, e_0_0] } })
+        expect(result).toMatchObject({ _tag: 'unexpected-error' })
       })
 
       it('should throw error if newEvents are not sorted in ascending order by eventId (global)', () => {
@@ -195,7 +195,8 @@ describe('syncstate', () => {
           upstreamHead: EventId.ROOT,
           localHead: e_0_0.id,
         })
-        expect(() => run({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_1_0, e_0_0] } })).toThrow()
+        const result = run({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_1_0, e_0_0] } })
+        expect(result).toMatchObject({ _tag: 'unexpected-error' })
       })
 
       it('should acknowledge pending event when receiving matching event', () => {
@@ -329,6 +330,17 @@ describe('syncstate', () => {
         expect(result.newSyncState.localHead).toMatchObject(e_1_0.id)
         expect(result.newEvents).toStrictEqual([e_1_0])
       })
+
+      it('should fail if incoming event is ≤ local head', () => {
+        const syncState = new SyncState.SyncState({
+          pending: [],
+          rollbackTail: [],
+          upstreamHead: e_1_0.id,
+          localHead: e_1_0.id,
+        })
+        const result = run({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_0] } })
+        expect(result).toMatchObject({ _tag: 'unexpected-error' })
+      })
     })
 
     describe('upstream-advance: rebase', () => {
@@ -513,14 +525,20 @@ const expectEventArraysEqual = (
   })
 }
 
-function expectAdvance(result: SyncState.UpdateResult): asserts result is SyncState.UpdateResultAdvance {
+function expectAdvance(
+  result: typeof SyncState.UpdateResult.Type,
+): asserts result is typeof SyncState.UpdateResultAdvance.Type {
   expect(result._tag).toBe('advance')
 }
 
-function expectRebase(result: SyncState.UpdateResult): asserts result is SyncState.UpdateResultRebase {
+function expectRebase(
+  result: typeof SyncState.UpdateResult.Type,
+): asserts result is typeof SyncState.UpdateResultRebase.Type {
   expect(result._tag).toBe('rebase')
 }
 
-function expectReject(result: SyncState.UpdateResult): asserts result is SyncState.UpdateResultReject {
+function expectReject(
+  result: typeof SyncState.UpdateResult.Type,
+): asserts result is typeof SyncState.UpdateResultReject.Type {
   expect(result._tag).toBe('reject')
 }

package/src/sync/syncstate.ts

@@ -1,6 +1,7 @@
-import { shouldNeverHappen } from '@livestore/utils'
-import { ReadonlyArray, Schema } from '@livestore/utils/effect'
+import { casesHandled } from '@livestore/utils'
+import { Match, ReadonlyArray, Schema } from '@livestore/utils/effect'
 
+import { UnexpectedError } from '../adapter-types.js'
 import * as EventId from '../schema/EventId.js'
 import * as MutationEvent from '../schema/MutationEvent.js'
 
@@ -79,31 +80,104 @@ export const PayloadUpstream = Schema.Union(PayloadUpstreamRebase, PayloadUpstre
 
 export type PayloadUpstream = typeof PayloadUpstream.Type
 
-export type UpdateResultAdvance = {
-  _tag: 'advance'
-  newSyncState: SyncState
-  previousSyncState: SyncState
+/** Only used for debugging purposes */
+export class UpdateContext extends Schema.Class<UpdateContext>('UpdateContext')({
+  payload: Payload,
+  syncState: SyncState,
+}) {
+  toJSON = (): any => {
+    const payload = Match.value(this.payload).pipe(
+      Match.tag('local-push', () => ({
+        _tag: 'local-push',
+        newEvents: this.payload.newEvents.map((e) => e.toJSON()),
+      })),
+      Match.tag('upstream-advance', () => ({
+        _tag: 'upstream-advance',
+        newEvents: this.payload.newEvents.map((e) => e.toJSON()),
+      })),
+      Match.tag('upstream-rebase', () => ({
+        _tag: 'upstream-rebase',
+        newEvents: this.payload.newEvents.map((e) => e.toJSON()),
+      })),
+      Match.exhaustive,
+    )
+    return {
+      payload,
+      syncState: this.syncState.toJSON(),
+    }
+  }
+}
+
+export class UpdateResultAdvance extends Schema.Class<UpdateResultAdvance>('UpdateResultAdvance')({
+  _tag: Schema.Literal('advance'),
+  newSyncState: SyncState,
   /** Events which weren't pending before the update */
-  newEvents: ReadonlyArray<MutationEvent.EncodedWithMeta>
+  newEvents: Schema.Array(MutationEvent.EncodedWithMeta),
+  updateContext: UpdateContext,
+}) {
+  toJSON = (): any => {
+    return {
+      _tag: this._tag,
+      newSyncState: this.newSyncState.toJSON(),
+      newEvents: this.newEvents.map((e) => e.toJSON()),
+      updateContext: this.updateContext.toJSON(),
+    }
+  }
 }
 
-export type UpdateResultRebase = {
-  _tag: 'rebase'
-  newSyncState: SyncState
-  previousSyncState: SyncState
+export class UpdateResultRebase extends Schema.Class<UpdateResultRebase>('UpdateResultRebase')({
+  _tag: Schema.Literal('rebase'),
+  newSyncState: SyncState,
   /** Events which weren't pending before the update */
-  newEvents: ReadonlyArray<MutationEvent.EncodedWithMeta>
-  eventsToRollback: ReadonlyArray<MutationEvent.EncodedWithMeta>
+  newEvents: Schema.Array(MutationEvent.EncodedWithMeta),
+  eventsToRollback: Schema.Array(MutationEvent.EncodedWithMeta),
+  updateContext: UpdateContext,
+}) {
+  toJSON = (): any => {
+    return {
+      _tag: this._tag,
+      newSyncState: this.newSyncState.toJSON(),
+      newEvents: this.newEvents.map((e) => e.toJSON()),
+      eventsToRollback: this.eventsToRollback.map((e) => e.toJSON()),
+      updateContext: this.updateContext.toJSON(),
+    }
+  }
 }
 
-export type UpdateResultReject = {
-  _tag: 'reject'
-  previousSyncState: SyncState
+export class UpdateResultReject extends Schema.Class<UpdateResultReject>('UpdateResultReject')({
+  _tag: Schema.Literal('reject'),
   /** The minimum id that the new events must have */
-  expectedMinimumId: EventId.EventId
+  expectedMinimumId: EventId.EventId,
+  updateContext: UpdateContext,
+}) {
+  toJSON = (): any => {
+    return {
+      _tag: this._tag,
+      expectedMinimumId: `(${this.expectedMinimumId.global},${this.expectedMinimumId.client})`,
+      updateContext: this.updateContext.toJSON(),
+    }
+  }
 }
 
-export type UpdateResult = UpdateResultAdvance | UpdateResultRebase | UpdateResultReject
+export class UpdateResultUnexpectedError extends Schema.Class<UpdateResultUnexpectedError>(
+  'UpdateResultUnexpectedError',
+)({
+  _tag: Schema.Literal('unexpected-error'),
+  cause: UnexpectedError,
+}) {}
+
+export class UpdateResult extends Schema.Union(
+  UpdateResultAdvance,
+  UpdateResultRebase,
+  UpdateResultReject,
+  UpdateResultUnexpectedError,
+) {}
+
+const unexpectedError = (cause: unknown): UpdateResultUnexpectedError =>
+  UpdateResultUnexpectedError.make({
+    _tag: 'unexpected-error',
+    cause: new UnexpectedError({ cause }),
+  })
 
 export const updateSyncState = ({
   syncState,
@@ -118,7 +192,7 @@ export const updateSyncState = ({
   isEqualEvent: (a: MutationEvent.EncodedWithMeta, b: MutationEvent.EncodedWithMeta) => boolean
   /** This is used in the leader which should ignore local events when receiving an upstream-advance payload */
   ignoreLocalEvents?: boolean
-}): UpdateResult => {
+}): typeof UpdateResult.Type => {
   const trimRollbackTail = (
     rollbackTail: ReadonlyArray<MutationEvent.EncodedWithMeta>,
   ): ReadonlyArray<MutationEvent.EncodedWithMeta> => {
@@ -129,6 +203,8 @@ export const updateSyncState = ({
     return rollbackTail.slice(index + 1)
   }
 
+  const updateContext = UpdateContext.make({ payload, syncState })
+
   switch (payload._tag) {
     case 'upstream-rebase': {
       // Find the index of the rollback event in the rollback tail
@@ -136,7 +212,7 @@ export const updateSyncState = ({
         EventId.isEqual(event.id, payload.rollbackUntil),
       )
       if (rollbackIndex === -1) {
-        return shouldNeverHappen(
+        return unexpectedError(
           `Rollback event not found in rollback tail. Rollback until: [${payload.rollbackUntil.global},${payload.rollbackUntil.client}]. Rollback tail: [${syncState.rollbackTail.map((e) => e.toString()).join(', ')}]`,
         )
       }
@@ -153,7 +229,7 @@ export const updateSyncState = ({
         isLocalEvent,
       })
 
-      return {
+      return UpdateResultRebase.make({
         _tag: 'rebase',
         newSyncState: new SyncState({
           pending: rebasedPending,
@@ -161,15 +237,15 @@ export const updateSyncState = ({
           upstreamHead: newUpstreamHead,
           localHead: rebasedPending.at(-1)?.id ?? newUpstreamHead,
         }),
-        previousSyncState: syncState,
-        newEvents: payload.newEvents,
+        newEvents: [...payload.newEvents, ...rebasedPending],
         eventsToRollback,
-      }
+        updateContext,
+      })
     }
 
     case 'upstream-advance': {
       if (payload.newEvents.length === 0) {
-        return {
+        return UpdateResultAdvance.make({
           _tag: 'advance',
           newSyncState: new SyncState({
             pending: syncState.pending,
@@ -177,18 +253,27 @@ export const updateSyncState = ({
             upstreamHead: syncState.upstreamHead,
             localHead: syncState.localHead,
           }),
-          previousSyncState: syncState,
           newEvents: [],
-        }
+          updateContext,
+        })
       }
 
       // Validate that newEvents are sorted in ascending order by eventId
       for (let i = 1; i < payload.newEvents.length; i++) {
         if (EventId.isGreaterThan(payload.newEvents[i - 1]!.id, payload.newEvents[i]!.id)) {
-          return shouldNeverHappen('Events must be sorted in ascending order by eventId')
+          return unexpectedError(
+            `Events must be sorted in ascending order by eventId. Received: [${payload.newEvents.map((e) => `(${e.id.global},${e.id.client})`).join(', ')}]`,
+          )
         }
       }
 
+      // Validate that incoming events are larger than upstream head
+      if (EventId.isGreaterThan(syncState.upstreamHead, payload.newEvents[0]!.id)) {
+        return unexpectedError(
+          `Incoming events must be greater than upstream head. Expected greater than: [${syncState.upstreamHead.global},${syncState.upstreamHead.client}]. Received: [${payload.newEvents.map((e) => `(${e.id.global},${e.id.client})`).join(', ')}]`,
+        )
+      }
+
       const newUpstreamHead = payload.newEvents.at(-1)!.id
 
       const divergentPendingIndex = findDivergencePoint({
@@ -235,7 +320,7 @@ export const updateSyncState = ({
           return true
         })
 
-        return {
+        return UpdateResultAdvance.make({
           _tag: 'advance',
           newSyncState: new SyncState({
             pending: pendingRemaining,
@@ -243,9 +328,9 @@ export const updateSyncState = ({
             upstreamHead: newUpstreamHead,
             localHead: pendingRemaining.at(-1)?.id ?? newUpstreamHead,
           }),
-          previousSyncState: syncState,
           newEvents,
-        }
+          updateContext,
+        })
       } else {
         const divergentPending = syncState.pending.slice(divergentPendingIndex)
         const rebasedPending = rebaseEvents({
@@ -262,7 +347,7 @@ export const updateSyncState = ({
           ignoreLocalEvents,
         })
 
-        return {
+        return UpdateResultRebase.make({
           _tag: 'rebase',
           newSyncState: new SyncState({
             pending: rebasedPending,
@@ -270,16 +355,21 @@ export const updateSyncState = ({
             upstreamHead: newUpstreamHead,
             localHead: rebasedPending.at(-1)!.id,
           }),
-          previousSyncState: syncState,
           newEvents: [...payload.newEvents.slice(divergentNewEventsIndex), ...rebasedPending],
           eventsToRollback: [...syncState.rollbackTail, ...divergentPending],
-        }
+          updateContext,
+        })
       }
     }
 
     case 'local-push': {
       if (payload.newEvents.length === 0) {
-        return { _tag: 'advance', newSyncState: syncState, previousSyncState: syncState, newEvents: [] }
+        return UpdateResultAdvance.make({
+          _tag: 'advance',
+          newSyncState: syncState,
+          newEvents: [],
+          updateContext,
+        })
       }
 
       const newEventsFirst = payload.newEvents.at(0)!
@@ -287,9 +377,13 @@ export const updateSyncState = ({
 
       if (invalidEventId) {
         const expectedMinimumId = EventId.nextPair(syncState.localHead, true).id
-        return { _tag: 'reject', previousSyncState: syncState, expectedMinimumId }
+        return UpdateResultReject.make({
+          _tag: 'reject',
+          expectedMinimumId,
+          updateContext,
+        })
       } else {
-        return {
+        return UpdateResultAdvance.make({
           _tag: 'advance',
           newSyncState: new SyncState({
             pending: [...syncState.pending, ...payload.newEvents],
@@ -297,33 +391,15 @@ export const updateSyncState = ({
             upstreamHead: syncState.upstreamHead,
             localHead: payload.newEvents.at(-1)!.id,
           }),
-          previousSyncState: syncState,
           newEvents: payload.newEvents,
-        }
+          updateContext,
+        })
       }
     }
 
-    // case 'upstream-trim-rollback-tail': {
-    //   // Find the index of the new rollback start in the rollback tail
-    //   const startIndex = syncState.rollbackTail.findIndex((event) => eventIdsEqual(event.id, payload.trimRollbackUntil))
-    //   if (startIndex === -1) {
-    //     return shouldNeverHappen('New rollback start event not found in rollback tail')
-    //   }
-
-    //   // Keep only the events from the start index onwards
-    //   const newRollbackTail = syncState.rollbackTail.slice(startIndex)
-
-    //   return {
-    //     _tag: 'advance',
-    //     syncState: {
-    //       pending: syncState.pending,
-    //       rollbackTail: newRollbackTail,
-    //       upstreamHead: syncState.upstreamHead,
-    //       localHead: syncState.localHead,
-    //     },
-    //     newEvents: [],
-    //   }
-    // }
+    default: {
+      casesHandled(payload)
+    }
   }
 }
 
@@ -385,3 +461,12 @@ const rebaseEvents = ({
     return newEvent
   })
 }
+
+/**
+ * TODO: Implement this
+ *
+ * In certain scenarios e.g. when the client session has a queue of upstream update results,
+ * it could make sense to "flatten" update results into a single update result which the client session
+ * can process more efficiently which avoids push-threshing
+ */
+const _flattenUpdateResults = (_updateResults: ReadonlyArray<UpdateResult>) => {}

package/src/version.ts

@@ -2,7 +2,7 @@
 // import packageJson from '../package.json' with { type: 'json' }
 // export const liveStoreVersion = packageJson.version
 
-export const liveStoreVersion = '0.3.0-dev.16' as const
+export const liveStoreVersion = '0.3.0-dev.17' as const
 
 /**
  * This version number is incremented whenever the internal storage format changes in a breaking way.