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

package/src/mutation.ts

@@ -8,10 +8,19 @@ import { prepareBindValues } from './util.js'
 
 export const getExecArgsFromMutation = ({
   mutationDef,
-  mutationEventDecoded,
+  mutationEvent,
 }: {
   mutationDef: MutationDef.Any
-  mutationEventDecoded: MutationEvent.Any | MutationEvent.PartialAny
+  /** Both encoded and decoded mutation events are supported to reduce the number of times we need to decode/encode */
+  mutationEvent:
+    | {
+        decoded: MutationEvent.AnyDecoded | MutationEvent.PartialAnyDecoded
+        encoded: undefined
+      }
+    | {
+        decoded: undefined
+        encoded: MutationEvent.AnyEncoded | MutationEvent.PartialAnyEncoded
+      }
 }): ReadonlyArray<{
   statementSql: string
   bindValues: PreparedBindValues
@@ -23,7 +32,9 @@ export const getExecArgsFromMutation = ({
 
   switch (typeof mutationDef.sql) {
     case 'function': {
-      const res = mutationDef.sql(mutationEventDecoded.args)
+      const mutationArgsDecoded =
+        mutationEvent.decoded?.args ?? Schema.decodeUnknownSync(mutationDef.schema)(mutationEvent.encoded!.args)
+      const res = mutationDef.sql(mutationArgsDecoded)
       statementRes = Array.isArray(res) ? res : [res]
       break
     }
@@ -40,10 +51,9 @@ export const getExecArgsFromMutation = ({
   return statementRes.map((statementRes) => {
     const statementSql = typeof statementRes === 'string' ? statementRes : statementRes.sql
 
-    const bindValues =
-      typeof statementRes === 'string'
-        ? Schema.encodeUnknownSync(mutationDef.schema)(mutationEventDecoded.args)
-        : statementRes.bindValues
+    const mutationArgsEncoded =
+      mutationEvent.encoded?.args ?? Schema.encodeUnknownSync(mutationDef.schema)(mutationEvent.decoded!.args)
+    const bindValues = typeof statementRes === 'string' ? mutationArgsEncoded : statementRes.bindValues
 
     const writeTables = typeof statementRes === 'string' ? undefined : statementRes.writeTables
 

package/src/otel.ts

@@ -18,3 +18,11 @@ export const provideOtel =
       Effect.provide(TracingLive),
     )
   }
+
+export const getDurationMsFromSpan = (span: otel.Span): number => {
+  const durationHr: [seconds: number, nanos: number] = (span as any)._duration
+  return durationHr[0] * 1000 + durationHr[1] / 1_000_000
+}
+
+export const getStartTimeHighResFromSpan = (span: otel.Span): DOMHighResTimeStamp =>
+  (span as any)._performanceStartTime as DOMHighResTimeStamp

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

@@ -1,22 +1,23 @@
-import { isDevEnv, memoizeByRef, shouldNeverHappen } from '@livestore/utils'
+import { memoizeByRef } from '@livestore/utils'
 import { Chunk, Effect, Option, Schema, Stream } from '@livestore/utils/effect'
 
-import { type MigrationOptionsFromMutationLog, type SynchronousDatabase, UnexpectedError } from './adapter-types.js'
-import { getExecArgsFromMutation } from './mutation.js'
+import { type MigrationOptionsFromMutationLog, type SqliteDb, UnexpectedError } from './adapter-types.js'
+import { makeApplyMutation } from './leader-thread/apply-mutation.js'
 import type { LiveStoreSchema, MutationDef, MutationEvent, MutationLogMetaRow } from './schema/mod.js'
-import { EventId, MUTATION_LOG_META_TABLE } from './schema/mod.js'
+import { EventId, getMutationDef, MUTATION_LOG_META_TABLE } from './schema/mod.js'
 import type { PreparedBindValues } from './util.js'
 import { sql } from './util.js'
 
 export const rehydrateFromMutationLog = ({
   logDb,
-  db,
+  // TODO re-use this db when bringing back the boot in-memory db implementation
+  // db,
   schema,
   migrationOptions,
   onProgress,
 }: {
-  logDb: SynchronousDatabase
-  db: SynchronousDatabase
+  logDb: SqliteDb
+  db: SqliteDb
   schema: LiveStoreSchema
   migrationOptions: MigrationOptionsFromMutationLog
   onProgress: (_: { done: number; total: number }) => Effect.Effect<void>
@@ -28,9 +29,11 @@ export const rehydrateFromMutationLog = ({
 
     const hashMutation = memoizeByRef((mutation: MutationDef.Any) => Schema.hash(mutation.schema))
 
+    const applyMutation = yield* makeApplyMutation
+
     const processMutation = (row: MutationLogMetaRow) =>
       Effect.gen(function* () {
-        const mutationDef = schema.mutations.get(row.mutation) ?? shouldNeverHappen(`Unknown mutation ${row.mutation}`)
+        const mutationDef = getMutationDef(schema, row.mutation)
 
         if (migrationOptions.excludeMutations?.has(row.mutation) === true) return
 
@@ -40,7 +43,10 @@ export const rehydrateFromMutationLog = ({
           )
         }
 
-        const argsDecoded = yield* Schema.decodeUnknown(Schema.parseJson(mutationDef.schema))(row.argsJson).pipe(
+        const args = JSON.parse(row.argsJson)
+
+        // Checking whether the schema has changed in an incompatible way
+        yield* Schema.decodeUnknown(mutationDef.schema)(args).pipe(
           Effect.mapError((cause) =>
             UnexpectedError.make({
               cause,
@@ -53,36 +59,24 @@ This likely means the schema has changed in an incompatible way.
           ),
         )
 
-        const mutationEventDecoded = {
-          id: { global: row.idGlobal, local: row.idLocal },
-          parentId: { global: row.parentIdGlobal, local: row.parentIdLocal },
+        const mutationEventEncoded = {
+          id: { global: row.idGlobal, client: row.idClient },
+          parentId: { global: row.parentIdGlobal, client: row.parentIdClient },
           mutation: row.mutation,
-          args: argsDecoded,
-        } satisfies MutationEvent.Any
-
-        const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
-
-        const makeExecuteOptions = (statementSql: string, bindValues: any) => ({
-          onRowsChanged: (rowsChanged: number) => {
-            if (rowsChanged === 0 && migrationOptions.logging?.excludeAffectedRows?.(statementSql) !== true) {
-              console.warn(`Mutation "${mutationDef.name}" did not affect any rows:`, statementSql, bindValues)
-            }
-          },
-        })
-
-        for (const { statementSql, bindValues } of execArgsArr) {
-          // TODO cache prepared statements for mutations
-          db.execute(statementSql, bindValues, isDevEnv() ? makeExecuteOptions(statementSql, bindValues) : undefined)
-          // console.log(`Re-executed mutation ${mutationSql}`, bindValues)
-        }
+          args,
+          clientId: row.clientId,
+          sessionId: row.sessionId ?? undefined,
+        } satisfies MutationEvent.AnyEncoded
+
+        yield* applyMutation(mutationEventEncoded, { skipMutationLog: true })
       }).pipe(Effect.withSpan(`@livestore/common:rehydrateFromMutationLog:processMutation`))
 
     const CHUNK_SIZE = 100
 
     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}
 `)
 
@@ -96,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

@@ -0,0 +1,12 @@
+import { Vitest } from '@livestore/utils/node-vitest'
+import { expect } from 'vitest'
+
+import { EventId } from './mod.js'
+
+Vitest.describe('EventId', () => {
+  Vitest.test('nextPair', () => {
+    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,16 +1,26 @@
-import { Schema } from '@livestore/utils/effect'
+import { Brand, Schema } from '@livestore/utils/effect'
+
+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 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: number; local: number }
+export type EventId = { global: GlobalEventId; client: ClientEventId }
 
 export const EventId = Schema.Struct({
-  global: Schema.Number,
-  local: Schema.Number,
+  global: GlobalEventId,
+  client: ClientEventId,
 }).annotations({ title: 'LiveStore.EventId' })
 
 /**
@@ -20,27 +30,51 @@ 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
+/**
+ * Convert an event id to a string representation.
+ */
+export const toString = (id: EventId) => `(${id.global},${id.client})`
+
+/**
+ * Convert a string representation of an event id to an event id.
+ */
+export const fromString = (str: string): EventId => {
+  const [global, client] = str.slice(1, -1).split(',').map(Number)
+  if (global === undefined || client === undefined) {
+    throw new Error('Invalid event id string')
+  }
+  return { global, client } as EventId
+}
+
+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, local: 0 } 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 => {
+  return Schema.is(EventId)(id) ? id : Schema.decodeSync(EventId)(id)
 }
 
-export const nextPair = (id: EventId, isLocal: boolean) => {
+export const nextPair = (id: EventId, isLocal: boolean): EventIdPair => {
   if (isLocal) {
-    return { id: { global: id.global, local: id.local + 1 }, parentId: id }
+    return { id: { global: id.global, client: (id.client + 1) as any as ClientEventId }, parentId: id }
   }
 
   return {
-    id: { global: id.global + 1, local: 0 },
-    // NOTE we always point to `local: 0` for non-localOnly mutations
-    parentId: { global: id.global, local: 0 },
+    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

@@ -1,5 +1,4 @@
 import { memoizeByRef } from '@livestore/utils'
-import type { Deferred } from '@livestore/utils/effect'
 import { Schema } from '@livestore/utils/effect'
 
 import * as EventId from './EventId.js'
@@ -11,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']>
 }
@@ -21,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> = {
@@ -28,13 +29,46 @@ 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 Any = MutationEvent<MutationDef.Any>
+export type AnyDecoded = MutationEvent<MutationDef.Any>
+export const AnyDecoded = Schema.Struct({
+  mutation: Schema.String,
+  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>
+export const AnyEncoded = Schema.Struct({
+  mutation: Schema.String,
+  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({
+  mutation: Schema.String,
+  args: Schema.Any,
+  id: EventId.GlobalEventId,
+  parentId: EventId.GlobalEventId,
+  clientId: Schema.String,
+}).annotations({ title: 'MutationEvent.AnyEncodedGlobal' })
+export type AnyEncodedGlobal = typeof AnyEncodedGlobal.Type
 
-export type PartialAny = MutationEventPartial<MutationDef.Any>
-export type PartialAnyEncoded = MutationEventPartialEncoded<MutationDef.Any>
+export type PartialAnyDecoded = MutationEventPartial<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]>
@@ -44,8 +78,9 @@ export type ForSchema<TSchema extends LiveStoreSchema> = {
   [K in keyof TSchema['_MutationDefMapType']]: MutationEvent<TSchema['_MutationDefMapType'][K]>
 }[keyof TSchema['_MutationDefMapType']]
 
-export const isPartialMutationEvent = (mutationEvent: Any | PartialAny): mutationEvent is PartialAny =>
-  'id' in mutationEvent === false && 'parentId' in mutationEvent === false
+export const isPartialMutationEvent = (
+  mutationEvent: AnyDecoded | PartialAnyDecoded,
+): mutationEvent is PartialAnyDecoded => 'id' in mutationEvent === false && 'parentId' in mutationEvent === false
 
 export type ForMutationDefRecord<TMutationsDefRecord extends MutationDefRecord> = Schema.Schema<
   {
@@ -54,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],
   {
@@ -62,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]
 >
@@ -85,12 +124,14 @@ export const makeMutationEventSchema = <TSchema extends LiveStoreSchema>(
   schema: TSchema,
 ): ForMutationDefRecord<TSchema['_MutationDefMapType']> =>
   Schema.Union(
-    ...[...schema.mutations.values()].map((def) =>
+    ...[...schema.mutations.map.values()].map((def) =>
       Schema.Struct({
         mutation: Schema.Literal(def.name),
         args: def.schema,
         id: EventId.EventId,
         parentId: EventId.EventId,
+        clientId: Schema.String,
+        sessionId: Schema.UndefinedOr(Schema.String),
       }),
     ),
   ).annotations({ title: 'MutationEvent' }) as any
@@ -99,48 +140,38 @@ export const makeMutationEventPartialSchema = <TSchema extends LiveStoreSchema>(
   schema: TSchema,
 ): MutationEventPartialSchema<TSchema['_MutationDefMapType']> =>
   Schema.Union(
-    ...[...schema.mutations.values()].map((def) =>
+    ...[...schema.mutations.map.values()].map((def) =>
       Schema.Struct({
         mutation: Schema.Literal(def.name),
         args: def.schema,
       }),
     ),
-  ).annotations({ title: 'MutationEventSchemaPartial' }) as any
+  ).annotations({ title: 'MutationEventPartial' }) as any
 
 export const makeMutationEventSchemaMemo = memoizeByRef(makeMutationEventSchema)
 
-export const Any = Schema.Struct({
-  mutation: Schema.String,
-  args: Schema.Any,
-  id: EventId.EventId,
-  parentId: EventId.EventId,
-}).annotations({ title: 'MutationEvent.Any' })
-
-export const DecodedAny = Schema.typeSchema(Any).annotations({
-  title: 'MutationEvent.DecodedAny',
-})
-
-export const EncodedAny = Schema.encodedSchema(Any).annotations({
-  title: 'MutationEvent.EncodedAny',
-})
-
-/** Equivalent to EncodedAny but with a meta field and some convenience methods */
+/** Equivalent to AnyEncoded but with a meta field and some convenience methods */
 export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEvent.EncodedWithMeta')({
   mutation: Schema.String,
   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<{ deferred?: Deferred.Deferred<void>; sessionChangeset?: Uint8Array }>,
+    Schema.Any as Schema.Schema<{
+      sessionChangeset?: Uint8Array
+    }>,
     { default: () => ({}) },
   ),
 }) {
   toJSON = (): any => {
     // Only used for logging/debugging
     // - More readable way to print the id + parentId
-    // - not including `meta`
+    // - not including `meta`, `clientId`, `sessionId`
     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,
     }
@@ -149,13 +180,29 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEven
   rebase = (parentId: EventId.EventId, isLocal: boolean) =>
     new EncodedWithMeta({
       ...this,
-      ...EventId.nextPair(this.id, isLocal),
+      ...EventId.nextPair(parentId, isLocal),
     })
+
+  static fromGlobal = (mutationEvent: AnyEncodedGlobal) =>
+    new EncodedWithMeta({
+      ...mutationEvent,
+      id: { global: mutationEvent.id, client: EventId.clientDefault },
+      parentId: { global: mutationEvent.parentId, client: EventId.clientDefault },
+      sessionId: undefined,
+    })
+
+  toGlobal = (): AnyEncodedGlobal => ({
+    ...this,
+    id: this.id.global,
+    parentId: this.parentId.global,
+  })
 }
 
 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)