@livestore/common 0.3.0-dev.7 → 0.3.0-dev.9

package/src/leader-thread/types.ts

@@ -6,6 +6,7 @@ import type {
   Option,
   Queue,
   Scope,
+  Subscribable,
   SubscriptionRef,
   WebChannel,
 } from '@livestore/utils/effect'
@@ -90,7 +91,7 @@ export class LeaderThreadCtx extends Context.Tag('LeaderThreadCtx')<
     mutationEventSchema: MutationEvent.ForMutationDefRecord<any>
     // devtools: DevtoolsContext
     syncBackend: SyncBackend | undefined
-    syncProcessor: SyncProcessor
+    syncProcessor: LeaderSyncProcessor
     connectedClientSessionPullQueues: PullQueueSet
     /** e.g. used for `store.__dev` APIs */
     extraIncomingMessagesQueue: Queue.Queue<Devtools.MessageToAppLeader>
@@ -107,17 +108,24 @@ export type PullQueueItem = {
   remaining: number
 }
 
-export interface SyncProcessor {
+export interface LeaderSyncProcessor {
   push: (
     /** `batch` needs to follow the same rules as `batch` in `SyncBackend.push` */
     batch: ReadonlyArray<MutationEvent.EncodedWithMeta>,
-  ) => Effect.Effect<void, UnexpectedError | InvalidPushError, HttpClient.HttpClient | LeaderThreadCtx>
+    options?: {
+      /**
+       * If true, the effect will only finish when the local push has been processed (i.e. succeeded or was rejected).
+       * @default false
+       */
+      waitForProcessing?: boolean
+    },
+  ) => Effect.Effect<void, InvalidPushError>
 
   pushPartial: (mutationEvent: MutationEvent.PartialAnyEncoded) => Effect.Effect<void, UnexpectedError, LeaderThreadCtx>
   boot: (args: {
     dbReady: Deferred.Deferred<void>
   }) => Effect.Effect<void, UnexpectedError, LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient>
-  syncState: Effect.Effect<SyncState.SyncState, UnexpectedError>
+  syncState: Subscribable.Subscribable<SyncState.SyncState>
 }
 
 export interface PullQueueSet {

package/src/schema/EventId.test.ts

@@ -0,0 +1,12 @@
+import { Vitest } from '@livestore/utils/node-vitest'
+import { expect } from 'vitest'
+
+import { EventId } from './mod.js'
+
+Vitest.describe('EventId', () => {
+  Vitest.test('nextPair', () => {
+    const e_0_0 = EventId.make({ global: 0, local: 0 })
+    expect(EventId.nextPair(e_0_0, false).id).toStrictEqual({ global: 1, local: 0 })
+    expect(EventId.nextPair(e_0_0, true).id).toStrictEqual({ global: 0, local: 1 })
+  })
+})

package/src/schema/MutationEvent.ts

@@ -2,6 +2,7 @@ import { memoizeByRef } from '@livestore/utils'
 import type { Deferred } from '@livestore/utils/effect'
 import { Schema } from '@livestore/utils/effect'
 
+import type { InvalidPushError } from '../sync/sync.js'
 import * as EventId from './EventId.js'
 import type { MutationDef, MutationDefRecord } from './mutations.js'
 import type { LiveStoreSchema } from './schema.js'
@@ -127,7 +128,7 @@ export const makeMutationEventPartialSchema = <TSchema extends LiveStoreSchema>(
         args: def.schema,
       }),
     ),
-  ).annotations({ title: 'MutationEventSchemaPartial' }) as any
+  ).annotations({ title: 'MutationEventPartial' }) as any
 
 export const makeMutationEventSchemaMemo = memoizeByRef(makeMutationEventSchema)
 
@@ -138,7 +139,10 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEven
   id: EventId.EventId,
   parentId: EventId.EventId,
   meta: Schema.optionalWith(
-    Schema.Any as Schema.Schema<{ deferred?: Deferred.Deferred<void>; sessionChangeset?: Uint8Array }>,
+    Schema.Any as Schema.Schema<{
+      deferred?: Deferred.Deferred<void, InvalidPushError>
+      sessionChangeset?: Uint8Array
+    }>,
     { default: () => ({}) },
   ),
 }) {
@@ -156,7 +160,7 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEven
   rebase = (parentId: EventId.EventId, isLocal: boolean) =>
     new EncodedWithMeta({
       ...this,
-      ...EventId.nextPair(this.id, isLocal),
+      ...EventId.nextPair(parentId, isLocal),
     })
 
   static fromGlobal = (mutationEvent: AnyEncodedGlobal) =>

package/src/sync/{client-session-sync-processor.ts → ClientSessionSyncProcessor.ts}

@@ -7,8 +7,7 @@ import type { ClientSessionLeaderThreadProxy, UnexpectedError } from '../adapter
 import * as EventId from '../schema/EventId.js'
 import { type LiveStoreSchema } from '../schema/mod.js'
 import * as MutationEvent from '../schema/MutationEvent.js'
-import type { SyncState } from './syncstate.js'
-import { updateSyncState } from './syncstate.js'
+import { SyncState, updateSyncState } from './syncstate.js'
 
 /**
  * Rebase behaviour:
@@ -42,19 +41,18 @@ export const makeClientSessionSyncProcessor = ({
   }
   rollback: (changeset: Uint8Array) => void
   refreshTables: (tables: Set<string>) => void
-  // rebaseBehaviour: 'auto-rebase' | 'manual-rebase'
   span: otel.Span
 }): ClientSessionSyncProcessor => {
   const mutationEventSchema = MutationEvent.makeMutationEventSchemaMemo(schema)
 
   const syncStateRef = {
-    current: {
+    current: new SyncState({
       localHead: initialLeaderHead,
       upstreamHead: initialLeaderHead,
       pending: [],
       // TODO init rollbackTail from leader to be ready for backend rebasing
       rollbackTail: [],
-    } as SyncState,
+    }),
   }
 
   const isLocalEvent = (mutationEventEncoded: MutationEvent.EncodedWithMeta) => {
@@ -104,6 +102,7 @@ export const makeClientSessionSyncProcessor = ({
       mutationEvent.meta.sessionChangeset = res.sessionChangeset
     }
 
+    // console.debug('pushToLeader', encodedMutationEvents.length, ...encodedMutationEvents.map((_) => _.toJSON()))
     pushToLeader(encodedMutationEvents)
 
     return { writeTables }
@@ -155,6 +154,8 @@ export const makeClientSessionSyncProcessor = ({
                 event.meta.sessionChangeset = undefined
               }
             }
+
+            pushToLeader(updateResult.newSyncState.pending)
           } else {
             span.addEvent('pull:advance', {
               payloadTag: payload._tag,

package/src/sync/index.ts

@@ -1,3 +1,3 @@
 export * from './sync.js'
 export * from './validate-push-payload.js'
-export * from './client-session-sync-processor.js'
+export * from './ClientSessionSyncProcessor.js'

package/src/sync/sync.ts

@@ -1,12 +1,23 @@
-import type { Effect, HttpClient, Option, Stream, SubscriptionRef } from '@livestore/utils/effect'
+import type { Effect, HttpClient, Option, Scope, Stream, SubscriptionRef } from '@livestore/utils/effect'
 import { Schema } from '@livestore/utils/effect'
 
+import type { UnexpectedError } from '../adapter-types.js'
+import type { InitialSyncOptions } from '../leader-thread/types.js'
 import * as EventId from '../schema/EventId.js'
 import type * as MutationEvent from '../schema/MutationEvent.js'
 
-export interface SyncBackendOptionsBase {
-  type: string
-  [key: string]: Schema.JsonValue
+/**
+ * Those arguments can be used to implement multi-tenancy etc and are passed in from the store.
+ */
+export type MakeBackendArgs = {
+  storeId: string
+  clientId: string
+}
+
+export type SyncOptions = {
+  makeBackend: (args: MakeBackendArgs) => Effect.Effect<SyncBackend<any>, UnexpectedError, Scope.Scope>
+  /** @default { _tag: 'Skip' } */
+  initialSyncOptions?: InitialSyncOptions
 }
 
 export type SyncBackend<TSyncMetadata = Schema.JsonValue> = {

package/src/sync/syncstate.test.ts

@@ -58,12 +58,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 +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).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.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 +114,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.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,13 +134,18 @@ 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 }
+          const syncState = new SyncState.SyncState({
+            pending: [],
+            rollbackTail: [],
+            upstreamHead: EventId.ROOT,
+            localHead: e_0_0.id,
+          })
           expect(() =>
             run({
               syncState,
@@ -145,7 +155,12 @@ describe('syncstate', () => {
         })
 
         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 +168,92 @@ 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 }
+        const syncState = new SyncState.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 = { 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,
+        })
         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 = { 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 +262,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 = {
+        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 +282,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 = {
+        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 +302,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 = {
+        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 +323,20 @@ 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])
       })
     })
 
     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 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,7 +344,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).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])
@@ -307,7 +352,12 @@ 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 = { pending: [e_0_0_b], rollbackTail: [], upstreamHead: EventId.ROOT, localHead: e_0_0_b.id }
+        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 +367,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 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 +387,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 }
+        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 +408,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 +431,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 = {
+        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 +455,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 +481,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,10 +504,10 @@ 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)
   })
 }