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

package/src/sync/syncstate.test.ts

@@ -1,4 +1,6 @@
-import { describe, expect, it } from 'vitest'
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { Cause, Effect, Exit, Schema } from '@livestore/utils/effect'
+import { assert, expect } from 'vitest'
 
 import * as EventSequenceNumber from '../schema/EventSequenceNumber/mod.ts'
 import * as LiveStoreEvent from '../schema/LiveStoreEvent/mod.ts'
@@ -48,8 +50,8 @@ const isEqualEvent = LiveStoreEvent.Client.isEqualEncoded
 
 const isClientEvent = (event: LiveStoreEvent.Client.EncodedWithMeta) => (event as TestEvent).isClient
 
-describe('syncstate', () => {
-  describe('merge', () => {
+Vitest.describe('syncstate', () => {
+  Vitest.describe('merge', () => {
     const merge = ({
       syncState,
       payload,
@@ -60,446 +62,564 @@ describe('syncstate', () => {
       ignoreClientEvents?: boolean
     }) => SyncState.merge({ syncState, payload, isClientEvent, isEqualEvent, ignoreClientEvents })
 
-    describe('upstream-rebase', () => {
-      it('should rollback until start', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e2_0],
-          upstreamHead: EventSequenceNumber.Client.ROOT,
-          localHead: e2_0.seqNum,
-        })
-        const e1_0_e2_0 = e1_0.rebase_(e2_0.seqNum, 0)
-        const e1_1_e2_1 = e1_1.rebase_(e1_0_e2_0.seqNum, 0)
-        const result = merge({
-          syncState,
-          payload: SyncState.PayloadUpstreamRebase.make({
-            rollbackEvents: [e1_0, e1_1],
-            newEvents: [e1_0_e2_0, e1_1_e2_1],
-          }),
-        })
-        const e2_0_e3_0 = e2_0.rebase_(e1_0_e2_0.seqNum, 1)
-        expectRebase(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_1_e2_1.seqNum)
-        expect(result.newSyncState.localHead).toMatchObject(e2_0_e3_0.seqNum)
-        expectEventArraysEqual(result.newEvents, [e1_0_e2_0, e1_1_e2_1, e2_0_e3_0])
-        expectEventArraysEqual(result.rollbackEvents, [e1_0, e1_1, e2_0])
-      })
-
-      it('should rollback only to specified point', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e2_0],
-          upstreamHead: EventSequenceNumber.Client.ROOT,
-          localHead: e2_0.seqNum,
-        })
-        const e1_1_e2_0 = e1_1.rebase_(e1_0.seqNum, 0)
-        const result = merge({
-          syncState,
-          payload: SyncState.PayloadUpstreamRebase.make({
-            newEvents: [e1_1_e2_0],
-            rollbackEvents: [e1_1],
-          }),
-        })
-        const e2_0_e3_0 = e2_0.rebase_(e1_1_e2_0.seqNum, 1)
-        expectRebase(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_1_e2_0.seqNum)
-        expect(result.newSyncState.localHead).toMatchObject(e2_0_e3_0.seqNum)
-        expectEventArraysEqual(result.newEvents, [e1_1_e2_0, e2_0_e3_0])
-        expectEventArraysEqual(result.rollbackEvents, [e1_1, e2_0])
-      })
-
-      it('should work for empty pending', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [],
-          upstreamHead: EventSequenceNumber.Client.ROOT,
-          localHead: e1_0.seqNum,
-        })
-        const result = merge({
-          syncState,
-          payload: SyncState.PayloadUpstreamRebase.make({ rollbackEvents: [e1_0], newEvents: [e2_0] }),
-        })
-        expectRebase(result)
-        expectEventArraysEqual(result.newSyncState.pending, [])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.seqNum)
-        expect(result.newSyncState.localHead).toMatchObject(e2_0.seqNum)
-        expect(result.newEvents).toStrictEqual([e2_0])
-      })
+    Vitest.describe('upstream-rebase', () => {
+      Vitest.it.effect('should rollback until start', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [e2_0],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: e2_0.seqNum,
+          })
+          const e1_0_e2_0 = e1_0.rebase_(e2_0.seqNum, 0)
+          const e1_1_e2_1 = e1_1.rebase_(e1_0_e2_0.seqNum, 0)
+          const result = yield* merge({
+            syncState,
+            payload: SyncState.PayloadUpstreamRebase.make({
+              rollbackEvents: [e1_0, e1_1],
+              newEvents: [e1_0_e2_0, e1_1_e2_1],
+            }),
+          })
+          const e2_0_e3_0 = e2_0.rebase_(e1_0_e2_0.seqNum, 1)
+          expectRebase(result)
+          expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
+          expect(result.newSyncState.upstreamHead).toMatchObject(e1_1_e2_1.seqNum)
+          expect(result.newSyncState.localHead).toMatchObject(e2_0_e3_0.seqNum)
+          expectEventArraysEqual(result.newEvents, [e1_0_e2_0, e1_1_e2_1, e2_0_e3_0])
+          expectEventArraysEqual(result.rollbackEvents, [e1_0, e1_1, e2_0])
+        }),
+      )
+
+      Vitest.it.effect('should rollback only to specified point', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [e2_0],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: e2_0.seqNum,
+          })
+          const e1_1_e2_0 = e1_1.rebase_(e1_0.seqNum, 0)
+          const result = yield* merge({
+            syncState,
+            payload: SyncState.PayloadUpstreamRebase.make({
+              newEvents: [e1_1_e2_0],
+              rollbackEvents: [e1_1],
+            }),
+          })
+          const e2_0_e3_0 = e2_0.rebase_(e1_1_e2_0.seqNum, 1)
+          expectRebase(result)
+          expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
+          expect(result.newSyncState.upstreamHead).toMatchObject(e1_1_e2_0.seqNum)
+          expect(result.newSyncState.localHead).toMatchObject(e2_0_e3_0.seqNum)
+          expectEventArraysEqual(result.newEvents, [e1_1_e2_0, e2_0_e3_0])
+          expectEventArraysEqual(result.rollbackEvents, [e1_1, e2_0])
+        }),
+      )
+
+      Vitest.it.effect('should work for empty pending', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: e1_0.seqNum,
+          })
+          const result = yield* merge({
+            syncState,
+            payload: SyncState.PayloadUpstreamRebase.make({ rollbackEvents: [e1_0], newEvents: [e2_0] }),
+          })
+          expectRebase(result)
+          expectEventArraysEqual(result.newSyncState.pending, [])
+          expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.seqNum)
+          expect(result.newSyncState.localHead).toMatchObject(e2_0.seqNum)
+          expect(result.newEvents).toStrictEqual([e2_0])
+        }),
+      )
     })
 
-    describe('upstream-advance: advance', () => {
-      it('should throw error if newEvents are not sorted in ascending order by event number (client)', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e1_0],
-          upstreamHead: EventSequenceNumber.Client.ROOT,
-          localHead: e1_0.seqNum,
-        })
-        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_1, e1_0] } })
-        expect(result).toMatchObject({ _tag: 'unknown-error' })
-      })
-
-      it('should throw error if newEvents are not sorted in ascending order by event number (global)', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e1_0],
-          upstreamHead: EventSequenceNumber.Client.ROOT,
-          localHead: e1_0.seqNum,
-        })
-        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e2_0, e1_0] } })
-        expect(result).toMatchObject({ _tag: 'unknown-error' })
-      })
-
-      it('should throw error if incoming event is < expected upstream head', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [],
-          upstreamHead: e2_0.seqNum,
-          localHead: e2_0.seqNum,
-        })
-        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0] } })
-        expect(result).toMatchObject({ _tag: 'unknown-error' })
-      })
-
-      it('should throw error if incoming event is = expected upstream head', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [],
-          upstreamHead: e2_0.seqNum,
-          localHead: e2_0.seqNum,
-        })
-        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e2_0] } })
-        expect(result).toMatchObject({ _tag: 'unknown-error' })
-      })
-
-      it('should confirm pending event when receiving matching event', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e1_0],
-          upstreamHead: EventSequenceNumber.Client.ROOT,
-          localHead: e1_0.seqNum,
-        })
-        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0] } })
-
-        expectAdvance(result)
-        expectEventArraysEqual(result.newSyncState.pending, [])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.seqNum)
-        expect(result.newSyncState.localHead).toMatchObject(e1_0.seqNum)
-        expectEventArraysEqual(result.newEvents, [])
-        expectEventArraysEqual(result.confirmedEvents, [e1_0])
-      })
-
-      it('should confirm partial pending event when receiving matching event', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e1_0, e2_0],
-          upstreamHead: EventSequenceNumber.Client.ROOT,
-          localHead: e2_0.seqNum,
-        })
-        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0] } })
-
-        expectAdvance(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e2_0])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.seqNum)
-        expect(result.newSyncState.localHead).toMatchObject(e2_0.seqNum)
-        expectEventArraysEqual(result.newEvents, [])
-        expectEventArraysEqual(result.confirmedEvents, [e1_0])
-      })
-
-      it('should confirm pending event and add new event', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e1_0],
-          upstreamHead: EventSequenceNumber.Client.ROOT,
-          localHead: e1_0.seqNum,
-        })
-        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0, e1_1] } })
-
-        expectAdvance(result)
-        expectEventArraysEqual(result.newSyncState.pending, [])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_1.seqNum)
-        expect(result.newSyncState.localHead).toMatchObject(e1_1.seqNum)
-        expect(result.newEvents).toStrictEqual([e1_1])
-        expectEventArraysEqual(result.confirmedEvents, [e1_0])
-      })
-
-      it('should confirm pending event and add multiple new events', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e1_1],
-          upstreamHead: e1_0.seqNum,
-          localHead: e1_1.seqNum,
-        })
-        const result = merge({
-          syncState,
-          payload: { _tag: 'upstream-advance', newEvents: [e1_1, e1_2, e1_3, e2_0, e2_1] },
-        })
-
-        expectAdvance(result)
-        expectEventArraysEqual(result.newSyncState.pending, [])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e2_1.seqNum)
-        expect(result.newSyncState.localHead).toMatchObject(e2_1.seqNum)
-        expect(result.newEvents).toStrictEqual([e1_2, e1_3, e2_0, e2_1])
-        expectEventArraysEqual(result.confirmedEvents, [e1_1])
-      })
-
-      it('should confirm pending global event while keep pending client events', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e1_0, e1_1],
-          upstreamHead: EventSequenceNumber.Client.ROOT,
-          localHead: e1_1.seqNum,
-        })
-        const result = merge({
-          syncState,
-          payload: { _tag: 'upstream-advance', newEvents: [e1_0] },
-        })
+    Vitest.describe('upstream-advance: advance', () => {
+      Vitest.it.effect('should die if newEvents are not sorted in ascending order by event number (client)', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [e1_0],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: e1_0.seqNum,
+          })
+          const exit = yield* merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_1, e1_0] } }).pipe(
+            Effect.exit,
+          )
+          assert(Exit.isFailure(exit))
+          expect(Cause.isDie(exit.cause)).toBe(true)
+        }),
+      )
+
+      Vitest.it.effect('should die if newEvents are not sorted in ascending order by event number (global)', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [e1_0],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: e1_0.seqNum,
+          })
+          const exit = yield* merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e2_0, e1_0] } }).pipe(
+            Effect.exit,
+          )
+          assert(Exit.isFailure(exit))
+          expect(Cause.isDie(exit.cause)).toBe(true)
+        }),
+      )
+
+      Vitest.it.effect('should die if incoming event is < expected upstream head', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [],
+            upstreamHead: e2_0.seqNum,
+            localHead: e2_0.seqNum,
+          })
+          const exit = yield* merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0] } }).pipe(
+            Effect.exit,
+          )
+          assert(Exit.isFailure(exit))
+          expect(Cause.isDie(exit.cause)).toBe(true)
+        }),
+      )
+
+      Vitest.it.effect('should die if incoming event is = expected upstream head', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [],
+            upstreamHead: e2_0.seqNum,
+            localHead: e2_0.seqNum,
+          })
+          const exit = yield* merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e2_0] } }).pipe(
+            Effect.exit,
+          )
+          assert(Exit.isFailure(exit))
+          expect(Cause.isDie(exit.cause)).toBe(true)
+        }),
+      )
+
+      Vitest.it.effect('should confirm pending event when receiving matching event', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [e1_0],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: e1_0.seqNum,
+          })
+          const result = yield* merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0] } })
+
+          expectAdvance(result)
+          expectEventArraysEqual(result.newSyncState.pending, [])
+          expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.seqNum)
+          expect(result.newSyncState.localHead).toMatchObject(e1_0.seqNum)
+          expectEventArraysEqual(result.newEvents, [])
+          expectEventArraysEqual(result.confirmedEvents, [e1_0])
+        }),
+      )
+
+      Vitest.it.effect('should confirm partial pending event when receiving matching event', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [e1_0, e2_0],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: e2_0.seqNum,
+          })
+          const result = yield* merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0] } })
+
+          expectAdvance(result)
+          expectEventArraysEqual(result.newSyncState.pending, [e2_0])
+          expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.seqNum)
+          expect(result.newSyncState.localHead).toMatchObject(e2_0.seqNum)
+          expectEventArraysEqual(result.newEvents, [])
+          expectEventArraysEqual(result.confirmedEvents, [e1_0])
+        }),
+      )
+
+      Vitest.it.effect('should confirm pending event and add new event', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [e1_0],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: e1_0.seqNum,
+          })
+          const result = yield* merge({
+            syncState,
+            payload: { _tag: 'upstream-advance', newEvents: [e1_0, e1_1] },
+          })
 
-        expectAdvance(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e1_1])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.seqNum)
-        expect(result.newSyncState.localHead).toMatchObject(e1_1.seqNum)
-        expectEventArraysEqual(result.newEvents, [])
-        expectEventArraysEqual(result.confirmedEvents, [e1_0])
-      })
+          expectAdvance(result)
+          expectEventArraysEqual(result.newSyncState.pending, [])
+          expect(result.newSyncState.upstreamHead).toMatchObject(e1_1.seqNum)
+          expect(result.newSyncState.localHead).toMatchObject(e1_1.seqNum)
+          expect(result.newEvents).toStrictEqual([e1_1])
+          expectEventArraysEqual(result.confirmedEvents, [e1_0])
+        }),
+      )
+
+      Vitest.it.effect('should confirm pending event and add multiple new events', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [e1_1],
+            upstreamHead: e1_0.seqNum,
+            localHead: e1_1.seqNum,
+          })
+          const result = yield* merge({
+            syncState,
+            payload: { _tag: 'upstream-advance', newEvents: [e1_1, e1_2, e1_3, e2_0, e2_1] },
+          })
 
-      it('should ignore client events (incoming is subset of pending)', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e0_1, e1_0],
-          upstreamHead: EventSequenceNumber.Client.ROOT,
-          localHead: e1_0.seqNum,
-        })
-        const result = merge({
-          syncState,
-          payload: { _tag: 'upstream-advance', newEvents: [e1_0] },
-          ignoreClientEvents: true,
-        })
-        expectAdvance(result)
-        expectEventArraysEqual(result.newSyncState.pending, [])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.seqNum)
-        expect(result.newSyncState.localHead).toMatchObject(e1_0.seqNum)
-        expectEventArraysEqual(result.newEvents, [])
-        expectEventArraysEqual(result.confirmedEvents, [e0_1, e1_0])
-      })
+          expectAdvance(result)
+          expectEventArraysEqual(result.newSyncState.pending, [])
+          expect(result.newSyncState.upstreamHead).toMatchObject(e2_1.seqNum)
+          expect(result.newSyncState.localHead).toMatchObject(e2_1.seqNum)
+          expect(result.newEvents).toStrictEqual([e1_2, e1_3, e2_0, e2_1])
+          expectEventArraysEqual(result.confirmedEvents, [e1_1])
+        }),
+      )
+
+      Vitest.it.effect('should confirm pending global event while keep pending client events', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [e1_0, e1_1],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: e1_1.seqNum,
+          })
+          const result = yield* merge({
+            syncState,
+            payload: { _tag: 'upstream-advance', newEvents: [e1_0] },
+          })
 
-      it('should ignore client events (incoming is subset of pending case 2)', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e0_1, e1_0, e2_0],
-          upstreamHead: EventSequenceNumber.Client.ROOT,
-          localHead: e1_0.seqNum,
-        })
-        const result = merge({
-          syncState,
-          payload: { _tag: 'upstream-advance', newEvents: [e1_0] },
-          ignoreClientEvents: true,
-        })
-        expectAdvance(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e2_0])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.seqNum)
-        expect(result.newSyncState.localHead).toMatchObject(e2_0.seqNum)
-        expectEventArraysEqual(result.newEvents, [])
-        expectEventArraysEqual(result.confirmedEvents, [e0_1, e1_0])
-      })
+          expectAdvance(result)
+          expectEventArraysEqual(result.newSyncState.pending, [e1_1])
+          expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.seqNum)
+          expect(result.newSyncState.localHead).toMatchObject(e1_1.seqNum)
+          expectEventArraysEqual(result.newEvents, [])
+          expectEventArraysEqual(result.confirmedEvents, [e1_0])
+        }),
+      )
+
+      Vitest.it.effect('should ignore client events (incoming is subset of pending)', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [e0_1, e1_0],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: e1_0.seqNum,
+          })
+          const result = yield* merge({
+            syncState,
+            payload: { _tag: 'upstream-advance', newEvents: [e1_0] },
+            ignoreClientEvents: true,
+          })
+          expectAdvance(result)
+          expectEventArraysEqual(result.newSyncState.pending, [])
+          expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.seqNum)
+          expect(result.newSyncState.localHead).toMatchObject(e1_0.seqNum)
+          expectEventArraysEqual(result.newEvents, [])
+          expectEventArraysEqual(result.confirmedEvents, [e0_1, e1_0])
+        }),
+      )
+
+      Vitest.it.effect('should ignore client events (incoming is subset of pending case 2)', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [e0_1, e1_0, e2_0],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: e1_0.seqNum,
+          })
+          const result = yield* merge({
+            syncState,
+            payload: { _tag: 'upstream-advance', newEvents: [e1_0] },
+            ignoreClientEvents: true,
+          })
+          expectAdvance(result)
+          expectEventArraysEqual(result.newSyncState.pending, [e2_0])
+          expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.seqNum)
+          expect(result.newSyncState.localHead).toMatchObject(e2_0.seqNum)
+          expectEventArraysEqual(result.newEvents, [])
+          expectEventArraysEqual(result.confirmedEvents, [e0_1, e1_0])
+        }),
+      )
+
+      Vitest.it.effect('should ignore client events (incoming goes beyond pending)', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [e0_1, e1_0, e1_1],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: e1_1.seqNum,
+          })
+          const result = yield* merge({
+            syncState,
+            payload: { _tag: 'upstream-advance', newEvents: [e1_0, e2_0] },
+            ignoreClientEvents: true,
+          })
 
-      it('should ignore client events (incoming goes beyond pending)', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e0_1, e1_0, e1_1],
-          upstreamHead: EventSequenceNumber.Client.ROOT,
-          localHead: e1_1.seqNum,
-        })
-        const result = merge({
-          syncState,
-          payload: { _tag: 'upstream-advance', newEvents: [e1_0, e2_0] },
-          ignoreClientEvents: true,
-        })
+          expectAdvance(result)
+          expectEventArraysEqual(result.newSyncState.pending, [])
+          expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.seqNum)
+          expect(result.newSyncState.localHead).toMatchObject(e2_0.seqNum)
+          expect(result.newEvents).toStrictEqual([e2_0])
+          expectEventArraysEqual(result.confirmedEvents, [e0_1, e1_0, e1_1])
+        }),
+      )
+
+      Vitest.it.effect('should die if incoming event is ≤ local head', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [],
+            upstreamHead: e2_0.seqNum,
+            localHead: e2_0.seqNum,
+          })
+          const exit = yield* merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0] } }).pipe(
+            Effect.exit,
+          )
+          assert(Exit.isFailure(exit))
+          expect(Cause.isDie(exit.cause)).toBe(true)
+        }),
+      )
+
+      Vitest.it.effect('should advance (not rebase) when pending event has undefined-valued key dropped by JSON wire round-trip', () =>
+        Effect.gen(function* () {
+          const argsSchema = Schema.Struct({
+            id: Schema.String,
+            flag: Schema.UndefinedOr(Schema.Boolean),
+          })
+          const localArgs = Schema.encodeUnknownSync(argsSchema)({ id: 'abc' } as any)
+          const wireArgs = JSON.parse(JSON.stringify(localArgs))
+
+          const localPending = new TestEvent({
+            seqNum: e1_0.seqNum,
+            parentSeqNum: e1_0.parentSeqNum,
+            name: e1_0.name,
+            args: localArgs,
+            clientId: e1_0.clientId,
+            sessionId: e1_0.sessionId,
+          })
+          const fromUpstream = new TestEvent({
+            seqNum: e1_0.seqNum,
+            parentSeqNum: e1_0.parentSeqNum,
+            name: e1_0.name,
+            args: wireArgs,
+            clientId: e1_0.clientId,
+            sessionId: e1_0.sessionId,
+          })
 
-        expectAdvance(result)
-        expectEventArraysEqual(result.newSyncState.pending, [])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.seqNum)
-        expect(result.newSyncState.localHead).toMatchObject(e2_0.seqNum)
-        expect(result.newEvents).toStrictEqual([e2_0])
-        expectEventArraysEqual(result.confirmedEvents, [e0_1, e1_0, e1_1])
-      })
+          const syncState = new SyncState.SyncState({
+            pending: [localPending],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: localPending.seqNum,
+          })
+          const result = yield* merge({
+            syncState,
+            payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [fromUpstream] }),
+          })
 
-      it('should fail if incoming event is ≤ local head', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [],
-          upstreamHead: e2_0.seqNum,
-          localHead: e2_0.seqNum,
-        })
-        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0] } })
-        expect(result).toMatchObject({ _tag: 'unknown-error' })
-      })
+          expectAdvance(result)
+          expect(result.confirmedEvents).toHaveLength(1)
+          expect(result.newSyncState.pending).toHaveLength(0)
+        }),
+      )
     })
 
-    describe('upstream-advance: rebase', () => {
-      it('should rebase single client event to end', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e1_0],
-          upstreamHead: EventSequenceNumber.Client.ROOT,
-          localHead: e1_0.seqNum,
-        })
-        const result = merge({ syncState, payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1] }) })
-
-        const e1_0_e1_2 = e1_0.rebase_(e1_1.seqNum, 1)
-
-        expectRebase(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e1_0_e1_2])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_1.seqNum)
-        expect(result.newSyncState.localHead).toMatchObject(e1_0_e1_2.seqNum)
-        expectEventArraysEqual(result.rollbackEvents, [e1_0])
-        expectEventArraysEqual(result.newEvents, [e1_1, e1_0_e1_2])
-      })
-
-      it('should rebase different event with same id', () => {
-        const e2_0_b = TestEvent.new({ global: 1, client: 0 }, e1_0.seqNum, '1_0_b', false)
-        const syncState = new SyncState.SyncState({
-          pending: [e2_0_b],
-          upstreamHead: EventSequenceNumber.Client.ROOT,
-          localHead: e2_0_b.seqNum,
-        })
-        const result = merge({ syncState, payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e2_0] }) })
-        const e2_0_e3_0 = e2_0_b.rebase_(e2_0.seqNum, 1)
-
-        expectRebase(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
-        expectEventArraysEqual(result.newEvents, [e2_0, e2_0_e3_0])
-        expectEventArraysEqual(result.rollbackEvents, [e2_0_b])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.seqNum)
-        expect(result.newSyncState.localHead).toMatchObject(e2_0_e3_0.seqNum)
-      })
-
-      it('should rebase single client event to end (more incoming events)', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e1_0],
-          upstreamHead: EventSequenceNumber.Client.ROOT,
-          localHead: e1_0.seqNum,
-        })
-        const result = merge({
-          syncState,
-          payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1, e1_2, e1_3, e2_0] }),
-        })
-
-        const e1_0_e3_0 = e1_0.rebase_(e2_0.seqNum, 1)
-
-        expectRebase(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e1_0_e3_0])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.seqNum)
-        expect(result.newSyncState.localHead).toMatchObject(e1_0_e3_0.seqNum)
-      })
-
-      it('should only rebase divergent events when first event matches', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e1_0, e1_1],
-          upstreamHead: EventSequenceNumber.Client.ROOT,
-          localHead: e1_0.seqNum,
-        })
-        const result = merge({
-          syncState,
-          payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_0, e1_2, e1_3, e2_0] }),
-        })
-
-        const e1_1_e2_1 = e1_1.rebase_(e2_0.seqNum, 1)
-
-        expectRebase(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e1_1_e2_1])
-        expectEventArraysEqual(result.rollbackEvents, [e1_1])
-        expectEventArraysEqual(result.newEvents, [e1_2, e1_3, e2_0, e1_1_e2_1])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.seqNum)
-        expect(result.newSyncState.localHead).toMatchObject(e1_1_e2_1.seqNum)
-      })
-
-      it('should rebase all client events when incoming chain starts differently', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e1_0, e1_1],
-          upstreamHead: EventSequenceNumber.Client.ROOT,
-          localHead: e1_1.seqNum,
-        })
-        const result = merge({
-          syncState,
-          payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1, e1_2, e1_3, e2_0] }),
-        })
+    Vitest.describe('upstream-advance: rebase', () => {
+      Vitest.it.effect('should rebase single client event to end', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [e1_0],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: e1_0.seqNum,
+          })
+          const result = yield* merge({
+            syncState,
+            payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1] }),
+          })
 
-        const e1_0_e2_1 = e1_0.rebase_(e2_0.seqNum, 1)
-        const e1_1_e2_2 = e1_1.rebase_(e1_0_e2_1.seqNum, 1)
+          const e1_0_e1_2 = e1_0.rebase_(e1_1.seqNum, 1)
+
+          expectRebase(result)
+          expectEventArraysEqual(result.newSyncState.pending, [e1_0_e1_2])
+          expect(result.newSyncState.upstreamHead).toMatchObject(e1_1.seqNum)
+          expect(result.newSyncState.localHead).toMatchObject(e1_0_e1_2.seqNum)
+          expectEventArraysEqual(result.rollbackEvents, [e1_0])
+          expectEventArraysEqual(result.newEvents, [e1_1, e1_0_e1_2])
+        }),
+      )
+
+      Vitest.it.effect('should rebase different event with same id', () =>
+        Effect.gen(function* () {
+          const e2_0_b = TestEvent.new({ global: 1, client: 0 }, e1_0.seqNum, '1_0_b', false)
+          const syncState = new SyncState.SyncState({
+            pending: [e2_0_b],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: e2_0_b.seqNum,
+          })
+          const result = yield* merge({
+            syncState,
+            payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e2_0] }),
+          })
+          const e2_0_e3_0 = e2_0_b.rebase_(e2_0.seqNum, 1)
+
+          expectRebase(result)
+          expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
+          expectEventArraysEqual(result.newEvents, [e2_0, e2_0_e3_0])
+          expectEventArraysEqual(result.rollbackEvents, [e2_0_b])
+          expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.seqNum)
+          expect(result.newSyncState.localHead).toMatchObject(e2_0_e3_0.seqNum)
+        }),
+      )
+
+      Vitest.it.effect('should rebase single client event to end (more incoming events)', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [e1_0],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: e1_0.seqNum,
+          })
+          const result = yield* merge({
+            syncState,
+            payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1, e1_2, e1_3, e2_0] }),
+          })
 
-        expectRebase(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e1_0_e2_1, e1_1_e2_2])
-        expectEventArraysEqual(result.newEvents, [e1_1, e1_2, e1_3, e2_0, e1_0_e2_1, e1_1_e2_2])
-        expectEventArraysEqual(result.rollbackEvents, [e1_0, e1_1])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.seqNum)
-        expect(result.newSyncState.localHead).toMatchObject(e1_1_e2_2.seqNum)
-      })
+          const e1_0_e3_0 = e1_0.rebase_(e2_0.seqNum, 1)
+
+          expectRebase(result)
+          expectEventArraysEqual(result.newSyncState.pending, [e1_0_e3_0])
+          expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.seqNum)
+          expect(result.newSyncState.localHead).toMatchObject(e1_0_e3_0.seqNum)
+        }),
+      )
+
+      Vitest.it.effect('should only rebase divergent events when first event matches', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [e1_0, e1_1],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: e1_0.seqNum,
+          })
+          const result = yield* merge({
+            syncState,
+            payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_0, e1_2, e1_3, e2_0] }),
+          })
 
-      describe('local-push', () => {
-        describe('advance', () => {
-          it('should advance with new events', () => {
-            const syncState = new SyncState.SyncState({
-              pending: [e1_0],
-              upstreamHead: EventSequenceNumber.Client.ROOT,
-              localHead: e1_0.seqNum,
-            })
-            const result = merge({
-              syncState,
-              payload: SyncState.PayloadLocalPush.make({ newEvents: [e1_1, e1_2, e1_3] }),
-            })
-
-            expectAdvance(result)
-            expectEventArraysEqual(result.newSyncState.pending, [e1_0, e1_1, e1_2, e1_3])
-            expect(result.newSyncState.upstreamHead).toMatchObject(EventSequenceNumber.Client.ROOT)
-            expect(result.newSyncState.localHead).toMatchObject(e1_3.seqNum)
-            expectEventArraysEqual(result.newEvents, [e1_1, e1_2, e1_3])
-            expectEventArraysEqual(result.confirmedEvents, [])
+          const e1_1_e2_1 = e1_1.rebase_(e2_0.seqNum, 1)
+
+          expectRebase(result)
+          expectEventArraysEqual(result.newSyncState.pending, [e1_1_e2_1])
+          expectEventArraysEqual(result.rollbackEvents, [e1_1])
+          expectEventArraysEqual(result.newEvents, [e1_2, e1_3, e2_0, e1_1_e2_1])
+          expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.seqNum)
+          expect(result.newSyncState.localHead).toMatchObject(e1_1_e2_1.seqNum)
+        }),
+      )
+
+      Vitest.it.effect('should rebase all client events when incoming chain starts differently', () =>
+        Effect.gen(function* () {
+          const syncState = new SyncState.SyncState({
+            pending: [e1_0, e1_1],
+            upstreamHead: EventSequenceNumber.Client.ROOT,
+            localHead: e1_1.seqNum,
+          })
+          const result = yield* merge({
+            syncState,
+            payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1, e1_2, e1_3, e2_0] }),
           })
 
+          const e1_0_e2_1 = e1_0.rebase_(e2_0.seqNum, 1)
+          const e1_1_e2_2 = e1_1.rebase_(e1_0_e2_1.seqNum, 1)
+
+          expectRebase(result)
+          expectEventArraysEqual(result.newSyncState.pending, [e1_0_e2_1, e1_1_e2_2])
+          expectEventArraysEqual(result.newEvents, [e1_1, e1_2, e1_3, e2_0, e1_0_e2_1, e1_1_e2_2])
+          expectEventArraysEqual(result.rollbackEvents, [e1_0, e1_1])
+          expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.seqNum)
+          expect(result.newSyncState.localHead).toMatchObject(e1_1_e2_2.seqNum)
+        }),
+      )
+
+      Vitest.describe('local-push', () => {
+        Vitest.describe('advance', () => {
+          Vitest.it.effect('should advance with new events', () =>
+            Effect.gen(function* () {
+              const syncState = new SyncState.SyncState({
+                pending: [e1_0],
+                upstreamHead: EventSequenceNumber.Client.ROOT,
+                localHead: e1_0.seqNum,
+              })
+              const result = yield* merge({
+                syncState,
+                payload: SyncState.PayloadLocalPush.make({ newEvents: [e1_1, e1_2, e1_3] }),
+              })
+
+              expectAdvance(result)
+              expectEventArraysEqual(result.newSyncState.pending, [e1_0, e1_1, e1_2, e1_3])
+              expect(result.newSyncState.upstreamHead).toMatchObject(EventSequenceNumber.Client.ROOT)
+              expect(result.newSyncState.localHead).toMatchObject(e1_3.seqNum)
+              expectEventArraysEqual(result.newEvents, [e1_1, e1_2, e1_3])
+              expectEventArraysEqual(result.confirmedEvents, [])
+            }),
+          )
+
           // Leaders can choose to ignore client-only events while still returning them for broadcast.
           // Ensure pending/local head only reflects events that must be pushed upstream.
-          it('keeps pending empty when pushing only client-only events that are being ignored', () => {
-            const syncState = new SyncState.SyncState({
-              pending: [],
-              upstreamHead: EventSequenceNumber.Client.ROOT,
-              localHead: EventSequenceNumber.Client.ROOT,
-            })
-
-            const result = merge({
-              syncState,
-              payload: SyncState.PayloadLocalPush.make({ newEvents: [e0_1] }),
-              ignoreClientEvents: true,
-            })
-
-            expectAdvance(result)
-            expectEventArraysEqual(result.newSyncState.pending, [])
-            expect(result.newSyncState.upstreamHead).toMatchObject(EventSequenceNumber.Client.ROOT)
-            expect(result.newSyncState.localHead).toMatchObject(EventSequenceNumber.Client.ROOT)
-            expectEventArraysEqual(result.newEvents, [e0_1])
-          })
-
-          it('appends only upstream-bound events to pending when ignoring client-only pushes', () => {
-            const syncState = new SyncState.SyncState({
-              pending: [],
-              upstreamHead: EventSequenceNumber.Client.ROOT,
-              localHead: EventSequenceNumber.Client.ROOT,
-            })
-
-            const result = merge({
-              syncState,
-              payload: SyncState.PayloadLocalPush.make({ newEvents: [e0_1, e1_0] }),
-              ignoreClientEvents: true,
-            })
-
-            expectAdvance(result)
-            expectEventArraysEqual(result.newSyncState.pending, [e1_0])
-            expect(result.newSyncState.upstreamHead).toMatchObject(EventSequenceNumber.Client.ROOT)
-            expect(result.newSyncState.localHead).toMatchObject(e1_0.seqNum)
-            expectEventArraysEqual(result.newEvents, [e0_1, e1_0])
-          })
-        })
-
-        describe('reject', () => {
-          it('should reject when new events are greater than pending events', () => {
-            const syncState = new SyncState.SyncState({
-              pending: [e1_0, e1_1],
-              upstreamHead: EventSequenceNumber.Client.ROOT,
-              localHead: e1_1.seqNum,
-            })
-            const result = merge({
-              syncState,
-              payload: SyncState.PayloadLocalPush.make({ newEvents: [e1_1, e1_2] }),
-            })
-
-            expectReject(result)
-            expect(result.expectedMinimumId).toMatchObject(e1_2.seqNum)
-          })
+          Vitest.it.effect('keeps pending empty when pushing only client-only events that are being ignored', () =>
+            Effect.gen(function* () {
+              const syncState = new SyncState.SyncState({
+                pending: [],
+                upstreamHead: EventSequenceNumber.Client.ROOT,
+                localHead: EventSequenceNumber.Client.ROOT,
+              })
+
+              const result = yield* merge({
+                syncState,
+                payload: SyncState.PayloadLocalPush.make({ newEvents: [e0_1] }),
+                ignoreClientEvents: true,
+              })
+
+              expectAdvance(result)
+              expectEventArraysEqual(result.newSyncState.pending, [])
+              expect(result.newSyncState.upstreamHead).toMatchObject(EventSequenceNumber.Client.ROOT)
+              expect(result.newSyncState.localHead).toMatchObject(EventSequenceNumber.Client.ROOT)
+              expectEventArraysEqual(result.newEvents, [e0_1])
+            }),
+          )
+
+          Vitest.it.effect(
+            'appends only upstream-bound events to pending when ignoring client-only pushes',
+            () =>
+              Effect.gen(function* () {
+                const syncState = new SyncState.SyncState({
+                  pending: [],
+                  upstreamHead: EventSequenceNumber.Client.ROOT,
+                  localHead: EventSequenceNumber.Client.ROOT,
+                })
+
+                const result = yield* merge({
+                  syncState,
+                  payload: SyncState.PayloadLocalPush.make({ newEvents: [e0_1, e1_0] }),
+                  ignoreClientEvents: true,
+                })
+
+                expectAdvance(result)
+                expectEventArraysEqual(result.newSyncState.pending, [e1_0])
+                expect(result.newSyncState.upstreamHead).toMatchObject(EventSequenceNumber.Client.ROOT)
+                expect(result.newSyncState.localHead).toMatchObject(e1_0.seqNum)
+                expectEventArraysEqual(result.newEvents, [e0_1, e1_0])
+              }),
+          )
+        })
+
+        Vitest.describe('reject', () => {
+          Vitest.it.effect('should reject when new events are greater than pending events', () =>
+            Effect.gen(function* () {
+              const syncState = new SyncState.SyncState({
+                pending: [e1_0, e1_1],
+                upstreamHead: EventSequenceNumber.Client.ROOT,
+                localHead: e1_1.seqNum,
+              })
+              const result = yield* merge({
+                syncState,
+                payload: SyncState.PayloadLocalPush.make({ newEvents: [e1_1, e1_2] }),
+              })
+
+              expectReject(result)
+              expect(result.expectedMinimumId).toMatchObject(e1_2.seqNum)
+            }),
+          )
         })
       })
     })
@@ -519,20 +639,20 @@ const expectEventArraysEqual = (
   })
 }
 
-function expectAdvance(
+const expectAdvance: (
   result: typeof SyncState.MergeResult.Type,
-): asserts result is typeof SyncState.MergeResultAdvance.Type {
+) => asserts result is typeof SyncState.MergeResultAdvance.Type = (result) => {
   expect(result._tag).toBe('advance')
 }
 
-function expectRebase(
+const expectRebase: (
   result: typeof SyncState.MergeResult.Type,
-): asserts result is typeof SyncState.MergeResultRebase.Type {
-  expect(result._tag, `Expected rebase, got ${result}`).toBe('rebase')
+) => asserts result is typeof SyncState.MergeResultRebase.Type = (result) => {
+  expect(result._tag, `Expected rebase, got ${result._tag}`).toBe('rebase')
 }
 
-function expectReject(
+const expectReject: (
   result: typeof SyncState.MergeResult.Type,
-): asserts result is typeof SyncState.MergeResultReject.Type {
+) => asserts result is typeof SyncState.MergeResultReject.Type = (result) => {
   expect(result._tag).toBe('reject')
 }