@livestore/common 0.3.0-dev.5 → 0.3.0-dev.50

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

@@ -1,6 +1,6 @@
+import { EventSequenceNumber } from '../../schema/mod.js'
 import { replacesFacts } from './facts.js'
 import { graphologyDag } from './graphology_.js'
-import { eventIdToString } from './history-dag.js'
 import type { HistoryDag } from './history-dag-common.js'
 import { emptyHistoryDag } from './history-dag-common.js'
 
@@ -17,25 +17,25 @@ export const compactEvents = (inputDag: HistoryDag): { dag: HistoryDag; compacte
   const dag = inputDag.copy()
   const compactedEventCount = 0
 
-  const orderedEventIdStrs = graphologyDag.topologicalSort(dag).reverse()
+  const orderedEventSequenceNumberStrs = graphologyDag.topologicalSort(dag).reverse()
 
   // drop root
-  orderedEventIdStrs.pop()
+  orderedEventSequenceNumberStrs.pop()
 
-  for (const eventIdStr of orderedEventIdStrs) {
-    if (dag.hasNode(eventIdStr) === false) {
+  for (const eventNumStr of orderedEventSequenceNumberStrs) {
+    if (dag.hasNode(eventNumStr) === false) {
       continue
     }
 
-    const subDagsForEvent = Array.from(makeSubDagsForEvent(dag, eventIdStr))
+    const subDagsForEvent = Array.from(makeSubDagsForEvent(dag, eventNumStr))
     for (const subDag of subDagsForEvent) {
       let shouldRetry = true
       while (shouldRetry) {
-        const subDagsInHistory = findSubDagsInHistory(dag, subDag, eventIdStr)
+        const subDagsInHistory = findSubDagsInHistory(dag, subDag, eventNumStr)
 
         // console.debug(
         //   'subDagsInHistory',
-        //   eventIdStr,
+        //   eventNumStr,
         //   'target',
         //   subDag.nodes(),
         //   'found',
@@ -65,9 +65,9 @@ export const compactEvents = (inputDag: HistoryDag): { dag: HistoryDag; compacte
   return { dag, compactedEventCount }
 }
 
-function* makeSubDagsForEvent(inputDag: HistoryDag, eventIdStr: string): Generator<HistoryDag> {
-  /** Map from eventIdStr to array of eventIdStrs that are dependencies */
-  let nextIterationEls: Map<string, string[]> = new Map([[eventIdStr, []]])
+function* makeSubDagsForEvent(inputDag: HistoryDag, eventNumStr: string): Generator<HistoryDag> {
+  /** Map from eventNumStr to array of eventNumStrs that are dependencies */
+  let nextIterationEls: Map<string, string[]> = new Map([[eventNumStr, []]])
   let previousDag: HistoryDag | undefined
 
   while (nextIterationEls.size > 0) {
@@ -77,19 +77,22 @@ function* makeSubDagsForEvent(inputDag: HistoryDag, eventIdStr: string): Generat
     const currentIterationEls = new Map(nextIterationEls)
     nextIterationEls = new Map()
 
-    for (const [currentEventIdStr, edgeTargetIdStrs] of currentIterationEls) {
-      const node = inputDag.getNodeAttributes(currentEventIdStr)
-      if (subDag.hasNode(currentEventIdStr) === false) {
-        subDag.addNode(currentEventIdStr, { ...node })
+    for (const [currentEventSequenceNumberStr, edgeTargetIdStrs] of currentIterationEls) {
+      const node = inputDag.getNodeAttributes(currentEventSequenceNumberStr)
+      if (subDag.hasNode(currentEventSequenceNumberStr) === false) {
+        subDag.addNode(currentEventSequenceNumberStr, { ...node })
       }
       for (const edgeTargetIdStr of edgeTargetIdStrs) {
-        subDag.addEdge(currentEventIdStr, edgeTargetIdStr, { type: 'facts' })
+        subDag.addEdge(currentEventSequenceNumberStr, edgeTargetIdStr, { type: 'facts' })
       }
 
-      for (const depEdge of inputDag.outboundEdgeEntries(currentEventIdStr)) {
+      for (const depEdge of inputDag.outboundEdgeEntries(currentEventSequenceNumberStr)) {
         if (depEdge.attributes.type === 'facts') {
-          const depEventIdStr = depEdge.target
-          nextIterationEls.set(depEventIdStr, [...(nextIterationEls.get(depEventIdStr) ?? []), currentEventIdStr])
+          const depEventSequenceNumberStr = depEdge.target
+          nextIterationEls.set(depEventSequenceNumberStr, [
+            ...(nextIterationEls.get(depEventSequenceNumberStr) ?? []),
+            currentEventSequenceNumberStr,
+          ])
         }
       }
     }
@@ -102,23 +105,23 @@ function* makeSubDagsForEvent(inputDag: HistoryDag, eventIdStr: string): Generat
 }
 
 /**
- * Iterates over all events from root to `upToExclEventIdStr`
+ * Iterates over all events from root to `upToExclEventSequenceNumberStr`
  * and collects all valid sub dags that are replaced by `targetSubDag`.
  */
 const findSubDagsInHistory = (
   inputDag: HistoryDag,
   targetSubDag: HistoryDag,
-  upToExclEventIdStr: string,
+  upToExclEventSequenceNumberStr: string,
 ): { subDags: HistoryDag[]; allOutsideDependencies: string[][] } => {
   const subDags: HistoryDag[] = []
   const allOutsideDependencies: string[][] = []
 
-  for (const eventIdStr of graphologyDag.topologicalSort(inputDag)) {
-    if (eventIdStr === upToExclEventIdStr) {
+  for (const eventNumStr of graphologyDag.topologicalSort(inputDag)) {
+    if (eventNumStr === upToExclEventSequenceNumberStr) {
       break
     }
 
-    for (const subDag of makeSubDagsForEvent(inputDag, eventIdStr)) {
+    for (const subDag of makeSubDagsForEvent(inputDag, eventNumStr)) {
       // console.debug('findSubDagsInHistory', 'target', targetSubDag.nodes(), 'subDag', subDag.nodes())
       if (subDag.size < targetSubDag.size) {
         continue
@@ -152,9 +155,9 @@ const outsideDependenciesForDag = (subDag: HistoryDag, inputDag: HistoryDag) =>
   for (const nodeIdStr of subDag.nodes()) {
     for (const edgeEntry of inputDag.outboundEdgeEntries(nodeIdStr)) {
       if (edgeEntry.attributes.type === 'facts') {
-        const depEventIdStr = edgeEntry.target
-        if (subDag.hasNode(depEventIdStr) === false) {
-          outsideDependencies.push(depEventIdStr)
+        const depEventSequenceNumberStr = edgeEntry.target
+        if (subDag.hasNode(depEventSequenceNumberStr) === false) {
+          outsideDependencies.push(depEventSequenceNumberStr)
         }
       }
     }
@@ -201,19 +204,19 @@ const dagReplacesDag = (dagA: HistoryDag, dagB: HistoryDag): boolean => {
   return true
 }
 
-const removeEvent = (dag: HistoryDag, eventIdStr: string) => {
-  // console.debug('removing event', eventIdStr)
-  const event = dag.getNodeAttributes(eventIdStr)
-  const parentIdStr = eventIdToString(event.parentId)
-  const childEdges = dag.outboundEdgeEntries(eventIdStr)
+const removeEvent = (dag: HistoryDag, eventNumStr: string) => {
+  // console.debug('removing event', eventNumStr)
+  const event = dag.getNodeAttributes(eventNumStr)
+  const parentSeqNumStr = EventSequenceNumber.toString(event.parentSeqNum)
+  const childEdges = dag.outboundEdgeEntries(eventNumStr)
 
   for (const childEdge of childEdges) {
     if (childEdge.attributes.type === 'parent') {
       const childEvent = dag.getNodeAttributes(childEdge.target)
-      childEvent.parentId = { ...event.parentId }
-      dag.addEdge(parentIdStr, eventIdToString(childEvent.id), { type: 'parent' })
+      childEvent.parentSeqNum = { ...event.parentSeqNum }
+      dag.addEdge(parentSeqNumStr, EventSequenceNumber.toString(childEvent.seqNum), { type: 'parent' })
     }
   }
 
-  dag.dropNode(eventIdStr)
+  dag.dropNode(eventNumStr)
 }

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.PartialAny[]
-    mutationDefs: Record<string, MutationDef.Any>
+    rebasedLocalEvents: LiveStoreEvent.PartialAnyDecoded[]
+    eventDefs: Record<string, EventDef.Any>
   }) => FactValidationResult
 }
 
 export type RebaseOutput = {
-  rebasedLocalEvents: MutationEvent.PartialAny[]
+  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,
   )
 }