@livestore/common 0.0.0-snapshot-aed277ba0960f72b8d464508961ab4aec1881230 → 0.0.0-snapshot-7bcbc24bb8873481e482d982636957f0c1f791f6

package/src/leader-thread/types.ts

@@ -16,6 +16,7 @@ import type {
   Devtools,
   InvalidPushError,
   MakeSqliteDb,
+  MigrationsReport,
   PersistenceInfo,
   SqliteDb,
   SyncBackend,
@@ -31,7 +32,7 @@ export const InitialSyncOptionsSkip = Schema.TaggedStruct('Skip', {})
 export type InitialSyncOptionsSkip = typeof InitialSyncOptionsSkip.Type
 
 export const InitialSyncOptionsBlocking = Schema.TaggedStruct('Blocking', {
-  timeout: Schema.DurationFromMillis,
+  timeout: Schema.Union(Schema.DurationFromMillis, Schema.Number),
 })
 
 export type InitialSyncOptionsBlocking = typeof InitialSyncOptionsBlocking.Type
@@ -70,8 +71,10 @@ export type DevtoolsOptions =
 export type DevtoolsContext =
   | {
       enabled: true
-      syncBackendPullLatch: Effect.Latch
-      syncBackendPushLatch: Effect.Latch
+      // syncBackendPullLatch: Effect.Latch
+      // syncBackendPushLatch: Effect.Latch
+      syncBackendLatch: Effect.Latch
+      syncBackendLatchState: SubscriptionRef.SubscriptionRef<{ latchClosed: boolean }>
     }
   | {
       enabled: false
@@ -95,6 +98,10 @@ export class LeaderThreadCtx extends Context.Tag('LeaderThreadCtx')<
     syncBackend: SyncBackend | undefined
     syncProcessor: LeaderSyncProcessor
     connectedClientSessionPullQueues: PullQueueSet
+    initialState: {
+      leaderHead: EventId.EventId
+      migrationsReport: MigrationsReport
+    }
     /**
      * e.g. used for `store._dev` APIs
      *
@@ -127,10 +134,18 @@ export interface LeaderSyncProcessor {
     },
   ) => Effect.Effect<void, InvalidPushError>
 
-  pushPartial: (mutationEvent: MutationEvent.PartialAnyEncoded) => Effect.Effect<void, UnexpectedError, LeaderThreadCtx>
+  pushPartial: (args: {
+    mutationEvent: MutationEvent.PartialAnyEncoded
+    clientId: string
+    sessionId: string | undefined
+  }) => Effect.Effect<void, UnexpectedError, LeaderThreadCtx>
   boot: (args: {
     dbReady: Deferred.Deferred<void>
-  }) => Effect.Effect<void, UnexpectedError, LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient>
+  }) => Effect.Effect<
+    { initialLeaderHead: EventId.EventId },
+    UnexpectedError,
+    LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient
+  >
   syncState: Subscribable.Subscribable<SyncState.SyncState>
 }
 

package/src/rehydrate-from-mutationlog.ts

@@ -60,10 +60,12 @@ This likely means the schema has changed in an incompatible way.
         )
 
         const mutationEventEncoded = {
-          id: { global: row.idGlobal, local: row.idLocal },
-          parentId: { global: row.parentIdGlobal, local: row.parentIdLocal },
+          id: { global: row.idGlobal, client: row.idClient },
+          parentId: { global: row.parentIdGlobal, client: row.parentIdClient },
           mutation: row.mutation,
           args,
+          clientId: row.clientId,
+          sessionId: row.sessionId ?? undefined,
         } satisfies MutationEvent.AnyEncoded
 
         yield* applyMutation(mutationEventEncoded, { skipMutationLog: true })
@@ -73,8 +75,8 @@ This likely means the schema has changed in an incompatible way.
 
     const stmt = logDb.prepare(sql`\
 SELECT * FROM ${MUTATION_LOG_META_TABLE} 
-WHERE idGlobal > $idGlobal OR (idGlobal = $idGlobal AND idLocal > $idLocal)
-ORDER BY idGlobal ASC, idLocal ASC
+WHERE idGlobal > $idGlobal OR (idGlobal = $idGlobal AND idClient > $idClient)
+ORDER BY idGlobal ASC, idClient ASC
 LIMIT ${CHUNK_SIZE}
 `)
 
@@ -88,14 +90,14 @@ LIMIT ${CHUNK_SIZE}
 
         const lastId = Chunk.isChunk(item)
           ? Chunk.last(item).pipe(
-              Option.map((_) => ({ global: _.idGlobal, local: _.idLocal })),
+              Option.map((_) => ({ global: _.idGlobal, client: _.idClient })),
               Option.getOrElse(() => EventId.ROOT),
             )
           : EventId.ROOT
         const nextItem = Chunk.fromIterable(
           stmt.select<MutationLogMetaRow>({
             $idGlobal: lastId?.global,
-            $idLocal: lastId?.local,
+            $idClient: lastId?.client,
           } as any as PreparedBindValues),
         )
         const prevItem = Chunk.isChunk(item) ? item : Chunk.empty()

package/src/schema/EventId.test.ts

@@ -5,8 +5,8 @@ import { EventId } from './mod.js'
 
 Vitest.describe('EventId', () => {
   Vitest.test('nextPair', () => {
-    const e_0_0 = EventId.make({ global: 0, local: 0 })
-    expect(EventId.nextPair(e_0_0, false).id).toStrictEqual({ global: 1, local: 0 })
-    expect(EventId.nextPair(e_0_0, true).id).toStrictEqual({ global: 0, local: 1 })
+    const e_0_0 = EventId.make({ global: 0, client: 0 })
+    expect(EventId.nextPair(e_0_0, false).id).toStrictEqual({ global: 1, client: 0 })
+    expect(EventId.nextPair(e_0_0, true).id).toStrictEqual({ global: 0, client: 1 })
   })
 })

package/src/schema/EventId.ts

@@ -1,26 +1,26 @@
 import { Brand, Schema } from '@livestore/utils/effect'
 
-export type LocalEventId = Brand.Branded<number, 'LocalEventId'>
-export const localEventId = Brand.nominal<LocalEventId>()
-export const LocalEventId = Schema.fromBrand(localEventId)(Schema.Int)
+export type ClientEventId = Brand.Branded<number, 'ClientEventId'>
+export const localEventId = Brand.nominal<ClientEventId>()
+export const ClientEventId = Schema.fromBrand(localEventId)(Schema.Int)
 
 export type GlobalEventId = Brand.Branded<number, 'GlobalEventId'>
 export const globalEventId = Brand.nominal<GlobalEventId>()
 export const GlobalEventId = Schema.fromBrand(globalEventId)(Schema.Int)
 
-export const localDefault = 0 as any as LocalEventId
+export const clientDefault = 0 as any as ClientEventId
 
 /**
  * LiveStore event id value consisting of a globally unique event sequence number
- * and a local sequence number.
+ * and a client sequence number.
  *
- * The local sequence number is only used for localOnly mutations and starts from 0 for each global sequence number.
+ * The client sequence number is only used for clientOnly mutations and starts from 0 for each global sequence number.
  */
-export type EventId = { global: GlobalEventId; local: LocalEventId }
+export type EventId = { global: GlobalEventId; client: ClientEventId }
 
 export const EventId = Schema.Struct({
   global: GlobalEventId,
-  local: LocalEventId,
+  client: ClientEventId,
 }).annotations({ title: 'LiveStore.EventId' })
 
 /**
@@ -30,17 +30,21 @@ export const compare = (a: EventId, b: EventId) => {
   if (a.global !== b.global) {
     return a.global - b.global
   }
-  return a.local - b.local
+  return a.client - b.client
 }
 
-export const isEqual = (a: EventId, b: EventId) => a.global === b.global && a.local === b.local
+export const isEqual = (a: EventId, b: EventId) => a.global === b.global && a.client === b.client
 
 export type EventIdPair = { id: EventId; parentId: EventId }
 
-export const ROOT = { global: -1 as any as GlobalEventId, local: localDefault } satisfies EventId
+export const ROOT = { global: -1 as any as GlobalEventId, client: clientDefault } satisfies EventId
 
 export const isGreaterThan = (a: EventId, b: EventId) => {
-  return a.global > b.global || (a.global === b.global && a.local > b.local)
+  return a.global > b.global || (a.global === b.global && a.client > b.client)
+}
+
+export const isGreaterThanOrEqual = (a: EventId, b: EventId) => {
+  return a.global > b.global || (a.global === b.global && a.client >= b.client)
 }
 
 export const make = (id: EventId | typeof EventId.Encoded): EventId => {
@@ -49,12 +53,12 @@ export const make = (id: EventId | typeof EventId.Encoded): EventId => {
 
 export const nextPair = (id: EventId, isLocal: boolean): EventIdPair => {
   if (isLocal) {
-    return { id: { global: id.global, local: (id.local + 1) as any as LocalEventId }, parentId: id }
+    return { id: { global: id.global, client: (id.client + 1) as any as ClientEventId }, parentId: id }
   }
 
   return {
-    id: { global: (id.global + 1) as any as GlobalEventId, local: localDefault },
-    // NOTE we always point to `local: 0` for non-localOnly mutations
-    parentId: { global: id.global, local: localDefault },
+    id: { global: (id.global + 1) as any as GlobalEventId, client: clientDefault },
+    // NOTE we always point to `client: 0` for non-clientOnly mutations
+    parentId: { global: id.global, client: clientDefault },
   }
 }

package/src/schema/MutationEvent.ts

@@ -10,7 +10,7 @@ export type MutationEventPartial<TMutationsDef extends MutationDef.Any> = {
   args: Schema.Schema.Type<TMutationsDef['schema']>
 }
 
-export type MutationEventPartialEncoded<TMutationsDef extends MutationDef.Any> = {
+export type PartialEncoded<TMutationsDef extends MutationDef.Any> = {
   mutation: TMutationsDef['name']
   args: Schema.Schema.Encoded<TMutationsDef['schema']>
 }
@@ -20,6 +20,8 @@ export type MutationEvent<TMutationsDef extends MutationDef.Any> = {
   args: Schema.Schema.Type<TMutationsDef['schema']>
   id: EventId.EventId
   parentId: EventId.EventId
+  clientId: string
+  sessionId: string | undefined
 }
 
 export type MutationEventEncoded<TMutationsDef extends MutationDef.Any> = {
@@ -27,6 +29,8 @@ export type MutationEventEncoded<TMutationsDef extends MutationDef.Any> = {
   args: Schema.Schema.Encoded<TMutationsDef['schema']>
   id: EventId.EventId
   parentId: EventId.EventId
+  clientId: string
+  sessionId: string | undefined
 }
 
 export type AnyDecoded = MutationEvent<MutationDef.Any>
@@ -35,6 +39,8 @@ export const AnyDecoded = Schema.Struct({
   args: Schema.Any,
   id: EventId.EventId,
   parentId: EventId.EventId,
+  clientId: Schema.String,
+  sessionId: Schema.UndefinedOr(Schema.String),
 }).annotations({ title: 'MutationEvent.AnyDecoded' })
 
 export type AnyEncoded = MutationEventEncoded<MutationDef.Any>
@@ -43,6 +49,8 @@ export const AnyEncoded = Schema.Struct({
   args: Schema.Any,
   id: EventId.EventId,
   parentId: EventId.EventId,
+  clientId: Schema.String,
+  sessionId: Schema.UndefinedOr(Schema.String),
 }).annotations({ title: 'MutationEvent.AnyEncoded' })
 
 export const AnyEncodedGlobal = Schema.Struct({
@@ -50,11 +58,17 @@ export const AnyEncodedGlobal = Schema.Struct({
   args: Schema.Any,
   id: EventId.GlobalEventId,
   parentId: EventId.GlobalEventId,
+  clientId: Schema.String,
 }).annotations({ title: 'MutationEvent.AnyEncodedGlobal' })
 export type AnyEncodedGlobal = typeof AnyEncodedGlobal.Type
 
 export type PartialAnyDecoded = MutationEventPartial<MutationDef.Any>
-export type PartialAnyEncoded = MutationEventPartialEncoded<MutationDef.Any>
+export type PartialAnyEncoded = PartialEncoded<MutationDef.Any>
+
+export const PartialAnyEncoded = Schema.Struct({
+  mutation: Schema.String,
+  args: Schema.Any,
+})
 
 export type PartialForSchema<TSchema extends LiveStoreSchema> = {
   [K in keyof TSchema['_MutationDefMapType']]: MutationEventPartial<TSchema['_MutationDefMapType'][K]>
@@ -75,6 +89,8 @@ export type ForMutationDefRecord<TMutationsDefRecord extends MutationDefRecord>
       args: Schema.Schema.Type<TMutationsDefRecord[K]['schema']>
       id: EventId.EventId
       parentId: EventId.EventId
+      clientId: string
+      sessionId: string | undefined
     }
   }[keyof TMutationsDefRecord],
   {
@@ -83,6 +99,8 @@ export type ForMutationDefRecord<TMutationsDefRecord extends MutationDefRecord>
       args: Schema.Schema.Encoded<TMutationsDefRecord[K]['schema']>
       id: EventId.EventId
       parentId: EventId.EventId
+      clientId: string
+      sessionId: string | undefined
     }
   }[keyof TMutationsDefRecord]
 >
@@ -112,6 +130,8 @@ export const makeMutationEventSchema = <TSchema extends LiveStoreSchema>(
         args: def.schema,
         id: EventId.EventId,
         parentId: EventId.EventId,
+        clientId: Schema.String,
+        sessionId: Schema.UndefinedOr(Schema.String),
       }),
     ),
   ).annotations({ title: 'MutationEvent' }) as any
@@ -136,6 +156,8 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEven
   args: Schema.Any,
   id: EventId.EventId,
   parentId: EventId.EventId,
+  clientId: Schema.String,
+  sessionId: Schema.UndefinedOr(Schema.String),
   // TODO get rid of `meta` again by cleaning up the usage implementations
   meta: Schema.optionalWith(
     Schema.Any as Schema.Schema<{
@@ -149,7 +171,7 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEven
     // - More readable way to print the id + parentId
     // - not including `meta`
     return {
-      id: `(${this.id.global},${this.id.local}) → (${this.parentId.global},${this.parentId.local})`,
+      id: `(${this.id.global},${this.id.client}) → (${this.parentId.global},${this.parentId.client})`,
       mutation: this.mutation,
       args: this.args,
     }
@@ -164,8 +186,9 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEven
   static fromGlobal = (mutationEvent: AnyEncodedGlobal) =>
     new EncodedWithMeta({
       ...mutationEvent,
-      id: { global: mutationEvent.id, local: EventId.localDefault },
-      parentId: { global: mutationEvent.parentId, local: EventId.localDefault },
+      id: { global: mutationEvent.id, client: EventId.clientDefault },
+      parentId: { global: mutationEvent.parentId, client: EventId.clientDefault },
+      sessionId: undefined,
     })
 
   toGlobal = (): AnyEncodedGlobal => ({
@@ -177,7 +200,9 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEven
 
 export const isEqualEncoded = (a: AnyEncoded, b: AnyEncoded) =>
   a.id.global === b.id.global &&
-  a.id.local === b.id.local &&
+  a.id.client === b.id.client &&
   a.mutation === b.mutation &&
+  a.clientId === b.clientId &&
+  // a.sessionId === b.sessionId &&
   // TODO use schema equality here
   JSON.stringify(a.args) === JSON.stringify(b.args)

package/src/schema/mutations.ts

@@ -1,7 +1,6 @@
 import { Schema } from '@livestore/utils/effect'
 
 import type { BindValues } from '../sql-queries/sql-queries.js'
-import type * as EventId from './EventId.js'
 
 export type MutationDefMap = Map<string | 'livestore.RawSql', MutationDef.Any>
 export type MutationDefRecord = {
@@ -38,24 +37,17 @@ export type MutationDef<TName extends string, TFrom, TTo> = {
     /** Warning: This feature is not fully implemented yet */
     historyId: string
     /**
-     * When set to true, the mutation won't be synced over the network
+     * When set to true, the mutation won't be synced across clients but
      */
-    localOnly: boolean
+    clientOnly: boolean
     /** Warning: This feature is not fully implemented yet */
     facts: FactsCallback<TTo> | undefined
   }
 
   /** Helper function to construct a partial mutation event */
-  (
-    args: TTo,
-    options?: {
-      id?: number
-    },
-  ): {
+  (args: TTo): {
     mutation: TName
     args: TTo
-    // TODO remove/clean up after sync-next is fully implemented
-    id?: EventId.EventId
   }
 }
 
@@ -120,7 +112,7 @@ export type DefineMutationOptions<TTo> = {
   /**
    * When set to true, the mutation won't be synced over the network
    */
-  localOnly?: boolean
+  clientOnly?: boolean
 }
 
 // TODO possibly also allow for mutation event subsumption behaviour
@@ -130,12 +122,7 @@ export const defineMutation = <TName extends string, TFrom, TTo>(
   sql: MutationDefSqlResult<NoInfer<TTo>>,
   options?: DefineMutationOptions<TTo>,
 ): MutationDef<TName, TFrom, TTo> => {
-  const makePartialEvent = (
-    args: TTo,
-    options?: {
-      id?: EventId.EventId
-    },
-  ) => ({ mutation: name, args, ...options })
+  const makePartialEvent = (args: TTo) => ({ mutation: name, args })
 
   Object.defineProperty(makePartialEvent, 'name', { value: name })
   Object.defineProperty(makePartialEvent, 'schema', { value: schema })
@@ -143,7 +130,7 @@ export const defineMutation = <TName extends string, TFrom, TTo>(
   Object.defineProperty(makePartialEvent, 'options', {
     value: {
       historyId: options?.historyId ?? 'main',
-      localOnly: options?.localOnly ?? false,
+      clientOnly: options?.clientOnly ?? false,
       facts: options?.facts
         ? (args, currentFacts) => {
             const res = options.facts!(args, currentFacts)

package/src/schema/system-tables.ts

@@ -48,13 +48,13 @@ export const sessionChangesetMetaTable = table(
   {
     // TODO bring back primary key
     idGlobal: SqliteDsl.integer({ schema: EventId.GlobalEventId }),
-    idLocal: SqliteDsl.integer({ schema: EventId.LocalEventId }),
+    idClient: SqliteDsl.integer({ schema: EventId.ClientEventId }),
     changeset: SqliteDsl.blob({ nullable: true }),
     debug: SqliteDsl.json({ nullable: true }),
   },
   {
     disableAutomaticIdColumn: true,
-    indexes: [{ columns: ['idGlobal', 'idLocal'], name: 'idx_session_changeset_id' }],
+    indexes: [{ columns: ['idGlobal', 'idClient'], name: 'idx_session_changeset_id' }],
   },
 )
 
@@ -64,7 +64,7 @@ export const systemTables = [schemaMetaTable, schemaMutationsMetaTable, sessionC
 
 /// Mutation log DB
 
-export const SyncStatus = Schema.Literal('synced', 'pending', 'error', 'localOnly')
+export const SyncStatus = Schema.Literal('synced', 'pending', 'error', 'clientOnly')
 export type SyncStatus = typeof SyncStatus.Type
 
 export const MUTATION_LOG_META_TABLE = 'mutation_log'
@@ -73,11 +73,14 @@ export const mutationLogMetaTable = table(
   MUTATION_LOG_META_TABLE,
   {
     idGlobal: SqliteDsl.integer({ primaryKey: true, schema: EventId.GlobalEventId }),
-    idLocal: SqliteDsl.integer({ primaryKey: true, schema: EventId.LocalEventId }),
+    idClient: SqliteDsl.integer({ primaryKey: true, schema: EventId.ClientEventId }),
     parentIdGlobal: SqliteDsl.integer({ schema: EventId.GlobalEventId }),
-    parentIdLocal: SqliteDsl.integer({ schema: EventId.LocalEventId }),
+    parentIdClient: SqliteDsl.integer({ schema: EventId.ClientEventId }),
     mutation: SqliteDsl.text({}),
     argsJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Any) }),
+    clientId: SqliteDsl.text({}),
+    /** Only available for mutations which were executed in this client */
+    sessionId: SqliteDsl.text({ nullable: true }),
     schemaHash: SqliteDsl.integer({}),
     syncMetadataJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Option(Schema.JsonValue)) }),
   },
@@ -85,7 +88,7 @@ export const mutationLogMetaTable = table(
     disableAutomaticIdColumn: true,
     indexes: [
       { columns: ['idGlobal'], name: 'idx_idGlobal' },
-      { columns: ['idGlobal', 'idLocal'], name: 'idx_mutationlog_id' },
+      { columns: ['idGlobal', 'idClient'], name: 'idx_mutationlog_id' },
     ],
   },
 )

package/src/schema/table-def.ts

@@ -61,7 +61,7 @@ export type TableOptionsInput = Partial<{
     | boolean
     | {
         enabled: true
-        localOnly?: boolean
+        clientOnly?: boolean
       }
 }>
 
@@ -115,7 +115,7 @@ export type TableOptions = {
         /**
          * When set to true, the mutations won't be synced over the network
          */
-        localOnly: boolean
+        clientOnly: boolean
       }
 
   /** Derived based on whether the table definition has one or more columns (besides the `id` column) */
@@ -153,12 +153,12 @@ export const table = <
     disableAutomaticIdColumn: options?.disableAutomaticIdColumn ?? false,
     deriveMutations:
       options?.deriveMutations === true
-        ? { enabled: true as const, localOnly: false }
+        ? { enabled: true as const, clientOnly: false }
         : options?.deriveMutations === false
           ? { enabled: false as const }
           : options?.deriveMutations === undefined
             ? { enabled: false as const }
-            : { enabled: true as const, localOnly: options.deriveMutations.localOnly ?? false },
+            : { enabled: true as const, clientOnly: options.deriveMutations.clientOnly ?? false },
     isSingleColumn: SqliteDsl.isColumnDefinition(columnOrColumns) === true,
     requiredInsertColumnNames: 'type-level-only',
   }
@@ -234,7 +234,7 @@ export const table = <
 export const tableHasDerivedMutations = <TTableDef extends TableDefBase>(
   tableDef: TTableDef,
 ): tableDef is TTableDef & {
-  options: { deriveMutations: { enabled: true; localOnly: boolean } }
+  options: { deriveMutations: { enabled: true; clientOnly: boolean } }
 } & DerivedMutationHelperFns<TTableDef['sqliteDef']['columns'], TTableDef['options']> =>
   tableDef.options.deriveMutations.enabled === true
 
@@ -268,13 +268,13 @@ type WithDefaults<
   isSingleton: TOptionsInput['isSingleton'] extends true ? true : false
   disableAutomaticIdColumn: TOptionsInput['disableAutomaticIdColumn'] extends true ? true : false
   deriveMutations: TOptionsInput['deriveMutations'] extends true
-    ? { enabled: true; localOnly: boolean }
+    ? { enabled: true; clientOnly: boolean }
     : TOptionsInput['deriveMutations'] extends false
       ? { enabled: false }
-      : TOptionsInput['deriveMutations'] extends { enabled: true; localOnly?: boolean }
+      : TOptionsInput['deriveMutations'] extends { enabled: true; clientOnly?: boolean }
         ? {
             enabled: true
-            localOnly: TOptionsInput['deriveMutations']['localOnly'] extends true ? true : false
+            clientOnly: TOptionsInput['deriveMutations']['clientOnly'] extends true ? true : false
           }
         : never
   isSingleColumn: SqliteDsl.IsSingleColumn<TColumns>

package/src/schema-management/migrations.ts

@@ -2,7 +2,7 @@ import { SqliteAst, SqliteDsl } from '@livestore/db-schema'
 import { memoizeByStringifyArgs } from '@livestore/utils'
 import { Effect, Schema as EffectSchema } from '@livestore/utils/effect'
 
-import type { SqliteDb } from '../adapter-types.js'
+import type { MigrationsReport, MigrationsReportEntry, SqliteDb, UnexpectedError } from '../adapter-types.js'
 import type { LiveStoreSchema } from '../schema/mod.js'
 import type { SchemaMetaRow, SchemaMutationsMetaRow } from '../schema/system-tables.js'
 import {
@@ -54,7 +54,7 @@ export const migrateDb = ({
   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 = ({

package/src/sync/ClientSessionSyncProcessor.ts

@@ -45,8 +45,8 @@ export const makeClientSessionSyncProcessor = ({
 
   const syncStateRef = {
     current: new SyncState.SyncState({
-      localHead: clientSession.leaderThread.mutations.initialMutationEventId,
-      upstreamHead: clientSession.leaderThread.mutations.initialMutationEventId,
+      localHead: clientSession.leaderThread.initialState.leaderHead,
+      upstreamHead: clientSession.leaderThread.initialState.leaderHead,
       pending: [],
       // TODO init rollbackTail from leader to be ready for backend rebasing
       rollbackTail: [],
@@ -54,10 +54,9 @@ export const makeClientSessionSyncProcessor = ({
   }
 
   const syncStateUpdateQueue = Queue.unbounded<SyncState.SyncState>().pipe(Effect.runSync)
-
   const isLocalEvent = (mutationEventEncoded: MutationEvent.EncodedWithMeta) => {
     const mutationDef = schema.mutations.get(mutationEventEncoded.mutation)!
-    return mutationDef.options.localOnly
+    return mutationDef.options.clientOnly
   }
 
   const push: ClientSessionSyncProcessor['push'] = (batch, { otelContext }) => {
@@ -66,10 +65,15 @@ export const makeClientSessionSyncProcessor = ({
     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)
+      const nextIdPair = EventId.nextPair(baseEventId, mutationDef.options.clientOnly)
       baseEventId = nextIdPair.id
       return new MutationEvent.EncodedWithMeta(
-        Schema.encodeUnknownSync(mutationEventSchema)({ ...mutationEvent, ...nextIdPair }),
+        Schema.encodeUnknownSync(mutationEventSchema)({
+          ...mutationEvent,
+          ...nextIdPair,
+          clientId: clientSession.clientId,
+          sessionId: clientSession.sessionId,
+        }),
       )
     })
 
@@ -114,6 +118,21 @@ 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 (typeof window !== 'undefined') {
+      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)),
+      )
+    }
+
     yield* clientSession.leaderThread.mutations.pull.pipe(
       Stream.tap(({ payload, remaining }) =>
         Effect.gen(function* () {

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 = EventId.make({ global: EventId.ROOT.global - 1, local: EventId.localDefault })
+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) {