@livestore/common 0.4.0-dev.9 → 0.5.0-dev.0

package/src/sync/errors.ts

@@ -1,38 +1,28 @@
 import { Schema } from '@livestore/utils/effect'
-import { UnexpectedError } from '../errors.ts'
+
 import { EventSequenceNumber } from '../schema/mod.ts'
 
-export class IsOfflineError extends Schema.TaggedError<IsOfflineError>()('IsOfflineError', {
-  cause: Schema.Defect,
-}) {}
+export class IsOfflineError extends Schema.TaggedError<IsOfflineError>('~@livestore/common/IsOfflineError')(
+  'IsOfflineError',
+  {
+    cause: Schema.Defect(),
+  },
+) {}
 
 /** Unique ID generated by the backend when its created. Used to check whether the backend identity has changed. */
-export const BackendId = Schema.String.annotations({ title: '@livestore/sync-cf:BackendId' })
+export const BackendId = Schema.String.annotate({ title: '@livestore/sync-cf:BackendId' })
 
-export class BackendIdMismatchError extends Schema.TaggedError<BackendIdMismatchError>()('BackendIdMismatchError', {
+export class BackendIdMismatchError extends Schema.TaggedError<BackendIdMismatchError>(
+  '~@livestore/common/BackendIdMismatchError',
+)('BackendIdMismatchError', {
   expected: BackendId,
   received: BackendId,
 }) {}
 
-export class ServerAheadError extends Schema.TaggedError<ServerAheadError>()('ServerAheadError', {
-  minimumExpectedNum: EventSequenceNumber.GlobalEventSequenceNumber,
-  providedNum: EventSequenceNumber.GlobalEventSequenceNumber,
-}) {}
-
-export class InvalidPushError extends Schema.TaggedError<InvalidPushError>()('InvalidPushError', {
-  cause: Schema.Union(UnexpectedError, ServerAheadError, BackendIdMismatchError),
-}) {}
-
-export class InvalidPullError extends Schema.TaggedError<InvalidPullError>()('InvalidPullError', {
-  cause: Schema.Defect,
-}) {}
-
-export class LeaderAheadError extends Schema.TaggedError<LeaderAheadError>()('LeaderAheadError', {
-  minimumExpectedNum: EventSequenceNumber.EventSequenceNumber,
-  providedNum: EventSequenceNumber.EventSequenceNumber,
-  /** Generation number the client session should use for subsequent pushes */
-  // nextGeneration: Schema.Number,
-}) {}
-
-export const SyncError = Schema.Union(InvalidPushError, InvalidPullError)
-export type SyncError = typeof SyncError.Type
+export class ServerAheadError extends Schema.TaggedError<ServerAheadError>('~@livestore/common/ServerAheadError')(
+  'ServerAheadError',
+  {
+    minimumExpectedNum: EventSequenceNumber.Global.Schema,
+    providedNum: EventSequenceNumber.Global.Schema,
+  },
+) {}

package/src/sync/index.ts

@@ -1,4 +1,6 @@
 export * from './ClientSessionSyncProcessor.ts'
 export * from './mock-sync-backend.ts'
 export * from './sync.ts'
+export { NetworkStatus } from './sync-backend.ts'
+export * from './transport-chunking.ts'
 export * from './validate-push-payload.ts'

package/src/sync/mock-sync-backend.test.ts

@@ -0,0 +1,78 @@
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { Effect, Fiber, Option, Stream } from '@livestore/utils/effect'
+
+import { EventSequenceNumber, type LiveStoreEvent } from '../schema/mod.ts'
+import { makeMockSyncBackend } from './mock-sync-backend.ts'
+
+Vitest.describe('makeMockSyncBackend', () => {
+  Vitest.live('broadcasts live events to every backend connection', () =>
+    Effect.gen(function* () {
+      const mockBackend = yield* makeMockSyncBackend({ startConnected: true })
+      const backendA = yield* mockBackend.makeSyncBackend
+      const backendB = yield* mockBackend.makeSyncBackend
+      const nextBatch = (backend: typeof backendA) =>
+        backend.pull(Option.none(), { live: true }).pipe(
+          Stream.filter((item) => item.batch.length > 0),
+          Stream.runFirstUnsafe,
+        )
+
+      const pullA = yield* nextBatch(backendA).pipe(Effect.forkScoped)
+      const pullB = yield* nextBatch(backendB).pipe(Effect.forkScoped)
+      const event = makeEvent(1)
+
+      yield* mockBackend.advance(event)
+
+      Vitest.expect((yield* Fiber.join(pullA)).batch.map((item) => item.eventEncoded)).toEqual([event])
+      Vitest.expect((yield* Fiber.join(pullB)).batch.map((item) => item.eventEncoded)).toEqual([event])
+    }),
+  )
+
+  Vitest.live('seeds a new backend connection with existing live events', () =>
+    Effect.gen(function* () {
+      const mockBackend = yield* makeMockSyncBackend({ startConnected: true })
+      const event = makeEvent(1)
+      yield* mockBackend.advance(event)
+
+      const backend = yield* mockBackend.makeSyncBackend
+      const item = yield* backend.pull(Option.none(), { live: true }).pipe(
+        Stream.filter((item) => item.batch.length > 0),
+        Stream.runFirstUnsafe,
+      )
+
+      Vitest.expect(item.batch.map((entry) => entry.eventEncoded)).toEqual([event])
+    }),
+  )
+
+  Vitest.live('filters seeded live events against the requested cursor', () =>
+    Effect.gen(function* () {
+      const mockBackend = yield* makeMockSyncBackend({ startConnected: true })
+      const existing = makeEvent(1)
+      const next = makeEvent(2)
+      yield* mockBackend.advance(existing)
+
+      const backend = yield* mockBackend.makeSyncBackend
+      const cursor = Option.some({
+        eventSequenceNumber: existing.seqNum,
+        metadata: Option.none(),
+      })
+      const pull = yield* backend.pull(cursor, { live: true }).pipe(
+        Stream.filter((item) => item.batch.length > 0),
+        Stream.runFirstUnsafe,
+        Effect.forkScoped,
+      )
+
+      yield* mockBackend.advance(next)
+
+      Vitest.expect((yield* Fiber.join(pull)).batch.map((entry) => entry.eventEncoded)).toEqual([next])
+    }),
+  )
+})
+
+const makeEvent = (seqNum: number): LiveStoreEvent.Global.Encoded => ({
+  name: 'v1.TestEvent',
+  args: { id: `event-${seqNum}` },
+  seqNum: EventSequenceNumber.Global.make(seqNum),
+  parentSeqNum: EventSequenceNumber.Global.make(seqNum - 1),
+  clientId: 'client-a',
+  sessionId: 'session-a',
+})

package/src/sync/mock-sync-backend.ts

@@ -1,21 +1,38 @@
-import type { Schema, Scope } from '@livestore/utils/effect'
-import { Effect, Mailbox, Option, Queue, Stream, SubscriptionRef } from '@livestore/utils/effect'
-import { UnexpectedError } from '../errors.ts'
+import {
+  type Schema,
+  type Scope,
+  Effect,
+  Option,
+  Queue,
+  Ref,
+  Semaphore,
+  Stream,
+  SubscriptionRef,
+} from '@livestore/utils/effect'
+
+import { UnknownError } from '../errors.ts'
 import { EventSequenceNumber, type LiveStoreEvent } from '../schema/mod.ts'
-import { InvalidPushError } from './errors.ts'
+import type { BackendIdMismatchError, ServerAheadError } from './errors.ts'
 import * as SyncBackend from './sync-backend.ts'
 import { validatePushPayload } from './validate-push-payload.ts'
 
 export interface MockSyncBackend {
-  pushedEvents: Stream.Stream<LiveStoreEvent.AnyEncodedGlobal>
+  pushedEvents: Stream.Stream<LiveStoreEvent.Global.Encoded>
   connect: Effect.Effect<void>
   disconnect: Effect.Effect<void>
-  makeSyncBackend: Effect.Effect<SyncBackend.SyncBackend, UnexpectedError, Scope.Scope>
-  advance: (...batch: LiveStoreEvent.AnyEncodedGlobal[]) => Effect.Effect<void>
-  /** Fail the next N push calls with an InvalidPushError (or custom error) */
+  makeSyncBackend: Effect.Effect<SyncBackend.SyncBackend, UnknownError, Scope.Scope>
+  advance: (...batch: LiveStoreEvent.Global.Encoded[]) => Effect.Effect<void>
+  /** Fail the next N push calls with an UnknownError, ServerAheadError, BackendIdMismatchError, or custom error */
   failNextPushes: (
     count: number,
-    error?: (batch: ReadonlyArray<LiveStoreEvent.AnyEncodedGlobal>) => Effect.Effect<never, InvalidPushError>,
+    error?: (
+      batch: ReadonlyArray<LiveStoreEvent.Global.Encoded>,
+    ) => Effect.Effect<never, UnknownError | ServerAheadError | BackendIdMismatchError>,
+  ) => Effect.Effect<void>
+  /** Fail the next N pull calls with an UnknownError, BackendIdMismatchError, or custom error */
+  failNextPulls: (
+    count: number,
+    error?: () => Effect.Effect<never, UnknownError | BackendIdMismatchError>,
   ) => Effect.Effect<void>
 }
 
@@ -29,109 +46,156 @@ export interface MockSyncBackendOptions {
 
 export const makeMockSyncBackend = (
   options?: MockSyncBackendOptions,
-): Effect.Effect<MockSyncBackend, UnexpectedError, Scope.Scope> =>
+): Effect.Effect<MockSyncBackend, UnknownError, Scope.Scope> =>
   Effect.gen(function* () {
-    const syncEventSequenceNumberRef = { current: EventSequenceNumber.ROOT.global }
-    const syncPullQueue = yield* Queue.unbounded<LiveStoreEvent.AnyEncodedGlobal>()
-    const pushedEventsQueue = yield* Mailbox.make<LiveStoreEvent.AnyEncodedGlobal>()
+    const span = yield* Effect.currentSpan.pipe(Effect.orDie)
+    const semaphore = yield* Semaphore.make(1)
+
+    // State refs
+    const syncHeadRef = yield* Ref.make(EventSequenceNumber.Client.ROOT.global)
+    const allEventsRef = yield* Ref.make<LiveStoreEvent.Global.Encoded[]>([])
     const syncIsConnectedRef = yield* SubscriptionRef.make(options?.startConnected ?? false)
-    const allEventsRef: { current: LiveStoreEvent.AnyEncodedGlobal[] } = { current: [] }
 
-    const span = yield* Effect.currentSpan.pipe(Effect.orDie)
+    // Queues for streaming
+    const syncPullQueues = new Set<Queue.Queue<LiveStoreEvent.Global.Encoded>>()
+    const pushedEventsQueue = yield* Queue.unbounded<LiveStoreEvent.Global.Encoded>()
+
+    yield* Effect.addFinalizer(() =>
+      Effect.gen(function* () {
+        for (const queue of syncPullQueues) yield* Queue.shutdown(queue)
+        syncPullQueues.clear()
+      }),
+    )
 
-    const semaphore = yield* Effect.makeSemaphore(1)
+    // Failure simulation state
+    const failPushRef = yield* Ref.make<
+      FailureState<
+        UnknownError | ServerAheadError | BackendIdMismatchError,
+        [ReadonlyArray<LiveStoreEvent.Global.Encoded>]
+      >
+    >({ remaining: 0, error: undefined })
+    const failPullRef = yield* Ref.make<FailureState<UnknownError | BackendIdMismatchError, []>>({
+      remaining: 0,
+      error: undefined,
+    })
 
-    // TODO improve the API and implementation of simulating errors
-    const failCounterRef = yield* SubscriptionRef.make(0)
-    const failEffectRef = yield* SubscriptionRef.make<
-      ((batch: ReadonlyArray<LiveStoreEvent.AnyEncodedGlobal>) => Effect.Effect<never, InvalidPushError>) | undefined
-    >(undefined)
+    const nonLiveChunkSize = Math.max(1, options?.nonLiveChunkSize ?? 100)
+
+    /** Check and consume a simulated failure, returning the error effect if one should fire */
+    const checkFailure = <E, Args extends unknown[]>(
+      ref: Ref.Ref<FailureState<E, Args>>,
+      defaultError: E,
+      ...args: Args
+    ): Effect.Effect<void, E> =>
+      Ref.modify(ref, (state) => {
+        if (state.remaining <= 0) {
+          return [Option.none(), state] as const
+        }
+        const error = state.error?.(...args) ?? Effect.fail(defaultError)
+        return [Option.some(error), { ...state, remaining: state.remaining - 1 }] as const
+      }).pipe(
+        Effect.flatMap(
+          Option.match({
+            onNone: () => Effect.void,
+            onSome: (errorEffect) => errorEffect,
+          }),
+        ),
+      )
+
+    const pullNonLive = (cursor: Option.Option<{ eventSequenceNumber: EventSequenceNumber.Global.Type }>) =>
+      Effect.gen(function* () {
+        const lastSeen = cursorPosition(cursor)
+        const allEvents = yield* Ref.get(allEventsRef)
+        return chunkEvents(
+          allEvents.filter((event) => event.seqNum > lastSeen),
+          nonLiveChunkSize,
+        )
+      }).pipe(
+        Effect.map((chunks) =>
+          Stream.fromIterable(chunks).pipe(
+            Stream.map(({ events, remaining }) => ({
+              batch: events.map((eventEncoded) => ({ eventEncoded, metadata: Option.none() })),
+              pageInfo: remaining > 0 ? SyncBackend.pageInfoMoreKnown(remaining) : SyncBackend.pageInfoNoMore,
+            })),
+          ),
+        ),
+        Stream.fromEffect,
+        Stream.flatten(),
+      )
 
     const makeSyncBackend = Effect.gen(function* () {
-      const nonLiveChunkSize = Math.max(1, options?.nonLiveChunkSize ?? 100)
+      // Every backend connection needs its own live cursor. A shared queue would
+      // load-balance events across Clients instead of broadcasting the log.
+      const syncPullQueue = yield* Effect.acquireRelease(
+        Queue.unbounded<LiveStoreEvent.Global.Encoded>(),
+        Queue.shutdown,
+      )
+      yield* semaphore.withPermits(1)(
+        Effect.gen(function* () {
+          const existingEvents = yield* Ref.get(allEventsRef)
+          syncPullQueues.add(syncPullQueue)
+          yield* Queue.offerAll(syncPullQueue, existingEvents)
+        }),
+      )
+      yield* Effect.addFinalizer(() => Effect.sync(() => syncPullQueues.delete(syncPullQueue)))
+
+      const pullLive = (cursor: Option.Option<{ eventSequenceNumber: EventSequenceNumber.Global.Type }>) => {
+        const lastSeen = cursorPosition(cursor)
+        return Stream.concat(
+          Stream.make(SyncBackend.pullResItemEmpty()),
+          Stream.fromQueue(syncPullQueue).pipe(
+            Stream.chunks,
+            Stream.map((chunk) => ({
+              batch: [...chunk]
+                .filter((eventEncoded) => eventEncoded.seqNum > lastSeen)
+                .map((eventEncoded) => ({ eventEncoded, metadata: Option.none() })),
+              pageInfo: SyncBackend.pageInfoNoMore,
+            })),
+          ),
+        )
+      }
 
       // TODO consider making offline state actively error pull/push.
       // Currently, offline only reflects in `isConnected`, while operations still succeed,
       // mirroring how some real providers behave during transient disconnects.
-      return SyncBackend.of<Schema.JsonValue>({
+      return SyncBackend.of({
         isConnected: syncIsConnectedRef,
         connect: SubscriptionRef.set(syncIsConnectedRef, true),
         ping: Effect.void,
-        pull: (cursor, options) =>
-          (options?.live
-            ? Stream.concat(
-                Stream.make(SyncBackend.pullResItemEmpty()),
-                Stream.fromQueue(syncPullQueue).pipe(
-                  Stream.chunks,
-                  Stream.map((chunk) => ({
-                    batch: [...chunk].map((eventEncoded) => ({ eventEncoded, metadata: Option.none() })),
-                    pageInfo: SyncBackend.pageInfoNoMore,
-                  })),
-                ),
-              )
-            : Stream.fromEffect(
-                Effect.sync(() => {
-                  const lastSeen = cursor.pipe(
-                    Option.match({
-                      onNone: () => EventSequenceNumber.ROOT.global,
-                      onSome: (_) => _.eventSequenceNumber,
-                    }),
-                  )
-                  // All events with seqNum greater than lastSeen
-                  const slice = allEventsRef.current.filter((e) => e.seqNum > lastSeen)
-                  // Split into configured chunk size
-                  const chunks: { events: LiveStoreEvent.AnyEncodedGlobal[]; remaining: number }[] = []
-                  for (let i = 0; i < slice.length; i += nonLiveChunkSize) {
-                    const end = Math.min(i + nonLiveChunkSize, slice.length)
-                    const remaining = Math.max(slice.length - end, 0)
-                    chunks.push({ events: slice.slice(i, end), remaining })
-                  }
-                  if (chunks.length === 0) {
-                    chunks.push({ events: [], remaining: 0 })
-                  }
-                  return chunks
-                }),
-              ).pipe(
-                Stream.flatMap((chunks) =>
-                  Stream.fromIterable(chunks).pipe(
-                    Stream.map(({ events, remaining }) => ({
-                      batch: events.map((eventEncoded) => ({ eventEncoded, metadata: Option.none() })),
-                      pageInfo: remaining > 0 ? SyncBackend.pageInfoMoreKnown(remaining) : SyncBackend.pageInfoNoMore,
-                    })),
-                  ),
-                ),
-              )
-          ).pipe(Stream.withSpan('MockSyncBackend:pull', { parent: span })),
+        pull: (cursor, pullOptions) =>
+          Stream.fromEffect(
+            checkFailure(
+              failPullRef,
+              new UnknownError({ cause: new Error('MockSyncBackend: simulated pull failure') }),
+            ),
+          ).pipe(
+            Stream.flatMap(() => (pullOptions?.live === true ? pullLive(cursor) : pullNonLive(cursor))),
+            Stream.withSpan('MockSyncBackend:pull', { parent: span }),
+          ),
         push: (batch) =>
           Effect.gen(function* () {
-            yield* validatePushPayload(batch, syncEventSequenceNumberRef.current)
-
-            const remaining = yield* SubscriptionRef.get(failCounterRef)
-            if (remaining > 0) {
-              const maybeFail = yield* SubscriptionRef.get(failEffectRef)
-              // decrement counter first
-              yield* SubscriptionRef.set(failCounterRef, remaining - 1)
-              if (maybeFail) {
-                return yield* maybeFail(batch)
-              }
-              return yield* new InvalidPushError({
-                cause: new UnexpectedError({ cause: new Error('MockSyncBackend: simulated push failure') }),
-              })
-            }
+            const currentHead = yield* Ref.get(syncHeadRef)
+            yield* validatePushPayload(batch, currentHead)
 
-            yield* Effect.sleep(10).pipe(Effect.withSpan('MockSyncBackend:push:sleep')) // Simulate network latency
+            yield* checkFailure(
+              failPushRef,
+              new UnknownError({ cause: new Error('MockSyncBackend: simulated push failure') }),
+              batch,
+            )
 
-            yield* pushedEventsQueue.offerAll(batch)
-            yield* syncPullQueue.offerAll(batch)
-            allEventsRef.current = allEventsRef.current.concat(batch)
+            yield* Effect.sleep(10).pipe(Effect.withSpan('MockSyncBackend:push:sleep')) // Simulate network latency
 
-            syncEventSequenceNumberRef.current = batch.at(-1)!.seqNum
+            yield* Queue.offerAll(pushedEventsQueue, batch)
+            yield* Effect.forEach(syncPullQueues, (queue) => Queue.offerAll(queue, batch), {
+              concurrency: 'unbounded',
+              discard: true,
+            })
+            yield* Ref.update(allEventsRef, (events) => events.concat(batch))
+            yield* Ref.set(syncHeadRef, batch.at(-1)!.seqNum)
           }).pipe(
             Effect.withSpan('MockSyncBackend:push', {
               parent: span,
-              attributes: {
-                nums: batch.map((_) => _.seqNum),
-              },
+              attributes: { nums: batch.map((_) => _.seqNum) },
             }),
             semaphore.withPermits(1),
           ),
@@ -146,11 +210,14 @@ export const makeMockSyncBackend = (
       })
     })
 
-    const advance = (...batch: LiveStoreEvent.AnyEncodedGlobal[]) =>
+    const advance = (...batch: LiveStoreEvent.Global.Encoded[]) =>
       Effect.gen(function* () {
-        syncEventSequenceNumberRef.current = batch.at(-1)!.seqNum
-        allEventsRef.current = allEventsRef.current.concat(batch)
-        yield* syncPullQueue.offerAll(batch)
+        yield* Ref.set(syncHeadRef, batch.at(-1)!.seqNum)
+        yield* Ref.update(allEventsRef, (events) => events.concat(batch))
+        yield* Effect.forEach(syncPullQueues, (queue) => Queue.offerAll(queue, batch), {
+          concurrency: 'unbounded',
+          discard: true,
+        })
       }).pipe(
         Effect.withSpan('MockSyncBackend:advance', {
           parent: span,
@@ -159,26 +226,47 @@ export const makeMockSyncBackend = (
         semaphore.withPermits(1),
       )
 
-    const connect = SubscriptionRef.set(syncIsConnectedRef, true)
-    const disconnect = SubscriptionRef.set(syncIsConnectedRef, false)
-
     const failNextPushes = (
       count: number,
-      error?: (batch: ReadonlyArray<LiveStoreEvent.AnyEncodedGlobal>) => Effect.Effect<never, InvalidPushError>,
-    ) =>
-      Effect.gen(function* () {
-        yield* SubscriptionRef.set(failCounterRef, count)
-        yield* SubscriptionRef.set(failEffectRef, error)
-      })
+      error?: (
+        batch: ReadonlyArray<LiveStoreEvent.Global.Encoded>,
+      ) => Effect.Effect<never, UnknownError | ServerAheadError | BackendIdMismatchError>,
+    ) => Ref.set(failPushRef, { remaining: count, error })
+
+    const failNextPulls = (count: number, error?: () => Effect.Effect<never, UnknownError | BackendIdMismatchError>) =>
+      Ref.set(failPullRef, { remaining: count, error })
 
     return {
-      syncEventSequenceNumberRef,
-      syncPullQueue,
-      pushedEvents: Mailbox.toStream(pushedEventsQueue),
-      connect,
-      disconnect,
+      pushedEvents: Stream.fromQueue(pushedEventsQueue),
+      connect: SubscriptionRef.set(syncIsConnectedRef, true),
+      disconnect: SubscriptionRef.set(syncIsConnectedRef, false),
       makeSyncBackend,
       advance,
       failNextPushes,
+      failNextPulls,
     }
   }).pipe(Effect.withSpanScoped('MockSyncBackend'))
+
+/** Internal state for simulating failures */
+interface FailureState<E, Args extends unknown[]> {
+  remaining: number
+  error: ((...args: Args) => Effect.Effect<never, E>) | undefined
+}
+
+const cursorPosition = (
+  cursor: Option.Option<{ eventSequenceNumber: EventSequenceNumber.Global.Type }>,
+): EventSequenceNumber.Global.Type =>
+  Option.match(cursor, {
+    onNone: () => EventSequenceNumber.Client.ROOT.global,
+    onSome: (_) => _.eventSequenceNumber,
+  })
+
+const chunkEvents = (events: ReadonlyArray<LiveStoreEvent.Global.Encoded>, chunkSize: number) => {
+  const chunks: Array<{ events: ReadonlyArray<LiveStoreEvent.Global.Encoded>; remaining: number }> = []
+  for (let index = 0; index < events.length; index += chunkSize) {
+    const end = Math.min(index + chunkSize, events.length)
+    chunks.push({ events: events.slice(index, end), remaining: Math.max(events.length - end, 0) })
+  }
+  if (chunks.length === 0) chunks.push({ events: [], remaining: 0 })
+  return chunks
+}

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

@@ -1,6 +1,5 @@
 import { EventSequenceNumber } from '../../schema/mod.ts'
 import { replacesFacts } from './facts.ts'
-import { graphologyDag } from './graphology_.ts'
 import type { HistoryDag } from './history-dag-common.ts'
 import { emptyHistoryDag } from './history-dag-common.ts'
 
@@ -17,7 +16,7 @@ export const compactEvents = (inputDag: HistoryDag): { dag: HistoryDag; compacte
   const dag = inputDag.copy()
   const compactedEventCount = 0
 
-  const orderedEventSequenceNumberStrs = graphologyDag.topologicalSort(dag).reverse()
+  const orderedEventSequenceNumberStrs = dag.topologicalNodeIds().toReversed()
 
   // drop root
   orderedEventSequenceNumberStrs.pop()
@@ -30,7 +29,7 @@ export const compactEvents = (inputDag: HistoryDag): { dag: HistoryDag; compacte
     const subDagsForEvent = Array.from(makeSubDagsForEvent(dag, eventNumStr))
     for (const subDag of subDagsForEvent) {
       let shouldRetry = true
-      while (shouldRetry) {
+      while (shouldRetry === true) {
         const subDagsInHistory = findSubDagsInHistory(dag, subDag, eventNumStr)
 
         // console.debug(
@@ -65,7 +64,7 @@ export const compactEvents = (inputDag: HistoryDag): { dag: HistoryDag; compacte
   return { dag, compactedEventCount }
 }
 
-function* makeSubDagsForEvent(inputDag: HistoryDag, eventNumStr: string): Generator<HistoryDag> {
+const makeSubDagsForEvent = function* (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
@@ -116,7 +115,7 @@ const findSubDagsInHistory = (
   const subDags: HistoryDag[] = []
   const allOutsideDependencies: string[][] = []
 
-  for (const eventNumStr of graphologyDag.topologicalSort(inputDag)) {
+  for (const eventNumStr of inputDag.topologicalNodeIds()) {
     if (eventNumStr === upToExclEventSequenceNumberStr) {
       break
     }
@@ -132,7 +131,7 @@ const findSubDagsInHistory = (
         allOutsideDependencies.push(outsideDependencies)
       }
 
-      if (outsideDependencies.length === 0 && dagReplacesDag(subDag, targetSubDag)) {
+      if (outsideDependencies.length === 0 && dagReplacesDag(subDag, targetSubDag) === true) {
         subDags.push(subDag)
       } else {
         break
@@ -172,7 +171,7 @@ const dagDependsOnDag = (dagA: HistoryDag, dagB: HistoryDag, inputDag: HistoryDa
     for (const edgeEntryA of inputDag.inboundEdgeEntries(nodeAIdStr)) {
       if (edgeEntryA.attributes.type === 'facts') {
         const depNodeIdStr = edgeEntryA.target
-        if (dagB.hasNode(depNodeIdStr)) {
+        if (dagB.hasNode(depNodeIdStr) === true) {
           return true
         }
       }
@@ -189,8 +188,8 @@ const dagReplacesDag = (dagA: HistoryDag, dagB: HistoryDag): boolean => {
   }
 
   // TODO write tests that covers deterministic order when DAGs have branches
-  const nodeEntriesA = graphologyDag.topologicalSort(dagA).map((nodeId) => dagA.getNodeAttributes(nodeId))
-  const nodeEntriesB = graphologyDag.topologicalSort(dagB).map((nodeId) => dagB.getNodeAttributes(nodeId))
+  const nodeEntriesA = dagA.topologicalNodeIds().map((nodeId) => dagA.getNodeAttributes(nodeId))
+  const nodeEntriesB = dagB.topologicalNodeIds().map((nodeId) => dagB.getNodeAttributes(nodeId))
 
   for (let i = 0; i < nodeEntriesA.length; i++) {
     const nodeA = nodeEntriesA[i]!
@@ -207,14 +206,14 @@ const dagReplacesDag = (dagA: HistoryDag, dagB: HistoryDag): boolean => {
 const removeEvent = (dag: HistoryDag, eventNumStr: string) => {
   // console.debug('removing event', eventNumStr)
   const event = dag.getNodeAttributes(eventNumStr)
-  const parentSeqNumStr = EventSequenceNumber.toString(event.parentSeqNum)
+  const parentSeqNumStr = EventSequenceNumber.Client.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.parentSeqNum = { ...event.parentSeqNum }
-      dag.addEdge(parentSeqNumStr, EventSequenceNumber.toString(childEvent.seqNum), { type: 'parent' })
+      dag.addEdge(parentSeqNumStr, EventSequenceNumber.Client.toString(childEvent.seqNum), { type: 'parent' })
     }
   }