@livestore/common 0.0.0-snapshot-2ef046b02334f52613d31dbe06af53487685edc0 → 0.0.0-snapshot-8115ad48d5a57244358c943ecc92bb0a30274b87

package/src/sync/syncstate.test.ts

@@ -2,10 +2,10 @@
 import { describe, expect, it } from 'vitest'
 
 import * as EventId from '../schema/EventId.js'
-import * as MutationEvent from '../schema/MutationEvent.js'
+import * as LiveStoreEvent from '../schema/LiveStoreEvent.js'
 import * as SyncState from './syncstate.js'
 
-class TestEvent extends MutationEvent.EncodedWithMeta {
+class TestEvent extends LiveStoreEvent.EncodedWithMeta {
   constructor(
     id: EventId.EventId | typeof EventId.EventId.Encoded,
     parentId: EventId.EventId,
@@ -15,7 +15,7 @@ class TestEvent extends MutationEvent.EncodedWithMeta {
     super({
       id: EventId.make(id),
       parentId: EventId.make(parentId),
-      mutation: 'a',
+      name: 'a',
       args: payload,
       clientId: 'static-local-id',
       sessionId: 'static-session-id',
@@ -31,18 +31,17 @@ class TestEvent extends MutationEvent.EncodedWithMeta {
   // toString = () => this.toJSON()
 }
 
-const e_r_1 = new TestEvent({ global: -1, client: 1 }, EventId.ROOT, 'a', true)
-const e_0_0 = new TestEvent({ global: 0, client: 0 }, EventId.ROOT, 'a', false)
-const e_0_1 = new TestEvent({ global: 0, client: 1 }, e_0_0.id, 'a', true)
-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 e0_1 = new TestEvent({ global: 0, client: 1 }, EventId.ROOT, 'a', true)
+const e1_0 = new TestEvent({ global: 1, client: 0 }, EventId.ROOT, 'a', false)
+const e1_1 = new TestEvent({ global: 1, client: 1 }, e1_0.id, 'a', true)
+const e1_2 = new TestEvent({ global: 1, client: 2 }, e1_1.id, 'a', true)
+const e1_3 = new TestEvent({ global: 1, client: 3 }, e1_2.id, 'a', true)
+const e2_0 = new TestEvent({ global: 2, client: 0 }, e1_0.id, 'a', false)
+const e2_1 = new TestEvent({ global: 2, client: 1 }, e2_0.id, 'a', true)
 
-const isEqualEvent = MutationEvent.isEqualEncoded
+const isEqualEvent = LiveStoreEvent.isEqualEncoded
 
-const isClientEvent = (event: MutationEvent.EncodedWithMeta) => (event as TestEvent).isLocal
+const isClientEvent = (event: LiveStoreEvent.EncodedWithMeta) => (event as TestEvent).isLocal
 
 describe('syncstate', () => {
   describe('merge', () => {
@@ -59,269 +58,261 @@ describe('syncstate', () => {
     describe('upstream-rebase', () => {
       it('should rollback until start', () => {
         const syncState = new SyncState.SyncState({
-          pending: [e_1_0],
+          pending: [e2_0],
           upstreamHead: EventId.ROOT,
-          localHead: e_1_0.id,
+          localHead: e2_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 e1_0_e2_0 = e1_0.rebase_(e2_0.id)
+        const e1_1_e2_1 = e1_1.rebase_(e1_0_e2_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],
+            rollbackEvents: [e1_0, e1_1],
+            newEvents: [e1_0_e2_0, e1_1_e2_1],
           }),
         })
-        const e_1_0_e_2_0 = e_1_0.rebase_(e_0_0_e_1_0.id)
+        const e2_0_e3_0 = e2_0.rebase_(e1_0_e2_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])
+        expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
+        expect(result.newSyncState.upstreamHead).toMatchObject(e1_1_e2_1.id)
+        expect(result.newSyncState.localHead).toMatchObject(e2_0_e3_0.id)
+        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: [e_1_0],
+          pending: [e2_0],
           upstreamHead: EventId.ROOT,
-          localHead: e_1_0.id,
+          localHead: e2_0.id,
         })
-        const e_0_1_e_1_0 = e_0_1.rebase_(e_0_0.id)
+        const e1_1_e2_0 = e1_1.rebase_(e1_0.id)
         const result = merge({
           syncState,
           payload: SyncState.PayloadUpstreamRebase.make({
-            newEvents: [e_0_1_e_1_0],
-            rollbackEvents: [e_0_1],
+            newEvents: [e1_1_e2_0],
+            rollbackEvents: [e1_1],
           }),
         })
-        const e_1_0_e_2_0 = e_1_0.rebase_(e_0_1_e_1_0.id)
+        const e2_0_e3_0 = e2_0.rebase_(e1_1_e2_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])
+        expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
+        expect(result.newSyncState.upstreamHead).toMatchObject(e1_1_e2_0.id)
+        expect(result.newSyncState.localHead).toMatchObject(e2_0_e3_0.id)
+        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: EventId.ROOT,
-          localHead: e_0_0.id,
+          localHead: e1_0.id,
         })
         const result = merge({
           syncState,
-          payload: SyncState.PayloadUpstreamRebase.make({ rollbackEvents: [e_0_0], newEvents: [e_1_0] }),
+          payload: SyncState.PayloadUpstreamRebase.make({ rollbackEvents: [e1_0], newEvents: [e2_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, [])
+        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.id)
+        expect(result.newSyncState.localHead).toMatchObject(e2_0.id)
+        expect(result.newEvents).toStrictEqual([e2_0])
       })
     })
 
     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],
+          pending: [e1_0],
           upstreamHead: EventId.ROOT,
-          localHead: e_0_0.id,
+          localHead: e1_0.id,
         })
-        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_1, e_0_0] } })
+        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_1, e1_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],
+          pending: [e1_0],
           upstreamHead: EventId.ROOT,
-          localHead: e_0_0.id,
+          localHead: e1_0.id,
         })
-        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_1_0, e_0_0] } })
+        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e2_0, e1_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,
+          upstreamHead: e2_0.id,
+          localHead: e2_0.id,
         })
-        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_0] } })
+        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_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,
+          upstreamHead: e2_0.id,
+          localHead: e2_0.id,
         })
-        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_2_0] } })
+        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e2_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],
+          pending: [e1_0],
           upstreamHead: EventId.ROOT,
-          localHead: e_0_0.id,
+          localHead: e1_0.id,
         })
-        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_0] } })
+        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0] } })
 
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e_0_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e_0_0.id)
+        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.id)
+        expect(result.newSyncState.localHead).toMatchObject(e1_0.id)
         expectEventArraysEqual(result.newEvents, [])
-        expectEventArraysEqual(result.confirmedEvents, [e_0_0])
+        expectEventArraysEqual(result.confirmedEvents, [e1_0])
       })
 
       it('should confirm partial pending event when receiving matching event', () => {
         const syncState = new SyncState.SyncState({
-          pending: [e_0_0, e_1_0],
+          pending: [e1_0, e2_0],
           upstreamHead: EventId.ROOT,
-          localHead: e_1_0.id,
+          localHead: e2_0.id,
         })
-        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_0] } })
+        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0] } })
 
         expectAdvance(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e_1_0])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e_0_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e_1_0.id)
+        expectEventArraysEqual(result.newSyncState.pending, [e2_0])
+        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.id)
+        expect(result.newSyncState.localHead).toMatchObject(e2_0.id)
         expectEventArraysEqual(result.newEvents, [])
-        expectEventArraysEqual(result.confirmedEvents, [e_0_0])
+        expectEventArraysEqual(result.confirmedEvents, [e1_0])
       })
 
       it('should confirm pending event and add new event', () => {
         const syncState = new SyncState.SyncState({
-          pending: [e_0_0],
+          pending: [e1_0],
           upstreamHead: EventId.ROOT,
-          localHead: e_0_0.id,
+          localHead: e1_0.id,
         })
-        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_0, e_0_1] } })
+        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0, e1_1] } })
 
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [])
-        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])
+        expect(result.newSyncState.upstreamHead).toMatchObject(e1_1.id)
+        expect(result.newSyncState.localHead).toMatchObject(e1_1.id)
+        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: [e_0_1],
-          upstreamHead: e_0_0.id,
-          localHead: e_0_1.id,
+          pending: [e1_1],
+          upstreamHead: e1_0.id,
+          localHead: e1_1.id,
         })
         const result = merge({
           syncState,
-          payload: { _tag: 'upstream-advance', newEvents: [e_0_1, e_0_2, e_0_3, e_1_0, e_1_1] },
+          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(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])
+        expect(result.newSyncState.upstreamHead).toMatchObject(e2_1.id)
+        expect(result.newSyncState.localHead).toMatchObject(e2_1.id)
+        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: EventId.ROOT,
+          localHead: e1_1.id,
+        })
+        const result = merge({
+          syncState,
+          payload: { _tag: 'upstream-advance', newEvents: [e1_0] },
+        })
+
+        expectAdvance(result)
+        expectEventArraysEqual(result.newSyncState.pending, [e1_1])
+        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.id)
+        expect(result.newSyncState.localHead).toMatchObject(e1_1.id)
+        expectEventArraysEqual(result.newEvents, [])
+        expectEventArraysEqual(result.confirmedEvents, [e1_0])
       })
 
       it('should ignore client events (incoming is subset of pending)', () => {
         const syncState = new SyncState.SyncState({
-          pending: [e_r_1, e_0_0],
+          pending: [e0_1, e1_0],
           upstreamHead: EventId.ROOT,
-          localHead: e_0_0.id,
+          localHead: e1_0.id,
         })
         const result = merge({
           syncState,
-          payload: { _tag: 'upstream-advance', newEvents: [e_0_0] },
+          payload: { _tag: 'upstream-advance', newEvents: [e1_0] },
           ignoreClientEvents: true,
         })
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e_0_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e_0_0.id)
+        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.id)
+        expect(result.newSyncState.localHead).toMatchObject(e1_0.id)
         expectEventArraysEqual(result.newEvents, [])
-        expectEventArraysEqual(result.confirmedEvents, [e_r_1, e_0_0])
+        expectEventArraysEqual(result.confirmedEvents, [e0_1, e1_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],
+          pending: [e0_1, e1_0, e2_0],
           upstreamHead: EventId.ROOT,
-          localHead: e_0_0.id,
+          localHead: e1_0.id,
         })
         const result = merge({
           syncState,
-          payload: { _tag: 'upstream-advance', newEvents: [e_0_0] },
+          payload: { _tag: 'upstream-advance', newEvents: [e1_0] },
           ignoreClientEvents: true,
         })
         expectAdvance(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e_1_0])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e_0_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e_1_0.id)
+        expectEventArraysEqual(result.newSyncState.pending, [e2_0])
+        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.id)
+        expect(result.newSyncState.localHead).toMatchObject(e2_0.id)
         expectEventArraysEqual(result.newEvents, [])
-        expectEventArraysEqual(result.confirmedEvents, [e_r_1, e_0_0])
+        expectEventArraysEqual(result.confirmedEvents, [e0_1, e1_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],
+          pending: [e0_1, e1_0, e1_1],
           upstreamHead: EventId.ROOT,
-          localHead: e_0_1.id,
+          localHead: e1_1.id,
         })
         const result = merge({
           syncState,
-          payload: { _tag: 'upstream-advance', newEvents: [e_0_0, e_1_0] },
+          payload: { _tag: 'upstream-advance', newEvents: [e1_0, e2_0] },
           ignoreClientEvents: true,
         })
 
         expectAdvance(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])
-        expectEventArraysEqual(result.confirmedEvents, [e_r_1, e_0_0, e_0_1])
+        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.id)
+        expect(result.newSyncState.localHead).toMatchObject(e2_0.id)
+        expect(result.newEvents).toStrictEqual([e2_0])
+        expectEventArraysEqual(result.confirmedEvents, [e0_1, e1_0, e1_1])
       })
 
       it('should fail if incoming event is ≤ local head', () => {
         const syncState = new SyncState.SyncState({
           pending: [],
-          upstreamHead: e_1_0.id,
-          localHead: e_1_0.id,
+          upstreamHead: e2_0.id,
+          localHead: e2_0.id,
         })
-        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_0] } })
+        const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0] } })
         expect(result).toMatchObject({ _tag: 'unexpected-error' })
       })
     })
@@ -329,120 +320,120 @@ describe('syncstate', () => {
     describe('upstream-advance: rebase', () => {
       it('should rebase single client event to end', () => {
         const syncState = new SyncState.SyncState({
-          pending: [e_0_0],
+          pending: [e1_0],
           upstreamHead: EventId.ROOT,
-          localHead: e_0_0.id,
+          localHead: e1_0.id,
         })
-        const result = merge({ syncState, payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e_0_1] }) })
+        const result = merge({ syncState, payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1] }) })
 
-        const e_0_0_e_0_2 = e_0_0.rebase_(e_0_1.id)
+        const e1_0_e1_2 = e1_0.rebase_(e1_1.id)
 
         expectRebase(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e_0_0_e_0_2])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e_0_1.id)
-        expect(result.newSyncState.localHead).toMatchObject(e_0_0_e_0_2.id)
-        expectEventArraysEqual(result.rollbackEvents, [e_0_0])
-        expectEventArraysEqual(result.newEvents, [e_0_1, e_0_0_e_0_2])
+        expectEventArraysEqual(result.newSyncState.pending, [e1_0_e1_2])
+        expect(result.newSyncState.upstreamHead).toMatchObject(e1_1.id)
+        expect(result.newSyncState.localHead).toMatchObject(e1_0_e1_2.id)
+        expectEventArraysEqual(result.rollbackEvents, [e1_0])
+        expectEventArraysEqual(result.newEvents, [e1_1, e1_0_e1_2])
       })
 
       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 e2_0_b = new TestEvent({ global: 1, client: 0 }, e1_0.id, '1_0_b', false)
         const syncState = new SyncState.SyncState({
-          pending: [e_1_0_b],
+          pending: [e2_0_b],
           upstreamHead: EventId.ROOT,
-          localHead: e_1_0_b.id,
+          localHead: e2_0_b.id,
         })
-        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)
+        const result = merge({ syncState, payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e2_0] }) })
+        const e2_0_e3_0 = e2_0_b.rebase_(e2_0.id)
 
         expectRebase(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e_1_0_e_2_0])
-        expectEventArraysEqual(result.newEvents, [e_1_0, e_1_0_e_2_0])
-        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)
+        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.id)
+        expect(result.newSyncState.localHead).toMatchObject(e2_0_e3_0.id)
       })
 
       it('should rebase single client event to end (more incoming events)', () => {
         const syncState = new SyncState.SyncState({
-          pending: [e_0_0],
+          pending: [e1_0],
           upstreamHead: EventId.ROOT,
-          localHead: e_0_0.id,
+          localHead: e1_0.id,
         })
         const result = merge({
           syncState,
-          payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e_0_1, e_0_2, e_0_3, e_1_0] }),
+          payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1, e1_2, e1_3, e2_0] }),
         })
 
-        const e_0_0_e_2_0 = e_0_0.rebase_(e_1_0.id)
+        const e1_0_e3_0 = e1_0.rebase_(e2_0.id)
 
         expectRebase(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e_0_0_e_2_0])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e_1_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e_0_0_e_2_0.id)
+        expectEventArraysEqual(result.newSyncState.pending, [e1_0_e3_0])
+        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.id)
+        expect(result.newSyncState.localHead).toMatchObject(e1_0_e3_0.id)
       })
 
       it('should only rebase divergent events when first event matches', () => {
         const syncState = new SyncState.SyncState({
-          pending: [e_0_0, e_0_1],
+          pending: [e1_0, e1_1],
           upstreamHead: EventId.ROOT,
-          localHead: e_0_0.id,
+          localHead: e1_0.id,
         })
         const result = merge({
           syncState,
-          payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e_0_0, e_0_2, e_0_3, e_1_0] }),
+          payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_0, e1_2, e1_3, e2_0] }),
         })
 
-        const e_0_1_e_1_1 = e_0_1.rebase_(e_1_0.id)
+        const e1_1_e2_1 = e1_1.rebase_(e2_0.id)
 
         expectRebase(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e_0_1_e_1_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)
+        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.id)
+        expect(result.newSyncState.localHead).toMatchObject(e1_1_e2_1.id)
       })
 
       it('should rebase all client events when incoming chain starts differently', () => {
         const syncState = new SyncState.SyncState({
-          pending: [e_0_0, e_0_1],
+          pending: [e1_0, e1_1],
           upstreamHead: EventId.ROOT,
-          localHead: e_0_1.id,
+          localHead: e1_1.id,
         })
         const result = merge({
           syncState,
-          payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e_0_1, e_0_2, e_0_3, e_1_0] }),
+          payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1, e1_2, e1_3, e2_0] }),
         })
 
-        const e_0_0_e_1_1 = e_0_0.rebase_(e_1_0.id)
-        const e_0_1_e_1_2 = e_0_1.rebase_(e_0_0_e_1_1.id)
+        const e1_0_e2_1 = e1_0.rebase_(e2_0.id)
+        const e1_1_e2_2 = e1_1.rebase_(e1_0_e2_1.id)
 
         expectRebase(result)
-        expectEventArraysEqual(result.newSyncState.pending, [e_0_0_e_1_1, e_0_1_e_1_2])
-        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.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)
+        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.id)
+        expect(result.newSyncState.localHead).toMatchObject(e1_1_e2_2.id)
       })
 
       describe('local-push', () => {
         describe('advance', () => {
           it('should advance with new events', () => {
             const syncState = new SyncState.SyncState({
-              pending: [e_0_0],
+              pending: [e1_0],
               upstreamHead: EventId.ROOT,
-              localHead: e_0_0.id,
+              localHead: e1_0.id,
             })
             const result = merge({
               syncState,
-              payload: SyncState.PayloadLocalPush.make({ newEvents: [e_0_1, e_0_2, e_0_3] }),
+              payload: SyncState.PayloadLocalPush.make({ newEvents: [e1_1, e1_2, e1_3] }),
             })
 
             expectAdvance(result)
-            expectEventArraysEqual(result.newSyncState.pending, [e_0_0, e_0_1, e_0_2, e_0_3])
+            expectEventArraysEqual(result.newSyncState.pending, [e1_0, e1_1, e1_2, e1_3])
             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])
+            expect(result.newSyncState.localHead).toMatchObject(e1_3.id)
+            expectEventArraysEqual(result.newEvents, [e1_1, e1_2, e1_3])
             expectEventArraysEqual(result.confirmedEvents, [])
           })
         })
@@ -450,17 +441,17 @@ describe('syncstate', () => {
         describe('reject', () => {
           it('should reject when new events are greater than pending events', () => {
             const syncState = new SyncState.SyncState({
-              pending: [e_0_0, e_0_1],
+              pending: [e1_0, e1_1],
               upstreamHead: EventId.ROOT,
-              localHead: e_0_1.id,
+              localHead: e1_1.id,
             })
             const result = merge({
               syncState,
-              payload: SyncState.PayloadLocalPush.make({ newEvents: [e_0_1, e_0_2] }),
+              payload: SyncState.PayloadLocalPush.make({ newEvents: [e1_1, e1_2] }),
             })
 
             expectReject(result)
-            expect(result.expectedMinimumId).toMatchObject(e_0_2.id)
+            expect(result.expectedMinimumId).toMatchObject(e1_2.id)
           })
         })
       })
@@ -469,14 +460,14 @@ describe('syncstate', () => {
 })
 
 const expectEventArraysEqual = (
-  actual: ReadonlyArray<MutationEvent.EncodedWithMeta>,
-  expected: ReadonlyArray<MutationEvent.EncodedWithMeta>,
+  actual: ReadonlyArray<LiveStoreEvent.EncodedWithMeta>,
+  expected: ReadonlyArray<LiveStoreEvent.EncodedWithMeta>,
 ) => {
   expect(actual.length).toBe(expected.length)
   actual.forEach((event, i) => {
     expect(event.id).toStrictEqual(expected[i]!.id)
     expect(event.parentId).toStrictEqual(expected[i]!.parentId)
-    expect(event.mutation).toStrictEqual(expected[i]!.mutation)
+    expect(event.name).toStrictEqual(expected[i]!.name)
     expect(event.args).toStrictEqual(expected[i]!.args)
   })
 }