@livestore/common 0.3.0-dev.8 → 0.3.0

package/src/sync/ClientSessionSyncProcessor.ts

@@ -1,186 +1,284 @@
+/// <reference lib="dom" />
 import { LS_DEV, shouldNeverHappen, TRACE_VERBOSE } from '@livestore/utils'
-import type { Scope } from '@livestore/utils/effect'
-import { Effect, Schema, Stream } from '@livestore/utils/effect'
+import type { Runtime, Scope } from '@livestore/utils/effect'
+import { BucketQueue, Effect, FiberHandle, Queue, Schema, Stream, Subscribable } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 
-import type { ClientSessionLeaderThreadProxy, UnexpectedError } from '../adapter-types.js'
-import * as EventId from '../schema/EventId.js'
-import { type LiveStoreSchema } from '../schema/mod.js'
-import * as MutationEvent from '../schema/MutationEvent.js'
-import type { SyncState } from './syncstate.js'
-import { updateSyncState } from './syncstate.js'
+import type { ClientSession, UnexpectedError } from '../adapter-types.js'
+import * as EventSequenceNumber from '../schema/EventSequenceNumber.js'
+import * as LiveStoreEvent from '../schema/LiveStoreEvent.js'
+import { getEventDef, type LiveStoreSchema, SystemTables } 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 also want to avoid "backwards-jumping" in the UI, so we'll transactionally apply a read model changes during a rebase.
+ *   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 state changes during a rebase.
  * - We might need to make the rebase behaviour configurable e.g. to let users manually trigger a rebase
+ *
+ * Longer term we should evalutate whether we can unify the ClientSessionSyncProcessor with the LeaderSyncProcessor.
  */
 export const makeClientSessionSyncProcessor = ({
   schema,
-  initialLeaderHead,
-  pushToLeader,
-  pullFromLeader,
-  applyMutation,
+  clientSession,
+  runtime,
+  materializeEvent,
   rollback,
   refreshTables,
   span,
+  params,
+  confirmUnsavedChanges,
 }: {
   schema: LiveStoreSchema
-  initialLeaderHead: EventId.EventId
-  pushToLeader: (batch: ReadonlyArray<MutationEvent.AnyEncoded>) => void
-  pullFromLeader: ClientSessionLeaderThreadProxy['mutations']['pull']
-  applyMutation: (
-    mutationEventDecoded: MutationEvent.PartialAnyDecoded,
+  clientSession: ClientSession
+  runtime: Runtime.Runtime<Scope.Scope>
+  materializeEvent: (
+    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
   span: otel.Span
+  params: {
+    leaderPushBatchSize: number
+  }
+  /**
+   * Currently only used in the web adapter:
+   * If true, registers a beforeunload event listener to confirm unsaved changes.
+   */
+  confirmUnsavedChanges: boolean
 }): ClientSessionSyncProcessor => {
-  const mutationEventSchema = MutationEvent.makeMutationEventSchemaMemo(schema)
+  const eventSchema = LiveStoreEvent.makeEventDefSchemaMemo(schema)
 
   const syncStateRef = {
-    current: {
-      localHead: initialLeaderHead,
-      upstreamHead: initialLeaderHead,
+    // 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: [],
-    } as SyncState,
+    }),
   }
 
-  const isLocalEvent = (mutationEventEncoded: MutationEvent.EncodedWithMeta) => {
-    const mutationDef = schema.mutations.get(mutationEventEncoded.mutation)!
-    return mutationDef.options.localOnly
-  }
+  const syncStateUpdateQueue = Queue.unbounded<SyncState.SyncState>().pipe(Effect.runSync)
+  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<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 = schema.mutations.get(mutationEvent.mutation)!
-      const nextIdPair = EventId.nextPair(baseEventId, mutationDef.options.localOnly)
-      baseEventId = nextIdPair.id
-      return new MutationEvent.EncodedWithMeta(
-        Schema.encodeUnknownSync(mutationEventSchema)({ ...mutationEvent, ...nextIdPair }),
+    let baseEventSequenceNumber = syncStateRef.current.localHead
+    const encodedEventDefs = batch.map(({ name, args }) => {
+      const eventDef = getEventDef(schema, name)
+      const nextNumPair = EventSequenceNumber.nextPair(baseEventSequenceNumber, eventDef.eventDef.options.clientOnly)
+      baseEventSequenceNumber = nextNumPair.seqNum
+      return new LiveStoreEvent.EncodedWithMeta(
+        Schema.encodeUnknownSync(eventSchema)({
+          name,
+          args,
+          ...nextNumPair,
+          clientId: clientSession.clientId,
+          sessionId: clientSession.sessionId,
+        }),
       )
     })
 
-    const updateResult = updateSyncState({
+    const mergeResult = SyncState.merge({
       syncState: syncStateRef.current,
-      payload: { _tag: 'local-push', newEvents: encodedMutationEvents },
-      isLocalEvent,
-      isEqualEvent: MutationEvent.isEqualEncoded,
+      payload: { _tag: 'local-push', newEvents: encodedEventDefs },
+      isClientEvent,
+      isEqualEvent: LiveStoreEvent.isEqualEncoded,
     })
 
+    if (mergeResult._tag === 'unexpected-error') {
+      return shouldNeverHappen('Unexpected error in client-session-sync-processor', mergeResult.cause)
+    }
+
     span.addEvent('local-push', {
-      batchSize: encodedMutationEvents.length,
-      updateResult: TRACE_VERBOSE ? JSON.stringify(updateResult) : undefined,
+      batchSize: encodedEventDefs.length,
+      mergeResult: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
     })
 
-    if (updateResult._tag !== 'advance') {
-      return shouldNeverHappen(`Expected advance, got ${updateResult._tag}`)
+    if (mergeResult._tag !== 'advance') {
+      return shouldNeverHappen(`Expected advance, got ${mergeResult._tag}`)
     }
 
-    syncStateRef.current = updateResult.newSyncState
+    syncStateRef.current = mergeResult.newSyncState
+    syncStateUpdateQueue.offer(mergeResult.newSyncState).pipe(Effect.runSync)
 
     const writeTables = new Set<string>()
-    for (const mutationEvent of updateResult.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 = materializeEvent(decodedEventDef, { otelContext, withChangeset: true })
       for (const table of res.writeTables) {
         writeTables.add(table)
       }
-      mutationEvent.meta.sessionChangeset = res.sessionChangeset
+      event.meta.sessionChangeset = res.sessionChangeset
     }
 
-    pushToLeader(encodedMutationEvents)
+    // console.debug('pushToLeader', encodedEventDefs.length, ...encodedEventDefs.map((_) => _.toJSON()))
+    BucketQueue.offerAll(leaderPushQueue, encodedEventDefs).pipe(Effect.runSync)
 
     return { writeTables }
   }
 
+  const debugInfo = {
+    rebaseCount: 0,
+    advanceCount: 0,
+    rejectCount: 0,
+  }
+
   const otelContext = otel.trace.setSpan(otel.context.active(), span)
 
   const boot: ClientSessionSyncProcessor['boot'] = Effect.gen(function* () {
-    yield* pullFromLeader.pipe(
-      Stream.tap(({ payload, remaining }) =>
+    // eslint-disable-next-line unicorn/prefer-global-this
+    if (confirmUnsavedChanges && typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
+      const onBeforeUnload = (event: BeforeUnloadEvent) => {
+        if (syncStateRef.current.pending.length > 0) {
+          // Trigger the default browser dialog
+          event.preventDefault()
+        }
+      }
+
+      yield* Effect.acquireRelease(
+        Effect.sync(() => window.addEventListener('beforeunload', onBeforeUnload)),
+        () => Effect.sync(() => window.removeEventListener('beforeunload', onBeforeUnload)),
+      )
+    }
+
+    const leaderPushingFiberHandle = yield* FiberHandle.make()
+
+    const backgroundLeaderPushing = Effect.gen(function* () {
+      const batch = yield* BucketQueue.takeBetween(leaderPushQueue, 1, params.leaderPushBatchSize)
+      yield* clientSession.leaderThread.events.push(batch).pipe(
+        Effect.catchTag('LeaderAheadError', () => {
+          debugInfo.rejectCount++
+          return BucketQueue.clear(leaderPushQueue)
+        }),
+      )
+    }).pipe(Effect.forever, Effect.interruptible, Effect.tapCauseLogPretty)
+
+    yield* FiberHandle.run(leaderPushingFiberHandle, backgroundLeaderPushing)
+
+    const getMergeCounter = () =>
+      clientSession.sqliteDb.select<{ mergeCounter: number }>(
+        sql`SELECT mergeCounter FROM ${SystemTables.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.events.pull({
+        cursor: { mergeCounter: getMergeCounter(), eventNum: syncStateRef.current.localHead },
+      }),
+    ).pipe(
+      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
+          }
 
-          const updateResult = updateSyncState({
+          const mergeResult = SyncState.merge({
             syncState: syncStateRef.current,
             payload,
-            isLocalEvent,
-            isEqualEvent: MutationEvent.isEqualEncoded,
+            isClientEvent,
+            isEqualEvent: LiveStoreEvent.isEqualEncoded,
           })
 
-          if (updateResult._tag === 'reject') {
-            debugger
-            throw new Error('TODO: implement reject in client-session-sync-queue for pull')
+          if (mergeResult._tag === 'unexpected-error') {
+            return yield* Effect.fail(mergeResult.cause)
+          } else if (mergeResult._tag === 'reject') {
+            return shouldNeverHappen('Unexpected reject in client-session-sync-processor', mergeResult)
           }
 
-          syncStateRef.current = updateResult.newSyncState
+          syncStateRef.current = mergeResult.newSyncState
+          syncStateUpdateQueue.offer(mergeResult.newSyncState).pipe(Effect.runSync)
 
-          if (updateResult._tag === 'rebase') {
-            span.addEvent('pull:rebase', {
+          if (mergeResult._tag === 'rebase') {
+            span.addEvent('merge:pull:rebase', {
               payloadTag: payload._tag,
               payload: TRACE_VERBOSE ? JSON.stringify(payload) : undefined,
-              newEventsCount: updateResult.newEvents.length,
-              rollbackCount: updateResult.eventsToRollback.length,
-              res: TRACE_VERBOSE ? JSON.stringify(updateResult) : undefined,
-              remaining,
+              newEventsCount: mergeResult.newEvents.length,
+              rollbackCount: mergeResult.rollbackEvents.length,
+              res: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
+              leaderMergeCounter,
             })
+
+            debugInfo.rebaseCount++
+
+            yield* FiberHandle.clear(leaderPushingFiberHandle)
+
+            // Reset the leader push queue since we're rebasing and will push again
+            yield* BucketQueue.clear(leaderPushQueue)
+
+            yield* FiberHandle.run(leaderPushingFiberHandle, backgroundLeaderPushing)
+
             if (LS_DEV) {
-              console.debug(
-                'pull:rebase: rollback',
-                updateResult.eventsToRollback.length,
-                ...updateResult.eventsToRollback.map((_) => _.toJSON()),
-              )
+              Effect.logDebug(
+                'merge:pull:rebase: rollback',
+                mergeResult.rollbackEvents.length,
+                ...mergeResult.rollbackEvents.slice(0, 10).map((_) => _.toJSON()),
+                { leaderMergeCounter },
+              ).pipe(Effect.provide(runtime), Effect.runSync)
             }
 
-            for (let i = updateResult.eventsToRollback.length - 1; i >= 0; i--) {
-              const event = updateResult.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: updateResult.newEvents.length,
-              res: TRACE_VERBOSE ? JSON.stringify(updateResult) : undefined,
-              remaining,
+              newEventsCount: mergeResult.newEvents.length,
+              res: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
+              leaderMergeCounter,
             })
+
+            debugInfo.advanceCount++
           }
 
-          if (updateResult.newEvents.length === 0) return
+          if (mergeResult.newEvents.length === 0) return
 
           const writeTables = new Set<string>()
-          for (const mutationEvent of updateResult.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 = materializeEvent(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)
-        }),
+        }).pipe(
+          Effect.tapCauseLogPretty,
+          Effect.catchAllCause((cause) => clientSession.shutdown(cause)),
+        ),
       ),
       Stream.runDrain,
+      Effect.forever, // NOTE Whenever the leader changes, we need to re-start the stream
+      Effect.interruptible,
+      Effect.withSpan('client-session-sync-processor:pull'),
       Effect.tapCauseLogPretty,
       Effect.forkScoped,
     )
@@ -189,18 +287,46 @@ export const makeClientSessionSyncProcessor = ({
   return {
     push,
     boot,
-    syncStateRef,
+    syncState: Subscribable.make({
+      get: Effect.gen(function* () {
+        const syncState = syncStateRef.current
+        if (syncStateRef === undefined) return shouldNeverHappen('Not initialized')
+        return syncState
+      }),
+      changes: Stream.fromQueue(syncStateUpdateQueue),
+    }),
+    debug: {
+      print: () =>
+        Effect.gen(function* () {
+          console.log('debugInfo', debugInfo)
+          console.log('syncState', syncStateRef.current)
+          const pushQueueSize = yield* BucketQueue.size(leaderPushQueue)
+          console.log('pushQueueSize', pushQueueSize)
+          const pushQueueItems = yield* BucketQueue.peekAll(leaderPushQueue)
+          console.log(
+            'pushQueueItems',
+            pushQueueItems.map((_) => _.toJSON()),
+          )
+        }).pipe(Effect.provide(runtime), Effect.runSync),
+      debugInfo: () => debugInfo,
+    },
   } satisfies ClientSessionSyncProcessor
 }
 
 export interface ClientSessionSyncProcessor {
   push: (
-    batch: ReadonlyArray<MutationEvent.PartialAnyDecoded>,
+    batch: ReadonlyArray<LiveStoreEvent.PartialAnyDecoded>,
     options: { otelContext: otel.Context },
   ) => {
     writeTables: Set<string>
   }
   boot: Effect.Effect<void, UnexpectedError, Scope.Scope>
-
-  syncStateRef: { current: SyncState }
+  syncState: Subscribable.Subscribable<SyncState.SyncState>
+  debug: {
+    print: () => void
+    debugInfo: () => {
+      rebaseCount: number
+      advanceCount: number
+    }
+  }
 }

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)
 }