@livestore/common 0.3.1 → 0.3.2-dev.1

package/src/sync/ClientSessionSyncProcessor.ts

@@ -1,15 +1,24 @@
 /// <reference lib="dom" />
 import { LS_DEV, shouldNeverHappen, TRACE_VERBOSE } from '@livestore/utils'
-import { Option, type Runtime, type Scope } from '@livestore/utils/effect'
-import { BucketQueue, Effect, FiberHandle, Queue, Schema, Stream, Subscribable } from '@livestore/utils/effect'
+import {
+  BucketQueue,
+  Effect,
+  FiberHandle,
+  Option,
+  Queue,
+  type Runtime,
+  Schema,
+  type Scope,
+  Stream,
+  Subscribable,
+} from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 
-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'
+import { type ClientSession, SyncError, type UnexpectedError } from '../adapter-types.ts'
+import * as EventSequenceNumber from '../schema/EventSequenceNumber.ts'
+import * as LiveStoreEvent from '../schema/LiveStoreEvent.ts'
+import { getEventDef, type LiveStoreSchema } from '../schema/mod.ts'
+import * as SyncState from './syncstate.ts'
 
 /**
  * Rebase behaviour:
@@ -21,6 +30,10 @@ import * as SyncState from './syncstate.js'
  * - 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.
+ *
+ * The session and leader sync processor are different in the following ways:
+ * - The leader sync processor pulls regular LiveStore events, while the session sync processor pulls SyncState.PayloadUpstream items
+ * - The session sync processor has no downstream nodes.
  */
 export const makeClientSessionSyncProcessor = ({
   schema,
@@ -37,7 +50,7 @@ export const makeClientSessionSyncProcessor = ({
   clientSession: ClientSession
   runtime: Runtime.Runtime<Scope.Scope>
   materializeEvent: (
-    eventDecoded: LiveStoreEvent.PartialAnyDecoded,
+    eventDecoded: LiveStoreEvent.AnyDecoded,
     options: { otelContext: otel.Context; withChangeset: boolean; materializerHashLeader: Option.Option<number> },
   ) => {
     writeTables: Set<string>
@@ -49,6 +62,7 @@ export const makeClientSessionSyncProcessor = ({
   span: otel.Span
   params: {
     leaderPushBatchSize: number
+    simulation?: ClientSessionSyncProcessorSimulationParams
   }
   /**
    * Currently only used in the web adapter:
@@ -58,6 +72,11 @@ export const makeClientSessionSyncProcessor = ({
 }): ClientSessionSyncProcessor => {
   const eventSchema = LiveStoreEvent.makeEventDefSchemaMemo(schema)
 
+  const simSleep = <TKey extends keyof ClientSessionSyncProcessorSimulationParams>(
+    key: TKey,
+    key2: keyof ClientSessionSyncProcessorSimulationParams[TKey],
+  ) => Effect.sleep((params.simulation?.[key]?.[key2] ?? 0) as number)
+
   const syncStateRef = {
     // The initial state is identical to the leader's initial state
     current: new SyncState.SyncState({
@@ -82,7 +101,10 @@ export const makeClientSessionSyncProcessor = ({
     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)
+      const nextNumPair = EventSequenceNumber.nextPair({
+        seqNum: baseEventSequenceNumber,
+        isClient: eventDef.eventDef.options.clientOnly,
+      })
       baseEventSequenceNumber = nextNumPair.seqNum
       return new LiveStoreEvent.EncodedWithMeta(
         Schema.encodeUnknownSync(eventSchema)({
@@ -103,7 +125,7 @@ export const makeClientSessionSyncProcessor = ({
     })
 
     if (mergeResult._tag === 'unexpected-error') {
-      return shouldNeverHappen('Unexpected error in client-session-sync-processor', mergeResult.cause)
+      return shouldNeverHappen('Unexpected error in client-session-sync-processor', mergeResult.message)
     }
 
     span.addEvent('local-push', {
@@ -155,7 +177,6 @@ export const makeClientSessionSyncProcessor = ({
   const otelContext = otel.trace.setSpan(otel.context.active(), span)
 
   const boot: ClientSessionSyncProcessor['boot'] = Effect.gen(function* () {
-    // 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) {
@@ -184,18 +205,11 @@ export const makeClientSessionSyncProcessor = ({
 
     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 },
-      }),
+      clientSession.leaderThread.events.pull({ cursor: syncStateRef.current.upstreamHead }),
     ).pipe(
-      Stream.tap(({ payload, mergeCounter: leaderMergeCounter }) =>
+      Stream.tap(({ payload }) =>
         Effect.gen(function* () {
           // yield* Effect.logDebug('ClientSessionSyncProcessor:pull', payload)
 
@@ -211,13 +225,13 @@ export const makeClientSessionSyncProcessor = ({
           })
 
           if (mergeResult._tag === 'unexpected-error') {
-            return yield* Effect.fail(mergeResult.cause)
+            return yield* new SyncError({ cause: mergeResult.message })
           } else if (mergeResult._tag === 'reject') {
             return shouldNeverHappen('Unexpected reject in client-session-sync-processor', mergeResult)
           }
 
           syncStateRef.current = mergeResult.newSyncState
-          syncStateUpdateQueue.offer(mergeResult.newSyncState).pipe(Effect.runSync)
+          yield* syncStateUpdateQueue.offer(mergeResult.newSyncState)
 
           if (mergeResult._tag === 'rebase') {
             span.addEvent('merge:pull:rebase', {
@@ -226,25 +240,28 @@ export const makeClientSessionSyncProcessor = ({
               newEventsCount: mergeResult.newEvents.length,
               rollbackCount: mergeResult.rollbackEvents.length,
               res: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
-              leaderMergeCounter,
+              rebaseGeneration: mergeResult.newSyncState.localHead.rebaseGeneration,
             })
 
             debugInfo.rebaseCount++
 
+            if (SIMULATION_ENABLED) yield* simSleep('pull', '1_before_leader_push_fiber_interrupt')
+
             yield* FiberHandle.clear(leaderPushingFiberHandle)
 
+            if (SIMULATION_ENABLED) yield* simSleep('pull', '2_before_leader_push_queue_clear')
+
             // Reset the leader push queue since we're rebasing and will push again
             yield* BucketQueue.clear(leaderPushQueue)
 
-            yield* FiberHandle.run(leaderPushingFiberHandle, backgroundLeaderPushing)
+            if (SIMULATION_ENABLED) yield* simSleep('pull', '3_before_rebase_rollback')
 
             if (LS_DEV) {
-              Effect.logDebug(
+              yield* 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 = mergeResult.rollbackEvents.length - 1; i >= 0; i--) {
@@ -255,15 +272,19 @@ export const makeClientSessionSyncProcessor = ({
               }
             }
 
-            // Pushing rebased pending events to leader
+            if (SIMULATION_ENABLED) yield* simSleep('pull', '4_before_leader_push_queue_offer')
+
             yield* BucketQueue.offerAll(leaderPushQueue, mergeResult.newSyncState.pending)
+
+            if (SIMULATION_ENABLED) yield* simSleep('pull', '5_before_leader_push_fiber_run')
+
+            yield* FiberHandle.run(leaderPushingFiberHandle, backgroundLeaderPushing)
           } else {
             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,
-              leaderMergeCounter,
             })
 
             debugInfo.advanceCount++
@@ -356,3 +377,17 @@ export interface ClientSessionSyncProcessor {
     }
   }
 }
+
+// TODO turn this into a build-time "macro" so all simulation snippets are removed for production builds
+const SIMULATION_ENABLED = true
+
+export const ClientSessionSyncProcessorSimulationParams = Schema.Struct({
+  pull: Schema.Struct({
+    '1_before_leader_push_fiber_interrupt': Schema.Int.pipe(Schema.between(0, 1000)),
+    '2_before_leader_push_queue_clear': Schema.Int.pipe(Schema.between(0, 1000)),
+    '3_before_rebase_rollback': Schema.Int.pipe(Schema.between(0, 1000)),
+    '4_before_leader_push_queue_offer': Schema.Int.pipe(Schema.between(0, 1000)),
+    '5_before_leader_push_fiber_run': Schema.Int.pipe(Schema.between(0, 1000)),
+  }),
+})
+type ClientSessionSyncProcessorSimulationParams = typeof ClientSessionSyncProcessorSimulationParams.Type

package/src/sync/index.ts

@@ -1,3 +1,3 @@
-export * from './sync.js'
-export * from './validate-push-payload.js'
-export * from './ClientSessionSyncProcessor.js'
+export * from './ClientSessionSyncProcessor.ts'
+export * from './sync.ts'
+export * from './validate-push-payload.ts'

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

@@ -1,8 +1,8 @@
-import { EventSequenceNumber } from '../../schema/mod.js'
-import { replacesFacts } from './facts.js'
-import { graphologyDag } from './graphology_.js'
-import type { HistoryDag } from './history-dag-common.js'
-import { emptyHistoryDag } from './history-dag-common.js'
+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'
 
 /**
  * Idea:

package/src/sync/next/facts.ts

@@ -6,10 +6,10 @@ import type {
   EventDefFactsGroup,
   EventDefFactsSnapshot,
   FactsCallback,
-} 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'
+} from '../../schema/EventDef.ts'
+import type * as EventSequenceNumber from '../../schema/EventSequenceNumber.ts'
+import { graphologyDag } from './graphology_.ts'
+import { EMPTY_FACT_VALUE, type HistoryDag, type HistoryDagNode } from './history-dag-common.ts'
 
 export const factsSnapshotForEvents = (
   events: HistoryDagNode[],

package/src/sync/next/graphology.ts

@@ -13,17 +13,9 @@ export declare class IGraph<
   constructor(options?: graphologyTypes.GraphOptions)
 }
 
-export const DirectedGraph = class DirectedGraph extends graphology.DirectedGraph {
-  constructor(options?: graphologyTypes.GraphOptions) {
-    super(options)
-  }
-} as typeof IGraph
-
-export const Graph = class Graph extends graphology.Graph {
-  constructor(options?: graphologyTypes.GraphOptions) {
-    super(options)
-  }
-} as typeof IGraph
+export const DirectedGraph = class DirectedGraph extends graphology.DirectedGraph {} as typeof IGraph
+
+export const Graph = class Graph extends graphology.Graph {} as typeof IGraph
 
 // export const graphology = graphology_ as graphologyTypes
 

package/src/sync/next/graphology_.ts

@@ -1,2 +1,2 @@
-export * as graphology from './graphology.js'
 export { default as graphologyDag } from 'graphology-dag'
+export * as graphology from './graphology.ts'

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

@@ -1,6 +1,6 @@
-import type { EventDefFactsGroup } from '../../schema/EventDef.js'
-import * as EventSequenceNumber from '../../schema/EventSequenceNumber.js'
-import { graphology } from './graphology_.js'
+import type { EventDefFactsGroup } from '../../schema/EventDef.ts'
+import * as EventSequenceNumber from '../../schema/EventSequenceNumber.ts'
+import { graphology } from './graphology_.ts'
 
 export const connectionTypeOptions = ['parent', 'facts'] as const
 export type ConnectionType = (typeof connectionTypeOptions)[number]

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

@@ -1,6 +1,6 @@
-import * as EventSequenceNumber from '../../schema/EventSequenceNumber.js'
-import { factsToString, validateFacts } from './facts.js'
-import { emptyHistoryDag, type HistoryDagNode, rootParentNum } from './history-dag-common.js'
+import * as EventSequenceNumber from '../../schema/EventSequenceNumber.ts'
+import { factsToString, validateFacts } from './facts.ts'
+import { emptyHistoryDag, type HistoryDagNode, rootParentNum } from './history-dag-common.ts'
 
 export const historyDagFromNodes = (dagNodes: HistoryDagNode[], options?: { skipFactsCheck: boolean }) => {
   if (options?.skipFactsCheck !== true) {

package/src/sync/next/mod.ts

@@ -1,5 +1,5 @@
-export * from './history-dag-common.js'
-export * from './history-dag.js'
-export * from './facts.js'
-export * from './compact-events.js'
-export * from './rebase-events.js'
+export * from './compact-events.ts'
+export * from './facts.ts'
+export * from './history-dag.ts'
+export * from './history-dag-common.ts'
+export * from './rebase-events.ts'

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

@@ -1,14 +1,14 @@
-import type { EventDef, EventDefFactsSnapshot } from '../../schema/EventDef.js'
-import * as EventSequenceNumber from '../../schema/EventSequenceNumber.js'
-import type * as LiveStoreEvent from '../../schema/LiveStoreEvent.js'
+import type { EventDef, EventDefFactsSnapshot } from '../../schema/EventDef.ts'
+import * as EventSequenceNumber from '../../schema/EventSequenceNumber.ts'
+import type * as LiveStoreEvent from '../../schema/LiveStoreEvent.ts'
 import {
   applyFactGroups,
-  factsIntersect,
   type FactValidationResult,
+  factsIntersect,
   getFactsGroupForEventArgs,
   validateFacts,
-} from './facts.js'
-import type { HistoryDagNode } from './history-dag-common.js'
+} from './facts.ts'
+import type { HistoryDagNode } from './history-dag-common.ts'
 
 export type RebaseEventWithConflict = HistoryDagNode & {
   conflictType: 'overlap' | 'missing-requirement'
@@ -38,6 +38,7 @@ export const defaultRebaseFn: RebaseFn = ({ pendingLocalEvents }) => {
   return { rebasedLocalEvents: pendingLocalEvents }
 }
 
+// TODO replace in favour of current rebase impl
 export const rebaseEvents = ({
   rebaseFn,
   pendingLocalEvents,

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

@@ -2,10 +2,10 @@ import { defineEvent } from '@livestore/common/schema'
 import { Schema } from '@livestore/utils/effect'
 import { describe, expect, it } from 'vitest'
 
-import { compactEvents } from '../compact-events.js'
-import { historyDagFromNodes } from '../history-dag.js'
-import { customSerializer } from './compact-events.test.js'
-import { printEvent, toEventNodes } from './event-fixtures.js'
+import { compactEvents } from '../compact-events.ts'
+import { historyDagFromNodes } from '../history-dag.ts'
+import { customSerializer } from './compact-events.test.ts'
+import { printEvent, toEventNodes } from './event-fixtures.ts'
 
 expect.addSnapshotSerializer(customSerializer)
 

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

@@ -1,11 +1,11 @@
 import type { EventDefFacts } from '@livestore/common/schema'
 import { describe, expect, it } from 'vitest'
 
-import { compactEvents } from '../compact-events.js'
-import { historyDagFromNodes } from '../history-dag.js'
-import type { HistoryDagNode } from '../history-dag-common.js'
-import { EMPTY_FACT_VALUE } from '../history-dag-common.js'
-import { events as eventDefs, printEvent, toEventNodes } from './event-fixtures.js'
+import { compactEvents } from '../compact-events.ts'
+import { historyDagFromNodes } from '../history-dag.ts'
+import type { HistoryDagNode } from '../history-dag-common.ts'
+import { EMPTY_FACT_VALUE } from '../history-dag-common.ts'
+import { events as eventDefs, printEvent, toEventNodes } from './event-fixtures.ts'
 
 const customStringify = (value: any): string => {
   if (value === null) {
@@ -64,7 +64,7 @@ const factsSetToString = (facts: EventDefFacts, prefix: string) =>
 export const customSerializer = {
   test: (val: unknown) => Array.isArray(val),
   print: (val: unknown[], _serialize: (item: unknown) => string) => {
-    return '[\n' + (val as any[]).map((item) => '  ' + customStringify(item)).join('\n') + '\n]'
+    return `[\n${(val as any[]).map((item) => `  ${customStringify(item)}`).join('\n')}\n]`
   },
 } as any
 

package/src/sync/next/test/event-fixtures.ts

@@ -1,12 +1,12 @@
 import { Schema } from '@livestore/utils/effect'
 
-import type { EventDef } from '../../../schema/EventDef.js'
-import { defineEvent, defineFacts } from '../../../schema/EventDef.js'
-import * as EventSequenceNumber from '../../../schema/EventSequenceNumber.js'
-import { factsSnapshotForDag, getFactsGroupForEventArgs } from '../facts.js'
-import { historyDagFromNodes } from '../history-dag.js'
-import type { HistoryDagNode } from '../history-dag-common.js'
-import { rootEventNode } from '../history-dag-common.js'
+import type { EventDef } from '../../../schema/EventDef.ts'
+import { defineEvent, defineFacts } from '../../../schema/EventDef.ts'
+import * as EventSequenceNumber from '../../../schema/EventSequenceNumber.ts'
+import { factsSnapshotForDag, getFactsGroupForEventArgs } from '../facts.ts'
+import { historyDagFromNodes } from '../history-dag.ts'
+import type { HistoryDagNode } from '../history-dag-common.ts'
+import { rootEventNode } from '../history-dag-common.ts'
 
 export const printEvent = ({ seqNum, parentSeqNum, factsGroup, ...rest }: HistoryDagNode) => ({
   seqNum: EventSequenceNumber.toString(seqNum),
@@ -144,7 +144,10 @@ export const toEventNodes = (
 
   const eventNodes = partialEvents.map((partialEvent) => {
     const eventDef = eventDefs[partialEvent.name]!
-    const eventNum = EventSequenceNumber.nextPair(currentEventSequenceNumber, eventDef.options.clientOnly).seqNum
+    const eventNum = EventSequenceNumber.nextPair({
+      seqNum: currentEventSequenceNumber,
+      isClient: eventDef.options.clientOnly,
+    }).seqNum
     currentEventSequenceNumber = eventNum
 
     const factsSnapshot = factsSnapshotForDag(historyDagFromNodes(nodesAcc, { skipFactsCheck: true }), undefined)
@@ -221,8 +224,14 @@ const getParentNum = (eventNum: EventSequenceNumber.EventSequenceNumber): EventS
   const clientParentNum = eventNum.client - 1
 
   if (clientParentNum < 0) {
-    return EventSequenceNumber.make({ global: globalParentNum - 1, client: EventSequenceNumber.clientDefault })
+    return EventSequenceNumber.make({
+      global: globalParentNum - 1,
+      client: EventSequenceNumber.clientDefault,
+    })
   }
 
-  return EventSequenceNumber.make({ global: globalParentNum, client: clientParentNum })
+  return EventSequenceNumber.make({
+    global: globalParentNum,
+    client: clientParentNum,
+  })
 }

package/src/sync/next/test/mod.ts

@@ -1 +1 @@
-export * from './event-fixtures.js'
+export * from './event-fixtures.ts'

package/src/sync/sync.ts

@@ -1,10 +1,10 @@
 import type { Effect, HttpClient, Option, Scope, Stream, SubscriptionRef } from '@livestore/utils/effect'
 import { Schema } from '@livestore/utils/effect'
 
-import type { UnexpectedError } from '../adapter-types.js'
-import type { InitialSyncOptions } from '../leader-thread/types.js'
-import * as EventSequenceNumber from '../schema/EventSequenceNumber.js'
-import type * as LiveStoreEvent from '../schema/LiveStoreEvent.js'
+import type { UnexpectedError } from '../adapter-types.ts'
+import type { InitialSyncOptions } from '../leader-thread/types.ts'
+import * as EventSequenceNumber from '../schema/EventSequenceNumber.ts'
+import type * as LiveStoreEvent from '../schema/LiveStoreEvent.ts'
 
 /**
  * Those arguments can be used to implement multi-tenancy etc and are passed in from the store.
@@ -80,6 +80,7 @@ export type SyncBackend<TSyncMetadata = Schema.JsonValue> = {
 
 export class IsOfflineError extends Schema.TaggedError<IsOfflineError>()('IsOfflineError', {}) {}
 
+// TODO gt rid of this error in favour of SyncError
 export class InvalidPushError extends Schema.TaggedError<InvalidPushError>()('InvalidPushError', {
   reason: Schema.Union(
     Schema.TaggedStruct('Unexpected', {
@@ -92,10 +93,12 @@ export class InvalidPushError extends Schema.TaggedError<InvalidPushError>()('In
   ),
 }) {}
 
+// TODO gt rid of this error in favour of SyncError
 export class InvalidPullError extends Schema.TaggedError<InvalidPullError>()('InvalidPullError', {
   message: Schema.String,
 }) {}
 
+// TODO gt rid of this error in favour of SyncError
 export class LeaderAheadError extends Schema.TaggedError<LeaderAheadError>()('LeaderAheadError', {
   minimumExpectedNum: EventSequenceNumber.EventSequenceNumber,
   providedNum: EventSequenceNumber.EventSequenceNumber,

package/src/sync/syncstate.test.ts

@@ -1,16 +1,17 @@
-/* eslint-disable prefer-arrow/prefer-arrow-functions */
 import { describe, expect, it } from 'vitest'
 
-import * as EventSequenceNumber from '../schema/EventSequenceNumber.js'
-import * as LiveStoreEvent from '../schema/LiveStoreEvent.js'
-import * as SyncState from './syncstate.js'
+import * as EventSequenceNumber from '../schema/EventSequenceNumber.ts'
+import * as LiveStoreEvent from '../schema/LiveStoreEvent.ts'
+import * as SyncState from './syncstate.ts'
 
 class TestEvent extends LiveStoreEvent.EncodedWithMeta {
+  public readonly payload: string
+  public readonly isClient: boolean
   constructor(
-    seqNum: EventSequenceNumber.EventSequenceNumber | typeof EventSequenceNumber.EventSequenceNumber.Encoded,
-    parentSeqNum: EventSequenceNumber.EventSequenceNumber,
-    public readonly payload: string,
-    public readonly isLocal: boolean,
+    seqNum: EventSequenceNumber.EventSequenceNumberInput,
+    parentSeqNum: EventSequenceNumber.EventSequenceNumberInput,
+    payload: string,
+    isClient: boolean,
   ) {
     super({
       seqNum: EventSequenceNumber.make(seqNum),
@@ -20,10 +21,12 @@ class TestEvent extends LiveStoreEvent.EncodedWithMeta {
       clientId: 'static-local-id',
       sessionId: 'static-session-id',
     })
+    this.payload = payload
+    this.isClient = isClient
   }
 
-  rebase_ = (parentSeqNum: EventSequenceNumber.EventSequenceNumber) => {
-    return this.rebase(parentSeqNum, this.isLocal)
+  rebase_ = (parentSeqNum: EventSequenceNumber.EventSequenceNumber, rebaseGeneration: number) => {
+    return this.rebase({ parentSeqNum, isClient: this.isClient, rebaseGeneration })
   }
 
   // Only used for Vitest printing
@@ -41,7 +44,7 @@ const e2_1 = new TestEvent({ global: 2, client: 1 }, e2_0.seqNum, 'a', true)
 
 const isEqualEvent = LiveStoreEvent.isEqualEncoded
 
-const isClientEvent = (event: LiveStoreEvent.EncodedWithMeta) => (event as TestEvent).isLocal
+const isClientEvent = (event: LiveStoreEvent.EncodedWithMeta) => (event as TestEvent).isClient
 
 describe('syncstate', () => {
   describe('merge', () => {
@@ -62,8 +65,8 @@ describe('syncstate', () => {
           upstreamHead: EventSequenceNumber.ROOT,
           localHead: e2_0.seqNum,
         })
-        const e1_0_e2_0 = e1_0.rebase_(e2_0.seqNum)
-        const e1_1_e2_1 = e1_1.rebase_(e1_0_e2_0.seqNum)
+        const e1_0_e2_0 = e1_0.rebase_(e2_0.seqNum, 0)
+        const e1_1_e2_1 = e1_1.rebase_(e1_0_e2_0.seqNum, 0)
         const result = merge({
           syncState,
           payload: SyncState.PayloadUpstreamRebase.make({
@@ -71,7 +74,7 @@ describe('syncstate', () => {
             newEvents: [e1_0_e2_0, e1_1_e2_1],
           }),
         })
-        const e2_0_e3_0 = e2_0.rebase_(e1_0_e2_0.seqNum)
+        const e2_0_e3_0 = e2_0.rebase_(e1_0_e2_0.seqNum, 1)
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
         expect(result.newSyncState.upstreamHead).toMatchObject(e1_1_e2_1.seqNum)
@@ -86,7 +89,7 @@ describe('syncstate', () => {
           upstreamHead: EventSequenceNumber.ROOT,
           localHead: e2_0.seqNum,
         })
-        const e1_1_e2_0 = e1_1.rebase_(e1_0.seqNum)
+        const e1_1_e2_0 = e1_1.rebase_(e1_0.seqNum, 0)
         const result = merge({
           syncState,
           payload: SyncState.PayloadUpstreamRebase.make({
@@ -94,7 +97,7 @@ describe('syncstate', () => {
             rollbackEvents: [e1_1],
           }),
         })
-        const e2_0_e3_0 = e2_0.rebase_(e1_1_e2_0.seqNum)
+        const e2_0_e3_0 = e2_0.rebase_(e1_1_e2_0.seqNum, 1)
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
         expect(result.newSyncState.upstreamHead).toMatchObject(e1_1_e2_0.seqNum)
@@ -326,7 +329,7 @@ describe('syncstate', () => {
         })
         const result = merge({ syncState, payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1] }) })
 
-        const e1_0_e1_2 = e1_0.rebase_(e1_1.seqNum)
+        const e1_0_e1_2 = e1_0.rebase_(e1_1.seqNum, 1)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e1_0_e1_2])
@@ -344,7 +347,7 @@ describe('syncstate', () => {
           localHead: e2_0_b.seqNum,
         })
         const result = merge({ syncState, payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e2_0] }) })
-        const e2_0_e3_0 = e2_0_b.rebase_(e2_0.seqNum)
+        const e2_0_e3_0 = e2_0_b.rebase_(e2_0.seqNum, 1)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
@@ -365,7 +368,7 @@ describe('syncstate', () => {
           payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1, e1_2, e1_3, e2_0] }),
         })
 
-        const e1_0_e3_0 = e1_0.rebase_(e2_0.seqNum)
+        const e1_0_e3_0 = e1_0.rebase_(e2_0.seqNum, 1)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e1_0_e3_0])
@@ -384,7 +387,7 @@ describe('syncstate', () => {
           payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_0, e1_2, e1_3, e2_0] }),
         })
 
-        const e1_1_e2_1 = e1_1.rebase_(e2_0.seqNum)
+        const e1_1_e2_1 = e1_1.rebase_(e2_0.seqNum, 1)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e1_1_e2_1])
@@ -405,8 +408,8 @@ describe('syncstate', () => {
           payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1, e1_2, e1_3, e2_0] }),
         })
 
-        const e1_0_e2_1 = e1_0.rebase_(e2_0.seqNum)
-        const e1_1_e2_2 = e1_1.rebase_(e1_0_e2_1.seqNum)
+        const e1_0_e2_1 = e1_0.rebase_(e2_0.seqNum, 1)
+        const e1_1_e2_2 = e1_1.rebase_(e1_0_e2_1.seqNum, 1)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e1_0_e2_1, e1_1_e2_2])