@livestore/common 0.3.0-dev.2 → 0.3.0-dev.22

package/src/schema-management/migrations.ts

@@ -1,8 +1,8 @@
-import { SqliteAst, SqliteDsl } from '@livestore/db-schema'
 import { memoizeByStringifyArgs } from '@livestore/utils'
 import { Effect, Schema as EffectSchema } from '@livestore/utils/effect'
 
-import type { SynchronousDatabase } from '../adapter-types.js'
+import type { MigrationsReport, MigrationsReportEntry, SqliteDb, UnexpectedError } from '../adapter-types.js'
+import { SqliteAst, SqliteDsl } from '../schema/db-schema/mod.js'
 import type { LiveStoreSchema } from '../schema/mod.js'
 import type { SchemaMetaRow, SchemaMutationsMetaRow } from '../schema/system-tables.js'
 import {
@@ -19,7 +19,7 @@ import { validateSchema } from './validate-mutation-defs.js'
 
 const getMemoizedTimestamp = memoizeByStringifyArgs(() => new Date().toISOString())
 
-export const makeSchemaManager = (db: SynchronousDatabase): Effect.Effect<SchemaManager> =>
+export const makeSchemaManager = (db: SqliteDb): Effect.Effect<SchemaManager> =>
   Effect.gen(function* () {
     yield* migrateTable({
       db,
@@ -51,10 +51,10 @@ export const migrateDb = ({
   schema,
   onProgress,
 }: {
-  db: SynchronousDatabase
+  db: SqliteDb
   schema: LiveStoreSchema
   onProgress?: (opts: { done: number; total: number }) => Effect.Effect<void>
-}) =>
+}): Effect.Effect<MigrationsReport, UnexpectedError> =>
   Effect.gen(function* () {
     yield* migrateTable({
       db,
@@ -81,6 +81,7 @@ export const migrateDb = ({
 
     const tablesToMigrate = new Set<{ tableAst: SqliteAst.Table; schemaHash: number }>()
 
+    const migrationsReportEntries: MigrationsReportEntry[] = []
     for (const tableDef of tableDefs) {
       const tableAst = tableDef.sqliteDef.ast
       const tableName = tableAst.name
@@ -90,9 +91,10 @@ export const migrateDb = ({
       if (schemaHash !== dbSchemaHash) {
         tablesToMigrate.add({ tableAst, schemaHash })
 
-        console.log(
-          `Schema hash mismatch for table '${tableName}' (DB: ${dbSchemaHash}, expected: ${schemaHash}), migrating table...`,
-        )
+        migrationsReportEntries.push({
+          tableName,
+          hashes: { expected: schemaHash, actual: dbSchemaHash },
+        })
       }
     }
 
@@ -107,6 +109,8 @@ export const migrateDb = ({
         yield* onProgress({ done: processedTables, total: tablesCount })
       }
     }
+
+    return { migrations: migrationsReportEntries }
   })
 
 export const migrateTable = ({
@@ -116,7 +120,7 @@ export const migrateTable = ({
   behaviour,
   skipMetaTable = false,
 }: {
-  db: SynchronousDatabase
+  db: SqliteDb
   tableAst: SqliteAst.Table
   schemaHash?: number
   behaviour: 'drop-and-recreate' | 'create-if-not-exists'
@@ -129,10 +133,10 @@ export const migrateTable = ({
 
     if (behaviour === 'drop-and-recreate') {
       // TODO need to possibly handle cascading deletes due to foreign keys
-      dbExecute(db, sql`drop table if exists ${tableName}`)
-      dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec}) strict`)
+      dbExecute(db, sql`drop table if exists '${tableName}'`)
+      dbExecute(db, sql`create table if not exists '${tableName}' (${columnSpec}) strict`)
     } else if (behaviour === 'create-if-not-exists') {
-      dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec}) strict`)
+      dbExecute(db, sql`create table if not exists '${tableName}' (${columnSpec}) strict`)
     }
 
     for (const index of tableAst.indexes) {
@@ -162,11 +166,11 @@ export const migrateTable = ({
 
 const createIndexFromDefinition = (tableName: string, index: SqliteAst.Index) => {
   const uniqueStr = index.unique ? 'UNIQUE' : ''
-  return sql`create ${uniqueStr} index if not exists ${index.name} on ${tableName} (${index.columns.join(', ')})`
+  return sql`create ${uniqueStr} index if not exists '${index.name}' on '${tableName}' (${index.columns.join(', ')})`
 }
 
 export const makeColumnSpec = (tableAst: SqliteAst.Table) => {
-  const primaryKeys = tableAst.columns.filter((_) => _.primaryKey).map((_) => _.name)
+  const primaryKeys = tableAst.columns.filter((_) => _.primaryKey).map((_) => `'${_.name}'`)
   const columnDefStrs = tableAst.columns.map(toSqliteColumnSpec)
   if (primaryKeys.length > 0) {
     columnDefStrs.push(`PRIMARY KEY (${primaryKeys.join(', ')})`)
@@ -191,5 +195,5 @@ const toSqliteColumnSpec = (column: SqliteAst.Column) => {
     return `default ${encodedDefaultValue}`
   })()
 
-  return `${column.name} ${columnTypeStr} ${nullableStr} ${defaultValueStr}`
+  return `'${column.name}' ${columnTypeStr} ${nullableStr} ${defaultValueStr}`
 }

package/src/schema-management/validate-mutation-defs.ts

@@ -11,7 +11,7 @@ export const validateSchema = (schema: LiveStoreSchema, schemaManager: SchemaMan
     const registeredMutationDefInfos = schemaManager.getMutationDefInfos()
 
     const missingMutationDefs = registeredMutationDefInfos.filter(
-      (registeredMutationDefInfo) => !schema.mutations.has(registeredMutationDefInfo.mutationName),
+      (registeredMutationDefInfo) => !schema.mutations.map.has(registeredMutationDefInfo.mutationName),
     )
 
     if (missingMutationDefs.length > 0) {
@@ -20,7 +20,7 @@ export const validateSchema = (schema: LiveStoreSchema, schemaManager: SchemaMan
       })
     }
 
-    for (const [, mutationDef] of schema.mutations) {
+    for (const [, mutationDef] of schema.mutations.map) {
       const registeredMutationDefInfo = registeredMutationDefInfos.find(
         (info) => info.mutationName === mutationDef.name,
       )

package/src/sql-queries/sql-queries.ts

@@ -1,7 +1,7 @@
-import type { SqliteDsl } from '@livestore/db-schema'
 import { shouldNeverHappen } from '@livestore/utils'
 import { pipe, ReadonlyArray, Schema, TreeFormatter } from '@livestore/utils/effect'
 
+import type { SqliteDsl } from '../schema/db-schema/mod.js'
 import { sql } from '../util.js'
 import { objectEntries } from './misc.js'
 import * as ClientTypes from './types.js'

package/src/sql-queries/sql-query-builder.ts

@@ -1,5 +1,4 @@
-import type { SqliteDsl } from '@livestore/db-schema'
-
+import type { SqliteDsl } from '../schema/db-schema/mod.js'
 import type { BindValues } from './sql-queries.js'
 import * as SqlQueries from './sql-queries.js'
 import type * as ClientTypes from './types.js'

package/src/sql-queries/types.ts

@@ -1,6 +1,8 @@
-import type { Prettify, SqliteDsl } from '@livestore/db-schema'
+import type { Prettify } from '@livestore/utils'
 import type { Schema } from '@livestore/utils/effect'
 
+import type { SqliteDsl } from '../schema/db-schema/mod.js'
+
 export type DecodedValuesForTableAll<TSchema extends SqliteDsl.DbSchema, TTableName extends keyof TSchema> = {
   [K in keyof GetColumns<TSchema, TTableName>]: Schema.Schema.Type<GetColumn<TSchema, TTableName, K>['schema']>
 }

package/src/sync/ClientSessionSyncProcessor.ts

@@ -0,0 +1,313 @@
+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'
+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 SyncState from './syncstate.js'
+
+/**
+ * Rebase behaviour:
+ * - We continously pull mutations 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 might need to make the rebase behaviour configurable e.g. to let users manually trigger a rebase
+ */
+export const makeClientSessionSyncProcessor = ({
+  schema,
+  clientSession,
+  runtime,
+  applyMutation,
+  rollback,
+  refreshTables,
+  span,
+  params,
+  confirmUnsavedChanges,
+}: {
+  schema: LiveStoreSchema
+  clientSession: ClientSession
+  runtime: Runtime.Runtime<Scope.Scope>
+  applyMutation: (
+    mutationEventDecoded: MutationEvent.PartialAnyDecoded,
+    options: { otelContext: otel.Context; withChangeset: boolean },
+  ) => {
+    writeTables: Set<string>
+    sessionChangeset: Uint8Array | undefined
+  }
+  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 syncStateRef = {
+    current: new SyncState.SyncState({
+      localHead: clientSession.leaderThread.initialState.leaderHead,
+      upstreamHead: clientSession.leaderThread.initialState.leaderHead,
+      pending: [],
+      // TODO init rollbackTail from leader to be ready for backend rebasing
+      rollbackTail: [],
+    }),
+  }
+
+  const syncStateUpdateQueue = Queue.unbounded<SyncState.SyncState>().pipe(Effect.runSync)
+  const isLocalEvent = (mutationEventEncoded: MutationEvent.EncodedWithMeta) =>
+    getMutationDef(schema, mutationEventEncoded.mutation).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 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)
+      baseEventId = nextIdPair.id
+      return new MutationEvent.EncodedWithMeta(
+        Schema.encodeUnknownSync(mutationEventSchema)({
+          ...mutationEvent,
+          ...nextIdPair,
+          clientId: clientSession.clientId,
+          sessionId: clientSession.sessionId,
+        }),
+      )
+    })
+
+    const updateResult = SyncState.updateSyncState({
+      syncState: syncStateRef.current,
+      payload: { _tag: 'local-push', newEvents: encodedMutationEvents },
+      isLocalEvent,
+      isEqualEvent: MutationEvent.isEqualEncoded,
+    })
+
+    if (updateResult._tag === 'unexpected-error') {
+      return shouldNeverHappen('Unexpected error in client-session-sync-processor', updateResult.cause)
+    }
+
+    span.addEvent('local-push', {
+      batchSize: encodedMutationEvents.length,
+      updateResult: TRACE_VERBOSE ? JSON.stringify(updateResult) : undefined,
+    })
+
+    if (updateResult._tag !== 'advance') {
+      return shouldNeverHappen(`Expected advance, got ${updateResult._tag}`)
+    }
+
+    syncStateRef.current = updateResult.newSyncState
+    syncStateUpdateQueue.offer(updateResult.newSyncState).pipe(Effect.runSync)
+
+    const writeTables = new Set<string>()
+    for (const mutationEvent of updateResult.newEvents) {
+      // TODO avoid encoding and decoding here again
+      const decodedMutationEvent = Schema.decodeSync(mutationEventSchema)(mutationEvent)
+      const res = applyMutation(decodedMutationEvent, { otelContext, withChangeset: true })
+      for (const table of res.writeTables) {
+        writeTables.add(table)
+      }
+      mutationEvent.meta.sessionChangeset = res.sessionChangeset
+    }
+
+    // console.debug('pushToLeader', encodedMutationEvents.length, ...encodedMutationEvents.map((_) => _.toJSON()))
+    BucketQueue.offerAll(leaderPushQueue, encodedMutationEvents).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* () {
+    // 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.mutations.push(batch).pipe(
+        Effect.catchTag('LeaderAheadError', () => {
+          debugInfo.rejectCount++
+          return BucketQueue.clear(leaderPushQueue)
+        }),
+      )
+    }).pipe(Effect.forever, Effect.interruptible, Effect.tapCauseLogPretty)
+
+    yield* FiberHandle.run(leaderPushingFiberHandle, backgroundLeaderPushing)
+
+    yield* clientSession.leaderThread.mutations.pull.pipe(
+      Stream.tap(({ payload, remaining }) =>
+        Effect.gen(function* () {
+          // console.log('pulled payload from leader', { payload, remaining })
+          if (clientSession.devtools.enabled) {
+            yield* clientSession.devtools.pullLatch.await
+          }
+
+          const updateResult = SyncState.updateSyncState({
+            syncState: syncStateRef.current,
+            payload,
+            isLocalEvent,
+            isEqualEvent: MutationEvent.isEqualEncoded,
+          })
+
+          if (updateResult._tag === 'unexpected-error') {
+            return yield* Effect.fail(updateResult.cause)
+          } else if (updateResult._tag === 'reject') {
+            return shouldNeverHappen('Unexpected reject in client-session-sync-processor', updateResult)
+          }
+
+          syncStateRef.current = updateResult.newSyncState
+          syncStateUpdateQueue.offer(updateResult.newSyncState).pipe(Effect.runSync)
+
+          if (updateResult._tag === 'rebase') {
+            span.addEvent('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,
+            })
+
+            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) {
+              Effect.logDebug(
+                'pull:rebase: rollback',
+                updateResult.eventsToRollback.length,
+                ...updateResult.eventsToRollback.slice(0, 10).map((_) => _.toJSON()),
+              ).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
+              }
+            }
+
+            yield* BucketQueue.offerAll(leaderPushQueue, updateResult.newSyncState.pending)
+          } else {
+            span.addEvent('pull:advance', {
+              payloadTag: payload._tag,
+              payload: TRACE_VERBOSE ? JSON.stringify(payload) : undefined,
+              newEventsCount: updateResult.newEvents.length,
+              res: TRACE_VERBOSE ? JSON.stringify(updateResult) : undefined,
+              remaining,
+            })
+
+            debugInfo.advanceCount++
+          }
+
+          if (updateResult.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 table of res.writeTables) {
+              writeTables.add(table)
+            }
+
+            mutationEvent.meta.sessionChangeset = res.sessionChangeset
+          }
+
+          refreshTables(writeTables)
+        }).pipe(
+          Effect.tapCauseLogPretty,
+          Effect.catchAllCause((cause) => Effect.sync(() => clientSession.shutdown(cause))),
+        ),
+      ),
+      Stream.runDrain,
+      Effect.forever, // NOTE Whenever the leader changes, we need to re-start the stream
+      Effect.withSpan('client-session-sync-processor:pull'),
+      Effect.tapCauseLogPretty,
+      Effect.forkScoped,
+    )
+  })
+
+  return {
+    push,
+    boot,
+    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>,
+    options: { otelContext: otel.Context },
+  ) => {
+    writeTables: Set<string>
+  }
+  boot: Effect.Effect<void, UnexpectedError, Scope.Scope>
+  syncState: Subscribable.Subscribable<SyncState.SyncState>
+  debug: {
+    print: () => void
+    debugInfo: () => {
+      rebaseCount: number
+      advanceCount: number
+    }
+  }
+}

package/src/sync/index.ts

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

package/src/sync/next/facts.ts

@@ -231,5 +231,5 @@ export const compareEventIds = (a: EventId.EventId, b: EventId.EventId) => {
   if (a.global !== b.global) {
     return a.global - b.global
   }
-  return a.local - b.local
+  return a.client - b.client
 }

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

@@ -20,7 +20,7 @@ export const emptyHistoryDag = (): HistoryDag =>
   })
 
 // TODO consider making `ROOT_ID` parent to itself
-export const rootParentId = { global: EventId.ROOT.global - 1, local: 0 } satisfies EventId.EventId
+export const rootParentId = EventId.make({ global: EventId.ROOT.global - 1, client: EventId.clientDefault })
 
 export type HistoryDagNode = {
   id: EventId.EventId
@@ -30,6 +30,8 @@ export type HistoryDagNode = {
   /** Facts are being used for conflict detection and history compaction */
   factsGroup: MutationEventFactsGroup
   meta?: any
+  clientId: string
+  sessionId: string | undefined
 }
 
 export const rootEventNode: HistoryDagNode = {
@@ -39,6 +41,8 @@ export const rootEventNode: HistoryDagNode = {
   mutation: '__Root__',
   args: {},
   factsGroup: { modifySet: new Map(), modifyUnset: new Map(), depRequire: new Map(), depRead: new Map() },
+  clientId: 'root',
+  sessionId: undefined,
 }
 
 export const EMPTY_FACT_VALUE = Symbol('EMPTY_FACT_VALUE')

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

@@ -3,7 +3,7 @@ import { factsToString, validateFacts } from './facts.js'
 import { emptyHistoryDag, type HistoryDagNode, rootParentId } from './history-dag-common.js'
 
 export const eventIdToString = (eventId: EventId.EventId) =>
-  eventId.local === 0 ? eventId.global.toString() : `${eventId.global}.${eventId.local}`
+  eventId.client === 0 ? eventId.global.toString() : `${eventId.global}.${eventId.client}`
 
 export const historyDagFromNodes = (dagNodes: HistoryDagNode[], options?: { skipFactsCheck: boolean }) => {
   if (options?.skipFactsCheck !== true) {

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

@@ -1,4 +1,4 @@
-import type * as EventId from '../../schema/EventId.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 {
@@ -19,13 +19,13 @@ export type RebaseInput = {
   newRemoteEvents: RebaseEventWithConflict[]
   pendingLocalEvents: RebaseEventWithConflict[]
   validate: (args: {
-    rebasedLocalEvents: MutationEvent.PartialAny[]
+    rebasedLocalEvents: MutationEvent.PartialAnyDecoded[]
     mutationDefs: Record<string, MutationDef.Any>
   }) => FactValidationResult
 }
 
 export type RebaseOutput = {
-  rebasedLocalEvents: MutationEvent.PartialAny[]
+  rebasedLocalEvents: MutationEvent.PartialAnyDecoded[]
 }
 
 export type RebaseFn = (input: RebaseInput) => RebaseOutput
@@ -43,12 +43,16 @@ export const rebaseEvents = ({
   pendingLocalEvents,
   newRemoteEvents,
   currentFactsSnapshot,
+  clientId,
+  sessionId,
 }: {
   pendingLocalEvents: HistoryDagNode[]
   newRemoteEvents: HistoryDagNode[]
   rebaseFn: RebaseFn
   currentFactsSnapshot: MutationEventFactsSnapshot
-}): MutationEvent.Any[] => {
+  clientId: string
+  sessionId: string | undefined
+}): ReadonlyArray<MutationEvent.AnyDecoded> => {
   const initialSnapshot = new Map(currentFactsSnapshot)
   applyFactGroups(
     newRemoteEvents.map((event) => event.factsGroup),
@@ -89,10 +93,12 @@ export const rebaseEvents = ({
   return rebasedLocalEvents.map(
     (event, index) =>
       ({
-        id: { global: headGlobalId + index + 1, local: 0 } satisfies EventId.EventId,
-        parentId: { global: headGlobalId + index, local: 0 } satisfies EventId.EventId,
+        id: EventId.make({ global: headGlobalId + index + 1, client: EventId.clientDefault }),
+        parentId: EventId.make({ global: headGlobalId + index, client: EventId.clientDefault }),
         mutation: event.mutation,
         args: event.args,
-      }) satisfies MutationEvent.Any,
+        clientId,
+        sessionId,
+      }) satisfies MutationEvent.AnyDecoded,
   )
 }

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

@@ -10,7 +10,7 @@ import { toEventNodes } from './mutation-fixtures.js'
 expect.addSnapshotSerializer(customSerializer)
 
 const compact = (events: any[]) => {
-  const dag = historyDagFromNodes(toEventNodes(events, mutations))
+  const dag = historyDagFromNodes(toEventNodes(events, mutations, 'client-id', 'session-id'))
   const compacted = compactEvents(dag)
 
   return Array.from(compacted.dag.nodeEntries())
@@ -50,8 +50,8 @@ describe('compactEvents calculator', () => {
 
     expect(expected).toMatchInlineSnapshot(`
       [
-        { id: 0, parentId: -1, mutation: "add", args: { value: 1 }, facts: "" }
-        { id: 1, parentId: 0, mutation: "add", args: { value: 1 }, facts: "" }
+        { id: 0, parentId: -1, mutation: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
+        { id: 1, parentId: 0, mutation: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
       ]
     `)
   })
@@ -64,8 +64,8 @@ describe('compactEvents calculator', () => {
 
     expect(expected).toMatchInlineSnapshot(`
       [
-        { id: 0, parentId: -1, mutation: "multiply", args: { value: 2 }, facts: "?multiplyByZero -multiplyByZero" }
-        { id: 1, parentId: 0, mutation: "multiply", args: { value: 2 }, facts: "?multiplyByZero -multiplyByZero" }
+        { id: 0, parentId: -1, mutation: "multiply", args: { value: 2 }, clientId: "client-id", sessionId: "session-id", facts: "?multiplyByZero -multiplyByZero" }
+        { id: 1, parentId: 0, mutation: "multiply", args: { value: 2 }, clientId: "client-id", sessionId: "session-id", facts: "?multiplyByZero -multiplyByZero" }
       ]
     `)
   })
@@ -79,7 +79,7 @@ describe('compactEvents calculator', () => {
 
     expect(expected).toMatchInlineSnapshot(`
       [
-        { id: 2, parentId: -1, mutation: "multiply", args: { value: 0 }, facts: "+multiplyByZero" }
+        { id: 2, parentId: -1, mutation: "multiply", args: { value: 0 }, clientId: "client-id", sessionId: "session-id", facts: "+multiplyByZero" }
       ]
     `)
   })
@@ -94,8 +94,8 @@ describe('compactEvents calculator', () => {
 
     expect(expected).toMatchInlineSnapshot(`
       [
-        { id: 2, parentId: -1, mutation: "multiply", args: { value: 0 }, facts: "+multiplyByZero" }
-        { id: 3, parentId: 2, mutation: "add", args: { value: 1 }, facts: "" }
+        { id: 2, parentId: -1, mutation: "multiply", args: { value: 0 }, clientId: "client-id", sessionId: "session-id", facts: "+multiplyByZero" }
+        { id: 3, parentId: 2, mutation: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
       ]
     `)
   })
@@ -111,10 +111,10 @@ describe('compactEvents calculator', () => {
 
     expect(expected).toMatchInlineSnapshot(`
       [
-        { id: 0, parentId: -1, mutation: "add", args: { value: 1 }, facts: "" }
-        { id: 2, parentId: 0, mutation: "multiply", args: { value: 0 }, facts: "+multiplyByZero" }
-        { id: 3, parentId: 2, mutation: "multiply", args: { value: 2 }, facts: "?multiplyByZero +multiplyByZero -multiplyByZero" }
-        { id: 4, parentId: 3, mutation: "add", args: { value: 1 }, facts: "" }
+        { id: 0, parentId: -1, mutation: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
+        { id: 2, parentId: 0, mutation: "multiply", args: { value: 0 }, clientId: "client-id", sessionId: "session-id", facts: "+multiplyByZero" }
+        { id: 3, parentId: 2, mutation: "multiply", args: { value: 2 }, clientId: "client-id", sessionId: "session-id", facts: "?multiplyByZero +multiplyByZero -multiplyByZero" }
+        { id: 4, parentId: 3, mutation: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
       ]
     `)
   })