@livestore/common 0.3.0-dev.46 → 0.3.0-dev.48

package/src/sync/next/test/event-fixtures.ts

@@ -2,12 +2,19 @@ import { Schema } from '@livestore/utils/effect'
 
 import type { EventDef } from '../../../schema/EventDef.js'
 import { defineEvent, defineFacts } from '../../../schema/EventDef.js'
-import * as EventId from '../../../schema/EventId.js'
+import * as EventSequenceNumber from '../../../schema/EventSequenceNumber.js'
 import { factsSnapshotForDag, getFactsGroupForEventArgs } from '../facts.js'
 import { historyDagFromNodes } from '../history-dag.js'
 import type { HistoryDagNode } from '../history-dag-common.js'
 import { rootEventNode } from '../history-dag-common.js'
 
+export const printEvent = ({ seqNum, parentSeqNum, factsGroup, ...rest }: HistoryDagNode) => ({
+  seqNum: EventSequenceNumber.toString(seqNum),
+  parentSeqNum: EventSequenceNumber.toString(parentSeqNum),
+  ...rest,
+  facts: factsGroup,
+})
+
 /** Used for conflict detection and event history compaction */
 export const facts = defineFacts({
   todoExists: (id: string) => `todo-exists-${id}`,
@@ -131,15 +138,15 @@ export const toEventNodes = (
 ): HistoryDagNode[] => {
   const nodesAcc: HistoryDagNode[] = [rootEventNode]
 
-  let currentEventId: EventId.EventId = EventId.ROOT
+  let currentEventSequenceNumber: EventSequenceNumber.EventSequenceNumber = EventSequenceNumber.ROOT
 
   const eventNodes = partialEvents.map((partialEvent) => {
     const eventDef = eventDefs[partialEvent.name]!
-    const eventId = EventId.nextPair(currentEventId, eventDef.options.clientOnly).id
-    currentEventId = eventId
+    const eventNum = EventSequenceNumber.nextPair(currentEventSequenceNumber, eventDef.options.clientOnly).seqNum
+    currentEventSequenceNumber = eventNum
 
     const factsSnapshot = factsSnapshotForDag(historyDagFromNodes(nodesAcc, { skipFactsCheck: true }), undefined)
-    // console.log('factsSnapshot', eventId, factsSnapshot)
+    // console.log('factsSnapshot', eventNum, factsSnapshot)
     // const depRead: EventDefFactsSnapshot = new Map<string, any>()
     // const factsSnapshotProxy = new Proxy(factsSnapshot, {
     //   get: (target, prop) => {
@@ -188,8 +195,8 @@ export const toEventNodes = (
     })
 
     const node = {
-      id: eventId,
-      parentId: getParentId(eventId),
+      seqNum: eventNum,
+      parentSeqNum: getParentNum(eventNum),
       name: partialEvent.name,
       args: partialEvent.args,
       factsGroup: facts,
@@ -207,13 +214,13 @@ export const toEventNodes = (
   return eventNodes
 }
 
-const getParentId = (eventId: EventId.EventId): EventId.EventId => {
-  const globalParentId = eventId.global
-  const clientParentId = eventId.client - 1
+const getParentNum = (eventNum: EventSequenceNumber.EventSequenceNumber): EventSequenceNumber.EventSequenceNumber => {
+  const globalParentNum = eventNum.global
+  const clientParentNum = eventNum.client - 1
 
-  if (clientParentId < 0) {
-    return EventId.make({ global: globalParentId - 1, client: EventId.clientDefault })
+  if (clientParentNum < 0) {
+    return EventSequenceNumber.make({ global: globalParentNum - 1, client: EventSequenceNumber.clientDefault })
   }
 
-  return EventId.make({ global: globalParentId, client: clientParentId })
+  return EventSequenceNumber.make({ global: globalParentNum, client: clientParentNum })
 }

package/src/sync/sync.ts

@@ -3,7 +3,7 @@ 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 * as EventSequenceNumber from '../schema/EventSequenceNumber.js'
 import type * as LiveStoreEvent from '../schema/LiveStoreEvent.js'
 
 /**
@@ -42,7 +42,7 @@ export type SyncBackend<TSyncMetadata = Schema.JsonValue> = {
   connect: Effect.Effect<void, IsOfflineError | UnexpectedError, HttpClient.HttpClient | Scope.Scope>
   pull: (
     args: Option.Option<{
-      cursor: EventId.EventId
+      cursor: EventSequenceNumber.EventSequenceNumber
       metadata: Option.Option<TSyncMetadata>
     }>,
   ) => Stream.Stream<
@@ -61,7 +61,7 @@ export type SyncBackend<TSyncMetadata = Schema.JsonValue> = {
     /**
      * Constraints for batch:
      * - Number of events: 1-100
-     * - event ids must be in ascending order
+     * - sequence numbers must be in ascending order
      * */
     batch: ReadonlyArray<LiveStoreEvent.AnyEncodedGlobal>,
   ) => Effect.Effect<void, IsOfflineError | InvalidPushError, HttpClient.HttpClient>
@@ -80,8 +80,8 @@ export class InvalidPushError extends Schema.TaggedError<InvalidPushError>()('In
       message: Schema.String,
     }),
     Schema.TaggedStruct('ServerAhead', {
-      minimumExpectedId: Schema.Number,
-      providedId: Schema.Number,
+      minimumExpectedNum: Schema.Number,
+      providedNum: Schema.Number,
     }),
   ),
 }) {}
@@ -91,8 +91,8 @@ export class InvalidPullError extends Schema.TaggedError<InvalidPullError>()('In
 }) {}
 
 export class LeaderAheadError extends Schema.TaggedError<LeaderAheadError>()('LeaderAheadError', {
-  minimumExpectedId: EventId.EventId,
-  providedId: EventId.EventId,
+  minimumExpectedNum: EventSequenceNumber.EventSequenceNumber,
+  providedNum: EventSequenceNumber.EventSequenceNumber,
   /** Generation number the client session should use for subsequent pushes */
   // nextGeneration: Schema.Number,
 }) {}

package/src/sync/syncstate.test.ts

@@ -1,20 +1,20 @@
 /* eslint-disable prefer-arrow/prefer-arrow-functions */
 import { describe, expect, it } from 'vitest'
 
-import * as EventId from '../schema/EventId.js'
+import * as EventSequenceNumber from '../schema/EventSequenceNumber.js'
 import * as LiveStoreEvent from '../schema/LiveStoreEvent.js'
 import * as SyncState from './syncstate.js'
 
 class TestEvent extends LiveStoreEvent.EncodedWithMeta {
   constructor(
-    id: EventId.EventId | typeof EventId.EventId.Encoded,
-    parentId: EventId.EventId,
+    seqNum: EventSequenceNumber.EventSequenceNumber | typeof EventSequenceNumber.EventSequenceNumber.Encoded,
+    parentSeqNum: EventSequenceNumber.EventSequenceNumber,
     public readonly payload: string,
     public readonly isLocal: boolean,
   ) {
     super({
-      id: EventId.make(id),
-      parentId: EventId.make(parentId),
+      seqNum: EventSequenceNumber.make(seqNum),
+      parentSeqNum: EventSequenceNumber.make(parentSeqNum),
       name: 'a',
       args: payload,
       clientId: 'static-local-id',
@@ -22,22 +22,22 @@ class TestEvent extends LiveStoreEvent.EncodedWithMeta {
     })
   }
 
-  rebase_ = (parentId: EventId.EventId) => {
-    return this.rebase(parentId, this.isLocal)
+  rebase_ = (parentSeqNum: EventSequenceNumber.EventSequenceNumber) => {
+    return this.rebase(parentSeqNum, this.isLocal)
   }
 
   // Only used for Vitest printing
-  // toJSON = () => `(${this.id.global},${this.id.client},${this.payload})`
+  // toJSON = () => `(${this.seqNum.global},${this.seqNum.client},${this.payload})`
   // toString = () => this.toJSON()
 }
 
-const e0_1 = new TestEvent({ global: 0, client: 1 }, EventId.ROOT, 'a', true)
-const e1_0 = new TestEvent({ global: 1, client: 0 }, EventId.ROOT, 'a', false)
-const e1_1 = new TestEvent({ global: 1, client: 1 }, e1_0.id, 'a', true)
-const e1_2 = new TestEvent({ global: 1, client: 2 }, e1_1.id, 'a', true)
-const e1_3 = new TestEvent({ global: 1, client: 3 }, e1_2.id, 'a', true)
-const e2_0 = new TestEvent({ global: 2, client: 0 }, e1_0.id, 'a', false)
-const e2_1 = new TestEvent({ global: 2, client: 1 }, e2_0.id, 'a', true)
+const 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
 
@@ -59,11 +59,11 @@ describe('syncstate', () => {
       it('should rollback until start', () => {
         const syncState = new SyncState.SyncState({
           pending: [e2_0],
-          upstreamHead: EventId.ROOT,
-          localHead: e2_0.id,
+          upstreamHead: EventSequenceNumber.ROOT,
+          localHead: e2_0.seqNum,
         })
-        const e1_0_e2_0 = e1_0.rebase_(e2_0.id)
-        const e1_1_e2_1 = e1_1.rebase_(e1_0_e2_0.id)
+        const 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: SyncState.PayloadUpstreamRebase.make({
@@ -71,11 +71,11 @@ describe('syncstate', () => {
             newEvents: [e1_0_e2_0, e1_1_e2_1],
           }),
         })
-        const e2_0_e3_0 = e2_0.rebase_(e1_0_e2_0.id)
+        const e2_0_e3_0 = e2_0.rebase_(e1_0_e2_0.seqNum)
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_1_e2_1.id)
-        expect(result.newSyncState.localHead).toMatchObject(e2_0_e3_0.id)
+        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])
       })
@@ -83,10 +83,10 @@ describe('syncstate', () => {
       it('should rollback only to specified point', () => {
         const syncState = new SyncState.SyncState({
           pending: [e2_0],
-          upstreamHead: EventId.ROOT,
-          localHead: e2_0.id,
+          upstreamHead: EventSequenceNumber.ROOT,
+          localHead: e2_0.seqNum,
         })
-        const e1_1_e2_0 = e1_1.rebase_(e1_0.id)
+        const e1_1_e2_0 = e1_1.rebase_(e1_0.seqNum)
         const result = merge({
           syncState,
           payload: SyncState.PayloadUpstreamRebase.make({
@@ -94,11 +94,11 @@ describe('syncstate', () => {
             rollbackEvents: [e1_1],
           }),
         })
-        const e2_0_e3_0 = e2_0.rebase_(e1_1_e2_0.id)
+        const e2_0_e3_0 = e2_0.rebase_(e1_1_e2_0.seqNum)
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_1_e2_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e2_0_e3_0.id)
+        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])
       })
@@ -106,8 +106,8 @@ describe('syncstate', () => {
       it('should work for empty pending', () => {
         const syncState = new SyncState.SyncState({
           pending: [],
-          upstreamHead: EventId.ROOT,
-          localHead: e1_0.id,
+          upstreamHead: EventSequenceNumber.ROOT,
+          localHead: e1_0.seqNum,
         })
         const result = merge({
           syncState,
@@ -115,28 +115,28 @@ describe('syncstate', () => {
         })
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e2_0.id)
+        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 (client)', () => {
+      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: EventId.ROOT,
-          localHead: e1_0.id,
+          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)', () => {
+      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: EventId.ROOT,
-          localHead: e1_0.id,
+          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' })
@@ -145,8 +145,8 @@ describe('syncstate', () => {
       it('should throw error if incoming event is < expected upstream head', () => {
         const syncState = new SyncState.SyncState({
           pending: [],
-          upstreamHead: e2_0.id,
-          localHead: e2_0.id,
+          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' })
@@ -155,8 +155,8 @@ describe('syncstate', () => {
       it('should throw error if incoming event is = expected upstream head', () => {
         const syncState = new SyncState.SyncState({
           pending: [],
-          upstreamHead: e2_0.id,
-          localHead: e2_0.id,
+          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' })
@@ -165,15 +165,15 @@ describe('syncstate', () => {
       it('should confirm pending event when receiving matching event', () => {
         const syncState = new SyncState.SyncState({
           pending: [e1_0],
-          upstreamHead: EventId.ROOT,
-          localHead: e1_0.id,
+          upstreamHead: EventSequenceNumber.ROOT,
+          localHead: e1_0.seqNum,
         })
         const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0] } })
 
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e1_0.id)
+        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.seqNum)
+        expect(result.newSyncState.localHead).toMatchObject(e1_0.seqNum)
         expectEventArraysEqual(result.newEvents, [])
         expectEventArraysEqual(result.confirmedEvents, [e1_0])
       })
@@ -181,15 +181,15 @@ describe('syncstate', () => {
       it('should confirm partial pending event when receiving matching event', () => {
         const syncState = new SyncState.SyncState({
           pending: [e1_0, e2_0],
-          upstreamHead: EventId.ROOT,
-          localHead: e2_0.id,
+          upstreamHead: EventSequenceNumber.ROOT,
+          localHead: e2_0.seqNum,
         })
         const result = merge({ syncState, payload: { _tag: 'upstream-advance', newEvents: [e1_0] } })
 
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [e2_0])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e2_0.id)
+        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.seqNum)
+        expect(result.newSyncState.localHead).toMatchObject(e2_0.seqNum)
         expectEventArraysEqual(result.newEvents, [])
         expectEventArraysEqual(result.confirmedEvents, [e1_0])
       })
@@ -197,15 +197,15 @@ describe('syncstate', () => {
       it('should confirm pending event and add new event', () => {
         const syncState = new SyncState.SyncState({
           pending: [e1_0],
-          upstreamHead: EventId.ROOT,
-          localHead: e1_0.id,
+          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, [])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_1.id)
-        expect(result.newSyncState.localHead).toMatchObject(e1_1.id)
+        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])
       })
@@ -213,8 +213,8 @@ describe('syncstate', () => {
       it('should confirm pending event and add multiple new events', () => {
         const syncState = new SyncState.SyncState({
           pending: [e1_1],
-          upstreamHead: e1_0.id,
-          localHead: e1_1.id,
+          upstreamHead: e1_0.seqNum,
+          localHead: e1_1.seqNum,
         })
         const result = merge({
           syncState,
@@ -223,8 +223,8 @@ describe('syncstate', () => {
 
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e2_1.id)
-        expect(result.newSyncState.localHead).toMatchObject(e2_1.id)
+        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])
       })
@@ -232,8 +232,8 @@ describe('syncstate', () => {
       it('should confirm pending global event while keep pending client events', () => {
         const syncState = new SyncState.SyncState({
           pending: [e1_0, e1_1],
-          upstreamHead: EventId.ROOT,
-          localHead: e1_1.id,
+          upstreamHead: EventSequenceNumber.ROOT,
+          localHead: e1_1.seqNum,
         })
         const result = merge({
           syncState,
@@ -242,8 +242,8 @@ describe('syncstate', () => {
 
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [e1_1])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e1_1.id)
+        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.seqNum)
+        expect(result.newSyncState.localHead).toMatchObject(e1_1.seqNum)
         expectEventArraysEqual(result.newEvents, [])
         expectEventArraysEqual(result.confirmedEvents, [e1_0])
       })
@@ -251,8 +251,8 @@ describe('syncstate', () => {
       it('should ignore client events (incoming is subset of pending)', () => {
         const syncState = new SyncState.SyncState({
           pending: [e0_1, e1_0],
-          upstreamHead: EventId.ROOT,
-          localHead: e1_0.id,
+          upstreamHead: EventSequenceNumber.ROOT,
+          localHead: e1_0.seqNum,
         })
         const result = merge({
           syncState,
@@ -261,8 +261,8 @@ describe('syncstate', () => {
         })
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e1_0.id)
+        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])
       })
@@ -270,8 +270,8 @@ describe('syncstate', () => {
       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: EventId.ROOT,
-          localHead: e1_0.id,
+          upstreamHead: EventSequenceNumber.ROOT,
+          localHead: e1_0.seqNum,
         })
         const result = merge({
           syncState,
@@ -280,8 +280,8 @@ describe('syncstate', () => {
         })
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [e2_0])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e2_0.id)
+        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])
       })
@@ -289,8 +289,8 @@ describe('syncstate', () => {
       it('should ignore client events (incoming goes beyond pending)', () => {
         const syncState = new SyncState.SyncState({
           pending: [e0_1, e1_0, e1_1],
-          upstreamHead: EventId.ROOT,
-          localHead: e1_1.id,
+          upstreamHead: EventSequenceNumber.ROOT,
+          localHead: e1_1.seqNum,
         })
         const result = merge({
           syncState,
@@ -300,8 +300,8 @@ describe('syncstate', () => {
 
         expectAdvance(result)
         expectEventArraysEqual(result.newSyncState.pending, [])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e2_0.id)
+        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])
       })
@@ -309,8 +309,8 @@ describe('syncstate', () => {
       it('should fail if incoming event is ≤ local head', () => {
         const syncState = new SyncState.SyncState({
           pending: [],
-          upstreamHead: e2_0.id,
-          localHead: e2_0.id,
+          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' })
@@ -321,99 +321,99 @@ describe('syncstate', () => {
       it('should rebase single client event to end', () => {
         const syncState = new SyncState.SyncState({
           pending: [e1_0],
-          upstreamHead: EventId.ROOT,
-          localHead: e1_0.id,
+          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.id)
+        const e1_0_e1_2 = e1_0.rebase_(e1_1.seqNum)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e1_0_e1_2])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e1_1.id)
-        expect(result.newSyncState.localHead).toMatchObject(e1_0_e1_2.id)
+        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 e2_0_b = new TestEvent({ global: 1, client: 0 }, e1_0.id, '1_0_b', false)
+        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: EventId.ROOT,
-          localHead: e2_0_b.id,
+          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.id)
+        const e2_0_e3_0 = e2_0_b.rebase_(e2_0.seqNum)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
         expectEventArraysEqual(result.newEvents, [e2_0, e2_0_e3_0])
         expectEventArraysEqual(result.rollbackEvents, [e2_0_b])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e2_0_e3_0.id)
+        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.seqNum)
+        expect(result.newSyncState.localHead).toMatchObject(e2_0_e3_0.seqNum)
       })
 
       it('should rebase single client event to end (more incoming events)', () => {
         const syncState = new SyncState.SyncState({
           pending: [e1_0],
-          upstreamHead: EventId.ROOT,
-          localHead: e1_0.id,
+          upstreamHead: EventSequenceNumber.ROOT,
+          localHead: e1_0.seqNum,
         })
         const result = merge({
           syncState,
           payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1, e1_2, e1_3, e2_0] }),
         })
 
-        const e1_0_e3_0 = e1_0.rebase_(e2_0.id)
+        const e1_0_e3_0 = e1_0.rebase_(e2_0.seqNum)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e1_0_e3_0])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e1_0_e3_0.id)
+        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 = new SyncState.SyncState({
           pending: [e1_0, e1_1],
-          upstreamHead: EventId.ROOT,
-          localHead: e1_0.id,
+          upstreamHead: EventSequenceNumber.ROOT,
+          localHead: e1_0.seqNum,
         })
         const result = merge({
           syncState,
           payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_0, e1_2, e1_3, e2_0] }),
         })
 
-        const e1_1_e2_1 = e1_1.rebase_(e2_0.id)
+        const e1_1_e2_1 = e1_1.rebase_(e2_0.seqNum)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e1_1_e2_1])
         expectEventArraysEqual(result.rollbackEvents, [e1_1])
         expectEventArraysEqual(result.newEvents, [e1_2, e1_3, e2_0, e1_1_e2_1])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e1_1_e2_1.id)
+        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.seqNum)
+        expect(result.newSyncState.localHead).toMatchObject(e1_1_e2_1.seqNum)
       })
 
       it('should rebase all client events when incoming chain starts differently', () => {
         const syncState = new SyncState.SyncState({
           pending: [e1_0, e1_1],
-          upstreamHead: EventId.ROOT,
-          localHead: e1_1.id,
+          upstreamHead: EventSequenceNumber.ROOT,
+          localHead: e1_1.seqNum,
         })
         const result = merge({
           syncState,
           payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1, e1_2, e1_3, e2_0] }),
         })
 
-        const e1_0_e2_1 = e1_0.rebase_(e2_0.id)
-        const e1_1_e2_2 = e1_1.rebase_(e1_0_e2_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, [e1_0_e2_1, e1_1_e2_2])
         expectEventArraysEqual(result.newEvents, [e1_1, e1_2, e1_3, e2_0, e1_0_e2_1, e1_1_e2_2])
         expectEventArraysEqual(result.rollbackEvents, [e1_0, e1_1])
-        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.id)
-        expect(result.newSyncState.localHead).toMatchObject(e1_1_e2_2.id)
+        expect(result.newSyncState.upstreamHead).toMatchObject(e2_0.seqNum)
+        expect(result.newSyncState.localHead).toMatchObject(e1_1_e2_2.seqNum)
       })
 
       describe('local-push', () => {
@@ -421,8 +421,8 @@ describe('syncstate', () => {
           it('should advance with new events', () => {
             const syncState = new SyncState.SyncState({
               pending: [e1_0],
-              upstreamHead: EventId.ROOT,
-              localHead: e1_0.id,
+              upstreamHead: EventSequenceNumber.ROOT,
+              localHead: e1_0.seqNum,
             })
             const result = merge({
               syncState,
@@ -431,8 +431,8 @@ describe('syncstate', () => {
 
             expectAdvance(result)
             expectEventArraysEqual(result.newSyncState.pending, [e1_0, e1_1, e1_2, e1_3])
-            expect(result.newSyncState.upstreamHead).toMatchObject(EventId.ROOT)
-            expect(result.newSyncState.localHead).toMatchObject(e1_3.id)
+            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, [])
           })
@@ -442,8 +442,8 @@ describe('syncstate', () => {
           it('should reject when new events are greater than pending events', () => {
             const syncState = new SyncState.SyncState({
               pending: [e1_0, e1_1],
-              upstreamHead: EventId.ROOT,
-              localHead: e1_1.id,
+              upstreamHead: EventSequenceNumber.ROOT,
+              localHead: e1_1.seqNum,
             })
             const result = merge({
               syncState,
@@ -451,7 +451,7 @@ describe('syncstate', () => {
             })
 
             expectReject(result)
-            expect(result.expectedMinimumId).toMatchObject(e1_2.id)
+            expect(result.expectedMinimumId).toMatchObject(e1_2.seqNum)
           })
         })
       })
@@ -465,8 +465,8 @@ 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.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)
   })