@livestore/common 0.3.0-dev.8 → 0.3.0

package/dist/sync/syncstate.test.js

@@ -1,374 +1,397 @@
 /* eslint-disable prefer-arrow/prefer-arrow-functions */
 import { describe, expect, it } from 'vitest';
-import * as EventId from '../schema/EventId.js';
-import * as MutationEvent from '../schema/MutationEvent.js';
+import * as EventSequenceNumber from '../schema/EventSequenceNumber.js';
+import * as LiveStoreEvent from '../schema/LiveStoreEvent.js';
 import * as SyncState from './syncstate.js';
-class TestEvent extends MutationEvent.EncodedWithMeta {
+class TestEvent extends LiveStoreEvent.EncodedWithMeta {
     payload;
     isLocal;
-    constructor(id, parentId, payload, isLocal) {
+    constructor(seqNum, parentSeqNum, payload, isLocal) {
         super({
-            id: EventId.make(id),
-            parentId: EventId.make(parentId),
-            mutation: 'a',
+            seqNum: EventSequenceNumber.make(seqNum),
+            parentSeqNum: EventSequenceNumber.make(parentSeqNum),
+            name: 'a',
             args: payload,
-            meta: {},
+            clientId: 'static-local-id',
+            sessionId: 'static-session-id',
         });
         this.payload = payload;
         this.isLocal = isLocal;
     }
-    rebase_ = (parentId) => {
-        return this.rebase(parentId, this.isLocal);
+    rebase_ = (parentSeqNum) => {
+        return this.rebase(parentSeqNum, this.isLocal);
     };
 }
-const e_r_1 = new TestEvent({ global: -1, local: 1 }, EventId.ROOT, 'a', true);
-const e_0_0 = new TestEvent({ global: 0, local: 0 }, EventId.ROOT, 'a', false);
-const e_0_1 = new TestEvent({ global: 0, local: 1 }, e_0_0.id, 'a', true);
-const e_0_2 = new TestEvent({ global: 0, local: 2 }, e_0_1.id, 'a', true);
-const e_0_3 = new TestEvent({ global: 0, local: 3 }, e_0_2.id, 'a', true);
-const e_1_0 = new TestEvent({ global: 1, local: 0 }, e_0_0.id, 'a', false);
-const e_1_1 = new TestEvent({ global: 1, local: 1 }, e_1_0.id, 'a', true);
-const e_2_0 = new TestEvent({ global: 2, local: 0 }, e_1_0.id, 'a', false);
-const isEqualEvent = MutationEvent.isEqualEncoded;
-const isLocalEvent = (event) => event.isLocal;
+const e0_1 = new TestEvent({ global: 0, client: 1 }, EventSequenceNumber.ROOT, 'a', true);
+const e1_0 = new TestEvent({ global: 1, client: 0 }, EventSequenceNumber.ROOT, 'a', false);
+const e1_1 = new TestEvent({ global: 1, client: 1 }, e1_0.seqNum, 'a', true);
+const e1_2 = new TestEvent({ global: 1, client: 2 }, e1_1.seqNum, 'a', true);
+const e1_3 = new TestEvent({ global: 1, client: 3 }, e1_2.seqNum, 'a', true);
+const e2_0 = new TestEvent({ global: 2, client: 0 }, e1_0.seqNum, 'a', false);
+const e2_1 = new TestEvent({ global: 2, client: 1 }, e2_0.seqNum, 'a', true);
+const isEqualEvent = LiveStoreEvent.isEqualEncoded;
+const isClientEvent = (event) => event.isLocal;
 describe('syncstate', () => {
-    describe('updateSyncState', () => {
-        const run = ({ syncState, payload, ignoreLocalEvents = false, }) => SyncState.updateSyncState({ syncState, payload, isLocalEvent, isEqualEvent, ignoreLocalEvents });
-        describe.each([{ trimRollbackUntil: false }, { trimRollbackUntil: true }])('upstream-rebase (trimRollbackUntil: $trimRollbackUntil)', ({ trimRollbackUntil }) => {
+    describe('merge', () => {
+        const merge = ({ syncState, payload, ignoreClientEvents = false, }) => SyncState.merge({ syncState, payload, isClientEvent, isEqualEvent, ignoreClientEvents });
+        describe('upstream-rebase', () => {
             it('should rollback until start', () => {
-                const 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({
+                const syncState = new SyncState.SyncState({
+                    pending: [e2_0],
+                    upstreamHead: EventSequenceNumber.ROOT,
+                    localHead: e2_0.seqNum,
+                });
+                const e1_0_e2_0 = e1_0.rebase_(e2_0.seqNum);
+                const e1_1_e2_1 = e1_1.rebase_(e1_0_e2_0.seqNum);
+                const result = merge({
                     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);
+                    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);
                 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).toBe(e_0_1_e_1_1.id);
-                expect(result.newSyncState.localHead).toMatchObject(e_1_0_e_2_0.id);
-                expectEventArraysEqual(result.newEvents, [e_0_0_e_1_0, e_0_1_e_1_1]);
-                expectEventArraysEqual(result.eventsToRollback, [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.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 = {
-                    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({
+                const syncState = new SyncState.SyncState({
+                    pending: [e2_0],
+                    upstreamHead: EventSequenceNumber.ROOT,
+                    localHead: e2_0.seqNum,
+                });
+                const e1_1_e2_0 = e1_1.rebase_(e1_0.seqNum);
+                const result = merge({
                     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);
+                    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);
                 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).toBe(e_0_1_e_1_0.id);
-                expect(result.newSyncState.localHead).toMatchObject(e_1_0_e_2_0.id);
-                expectEventArraysEqual(result.newEvents, [e_0_1_e_1_0]);
-                expectEventArraysEqual(result.eventsToRollback, [e_0_1, e_1_0]);
+                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 = { 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] },
+                const syncState = new SyncState.SyncState({
+                    pending: [],
+                    upstreamHead: EventSequenceNumber.ROOT,
+                    localHead: e1_0.seqNum,
                 });
-                expectRebase(result);
-                expectEventArraysEqual(result.newSyncState.pending, []);
-                expectEventArraysEqual(result.newSyncState.rollbackTail, [e_1_0]);
-                expect(result.newSyncState.upstreamHead).toBe(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 = { pending: [], rollbackTail: [], upstreamHead: EventId.ROOT, localHead: e_0_0.id };
-                expect(() => run({
-                    syncState,
-                    payload: { _tag: 'upstream-rebase', rollbackUntil: e_0_0.id, newEvents: [e_1_0] },
-                })).toThrow();
-            });
-            it('should work for empty incoming', () => {
-                const syncState = { pending: [], rollbackTail: [e_0_0], upstreamHead: EventId.ROOT, localHead: e_0_0.id };
-                const result = run({
+                const result = merge({
                     syncState,
-                    payload: { _tag: 'upstream-rebase', rollbackUntil: e_0_0.id, newEvents: [] },
+                    payload: SyncState.PayloadUpstreamRebase.make({ rollbackEvents: [e1_0], newEvents: [e2_0] }),
                 });
                 expectRebase(result);
                 expectEventArraysEqual(result.newSyncState.pending, []);
-                expectEventArraysEqual(result.newSyncState.rollbackTail, []);
-                expect(result.newSyncState.upstreamHead).toBe(EventId.ROOT);
-                expect(result.newSyncState.localHead).toMatchObject(EventId.ROOT);
-                expect(result.newEvents).toStrictEqual([]);
+                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 eventId (local)', () => {
-                const syncState = { pending: [e_0_0], rollbackTail: [], upstreamHead: EventId.ROOT, localHead: e_0_0.id };
-                expect(() => run({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_1, e_0_0] } })).toThrow();
+            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.ROOT,
+                    localHead: e1_0.seqNum,
+                });
+                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 = { pending: [e_0_0], rollbackTail: [], upstreamHead: EventId.ROOT, localHead: e_0_0.id };
-                expect(() => run({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_1_0, e_0_0] } })).toThrow();
+            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.ROOT,
+                    localHead: e1_0.seqNum,
+                });
+                const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e2_0, e1_0] } });
+                expect(result).toMatchObject({ _tag: 'unexpected-error' });
             });
-            it('should acknowledge pending event when receiving matching event', () => {
-                const 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] } });
+            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: 'unexpected-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: 'unexpected-error' });
+            });
+            it('should confirm pending event when receiving matching event', () => {
+                const syncState = new SyncState.SyncState({
+                    pending: [e1_0],
+                    upstreamHead: EventSequenceNumber.ROOT,
+                    localHead: e1_0.seqNum,
+                });
+                const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0] } });
                 expectAdvance(result);
                 expectEventArraysEqual(result.newSyncState.pending, []);
-                expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_0]);
-                expect(result.newSyncState.upstreamHead).toBe(e_0_0.id);
-                expect(result.newSyncState.localHead).toMatchObject(e_0_0.id);
-                expect(result.newEvents).toStrictEqual([]);
+                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 acknowledge partial pending event when receiving matching event', () => {
-                const 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] } });
+            it('should confirm partial pending event when receiving matching event', () => {
+                const syncState = new SyncState.SyncState({
+                    pending: [e1_0, e2_0],
+                    upstreamHead: EventSequenceNumber.ROOT,
+                    localHead: e2_0.seqNum,
+                });
+                const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0] } });
                 expectAdvance(result);
-                expectEventArraysEqual(result.newSyncState.pending, [e_1_0]);
-                expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_0]);
-                expect(result.newSyncState.upstreamHead).toBe(e_0_0.id);
-                expect(result.newSyncState.localHead).toMatchObject(e_1_0.id);
-                expect(result.newEvents).toStrictEqual([]);
+                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 acknowledge pending event and add new event', () => {
-                const 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] } });
+            it('should confirm pending event and add new event', () => {
+                const syncState = new SyncState.SyncState({
+                    pending: [e1_0],
+                    upstreamHead: EventSequenceNumber.ROOT,
+                    localHead: e1_0.seqNum,
+                });
+                const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0, e1_1] } });
                 expectAdvance(result);
                 expectEventArraysEqual(result.newSyncState.pending, []);
-                expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_0, e_0_1]);
-                expect(result.newSyncState.upstreamHead).toBe(e_0_1.id);
-                expect(result.newSyncState.localHead).toMatchObject(e_0_1.id);
-                expect(result.newEvents).toStrictEqual([e_0_1]);
+                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 acknowledge pending event and add multiple new events', () => {
-                const syncState = { pending: [e_0_1], rollbackTail: [], upstreamHead: e_0_0.id, localHead: e_0_1.id };
-                const result = run({
+            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: [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, []);
-                expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_1, e_0_2, e_0_3, e_1_0, e_1_1]);
-                expect(result.newSyncState.upstreamHead).toBe(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]);
+                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 ignore local events (incoming is subset of pending)', () => {
-                const syncState = {
-                    pending: [e_r_1, e_0_0],
-                    rollbackTail: [],
-                    upstreamHead: EventId.ROOT,
-                    localHead: e_0_0.id,
-                };
-                const result = run({
+            it('should confirm pending global event while keep pending client events', () => {
+                const syncState = new SyncState.SyncState({
+                    pending: [e1_0, e1_1],
+                    upstreamHead: EventSequenceNumber.ROOT,
+                    localHead: e1_1.seqNum,
+                });
+                const result = merge({
                     syncState,
-                    payload: { _tag: 'upstream-advance', newEvents: [e_0_0] },
-                    ignoreLocalEvents: true,
+                    payload: { _tag: 'upstream-advance', newEvents: [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]);
+            });
+            it('should ignore client events (incoming is subset of pending)', () => {
+                const syncState = new SyncState.SyncState({
+                    pending: [e0_1, e1_0],
+                    upstreamHead: EventSequenceNumber.ROOT,
+                    localHead: e1_0.seqNum,
+                });
+                const result = merge({
+                    syncState,
+                    payload: { _tag: 'upstream-advance', newEvents: [e1_0] },
+                    ignoreClientEvents: true,
                 });
                 expectAdvance(result);
                 expectEventArraysEqual(result.newSyncState.pending, []);
-                expectEventArraysEqual(result.newSyncState.rollbackTail, [e_r_1, e_0_0]);
-                expect(result.newSyncState.upstreamHead).toBe(e_0_0.id);
-                expect(result.newSyncState.localHead).toMatchObject(e_0_0.id);
-                expect(result.newEvents).toStrictEqual([]);
+                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]);
             });
-            it('should ignore local events (incoming is subset of pending case 2)', () => {
-                const syncState = {
-                    pending: [e_r_1, e_0_0, e_1_0],
-                    rollbackTail: [],
-                    upstreamHead: EventId.ROOT,
-                    localHead: e_0_0.id,
-                };
-                const result = run({
+            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.ROOT,
+                    localHead: e1_0.seqNum,
+                });
+                const result = merge({
                     syncState,
-                    payload: { _tag: 'upstream-advance', newEvents: [e_0_0] },
-                    ignoreLocalEvents: true,
+                    payload: { _tag: 'upstream-advance', newEvents: [e1_0] },
+                    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).toBe(e_0_0.id);
-                expect(result.newSyncState.localHead).toMatchObject(e_1_0.id);
-                expect(result.newEvents).toStrictEqual([]);
+                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]);
             });
-            it('should ignore local events (incoming goes beyond pending)', () => {
-                const syncState = {
-                    pending: [e_r_1, e_0_0, e_0_1],
-                    rollbackTail: [],
-                    upstreamHead: EventId.ROOT,
-                    localHead: e_0_1.id,
-                };
-                const result = run({
+            it('should ignore client events (incoming goes beyond pending)', () => {
+                const syncState = new SyncState.SyncState({
+                    pending: [e0_1, e1_0, e1_1],
+                    upstreamHead: EventSequenceNumber.ROOT,
+                    localHead: e1_1.seqNum,
+                });
+                const result = merge({
                     syncState,
-                    payload: { _tag: 'upstream-advance', newEvents: [e_0_0, e_1_0] },
-                    ignoreLocalEvents: true,
+                    payload: { _tag: 'upstream-advance', newEvents: [e1_0, e2_0] },
+                    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).toBe(e_1_0.id);
-                expect(result.newSyncState.localHead).toMatchObject(e_1_0.id);
-                expect(result.newEvents).toStrictEqual([e_1_0]);
+                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]);
+            });
+            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: 'unexpected-error' });
             });
         });
         describe('upstream-advance: rebase', () => {
-            it('should rebase single local event to end', () => {
-                const 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 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).toBe(e_0_1.id);
-                expect(result.newSyncState.localHead).toMatchObject(e_0_0_e_0_2.id);
-                expectEventArraysEqual(result.eventsToRollback, [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, local: 0 }, EventId.ROOT, '0_0_b', true);
-                const 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);
+            it('should rebase single client event to end', () => {
+                const syncState = new SyncState.SyncState({
+                    pending: [e1_0],
+                    upstreamHead: EventSequenceNumber.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);
                 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).toBe(e_0_0.id);
-                expect(result.newSyncState.localHead).toMatchObject(e_0_0_e_1_0.id);
+                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 e_1_0_b = new TestEvent({ global: 1, local: 0 }, e_0_0.id, '1_0_b', false);
-                const 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 e_1_0_e_2_0 = e_1_0_b.rebase_(e_1_0.id);
+                const e2_0_b = new TestEvent({ global: 1, client: 0 }, e1_0.seqNum, '1_0_b', false);
+                const syncState = new SyncState.SyncState({
+                    pending: [e2_0_b],
+                    upstreamHead: EventSequenceNumber.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);
                 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]);
-                expect(result.newSyncState.upstreamHead).toBe(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.seqNum);
+                expect(result.newSyncState.localHead).toMatchObject(e2_0_e3_0.seqNum);
             });
-            it('should rebase single local event to end (more incoming events)', () => {
-                const syncState = { pending: [e_0_0], rollbackTail: [], upstreamHead: EventId.ROOT, localHead: e_0_0.id };
-                const result = run({
+            it('should rebase single client event to end (more incoming events)', () => {
+                const syncState = new SyncState.SyncState({
+                    pending: [e1_0],
+                    upstreamHead: EventSequenceNumber.ROOT,
+                    localHead: e1_0.seqNum,
+                });
+                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: [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.seqNum);
                 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).toBe(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.seqNum);
+                expect(result.newSyncState.localHead).toMatchObject(e1_0_e3_0.seqNum);
             });
             it('should only rebase divergent events when first event matches', () => {
-                const syncState = {
-                    pending: [e_0_0, e_0_1],
-                    rollbackTail: [],
-                    upstreamHead: EventId.ROOT,
-                    localHead: e_0_0.id,
-                };
-                const result = run({
+                const syncState = new SyncState.SyncState({
+                    pending: [e1_0, e1_1],
+                    upstreamHead: EventSequenceNumber.ROOT,
+                    localHead: e1_0.seqNum,
+                });
+                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: [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.seqNum);
                 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.newEvents, [e_0_2, e_0_3, e_1_0, e_0_1_e_1_1]);
-                expect(result.newSyncState.upstreamHead).toBe(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.seqNum);
+                expect(result.newSyncState.localHead).toMatchObject(e1_1_e2_1.seqNum);
             });
-            it('should rebase all local events when incoming chain starts differently', () => {
-                const syncState = {
-                    pending: [e_0_0, e_0_1],
-                    rollbackTail: [],
-                    upstreamHead: EventId.ROOT,
-                    localHead: e_0_1.id,
-                };
-                const result = run({
+            it('should rebase all client events when incoming chain starts differently', () => {
+                const syncState = new SyncState.SyncState({
+                    pending: [e1_0, e1_1],
+                    upstreamHead: EventSequenceNumber.ROOT,
+                    localHead: e1_1.seqNum,
+                });
+                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: [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.seqNum);
+                const e1_1_e2_2 = e1_1.rebase_(e1_0_e2_1.seqNum);
                 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]);
-                expect(result.newSyncState.upstreamHead).toBe(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.seqNum);
+                expect(result.newSyncState.localHead).toMatchObject(e1_1_e2_2.seqNum);
             });
             describe('local-push', () => {
                 describe('advance', () => {
                     it('should advance with new events', () => {
-                        const 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 syncState = new SyncState.SyncState({
+                            pending: [e1_0],
+                            upstreamHead: EventSequenceNumber.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, [e_0_0, e_0_1, e_0_2, e_0_3]);
-                        expectEventArraysEqual(result.newSyncState.rollbackTail, []);
-                        expect(result.newSyncState.upstreamHead).toBe(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.newSyncState.pending, [e1_0, e1_1, e1_2, e1_3]);
+                        expect(result.newSyncState.upstreamHead).toMatchObject(EventSequenceNumber.ROOT);
+                        expect(result.newSyncState.localHead).toMatchObject(e1_3.seqNum);
+                        expectEventArraysEqual(result.newEvents, [e1_1, e1_2, e1_3]);
+                        expectEventArraysEqual(result.confirmedEvents, []);
                     });
                 });
                 describe('reject', () => {
                     it('should reject when new events are greater than pending events', () => {
-                        const 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 syncState = new SyncState.SyncState({
+                            pending: [e1_0, e1_1],
+                            upstreamHead: EventSequenceNumber.ROOT,
+                            localHead: e1_1.seqNum,
+                        });
+                        const result = merge({
+                            syncState,
+                            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.seqNum);
                     });
                 });
             });
@@ -378,9 +401,9 @@ describe('syncstate', () => {
 const expectEventArraysEqual = (actual, expected) => {
     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.seqNum).toStrictEqual(expected[i].seqNum);
+        expect(event.parentSeqNum).toStrictEqual(expected[i].parentSeqNum);
+        expect(event.name).toStrictEqual(expected[i].name);
         expect(event.args).toStrictEqual(expected[i].args);
     });
 };
@@ -388,7 +411,7 @@ function expectAdvance(result) {
     expect(result._tag).toBe('advance');
 }
 function expectRebase(result) {
-    expect(result._tag).toBe('rebase');
+    expect(result._tag, `Expected rebase, got ${result}`).toBe('rebase');
 }
 function expectReject(result) {
     expect(result._tag).toBe('reject');