@livestore/common 0.3.0-dev.2 → 0.3.0-dev.22

package/src/sync/syncstate.test.ts

@@ -7,17 +7,19 @@ import * as SyncState from './syncstate.js'
 
 class TestEvent extends MutationEvent.EncodedWithMeta {
   constructor(
-    public readonly id: EventId.EventId,
-    public readonly parentId: EventId.EventId,
+    id: EventId.EventId | typeof EventId.EventId.Encoded,
+    parentId: EventId.EventId,
     public readonly payload: string,
     public readonly isLocal: boolean,
   ) {
     super({
-      id,
-      parentId,
+      id: EventId.make(id),
+      parentId: EventId.make(parentId),
       mutation: 'a',
       args: payload,
-      meta: {},
+
+      clientId: 'static-local-id',
+      sessionId: undefined,
     })
   }
 
@@ -26,17 +28,17 @@ class TestEvent extends MutationEvent.EncodedWithMeta {
   }
 
   // Only used for Vitest printing
-  // toJSON = () => `(${this.id.global},${this.id.local},${this.payload})`
+  // toJSON = () => `(${this.id.global},${this.id.client},${this.payload})`
   // toString = () => this.toJSON()
 }
 
-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_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 isEqualEvent = MutationEvent.isEqualEncoded
 
@@ -58,12 +60,12 @@ describe('syncstate', () => {
       'upstream-rebase (trimRollbackUntil: $trimRollbackUntil)',
       ({ trimRollbackUntil }) => {
         it('should rollback until start', () => {
-          const syncState = {
+          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({
@@ -83,19 +85,19 @@ describe('syncstate', () => {
           } 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.upstreamHead).toMatchObject(e_0_1_e_1_1.id)
           expect(result.newSyncState.localHead).toMatchObject(e_1_0_e_2_0.id)
-          expectEventArraysEqual(result.newEvents, [e_0_0_e_1_0, e_0_1_e_1_1])
+          expectEventArraysEqual(result.newEvents, [e_0_0_e_1_0, e_0_1_e_1_1, e_1_0_e_2_0])
           expectEventArraysEqual(result.eventsToRollback, [e_0_0, e_0_1, e_1_0])
         })
 
         it('should rollback only to specified point', () => {
-          const syncState = {
+          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,
@@ -114,14 +116,19 @@ describe('syncstate', () => {
           } 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.upstreamHead).toMatchObject(e_0_1_e_1_0.id)
           expect(result.newSyncState.localHead).toMatchObject(e_1_0_e_2_0.id)
-          expectEventArraysEqual(result.newEvents, [e_0_1_e_1_0])
+          expectEventArraysEqual(result.newEvents, [e_0_1_e_1_0, e_1_0_e_2_0])
           expectEventArraysEqual(result.eventsToRollback, [e_0_1, e_1_0])
         })
 
         it('should work for empty pending', () => {
-          const syncState = { pending: [], rollbackTail: [e_0_0], upstreamHead: EventId.ROOT, localHead: e_0_0.id }
+          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] },
@@ -129,23 +136,32 @@ describe('syncstate', () => {
           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.upstreamHead).toMatchObject(e_1_0.id)
           expect(result.newSyncState.localHead).toMatchObject(e_1_0.id)
-          expect(result.newEvents).toEqual([e_1_0])
+          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()
+          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' })
         })
 
         it('should work for empty incoming', () => {
-          const syncState = { pending: [], rollbackTail: [e_0_0], upstreamHead: EventId.ROOT, localHead: e_0_0.id }
+          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: [] },
@@ -153,67 +169,94 @@ describe('syncstate', () => {
           expectRebase(result)
           expectEventArraysEqual(result.newSyncState.pending, [])
           expectEventArraysEqual(result.newSyncState.rollbackTail, [])
-          expect(result.newSyncState.upstreamHead).toBe(EventId.ROOT)
+          expect(result.newSyncState.upstreamHead).toMatchObject(EventId.ROOT)
           expect(result.newSyncState.localHead).toMatchObject(EventId.ROOT)
-          expect(result.newEvents).toEqual([])
+          expect(result.newEvents).toStrictEqual([])
         })
       },
     )
 
     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 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] } })
+        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()
+        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] } })
+        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 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] } })
 
         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.upstreamHead).toMatchObject(e_0_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_0_0.id)
-        expect(result.newEvents).toEqual([])
+        expect(result.newEvents).toStrictEqual([])
       })
 
       it('should acknowledge partial pending event when receiving matching event', () => {
-        const syncState = {
+        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] } })
 
         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.upstreamHead).toMatchObject(e_0_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_1_0.id)
-        expect(result.newEvents).toEqual([])
+        expect(result.newEvents).toStrictEqual([])
       })
 
       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 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] } })
 
         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.upstreamHead).toMatchObject(e_0_1.id)
         expect(result.newSyncState.localHead).toMatchObject(e_0_1.id)
-        expect(result.newEvents).toEqual([e_0_1])
+        expect(result.newEvents).toStrictEqual([e_0_1])
       })
 
       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 syncState = new SyncState.SyncState({
+          pending: [e_0_1],
+          rollbackTail: [],
+          upstreamHead: e_0_0.id,
+          localHead: e_0_1.id,
+        })
         const result = run({
           syncState,
           payload: { _tag: 'upstream-advance', newEvents: [e_0_1, e_0_2, e_0_3, e_1_0, e_1_1] },
@@ -222,18 +265,18 @@ describe('syncstate', () => {
         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.upstreamHead).toMatchObject(e_1_1.id)
         expect(result.newSyncState.localHead).toMatchObject(e_1_1.id)
-        expect(result.newEvents).toEqual([e_0_2, e_0_3, e_1_0, e_1_1])
+        expect(result.newEvents).toStrictEqual([e_0_2, e_0_3, e_1_0, e_1_1])
       })
 
-      it('should ignore local events (incoming is subset of pending)', () => {
-        const syncState = {
+      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({
           syncState,
           payload: { _tag: 'upstream-advance', newEvents: [e_0_0] },
@@ -242,18 +285,18 @@ describe('syncstate', () => {
         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.upstreamHead).toMatchObject(e_0_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_0_0.id)
-        expect(result.newEvents).toEqual([])
+        expect(result.newEvents).toStrictEqual([])
       })
 
-      it('should ignore local events (incoming is subset of pending case 2)', () => {
-        const syncState = {
+      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({
           syncState,
           payload: { _tag: 'upstream-advance', newEvents: [e_0_0] },
@@ -262,18 +305,18 @@ describe('syncstate', () => {
         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.upstreamHead).toMatchObject(e_0_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_1_0.id)
-        expect(result.newEvents).toEqual([])
+        expect(result.newEvents).toStrictEqual([])
       })
 
-      it('should ignore local events (incoming goes beyond pending)', () => {
-        const syncState = {
+      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({
           syncState,
           payload: { _tag: 'upstream-advance', newEvents: [e_0_0, e_1_0] },
@@ -283,15 +326,31 @@ describe('syncstate', () => {
         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.upstreamHead).toMatchObject(e_1_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_1_0.id)
-        expect(result.newEvents).toEqual([e_1_0])
+        expect(result.newEvents).toStrictEqual([e_1_0])
+      })
+
+      it('should fail if incoming event is ≤ local head', () => {
+        const syncState = new SyncState.SyncState({
+          pending: [],
+          rollbackTail: [],
+          upstreamHead: e_1_0.id,
+          localHead: e_1_0.id,
+        })
+        const result = run({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e_0_0] } })
+        expect(result).toMatchObject({ _tag: 'unexpected-error' })
       })
     })
 
     describe('upstream-advance: rebase', () => {
-      it('should rebase single local event to end', () => {
-        const syncState = { pending: [e_0_0], rollbackTail: [], upstreamHead: EventId.ROOT, localHead: e_0_0.id }
+      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 e_0_0_e_0_2 = e_0_0.rebase_(e_0_1.id)
@@ -299,15 +358,20 @@ describe('syncstate', () => {
         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.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.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 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)
@@ -317,18 +381,18 @@ describe('syncstate', () => {
         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.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, local: 0 }, e_0_0.id, '1_0_b', false)
-        const syncState = {
+        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 e_1_0_e_2_0 = e_1_0_b.rebase_(e_1_0.id)
 
@@ -337,12 +401,17 @@ describe('syncstate', () => {
         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.upstreamHead).toMatchObject(e_1_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_1_0_e_2_0.id)
       })
 
-      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 }
+      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({
           syncState,
           payload: { _tag: 'upstream-advance', newEvents: [e_0_1, e_0_2, e_0_3, e_1_0] },
@@ -353,17 +422,17 @@ describe('syncstate', () => {
         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.upstreamHead).toMatchObject(e_1_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_0_0_e_2_0.id)
       })
 
       it('should only rebase divergent events when first event matches', () => {
-        const syncState = {
+        const syncState = new SyncState.SyncState({
           pending: [e_0_0, e_0_1],
           rollbackTail: [],
           upstreamHead: EventId.ROOT,
           localHead: e_0_0.id,
-        }
+        })
         const result = run({
           syncState,
           payload: { _tag: 'upstream-advance', newEvents: [e_0_0, e_0_2, e_0_3, e_1_0] },
@@ -376,17 +445,17 @@ describe('syncstate', () => {
         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.upstreamHead).toMatchObject(e_1_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_0_1_e_1_1.id)
       })
 
-      it('should rebase all local events when incoming chain starts differently', () => {
-        const 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({
           syncState,
           payload: { _tag: 'upstream-advance', newEvents: [e_0_1, e_0_2, e_0_3, e_1_0] },
@@ -400,20 +469,25 @@ describe('syncstate', () => {
         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.upstreamHead).toMatchObject(e_1_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_0_1_e_1_2.id)
       })
 
       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 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] } })
 
             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.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])
           })
@@ -421,12 +495,12 @@ describe('syncstate', () => {
 
         describe('reject', () => {
           it('should reject when new events are greater than pending events', () => {
-            const syncState = {
+            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] } })
 
             expectReject(result)
@@ -444,21 +518,27 @@ const expectEventArraysEqual = (
 ) => {
   expect(actual.length).toBe(expected.length)
   actual.forEach((event, i) => {
-    expect(event.id).toEqual(expected[i]!.id)
-    expect(event.parentId).toEqual(expected[i]!.parentId)
-    expect(event.mutation).toEqual(expected[i]!.mutation)
-    expect(event.args).toEqual(expected[i]!.args)
+    expect(event.id).toStrictEqual(expected[i]!.id)
+    expect(event.parentId).toStrictEqual(expected[i]!.parentId)
+    expect(event.mutation).toStrictEqual(expected[i]!.mutation)
+    expect(event.args).toStrictEqual(expected[i]!.args)
   })
 }
 
-function expectAdvance(result: SyncState.UpdateResult): asserts result is SyncState.UpdateResultAdvance {
+function expectAdvance(
+  result: typeof SyncState.UpdateResult.Type,
+): asserts result is typeof SyncState.UpdateResultAdvance.Type {
   expect(result._tag).toBe('advance')
 }
 
-function expectRebase(result: SyncState.UpdateResult): asserts result is SyncState.UpdateResultRebase {
+function expectRebase(
+  result: typeof SyncState.UpdateResult.Type,
+): asserts result is typeof SyncState.UpdateResultRebase.Type {
   expect(result._tag).toBe('rebase')
 }
 
-function expectReject(result: SyncState.UpdateResult): asserts result is SyncState.UpdateResultReject {
+function expectReject(
+  result: typeof SyncState.UpdateResult.Type,
+): asserts result is typeof SyncState.UpdateResultReject.Type {
   expect(result._tag).toBe('reject')
 }