@livestore/common 0.3.0-dev.11 → 0.3.0-dev.13

package/src/leader-thread/make-leader-thread-layer.ts

@@ -1,7 +1,7 @@
 import type { HttpClient, Scope } from '@livestore/utils/effect'
 import { Deferred, Effect, Layer, Queue, SubscriptionRef } from '@livestore/utils/effect'
 
-import type { BootStatus, MakeSqliteDb, SqliteError } from '../adapter-types.js'
+import type { BootStatus, MakeSqliteDb, MigrationsReport, SqliteError } from '../adapter-types.js'
 import { UnexpectedError } from '../adapter-types.js'
 import type * as Devtools from '../devtools/index.js'
 import type { LiveStoreSchema } from '../schema/mod.js'
@@ -67,15 +67,15 @@ export const makeLeaderThreadLayer = ({
       initialBlockingSyncContext,
     })
 
-    const extraIncomingMessagesQueue = yield* Queue.unbounded<Devtools.MessageToAppLeader>().pipe(
+    const extraIncomingMessagesQueue = yield* Queue.unbounded<Devtools.Leader.MessageToApp>().pipe(
       Effect.acquireRelease(Queue.shutdown),
     )
 
     const devtoolsContext = devtoolsOptions.enabled
       ? {
           enabled: true as const,
-          syncBackendPullLatch: yield* Effect.makeLatch(true),
-          syncBackendPushLatch: yield* Effect.makeLatch(true),
+          syncBackendLatch: yield* Effect.makeLatch(true),
+          syncBackendLatchState: yield* SubscriptionRef.make<{ latchClosed: boolean }>({ latchClosed: false }),
         }
       : { enabled: false as const }
 
@@ -95,6 +95,8 @@ export const makeLeaderThreadLayer = ({
       connectedClientSessionPullQueues: yield* makePullQueueSet,
       extraIncomingMessagesQueue,
       devtools: devtoolsContext,
+      // State will be set during `bootLeaderThread`
+      initialState: {} as any as LeaderThreadCtx['Type']['initialState'],
     } satisfies typeof LeaderThreadCtx.Service
 
     // @ts-expect-error For debugging purposes
@@ -102,7 +104,11 @@ export const makeLeaderThreadLayer = ({
 
     const layer = Layer.succeed(LeaderThreadCtx, ctx)
 
-    yield* bootLeaderThread({ dbMissing, initialBlockingSyncContext, devtoolsOptions }).pipe(Effect.provide(layer))
+    ctx.initialState = yield* bootLeaderThread({
+      dbMissing,
+      initialBlockingSyncContext,
+      devtoolsOptions,
+    }).pipe(Effect.provide(layer))
 
     return layer
   }).pipe(
@@ -172,7 +178,7 @@ const bootLeaderThread = ({
   initialBlockingSyncContext: InitialBlockingSyncContext
   devtoolsOptions: DevtoolsOptions
 }): Effect.Effect<
-  void,
+  LeaderThreadCtx['Type']['initialState'],
   UnexpectedError | SqliteError | IsOfflineError | InvalidPullError,
   LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient
 > =>
@@ -206,19 +212,33 @@ const bootLeaderThread = ({
 
     // We're already starting pulling from the sync backend concurrently but wait until the db is ready before
     // processing any incoming mutations
-    yield* syncProcessor.boot({ dbReady })
+    const { initialLeaderHead } = yield* syncProcessor.boot({ dbReady })
 
+    let migrationsReport: MigrationsReport
     if (dbMissing) {
-      yield* recreateDb
+      const recreateResult = yield* recreateDb
+      migrationsReport = recreateResult.migrationsReport
+    } else {
+      migrationsReport = { migrations: [] }
     }
 
     yield* Deferred.succeed(dbReady, void 0)
 
     if (initialBlockingSyncContext.blockingDeferred !== undefined) {
-      yield* initialBlockingSyncContext.blockingDeferred
+      // Provides a syncing status right away before the first pull response comes in
+      yield* Queue.offer(bootStatusQueue, {
+        stage: 'syncing',
+        progress: { done: 0, total: -1 },
+      })
+
+      yield* initialBlockingSyncContext.blockingDeferred.pipe(
+        Effect.withSpan('@livestore/common:leader-thread:initial-sync-blocking'),
+      )
     }
 
     yield* Queue.offer(bootStatusQueue, { stage: 'done' })
 
     yield* bootDevtools(devtoolsOptions).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
+
+    return { migrationsReport, leaderHead: initialLeaderHead }
   })

package/src/leader-thread/mutationlog.ts

@@ -23,18 +23,20 @@ export const getMutationEventsSince = (
       .map((_) => ({
         mutation: _.mutation,
         args: _.argsJson,
-        id: { global: _.idGlobal, local: _.idLocal },
-        parentId: { global: _.parentIdGlobal, local: _.parentIdLocal },
+        id: { global: _.idGlobal, client: _.idClient },
+        parentId: { global: _.parentIdGlobal, client: _.parentIdClient },
+        clientId: _.clientId,
+        sessionId: _.sessionId ?? undefined,
       }))
       .filter((_) => EventId.compare(_.id, since) > 0)
   })
 
-export const getLocalHeadFromDb = (dbMutationLog: SqliteDb): EventId.EventId => {
-  const res = dbMutationLog.select<{ idGlobal: EventId.GlobalEventId; idLocal: EventId.LocalEventId }>(
-    sql`select idGlobal, idLocal from ${MUTATION_LOG_META_TABLE} order by idGlobal DESC, idLocal DESC limit 1`,
+export const getClientHeadFromDb = (dbMutationLog: SqliteDb): EventId.EventId => {
+  const res = dbMutationLog.select<{ idGlobal: EventId.GlobalEventId; idClient: EventId.ClientEventId }>(
+    sql`select idGlobal, idClient from ${MUTATION_LOG_META_TABLE} order by idGlobal DESC, idClient DESC limit 1`,
   )[0]
 
-  return res ? { global: res.idGlobal, local: res.idLocal } : EventId.ROOT
+  return res ? { global: res.idGlobal, client: res.idClient } : EventId.ROOT
 }
 
 export const getBackendHeadFromDb = (dbMutationLog: SqliteDb): EventId.GlobalEventId =>

package/src/leader-thread/recreate-db.ts

@@ -2,19 +2,20 @@ import { casesHandled } from '@livestore/utils'
 import type { HttpClient } from '@livestore/utils/effect'
 import { Effect, Queue } from '@livestore/utils/effect'
 
-import type { InvalidPullError, IsOfflineError, MigrationHooks, SqliteError } from '../index.js'
+import type { InvalidPullError, IsOfflineError, MigrationHooks, MigrationsReport, SqliteError } from '../index.js'
 import { initializeSingletonTables, migrateDb, rehydrateFromMutationLog, UnexpectedError } from '../index.js'
 import { configureConnection } from './connection.js'
 import { LeaderThreadCtx } from './types.js'
 
 export const recreateDb: Effect.Effect<
-  void,
+  { migrationsReport: MigrationsReport },
   UnexpectedError | SqliteError | IsOfflineError | InvalidPullError,
   LeaderThreadCtx | HttpClient.HttpClient
 > = Effect.gen(function* () {
   const { dbReadModel, dbMutationLog, schema, bootStatusQueue } = yield* LeaderThreadCtx
 
   const migrationOptions = schema.migrationOptions
+  let migrationsReport: MigrationsReport
 
   yield* Effect.addFinalizer(
     Effect.fn('recreateDb:finalizer')(function* (ex) {
@@ -27,13 +28,13 @@ export const recreateDb: Effect.Effect<
   // TODO bring back this optimization
   // const tmpDb = yield* makeSqliteDb({ _tag: 'in-memory' })
   const tmpDb = dbReadModel
-  yield* configureConnection(tmpDb, { fkEnabled: true })
+  yield* configureConnection(tmpDb, { foreignKeys: true })
 
   const initDb = (hooks: Partial<MigrationHooks> | undefined) =>
     Effect.gen(function* () {
       yield* Effect.tryAll(() => hooks?.init?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
-      yield* migrateDb({
+      const migrationsReport = yield* migrateDb({
         db: tmpDb,
         schema,
         onProgress: ({ done, total }) =>
@@ -44,16 +45,18 @@ export const recreateDb: Effect.Effect<
 
       yield* Effect.tryAll(() => hooks?.pre?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
-      return tmpDb
+      return { migrationsReport, tmpDb }
     })
 
   switch (migrationOptions.strategy) {
     case 'from-mutation-log': {
       const hooks = migrationOptions.hooks
-      const tmpDb = yield* initDb(hooks)
+      const initResult = yield* initDb(hooks)
+
+      migrationsReport = initResult.migrationsReport
 
       yield* rehydrateFromMutationLog({
-        db: tmpDb,
+        db: initResult.tmpDb,
         logDb: dbMutationLog,
         schema,
         migrationOptions,
@@ -61,23 +64,27 @@ export const recreateDb: Effect.Effect<
           Queue.offer(bootStatusQueue, { stage: 'rehydrating', progress: { done, total } }),
       })
 
-      yield* Effect.tryAll(() => hooks?.post?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
+      yield* Effect.tryAll(() => hooks?.post?.(initResult.tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
       break
     }
     case 'hard-reset': {
       const hooks = migrationOptions.hooks
-      const tmpInMemoryDb = yield* initDb(hooks)
+      const initResult = yield* initDb(hooks)
+
+      migrationsReport = initResult.migrationsReport
 
       // The database is migrated but empty now, so nothing else to do
 
-      yield* Effect.tryAll(() => hooks?.post?.(tmpInMemoryDb)).pipe(UnexpectedError.mapToUnexpectedError)
+      yield* Effect.tryAll(() => hooks?.post?.(initResult.tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
       break
     }
     case 'manual': {
       const oldDbData = dbReadModel.export()
 
+      migrationsReport = { migrations: [] }
+
       const newDbData = yield* Effect.tryAll(() => migrationOptions.migrate(oldDbData)).pipe(
         UnexpectedError.mapToUnexpectedError,
       )
@@ -106,6 +113,8 @@ export const recreateDb: Effect.Effect<
 
   // TODO bring back
   // tmpDb.close()
+
+  return { migrationsReport }
 }).pipe(
   Effect.scoped, // NOTE we're closing the scope here so finalizers are called when the effect is done
   Effect.withSpan('@livestore/common:leader-thread:recreateDb'),

package/src/leader-thread/types.ts

@@ -1,7 +1,6 @@
 import type {
   Deferred,
   Effect,
-  Fiber,
   HttpClient,
   Option,
   Queue,
@@ -17,6 +16,7 @@ import type {
   Devtools,
   InvalidPushError,
   MakeSqliteDb,
+  MigrationsReport,
   PersistenceInfo,
   SqliteDb,
   SyncBackend,
@@ -28,18 +28,11 @@ import type { ShutdownChannel } from './shutdown-channel.js'
 
 export type ShutdownState = 'running' | 'shutting-down'
 
-export class OuterWorkerCtx extends Context.Tag('OuterWorkerCtx')<
-  OuterWorkerCtx,
-  {
-    innerFiber: Fiber.RuntimeFiber<any, any>
-  }
->() {}
-
 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
@@ -67,7 +60,7 @@ export type DevtoolsOptions =
       enabled: true
       makeBootContext: Effect.Effect<
         {
-          devtoolsWebChannel: WebChannel.WebChannel<Devtools.MessageToAppLeader, Devtools.MessageFromAppLeader>
+          devtoolsWebChannel: WebChannel.WebChannel<Devtools.Leader.MessageToApp, Devtools.Leader.MessageFromApp>
           persistenceInfo: PersistenceInfoPair
         },
         UnexpectedError,
@@ -78,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
@@ -103,12 +98,16 @@ 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
      *
      * This is currently separated from `.devtools` as it also needs to work when devtools are disabled
      */
-    extraIncomingMessagesQueue: Queue.Queue<Devtools.MessageToAppLeader>
+    extraIncomingMessagesQueue: Queue.Queue<Devtools.Leader.MessageToApp>
   }
 >() {}
 
@@ -135,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/query-builder/api.ts

@@ -3,8 +3,8 @@ import { type Option, Predicate, type Schema } from '@livestore/utils/effect'
 
 import type { SessionIdSymbol } from '../adapter-types.js'
 import type { QueryInfo } from '../query-info.js'
+import type { SqliteDsl } from '../schema/db-schema/mod.js'
 import type { DbSchema } from '../schema/mod.js'
-import type { SqliteDsl } from '../schema/table-def.js'
 import type { SqlValue } from '../util.js'
 
 export type QueryBuilderAst = QueryBuilderAst.SelectQuery | QueryBuilderAst.CountQuery | QueryBuilderAst.RowQuery
@@ -35,7 +35,7 @@ export namespace QueryBuilderAst {
   export type RowQuery = {
     readonly _tag: 'RowQuery'
     readonly tableDef: DbSchema.TableDefBase
-    readonly id: string | SessionIdSymbol
+    readonly id: string | SessionIdSymbol | number
     readonly insertValues: Record<string, unknown>
   }
 
@@ -252,10 +252,10 @@ export namespace QueryBuilder {
         ? (_: 'Error: Need to enable deriveMutations to use row()') => any
         : TTableDef['options']['requiredInsertColumnNames'] extends never
           ? (
-              id: string | SessionIdSymbol,
+              id: string | SessionIdSymbol | number,
             ) => QueryBuilder<RowQuery.Result<TTableDef>, TTableDef, QueryBuilder.ApiFeature, QueryInfo.Row>
           : <TOptions extends RowQuery.RequiredColumnsOptions<TTableDef>>(
-              id: string | SessionIdSymbol,
+              id: string | SessionIdSymbol | number,
               opts: TOptions,
             ) => QueryBuilder<RowQuery.Result<TTableDef>, TTableDef, QueryBuilder.ApiFeature, QueryInfo.Row>
   }

package/src/query-builder/impl.test.ts

@@ -18,13 +18,23 @@ const todos = DbSchema.table(
   { deriveMutations: true },
 )
 
+const todosWithIntId = DbSchema.table(
+  'todos_with_int_id',
+  {
+    id: DbSchema.integer({ primaryKey: true }),
+    text: DbSchema.text({ default: '', nullable: false }),
+    status: DbSchema.text({ schema: Schema.Literal('active', 'completed') }),
+  },
+  { deriveMutations: true },
+)
+
 const comments = DbSchema.table('comments', {
   id: DbSchema.text({ primaryKey: true }),
   text: DbSchema.text({ default: '', nullable: false }),
   todoId: DbSchema.text({}),
 })
 
-const db = { todos: todos.query, comments: comments.query }
+const db = { todos: todos.query, todosWithIntId: todosWithIntId.query, comments: comments.query }
 
 describe('query builder', () => {
   describe('result schema', () => {
@@ -204,6 +214,17 @@ describe('query builder', () => {
         }
       `)
     })
+
+    it('should handle row queries with numbers', () => {
+      expect(db.todosWithIntId.row(123, { insertValues: { status: 'active' } }).asSql()).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            123,
+          ],
+          "query": "SELECT * FROM 'todos_with_int_id' WHERE id = ?",
+        }
+      `)
+    })
   })
 })
 

package/src/query-builder/impl.ts

@@ -128,12 +128,12 @@ export const makeQueryBuilder = <TResult, TTableDef extends DbSchema.TableDefBas
       // eslint-disable-next-line prefer-rest-params
       const params = [...arguments]
 
-      let id: string
+      let id: string | number
 
       if (tableDef.options.isSingleton) {
         id = tableDef.sqliteDef.columns.id!.default.pipe(Option.getOrThrow)
       } else {
-        id = params[0] as string
+        id = params[0] as string | number
         if (id === undefined) {
           invalidQueryBuilder(`Id missing for row query on non-singleton table ${tableDef.sqliteDef.name}`)
         }

package/src/query-info.ts

@@ -24,20 +24,20 @@ export namespace QueryInfo {
   export type Row = {
     _tag: 'Row'
     table: DbSchema.TableDefBase
-    id: string | SessionIdSymbol
+    id: string | SessionIdSymbol | number
   }
 
   export type Col = {
     _tag: 'Col'
     table: DbSchema.TableDefBase
-    id: string | SessionIdSymbol
+    id: string | SessionIdSymbol | number
     column: string
   }
 
   export type ColJsonValue = {
     _tag: 'ColJsonValue'
     table: DbSchema.TableDefBase
-    id: string | SessionIdSymbol
+    id: string | SessionIdSymbol | number
     column: string
     /**
      * example: `$.tabs[3].items[2]` (`$` referring to the column value)

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 },
   }
 }