@livestore/common 0.3.1 → 0.3.2-dev.0

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

@@ -1,3 +1,4 @@
+/** biome-ignore-all lint/complexity/noArguments: using arguments is fine here */
 import { casesHandled, shouldNeverHappen } from '@livestore/utils'
 import { Match, Option, Predicate, Schema } from '@livestore/utils/effect'
 
@@ -36,7 +37,7 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
         select: { columns },
       }) as any
     },
-    // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+    // biome-ignore lint/complexity/useArrowFunction: prefer function over arrow function for this case
     where: function () {
       if (ast._tag === 'InsertQuery') return invalidQueryBuilder('Cannot use where with insert')
       if (ast._tag === 'RowQuery') return invalidQueryBuilder('Cannot use where with row')
@@ -136,7 +137,7 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
         ),
       })
     },
-    first: (options) => {
+    first: (behaviour) => {
       assertSelectQueryBuilderAst(ast)
 
       if (ast.limit._tag === 'Some') return invalidQueryBuilder(`.first() can't be called after .limit()`)
@@ -144,8 +145,7 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
       return makeQueryBuilder(tableDef, {
         ...ast,
         limit: Option.some(1),
-        pickFirst:
-          options?.fallback !== undefined && options.fallback !== 'throws' ? { fallback: options.fallback } : 'throws',
+        pickFirst: { _tag: 'enabled', ...(behaviour ?? { behaviour: 'undefined' }) },
       })
     },
     // // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
@@ -249,7 +249,7 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
   return {
     [QueryBuilderTypeId]: QueryBuilderTypeId,
     [QueryBuilderAstSymbol]: ast,
-    ['ResultType']: 'only-for-type-inference' as TResult,
+    ResultType: 'only-for-type-inference' as TResult,
     asSql: () => astToSql(ast),
     toString: () => {
       try {
@@ -266,7 +266,7 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
 const emptyAst = (tableDef: TableDefBase): QueryBuilderAst.SelectQuery => ({
   _tag: 'SelectQuery',
   columns: [],
-  pickFirst: false,
+  pickFirst: { _tag: 'disabled' },
   select: { columns: [] },
   orderBy: [],
   offset: Option.none(),
@@ -280,28 +280,28 @@ const emptyAst = (tableDef: TableDefBase): QueryBuilderAst.SelectQuery => ({
 // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
 function assertSelectQueryBuilderAst(ast: QueryBuilderAst): asserts ast is QueryBuilderAst.SelectQuery {
   if (ast._tag !== 'SelectQuery') {
-    return shouldNeverHappen('Expected SelectQuery but got ' + ast._tag)
+    return shouldNeverHappen(`Expected SelectQuery but got ${ast._tag}`)
   }
 }
 
 // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
 function assertInsertQueryBuilderAst(ast: QueryBuilderAst): asserts ast is QueryBuilderAst.InsertQuery {
   if (ast._tag !== 'InsertQuery') {
-    return shouldNeverHappen('Expected InsertQuery but got ' + ast._tag)
+    return shouldNeverHappen(`Expected InsertQuery but got ${ast._tag}`)
   }
 }
 
 // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
 function assertWriteQueryBuilderAst(ast: QueryBuilderAst): asserts ast is QueryBuilderAst.WriteQuery {
   if (ast._tag !== 'InsertQuery' && ast._tag !== 'UpdateQuery' && ast._tag !== 'DeleteQuery') {
-    return shouldNeverHappen('Expected WriteQuery but got ' + ast._tag)
+    return shouldNeverHappen(`Expected WriteQuery but got ${ast._tag}`)
   }
 }
 
 const isRowQuery = (ast: QueryBuilderAst): ast is QueryBuilderAst.RowQuery => ast._tag === 'RowQuery'
 
 export const invalidQueryBuilder = (msg?: string) => {
-  return shouldNeverHappen('Invalid query builder' + (msg ? `: ${msg}` : ''))
+  return shouldNeverHappen(`Invalid query builder${msg ? `: ${msg}` : ''}`)
 }
 
 export const getResultSchema = (qb: QueryBuilder<any, any, any>): Schema.Schema<any> => {
@@ -309,9 +309,12 @@ export const getResultSchema = (qb: QueryBuilder<any, any, any>): Schema.Schema<
   switch (queryAst._tag) {
     case 'SelectQuery': {
       const arraySchema = Schema.Array(queryAst.resultSchemaSingle)
-      if (queryAst.pickFirst === false) {
+      if (queryAst.pickFirst._tag === 'disabled') {
         return arraySchema
-      } else if (queryAst.pickFirst === 'throws') {
+      } else if (queryAst.pickFirst.behaviour === 'undefined') {
+        const arraySchema = Schema.Array(Schema.UndefinedOr(queryAst.resultSchemaSingle))
+        return arraySchema.pipe(Schema.headOrElse(() => undefined))
+      } else if (queryAst.pickFirst.behaviour === 'error') {
         // Will throw if the array is empty
         return arraySchema.pipe(Schema.headOrElse())
       } else {

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

@@ -4,7 +4,7 @@ import * as EventSequenceNumber from '../../EventSequenceNumber.js'
 import { SqliteDsl } from './db-schema/mod.js'
 import { table } from './table-def.js'
 
-/// Read model DB
+/// State DB
 
 export const SCHEMA_META_TABLE = '__livestore_schema'
 
@@ -46,6 +46,7 @@ export const sessionChangesetMetaTable = table({
     // TODO bring back primary key
     seqNumGlobal: SqliteDsl.integer({ schema: EventSequenceNumber.GlobalEventSequenceNumber }),
     seqNumClient: SqliteDsl.integer({ schema: EventSequenceNumber.ClientEventSequenceNumber }),
+    seqNumRebaseGeneration: SqliteDsl.integer({}),
     changeset: SqliteDsl.blob({ nullable: true }),
     debug: SqliteDsl.json({ nullable: true }),
   },
@@ -54,25 +55,7 @@ export const sessionChangesetMetaTable = table({
 
 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: {
-    id: SqliteDsl.integer({ primaryKey: true, schema: Schema.Literal(0) }),
-    mergeCounter: SqliteDsl.integer({ primaryKey: true }),
-  },
-})
-
-export type LeaderMergeCounterRow = typeof leaderMergeCounterTable.Type
-
-export const stateSystemTables = [
-  schemaMetaTable,
-  schemaEventDefsMetaTable,
-  sessionChangesetMetaTable,
-  leaderMergeCounterTable,
-]
+export const stateSystemTables = [schemaMetaTable, schemaEventDefsMetaTable, sessionChangesetMetaTable] as const
 
 export const isStateSystemTable = (tableName: string) => stateSystemTables.some((_) => _.sqliteDef.name === tableName)
 
@@ -86,8 +69,11 @@ export const eventlogMetaTable = table({
     // TODO Adjust modeling so a global event never needs a client id component
     seqNumGlobal: SqliteDsl.integer({ primaryKey: true, schema: EventSequenceNumber.GlobalEventSequenceNumber }),
     seqNumClient: SqliteDsl.integer({ primaryKey: true, schema: EventSequenceNumber.ClientEventSequenceNumber }),
+    seqNumRebaseGeneration: SqliteDsl.integer({ primaryKey: true }),
     parentSeqNumGlobal: SqliteDsl.integer({ schema: EventSequenceNumber.GlobalEventSequenceNumber }),
     parentSeqNumClient: SqliteDsl.integer({ schema: EventSequenceNumber.ClientEventSequenceNumber }),
+    parentSeqNumRebaseGeneration: SqliteDsl.integer({}),
+    /** Event definition name */
     name: SqliteDsl.text({}),
     argsJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Any) }),
     clientId: SqliteDsl.text({}),
@@ -97,7 +83,7 @@ export const eventlogMetaTable = table({
   },
   indexes: [
     { columns: ['seqNumGlobal'], name: 'idx_eventlog_seqNumGlobal' },
-    { columns: ['seqNumGlobal', 'seqNumClient'], name: 'idx_eventlog_seqNum' },
+    { columns: ['seqNumGlobal', 'seqNumClient', 'seqNumRebaseGeneration'], name: 'idx_eventlog_seqNum' },
   ],
 })
 
@@ -105,6 +91,7 @@ export type EventlogMetaRow = typeof eventlogMetaTable.Type
 
 export const SYNC_STATUS_TABLE = '__livestore_sync_status'
 
+// TODO support sync backend identity (to detect if sync backend changes)
 export const syncStatusTable = table({
   name: SYNC_STATUS_TABLE,
   columns: {
@@ -114,4 +101,4 @@ export const syncStatusTable = table({
 
 export type SyncStatusRow = typeof syncStatusTable.Type
 
-export const eventlogSystemTables = [eventlogMetaTable, syncStatusTable]
+export const eventlogSystemTables = [eventlogMetaTable, syncStatusTable] as const

package/src/schema/state/sqlite/table-def.ts

@@ -1,4 +1,4 @@
-import { type Nullable } from '@livestore/utils'
+import type { Nullable } from '@livestore/utils'
 import type { Schema, Types } from '@livestore/utils/effect'
 
 import { SqliteDsl } from './db-schema/mod.js'

package/src/schema-management/migrations.ts

@@ -1,7 +1,9 @@
 import { memoizeByStringifyArgs } from '@livestore/utils'
 import { Effect, Schema as EffectSchema } from '@livestore/utils/effect'
 
-import type { MigrationsReport, MigrationsReportEntry, SqliteDb, UnexpectedError } from '../adapter-types.js'
+import type { SqliteDb } from '../adapter-types.js'
+import type { MigrationsReport, MigrationsReportEntry } from '../defs.js'
+import type { UnexpectedError } from '../errors.js'
 import type { LiveStoreSchema } from '../schema/mod.js'
 import { SqliteAst, SqliteDsl } from '../schema/state/sqlite/db-schema/mod.js'
 import type { SchemaEventDefsMetaRow, SchemaMetaRow } from '../schema/state/sqlite/system-tables.js'

package/src/sql-queries/sql-queries.ts

@@ -106,6 +106,7 @@ export const insertRows = <TColumns extends SqliteDsl.Columns>({
 
   const bindValues = valuesArray.reduce(
     (acc, values, itemIndex) => ({
+      // biome-ignore lint/performance/noAccumulatingSpread: TODO improve this some day
       ...acc,
       ...makeBindValues({ columns, values, variablePrefix: `item_${itemIndex}_` }),
     }),
@@ -292,6 +293,7 @@ Error: ${parseErrorStr}
 Value:`,
             value,
           )
+          // biome-ignore lint/suspicious/noDebugger: debug
           debugger
           throw res.left
         } else {

package/src/sqlite-types.ts

@@ -0,0 +1,76 @@
+import { type Effect, Schema } from '@livestore/utils/effect'
+import type { SqliteError, UnexpectedError } from './errors.js'
+import type { EventSequenceNumber } from './schema/mod.js'
+import type { QueryBuilder } from './schema/state/sqlite/query-builder/api.js'
+import type { PreparedBindValues } from './util.js'
+
+/**
+ * Common interface for SQLite databases used by LiveStore to facilitate a consistent API across different platforms.
+ * Always assumes a synchronous SQLite build with the `bytecode` and `session` extensions enabled.
+ * Can be either in-memory or persisted to disk.
+ */
+export interface SqliteDb<TReq = any, TMetadata extends TReq = TReq> {
+  _tag: 'SqliteDb'
+  metadata: TMetadata
+  /** Debug information (currently not persisted and only available at runtime) */
+  debug: SqliteDebugInfo
+  prepare(queryStr: string): PreparedStatement
+  execute(
+    queryStr: string,
+    bindValues?: PreparedBindValues | undefined,
+    options?: { onRowsChanged?: (rowsChanged: number) => void },
+  ): void
+  execute(queryBuilder: QueryBuilder.Any, options?: { onRowsChanged?: (rowsChanged: number) => void }): void
+
+  select<T>(queryStr: string, bindValues?: PreparedBindValues | undefined): ReadonlyArray<T>
+  select<T>(queryBuilder: QueryBuilder<T, any, any>): T
+
+  export(): Uint8Array
+  import: (data: Uint8Array | SqliteDb<TReq>) => void
+  close(): void
+  destroy(): void
+  session(): SqliteDbSession
+  makeChangeset: (data: Uint8Array) => SqliteDbChangeset
+}
+
+export type SqliteDebugInfo = { head: EventSequenceNumber.EventSequenceNumber }
+
+// TODO refactor this helper type. It's quite cumbersome to use and should be revisited.
+export type MakeSqliteDb<
+  TReq = { dbPointer: number; persistenceInfo: PersistenceInfo },
+  TInput_ extends { _tag: string } = { _tag: string },
+  TMetadata_ extends TReq = TReq,
+  R = never,
+> = <
+  TInput extends TInput_,
+  TMetadata extends TMetadata_ & { _tag: TInput['_tag'] } = TMetadata_ & { _tag: TInput['_tag'] },
+>(
+  input: TInput,
+) => Effect.Effect<SqliteDb<TReq, Extract<TMetadata, { _tag: TInput['_tag'] }>>, SqliteError | UnexpectedError, R>
+
+export interface PreparedStatement {
+  execute(bindValues: PreparedBindValues | undefined, options?: { onRowsChanged?: (rowsChanged: number) => void }): void
+  select<T>(bindValues: PreparedBindValues | undefined): ReadonlyArray<T>
+  finalize(): void
+  sql: string
+}
+
+export type SqliteDbSession = {
+  changeset: () => Uint8Array | undefined
+  finish: () => void
+}
+
+export type SqliteDbChangeset = {
+  // TODO combining changesets (requires changes in the SQLite WASM binding)
+  invert: () => SqliteDbChangeset
+  apply: () => void
+}
+
+export const PersistenceInfo = Schema.Struct(
+  {
+    fileName: Schema.String,
+  },
+  { key: Schema.String, value: Schema.Any },
+).annotations({ title: 'LiveStore.PersistenceInfo' })
+
+export type PersistenceInfo<With extends {} = {}> = typeof PersistenceInfo.Type & With

package/src/sync/ClientSessionSyncProcessor.ts

@@ -4,11 +4,10 @@ import { Option, type Runtime, type Scope } from '@livestore/utils/effect'
 import { BucketQueue, Effect, FiberHandle, Queue, Schema, Stream, Subscribable } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 
-import type { ClientSession, UnexpectedError } from '../adapter-types.js'
+import { type ClientSession, SyncError, type UnexpectedError } from '../adapter-types.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'
+import { getEventDef, type LiveStoreSchema } from '../schema/mod.js'
 import * as SyncState from './syncstate.js'
 
 /**
@@ -21,6 +20,10 @@ import * as SyncState from './syncstate.js'
  * - We might need to make the rebase behaviour configurable e.g. to let users manually trigger a rebase
  *
  * Longer term we should evalutate whether we can unify the ClientSessionSyncProcessor with the LeaderSyncProcessor.
+ *
+ * The session and leader sync processor are different in the following ways:
+ * - The leader sync processor pulls regular LiveStore events, while the session sync processor pulls SyncState.PayloadUpstream items
+ * - The session sync processor has no downstream nodes.
  */
 export const makeClientSessionSyncProcessor = ({
   schema,
@@ -37,7 +40,7 @@ export const makeClientSessionSyncProcessor = ({
   clientSession: ClientSession
   runtime: Runtime.Runtime<Scope.Scope>
   materializeEvent: (
-    eventDecoded: LiveStoreEvent.PartialAnyDecoded,
+    eventDecoded: LiveStoreEvent.AnyDecoded,
     options: { otelContext: otel.Context; withChangeset: boolean; materializerHashLeader: Option.Option<number> },
   ) => {
     writeTables: Set<string>
@@ -82,7 +85,10 @@ export const makeClientSessionSyncProcessor = ({
     let baseEventSequenceNumber = syncStateRef.current.localHead
     const encodedEventDefs = batch.map(({ name, args }) => {
       const eventDef = getEventDef(schema, name)
-      const nextNumPair = EventSequenceNumber.nextPair(baseEventSequenceNumber, eventDef.eventDef.options.clientOnly)
+      const nextNumPair = EventSequenceNumber.nextPair({
+        seqNum: baseEventSequenceNumber,
+        isClient: eventDef.eventDef.options.clientOnly,
+      })
       baseEventSequenceNumber = nextNumPair.seqNum
       return new LiveStoreEvent.EncodedWithMeta(
         Schema.encodeUnknownSync(eventSchema)({
@@ -103,7 +109,7 @@ export const makeClientSessionSyncProcessor = ({
     })
 
     if (mergeResult._tag === 'unexpected-error') {
-      return shouldNeverHappen('Unexpected error in client-session-sync-processor', mergeResult.cause)
+      return shouldNeverHappen('Unexpected error in client-session-sync-processor', mergeResult.message)
     }
 
     span.addEvent('local-push', {
@@ -184,18 +190,11 @@ export const makeClientSessionSyncProcessor = ({
 
     yield* FiberHandle.run(leaderPushingFiberHandle, backgroundLeaderPushing)
 
-    const getMergeCounter = () =>
-      clientSession.sqliteDb.select<{ mergeCounter: number }>(
-        sql`SELECT mergeCounter FROM ${SystemTables.LEADER_MERGE_COUNTER_TABLE} WHERE id = 0`,
-      )[0]?.mergeCounter ?? 0
-
     // 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(), eventNum: syncStateRef.current.localHead },
-      }),
+      clientSession.leaderThread.events.pull({ cursor: syncStateRef.current.upstreamHead }),
     ).pipe(
-      Stream.tap(({ payload, mergeCounter: leaderMergeCounter }) =>
+      Stream.tap(({ payload }) =>
         Effect.gen(function* () {
           // yield* Effect.logDebug('ClientSessionSyncProcessor:pull', payload)
 
@@ -211,13 +210,13 @@ export const makeClientSessionSyncProcessor = ({
           })
 
           if (mergeResult._tag === 'unexpected-error') {
-            return yield* Effect.fail(mergeResult.cause)
+            return yield* new SyncError({ cause: mergeResult.message })
           } else if (mergeResult._tag === 'reject') {
             return shouldNeverHappen('Unexpected reject in client-session-sync-processor', mergeResult)
           }
 
           syncStateRef.current = mergeResult.newSyncState
-          syncStateUpdateQueue.offer(mergeResult.newSyncState).pipe(Effect.runSync)
+          yield* syncStateUpdateQueue.offer(mergeResult.newSyncState)
 
           if (mergeResult._tag === 'rebase') {
             span.addEvent('merge:pull:rebase', {
@@ -226,7 +225,7 @@ export const makeClientSessionSyncProcessor = ({
               newEventsCount: mergeResult.newEvents.length,
               rollbackCount: mergeResult.rollbackEvents.length,
               res: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
-              leaderMergeCounter,
+              rebaseGeneration: mergeResult.newSyncState.localHead.rebaseGeneration,
             })
 
             debugInfo.rebaseCount++
@@ -243,7 +242,6 @@ export const makeClientSessionSyncProcessor = ({
                 'merge:pull:rebase: rollback',
                 mergeResult.rollbackEvents.length,
                 ...mergeResult.rollbackEvents.slice(0, 10).map((_) => _.toJSON()),
-                { leaderMergeCounter },
               ).pipe(Effect.provide(runtime), Effect.runSync)
             }
 
@@ -263,7 +261,6 @@ export const makeClientSessionSyncProcessor = ({
               payload: TRACE_VERBOSE ? JSON.stringify(payload) : undefined,
               newEventsCount: mergeResult.newEvents.length,
               res: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
-              leaderMergeCounter,
             })
 
             debugInfo.advanceCount++

package/src/sync/next/graphology.ts

@@ -14,15 +14,9 @@ export declare class IGraph<
 }
 
 export const DirectedGraph = class DirectedGraph extends graphology.DirectedGraph {
-  constructor(options?: graphologyTypes.GraphOptions) {
-    super(options)
-  }
 } as typeof IGraph
 
 export const Graph = class Graph extends graphology.Graph {
-  constructor(options?: graphologyTypes.GraphOptions) {
-    super(options)
-  }
 } as typeof IGraph
 
 // export const graphology = graphology_ as graphologyTypes

package/src/sync/next/rebase-events.ts

@@ -38,6 +38,7 @@ export const defaultRebaseFn: RebaseFn = ({ pendingLocalEvents }) => {
   return { rebasedLocalEvents: pendingLocalEvents }
 }
 
+// TODO replace in favour of current rebase impl
 export const rebaseEvents = ({
   rebaseFn,
   pendingLocalEvents,

package/src/sync/next/test/compact-events.test.ts

@@ -64,7 +64,7 @@ const factsSetToString = (facts: EventDefFacts, prefix: string) =>
 export const customSerializer = {
   test: (val: unknown) => Array.isArray(val),
   print: (val: unknown[], _serialize: (item: unknown) => string) => {
-    return '[\n' + (val as any[]).map((item) => '  ' + customStringify(item)).join('\n') + '\n]'
+    return `[\n${(val as any[]).map((item) => `  ${customStringify(item)}`).join('\n')}\n]`
   },
 } as any
 

package/src/sync/next/test/event-fixtures.ts

@@ -144,7 +144,10 @@ export const toEventNodes = (
 
   const eventNodes = partialEvents.map((partialEvent) => {
     const eventDef = eventDefs[partialEvent.name]!
-    const eventNum = EventSequenceNumber.nextPair(currentEventSequenceNumber, eventDef.options.clientOnly).seqNum
+    const eventNum = EventSequenceNumber.nextPair({
+      seqNum: currentEventSequenceNumber,
+      isClient: eventDef.options.clientOnly,
+    }).seqNum
     currentEventSequenceNumber = eventNum
 
     const factsSnapshot = factsSnapshotForDag(historyDagFromNodes(nodesAcc, { skipFactsCheck: true }), undefined)
@@ -221,8 +224,14 @@ const getParentNum = (eventNum: EventSequenceNumber.EventSequenceNumber): EventS
   const clientParentNum = eventNum.client - 1
 
   if (clientParentNum < 0) {
-    return EventSequenceNumber.make({ global: globalParentNum - 1, client: EventSequenceNumber.clientDefault })
+    return EventSequenceNumber.make({
+      global: globalParentNum - 1,
+      client: EventSequenceNumber.clientDefault,
+    })
   }
 
-  return EventSequenceNumber.make({ global: globalParentNum, client: clientParentNum })
+  return EventSequenceNumber.make({
+    global: globalParentNum,
+    client: clientParentNum,
+  })
 }

package/src/sync/sync.ts

@@ -80,6 +80,7 @@ export type SyncBackend<TSyncMetadata = Schema.JsonValue> = {
 
 export class IsOfflineError extends Schema.TaggedError<IsOfflineError>()('IsOfflineError', {}) {}
 
+// TODO gt rid of this error in favour of SyncError
 export class InvalidPushError extends Schema.TaggedError<InvalidPushError>()('InvalidPushError', {
   reason: Schema.Union(
     Schema.TaggedStruct('Unexpected', {
@@ -92,10 +93,12 @@ export class InvalidPushError extends Schema.TaggedError<InvalidPushError>()('In
   ),
 }) {}
 
+// TODO gt rid of this error in favour of SyncError
 export class InvalidPullError extends Schema.TaggedError<InvalidPullError>()('InvalidPullError', {
   message: Schema.String,
 }) {}
 
+// TODO gt rid of this error in favour of SyncError
 export class LeaderAheadError extends Schema.TaggedError<LeaderAheadError>()('LeaderAheadError', {
   minimumExpectedNum: EventSequenceNumber.EventSequenceNumber,
   providedNum: EventSequenceNumber.EventSequenceNumber,

package/src/sync/syncstate.test.ts

@@ -7,10 +7,10 @@ import * as SyncState from './syncstate.js'
 
 class TestEvent extends LiveStoreEvent.EncodedWithMeta {
   constructor(
-    seqNum: EventSequenceNumber.EventSequenceNumber | typeof EventSequenceNumber.EventSequenceNumber.Encoded,
-    parentSeqNum: EventSequenceNumber.EventSequenceNumber,
+    seqNum: EventSequenceNumber.EventSequenceNumberInput,
+    parentSeqNum: EventSequenceNumber.EventSequenceNumberInput,
     public readonly payload: string,
-    public readonly isLocal: boolean,
+    public readonly isClient: boolean,
   ) {
     super({
       seqNum: EventSequenceNumber.make(seqNum),
@@ -22,8 +22,8 @@ class TestEvent extends LiveStoreEvent.EncodedWithMeta {
     })
   }
 
-  rebase_ = (parentSeqNum: EventSequenceNumber.EventSequenceNumber) => {
-    return this.rebase(parentSeqNum, this.isLocal)
+  rebase_ = (parentSeqNum: EventSequenceNumber.EventSequenceNumber, rebaseGeneration: number) => {
+    return this.rebase({ parentSeqNum, isClient: this.isClient, rebaseGeneration })
   }
 
   // Only used for Vitest printing
@@ -41,7 +41,7 @@ const e2_1 = new TestEvent({ global: 2, client: 1 }, e2_0.seqNum, 'a', true)
 
 const isEqualEvent = LiveStoreEvent.isEqualEncoded
 
-const isClientEvent = (event: LiveStoreEvent.EncodedWithMeta) => (event as TestEvent).isLocal
+const isClientEvent = (event: LiveStoreEvent.EncodedWithMeta) => (event as TestEvent).isClient
 
 describe('syncstate', () => {
   describe('merge', () => {
@@ -62,8 +62,8 @@ describe('syncstate', () => {
           upstreamHead: EventSequenceNumber.ROOT,
           localHead: e2_0.seqNum,
         })
-        const e1_0_e2_0 = e1_0.rebase_(e2_0.seqNum)
-        const e1_1_e2_1 = e1_1.rebase_(e1_0_e2_0.seqNum)
+        const e1_0_e2_0 = e1_0.rebase_(e2_0.seqNum, 0)
+        const e1_1_e2_1 = e1_1.rebase_(e1_0_e2_0.seqNum, 0)
         const result = merge({
           syncState,
           payload: SyncState.PayloadUpstreamRebase.make({
@@ -71,7 +71,7 @@ describe('syncstate', () => {
             newEvents: [e1_0_e2_0, e1_1_e2_1],
           }),
         })
-        const e2_0_e3_0 = e2_0.rebase_(e1_0_e2_0.seqNum)
+        const e2_0_e3_0 = e2_0.rebase_(e1_0_e2_0.seqNum, 1)
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
         expect(result.newSyncState.upstreamHead).toMatchObject(e1_1_e2_1.seqNum)
@@ -86,7 +86,7 @@ describe('syncstate', () => {
           upstreamHead: EventSequenceNumber.ROOT,
           localHead: e2_0.seqNum,
         })
-        const e1_1_e2_0 = e1_1.rebase_(e1_0.seqNum)
+        const e1_1_e2_0 = e1_1.rebase_(e1_0.seqNum, 0)
         const result = merge({
           syncState,
           payload: SyncState.PayloadUpstreamRebase.make({
@@ -94,7 +94,7 @@ describe('syncstate', () => {
             rollbackEvents: [e1_1],
           }),
         })
-        const e2_0_e3_0 = e2_0.rebase_(e1_1_e2_0.seqNum)
+        const e2_0_e3_0 = e2_0.rebase_(e1_1_e2_0.seqNum, 1)
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
         expect(result.newSyncState.upstreamHead).toMatchObject(e1_1_e2_0.seqNum)
@@ -326,7 +326,7 @@ describe('syncstate', () => {
         })
         const result = merge({ syncState, payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1] }) })
 
-        const e1_0_e1_2 = e1_0.rebase_(e1_1.seqNum)
+        const e1_0_e1_2 = e1_0.rebase_(e1_1.seqNum, 1)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e1_0_e1_2])
@@ -344,7 +344,7 @@ describe('syncstate', () => {
           localHead: e2_0_b.seqNum,
         })
         const result = merge({ syncState, payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e2_0] }) })
-        const e2_0_e3_0 = e2_0_b.rebase_(e2_0.seqNum)
+        const e2_0_e3_0 = e2_0_b.rebase_(e2_0.seqNum, 1)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e2_0_e3_0])
@@ -365,7 +365,7 @@ describe('syncstate', () => {
           payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1, e1_2, e1_3, e2_0] }),
         })
 
-        const e1_0_e3_0 = e1_0.rebase_(e2_0.seqNum)
+        const e1_0_e3_0 = e1_0.rebase_(e2_0.seqNum, 1)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e1_0_e3_0])
@@ -384,7 +384,7 @@ describe('syncstate', () => {
           payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_0, e1_2, e1_3, e2_0] }),
         })
 
-        const e1_1_e2_1 = e1_1.rebase_(e2_0.seqNum)
+        const e1_1_e2_1 = e1_1.rebase_(e2_0.seqNum, 1)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e1_1_e2_1])
@@ -405,8 +405,8 @@ describe('syncstate', () => {
           payload: SyncState.PayloadUpstreamAdvance.make({ newEvents: [e1_1, e1_2, e1_3, e2_0] }),
         })
 
-        const e1_0_e2_1 = e1_0.rebase_(e2_0.seqNum)
-        const e1_1_e2_2 = e1_1.rebase_(e1_0_e2_1.seqNum)
+        const e1_0_e2_1 = e1_0.rebase_(e2_0.seqNum, 1)
+        const e1_1_e2_2 = e1_1.rebase_(e1_0_e2_1.seqNum, 1)
 
         expectRebase(result)
         expectEventArraysEqual(result.newSyncState.pending, [e1_0_e2_1, e1_1_e2_2])