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

package/dist/sync/validate-push-payload.js.map

@@ -1 +1 @@
-{"version":3,"file":"validate-push-payload.js","sourceRoot":"","sources":["../../src/sync/validate-push-payload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAGhD,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAE5C,+BAA+B;AAC/B,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,KAAqD,EACrD,cAAqC,EACrC,EAAE,CACF,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,IAAI,KAAK,CAAC,CAAC,CAAE,CAAC,EAAE,IAAI,cAAc,EAAE,CAAC;QACnC,OAAO,KAAK,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC;YAClC,MAAM,EAAE;gBACN,IAAI,EAAE,aAAa;gBACnB,iBAAiB,EAAE,cAAc,GAAG,CAAC;gBACrC,UAAU,EAAE,KAAK,CAAC,CAAC,CAAE,CAAC,EAAE;aACzB;SACF,CAAC,CAAA;IACJ,CAAC;AACH,CAAC,CAAC,CAAA"}
+{"version":3,"file":"validate-push-payload.js","sourceRoot":"","sources":["../../src/sync/validate-push-payload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAGhD,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAE5C,+BAA+B;AAC/B,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,KAAqD,EACrD,0BAAyE,EACzE,EAAE,CACF,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,IAAI,KAAK,CAAC,CAAC,CAAE,CAAC,MAAM,IAAI,0BAA0B,EAAE,CAAC;QACnD,OAAO,KAAK,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC;YAClC,MAAM,EAAE;gBACN,IAAI,EAAE,aAAa;gBACnB,kBAAkB,EAAE,0BAA0B,GAAG,CAAC;gBAClD,WAAW,EAAE,KAAK,CAAC,CAAC,CAAE,CAAC,MAAM;aAC9B;SACF,CAAC,CAAA;IACJ,CAAC;AACH,CAAC,CAAC,CAAA"}

package/dist/version.d.ts

@@ -1,4 +1,4 @@
-export declare const liveStoreVersion: "0.3.0-dev.46";
+export declare const liveStoreVersion: "0.3.0-dev.48";
 /**
  * This version number is incremented whenever the internal storage format changes in a breaking way.
  * Whenever this version changes, LiveStore will start with fresh database files. Old database files are not deleted.
@@ -6,5 +6,5 @@ export declare const liveStoreVersion: "0.3.0-dev.46";
  * While LiveStore is in alpha, this might happen more frequently.
  * In the future, LiveStore will provide a migration path for older database files to avoid the impression of data loss.
  */
-export declare const liveStoreStorageFormatVersion = 3;
+export declare const liveStoreStorageFormatVersion = 4;
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1,7 +1,7 @@
 // TODO bring back when Expo and Playwright supports `with` imports
 // import packageJson from '../package.json' with { type: 'json' }
 // export const liveStoreVersion = packageJson.version
-export const liveStoreVersion = '0.3.0-dev.46';
+export const liveStoreVersion = '0.3.0-dev.48';
 /**
  * This version number is incremented whenever the internal storage format changes in a breaking way.
  * Whenever this version changes, LiveStore will start with fresh database files. Old database files are not deleted.
@@ -9,5 +9,5 @@ export const liveStoreVersion = '0.3.0-dev.46';
  * While LiveStore is in alpha, this might happen more frequently.
  * In the future, LiveStore will provide a migration path for older database files to avoid the impression of data loss.
  */
-export const liveStoreStorageFormatVersion = 3;
+export const liveStoreStorageFormatVersion = 4;
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livestore/common",
-  "version": "0.3.0-dev.46",
+  "version": "0.3.0-dev.48",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -54,12 +54,12 @@
     "graphology": "0.26.0-alpha1",
     "graphology-dag": "0.4.1",
     "graphology-types": "0.24.8",
-    "@livestore/utils": "0.3.0-dev.46",
-    "@livestore/webmesh": "0.3.0-dev.46"
+    "@livestore/utils": "0.3.0-dev.48",
+    "@livestore/webmesh": "0.3.0-dev.48"
   },
   "devDependencies": {
     "vitest": "^3.1.2",
-    "@livestore/utils-dev": "0.3.0-dev.46"
+    "@livestore/utils-dev": "0.3.0-dev.48"
   },
   "files": [
     "package.json",

package/src/adapter-types.ts

@@ -2,7 +2,7 @@ import type { Cause, Queue, Scope, SubscriptionRef, WebChannel } from '@livestor
 import { Effect, Schema, Stream } from '@livestore/utils/effect'
 
 import type * as Devtools from './devtools/mod.js'
-import * as EventId from './schema/EventId.js'
+import * as EventSequenceNumber from './schema/EventSequenceNumber.js'
 import type { LiveStoreEvent, LiveStoreSchema } from './schema/mod.js'
 import type { LeaderAheadError } from './sync/sync.js'
 import type { PayloadUpstream, SyncState } from './sync/syncstate.js'
@@ -34,14 +34,16 @@ export interface ClientSession {
   sessionId: string
   /** Status info whether current session is leader or not */
   lockStatus: SubscriptionRef.SubscriptionRef<LockStatus>
-  shutdown: (cause: Cause.Cause<UnexpectedError | IntentionalShutdownCause>) => void
+  shutdown: (cause: Cause.Cause<UnexpectedError | IntentionalShutdownCause>) => Effect.Effect<void>
   /** A proxy API to communicate with the leader thread */
   leaderThread: ClientSessionLeaderThreadProxy
+  /** A unique identifier for the current instance of the client session. Used for debugging purposes. */
+  debugInstanceId: string
 }
 
 export const LeaderPullCursor = Schema.Struct({
   mergeCounter: Schema.Number,
-  eventId: EventId.EventId,
+  eventNum: EventSequenceNumber.EventSequenceNumber,
 })
 
 export type LeaderPullCursor = typeof LeaderPullCursor.Type
@@ -56,8 +58,8 @@ export interface ClientSessionLeaderThreadProxy {
   }
   /** The initial state after the leader thread has booted */
   readonly initialState: {
-    /** The latest mutation event id during boot. Used for the client session to resume syncing. */
-    readonly leaderHead: EventId.EventId
+    /** The latest event sequence number during boot. Used for the client session to resume syncing. */
+    readonly leaderHead: EventSequenceNumber.EventSequenceNumber
     /** The migrations report from the leader thread */
     readonly migrationsReport: MigrationsReport
   }
@@ -193,7 +195,9 @@ export class SqliteError extends Schema.TaggedError<SqliteError>()('LiveStore.Sq
     }),
   ),
   /** The SQLite result code */
-  code: Schema.optional(Schema.Number),
+  // code: Schema.optional(Schema.Number),
+  // Added string support for Expo SQLite (we should refactor this to have a unified error type)
+  code: Schema.optional(Schema.Union(Schema.Number, Schema.String)),
   /** The original SQLite3 error */
   cause: Schema.Defect,
   note: Schema.optional(Schema.String),
@@ -240,7 +244,7 @@ export interface AdapterArgs {
   devtoolsEnabled: boolean
   debugInstanceId: string
   bootStatusQueue: Queue.Queue<BootStatus>
-  shutdown: (cause: Cause.Cause<any>) => void
+  shutdown: (cause: Cause.Cause<any>) => Effect.Effect<void>
   connectDevtoolsToStore: ConnectDevtoolsToStore
   /**
    * Payload that will be passed to the sync backend when connecting

package/src/devtools/devtools-messages-client-session.ts

@@ -1,7 +1,7 @@
 import { Schema } from '@livestore/utils/effect'
 
 import { DebugInfo } from '../debug-info.js'
-import { EventId } from '../schema/mod.js'
+import { EventSequenceNumber } from '../schema/mod.js'
 import { PreparedBindValues } from '../util.js'
 import { LSDClientSessionChannelMessage, LSDClientSessionReqResMessage } from './devtools-messages-common.js'
 
@@ -52,8 +52,8 @@ export class SyncHeadUnsubscribe extends LSDClientSessionReqResMessage('LSD.Clie
   subscriptionId: Schema.String,
 }) {}
 export class SyncHeadRes extends LSDClientSessionReqResMessage('LSD.ClientSession.SyncHeadRes', {
-  local: EventId.EventId,
-  upstream: EventId.EventId,
+  local: EventSequenceNumber.EventSequenceNumber,
+  upstream: EventSequenceNumber.EventSequenceNumber,
   subscriptionId: Schema.String,
 }) {}
 

package/src/devtools/devtools-messages-leader.ts

@@ -1,7 +1,7 @@
 import { Schema, Transferable } from '@livestore/utils/effect'
 
 import * as LiveStoreEvent from '../schema/LiveStoreEvent.js'
-import { EventId } from '../schema/mod.js'
+import { EventSequenceNumber } from '../schema/mod.js'
 import * as SyncState from '../sync/syncstate.js'
 import { LeaderReqResMessage, LSDMessage, LSDReqResMessage, NetworkStatus } from './devtools-messages-common.js'
 
@@ -63,8 +63,8 @@ export class SyncHeadUnsubscribe extends LSDReqResMessage('LSD.Leader.SyncHeadUn
   subscriptionId: Schema.String,
 }) {}
 export class SyncHeadRes extends LSDReqResMessage('LSD.Leader.SyncHeadRes', {
-  local: EventId.EventId,
-  upstream: EventId.EventId,
+  local: EventSequenceNumber.EventSequenceNumber,
+  upstream: EventSequenceNumber.EventSequenceNumber,
   subscriptionId: Schema.String,
 }) {}
 

package/src/devtools/mod.ts

@@ -24,7 +24,7 @@ export type DevtoolsModeTag = typeof DevtoolsModeTag.Type
 
 export const makeNodeName = {
   devtools: {
-    random: () => `devtools-session-info-${nanoid()}`,
+    random: () => `devtools-instance-${nanoid()}`,
   },
   client: {
     session: ({ storeId, clientId, sessionId }: { storeId: string; clientId: string; sessionId: string }) =>

package/src/leader-thread/LeaderSyncProcessor.ts

@@ -18,7 +18,7 @@ import type * as otel from '@opentelemetry/api'
 import type { SqliteDb } from '../adapter-types.js'
 import { UnexpectedError } from '../adapter-types.js'
 import type { LiveStoreSchema } from '../schema/mod.js'
-import { EventId, getEventDef, LiveStoreEvent, SystemTables } from '../schema/mod.js'
+import { EventSequenceNumber, getEventDef, LiveStoreEvent, SystemTables } from '../schema/mod.js'
 import { LeaderAheadError } from '../sync/sync.js'
 import * as SyncState from '../sync/syncstate.js'
 import { sql } from '../util.js'
@@ -118,7 +118,7 @@ export const makeLeaderSyncProcessor = ({
      * If a local-push batch is rejected, all subsequent push queue items with the same generation are also rejected,
      * even if they would be valid on their own.
      */
-    // TODO get rid of this in favour of the `mergeGeneration` event id field
+    // TODO get rid of this in favour of the `mergeGeneration` event sequence number field
     const currentLocalPushGenerationRef = { current: 0 }
 
     type MergeCounter = number
@@ -150,9 +150,9 @@ export const makeLeaderSyncProcessor = ({
      *
      * Thus the purpoe of the pushHeadRef is the guard the integrity of the local push queue
      */
-    const pushHeadRef = { current: EventId.ROOT }
-    const advancePushHead = (eventId: EventId.EventId) => {
-      pushHeadRef.current = EventId.max(pushHeadRef.current, eventId)
+    const pushHeadRef = { current: EventSequenceNumber.ROOT }
+    const advancePushHead = (eventNum: EventSequenceNumber.EventSequenceNumber) => {
+      pushHeadRef.current = EventSequenceNumber.max(pushHeadRef.current, eventNum)
     }
 
     // NOTE: New events are only pushed to sync backend after successful local push processing
@@ -162,7 +162,7 @@ export const makeLeaderSyncProcessor = ({
 
         yield* validatePushBatch(newEvents, pushHeadRef.current)
 
-        advancePushHead(newEvents.at(-1)!.id)
+        advancePushHead(newEvents.at(-1)!.seqNum)
 
         const waitForProcessing = options?.waitForProcessing ?? false
         const generation = currentLocalPushGenerationRef.current
@@ -203,7 +203,7 @@ export const makeLeaderSyncProcessor = ({
           args,
           clientId,
           sessionId,
-          ...EventId.nextPair(syncState.localHead, eventDef.options.clientOnly),
+          ...EventSequenceNumber.nextPair(syncState.localHead, eventDef.options.clientOnly),
         })
 
         yield* push([eventEncoded])
@@ -223,9 +223,11 @@ export const makeLeaderSyncProcessor = ({
         runtime,
       }
 
-      const initialLocalHead = dbEventlogMissing ? EventId.ROOT : Eventlog.getClientHeadFromDb(dbEventlog)
+      const initialLocalHead = dbEventlogMissing ? EventSequenceNumber.ROOT : Eventlog.getClientHeadFromDb(dbEventlog)
 
-      const initialBackendHead = dbEventlogMissing ? EventId.ROOT.global : Eventlog.getBackendHeadFromDb(dbEventlog)
+      const initialBackendHead = dbEventlogMissing
+        ? EventSequenceNumber.ROOT.global
+        : Eventlog.getBackendHeadFromDb(dbEventlog)
 
       if (initialBackendHead > initialLocalHead.global) {
         return shouldNeverHappen(
@@ -235,11 +237,11 @@ export const makeLeaderSyncProcessor = ({
 
       const pendingEvents = dbEventlogMissing
         ? []
-        : yield* Eventlog.getEventsSince({ global: initialBackendHead, client: EventId.clientDefault })
+        : yield* Eventlog.getEventsSince({ global: initialBackendHead, client: EventSequenceNumber.clientDefault })
 
       const initialSyncState = new SyncState.SyncState({
         pending: pendingEvents,
-        upstreamHead: { global: initialBackendHead, client: EventId.clientDefault },
+        upstreamHead: { global: initialBackendHead, client: EventSequenceNumber.clientDefault },
         localHead: initialLocalHead,
       })
 
@@ -347,7 +349,7 @@ export const makeLeaderSyncProcessor = ({
                 payload: {
                   _tag: 'upstream-advance' as const,
                   newEvents: ReadonlyArray.dropWhile(payload.newEvents, (eventEncoded) =>
-                    EventId.isGreaterThanOrEqual(cursor.eventId, eventEncoded.id),
+                    EventSequenceNumber.isGreaterThanOrEqual(cursor.eventNum, eventEncoded.seqNum),
                   ),
                 },
                 mergeCounter,
@@ -479,7 +481,7 @@ const backgroundApplyLocalPushes = ({
 
           const nextGeneration = currentLocalPushGenerationRef.current
 
-          const providedId = newEvents.at(0)!.id
+          const providedNum = newEvents.at(0)!.seqNum
           // All subsequent pushes with same generation should be rejected as well
           // We're also handling the case where the localPushQueue already contains events
           // from the next generation which we preserve in the queue
@@ -503,8 +505,8 @@ const backgroundApplyLocalPushes = ({
             Deferred.fail(
               deferred,
               LeaderAheadError.make({
-                minimumExpectedId: mergeResult.expectedMinimumId,
-                providedId,
+                minimumExpectedNum: mergeResult.expectedMinimumId,
+                providedNum,
                 // nextGeneration,
               }),
             ),
@@ -617,7 +619,7 @@ const backgroundBackendPulling = ({
   mergePayloads,
   advancePushHead,
 }: {
-  initialBackendHead: EventId.GlobalEventId
+  initialBackendHead: EventSequenceNumber.GlobalEventSequenceNumber
   isClientEvent: (eventEncoded: LiveStoreEvent.EncodedWithMeta) => boolean
   restartBackendPushing: (
     filteredRebasedPending: ReadonlyArray<LiveStoreEvent.EncodedWithMeta>,
@@ -631,7 +633,7 @@ const backgroundBackendPulling = ({
   connectedClientSessionPullQueues: PullQueueSet
   mergeCounterRef: { current: number }
   mergePayloads: Map<number, typeof SyncState.PayloadUpstream.Type>
-  advancePushHead: (eventId: EventId.EventId) => void
+  advancePushHead: (eventNum: EventSequenceNumber.EventSequenceNumber) => void
 }) =>
   Effect.gen(function* () {
     const { syncBackend, dbState: db, dbEventlog, schema } = yield* LeaderThreadCtx
@@ -675,7 +677,7 @@ const backgroundBackendPulling = ({
           return yield* Effect.fail(mergeResult.cause)
         }
 
-        const newBackendHead = newEvents.at(-1)!.id
+        const newBackendHead = newEvents.at(-1)!.seqNum
 
         Eventlog.updateBackendHead(dbEventlog, newBackendHead)
 
@@ -697,7 +699,7 @@ const backgroundBackendPulling = ({
             yield* rollback({
               dbState: db,
               dbEventlog,
-              eventIdsToRollback: mergeResult.rollbackEvents.map((_) => _.id),
+              eventNumsToRollback: mergeResult.rollbackEvents.map((_) => _.seqNum),
             })
           }
 
@@ -731,7 +733,9 @@ const backgroundBackendPulling = ({
             // `mergeResult.confirmedEvents` don't contain the correct sync metadata, so we need to use
             // `newEvents` instead which we filter via `mergeResult.confirmedEvents`
             const confirmedNewEvents = newEvents.filter((event) =>
-              mergeResult.confirmedEvents.some((confirmedEvent) => EventId.isEqual(event.id, confirmedEvent.id)),
+              mergeResult.confirmedEvents.some((confirmedEvent) =>
+                EventSequenceNumber.isEqual(event.seqNum, confirmedEvent.seqNum),
+              ),
             )
             yield* Eventlog.updateSyncMetadata(confirmedNewEvents)
           }
@@ -828,10 +832,10 @@ const backgroundBackendPushing = ({
     }
   }).pipe(Effect.interruptible, Effect.withSpan('@livestore/common:LeaderSyncProcessor:backend-pushing'))
 
-const trimChangesetRows = (db: SqliteDb, newHead: EventId.EventId) => {
+const trimChangesetRows = (db: SqliteDb, newHead: EventSequenceNumber.EventSequenceNumber) => {
   // Since we're using the session changeset rows to query for the current head,
   // we're keeping at least one row for the current head, and thus are using `<` instead of `<=`
-  db.execute(sql`DELETE FROM ${SystemTables.SESSION_CHANGESET_META_TABLE} WHERE idGlobal < ${newHead.global}`)
+  db.execute(sql`DELETE FROM ${SystemTables.SESSION_CHANGESET_META_TABLE} WHERE seqNumGlobal < ${newHead.global}`)
 }
 
 interface PullQueueSet {
@@ -908,7 +912,10 @@ const getMergeCounterFromDb = (dbState: SqliteDb) =>
     return result[0]?.mergeCounter ?? 0
   })
 
-const validatePushBatch = (batch: ReadonlyArray<LiveStoreEvent.EncodedWithMeta>, pushHead: EventId.EventId) =>
+const validatePushBatch = (
+  batch: ReadonlyArray<LiveStoreEvent.EncodedWithMeta>,
+  pushHead: EventSequenceNumber.EventSequenceNumber,
+) =>
   Effect.gen(function* () {
     if (batch.length === 0) {
       return
@@ -916,18 +923,18 @@ const validatePushBatch = (batch: ReadonlyArray<LiveStoreEvent.EncodedWithMeta>,
 
     // Make sure batch is monotonically increasing
     for (let i = 1; i < batch.length; i++) {
-      if (EventId.isGreaterThanOrEqual(batch[i - 1]!.id, batch[i]!.id)) {
+      if (EventSequenceNumber.isGreaterThanOrEqual(batch[i - 1]!.seqNum, batch[i]!.seqNum)) {
         shouldNeverHappen(
-          `Events must be ordered in monotonically ascending order by eventId. Received: [${batch.map((e) => EventId.toString(e.id)).join(', ')}]`,
+          `Events must be ordered in monotonically ascending order by eventNum. Received: [${batch.map((e) => EventSequenceNumber.toString(e.seqNum)).join(', ')}]`,
         )
       }
     }
 
-    // Make sure smallest event id is > pushHead
-    if (EventId.isGreaterThanOrEqual(pushHead, batch[0]!.id)) {
+    // Make sure smallest sequence number is > pushHead
+    if (EventSequenceNumber.isGreaterThanOrEqual(pushHead, batch[0]!.seqNum)) {
       return yield* LeaderAheadError.make({
-        minimumExpectedId: pushHead,
-        providedId: batch[0]!.id,
+        minimumExpectedNum: pushHead,
+        providedNum: batch[0]!.seqNum,
       })
     }
   })

package/src/leader-thread/eventlog.ts

@@ -2,7 +2,7 @@ import { LS_DEV, shouldNeverHappen } from '@livestore/utils'
 import { Effect, Option, Schema } from '@livestore/utils/effect'
 
 import type { SqliteDb } 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 {
   EVENTLOG_META_TABLE,
@@ -34,7 +34,7 @@ export const initEventlogDb = (dbEventlog: SqliteDb) =>
     yield* execSql(
       dbEventlog,
       sql`INSERT INTO ${SYNC_STATUS_TABLE} (head)
-          SELECT ${EventId.ROOT.global}
+          SELECT ${EventSequenceNumber.ROOT.global}
           WHERE NOT EXISTS (SELECT 1 FROM ${SYNC_STATUS_TABLE})`,
       {},
     )
@@ -42,16 +42,16 @@ export const initEventlogDb = (dbEventlog: SqliteDb) =>
 
 /** Exclusive of the "since event" */
 export const getEventsSince = (
-  since: EventId.EventId,
+  since: EventSequenceNumber.EventSequenceNumber,
 ): Effect.Effect<ReadonlyArray<LiveStoreEvent.EncodedWithMeta>, never, LeaderThreadCtx> =>
   Effect.gen(function* () {
     const { dbEventlog, dbState } = yield* LeaderThreadCtx
 
-    const query = eventlogMetaTable.where('idGlobal', '>=', since.global).asSql()
+    const query = eventlogMetaTable.where('seqNumGlobal', '>=', since.global).asSql()
     const pendingEventsRaw = dbEventlog.select(query.query, prepareBindValues(query.bindValues, query.query))
     const pendingEvents = Schema.decodeUnknownSync(eventlogMetaTable.rowSchema.pipe(Schema.Array))(pendingEventsRaw)
 
-    const sessionChangesetRows = sessionChangesetMetaTable.where('idGlobal', '>=', since.global).asSql()
+    const sessionChangesetRows = sessionChangesetMetaTable.where('seqNumGlobal', '>=', since.global).asSql()
     const sessionChangesetRowsRaw = dbState.select(
       sessionChangesetRows.query,
       prepareBindValues(sessionChangesetRows.bindValues, sessionChangesetRows.query),
@@ -64,13 +64,14 @@ export const getEventsSince = (
       .map((eventlogEvent) => {
         const sessionChangeset = sessionChangesetRowsDecoded.find(
           (readModelEvent) =>
-            readModelEvent.idGlobal === eventlogEvent.idGlobal && readModelEvent.idClient === eventlogEvent.idClient,
+            readModelEvent.seqNumGlobal === eventlogEvent.seqNumGlobal &&
+            readModelEvent.seqNumClient === eventlogEvent.seqNumClient,
         )
         return LiveStoreEvent.EncodedWithMeta.make({
           name: eventlogEvent.name,
           args: eventlogEvent.argsJson,
-          id: { global: eventlogEvent.idGlobal, client: eventlogEvent.idClient },
-          parentId: { global: eventlogEvent.parentIdGlobal, client: eventlogEvent.parentIdClient },
+          seqNum: { global: eventlogEvent.seqNumGlobal, client: eventlogEvent.seqNumClient },
+          parentSeqNum: { global: eventlogEvent.parentSeqNumGlobal, client: eventlogEvent.parentSeqNumClient },
           clientId: eventlogEvent.clientId,
           sessionId: eventlogEvent.sessionId,
           meta: {
@@ -86,24 +87,28 @@ export const getEventsSince = (
           },
         })
       })
-      .filter((_) => EventId.compare(_.id, since) > 0)
-      .sort((a, b) => EventId.compare(a.id, b.id))
+      .filter((_) => EventSequenceNumber.compare(_.seqNum, since) > 0)
+      .sort((a, b) => EventSequenceNumber.compare(a.seqNum, b.seqNum))
   })
 
-export const getClientHeadFromDb = (dbEventlog: SqliteDb): EventId.EventId => {
-  const res = dbEventlog.select<{ idGlobal: EventId.GlobalEventId; idClient: EventId.ClientEventId }>(
-    sql`select idGlobal, idClient from ${EVENTLOG_META_TABLE} order by idGlobal DESC, idClient DESC limit 1`,
+export const getClientHeadFromDb = (dbEventlog: SqliteDb): EventSequenceNumber.EventSequenceNumber => {
+  const res = dbEventlog.select<{
+    seqNumGlobal: EventSequenceNumber.GlobalEventSequenceNumber
+    seqNumClient: EventSequenceNumber.ClientEventSequenceNumber
+  }>(
+    sql`select seqNumGlobal, seqNumClient from ${EVENTLOG_META_TABLE} order by seqNumGlobal DESC, seqNumClient DESC limit 1`,
   )[0]
 
-  return res ? { global: res.idGlobal, client: res.idClient } : EventId.ROOT
+  return res ? { global: res.seqNumGlobal, client: res.seqNumClient } : EventSequenceNumber.ROOT
 }
 
-export const getBackendHeadFromDb = (dbEventlog: SqliteDb): EventId.GlobalEventId =>
-  dbEventlog.select<{ head: EventId.GlobalEventId }>(sql`select head from ${SYNC_STATUS_TABLE}`)[0]?.head ??
-  EventId.ROOT.global
+export const getBackendHeadFromDb = (dbEventlog: SqliteDb): EventSequenceNumber.GlobalEventSequenceNumber =>
+  dbEventlog.select<{ head: EventSequenceNumber.GlobalEventSequenceNumber }>(
+    sql`select head from ${SYNC_STATUS_TABLE}`,
+  )[0]?.head ?? EventSequenceNumber.ROOT.global
 
 // TODO use prepared statements
-export const updateBackendHead = (dbEventlog: SqliteDb, head: EventId.EventId) =>
+export const updateBackendHead = (dbEventlog: SqliteDb, head: EventSequenceNumber.EventSequenceNumber) =>
   dbEventlog.execute(sql`UPDATE ${SYNC_STATUS_TABLE} SET head = ${head.global}`)
 
 export const insertIntoEventlog = (
@@ -115,16 +120,16 @@ export const insertIntoEventlog = (
 ) =>
   Effect.gen(function* () {
     // Check history consistency during LS_DEV
-    if (LS_DEV && eventEncoded.parentId.global !== EventId.ROOT.global) {
+    if (LS_DEV && eventEncoded.parentSeqNum.global !== EventSequenceNumber.ROOT.global) {
       const parentEventExists =
         dbEventlog.select<{ count: number }>(
-          `SELECT COUNT(*) as count FROM ${EVENTLOG_META_TABLE} WHERE idGlobal = ? AND idClient = ?`,
-          [eventEncoded.parentId.global, eventEncoded.parentId.client] as any as PreparedBindValues,
+          `SELECT COUNT(*) as count FROM ${EVENTLOG_META_TABLE} WHERE seqNumGlobal = ? AND seqNumClient = ?`,
+          [eventEncoded.parentSeqNum.global, eventEncoded.parentSeqNum.client] as any as PreparedBindValues,
         )[0]!.count === 1
 
       if (parentEventExists === false) {
         shouldNeverHappen(
-          `Parent mutation ${eventEncoded.parentId.global},${eventEncoded.parentId.client} does not exist`,
+          `Parent mutation ${eventEncoded.parentSeqNum.global},${eventEncoded.parentSeqNum.client} does not exist`,
         )
       }
     }
@@ -136,10 +141,10 @@ export const insertIntoEventlog = (
         tableName: EVENTLOG_META_TABLE,
         columns: eventlogMetaTable.sqliteDef.columns,
         values: {
-          idGlobal: eventEncoded.id.global,
-          idClient: eventEncoded.id.client,
-          parentIdGlobal: eventEncoded.parentId.global,
-          parentIdClient: eventEncoded.parentId.client,
+          seqNumGlobal: eventEncoded.seqNum.global,
+          seqNumClient: eventEncoded.seqNum.client,
+          parentSeqNumGlobal: eventEncoded.parentSeqNum.global,
+          parentSeqNumClient: eventEncoded.parentSeqNum.client,
           name: eventEncoded.name,
           argsJson: eventEncoded.args ?? {},
           clientId,
@@ -164,18 +169,18 @@ export const updateSyncMetadata = (items: ReadonlyArray<LiveStoreEvent.EncodedWi
         ...updateRows({
           tableName: EVENTLOG_META_TABLE,
           columns: eventlogMetaTable.sqliteDef.columns,
-          where: { idGlobal: event.id.global, idClient: event.id.client },
+          where: { seqNumGlobal: event.seqNum.global, seqNumClient: event.seqNum.client },
           updateValues: { syncMetadataJson: event.meta.syncMetadata },
         }),
       )
     }
   })
 
-export const getSyncBackendCursorInfo = (remoteHead: EventId.GlobalEventId) =>
+export const getSyncBackendCursorInfo = (remoteHead: EventSequenceNumber.GlobalEventSequenceNumber) =>
   Effect.gen(function* () {
     const { dbEventlog } = yield* LeaderThreadCtx
 
-    if (remoteHead === EventId.ROOT.global) return Option.none()
+    if (remoteHead === EventSequenceNumber.ROOT.global) return Option.none()
 
     const EventlogQuerySchema = Schema.Struct({
       syncMetadataJson: Schema.parseJson(Schema.Option(Schema.JsonValue)),
@@ -183,12 +188,12 @@ export const getSyncBackendCursorInfo = (remoteHead: EventId.GlobalEventId) =>
 
     const syncMetadataOption = yield* Effect.sync(() =>
       dbEventlog.select<{ syncMetadataJson: string }>(
-        sql`SELECT syncMetadataJson FROM ${EVENTLOG_META_TABLE} WHERE idGlobal = ${remoteHead} ORDER BY idClient ASC LIMIT 1`,
+        sql`SELECT syncMetadataJson FROM ${EVENTLOG_META_TABLE} WHERE seqNumGlobal = ${remoteHead} ORDER BY seqNumClient ASC LIMIT 1`,
       ),
     ).pipe(Effect.andThen(Schema.decode(EventlogQuerySchema)), Effect.map(Option.flatten), Effect.orDie)
 
     return Option.some({
-      cursor: { global: remoteHead, client: EventId.clientDefault },
+      cursor: { global: remoteHead, client: EventSequenceNumber.clientDefault },
       metadata: syncMetadataOption,
     }) satisfies InitialSyncInfo
   }).pipe(Effect.withSpan('@livestore/common:eventlog:getSyncBackendCursorInfo', { attributes: { remoteHead } }))

package/src/leader-thread/leader-worker-devtools.ts

@@ -50,7 +50,7 @@ export const bootDevtools = (options: DevtoolsOptions) =>
           const syncState = yield* syncProcessor.syncState
           const mergeCounter = syncProcessor.getMergeCounter()
 
-          yield* syncProcessor.pull({ cursor: { mergeCounter, eventId: syncState.localHead } }).pipe(
+          yield* syncProcessor.pull({ cursor: { mergeCounter, eventNum: syncState.localHead } }).pipe(
             Stream.tap(({ payload }) => sendMessage(Devtools.Leader.SyncPull.make({ payload, liveStoreVersion }))),
             Stream.runDrain,
             Effect.forkScoped,

package/src/leader-thread/materialize-event.ts

@@ -4,7 +4,7 @@ import { Effect, ReadonlyArray, Schema } from '@livestore/utils/effect'
 import type { SqliteDb } from '../adapter-types.js'
 import { getExecArgsFromEvent } from '../materializer-helper.js'
 import type { LiveStoreSchema } from '../schema/mod.js'
-import { EventId, getEventDef, SystemTables } from '../schema/mod.js'
+import { EventSequenceNumber, getEventDef, SystemTables } from '../schema/mod.js'
 import { insertRow } from '../sql-queries/index.js'
 import { sql } from '../util.js'
 import { execSql, execSqlPrepared } from './connection.js'
@@ -71,8 +71,8 @@ export const makeMaterializeEvent = ({
             tableName: SystemTables.SESSION_CHANGESET_META_TABLE,
             columns: SystemTables.sessionChangesetMetaTable.sqliteDef.columns,
             values: {
-              idGlobal: eventEncoded.id.global,
-              idClient: eventEncoded.id.client,
+              seqNumGlobal: eventEncoded.seqNum.global,
+              seqNumClient: eventEncoded.seqNum.client,
               // NOTE the changeset will be empty (i.e. null) for no-op events
               changeset: changeset ?? null,
               debug: LS_DEV ? execArgsArr : null,
@@ -112,8 +112,8 @@ export const makeMaterializeEvent = ({
         Effect.withSpan(`@livestore/common:leader-thread:materializeEvent`, {
           attributes: {
             eventName: eventEncoded.name,
-            eventId: eventEncoded.id,
-            'span.label': `${EventId.toString(eventEncoded.id)} ${eventEncoded.name}`,
+            eventNum: eventEncoded.seqNum,
+            'span.label': `${EventSequenceNumber.toString(eventEncoded.seqNum)} ${eventEncoded.name}`,
           },
         }),
         // Effect.logDuration('@livestore/common:leader-thread:materializeEvent'),
@@ -123,19 +123,23 @@ export const makeMaterializeEvent = ({
 export const rollback = ({
   dbState,
   dbEventlog,
-  eventIdsToRollback,
+  eventNumsToRollback,
 }: {
   dbState: SqliteDb
   dbEventlog: SqliteDb
-  eventIdsToRollback: EventId.EventId[]
+  eventNumsToRollback: EventSequenceNumber.EventSequenceNumber[]
 }) =>
   Effect.gen(function* () {
     const rollbackEvents = dbState
       .select<SystemTables.SessionChangesetMetaRow>(
-        sql`SELECT * FROM ${SystemTables.SESSION_CHANGESET_META_TABLE} WHERE (idGlobal, idClient) IN (${eventIdsToRollback.map((id) => `(${id.global}, ${id.client})`).join(', ')})`,
+        sql`SELECT * FROM ${SystemTables.SESSION_CHANGESET_META_TABLE} WHERE (seqNumGlobal, seqNumClient) IN (${eventNumsToRollback.map((id) => `(${id.global}, ${id.client})`).join(', ')})`,
       )
-      .map((_) => ({ id: { global: _.idGlobal, client: _.idClient }, changeset: _.changeset, debug: _.debug }))
-      .toSorted((a, b) => EventId.compare(a.id, b.id))
+      .map((_) => ({
+        seqNum: { global: _.seqNumGlobal, client: _.seqNumClient },
+        changeset: _.changeset,
+        debug: _.debug,
+      }))
+      .toSorted((a, b) => EventSequenceNumber.compare(a.seqNum, b.seqNum))
 
     // Apply changesets in reverse order
     for (let i = rollbackEvents.length - 1; i >= 0; i--) {
@@ -145,25 +149,25 @@ export const rollback = ({
       }
     }
 
-    const eventIdPairChunks = ReadonlyArray.chunksOf(100)(
-      eventIdsToRollback.map((id) => `(${id.global}, ${id.client})`),
+    const eventNumPairChunks = ReadonlyArray.chunksOf(100)(
+      eventNumsToRollback.map((seqNum) => `(${seqNum.global}, ${seqNum.client})`),
     )
 
     // Delete the changeset rows
-    for (const eventIdPairChunk of eventIdPairChunks) {
+    for (const eventNumPairChunk of eventNumPairChunks) {
       dbState.execute(
-        sql`DELETE FROM ${SystemTables.SESSION_CHANGESET_META_TABLE} WHERE (idGlobal, idClient) IN (${eventIdPairChunk.join(', ')})`,
+        sql`DELETE FROM ${SystemTables.SESSION_CHANGESET_META_TABLE} WHERE (seqNumGlobal, seqNumClient) IN (${eventNumPairChunk.join(', ')})`,
       )
     }
 
     // Delete the eventlog rows
-    for (const eventIdPairChunk of eventIdPairChunks) {
+    for (const eventNumPairChunk of eventNumPairChunks) {
       dbEventlog.execute(
-        sql`DELETE FROM ${SystemTables.EVENTLOG_META_TABLE} WHERE (idGlobal, idClient) IN (${eventIdPairChunk.join(', ')})`,
+        sql`DELETE FROM ${SystemTables.EVENTLOG_META_TABLE} WHERE (seqNumGlobal, seqNumClient) IN (${eventNumPairChunk.join(', ')})`,
       )
     }
   }).pipe(
     Effect.withSpan('@livestore/common:LeaderSyncProcessor:rollback', {
-      attributes: { count: eventIdsToRollback.length },
+      attributes: { count: eventNumsToRollback.length },
     }),
   )