@livestore/common 0.3.0-dev.5 → 0.3.0-dev.50

package/src/schema/table-def.ts

@@ -1,343 +0,0 @@
-import type { Nullable, PrettifyFlat } from '@livestore/db-schema'
-import { SqliteDsl } from '@livestore/db-schema'
-import { shouldNeverHappen } from '@livestore/utils'
-import { ReadonlyRecord, Schema } from '@livestore/utils/effect'
-
-import type { DerivedMutationHelperFns } from '../derived-mutations.js'
-import { makeDerivedMutationDefsForTable } from '../derived-mutations.js'
-import type { QueryBuilder } from '../query-builder/mod.js'
-import { makeQueryBuilder } from '../query-builder/mod.js'
-
-export const { blob, boolean, column, datetime, integer, isColumnDefinition, json, real, text } = SqliteDsl
-
-export { SqliteDsl } from '@livestore/db-schema'
-
-export type StateType = 'singleton' | 'dynamic'
-
-export type DefaultSqliteTableDef = SqliteDsl.TableDefinition<string, SqliteDsl.Columns>
-export type DefaultSqliteTableDefConstrained = SqliteDsl.TableDefinition<string, SqliteDsl.ConstraintColumns>
-
-export type TableDefBase<
-  TSqliteDef extends DefaultSqliteTableDef = DefaultSqliteTableDefConstrained,
-  TOptions extends TableOptions = TableOptions,
-  TSchema = SqliteDsl.StructSchemaForColumns<TSqliteDef['columns']>,
-> = {
-  sqliteDef: TSqliteDef
-  options: TOptions
-  // Derived from `sqliteDef`, so only exposed for convenience
-  schema: TSchema
-}
-
-export type TableDef<
-  TSqliteDef extends DefaultSqliteTableDef = DefaultSqliteTableDefConstrained,
-  TOptions extends TableOptions = TableOptions,
-  // NOTE we're not using `SqliteDsl.StructSchemaForColumns<TSqliteDef['columns']>`
-  // as we don't want the alias type for users to show up, so we're redefining it here
-  TSchema = Schema.Schema<
-    SqliteDsl.AnyIfConstained<
-      TSqliteDef['columns'],
-      { readonly [K in keyof TSqliteDef['columns']]: TSqliteDef['columns'][K]['schema']['Type'] }
-    >,
-    SqliteDsl.AnyIfConstained<
-      TSqliteDef['columns'],
-      { readonly [K in keyof TSqliteDef['columns']]: TSqliteDef['columns'][K]['schema']['Encoded'] }
-    >
-  >,
-> = {
-  sqliteDef: TSqliteDef
-  options: TOptions
-  // Derived from `sqliteDef`, so only exposed for convenience
-  schema: TSchema
-  query: QueryBuilder<ReadonlyArray<Schema.Schema.Type<TSchema>>, TableDef<TSqliteDef & {}, TOptions>>
-} & (TOptions['deriveMutations']['enabled'] extends true
-  ? DerivedMutationHelperFns<TSqliteDef['columns'], TOptions>
-  : {})
-
-export type TableOptionsInput = Partial<{
-  indexes: SqliteDsl.Index[]
-  disableAutomaticIdColumn: boolean
-  isSingleton: boolean
-  deriveMutations:
-    | boolean
-    | {
-        enabled: true
-        localOnly?: boolean
-      }
-}>
-
-type ToColumns<TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>> =
-  TColumns extends SqliteDsl.Columns
-    ? TColumns
-    : TColumns extends SqliteDsl.ColumnDefinition<any, any>
-      ? { value: TColumns }
-      : never
-
-type ValidateTableOptionsInput<
-  TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>,
-  TOptionsInput extends TableOptionsInput,
-  TPassthroughIfValid,
-> =
-  SqliteDsl.FromColumns.RequiresInsertValues<ToColumns<TColumns>> extends true
-    ? TOptionsInput['isSingleton'] extends true
-      ? 'Error: To use `isSingleton: true` with this table, each column must have a default value or be nullable'
-      : TPassthroughIfValid
-    : TPassthroughIfValid
-
-export type TableOptions = {
-  /**
-   * Setting this to true will have the following consequences:
-   * - An `id` column will be added with `primaryKey: true` and `"singleton"` as default value and only allowed value
-   * - LiveStore will automatically create the singleton row when booting up
-   * - LiveStore will fail if there is already a column defined with `primaryKey: true`
-   *
-   * @default false
-   */
-  readonly isSingleton: boolean
-
-  readonly disableAutomaticIdColumn: boolean
-
-  /**
-   * Setting this to true will automatically derive insert, update and delete mutations for this table. Example:
-   *
-   * ```ts
-   * const todos = table('todos', { ... }, { deriveMutations: true })
-   * todos.insert({ id: '1', text: 'Hello' })
-   * ```
-   *
-   * This is also a prerequisite for using the `useRow`, `useAtom` and `rowQuery` APIs.
-   *
-   * Important: When using this option, make sure you're following the "Rules of mutations" for the table schema.
-   */
-  readonly deriveMutations:
-    | { enabled: false }
-    | {
-        enabled: true
-        /**
-         * When set to true, the mutations won't be synced over the network
-         */
-        localOnly: boolean
-      }
-
-  /** Derived based on whether the table definition has one or more columns (besides the `id` column) */
-  readonly isSingleColumn: boolean
-
-  /**
-   * Derived based on whether the table definition has one or more columns (besides the `id` column) that require
-   * insert values (i.e. are not nullable and don't have a default value)
-   *
-   * `isSingleton` tables always imply `requiresInsertValues: false`
-   */
-  readonly requiredInsertColumnNames: string
-}
-
-export const table = <
-  TName extends string,
-  TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>,
-  TOptionsInput extends TableOptionsInput = TableOptionsInput,
->(
-  name: TName,
-  columnOrColumns: TColumns,
-  options?: TOptionsInput,
-): ValidateTableOptionsInput<
-  TColumns,
-  TOptionsInput,
-  TableDef<
-    SqliteTableDefForInput<TName, TColumns, WithDefaults<TOptionsInput, TColumns>>,
-    WithDefaults<TOptionsInput, TColumns>
-  >
-> => {
-  const tablePath = name
-
-  const options_: TableOptions = {
-    isSingleton: options?.isSingleton ?? false,
-    disableAutomaticIdColumn: options?.disableAutomaticIdColumn ?? false,
-    deriveMutations:
-      options?.deriveMutations === true
-        ? { enabled: true as const, localOnly: false }
-        : options?.deriveMutations === false
-          ? { enabled: false as const }
-          : options?.deriveMutations === undefined
-            ? { enabled: false as const }
-            : { enabled: true as const, localOnly: options.deriveMutations.localOnly ?? false },
-    isSingleColumn: SqliteDsl.isColumnDefinition(columnOrColumns) === true,
-    requiredInsertColumnNames: 'type-level-only',
-  }
-
-  const columns = (
-    SqliteDsl.isColumnDefinition(columnOrColumns) ? { value: columnOrColumns } : columnOrColumns
-  ) as SqliteDsl.Columns
-
-  if (options_.disableAutomaticIdColumn === true) {
-    if (columns.id === undefined && options_.isSingleton === true) {
-      shouldNeverHappen(
-        `Cannot create table ${name} with "isSingleton: true" because there is no column with name "id" and "disableAutomaticIdColumn: true" is set`,
-      )
-    }
-  } else if (columns.id === undefined && ReadonlyRecord.some(columns, (_) => _.primaryKey === true) === false) {
-    if (options_.isSingleton) {
-      columns.id = SqliteDsl.text({ schema: Schema.Literal('singleton'), primaryKey: true, default: 'singleton' })
-    } else {
-      columns.id = SqliteDsl.text({ primaryKey: true })
-    }
-  }
-
-  const sqliteDef = SqliteDsl.table(tablePath, columns, options?.indexes ?? [])
-
-  // TODO also enforce this on the type level
-  if (options_.isSingleton) {
-    for (const column of sqliteDef.ast.columns) {
-      if (column.nullable === false && column.default._tag === 'None') {
-        shouldNeverHappen(
-          `When creating a singleton table, each column must be either nullable or have a default value. Column '${column.name}' is neither.`,
-        )
-      }
-    }
-  }
-
-  const isSingleColumn = SqliteDsl.isColumnDefinition(columnOrColumns) === true
-
-  const schema = SqliteDsl.structSchemaForTable(sqliteDef)
-  const tableDef = { sqliteDef, options: options_, schema } satisfies TableDefBase
-  const query = makeQueryBuilder(tableDef)
-  // const tableDef = { ...tableDefBase, query } satisfies TableDef
-
-  // NOTE we're currently patching the existing tableDef object
-  // as it's being used as part of the query builder API
-  // @ts-expect-error TODO properly implement this
-  tableDef.query = query
-
-  if (tableHasDerivedMutations(tableDef)) {
-    const derivedMutationDefs = makeDerivedMutationDefsForTable(tableDef)
-
-    tableDef.insert = (valuesOrValue: any) => {
-      if (isSingleColumn && options_.isSingleton) {
-        return derivedMutationDefs.insert({ id: 'singleton', value: { value: valuesOrValue } })
-      } else {
-        return derivedMutationDefs.insert(valuesOrValue as any)
-      }
-    }
-
-    tableDef.update = (argsOrValues: any) => {
-      if (isSingleColumn && options_.isSingleton) {
-        return derivedMutationDefs.update({ where: { id: 'singleton' }, values: { value: argsOrValues } as any })
-      } else {
-        return derivedMutationDefs.update(argsOrValues as any)
-      }
-    }
-
-    tableDef.delete = (args: any) => derivedMutationDefs.delete(args)
-  }
-
-  return tableDef as any
-}
-
-export const tableHasDerivedMutations = <TTableDef extends TableDefBase>(
-  tableDef: TTableDef,
-): tableDef is TTableDef & {
-  options: { deriveMutations: { enabled: true; localOnly: boolean } }
-} & DerivedMutationHelperFns<TTableDef['sqliteDef']['columns'], TTableDef['options']> =>
-  tableDef.options.deriveMutations.enabled === true
-
-export const tableIsSingleton = <TTableDef extends TableDefBase>(
-  tableDef: TTableDef,
-): tableDef is TTableDef & { options: { isSingleton: true } } => tableDef.options.isSingleton === true
-
-type SqliteTableDefForInput<
-  TName extends string,
-  TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>,
-  TOptions extends TableOptions,
-> = SqliteDsl.TableDefinition<TName, PrettifyFlat<WithId<ToColumns<TColumns>, TOptions>>>
-
-type WithId<TColumns extends SqliteDsl.Columns, TOptions extends TableOptions> = TColumns &
-  ('id' extends keyof TColumns
-    ? {}
-    : TOptions['disableAutomaticIdColumn'] extends true
-      ? {}
-      : TOptions['isSingleton'] extends true
-        ? {
-            id: SqliteDsl.ColumnDefinition<'singleton', 'singleton'>
-          }
-        : {
-            id: SqliteDsl.ColumnDefinition<string, string>
-          })
-
-type WithDefaults<
-  TOptionsInput extends TableOptionsInput,
-  TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>,
-> = {
-  isSingleton: TOptionsInput['isSingleton'] extends true ? true : false
-  disableAutomaticIdColumn: TOptionsInput['disableAutomaticIdColumn'] extends true ? true : false
-  deriveMutations: TOptionsInput['deriveMutations'] extends true
-    ? { enabled: true; localOnly: boolean }
-    : TOptionsInput['deriveMutations'] extends false
-      ? { enabled: false }
-      : TOptionsInput['deriveMutations'] extends { enabled: true; localOnly?: boolean }
-        ? {
-            enabled: true
-            localOnly: TOptionsInput['deriveMutations']['localOnly'] extends true ? true : false
-          }
-        : never
-  isSingleColumn: SqliteDsl.IsSingleColumn<TColumns>
-  requiredInsertColumnNames: SqliteDsl.FromColumns.RequiredInsertColumnNames<ToColumns<TColumns>>
-}
-
-export namespace FromTable {
-  // TODO this sometimes doesn't preserve the order of columns
-  export type RowDecoded<TTableDef extends TableDefBase> = PrettifyFlat<
-    Nullable<Pick<RowDecodedAll<TTableDef>, NullableColumnNames<TTableDef>>> &
-      Omit<RowDecodedAll<TTableDef>, NullableColumnNames<TTableDef>>
-  >
-
-  export type NullableColumnNames<TTableDef extends TableDefBase> = FromColumns.NullableColumnNames<
-    TTableDef['sqliteDef']['columns']
-  >
-
-  export type Columns<TTableDef extends TableDefBase> = {
-    [K in keyof TTableDef['sqliteDef']['columns']]: TTableDef['sqliteDef']['columns'][K]['columnType']
-  }
-
-  export type RowEncodeNonNullable<TTableDef extends TableDefBase> = {
-    [K in keyof TTableDef['sqliteDef']['columns']]: Schema.Schema.Encoded<
-      TTableDef['sqliteDef']['columns'][K]['schema']
-    >
-  }
-
-  export type RowEncoded<TTableDef extends TableDefBase> = PrettifyFlat<
-    Nullable<Pick<RowEncodeNonNullable<TTableDef>, NullableColumnNames<TTableDef>>> &
-      Omit<RowEncodeNonNullable<TTableDef>, NullableColumnNames<TTableDef>>
-  >
-
-  export type RowDecodedAll<TTableDef extends TableDefBase> = {
-    [K in keyof TTableDef['sqliteDef']['columns']]: Schema.Schema.Type<TTableDef['sqliteDef']['columns'][K]['schema']>
-  }
-}
-
-export namespace FromColumns {
-  // TODO this sometimes doesn't preserve the order of columns
-  export type RowDecoded<TColumns extends SqliteDsl.Columns> = PrettifyFlat<
-    Nullable<Pick<RowDecodedAll<TColumns>, NullableColumnNames<TColumns>>> &
-      Omit<RowDecodedAll<TColumns>, NullableColumnNames<TColumns>>
-  >
-
-  export type RowDecodedAll<TColumns extends SqliteDsl.Columns> = {
-    [K in keyof TColumns]: Schema.Schema.Type<TColumns[K]['schema']>
-  }
-
-  export type RowEncoded<TColumns extends SqliteDsl.Columns> = PrettifyFlat<
-    Nullable<Pick<RowEncodeNonNullable<TColumns>, NullableColumnNames<TColumns>>> &
-      Omit<RowEncodeNonNullable<TColumns>, NullableColumnNames<TColumns>>
-  >
-
-  export type RowEncodeNonNullable<TColumns extends SqliteDsl.Columns> = {
-    [K in keyof TColumns]: Schema.Schema.Encoded<TColumns[K]['schema']>
-  }
-
-  export type NullableColumnNames<TColumns extends SqliteDsl.Columns> = keyof {
-    [K in keyof TColumns as TColumns[K]['default'] extends true ? K : never]: {}
-  }
-
-  export type RequiredInsertColumnNames<TColumns extends SqliteDsl.Columns> =
-    SqliteDsl.FromColumns.RequiredInsertColumnNames<TColumns>
-
-  export type InsertRowDecoded<TColumns extends SqliteDsl.Columns> = SqliteDsl.FromColumns.InsertRowDecoded<TColumns>
-}

package/src/schema-management/validate-mutation-defs.ts

@@ -1,63 +0,0 @@
-import { Effect, Schema } from '@livestore/utils/effect'
-
-import { UnexpectedError } from '../adapter-types.js'
-import type { LiveStoreSchema } from '../schema/mod.js'
-import type { MutationDef } from '../schema/mutations.js'
-import type { MutationDefInfo, SchemaManager } from './common.js'
-
-export const validateSchema = (schema: LiveStoreSchema, schemaManager: SchemaManager) =>
-  Effect.gen(function* () {
-    // Validate mutation definitions
-    const registeredMutationDefInfos = schemaManager.getMutationDefInfos()
-
-    const missingMutationDefs = registeredMutationDefInfos.filter(
-      (registeredMutationDefInfo) => !schema.mutations.has(registeredMutationDefInfo.mutationName),
-    )
-
-    if (missingMutationDefs.length > 0) {
-      yield* new UnexpectedError({
-        cause: `Missing mutation definitions: ${missingMutationDefs.map((info) => info.mutationName).join(', ')}`,
-      })
-    }
-
-    for (const [, mutationDef] of schema.mutations) {
-      const registeredMutationDefInfo = registeredMutationDefInfos.find(
-        (info) => info.mutationName === mutationDef.name,
-      )
-
-      validateMutationDef(mutationDef, schemaManager, registeredMutationDefInfo)
-    }
-
-    // Validate table schemas
-  })
-
-export const validateMutationDef = (
-  mutationDef: MutationDef.Any,
-  schemaManager: SchemaManager,
-  registeredMutationDefInfo: MutationDefInfo | undefined,
-) => {
-  const schemaHash = Schema.hash(mutationDef.schema)
-
-  if (registeredMutationDefInfo === undefined) {
-    schemaManager.setMutationDefInfo({
-      schemaHash,
-      mutationName: mutationDef.name,
-    })
-
-    return
-  }
-
-  if (schemaHash === registeredMutationDefInfo.schemaHash) return
-
-  // TODO bring back some form of schema compatibility check (see https://github.com/livestorejs/livestore/issues/69)
-  // const newSchemaIsCompatibleWithOldSchema = Schema.isSubType(jsonSchemaDefFromMgmtStore, mutationDef.schema)
-
-  // if (!newSchemaIsCompatibleWithOldSchema) {
-  //   shouldNeverHappen(`Schema for mutation ${mutationDef.name} has changed in an incompatible way`)
-  // }
-
-  schemaManager.setMutationDefInfo({
-    schemaHash,
-    mutationName: mutationDef.name,
-  })
-}

package/src/sync/client-session-sync-processor.ts

@@ -1,207 +0,0 @@
-import { LS_DEV, shouldNeverHappen, TRACE_VERBOSE } from '@livestore/utils'
-import type { Scope } from '@livestore/utils/effect'
-import { Effect, Schema, Stream } from '@livestore/utils/effect'
-import * as otel from '@opentelemetry/api'
-
-import type { ClientSessionLeaderThreadProxy, UnexpectedError } from '../adapter-types.js'
-import * as EventId from '../schema/EventId.js'
-import { type LiveStoreSchema } from '../schema/mod.js'
-import * as MutationEvent from '../schema/MutationEvent.js'
-import type { SyncState } from './syncstate.js'
-import { updateSyncState } from './syncstate.js'
-
-/**
- * Rebase behaviour:
- * - We continously pull mutations from the leader and apply them to the local store.
- * - If there was a race condition (i.e. the leader and client session have both advacned),
- *   we'll need to rebase the local pending mutations on top of the leader's head.
- * - The goal is to never block the UI, so we'll interrupt rebasing if a new mutations is pushed by the client session.
- * - We also want to avoid "backwards-jumping" in the UI, so we'll transactionally apply a read model changes during a rebase.
- * - We might need to make the rebase behaviour configurable e.g. to let users manually trigger a rebase
- */
-export const makeClientSessionSyncProcessor = ({
-  schema,
-  initialLeaderHead,
-  pushToLeader,
-  pullFromLeader,
-  applyMutation,
-  rollback,
-  refreshTables,
-  span,
-}: {
-  schema: LiveStoreSchema
-  initialLeaderHead: EventId.EventId
-  pushToLeader: (batch: ReadonlyArray<MutationEvent.AnyEncoded>) => void
-  pullFromLeader: ClientSessionLeaderThreadProxy['mutations']['pull']
-  applyMutation: (
-    mutationEventDecoded: MutationEvent.PartialAny,
-    options: { otelContext: otel.Context; withChangeset: boolean },
-  ) => {
-    writeTables: Set<string>
-    sessionChangeset: Uint8Array | undefined
-  }
-  rollback: (changeset: Uint8Array) => void
-  refreshTables: (tables: Set<string>) => void
-  // rebaseBehaviour: 'auto-rebase' | 'manual-rebase'
-  span: otel.Span
-}): ClientSessionSyncProcessor => {
-  const mutationEventSchema = MutationEvent.makeMutationEventSchemaMemo(schema)
-
-  const syncStateRef = {
-    current: {
-      localHead: initialLeaderHead,
-      upstreamHead: initialLeaderHead,
-      pending: [],
-      // TODO init rollbackTail from leader to be ready for backend rebasing
-      rollbackTail: [],
-    } as SyncState,
-  }
-
-  const isLocalEvent = (mutationEventEncoded: MutationEvent.EncodedWithMeta) => {
-    const mutationDef = schema.mutations.get(mutationEventEncoded.mutation)!
-    return mutationDef.options.localOnly
-  }
-
-  const push: ClientSessionSyncProcessor['push'] = (batch, { otelContext }) => {
-    // TODO validate batch
-
-    let baseEventId = syncStateRef.current.localHead
-    const encodedMutationEvents = batch.map((mutationEvent) => {
-      const mutationDef = schema.mutations.get(mutationEvent.mutation)!
-      const nextIdPair = EventId.nextPair(baseEventId, mutationDef.options.localOnly)
-      baseEventId = nextIdPair.id
-      return new MutationEvent.EncodedWithMeta(
-        Schema.encodeUnknownSync(mutationEventSchema)({ ...mutationEvent, ...nextIdPair }),
-      )
-    })
-
-    const updateResult = updateSyncState({
-      syncState: syncStateRef.current,
-      payload: { _tag: 'local-push', newEvents: encodedMutationEvents },
-      isLocalEvent,
-      isEqualEvent: MutationEvent.isEqualEncoded,
-    })
-
-    span.addEvent('local-push', {
-      batchSize: encodedMutationEvents.length,
-      updateResult: TRACE_VERBOSE ? JSON.stringify(updateResult) : undefined,
-    })
-
-    if (updateResult._tag !== 'advance') {
-      return shouldNeverHappen(`Expected advance, got ${updateResult._tag}`)
-    }
-
-    syncStateRef.current = updateResult.newSyncState
-
-    const writeTables = new Set<string>()
-    for (const mutationEvent of updateResult.newEvents) {
-      // TODO avoid encoding and decoding here again
-      const decodedMutationEvent = Schema.decodeSync(mutationEventSchema)(mutationEvent)
-      const res = applyMutation(decodedMutationEvent, { otelContext, withChangeset: true })
-      for (const table of res.writeTables) {
-        writeTables.add(table)
-      }
-      mutationEvent.meta.sessionChangeset = res.sessionChangeset
-    }
-
-    pushToLeader(encodedMutationEvents)
-
-    return { writeTables }
-  }
-
-  const otelContext = otel.trace.setSpan(otel.context.active(), span)
-
-  const boot: ClientSessionSyncProcessor['boot'] = Effect.gen(function* () {
-    yield* pullFromLeader.pipe(
-      Stream.tap(({ payload, remaining }) =>
-        Effect.gen(function* () {
-          // console.log('pulled payload from leader', { payload, remaining })
-
-          const updateResult = updateSyncState({
-            syncState: syncStateRef.current,
-            payload,
-            isLocalEvent,
-            isEqualEvent: MutationEvent.isEqualEncoded,
-          })
-
-          if (updateResult._tag === 'reject') {
-            debugger
-            throw new Error('TODO: implement reject in client-session-sync-queue for pull')
-          }
-
-          syncStateRef.current = updateResult.newSyncState
-
-          if (updateResult._tag === 'rebase') {
-            span.addEvent('pull:rebase', {
-              payloadTag: payload._tag,
-              payload: TRACE_VERBOSE ? JSON.stringify(payload) : undefined,
-              newEventsCount: updateResult.newEvents.length,
-              rollbackCount: updateResult.eventsToRollback.length,
-              res: TRACE_VERBOSE ? JSON.stringify(updateResult) : undefined,
-              remaining,
-            })
-            if (LS_DEV) {
-              console.debug(
-                'pull:rebase: rollback',
-                updateResult.eventsToRollback.length,
-                ...updateResult.eventsToRollback.map((_) => _.toJSON()),
-              )
-            }
-
-            for (let i = updateResult.eventsToRollback.length - 1; i >= 0; i--) {
-              const event = updateResult.eventsToRollback[i]!
-              if (event.meta.sessionChangeset) {
-                rollback(event.meta.sessionChangeset)
-                event.meta.sessionChangeset = undefined
-              }
-            }
-          } else {
-            span.addEvent('pull:advance', {
-              payloadTag: payload._tag,
-              payload: TRACE_VERBOSE ? JSON.stringify(payload) : undefined,
-              newEventsCount: updateResult.newEvents.length,
-              res: TRACE_VERBOSE ? JSON.stringify(updateResult) : undefined,
-              remaining,
-            })
-          }
-
-          if (updateResult.newEvents.length === 0) return
-
-          const writeTables = new Set<string>()
-          for (const mutationEvent of updateResult.newEvents) {
-            const decodedMutationEvent = Schema.decodeSync(mutationEventSchema)(mutationEvent)
-            const res = applyMutation(decodedMutationEvent, { otelContext, withChangeset: true })
-            for (const table of res.writeTables) {
-              writeTables.add(table)
-            }
-
-            mutationEvent.meta.sessionChangeset = res.sessionChangeset
-          }
-
-          refreshTables(writeTables)
-        }),
-      ),
-      Stream.runDrain,
-      Effect.tapCauseLogPretty,
-      Effect.forkScoped,
-    )
-  })
-
-  return {
-    push,
-    boot,
-    syncStateRef,
-  } satisfies ClientSessionSyncProcessor
-}
-
-export interface ClientSessionSyncProcessor {
-  push: (
-    batch: ReadonlyArray<MutationEvent.PartialAny>,
-    options: { otelContext: otel.Context },
-  ) => {
-    writeTables: Set<string>
-  }
-  boot: Effect.Effect<void, UnexpectedError, Scope.Scope>
-
-  syncStateRef: { current: SyncState }
-}