@livestore/common 0.3.0-dev.8 → 0.3.0

package/src/sync/next/facts.ts

@@ -1,24 +1,24 @@
 import { notYetImplemented } from '@livestore/utils'
 
-import type * as EventId from '../../schema/EventId.js'
 import type {
+  EventDefFactInput,
+  EventDefFacts,
+  EventDefFactsGroup,
+  EventDefFactsSnapshot,
   FactsCallback,
-  MutationEventFactInput,
-  MutationEventFacts,
-  MutationEventFactsGroup,
-  MutationEventFactsSnapshot,
-} from '../../schema/mutations.js'
+} from '../../schema/EventDef.js'
+import type * as EventSequenceNumber from '../../schema/EventSequenceNumber.js'
 import { graphologyDag } from './graphology_.js'
 import { EMPTY_FACT_VALUE, type HistoryDag, type HistoryDagNode } from './history-dag-common.js'
 
 export const factsSnapshotForEvents = (
   events: HistoryDagNode[],
-  endEventId: EventId.EventId,
-): MutationEventFactsSnapshot => {
+  endEventSequenceNumber: EventSequenceNumber.EventSequenceNumber,
+): EventDefFactsSnapshot => {
   const facts = new Map<string, any>()
 
   for (const event of events) {
-    if (compareEventIds(event.id, endEventId) > 0) {
+    if (compareEventSequenceNumbers(event.seqNum, endEventSequenceNumber) > 0) {
       return facts
     }
 
@@ -30,15 +30,15 @@ export const factsSnapshotForEvents = (
 
 export const factsSnapshotForDag = (
   dag: HistoryDag,
-  endEventId: EventId.EventId | undefined,
-): MutationEventFactsSnapshot => {
+  endEventSequenceNumber: EventSequenceNumber.EventSequenceNumber | undefined,
+): EventDefFactsSnapshot => {
   const facts = new Map<string, any>()
 
-  const orderedEventIdStrs = graphologyDag.topologicalSort(dag)
+  const orderedEventSequenceNumberStrs = graphologyDag.topologicalSort(dag)
 
-  for (let i = 0; i < orderedEventIdStrs.length; i++) {
-    const event = dag.getNodeAttributes(orderedEventIdStrs[i]!)
-    if (endEventId !== undefined && compareEventIds(event.id, endEventId) > 0) {
+  for (let i = 0; i < orderedEventSequenceNumberStrs.length; i++) {
+    const event = dag.getNodeAttributes(orderedEventSequenceNumberStrs[i]!)
+    if (endEventSequenceNumber !== undefined && compareEventSequenceNumbers(event.seqNum, endEventSequenceNumber) > 0) {
       return facts
     }
 
@@ -56,20 +56,20 @@ export type FactValidationResult =
       success: false
       /** Index of the item that caused the validation to fail */
       index: number
-      requiredFacts: MutationEventFacts
+      requiredFacts: EventDefFacts
       mismatch: {
-        existing: MutationEventFacts
-        required: MutationEventFacts
+        existing: EventDefFacts
+        required: EventDefFacts
       }
-      currentSnapshot: MutationEventFacts
+      currentSnapshot: EventDefFacts
     }
 
 export const validateFacts = ({
   factGroups,
   initialSnapshot,
 }: {
-  factGroups: MutationEventFactsGroup[]
-  initialSnapshot: MutationEventFactsSnapshot
+  factGroups: EventDefFactsGroup[]
+  initialSnapshot: EventDefFactsSnapshot
 }): FactValidationResult => {
   const currentSnapshot = new Map(initialSnapshot)
 
@@ -102,13 +102,13 @@ export const validateFacts = ({
   }
 }
 
-export const applyFactGroups = (factGroups: MutationEventFactsGroup[], snapshot: MutationEventFactsSnapshot) => {
+export const applyFactGroups = (factGroups: EventDefFactsGroup[], snapshot: EventDefFactsSnapshot) => {
   for (const factGroup of factGroups) {
     applyFactGroup(factGroup, snapshot)
   }
 }
 
-export const applyFactGroup = (factGroup: MutationEventFactsGroup, snapshot: MutationEventFactsSnapshot) => {
+export const applyFactGroup = (factGroup: EventDefFactsGroup, snapshot: EventDefFactsSnapshot) => {
   for (const [key, value] of factGroup.modifySet) {
     snapshot.set(key, value)
   }
@@ -119,7 +119,7 @@ export const applyFactGroup = (factGroup: MutationEventFactsGroup, snapshot: Mut
 }
 
 /** Check if setA is a subset of setB */
-const isSubSetMapByValue = (setA: MutationEventFacts, setB: MutationEventFacts) => {
+const isSubSetMapByValue = (setA: EventDefFacts, setB: EventDefFacts) => {
   for (const [key, value] of setA) {
     if (setB.get(key) !== value) {
       return false
@@ -129,7 +129,7 @@ const isSubSetMapByValue = (setA: MutationEventFacts, setB: MutationEventFacts)
 }
 
 /** Check if setA is a subset of setB */
-const isSubSetMapByKey = (setA: MutationEventFacts, setB: MutationEventFacts) => {
+const isSubSetMapByKey = (setA: EventDefFacts, setB: EventDefFacts) => {
   for (const [key, _value] of setA) {
     if (!setB.has(key)) {
       return false
@@ -139,17 +139,16 @@ const isSubSetMapByKey = (setA: MutationEventFacts, setB: MutationEventFacts) =>
 }
 
 /** Check if groupA depends on groupB */
-export const dependsOn = (groupA: MutationEventFactsGroup, groupB: MutationEventFactsGroup): boolean =>
+export const dependsOn = (groupA: EventDefFactsGroup, groupB: EventDefFactsGroup): boolean =>
   factsIntersect(groupA.depRead, groupB.modifySet) ||
   factsIntersect(groupA.depRead, groupB.modifyUnset) ||
   factsIntersect(groupA.depRequire, groupB.modifySet) ||
   factsIntersect(groupA.depRequire, groupB.modifyUnset)
 
-export const replacesFacts = (groupA: MutationEventFactsGroup, groupB: MutationEventFactsGroup): boolean => {
-  const replaces = (a: MutationEventFacts, b: MutationEventFacts) => a.size > 0 && b.size > 0 && isSameMapByKey(a, b)
+export const replacesFacts = (groupA: EventDefFactsGroup, groupB: EventDefFactsGroup): boolean => {
+  const replaces = (a: EventDefFacts, b: EventDefFacts) => a.size > 0 && b.size > 0 && isSameMapByKey(a, b)
 
-  const noFactsOrSame = (a: MutationEventFacts, b: MutationEventFacts) =>
-    a.size === 0 || b.size === 0 || isSameMapByKey(a, b)
+  const noFactsOrSame = (a: EventDefFacts, b: EventDefFacts) => a.size === 0 || b.size === 0 || isSameMapByKey(a, b)
 
   return (
     (replaces(groupA.modifySet, groupB.modifySet) && noFactsOrSame(groupA.modifyUnset, groupB.modifyUnset)) ||
@@ -159,16 +158,16 @@ export const replacesFacts = (groupA: MutationEventFactsGroup, groupB: MutationE
   )
 }
 
-export const isSameMapByKey = (set: MutationEventFacts, otherSet: MutationEventFacts) =>
+export const isSameMapByKey = (set: EventDefFacts, otherSet: EventDefFacts) =>
   set.size === otherSet.size && isSubSetMapByKey(set, otherSet)
 
-export const factsToString = (facts: MutationEventFacts) => {
+export const factsToString = (facts: EventDefFacts) => {
   return Array.from(facts)
     .map(([key, value]) => (value === EMPTY_FACT_VALUE ? key : `${key}=${value}`))
     .join(', ')
 }
 
-export const factsIntersect = (setA: MutationEventFacts, setB: MutationEventFacts): boolean => {
+export const factsIntersect = (setA: EventDefFacts, setB: EventDefFacts): boolean => {
   for (const [key, _value] of setA) {
     if (setB.has(key)) {
       return true
@@ -177,16 +176,16 @@ export const factsIntersect = (setA: MutationEventFacts, setB: MutationEventFact
   return false
 }
 
-export const getFactsGroupForMutationArgs = ({
+export const getFactsGroupForEventArgs = ({
   factsCallback,
   args,
   currentFacts,
 }: {
   factsCallback: FactsCallback<any> | undefined
   args: any
-  currentFacts: MutationEventFactsSnapshot
-}): MutationEventFactsGroup => {
-  const depRead: MutationEventFactsSnapshot = new Map<string, any>()
+  currentFacts: EventDefFactsSnapshot
+}): EventDefFactsGroup => {
+  const depRead: EventDefFactsSnapshot = new Map<string, any>()
   const factsSnapshotProxy = new Proxy(currentFacts, {
     get: (target, prop) => {
       if (prop === 'has') {
@@ -201,12 +200,12 @@ export const getFactsGroupForMutationArgs = ({
         }
       }
 
-      notYetImplemented(`getFactsGroupForMutationArgs: ${prop.toString()} is not yet implemented`)
+      notYetImplemented(`getFactsGroupForEventArgs: ${prop.toString()} is not yet implemented`)
     },
   })
 
   const factsRes = factsCallback?.(args, factsSnapshotProxy)
-  const iterableToMap = (iterable: Iterable<MutationEventFactInput>) => {
+  const iterableToMap = (iterable: Iterable<EventDefFactInput>) => {
     const map = new Map()
     for (const item of iterable) {
       if (typeof item === 'string') {
@@ -227,9 +226,12 @@ export const getFactsGroupForMutationArgs = ({
   return facts
 }
 
-export const compareEventIds = (a: EventId.EventId, b: EventId.EventId) => {
+export const compareEventSequenceNumbers = (
+  a: EventSequenceNumber.EventSequenceNumber,
+  b: EventSequenceNumber.EventSequenceNumber,
+) => {
   if (a.global !== b.global) {
     return a.global - b.global
   }
-  return a.local - b.local
+  return a.client - b.client
 }

package/src/sync/next/history-dag-common.ts

@@ -1,5 +1,5 @@
-import * as EventId from '../../schema/EventId.js'
-import type { MutationEventFactsGroup } from '../../schema/mutations.js'
+import type { EventDefFactsGroup } from '../../schema/EventDef.js'
+import * as EventSequenceNumber from '../../schema/EventSequenceNumber.js'
 import { graphology } from './graphology_.js'
 
 export const connectionTypeOptions = ['parent', 'facts'] as const
@@ -20,25 +20,32 @@ export const emptyHistoryDag = (): HistoryDag =>
   })
 
 // TODO consider making `ROOT_ID` parent to itself
-export const rootParentId = EventId.make({ global: EventId.ROOT.global - 1, local: EventId.localDefault })
+export const rootParentNum = EventSequenceNumber.make({
+  global: EventSequenceNumber.ROOT.global - 1,
+  client: EventSequenceNumber.clientDefault,
+})
 
 export type HistoryDagNode = {
-  id: EventId.EventId
-  parentId: EventId.EventId
-  mutation: string
+  seqNum: EventSequenceNumber.EventSequenceNumber
+  parentSeqNum: EventSequenceNumber.EventSequenceNumber
+  name: string
   args: any
   /** Facts are being used for conflict detection and history compaction */
-  factsGroup: MutationEventFactsGroup
+  factsGroup: EventDefFactsGroup
   meta?: any
+  clientId: string
+  sessionId: string | undefined
 }
 
 export const rootEventNode: HistoryDagNode = {
-  id: EventId.ROOT,
-  parentId: rootParentId,
+  seqNum: EventSequenceNumber.ROOT,
+  parentSeqNum: rootParentNum,
   // unused below
-  mutation: '__Root__',
+  name: '__Root__',
   args: {},
   factsGroup: { modifySet: new Map(), modifyUnset: new Map(), depRequire: new Map(), depRead: new Map() },
+  clientId: 'root',
+  sessionId: undefined,
 }
 
 export const EMPTY_FACT_VALUE = Symbol('EMPTY_FACT_VALUE')

package/src/sync/next/history-dag.ts

@@ -1,9 +1,6 @@
-import type * as EventId from '../../schema/EventId.js'
+import * as EventSequenceNumber from '../../schema/EventSequenceNumber.js'
 import { factsToString, validateFacts } from './facts.js'
-import { emptyHistoryDag, type HistoryDagNode, rootParentId } from './history-dag-common.js'
-
-export const eventIdToString = (eventId: EventId.EventId) =>
-  eventId.local === 0 ? eventId.global.toString() : `${eventId.global}.${eventId.local}`
+import { emptyHistoryDag, type HistoryDagNode, rootParentNum } from './history-dag-common.js'
 
 export const historyDagFromNodes = (dagNodes: HistoryDagNode[], options?: { skipFactsCheck: boolean }) => {
   if (options?.skipFactsCheck !== true) {
@@ -14,18 +11,20 @@ export const historyDagFromNodes = (dagNodes: HistoryDagNode[], options?: { skip
 
     if (validationResult.success === false) {
       throw new Error(
-        `Mutation ${dagNodes[validationResult.index]!.mutation} requires facts that have not been set yet.\nRequires: ${factsToString(validationResult.requiredFacts)}\nFacts Snapshot: ${factsToString(validationResult.currentSnapshot)}`,
+        `Event ${dagNodes[validationResult.index]!.name} requires facts that have not been set yet.\nRequires: ${factsToString(validationResult.requiredFacts)}\nFacts Snapshot: ${factsToString(validationResult.currentSnapshot)}`,
       )
     }
   }
 
   const dag = emptyHistoryDag()
 
-  dagNodes.forEach((node) => dag.addNode(eventIdToString(node.id), node))
+  dagNodes.forEach((node) => dag.addNode(EventSequenceNumber.toString(node.seqNum), node))
 
   dagNodes.forEach((node) => {
-    if (eventIdToString(node.parentId) !== eventIdToString(rootParentId)) {
-      dag.addEdge(eventIdToString(node.parentId), eventIdToString(node.id), { type: 'parent' })
+    if (EventSequenceNumber.toString(node.parentSeqNum) !== EventSequenceNumber.toString(rootParentNum)) {
+      dag.addEdge(EventSequenceNumber.toString(node.parentSeqNum), EventSequenceNumber.toString(node.seqNum), {
+        type: 'parent',
+      })
     }
   })
 
@@ -34,28 +33,28 @@ export const historyDagFromNodes = (dagNodes: HistoryDagNode[], options?: { skip
     for (const factKey of factKeys) {
       // Find the first ancestor node with a matching fact key (via modifySet or modifyUnset) by traversing the graph backwards via the parent edges
       const depNode = (() => {
-        let currentIdStr = eventIdToString(node.id)
+        let currentSeqNumStr = EventSequenceNumber.toString(node.seqNum)
 
-        while (currentIdStr !== eventIdToString(rootParentId)) {
-          const parentEdge = dag.inEdges(currentIdStr).find((e) => dag.getEdgeAttribute(e, 'type') === 'parent')
+        while (currentSeqNumStr !== EventSequenceNumber.toString(rootParentNum)) {
+          const parentEdge = dag.inEdges(currentSeqNumStr).find((e) => dag.getEdgeAttribute(e, 'type') === 'parent')
           if (!parentEdge) return null
 
-          const parentIdStr = dag.source(parentEdge)
-          const parentNode = dag.getNodeAttributes(parentIdStr)
+          const parentSeqNumStr = dag.source(parentEdge)
+          const parentNode = dag.getNodeAttributes(parentSeqNumStr)
 
           if (parentNode.factsGroup.modifySet.has(factKey) || parentNode.factsGroup.modifyUnset.has(factKey)) {
             return parentNode
           }
 
-          currentIdStr = parentIdStr
+          currentSeqNumStr = parentSeqNumStr
         }
 
         return null
       })()
 
       if (depNode) {
-        const depNodeIdStr = eventIdToString(depNode.id)
-        const nodeIdStr = eventIdToString(node.id)
+        const depNodeIdStr = EventSequenceNumber.toString(depNode.seqNum)
+        const nodeIdStr = EventSequenceNumber.toString(node.seqNum)
         if (dag.edges(depNodeIdStr, nodeIdStr).filter((e) => dag.getEdgeAttributes(e).type === 'facts').length === 0) {
           dag.addEdge(depNodeIdStr, nodeIdStr, { type: 'facts' })
         }

package/src/sync/next/rebase-events.ts

@@ -1,11 +1,11 @@
-import * as EventId from '../../schema/EventId.js'
-import type * as MutationEvent from '../../schema/MutationEvent.js'
-import type { MutationDef, MutationEventFactsSnapshot } from '../../schema/mutations.js'
+import type { EventDef, EventDefFactsSnapshot } from '../../schema/EventDef.js'
+import * as EventSequenceNumber from '../../schema/EventSequenceNumber.js'
+import type * as LiveStoreEvent from '../../schema/LiveStoreEvent.js'
 import {
   applyFactGroups,
   factsIntersect,
   type FactValidationResult,
-  getFactsGroupForMutationArgs,
+  getFactsGroupForEventArgs,
   validateFacts,
 } from './facts.js'
 import type { HistoryDagNode } from './history-dag-common.js'
@@ -19,13 +19,13 @@ export type RebaseInput = {
   newRemoteEvents: RebaseEventWithConflict[]
   pendingLocalEvents: RebaseEventWithConflict[]
   validate: (args: {
-    rebasedLocalEvents: MutationEvent.PartialAnyDecoded[]
-    mutationDefs: Record<string, MutationDef.Any>
+    rebasedLocalEvents: LiveStoreEvent.PartialAnyDecoded[]
+    eventDefs: Record<string, EventDef.Any>
   }) => FactValidationResult
 }
 
 export type RebaseOutput = {
-  rebasedLocalEvents: MutationEvent.PartialAnyDecoded[]
+  rebasedLocalEvents: LiveStoreEvent.PartialAnyDecoded[]
 }
 
 export type RebaseFn = (input: RebaseInput) => RebaseOutput
@@ -43,12 +43,16 @@ export const rebaseEvents = ({
   pendingLocalEvents,
   newRemoteEvents,
   currentFactsSnapshot,
+  clientId,
+  sessionId,
 }: {
   pendingLocalEvents: HistoryDagNode[]
   newRemoteEvents: HistoryDagNode[]
   rebaseFn: RebaseFn
-  currentFactsSnapshot: MutationEventFactsSnapshot
-}): ReadonlyArray<MutationEvent.AnyDecoded> => {
+  currentFactsSnapshot: EventDefFactsSnapshot
+  clientId: string
+  sessionId: string
+}): ReadonlyArray<LiveStoreEvent.AnyDecoded> => {
   const initialSnapshot = new Map(currentFactsSnapshot)
   applyFactGroups(
     newRemoteEvents.map((event) => event.factsGroup),
@@ -72,11 +76,11 @@ export const rebaseEvents = ({
         factsIntersect(pending.factsGroup.modifySet, remote.factsGroup.modifySet),
       ),
     })),
-    validate: ({ rebasedLocalEvents, mutationDefs }) =>
+    validate: ({ rebasedLocalEvents, eventDefs }) =>
       validateFacts({
         factGroups: rebasedLocalEvents.map((event) =>
-          getFactsGroupForMutationArgs({
-            factsCallback: mutationDefs[event.mutation]!.options.facts,
+          getFactsGroupForEventArgs({
+            factsCallback: eventDefs[event.name]!.options.facts,
             args: event.args,
             currentFacts: new Map(),
           }),
@@ -84,15 +88,23 @@ export const rebaseEvents = ({
         initialSnapshot,
       }),
   })
-  const headGlobalId = newRemoteEvents.at(-1)!.id.global
+  const headGlobalId = newRemoteEvents.at(-1)!.seqNum.global
 
   return rebasedLocalEvents.map(
     (event, index) =>
       ({
-        id: EventId.make({ global: headGlobalId + index + 1, local: EventId.localDefault }),
-        parentId: EventId.make({ global: headGlobalId + index, local: EventId.localDefault }),
-        mutation: event.mutation,
+        seqNum: EventSequenceNumber.make({
+          global: headGlobalId + index + 1,
+          client: EventSequenceNumber.clientDefault,
+        }),
+        parentSeqNum: EventSequenceNumber.make({
+          global: headGlobalId + index,
+          client: EventSequenceNumber.clientDefault,
+        }),
+        name: event.name,
         args: event.args,
-      }) satisfies MutationEvent.AnyDecoded,
+        clientId,
+        sessionId,
+      }) satisfies LiveStoreEvent.AnyDecoded,
   )
 }

package/src/sync/next/test/compact-events.calculator.test.ts

@@ -1,21 +1,21 @@
-import { defineMutation } from '@livestore/common/schema'
+import { defineEvent } from '@livestore/common/schema'
 import { Schema } from '@livestore/utils/effect'
 import { describe, expect, it } from 'vitest'
 
 import { compactEvents } from '../compact-events.js'
 import { historyDagFromNodes } from '../history-dag.js'
 import { customSerializer } from './compact-events.test.js'
-import { toEventNodes } from './mutation-fixtures.js'
+import { printEvent, toEventNodes } from './event-fixtures.js'
 
 expect.addSnapshotSerializer(customSerializer)
 
 const compact = (events: any[]) => {
-  const dag = historyDagFromNodes(toEventNodes(events, mutations))
+  const dag = historyDagFromNodes(toEventNodes(events, eventDefs, 'client-id', 'session-id'))
   const compacted = compactEvents(dag)
 
   return Array.from(compacted.dag.nodeEntries())
     .map((_) => _.attributes)
-    .map(({ factsGroup, ...rest }) => ({ ...rest, facts: factsGroup }))
+    .map(printEvent)
     .slice(1)
 }
 
@@ -23,98 +23,98 @@ const facts = {
   multiplyByZero: `multiplyByZero`,
 }
 
-const mutations = {
-  add: defineMutation('add', Schema.Struct({ value: Schema.Number }), 'UPDATE values SET value = value + $value', {}),
-  multiply: defineMutation(
-    'multiply',
-    Schema.Struct({ value: Schema.Number }),
-    'UPDATE values SET value = value * $value',
-    {
-      facts: ({ value }, currentFacts) => ({
-        modify: {
-          set: value === 0 || currentFacts.has(facts.multiplyByZero) ? [facts.multiplyByZero] : [],
-          unset: value === 0 ? [] : [facts.multiplyByZero],
-        },
-      }),
-    },
-  ),
+const eventDefs = {
+  add: defineEvent({
+    name: 'add',
+    schema: Schema.Struct({ value: Schema.Number }),
+  }),
+  multiply: defineEvent({
+    name: 'multiply',
+    schema: Schema.Struct({ value: Schema.Number }),
+    facts: ({ value }, currentFacts) => ({
+      modify: {
+        set: value === 0 || currentFacts.has(facts.multiplyByZero) ? [facts.multiplyByZero] : [],
+        unset: value === 0 ? [] : [facts.multiplyByZero],
+      },
+    }),
+  }),
   // TODO divide by zero
 }
 
 describe('compactEvents calculator', () => {
   it('1 + 1', () => {
     const expected = compact([
-      mutations.add({ value: 1 }), // 0
-      mutations.add({ value: 1 }), // 1
+      eventDefs.add({ value: 1 }), // 0
+      eventDefs.add({ value: 1 }), // 1
     ])
 
     expect(expected).toMatchInlineSnapshot(`
       [
-        { id: 0, parentId: -1, mutation: "add", args: { value: 1 }, facts: "" }
-        { id: 1, parentId: 0, mutation: "add", args: { value: 1 }, facts: "" }
+        { seqNum: "e1", parentSeqNum: "e0", name: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
+        { seqNum: "e2", parentSeqNum: "e1", name: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
       ]
     `)
   })
 
   it('2 * 2', () => {
     const expected = compact([
-      mutations.multiply({ value: 2 }), // 0
-      mutations.multiply({ value: 2 }), // 1
+      eventDefs.multiply({ value: 2 }), // 0
+      eventDefs.multiply({ value: 2 }), // 1
     ])
 
     expect(expected).toMatchInlineSnapshot(`
       [
-        { id: 0, parentId: -1, mutation: "multiply", args: { value: 2 }, facts: "?multiplyByZero -multiplyByZero" }
-        { id: 1, parentId: 0, mutation: "multiply", args: { value: 2 }, facts: "?multiplyByZero -multiplyByZero" }
+        { seqNum: "e1", parentSeqNum: "e0", name: "multiply", args: { value: 2 }, clientId: "client-id", sessionId: "session-id", facts: "?multiplyByZero -multiplyByZero" }
+        { seqNum: "e2", parentSeqNum: "e1", name: "multiply", args: { value: 2 }, clientId: "client-id", sessionId: "session-id", facts: "?multiplyByZero -multiplyByZero" }
       ]
     `)
   })
 
   it('2 * 2 * 0', () => {
     const expected = compact([
-      mutations.multiply({ value: 2 }), // 0
-      mutations.multiply({ value: 2 }), // 1
-      mutations.multiply({ value: 0 }), // 2
+      eventDefs.multiply({ value: 2 }), // 0
+      eventDefs.multiply({ value: 2 }), // 1
+      eventDefs.multiply({ value: 0 }), // 2
     ])
 
     expect(expected).toMatchInlineSnapshot(`
       [
-        { id: 2, parentId: -1, mutation: "multiply", args: { value: 0 }, facts: "+multiplyByZero" }
+        { seqNum: "e3", parentSeqNum: "e0", name: "multiply", args: { value: 0 }, clientId: "client-id", sessionId: "session-id", facts: "+multiplyByZero" }
       ]
     `)
   })
 
   it('2 * 2 * 0 + 1', () => {
     const expected = compact([
-      mutations.multiply({ value: 2 }), // 0
-      mutations.multiply({ value: 2 }), // 1
-      mutations.multiply({ value: 0 }), // 2
-      mutations.add({ value: 1 }), // 3
+      eventDefs.multiply({ value: 2 }), // 0
+      eventDefs.multiply({ value: 2 }), // 1
+      eventDefs.multiply({ value: 0 }), // 2
+      eventDefs.add({ value: 1 }), // 3
     ])
 
     expect(expected).toMatchInlineSnapshot(`
       [
-        { id: 2, parentId: -1, mutation: "multiply", args: { value: 0 }, facts: "+multiplyByZero" }
-        { id: 3, parentId: 2, mutation: "add", args: { value: 1 }, facts: "" }
+        { seqNum: "e3", parentSeqNum: "e0", name: "multiply", args: { value: 0 }, clientId: "client-id", sessionId: "session-id", facts: "+multiplyByZero" }
+        { seqNum: "e4", parentSeqNum: "e3", name: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
       ]
     `)
   })
 
   it('1 + 2 * 0 * 2 + 1', () => {
     const expected = compact([
-      mutations.add({ value: 1 }), // 0
-      mutations.multiply({ value: 2 }), // 1
-      mutations.multiply({ value: 0 }), // 2
-      mutations.multiply({ value: 2 }), // 3
-      mutations.add({ value: 1 }), // 4
+      eventDefs.add({ value: 1 }), // 0
+      eventDefs.multiply({ value: 2 }), // 1
+      eventDefs.multiply({ value: 0 }), // 2
+      eventDefs.multiply({ value: 2 }), // 3
+      eventDefs.add({ value: 1 }), // 4
     ])
 
     expect(expected).toMatchInlineSnapshot(`
       [
-        { id: 0, parentId: -1, mutation: "add", args: { value: 1 }, facts: "" }
-        { id: 2, parentId: 0, mutation: "multiply", args: { value: 0 }, facts: "+multiplyByZero" }
-        { id: 3, parentId: 2, mutation: "multiply", args: { value: 2 }, facts: "?multiplyByZero +multiplyByZero -multiplyByZero" }
-        { id: 4, parentId: 3, mutation: "add", args: { value: 1 }, facts: "" }
+        { seqNum: "e1", parentSeqNum: "e0", name: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
+        { seqNum: "e3", parentSeqNum: "e1", name: "multiply", args: { value: 0 }, clientId: "client-id", sessionId: "session-id", facts: "+multiplyByZero" }
+        { seqNum: "e4", parentSeqNum: "e3", name: "multiply", args: { value: 2 }, clientId: "client-id", sessionId: "session-id", facts: "?multiplyByZero +multiplyByZero -multiplyByZero" }
+        { seqNum: "e5", parentSeqNum: "e4", name: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
       ]
     `)
   })