@livestore/common 0.0.0-snapshot-f6ec49b1a18859aad769f0a0d8edf8bae231ed07 → 0.0.0-snapshot-2ef046b02334f52613d31dbe06af53487685edc0

package/src/sync/syncstate.test.ts

@@ -17,7 +17,6 @@ class TestEvent extends MutationEvent.EncodedWithMeta {
       parentId: EventId.make(parentId),
       mutation: 'a',
       args: payload,
-
       clientId: 'static-local-id',
       sessionId: 'static-session-id',
     })
@@ -39,306 +38,290 @@ const e_0_2 = new TestEvent({ global: 0, client: 2 }, e_0_1.id, 'a', true)
 const e_0_3 = new TestEvent({ global: 0, client: 3 }, e_0_2.id, 'a', true)
 const e_1_0 = new TestEvent({ global: 1, client: 0 }, e_0_0.id, 'a', false)
 const e_1_1 = new TestEvent({ global: 1, client: 1 }, e_1_0.id, 'a', true)
+const e_2_0 = new TestEvent({ global: 2, client: 0 }, e_1_0.id, 'a', false)
 
 const isEqualEvent = MutationEvent.isEqualEncoded
 
-const isLocalEvent = (event: MutationEvent.EncodedWithMeta) => (event as TestEvent).isLocal
+const isClientEvent = (event: MutationEvent.EncodedWithMeta) => (event as TestEvent).isLocal
 
 describe('syncstate', () => {
-  describe('updateSyncState', () => {
-    const run = ({
+  describe('merge', () => {
+    const merge = ({
       syncState,
       payload,
-      ignoreLocalEvents = false,
+      ignoreClientEvents = false,
     }: {
       syncState: SyncState.SyncState
       payload: typeof SyncState.Payload.Type
-      ignoreLocalEvents?: boolean
-    }) => SyncState.updateSyncState({ syncState, payload, isLocalEvent, isEqualEvent, ignoreLocalEvents })
-
-    describe.each([{ trimRollbackUntil: false }, { trimRollbackUntil: true }])(
-      'upstream-rebase (trimRollbackUntil: $trimRollbackUntil)',
-      ({ trimRollbackUntil }) => {
-        it('should rollback until start', () => {
-          const syncState = new SyncState.SyncState({
-            pending: [e_1_0],
-            rollbackTail: [e_0_0, e_0_1],
-            upstreamHead: EventId.ROOT,
-            localHead: e_1_0.id,
-          })
-          const e_0_0_e_1_0 = e_0_0.rebase_(e_1_0.id)
-          const e_0_1_e_1_1 = e_0_1.rebase_(e_0_0_e_1_0.id)
-          const result = run({
-            syncState,
-            payload: {
-              _tag: 'upstream-rebase',
-              rollbackUntil: e_0_0.id,
-              newEvents: [e_0_0_e_1_0, e_0_1_e_1_1],
-              trimRollbackUntil: trimRollbackUntil ? e_0_1_e_1_1.id : undefined,
-            },
-          })
-          const e_1_0_e_2_0 = e_1_0.rebase_(e_0_0_e_1_0.id)
-          expectRebase(result)
-          expectEventArraysEqual(result.newSyncState.pending, [e_1_0_e_2_0])
-          if (trimRollbackUntil) {
-            expectEventArraysEqual(result.newSyncState.rollbackTail, [])
-          } else {
-            expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_0_e_1_0, e_0_1_e_1_1])
-          }
-          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, e_1_0_e_2_0])
-          expectEventArraysEqual(result.eventsToRollback, [e_0_0, e_0_1, e_1_0])
-        })
-
-        it('should rollback only to specified point', () => {
-          const syncState = new SyncState.SyncState({
-            pending: [e_1_0],
-            rollbackTail: [e_0_0, e_0_1],
-            upstreamHead: EventId.ROOT,
-            localHead: e_1_0.id,
-          })
-          const e_0_1_e_1_0 = e_0_1.rebase_(e_0_0.id)
-          const result = run({
-            syncState,
-            payload: {
-              _tag: 'upstream-rebase',
-              rollbackUntil: e_0_1.id,
-              newEvents: [e_0_1_e_1_0],
-              trimRollbackUntil: trimRollbackUntil ? e_0_0.id : undefined,
-            },
-          })
-          const e_1_0_e_2_0 = e_1_0.rebase_(e_0_1_e_1_0.id)
-          expectRebase(result)
-          expectEventArraysEqual(result.newSyncState.pending, [e_1_0_e_2_0])
-          if (trimRollbackUntil) {
-            expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_1_e_1_0])
-          } else {
-            expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_0, e_0_1_e_1_0])
-          }
-          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, e_1_0_e_2_0])
-          expectEventArraysEqual(result.eventsToRollback, [e_0_1, e_1_0])
-        })
-
-        it('should work for empty pending', () => {
-          const syncState = new SyncState.SyncState({
-            pending: [],
-            rollbackTail: [e_0_0],
-            upstreamHead: EventId.ROOT,
-            localHead: e_0_0.id,
-          })
-          const result = run({
-            syncState,
-            payload: { _tag: 'upstream-rebase', rollbackUntil: e_0_0.id, newEvents: [e_1_0] },
-          })
-          expectRebase(result)
-          expectEventArraysEqual(result.newSyncState.pending, [])
-          expectEventArraysEqual(result.newSyncState.rollbackTail, [e_1_0])
-          expect(result.newSyncState.upstreamHead).toMatchObject(e_1_0.id)
-          expect(result.newSyncState.localHead).toMatchObject(e_1_0.id)
-          expect(result.newEvents).toStrictEqual([e_1_0])
-        })
-
-        it('should fail for empty rollback tail', () => {
-          const syncState = new SyncState.SyncState({
-            pending: [],
-            rollbackTail: [],
-            upstreamHead: EventId.ROOT,
-            localHead: e_0_0.id,
-          })
-          const result = run({
-            syncState,
-            payload: { _tag: 'upstream-rebase', rollbackUntil: e_0_0.id, newEvents: [e_1_0] },
-          })
-          expect(result).toMatchObject({ _tag: 'unexpected-error' })
+      ignoreClientEvents?: boolean
+    }) => SyncState.merge({ syncState, payload, isClientEvent, isEqualEvent, ignoreClientEvents })
+
+    describe('upstream-rebase', () => {
+      it('should rollback until start', () => {
+        const syncState = new SyncState.SyncState({
+          pending: [e_1_0],
+          upstreamHead: EventId.ROOT,
+          localHead: e_1_0.id,
+        })
+        const e_0_0_e_1_0 = e_0_0.rebase_(e_1_0.id)
+        const e_0_1_e_1_1 = e_0_1.rebase_(e_0_0_e_1_0.id)
+        const result = merge({
+          syncState,
+          payload: SyncState.PayloadUpstreamRebase.make({
+            rollbackEvents: [e_0_0, e_0_1],
+            newEvents: [e_0_0_e_1_0, e_0_1_e_1_1],
+          }),
         })
+        const e_1_0_e_2_0 = e_1_0.rebase_(e_0_0_e_1_0.id)
+        expectRebase(result)
+        expectEventArraysEqual(result.newSyncState.pending, [e_1_0_e_2_0])
+        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, e_1_0_e_2_0])
+        expectEventArraysEqual(result.rollbackEvents, [e_0_0, e_0_1, e_1_0])
+      })
 
-        it('should work for empty incoming', () => {
-          const syncState = new SyncState.SyncState({
-            pending: [],
-            rollbackTail: [e_0_0],
-            upstreamHead: EventId.ROOT,
-            localHead: e_0_0.id,
-          })
-          const result = run({
-            syncState,
-            payload: { _tag: 'upstream-rebase', rollbackUntil: e_0_0.id, newEvents: [] },
-          })
-          expectRebase(result)
-          expectEventArraysEqual(result.newSyncState.pending, [])
-          expectEventArraysEqual(result.newSyncState.rollbackTail, [])
-          expect(result.newSyncState.upstreamHead).toMatchObject(EventId.ROOT)
-          expect(result.newSyncState.localHead).toMatchObject(EventId.ROOT)
-          expect(result.newEvents).toStrictEqual([])
+      it('should rollback only to specified point', () => {
+        const syncState = new SyncState.SyncState({
+          pending: [e_1_0],
+          upstreamHead: EventId.ROOT,
+          localHead: e_1_0.id,
+        })
+        const e_0_1_e_1_0 = e_0_1.rebase_(e_0_0.id)
+        const result = merge({
+          syncState,
+          payload: SyncState.PayloadUpstreamRebase.make({
+            newEvents: [e_0_1_e_1_0],
+            rollbackEvents: [e_0_1],
+          }),
         })
-      },
-    )
+        const e_1_0_e_2_0 = e_1_0.rebase_(e_0_1_e_1_0.id)
+        expectRebase(result)
+        expectEventArraysEqual(result.newSyncState.pending, [e_1_0_e_2_0])
+        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, e_1_0_e_2_0])
+        expectEventArraysEqual(result.rollbackEvents, [e_0_1, e_1_0])
+      })
+
+      it('should work for empty pending', () => {
+        const syncState = new SyncState.SyncState({
+          pending: [],
+          upstreamHead: EventId.ROOT,
+          localHead: e_0_0.id,
+        })
+        const result = merge({
+          syncState,
+          payload: SyncState.PayloadUpstreamRebase.make({ rollbackEvents: [e_0_0], newEvents: [e_1_0] }),
+        })
+        expectRebase(result)
+        expectEventArraysEqual(result.newSyncState.pending, [])
+        expect(result.newSyncState.upstreamHead).toMatchObject(e_1_0.id)
+        expect(result.newSyncState.localHead).toMatchObject(e_1_0.id)
+        expect(result.newEvents).toStrictEqual([e_1_0])
+      })
+
+      it('should work for empty incoming', () => {
+        const syncState = new SyncState.SyncState({
+          pending: [],
+          upstreamHead: EventId.ROOT,
+          localHead: e_0_0.id,
+        })
+        const result = merge({
+          syncState,
+          payload: SyncState.PayloadUpstreamRebase.make({ rollbackEvents: [e_0_0], newEvents: [] }),
+        })
+        expectRebase(result)
+        expectEventArraysEqual(result.newSyncState.pending, [])
+        expect(result.newSyncState.upstreamHead).toMatchObject(EventId.ROOT)
+        expect(result.newSyncState.localHead).toMatchObject(EventId.ROOT)
+        expectEventArraysEqual(result.newEvents, [])
+      })
+    })
 
     describe('upstream-advance: advance', () => {
       it('should throw error if newEvents are not sorted in ascending order by eventId (client)', () => {
         const syncState = new SyncState.SyncState({
           pending: [e_0_0],
-          rollbackTail: [],
           upstreamHead: EventId.ROOT,
           localHead: e_0_0.id,
         })
-        const result = run({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_1, e_0_0] } })
+        const result = merge({ 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)', () => {
         const syncState = new SyncState.SyncState({
           pending: [e_0_0],
-          rollbackTail: [],
           upstreamHead: EventId.ROOT,
           localHead: e_0_0.id,
         })
-        const result = run({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_1_0, e_0_0] } })
+        const result = merge({ 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', () => {
+      it('should throw error if incoming event is < expected upstream head', () => {
+        const syncState = new SyncState.SyncState({
+          pending: [],
+          upstreamHead: e_1_0.id,
+          localHead: e_1_0.id,
+        })
+        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_0] } })
+        expect(result).toMatchObject({ _tag: 'unexpected-error' })
+      })
+
+      it('should throw error if incoming event is = expected upstream head', () => {
+        const syncState = new SyncState.SyncState({
+          pending: [],
+          upstreamHead: e_1_0.id,
+          localHead: e_1_0.id,
+        })
+        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_1_0] } })
+        expect(result).toMatchObject({ _tag: 'unexpected-error' })
+      })
+
+      it('should throw if the parent id of the first incoming event is unknown', () => {
+        const syncState = new SyncState.SyncState({
+          pending: [],
+          upstreamHead: EventId.ROOT,
+          localHead: e_0_0.id,
+        })
+        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_2_0] } })
+        expect(result).toMatchObject({ _tag: 'unexpected-error' })
+      })
+
+      it('should confirm pending event when receiving matching event', () => {
         const syncState = new SyncState.SyncState({
           pending: [e_0_0],
-          rollbackTail: [],
           upstreamHead: EventId.ROOT,
           localHead: e_0_0.id,
         })
-        const result = run({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_0] } })
+        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_0] } })
 
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [])
-        expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_0])
         expect(result.newSyncState.upstreamHead).toMatchObject(e_0_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_0_0.id)
-        expect(result.newEvents).toStrictEqual([])
+        expectEventArraysEqual(result.newEvents, [])
+        expectEventArraysEqual(result.confirmedEvents, [e_0_0])
       })
 
-      it('should acknowledge partial pending event when receiving matching event', () => {
+      it('should confirm partial pending event when receiving matching event', () => {
         const syncState = new SyncState.SyncState({
           pending: [e_0_0, e_1_0],
-          rollbackTail: [],
           upstreamHead: EventId.ROOT,
           localHead: e_1_0.id,
         })
-        const result = run({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_0] } })
+        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_0] } })
 
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [e_1_0])
-        expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_0])
         expect(result.newSyncState.upstreamHead).toMatchObject(e_0_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_1_0.id)
-        expect(result.newEvents).toStrictEqual([])
+        expectEventArraysEqual(result.newEvents, [])
+        expectEventArraysEqual(result.confirmedEvents, [e_0_0])
       })
 
-      it('should acknowledge pending event and add new event', () => {
+      it('should confirm pending event and add new event', () => {
         const syncState = new SyncState.SyncState({
           pending: [e_0_0],
-          rollbackTail: [],
           upstreamHead: EventId.ROOT,
           localHead: e_0_0.id,
         })
-        const result = run({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_0, e_0_1] } })
+        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_0, e_0_1] } })
 
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [])
-        expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_0, e_0_1])
         expect(result.newSyncState.upstreamHead).toMatchObject(e_0_1.id)
         expect(result.newSyncState.localHead).toMatchObject(e_0_1.id)
         expect(result.newEvents).toStrictEqual([e_0_1])
+        expectEventArraysEqual(result.confirmedEvents, [e_0_0])
       })
 
-      it('should acknowledge pending event and add multiple new events', () => {
+      it('should confirm pending event and add multiple new events', () => {
         const syncState = new SyncState.SyncState({
           pending: [e_0_1],
-          rollbackTail: [],
           upstreamHead: e_0_0.id,
           localHead: e_0_1.id,
         })
-        const result = run({
+        const result = merge({
           syncState,
           payload: { _tag: 'upstream-advance', newEvents: [e_0_1, e_0_2, e_0_3, e_1_0, e_1_1] },
         })
 
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [])
-        expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_1, e_0_2, e_0_3, e_1_0, e_1_1])
         expect(result.newSyncState.upstreamHead).toMatchObject(e_1_1.id)
         expect(result.newSyncState.localHead).toMatchObject(e_1_1.id)
         expect(result.newEvents).toStrictEqual([e_0_2, e_0_3, e_1_0, e_1_1])
+        expectEventArraysEqual(result.confirmedEvents, [e_0_1])
       })
 
       it('should ignore client events (incoming is subset of pending)', () => {
         const syncState = new SyncState.SyncState({
           pending: [e_r_1, e_0_0],
-          rollbackTail: [],
           upstreamHead: EventId.ROOT,
           localHead: e_0_0.id,
         })
-        const result = run({
+        const result = merge({
           syncState,
           payload: { _tag: 'upstream-advance', newEvents: [e_0_0] },
-          ignoreLocalEvents: true,
+          ignoreClientEvents: true,
         })
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [])
-        expectEventArraysEqual(result.newSyncState.rollbackTail, [e_r_1, e_0_0])
         expect(result.newSyncState.upstreamHead).toMatchObject(e_0_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_0_0.id)
-        expect(result.newEvents).toStrictEqual([])
+        expectEventArraysEqual(result.newEvents, [])
+        expectEventArraysEqual(result.confirmedEvents, [e_r_1, e_0_0])
       })
 
       it('should ignore client events (incoming is subset of pending case 2)', () => {
         const syncState = new SyncState.SyncState({
           pending: [e_r_1, e_0_0, e_1_0],
-          rollbackTail: [],
           upstreamHead: EventId.ROOT,
           localHead: e_0_0.id,
         })
-        const result = run({
+        const result = merge({
           syncState,
           payload: { _tag: 'upstream-advance', newEvents: [e_0_0] },
-          ignoreLocalEvents: true,
+          ignoreClientEvents: true,
         })
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [e_1_0])
-        expectEventArraysEqual(result.newSyncState.rollbackTail, [e_r_1, e_0_0])
         expect(result.newSyncState.upstreamHead).toMatchObject(e_0_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_1_0.id)
-        expect(result.newEvents).toStrictEqual([])
+        expectEventArraysEqual(result.newEvents, [])
+        expectEventArraysEqual(result.confirmedEvents, [e_r_1, e_0_0])
       })
 
       it('should ignore client events (incoming goes beyond pending)', () => {
         const syncState = new SyncState.SyncState({
           pending: [e_r_1, e_0_0, e_0_1],
-          rollbackTail: [],
           upstreamHead: EventId.ROOT,
           localHead: e_0_1.id,
         })
-        const result = run({
+        const result = merge({
           syncState,
           payload: { _tag: 'upstream-advance', newEvents: [e_0_0, e_1_0] },
-          ignoreLocalEvents: true,
+          ignoreClientEvents: true,
         })
 
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [])
-        expectEventArraysEqual(result.newSyncState.rollbackTail, [e_r_1, e_0_0, e_0_1, e_1_0])
         expect(result.newSyncState.upstreamHead).toMatchObject(e_1_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_1_0.id)
         expect(result.newEvents).toStrictEqual([e_1_0])
+        expectEventArraysEqual(result.confirmedEvents, [e_r_1, e_0_0, e_0_1])
       })
 
       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] } })
+        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_0] } })
         expect(result).toMatchObject({ _tag: 'unexpected-error' })
       })
     })
@@ -347,60 +330,35 @@ describe('syncstate', () => {
       it('should rebase single client event to end', () => {
         const syncState = new SyncState.SyncState({
           pending: [e_0_0],
-          rollbackTail: [],
           upstreamHead: EventId.ROOT,
           localHead: e_0_0.id,
         })
-        const result = run({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_1] } })
+        const result = merge({ syncState, payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e_0_1] }) })
 
         const e_0_0_e_0_2 = e_0_0.rebase_(e_0_1.id)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e_0_0_e_0_2])
-        expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_1])
         expect(result.newSyncState.upstreamHead).toMatchObject(e_0_1.id)
         expect(result.newSyncState.localHead).toMatchObject(e_0_0_e_0_2.id)
-        expectEventArraysEqual(result.eventsToRollback, [e_0_0])
+        expectEventArraysEqual(result.rollbackEvents, [e_0_0])
         expectEventArraysEqual(result.newEvents, [e_0_1, e_0_0_e_0_2])
       })
 
-      it('should rebase different event with same id (no rollback tail)', () => {
-        const e_0_0_b = new TestEvent({ global: 0, client: 0 }, EventId.ROOT, '0_0_b', true)
-        const syncState = new SyncState.SyncState({
-          pending: [e_0_0_b],
-          rollbackTail: [],
-          upstreamHead: EventId.ROOT,
-          localHead: e_0_0_b.id,
-        })
-        const result = run({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_0] } })
-
-        const e_0_0_e_1_0 = e_0_0_b.rebase_(e_0_0.id)
-
-        expectRebase(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e_0_0_e_1_0])
-        expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_0])
-        expectEventArraysEqual(result.newEvents, [e_0_0, e_0_0_e_1_0])
-        expectEventArraysEqual(result.eventsToRollback, [e_0_0_b])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e_0_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e_0_0_e_1_0.id)
-      })
-
       it('should rebase different event with same id', () => {
         const e_1_0_b = new TestEvent({ global: 1, client: 0 }, e_0_0.id, '1_0_b', false)
         const syncState = new SyncState.SyncState({
           pending: [e_1_0_b],
-          rollbackTail: [e_0_0, e_0_1],
           upstreamHead: EventId.ROOT,
           localHead: e_1_0_b.id,
         })
-        const result = run({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_1_0] } })
+        const result = merge({ syncState, payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e_1_0] }) })
         const e_1_0_e_2_0 = e_1_0_b.rebase_(e_1_0.id)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e_1_0_e_2_0])
-        expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_0, e_0_1, e_1_0])
         expectEventArraysEqual(result.newEvents, [e_1_0, e_1_0_e_2_0])
-        expectEventArraysEqual(result.eventsToRollback, [e_0_0, e_0_1, e_1_0_b])
+        expectEventArraysEqual(result.rollbackEvents, [e_1_0_b])
         expect(result.newSyncState.upstreamHead).toMatchObject(e_1_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_1_0_e_2_0.id)
       })
@@ -408,20 +366,18 @@ describe('syncstate', () => {
       it('should rebase single client event to end (more incoming events)', () => {
         const syncState = new SyncState.SyncState({
           pending: [e_0_0],
-          rollbackTail: [],
           upstreamHead: EventId.ROOT,
           localHead: e_0_0.id,
         })
-        const result = run({
+        const result = merge({
           syncState,
-          payload: { _tag: 'upstream-advance', newEvents: [e_0_1, e_0_2, e_0_3, e_1_0] },
+          payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e_0_1, e_0_2, e_0_3, e_1_0] }),
         })
 
         const e_0_0_e_2_0 = e_0_0.rebase_(e_1_0.id)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e_0_0_e_2_0])
-        expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_1, e_0_2, e_0_3, e_1_0])
         expect(result.newSyncState.upstreamHead).toMatchObject(e_1_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_0_0_e_2_0.id)
       })
@@ -429,21 +385,19 @@ describe('syncstate', () => {
       it('should only rebase divergent events when first event matches', () => {
         const syncState = new SyncState.SyncState({
           pending: [e_0_0, e_0_1],
-          rollbackTail: [],
           upstreamHead: EventId.ROOT,
           localHead: e_0_0.id,
         })
-        const result = run({
+        const result = merge({
           syncState,
-          payload: { _tag: 'upstream-advance', newEvents: [e_0_0, e_0_2, e_0_3, e_1_0] },
+          payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e_0_0, e_0_2, e_0_3, e_1_0] }),
         })
 
         const e_0_1_e_1_1 = e_0_1.rebase_(e_1_0.id)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e_0_1_e_1_1])
-        expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_0, e_0_2, e_0_3, e_1_0])
-        expectEventArraysEqual(result.eventsToRollback, [e_0_1])
+        expectEventArraysEqual(result.rollbackEvents, [e_0_1])
         expectEventArraysEqual(result.newEvents, [e_0_2, e_0_3, e_1_0, e_0_1_e_1_1])
         expect(result.newSyncState.upstreamHead).toMatchObject(e_1_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_0_1_e_1_1.id)
@@ -452,13 +406,12 @@ describe('syncstate', () => {
       it('should rebase all client events when incoming chain starts differently', () => {
         const syncState = new SyncState.SyncState({
           pending: [e_0_0, e_0_1],
-          rollbackTail: [],
           upstreamHead: EventId.ROOT,
           localHead: e_0_1.id,
         })
-        const result = run({
+        const result = merge({
           syncState,
-          payload: { _tag: 'upstream-advance', newEvents: [e_0_1, e_0_2, e_0_3, e_1_0] },
+          payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e_0_1, e_0_2, e_0_3, e_1_0] }),
         })
 
         const e_0_0_e_1_1 = e_0_0.rebase_(e_1_0.id)
@@ -466,9 +419,8 @@ describe('syncstate', () => {
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e_0_0_e_1_1, e_0_1_e_1_2])
-        expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_1, e_0_2, e_0_3, e_1_0])
         expectEventArraysEqual(result.newEvents, [e_0_1, e_0_2, e_0_3, e_1_0, e_0_0_e_1_1, e_0_1_e_1_2])
-        expectEventArraysEqual(result.eventsToRollback, [e_0_0, e_0_1])
+        expectEventArraysEqual(result.rollbackEvents, [e_0_0, e_0_1])
         expect(result.newSyncState.upstreamHead).toMatchObject(e_1_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_0_1_e_1_2.id)
       })
@@ -478,18 +430,20 @@ describe('syncstate', () => {
           it('should advance with new events', () => {
             const syncState = new SyncState.SyncState({
               pending: [e_0_0],
-              rollbackTail: [],
               upstreamHead: EventId.ROOT,
               localHead: e_0_0.id,
             })
-            const result = run({ syncState, payload: { _tag: 'local-push', newEvents: [e_0_1, e_0_2, e_0_3] } })
+            const result = merge({
+              syncState,
+              payload: SyncState.PayloadLocalPush.make({ newEvents: [e_0_1, e_0_2, e_0_3] }),
+            })
 
             expectAdvance(result)
             expectEventArraysEqual(result.newSyncState.pending, [e_0_0, e_0_1, e_0_2, e_0_3])
-            expectEventArraysEqual(result.newSyncState.rollbackTail, [])
             expect(result.newSyncState.upstreamHead).toMatchObject(EventId.ROOT)
             expect(result.newSyncState.localHead).toMatchObject(e_0_3.id)
             expectEventArraysEqual(result.newEvents, [e_0_1, e_0_2, e_0_3])
+            expectEventArraysEqual(result.confirmedEvents, [])
           })
         })
 
@@ -497,11 +451,13 @@ describe('syncstate', () => {
           it('should reject when new events are greater than pending events', () => {
             const syncState = new SyncState.SyncState({
               pending: [e_0_0, e_0_1],
-              rollbackTail: [],
               upstreamHead: EventId.ROOT,
               localHead: e_0_1.id,
             })
-            const result = run({ syncState, payload: { _tag: 'local-push', newEvents: [e_0_1, e_0_2] } })
+            const result = merge({
+              syncState,
+              payload: SyncState.PayloadLocalPush.make({ newEvents: [e_0_1, e_0_2] }),
+            })
 
             expectReject(result)
             expect(result.expectedMinimumId).toMatchObject(e_0_2.id)
@@ -526,19 +482,19 @@ const expectEventArraysEqual = (
 }
 
 function expectAdvance(
-  result: typeof SyncState.UpdateResult.Type,
-): asserts result is typeof SyncState.UpdateResultAdvance.Type {
+  result: typeof SyncState.MergeResult.Type,
+): asserts result is typeof SyncState.MergeResultAdvance.Type {
   expect(result._tag).toBe('advance')
 }
 
 function expectRebase(
-  result: typeof SyncState.UpdateResult.Type,
-): asserts result is typeof SyncState.UpdateResultRebase.Type {
-  expect(result._tag).toBe('rebase')
+  result: typeof SyncState.MergeResult.Type,
+): asserts result is typeof SyncState.MergeResultRebase.Type {
+  expect(result._tag, `Expected rebase, got ${result}`).toBe('rebase')
 }
 
 function expectReject(
-  result: typeof SyncState.UpdateResult.Type,
-): asserts result is typeof SyncState.UpdateResultReject.Type {
+  result: typeof SyncState.MergeResult.Type,
+): asserts result is typeof SyncState.MergeResultReject.Type {
   expect(result._tag).toBe('reject')
 }