@livestore/common 0.3.0-dev.47 → 0.3.0-dev.48

package/src/make-client-session.ts

@@ -33,6 +33,7 @@ export const makeClientSession = <R>({
   connectWebmeshNode,
   webmeshMode,
   registerBeforeUnload,
+  debugInstanceId,
 }: AdapterArgs & {
   clientId: string
   sessionId: string
@@ -130,5 +131,6 @@ export const makeClientSession = <R>({
       clientId,
       sessionId,
       shutdown,
+      debugInstanceId,
     } satisfies ClientSession
   })

package/src/materializer-helper.ts

@@ -1,4 +1,4 @@
-import { isReadonlyArray } from '@livestore/utils'
+import { isNil, isReadonlyArray } from '@livestore/utils'
 import { Schema } from '@livestore/utils/effect'
 
 import type { SqliteDb } from './adapter-types.js'
@@ -38,7 +38,10 @@ export const getExecArgsFromEvent = ({
 }> => {
   const eventArgsDecoded =
     event.decoded === undefined ? Schema.decodeUnknownSync(eventDef.schema)(event.encoded!.args) : event.decoded.args
-  const eventArgsEncoded = event.encoded?.args ?? Schema.encodeUnknownSync(eventDef.schema)(event.decoded!.args)
+
+  const eventArgsEncoded = isNil(event.decoded?.args)
+    ? undefined
+    : Schema.encodeUnknownSync(eventDef.schema)(event.decoded!.args)
 
   const query: MaterializerContextQuery = (
     rawQueryOrQueryBuilder:

package/src/rematerialize-from-eventlog.ts

@@ -4,7 +4,7 @@ import { Chunk, Effect, Option, Schema, Stream } from '@livestore/utils/effect'
 import { type SqliteDb, UnexpectedError } from './adapter-types.js'
 import type { MaterializeEvent } from './leader-thread/mod.js'
 import type { EventDef, LiveStoreSchema } from './schema/mod.js'
-import { EventId, getEventDef, LiveStoreEvent, SystemTables } from './schema/mod.js'
+import { EventSequenceNumber, getEventDef, LiveStoreEvent, SystemTables } from './schema/mod.js'
 import type { PreparedBindValues } from './util.js'
 import { sql } from './util.js'
 
@@ -56,8 +56,8 @@ This likely means the schema has changed in an incompatible way.
         )
 
         const eventEncoded = LiveStoreEvent.EncodedWithMeta.make({
-          id: { global: row.idGlobal, client: row.idClient },
-          parentId: { global: row.parentIdGlobal, client: row.parentIdClient },
+          seqNum: { global: row.seqNumGlobal, client: row.seqNumClient },
+          parentSeqNum: { global: row.parentSeqNumGlobal, client: row.parentSeqNumClient },
           name: row.name,
           args,
           clientId: row.clientId,
@@ -71,8 +71,8 @@ This likely means the schema has changed in an incompatible way.
 
     const stmt = dbEventlog.prepare(sql`\
 SELECT * FROM ${SystemTables.EVENTLOG_META_TABLE} 
-WHERE idGlobal > $idGlobal OR (idGlobal = $idGlobal AND idClient > $idClient)
-ORDER BY idGlobal ASC, idClient ASC
+WHERE seqNumGlobal > $seqNumGlobal OR (seqNumGlobal = $seqNumGlobal AND seqNumClient > $seqNumClient)
+ORDER BY seqNumGlobal ASC, seqNumClient ASC
 LIMIT ${CHUNK_SIZE}
 `)
 
@@ -87,14 +87,14 @@ LIMIT ${CHUNK_SIZE}
 
       const lastId = Chunk.isChunk(item)
         ? Chunk.last(item).pipe(
-            Option.map((_) => ({ global: _.idGlobal, client: _.idClient })),
-            Option.getOrElse(() => EventId.ROOT),
+            Option.map((_) => ({ global: _.seqNumGlobal, client: _.seqNumClient })),
+            Option.getOrElse(() => EventSequenceNumber.ROOT),
           )
-        : EventId.ROOT
+        : EventSequenceNumber.ROOT
       const nextItem = Chunk.fromIterable(
         stmt.select<SystemTables.EventlogMetaRow>({
-          $idGlobal: lastId?.global,
-          $idClient: lastId?.client,
+          $seqNumGlobal: lastId?.global,
+          $seqNumClient: lastId?.client,
         } as any as PreparedBindValues),
       )
       const prevItem = Chunk.isChunk(item) ? item : Chunk.empty()

package/src/schema/EventSequenceNumber.test.ts

@@ -0,0 +1,12 @@
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { expect } from 'vitest'
+
+import { EventSequenceNumber } from './mod.js'
+
+Vitest.describe('EventSequenceNumber', () => {
+  Vitest.test('nextPair', () => {
+    const e_0_0 = EventSequenceNumber.make({ global: 0, client: 0 })
+    expect(EventSequenceNumber.nextPair(e_0_0, false).seqNum).toStrictEqual({ global: 1, client: 0 })
+    expect(EventSequenceNumber.nextPair(e_0_0, true).seqNum).toStrictEqual({ global: 0, client: 1 })
+  })
+})

package/src/schema/EventSequenceNumber.ts

@@ -0,0 +1,121 @@
+import { Brand, Schema } from '@livestore/utils/effect'
+
+export type ClientEventSequenceNumber = Brand.Branded<number, 'ClientEventSequenceNumber'>
+export const localEventSequenceNumber = Brand.nominal<ClientEventSequenceNumber>()
+export const ClientEventSequenceNumber = Schema.fromBrand(localEventSequenceNumber)(Schema.Int)
+
+export type GlobalEventSequenceNumber = Brand.Branded<number, 'GlobalEventSequenceNumber'>
+export const globalEventSequenceNumber = Brand.nominal<GlobalEventSequenceNumber>()
+export const GlobalEventSequenceNumber = Schema.fromBrand(globalEventSequenceNumber)(Schema.Int)
+
+export const clientDefault = 0 as any as ClientEventSequenceNumber
+
+/**
+ * LiveStore event sequence number value consisting of a globally unique event sequence number
+ * and a client sequence number.
+ *
+ * The client sequence number is only used for clientOnly events and starts from 0 for each global sequence number.
+ */
+export type EventSequenceNumber = {
+  global: GlobalEventSequenceNumber
+  client: ClientEventSequenceNumber
+  /**
+   * TODO add generation number in favour of LEADER_MERGE_COUNTER_TABLE
+   */
+  // generation: number
+}
+
+// export const EventSequenceNumber = Schema.Struct({})
+// export const EventSequenceNumber = Schema.Struct({})
+// export const ClientEventSequenceNumber = Schema.Struct({})
+// export const GlobalEventSequenceNumber = Schema.Struct({})
+
+/**
+ * NOTE: Client mutation events with a non-0 client id, won't be synced to the sync backend.
+ */
+export const EventSequenceNumber = Schema.Struct({
+  global: GlobalEventSequenceNumber,
+  /** Only increments for clientOnly events */
+  client: ClientEventSequenceNumber,
+
+  // TODO also provide a way to see "confirmation level" of event (e.g. confirmed by leader/sync backend)
+
+  // TODO: actually add this field
+  // Client only
+  // generation: Schema.Number.pipe(Schema.optional),
+}).annotations({ title: 'LiveStore.EventSequenceNumber' })
+
+/**
+ * Compare two event sequence numbers i.e. checks if the first event sequence number is less than the second.
+ */
+export const compare = (a: EventSequenceNumber, b: EventSequenceNumber) => {
+  if (a.global !== b.global) {
+    return a.global - b.global
+  }
+  return a.client - b.client
+}
+
+/**
+ * Convert an event sequence number to a string representation.
+ */
+export const toString = (seqNum: EventSequenceNumber) =>
+  seqNum.client === 0 ? `e${seqNum.global}` : `e${seqNum.global}+${seqNum.client}`
+
+/**
+ * Convert a string representation of an event sequence number to an event sequence number.
+ */
+export const fromString = (str: string): EventSequenceNumber => {
+  const [global, client] = str.slice(1, -1).split(',').map(Number)
+  if (global === undefined || client === undefined) {
+    throw new Error('Invalid event sequence number string')
+  }
+  return { global, client } as EventSequenceNumber
+}
+
+export const isEqual = (a: EventSequenceNumber, b: EventSequenceNumber) =>
+  a.global === b.global && a.client === b.client
+
+export type EventSequenceNumberPair = { seqNum: EventSequenceNumber; parentSeqNum: EventSequenceNumber }
+
+export const ROOT = {
+  global: 0 as any as GlobalEventSequenceNumber,
+  client: clientDefault,
+} satisfies EventSequenceNumber
+
+export const isGreaterThan = (a: EventSequenceNumber, b: EventSequenceNumber) => {
+  return a.global > b.global || (a.global === b.global && a.client > b.client)
+}
+
+export const isGreaterThanOrEqual = (a: EventSequenceNumber, b: EventSequenceNumber) => {
+  return a.global > b.global || (a.global === b.global && a.client >= b.client)
+}
+
+export const max = (a: EventSequenceNumber, b: EventSequenceNumber) => {
+  return a.global > b.global || (a.global === b.global && a.client > b.client) ? a : b
+}
+
+export const diff = (a: EventSequenceNumber, b: EventSequenceNumber) => {
+  return {
+    global: a.global - b.global,
+    client: a.client - b.client,
+  }
+}
+
+export const make = (seqNum: EventSequenceNumber | typeof EventSequenceNumber.Encoded): EventSequenceNumber => {
+  return Schema.is(EventSequenceNumber)(seqNum) ? seqNum : Schema.decodeSync(EventSequenceNumber)(seqNum)
+}
+
+export const nextPair = (seqNum: EventSequenceNumber, isLocal: boolean): EventSequenceNumberPair => {
+  if (isLocal) {
+    return {
+      seqNum: { global: seqNum.global, client: (seqNum.client + 1) as any as ClientEventSequenceNumber },
+      parentSeqNum: seqNum,
+    }
+  }
+
+  return {
+    seqNum: { global: (seqNum.global + 1) as any as GlobalEventSequenceNumber, client: clientDefault },
+    // NOTE we always point to `client: 0` for non-clientOnly events
+    parentSeqNum: { global: seqNum.global, client: clientDefault },
+  }
+}

package/src/schema/LiveStoreEvent.ts

@@ -2,53 +2,55 @@ import { memoizeByRef } from '@livestore/utils'
 import { Option, Schema } from '@livestore/utils/effect'
 
 import type { EventDef, EventDefRecord } from './EventDef.js'
-import * as EventId from './EventId.js'
+import * as EventSequenceNumber from './EventSequenceNumber.js'
 import type { LiveStoreSchema } from './schema.js'
 
-export type EventDefPartial<TEventDef extends EventDef.Any> = {
-  name: TEventDef['name']
-  args: Schema.Schema.Type<TEventDef['schema']>
-}
+export namespace ForEventDef {
+  export type PartialDecoded<TEventDef extends EventDef.Any> = {
+    name: TEventDef['name']
+    args: Schema.Schema.Type<TEventDef['schema']>
+  }
 
-export type PartialEncoded<TEventDef extends EventDef.Any> = {
-  name: TEventDef['name']
-  args: Schema.Schema.Encoded<TEventDef['schema']>
-}
+  export type PartialEncoded<TEventDef extends EventDef.Any> = {
+    name: TEventDef['name']
+    args: Schema.Schema.Encoded<TEventDef['schema']>
+  }
 
-export type ForEventDef<TEventDef extends EventDef.Any> = {
-  name: TEventDef['name']
-  args: Schema.Schema.Type<TEventDef['schema']>
-  id: EventId.EventId
-  parentId: EventId.EventId
-  clientId: string
-  sessionId: string
-}
+  export type Decoded<TEventDef extends EventDef.Any> = {
+    name: TEventDef['name']
+    args: Schema.Schema.Type<TEventDef['schema']>
+    seqNum: EventSequenceNumber.EventSequenceNumber
+    parentSeqNum: EventSequenceNumber.EventSequenceNumber
+    clientId: string
+    sessionId: string
+  }
 
-export type EventDefEncoded<TEventDef extends EventDef.Any> = {
-  name: TEventDef['name']
-  args: Schema.Schema.Encoded<TEventDef['schema']>
-  id: EventId.EventId
-  parentId: EventId.EventId
-  clientId: string
-  sessionId: string
+  export type Encoded<TEventDef extends EventDef.Any> = {
+    name: TEventDef['name']
+    args: Schema.Schema.Encoded<TEventDef['schema']>
+    seqNum: EventSequenceNumber.EventSequenceNumber
+    parentSeqNum: EventSequenceNumber.EventSequenceNumber
+    clientId: string
+    sessionId: string
+  }
 }
 
-export type AnyDecoded = ForEventDef<EventDef.Any>
+export type AnyDecoded = ForEventDef.Decoded<EventDef.Any>
 export const AnyDecoded = Schema.Struct({
   name: Schema.String,
   args: Schema.Any,
-  id: EventId.EventId,
-  parentId: EventId.EventId,
+  seqNum: EventSequenceNumber.EventSequenceNumber,
+  parentSeqNum: EventSequenceNumber.EventSequenceNumber,
   clientId: Schema.String,
   sessionId: Schema.String,
 }).annotations({ title: 'LiveStoreEvent.AnyDecoded' })
 
-export type AnyEncoded = EventDefEncoded<EventDef.Any>
+export type AnyEncoded = ForEventDef.Encoded<EventDef.Any>
 export const AnyEncoded = Schema.Struct({
   name: Schema.String,
   args: Schema.Any,
-  id: EventId.EventId,
-  parentId: EventId.EventId,
+  seqNum: EventSequenceNumber.EventSequenceNumber,
+  parentSeqNum: EventSequenceNumber.EventSequenceNumber,
   clientId: Schema.String,
   sessionId: Schema.String,
 }).annotations({ title: 'LiveStoreEvent.AnyEncoded' })
@@ -56,15 +58,15 @@ export const AnyEncoded = Schema.Struct({
 export const AnyEncodedGlobal = Schema.Struct({
   name: Schema.String,
   args: Schema.Any,
-  id: EventId.GlobalEventId,
-  parentId: EventId.GlobalEventId,
+  seqNum: EventSequenceNumber.GlobalEventSequenceNumber,
+  parentSeqNum: EventSequenceNumber.GlobalEventSequenceNumber,
   clientId: Schema.String,
   sessionId: Schema.String,
 }).annotations({ title: 'LiveStoreEvent.AnyEncodedGlobal' })
 export type AnyEncodedGlobal = typeof AnyEncodedGlobal.Type
 
-export type PartialAnyDecoded = EventDefPartial<EventDef.Any>
-export type PartialAnyEncoded = PartialEncoded<EventDef.Any>
+export type PartialAnyDecoded = ForEventDef.PartialDecoded<EventDef.Any>
+export type PartialAnyEncoded = ForEventDef.PartialEncoded<EventDef.Any>
 
 export const PartialAnyEncoded = Schema.Struct({
   name: Schema.String,
@@ -72,23 +74,23 @@ export const PartialAnyEncoded = Schema.Struct({
 })
 
 export type PartialForSchema<TSchema extends LiveStoreSchema> = {
-  [K in keyof TSchema['_EventDefMapType']]: EventDefPartial<TSchema['_EventDefMapType'][K]>
+  [K in keyof TSchema['_EventDefMapType']]: ForEventDef.PartialDecoded<TSchema['_EventDefMapType'][K]>
 }[keyof TSchema['_EventDefMapType']]
 
 export type ForSchema<TSchema extends LiveStoreSchema> = {
-  [K in keyof TSchema['_EventDefMapType']]: ForEventDef<TSchema['_EventDefMapType'][K]>
+  [K in keyof TSchema['_EventDefMapType']]: ForEventDef.Decoded<TSchema['_EventDefMapType'][K]>
 }[keyof TSchema['_EventDefMapType']]
 
 export const isPartialEventDef = (event: AnyDecoded | PartialAnyDecoded): event is PartialAnyDecoded =>
-  'id' in event === false && 'parentId' in event === false
+  'num' in event === false && 'parentSeqNum' in event === false
 
 export type ForEventDefRecord<TEventDefRecord extends EventDefRecord> = Schema.Schema<
   {
     [K in keyof TEventDefRecord]: {
       name: K
       args: Schema.Schema.Type<TEventDefRecord[K]['schema']>
-      id: EventId.EventId
-      parentId: EventId.EventId
+      seqNum: EventSequenceNumber.EventSequenceNumber
+      parentSeqNum: EventSequenceNumber.EventSequenceNumber
       clientId: string
       sessionId: string
     }
@@ -97,8 +99,8 @@ export type ForEventDefRecord<TEventDefRecord extends EventDefRecord> = Schema.S
     [K in keyof TEventDefRecord]: {
       name: K
       args: Schema.Schema.Encoded<TEventDefRecord[K]['schema']>
-      id: EventId.EventId
-      parentId: EventId.EventId
+      seqNum: EventSequenceNumber.EventSequenceNumber
+      parentSeqNum: EventSequenceNumber.EventSequenceNumber
       clientId: string
       sessionId: string
     }
@@ -128,8 +130,8 @@ export const makeEventDefSchema = <TSchema extends LiveStoreSchema>(
       Schema.Struct({
         name: Schema.Literal(def.name),
         args: def.schema,
-        id: EventId.EventId,
-        parentId: EventId.EventId,
+        seqNum: EventSequenceNumber.EventSequenceNumber,
+        parentSeqNum: EventSequenceNumber.EventSequenceNumber,
         clientId: Schema.String,
         sessionId: Schema.String,
       }),
@@ -154,9 +156,8 @@ export const makeEventDefSchemaMemo = memoizeByRef(makeEventDefSchema)
 export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('LiveStoreEvent.EncodedWithMeta')({
   name: Schema.String,
   args: Schema.Any,
-  // TODO rename to `.num` / `.parentNum`
-  id: EventId.EventId,
-  parentId: EventId.EventId,
+  seqNum: EventSequenceNumber.EventSequenceNumber,
+  parentSeqNum: EventSequenceNumber.EventSequenceNumber,
   clientId: Schema.String,
   sessionId: Schema.String,
   // TODO get rid of `meta` again by cleaning up the usage implementations
@@ -181,10 +182,10 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('LiveStoreEve
 }) {
   toJSON = (): any => {
     // Only used for logging/debugging
-    // - More readable way to print the id + parentId
+    // - More readable way to print the seqNum + parentSeqNum
     // - not including `meta`, `clientId`, `sessionId`
     return {
-      id: `${EventId.toString(this.id)} → ${EventId.toString(this.parentId)} (${this.clientId}, ${this.sessionId})`,
+      seqNum: `${EventSequenceNumber.toString(this.seqNum)} → ${EventSequenceNumber.toString(this.parentSeqNum)} (${this.clientId}, ${this.sessionId})`,
       name: this.name,
       args: this.args,
     }
@@ -192,46 +193,46 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('LiveStoreEve
 
   /**
    * Example: (global event)
-   * For event id e2 → e1 which should be rebased on event id e3 → e2
-   * the resulting event id will be e4 → e3
+   * For event e2 → e1 which should be rebased on event e3 → e2
+   * the resulting event num will be e4 → e3
    *
    * Example: (client event)
-   * For event id e2+1 → e2 which should be rebased on event id e3 → e2
-   * the resulting event id will be e3+1 → e3
+   * For event e2+1 → e2 which should be rebased on event e3 → e2
+   * the resulting event num will be e3+1 → e3
    *
    * Syntax: e2+2 → e2+1
    *          ^ ^    ^ ^
-   *          | |    | +- client parent id
-   *          | |    +--- global parent id
-   *          | +-- client id
-   *          +---- global id
-   * Client id is ommitted for global events
+   *          | |    | +- client parent number
+   *          | |    +--- global parent number
+   *          | +-- client number
+   *          +---- global number
+   * Client num is ommitted for global events
    */
-  rebase = (parentId: EventId.EventId, isClient: boolean) =>
+  rebase = (parentSeqNum: EventSequenceNumber.EventSequenceNumber, isClient: boolean) =>
     new EncodedWithMeta({
       ...this,
-      ...EventId.nextPair(parentId, isClient),
+      ...EventSequenceNumber.nextPair(parentSeqNum, isClient),
     })
 
   static fromGlobal = (event: AnyEncodedGlobal, syncMetadata: Option.Option<Schema.JsonValue>) =>
     new EncodedWithMeta({
       ...event,
-      id: { global: event.id, client: EventId.clientDefault },
-      parentId: { global: event.parentId, client: EventId.clientDefault },
+      seqNum: { global: event.seqNum, client: EventSequenceNumber.clientDefault },
+      parentSeqNum: { global: event.parentSeqNum, client: EventSequenceNumber.clientDefault },
       meta: { sessionChangeset: { _tag: 'unset' as const }, syncMetadata },
     })
 
   toGlobal = (): AnyEncodedGlobal => ({
     ...this,
-    id: this.id.global,
-    parentId: this.parentId.global,
+    seqNum: this.seqNum.global,
+    parentSeqNum: this.parentSeqNum.global,
   })
 }
 
 /** NOTE `meta` is not considered for equality */
 export const isEqualEncoded = (a: AnyEncoded, b: AnyEncoded) =>
-  a.id.global === b.id.global &&
-  a.id.client === b.id.client &&
+  a.seqNum.global === b.seqNum.global &&
+  a.seqNum.client === b.seqNum.client &&
   a.name === b.name &&
   a.clientId === b.clientId &&
   a.sessionId === b.sessionId &&

package/src/schema/mod.ts

@@ -5,5 +5,5 @@ export * from './state/sqlite/schema-helpers.js'
 export * from './schema.js'
 export * as State from './state/mod.js'
 export * as LiveStoreEvent from './LiveStoreEvent.js'
-export * as EventId from './EventId.js'
+export * as EventSequenceNumber from './EventSequenceNumber.js'
 export * as Events from './events.js'

package/src/schema/state/sqlite/query-builder/impl.test.ts

@@ -269,6 +269,15 @@ describe('query builder', () => {
           "schema": "(ReadonlyArray<({ readonly count: number } <-> number)> <-> number)",
         }
       `)
+      expect(dump(db.todos.where('completed', true).count())).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            1,
+          ],
+          "query": "SELECT COUNT(*) as count FROM 'todos' WHERE completed = ?",
+          "schema": "(ReadonlyArray<({ readonly count: number } <-> number)> <-> number)",
+        }
+      `)
     })
 
     it('should handle NULL comparisons', () => {

package/src/schema/state/sqlite/query-builder/impl.ts

@@ -122,12 +122,13 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
       return makeQueryBuilder(tableDef, { ...ast, offset: Option.some(offset) })
     },
     count: () => {
-      if (isRowQuery(ast)) return invalidQueryBuilder()
+      if (isRowQuery(ast) || ast._tag === 'InsertQuery' || ast._tag === 'UpdateQuery' || ast._tag === 'DeleteQuery')
+        return invalidQueryBuilder()
 
       return makeQueryBuilder(tableDef, {
         _tag: 'CountQuery',
         tableDef,
-        where: [],
+        where: ast.where,
         resultSchema: Schema.Struct({ count: Schema.Number }).pipe(
           Schema.pluck('count'),
           Schema.Array,

package/src/schema/state/sqlite/system-tables.ts

@@ -1,6 +1,6 @@
 import { Schema } from '@livestore/utils/effect'
 
-import * as EventId from '../../EventId.js'
+import * as EventSequenceNumber from '../../EventSequenceNumber.js'
 import { SqliteDsl } from './db-schema/mod.js'
 import { table } from './table-def.js'
 
@@ -44,18 +44,19 @@ export const sessionChangesetMetaTable = table({
   name: SESSION_CHANGESET_META_TABLE,
   columns: {
     // TODO bring back primary key
-    idGlobal: SqliteDsl.integer({ schema: EventId.GlobalEventId }),
-    idClient: SqliteDsl.integer({ schema: EventId.ClientEventId }),
+    seqNumGlobal: SqliteDsl.integer({ schema: EventSequenceNumber.GlobalEventSequenceNumber }),
+    seqNumClient: SqliteDsl.integer({ schema: EventSequenceNumber.ClientEventSequenceNumber }),
     changeset: SqliteDsl.blob({ nullable: true }),
     debug: SqliteDsl.json({ nullable: true }),
   },
-  indexes: [{ columns: ['idGlobal', 'idClient'], name: 'idx_session_changeset_id' }],
+  indexes: [{ columns: ['seqNumGlobal', 'seqNumClient'], name: 'idx_session_changeset_id' }],
 })
 
 export type SessionChangesetMetaRow = typeof sessionChangesetMetaTable.Type
 
 export const LEADER_MERGE_COUNTER_TABLE = '__livestore_leader_merge_counter'
 
+// TODO get rid of this table in favour of client-only merge generation
 export const leaderMergeCounterTable = table({
   name: LEADER_MERGE_COUNTER_TABLE,
   columns: {
@@ -83,10 +84,10 @@ export const eventlogMetaTable = table({
   name: EVENTLOG_META_TABLE,
   columns: {
     // TODO Adjust modeling so a global event never needs a client id component
-    idGlobal: SqliteDsl.integer({ primaryKey: true, schema: EventId.GlobalEventId }),
-    idClient: SqliteDsl.integer({ primaryKey: true, schema: EventId.ClientEventId }),
-    parentIdGlobal: SqliteDsl.integer({ schema: EventId.GlobalEventId }),
-    parentIdClient: SqliteDsl.integer({ schema: EventId.ClientEventId }),
+    seqNumGlobal: SqliteDsl.integer({ primaryKey: true, schema: EventSequenceNumber.GlobalEventSequenceNumber }),
+    seqNumClient: SqliteDsl.integer({ primaryKey: true, schema: EventSequenceNumber.ClientEventSequenceNumber }),
+    parentSeqNumGlobal: SqliteDsl.integer({ schema: EventSequenceNumber.GlobalEventSequenceNumber }),
+    parentSeqNumClient: SqliteDsl.integer({ schema: EventSequenceNumber.ClientEventSequenceNumber }),
     name: SqliteDsl.text({}),
     argsJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Any) }),
     clientId: SqliteDsl.text({}),
@@ -95,8 +96,8 @@ export const eventlogMetaTable = table({
     syncMetadataJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Option(Schema.JsonValue)) }),
   },
   indexes: [
-    { columns: ['idGlobal'], name: 'idx_eventlog_idGlobal' },
-    { columns: ['idGlobal', 'idClient'], name: 'idx_eventlog_id' },
+    { columns: ['seqNumGlobal'], name: 'idx_eventlog_seqNumGlobal' },
+    { columns: ['seqNumGlobal', 'seqNumClient'], name: 'idx_eventlog_seqNum' },
   ],
 })
 

package/src/sync/ClientSessionSyncProcessor.ts

@@ -5,7 +5,7 @@ import { BucketQueue, Effect, FiberHandle, Queue, Schema, Stream, Subscribable }
 import * as otel from '@opentelemetry/api'
 
 import type { ClientSession, UnexpectedError } from '../adapter-types.js'
-import * as EventId from '../schema/EventId.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'
@@ -77,16 +77,16 @@ export const makeClientSessionSyncProcessor = ({
   const push: ClientSessionSyncProcessor['push'] = (batch, { otelContext }) => {
     // TODO validate batch
 
-    let baseEventId = syncStateRef.current.localHead
+    let baseEventSequenceNumber = syncStateRef.current.localHead
     const encodedEventDefs = batch.map(({ name, args }) => {
       const eventDef = getEventDef(schema, name)
-      const nextIdPair = EventId.nextPair(baseEventId, eventDef.eventDef.options.clientOnly)
-      baseEventId = nextIdPair.id
+      const nextNumPair = EventSequenceNumber.nextPair(baseEventSequenceNumber, eventDef.eventDef.options.clientOnly)
+      baseEventSequenceNumber = nextNumPair.seqNum
       return new LiveStoreEvent.EncodedWithMeta(
         Schema.encodeUnknownSync(eventSchema)({
           name,
           args,
-          ...nextIdPair,
+          ...nextNumPair,
           clientId: clientSession.clientId,
           sessionId: clientSession.sessionId,
         }),
@@ -179,7 +179,7 @@ export const makeClientSessionSyncProcessor = ({
     // 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(), eventId: syncStateRef.current.localHead },
+        cursor: { mergeCounter: getMergeCounter(), eventNum: syncStateRef.current.localHead },
       }),
     ).pipe(
       Stream.tap(({ payload, mergeCounter: leaderMergeCounter }) =>