@livestore/common 0.0.0-snapshot-2b8a9de3ec1a701aca891ebc2c98eb328274ae9e → 0.0.0-snapshot-2c861249e50661661613204300b1fc0d902c2e46

package/src/sync/ClientSessionSyncProcessor.ts

@@ -1,3 +1,4 @@
+/// <reference lib="dom" />
 import { LS_DEV, shouldNeverHappen, TRACE_VERBOSE } from '@livestore/utils'
 import type { Runtime, Scope } from '@livestore/utils/effect'
 import { BucketQueue, Effect, FiberHandle, Queue, Schema, Stream, Subscribable } from '@livestore/utils/effect'
@@ -5,16 +6,17 @@ import * as otel from '@opentelemetry/api'
 
 import type { ClientSession, UnexpectedError } from '../adapter-types.js'
 import * as EventId from '../schema/EventId.js'
-import { getMutationDef, type LiveStoreSchema } from '../schema/mod.js'
-import * as MutationEvent from '../schema/MutationEvent.js'
+import * as LiveStoreEvent from '../schema/LiveStoreEvent.js'
+import { getEventDef, LEADER_MERGE_COUNTER_TABLE, type LiveStoreSchema } from '../schema/mod.js'
+import { sql } from '../util.js'
 import * as SyncState from './syncstate.js'
 
 /**
  * Rebase behaviour:
- * - We continously pull mutations from the leader and apply them to the local store.
+ * - We continously pull events from the leader and apply them to the local store.
  * - If there was a race condition (i.e. the leader and client session have both advacned),
- *   we'll need to rebase the local pending mutations on top of the leader's head.
- * - The goal is to never block the UI, so we'll interrupt rebasing if a new mutations is pushed by the client session.
+ *   we'll need to rebase the local pending events on top of the leader's head.
+ * - The goal is to never block the UI, so we'll interrupt rebasing if a new events is pushed by the client session.
  * - We also want to avoid "backwards-jumping" in the UI, so we'll transactionally apply a read model changes during a rebase.
  * - We might need to make the rebase behaviour configurable e.g. to let users manually trigger a rebase
  *
@@ -24,7 +26,7 @@ export const makeClientSessionSyncProcessor = ({
   schema,
   clientSession,
   runtime,
-  applyMutation,
+  applyEvent,
   rollback,
   refreshTables,
   span,
@@ -34,12 +36,12 @@ export const makeClientSessionSyncProcessor = ({
   schema: LiveStoreSchema
   clientSession: ClientSession
   runtime: Runtime.Runtime<Scope.Scope>
-  applyMutation: (
-    mutationEventDecoded: MutationEvent.PartialAnyDecoded,
+  applyEvent: (
+    eventDecoded: LiveStoreEvent.PartialAnyDecoded,
     options: { otelContext: otel.Context; withChangeset: boolean },
   ) => {
     writeTables: Set<string>
-    sessionChangeset: Uint8Array | undefined
+    sessionChangeset: { _tag: 'sessionChangeset'; data: Uint8Array; debug: any } | { _tag: 'no-op' } | { _tag: 'unset' }
   }
   rollback: (changeset: Uint8Array) => void
   refreshTables: (tables: Set<string>) => void
@@ -53,36 +55,37 @@ export const makeClientSessionSyncProcessor = ({
    */
   confirmUnsavedChanges: boolean
 }): ClientSessionSyncProcessor => {
-  const mutationEventSchema = MutationEvent.makeMutationEventSchemaMemo(schema)
+  const eventSchema = LiveStoreEvent.makeEventDefSchemaMemo(schema)
 
   const syncStateRef = {
+    // The initial state is identical to the leader's initial state
     current: new SyncState.SyncState({
       localHead: clientSession.leaderThread.initialState.leaderHead,
       upstreamHead: clientSession.leaderThread.initialState.leaderHead,
+      // Given we're starting with the leader's snapshot, we don't have any pending events intially
       pending: [],
-      // TODO init rollbackTail from leader to be ready for backend rebasing
-      rollbackTail: [],
     }),
   }
 
   const syncStateUpdateQueue = Queue.unbounded<SyncState.SyncState>().pipe(Effect.runSync)
-  const isClientEvent = (mutationEventEncoded: MutationEvent.EncodedWithMeta) =>
-    getMutationDef(schema, mutationEventEncoded.mutation).options.clientOnly
+  const isClientEvent = (eventEncoded: LiveStoreEvent.EncodedWithMeta) =>
+    getEventDef(schema, eventEncoded.name).eventDef.options.clientOnly
 
   /** We're queuing push requests to reduce the number of messages sent to the leader by batching them */
-  const leaderPushQueue = BucketQueue.make<MutationEvent.EncodedWithMeta>().pipe(Effect.runSync)
+  const leaderPushQueue = BucketQueue.make<LiveStoreEvent.EncodedWithMeta>().pipe(Effect.runSync)
 
   const push: ClientSessionSyncProcessor['push'] = (batch, { otelContext }) => {
     // TODO validate batch
 
     let baseEventId = syncStateRef.current.localHead
-    const encodedMutationEvents = batch.map((mutationEvent) => {
-      const mutationDef = getMutationDef(schema, mutationEvent.mutation)
-      const nextIdPair = EventId.nextPair(baseEventId, mutationDef.options.clientOnly)
+    const encodedEventDefs = batch.map(({ name, args }) => {
+      const eventDef = getEventDef(schema, name)
+      const nextIdPair = EventId.nextPair(baseEventId, eventDef.eventDef.options.clientOnly)
       baseEventId = nextIdPair.id
-      return new MutationEvent.EncodedWithMeta(
-        Schema.encodeUnknownSync(mutationEventSchema)({
-          ...mutationEvent,
+      return new LiveStoreEvent.EncodedWithMeta(
+        Schema.encodeUnknownSync(eventSchema)({
+          name,
+          args,
           ...nextIdPair,
           clientId: clientSession.clientId,
           sessionId: clientSession.sessionId,
@@ -92,9 +95,9 @@ export const makeClientSessionSyncProcessor = ({
 
     const mergeResult = SyncState.merge({
       syncState: syncStateRef.current,
-      payload: { _tag: 'local-push', newEvents: encodedMutationEvents },
+      payload: { _tag: 'local-push', newEvents: encodedEventDefs },
       isClientEvent,
-      isEqualEvent: MutationEvent.isEqualEncoded,
+      isEqualEvent: LiveStoreEvent.isEqualEncoded,
     })
 
     if (mergeResult._tag === 'unexpected-error') {
@@ -102,7 +105,7 @@ export const makeClientSessionSyncProcessor = ({
     }
 
     span.addEvent('local-push', {
-      batchSize: encodedMutationEvents.length,
+      batchSize: encodedEventDefs.length,
       mergeResult: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
     })
 
@@ -114,18 +117,18 @@ export const makeClientSessionSyncProcessor = ({
     syncStateUpdateQueue.offer(mergeResult.newSyncState).pipe(Effect.runSync)
 
     const writeTables = new Set<string>()
-    for (const mutationEvent of mergeResult.newEvents) {
+    for (const event of mergeResult.newEvents) {
       // TODO avoid encoding and decoding here again
-      const decodedMutationEvent = Schema.decodeSync(mutationEventSchema)(mutationEvent)
-      const res = applyMutation(decodedMutationEvent, { otelContext, withChangeset: true })
+      const decodedEventDef = Schema.decodeSync(eventSchema)(event)
+      const res = applyEvent(decodedEventDef, { otelContext, withChangeset: true })
       for (const table of res.writeTables) {
         writeTables.add(table)
       }
-      mutationEvent.meta.sessionChangeset = res.sessionChangeset
+      event.meta.sessionChangeset = res.sessionChangeset
     }
 
-    // console.debug('pushToLeader', encodedMutationEvents.length, ...encodedMutationEvents.map((_) => _.toJSON()))
-    BucketQueue.offerAll(leaderPushQueue, encodedMutationEvents).pipe(Effect.runSync)
+    // console.debug('pushToLeader', encodedEventDefs.length, ...encodedEventDefs.map((_) => _.toJSON()))
+    BucketQueue.offerAll(leaderPushQueue, encodedEventDefs).pipe(Effect.runSync)
 
     return { writeTables }
   }
@@ -158,7 +161,7 @@ export const makeClientSessionSyncProcessor = ({
 
     const backgroundLeaderPushing = Effect.gen(function* () {
       const batch = yield* BucketQueue.takeBetween(leaderPushQueue, 1, params.leaderPushBatchSize)
-      yield* clientSession.leaderThread.mutations.push(batch).pipe(
+      yield* clientSession.leaderThread.events.push(batch).pipe(
         Effect.catchTag('LeaderAheadError', () => {
           debugInfo.rejectCount++
           return BucketQueue.clear(leaderPushQueue)
@@ -168,13 +171,21 @@ export const makeClientSessionSyncProcessor = ({
 
     yield* FiberHandle.run(leaderPushingFiberHandle, backgroundLeaderPushing)
 
+    const getMergeCounter = () =>
+      clientSession.sqliteDb.select<{ mergeCounter: number }>(
+        sql`SELECT mergeCounter FROM ${LEADER_MERGE_COUNTER_TABLE} WHERE id = 0`,
+      )[0]?.mergeCounter ?? 0
+
     // NOTE We need to lazily call `.pull` as we want the cursor to be updated
     yield* Stream.suspend(() =>
-      clientSession.leaderThread.mutations.pull({ cursor: syncStateRef.current.localHead }),
+      clientSession.leaderThread.events.pull({
+        cursor: { mergeCounter: getMergeCounter(), eventId: syncStateRef.current.localHead },
+      }),
     ).pipe(
-      Stream.tap(({ payload, remaining }) =>
+      Stream.tap(({ payload, mergeCounter: leaderMergeCounter }) =>
         Effect.gen(function* () {
-          // console.log('pulled payload from leader', { payload, remaining })
+          // yield* Effect.logDebug('ClientSessionSyncProcessor:pull', payload)
+
           if (clientSession.devtools.enabled) {
             yield* clientSession.devtools.pullLatch.await
           }
@@ -183,7 +194,7 @@ export const makeClientSessionSyncProcessor = ({
             syncState: syncStateRef.current,
             payload,
             isClientEvent,
-            isEqualEvent: MutationEvent.isEqualEncoded,
+            isEqualEvent: LiveStoreEvent.isEqualEncoded,
           })
 
           if (mergeResult._tag === 'unexpected-error') {
@@ -196,13 +207,13 @@ export const makeClientSessionSyncProcessor = ({
           syncStateUpdateQueue.offer(mergeResult.newSyncState).pipe(Effect.runSync)
 
           if (mergeResult._tag === 'rebase') {
-            span.addEvent('pull:rebase', {
+            span.addEvent('merge:pull:rebase', {
               payloadTag: payload._tag,
               payload: TRACE_VERBOSE ? JSON.stringify(payload) : undefined,
               newEventsCount: mergeResult.newEvents.length,
-              rollbackCount: mergeResult.eventsToRollback.length,
+              rollbackCount: mergeResult.rollbackEvents.length,
               res: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
-              remaining,
+              leaderMergeCounter,
             })
 
             debugInfo.rebaseCount++
@@ -216,28 +227,29 @@ export const makeClientSessionSyncProcessor = ({
 
             if (LS_DEV) {
               Effect.logDebug(
-                'pull:rebase: rollback',
-                mergeResult.eventsToRollback.length,
-                ...mergeResult.eventsToRollback.slice(0, 10).map((_) => _.toJSON()),
+                'merge:pull:rebase: rollback',
+                mergeResult.rollbackEvents.length,
+                ...mergeResult.rollbackEvents.slice(0, 10).map((_) => _.toJSON()),
+                { leaderMergeCounter },
               ).pipe(Effect.provide(runtime), Effect.runSync)
             }
 
-            for (let i = mergeResult.eventsToRollback.length - 1; i >= 0; i--) {
-              const event = mergeResult.eventsToRollback[i]!
-              if (event.meta.sessionChangeset) {
-                rollback(event.meta.sessionChangeset)
-                event.meta.sessionChangeset = undefined
+            for (let i = mergeResult.rollbackEvents.length - 1; i >= 0; i--) {
+              const event = mergeResult.rollbackEvents[i]!
+              if (event.meta.sessionChangeset._tag !== 'no-op' && event.meta.sessionChangeset._tag !== 'unset') {
+                rollback(event.meta.sessionChangeset.data)
+                event.meta.sessionChangeset = { _tag: 'unset' }
               }
             }
 
             yield* BucketQueue.offerAll(leaderPushQueue, mergeResult.newSyncState.pending)
           } else {
-            span.addEvent('pull:advance', {
+            span.addEvent('merge:pull:advance', {
               payloadTag: payload._tag,
               payload: TRACE_VERBOSE ? JSON.stringify(payload) : undefined,
               newEventsCount: mergeResult.newEvents.length,
               res: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
-              remaining,
+              leaderMergeCounter,
             })
 
             debugInfo.advanceCount++
@@ -246,14 +258,15 @@ export const makeClientSessionSyncProcessor = ({
           if (mergeResult.newEvents.length === 0) return
 
           const writeTables = new Set<string>()
-          for (const mutationEvent of mergeResult.newEvents) {
-            const decodedMutationEvent = Schema.decodeSync(mutationEventSchema)(mutationEvent)
-            const res = applyMutation(decodedMutationEvent, { otelContext, withChangeset: true })
+          for (const event of mergeResult.newEvents) {
+            // TODO apply changeset if available (will require tracking of write tables as well)
+            const decodedEventDef = Schema.decodeSync(eventSchema)(event)
+            const res = applyEvent(decodedEventDef, { otelContext, withChangeset: true })
             for (const table of res.writeTables) {
               writeTables.add(table)
             }
 
-            mutationEvent.meta.sessionChangeset = res.sessionChangeset
+            event.meta.sessionChangeset = res.sessionChangeset
           }
 
           refreshTables(writeTables)
@@ -302,7 +315,7 @@ export const makeClientSessionSyncProcessor = ({
 
 export interface ClientSessionSyncProcessor {
   push: (
-    batch: ReadonlyArray<MutationEvent.PartialAnyDecoded>,
+    batch: ReadonlyArray<LiveStoreEvent.PartialAnyDecoded>,
     options: { otelContext: otel.Context },
   ) => {
     writeTables: Set<string>

package/src/sync/next/facts.ts

@@ -1,20 +1,20 @@
 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 EventId from '../../schema/EventId.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 => {
+): EventDefFactsSnapshot => {
   const facts = new Map<string, any>()
 
   for (const event of events) {
@@ -31,7 +31,7 @@ export const factsSnapshotForEvents = (
 export const factsSnapshotForDag = (
   dag: HistoryDag,
   endEventId: EventId.EventId | undefined,
-): MutationEventFactsSnapshot => {
+): EventDefFactsSnapshot => {
   const facts = new Map<string, any>()
 
   const orderedEventIdStrs = graphologyDag.topologicalSort(dag)
@@ -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') {

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

@@ -1,5 +1,5 @@
+import type { EventDefFactsGroup } from '../../schema/EventDef.js'
 import * as EventId from '../../schema/EventId.js'
-import type { MutationEventFactsGroup } from '../../schema/mutations.js'
 import { graphology } from './graphology_.js'
 
 export const connectionTypeOptions = ['parent', 'facts'] as const
@@ -25,10 +25,10 @@ export const rootParentId = EventId.make({ global: EventId.ROOT.global - 1, clie
 export type HistoryDagNode = {
   id: EventId.EventId
   parentId: EventId.EventId
-  mutation: string
+  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
@@ -38,7 +38,7 @@ export const rootEventNode: HistoryDagNode = {
   id: EventId.ROOT,
   parentId: rootParentId,
   // unused below
-  mutation: '__Root__',
+  name: '__Root__',
   args: {},
   factsGroup: { modifySet: new Map(), modifyUnset: new Map(), depRequire: new Map(), depRead: new Map() },
   clientId: 'root',

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

@@ -14,7 +14,7 @@ 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)}`,
       )
     }
   }

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

@@ -1,11 +1,11 @@
+import type { EventDef, EventDefFactsSnapshot } from '../../schema/EventDef.js'
 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 * 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
@@ -49,10 +49,10 @@ export const rebaseEvents = ({
   pendingLocalEvents: HistoryDagNode[]
   newRemoteEvents: HistoryDagNode[]
   rebaseFn: RebaseFn
-  currentFactsSnapshot: MutationEventFactsSnapshot
+  currentFactsSnapshot: EventDefFactsSnapshot
   clientId: string
   sessionId: string
-}): ReadonlyArray<MutationEvent.AnyDecoded> => {
+}): ReadonlyArray<LiveStoreEvent.AnyDecoded> => {
   const initialSnapshot = new Map(currentFactsSnapshot)
   applyFactGroups(
     newRemoteEvents.map((event) => event.factsGroup),
@@ -76,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(),
           }),
@@ -95,10 +95,10 @@ export const rebaseEvents = ({
       ({
         id: EventId.make({ global: headGlobalId + index + 1, client: EventId.clientDefault }),
         parentId: EventId.make({ global: headGlobalId + index, client: EventId.clientDefault }),
-        mutation: event.mutation,
+        name: event.name,
         args: event.args,
         clientId,
         sessionId,
-      }) satisfies MutationEvent.AnyDecoded,
+      }) satisfies LiveStoreEvent.AnyDecoded,
   )
 }