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

package/src/sync/syncstate.test.ts

@@ -7,14 +7,14 @@ import * as SyncState from './syncstate.js'
 
 class TestEvent extends MutationEvent.EncodedWithMeta {
   constructor(
-    id: EventId.EventId | typeof EventId.EventId.Encoded,
-    parentId: EventId.EventId,
+    public readonly id: EventId.EventId,
+    public readonly parentId: EventId.EventId,
     public readonly payload: string,
     public readonly isLocal: boolean,
   ) {
     super({
-      id: EventId.make(id),
-      parentId: EventId.make(parentId),
+      id,
+      parentId,
       mutation: 'a',
       args: payload,
       meta: {},
@@ -58,12 +58,12 @@ describe('syncstate', () => {
       'upstream-rebase (trimRollbackUntil: $trimRollbackUntil)',
       ({ trimRollbackUntil }) => {
         it('should rollback until start', () => {
-          const syncState = new SyncState.SyncState({
+          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({
@@ -83,19 +83,19 @@ describe('syncstate', () => {
           } else {
             expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_0_e_1_0, e_0_1_e_1_1])
           }
-          expect(result.newSyncState.upstreamHead).toMatchObject(e_0_1_e_1_1.id)
+          expect(result.newSyncState.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])
         })
 
         it('should rollback only to specified point', () => {
-          const syncState = new SyncState.SyncState({
+          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({
             syncState,
@@ -114,19 +114,14 @@ describe('syncstate', () => {
           } else {
             expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_0, e_0_1_e_1_0])
           }
-          expect(result.newSyncState.upstreamHead).toMatchObject(e_0_1_e_1_0.id)
+          expect(result.newSyncState.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])
         })
 
         it('should work for empty pending', () => {
-          const syncState = new SyncState.SyncState({
-            pending: [],
-            rollbackTail: [e_0_0],
-            upstreamHead: EventId.ROOT,
-            localHead: e_0_0.id,
-          })
+          const 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] },
@@ -134,18 +129,13 @@ describe('syncstate', () => {
           expectRebase(result)
           expectEventArraysEqual(result.newSyncState.pending, [])
           expectEventArraysEqual(result.newSyncState.rollbackTail, [e_1_0])
-          expect(result.newSyncState.upstreamHead).toMatchObject(e_1_0.id)
+          expect(result.newSyncState.upstreamHead).toBe(e_1_0.id)
           expect(result.newSyncState.localHead).toMatchObject(e_1_0.id)
-          expect(result.newEvents).toStrictEqual([e_1_0])
+          expect(result.newEvents).toEqual([e_1_0])
         })
 
         it('should fail for empty rollback tail', () => {
-          const syncState = new SyncState.SyncState({
-            pending: [],
-            rollbackTail: [],
-            upstreamHead: EventId.ROOT,
-            localHead: e_0_0.id,
-          })
+          const syncState = { pending: [], rollbackTail: [], upstreamHead: EventId.ROOT, localHead: e_0_0.id }
           expect(() =>
             run({
               syncState,
@@ -155,12 +145,7 @@ describe('syncstate', () => {
         })
 
         it('should work for empty incoming', () => {
-          const syncState = new SyncState.SyncState({
-            pending: [],
-            rollbackTail: [e_0_0],
-            upstreamHead: EventId.ROOT,
-            localHead: e_0_0.id,
-          })
+          const 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: [] },
@@ -168,92 +153,67 @@ describe('syncstate', () => {
           expectRebase(result)
           expectEventArraysEqual(result.newSyncState.pending, [])
           expectEventArraysEqual(result.newSyncState.rollbackTail, [])
-          expect(result.newSyncState.upstreamHead).toMatchObject(EventId.ROOT)
+          expect(result.newSyncState.upstreamHead).toBe(EventId.ROOT)
           expect(result.newSyncState.localHead).toMatchObject(EventId.ROOT)
-          expect(result.newEvents).toStrictEqual([])
+          expect(result.newEvents).toEqual([])
         })
       },
     )
 
     describe('upstream-advance: advance', () => {
       it('should throw error if newEvents are not sorted in ascending order by eventId (local)', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e_0_0],
-          rollbackTail: [],
-          upstreamHead: EventId.ROOT,
-          localHead: e_0_0.id,
-        })
+        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 (global)', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e_0_0],
-          rollbackTail: [],
-          upstreamHead: EventId.ROOT,
-          localHead: e_0_0.id,
-        })
+        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 acknowledge pending event when receiving matching event', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e_0_0],
-          rollbackTail: [],
-          upstreamHead: EventId.ROOT,
-          localHead: e_0_0.id,
-        })
+        const 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).toMatchObject(e_0_0.id)
+        expect(result.newSyncState.upstreamHead).toBe(e_0_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_0_0.id)
-        expect(result.newEvents).toStrictEqual([])
+        expect(result.newEvents).toEqual([])
       })
 
       it('should acknowledge partial pending event when receiving matching event', () => {
-        const syncState = new SyncState.SyncState({
+        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] } })
 
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [e_1_0])
         expectEventArraysEqual(result.newSyncState.rollbackTail, [e_0_0])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e_0_0.id)
+        expect(result.newSyncState.upstreamHead).toBe(e_0_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_1_0.id)
-        expect(result.newEvents).toStrictEqual([])
+        expect(result.newEvents).toEqual([])
       })
 
       it('should acknowledge pending event and add new event', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e_0_0],
-          rollbackTail: [],
-          upstreamHead: EventId.ROOT,
-          localHead: e_0_0.id,
-        })
+        const 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).toMatchObject(e_0_1.id)
+        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.newEvents).toEqual([e_0_1])
       })
 
       it('should acknowledge pending event and add multiple new events', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e_0_1],
-          rollbackTail: [],
-          upstreamHead: e_0_0.id,
-          localHead: e_0_1.id,
-        })
+        const 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] },
@@ -262,18 +222,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).toMatchObject(e_1_1.id)
+        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.newEvents).toEqual([e_0_2, e_0_3, e_1_0, e_1_1])
       })
 
       it('should ignore local events (incoming is subset of pending)', () => {
-        const syncState = new SyncState.SyncState({
+        const 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] },
@@ -282,18 +242,18 @@ describe('syncstate', () => {
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [])
         expectEventArraysEqual(result.newSyncState.rollbackTail, [e_r_1, e_0_0])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e_0_0.id)
+        expect(result.newSyncState.upstreamHead).toBe(e_0_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_0_0.id)
-        expect(result.newEvents).toStrictEqual([])
+        expect(result.newEvents).toEqual([])
       })
 
       it('should ignore local events (incoming is subset of pending case 2)', () => {
-        const syncState = new SyncState.SyncState({
+        const 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] },
@@ -302,18 +262,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).toMatchObject(e_0_0.id)
+        expect(result.newSyncState.upstreamHead).toBe(e_0_0.id)
         expect(result.newSyncState.localHead).toMatchObject(e_1_0.id)
-        expect(result.newEvents).toStrictEqual([])
+        expect(result.newEvents).toEqual([])
       })
 
       it('should ignore local events (incoming goes beyond pending)', () => {
-        const syncState = new SyncState.SyncState({
+        const 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] },
@@ -323,20 +283,15 @@ 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).toMatchObject(e_1_0.id)
+        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.newEvents).toEqual([e_1_0])
       })
     })
 
     describe('upstream-advance: rebase', () => {
       it('should rebase single local event to end', () => {
-        const syncState = new SyncState.SyncState({
-          pending: [e_0_0],
-          rollbackTail: [],
-          upstreamHead: EventId.ROOT,
-          localHead: e_0_0.id,
-        })
+        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)
@@ -344,7 +299,7 @@ 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).toMatchObject(e_0_1.id)
+        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])
@@ -352,12 +307,7 @@ describe('syncstate', () => {
 
       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 = new SyncState.SyncState({
-          pending: [e_0_0_b],
-          rollbackTail: [],
-          upstreamHead: EventId.ROOT,
-          localHead: e_0_0_b.id,
-        })
+        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)
@@ -367,18 +317,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).toMatchObject(e_0_0.id)
+        expect(result.newSyncState.upstreamHead).toBe(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 = new SyncState.SyncState({
+        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)
 
@@ -387,17 +337,12 @@ 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).toMatchObject(e_1_0.id)
+        expect(result.newSyncState.upstreamHead).toBe(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 = new SyncState.SyncState({
-          pending: [e_0_0],
-          rollbackTail: [],
-          upstreamHead: EventId.ROOT,
-          localHead: e_0_0.id,
-        })
+        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, e_0_2, e_0_3, e_1_0] },
@@ -408,17 +353,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).toMatchObject(e_1_0.id)
+        expect(result.newSyncState.upstreamHead).toBe(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 = new SyncState.SyncState({
+        const 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] },
@@ -431,17 +376,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).toMatchObject(e_1_0.id)
+        expect(result.newSyncState.upstreamHead).toBe(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 = new SyncState.SyncState({
+        const 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] },
@@ -455,25 +400,20 @@ 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).toMatchObject(e_1_0.id)
+        expect(result.newSyncState.upstreamHead).toBe(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 = new SyncState.SyncState({
-              pending: [e_0_0],
-              rollbackTail: [],
-              upstreamHead: EventId.ROOT,
-              localHead: e_0_0.id,
-            })
+            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] } })
 
             expectAdvance(result)
             expectEventArraysEqual(result.newSyncState.pending, [e_0_0, e_0_1, e_0_2, e_0_3])
             expectEventArraysEqual(result.newSyncState.rollbackTail, [])
-            expect(result.newSyncState.upstreamHead).toMatchObject(EventId.ROOT)
+            expect(result.newSyncState.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])
           })
@@ -481,12 +421,12 @@ describe('syncstate', () => {
 
         describe('reject', () => {
           it('should reject when new events are greater than pending events', () => {
-            const syncState = new SyncState.SyncState({
+            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] } })
 
             expectReject(result)
@@ -504,10 +444,10 @@ const expectEventArraysEqual = (
 ) => {
   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.args).toStrictEqual(expected[i]!.args)
+    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)
   })
 }
 

package/src/sync/syncstate.ts

@@ -39,21 +39,19 @@ import * as MutationEvent from '../schema/MutationEvent.js'
  * The `updateSyncState` function processes updates to the sync state based on incoming payloads,
  * handling cases such as upstream rebase, advance, local push, and rollback tail trimming.
  */
-export class SyncState extends Schema.Class<SyncState>('SyncState')({
+export interface SyncState {
+  pending: ReadonlyArray<MutationEvent.EncodedWithMeta>
+  rollbackTail: ReadonlyArray<MutationEvent.EncodedWithMeta>
+  upstreamHead: EventId.EventId
+  localHead: EventId.EventId
+}
+
+export const SyncState = Schema.Struct({
   pending: Schema.Array(MutationEvent.EncodedWithMeta),
   rollbackTail: Schema.Array(MutationEvent.EncodedWithMeta),
   upstreamHead: EventId.EventId,
   localHead: EventId.EventId,
-}) {
-  toJSON = (): any => {
-    return {
-      pending: this.pending.map((e) => e.toJSON()),
-      rollbackTail: this.rollbackTail.map((e) => e.toJSON()),
-      upstreamHead: `(${this.upstreamHead.global},${this.upstreamHead.local})`,
-      localHead: `(${this.localHead.global},${this.localHead.local})`,
-    }
-  }
-}
+}).annotations({ title: 'SyncState' })
 
 export class PayloadUpstreamRebase extends Schema.TaggedStruct('upstream-rebase', {
   /** Rollback until this event in the rollback tail (inclusive). Starting from the end of the rollback tail. */
@@ -155,12 +153,12 @@ export const updateSyncState = ({
 
       return {
         _tag: 'rebase',
-        newSyncState: new SyncState({
+        newSyncState: {
           pending: rebasedPending,
           rollbackTail: trimRollbackTail([...syncState.rollbackTail.slice(0, rollbackIndex), ...payload.newEvents]),
           upstreamHead: newUpstreamHead,
           localHead: rebasedPending.at(-1)?.id ?? newUpstreamHead,
-        }),
+        },
         previousSyncState: syncState,
         newEvents: payload.newEvents,
         eventsToRollback,
@@ -171,12 +169,12 @@ export const updateSyncState = ({
       if (payload.newEvents.length === 0) {
         return {
           _tag: 'advance',
-          newSyncState: new SyncState({
+          newSyncState: {
             pending: syncState.pending,
             rollbackTail: trimRollbackTail(syncState.rollbackTail),
             upstreamHead: syncState.upstreamHead,
             localHead: syncState.localHead,
-          }),
+          },
           previousSyncState: syncState,
           newEvents: [],
         }
@@ -237,12 +235,12 @@ export const updateSyncState = ({
 
         return {
           _tag: 'advance',
-          newSyncState: new SyncState({
+          newSyncState: {
             pending: pendingRemaining,
             rollbackTail: trimRollbackTail([...syncState.rollbackTail, ...pendingAndNewEvents]),
             upstreamHead: newUpstreamHead,
             localHead: pendingRemaining.at(-1)?.id ?? newUpstreamHead,
-          }),
+          },
           previousSyncState: syncState,
           newEvents,
         }
@@ -264,12 +262,12 @@ export const updateSyncState = ({
 
         return {
           _tag: 'rebase',
-          newSyncState: new SyncState({
+          newSyncState: {
             pending: rebasedPending,
             rollbackTail: trimRollbackTail([...syncState.rollbackTail, ...payload.newEvents]),
             upstreamHead: newUpstreamHead,
             localHead: rebasedPending.at(-1)!.id,
-          }),
+          },
           previousSyncState: syncState,
           newEvents: [...payload.newEvents.slice(divergentNewEventsIndex), ...rebasedPending],
           eventsToRollback: [...syncState.rollbackTail, ...divergentPending],
@@ -291,12 +289,12 @@ export const updateSyncState = ({
       } else {
         return {
           _tag: 'advance',
-          newSyncState: new SyncState({
+          newSyncState: {
             pending: [...syncState.pending, ...payload.newEvents],
             rollbackTail: syncState.rollbackTail,
             upstreamHead: syncState.upstreamHead,
             localHead: payload.newEvents.at(-1)!.id,
-          }),
+          },
           previousSyncState: syncState,
           newEvents: payload.newEvents,
         }

package/src/sync/validate-push-payload.ts

@@ -1,20 +1,17 @@
 import { Effect } from '@livestore/utils/effect'
 
-import type { EventId, MutationEvent } from '../schema/mod.js'
+import type { MutationEvent } from '../schema/mod.js'
 import { InvalidPushError } from './sync.js'
 
 // TODO proper batch validation
-export const validatePushPayload = (
-  batch: ReadonlyArray<MutationEvent.AnyEncodedGlobal>,
-  currentEventId: EventId.GlobalEventId,
-) =>
+export const validatePushPayload = (batch: ReadonlyArray<MutationEvent.AnyEncoded>, currentEventId: number) =>
   Effect.gen(function* () {
-    if (batch[0]!.id <= currentEventId) {
+    if (batch[0]!.id.global <= currentEventId) {
       return yield* InvalidPushError.make({
         reason: {
           _tag: 'ServerAhead',
           minimumExpectedId: currentEventId + 1,
-          providedId: batch[0]!.id,
+          providedId: batch[0]!.id.global,
         },
       })
     }

package/src/version.ts

@@ -2,7 +2,7 @@
 // import packageJson from '../package.json' with { type: 'json' }
 // export const liveStoreVersion = packageJson.version
 
-export const liveStoreVersion = '0.3.0-dev.10' as const
+export const liveStoreVersion = '0.3.0-dev.0' as const
 
 /**
  * This version number is incremented whenever the internal storage format changes in a breaking way.

package/dist/leader-thread/LeaderSyncProcessor.d.ts

@@ -1,37 +0,0 @@
-import type { Scope } from '@livestore/utils/effect';
-import { Effect } from '@livestore/utils/effect';
-import type { SynchronousDatabase } from '../adapter-types.js';
-import { UnexpectedError } from '../adapter-types.js';
-import type { LiveStoreSchema } from '../schema/mod.js';
-import type { InitialBlockingSyncContext, LeaderSyncProcessor } from './types.js';
-/**
- * The LeaderSyncProcessor manages synchronization of mutations between
- * the local state and the sync backend, ensuring efficient and orderly processing.
- *
- * In the LeaderSyncProcessor, pulling always has precedence over pushing.
- *
- * Responsibilities:
- * - Queueing incoming local mutations in a localPushMailbox.
- * - Broadcasting mutations to client sessions via pull queues.
- * - Pushing mutations to the sync backend.
- *
- * Notes:
- *
- * local push processing:
- * - localPushMailbox:
- *   - Maintains events in ascending order.
- *   - Uses `Deferred` objects to resolve/reject events based on application success.
- * - Processes events from the mailbox, applying mutations in batches.
- * - Controlled by a `Latch` to manage execution flow.
- * - The latch closes on pull receipt and re-opens post-pull completion.
- * - Processes up to `maxBatchSize` events per cycle.
- *
- */
-export declare const makeLeaderSyncProcessor: ({ schema, dbMissing, dbLog, initialBlockingSyncContext, }: {
-    schema: LiveStoreSchema;
-    /** Only used to know whether we can safely query dbLog during setup execution */
-    dbMissing: boolean;
-    dbLog: SynchronousDatabase;
-    initialBlockingSyncContext: InitialBlockingSyncContext;
-}) => Effect.Effect<LeaderSyncProcessor, UnexpectedError, Scope.Scope>;
-//# sourceMappingURL=LeaderSyncProcessor.d.ts.map

package/dist/leader-thread/LeaderSyncProcessor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LeaderSyncProcessor.d.ts","sourceRoot":"","sources":["../../src/leader-thread/LeaderSyncProcessor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAc,KAAK,EAAE,MAAM,yBAAyB,CAAA;AAChE,OAAO,EAGL,MAAM,EAUP,MAAM,yBAAyB,CAAA;AAGhC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,EAAE,eAAe,EAA2B,MAAM,kBAAkB,CAAA;AAehF,OAAO,KAAK,EAAE,0BAA0B,EAAmB,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAQlG;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,uBAAuB,8DAKjC;IACD,MAAM,EAAE,eAAe,CAAA;IACvB,iFAAiF;IACjF,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,mBAAmB,CAAA;IAC1B,0BAA0B,EAAE,0BAA0B,CAAA;CACvD,KAAG,MAAM,CAAC,MAAM,CAAC,mBAAmB,EAAE,eAAe,EAAE,KAAK,CAAC,KAAK,CAwK/D,CAAA"}