@livestore/common 0.2.0-dev.2 → 0.3.0-dev.0

package/src/adapter-types.ts

@@ -2,7 +2,10 @@ import type { Cause, Queue, Scope, SubscriptionRef, WebChannel } from '@livestor
 import { Effect, Schema, Stream } from '@livestore/utils/effect'
 
 import type * as Devtools from './devtools/index.js'
-import type { LiveStoreSchema, MutationEvent } from './schema/index.js'
+import type { EventId } from './schema/EventId.js'
+import type { LiveStoreSchema, MutationEvent } from './schema/mod.js'
+import type { InvalidPushError } from './sync/sync.js'
+import type { PayloadUpstream, SyncState } from './sync/syncstate.js'
 import type { PreparedBindValues } from './util.js'
 
 export interface PreparedStatement {
@@ -12,6 +15,17 @@ export interface PreparedStatement {
   sql: string
 }
 
+export type SynchronousDatabaseSession = {
+  changeset: () => Uint8Array | undefined
+  finish: () => void
+}
+
+export type SynchronousDatabaseChangeset = {
+  // TODO combining changesets (requires changes in the SQLite WASM binding)
+  invert: () => SynchronousDatabaseChangeset
+  apply: () => void
+}
+
 export type ClientSession = {
   /** SQLite database with synchronous API running in the same thread (usually in-memory) */
   syncDb: SynchronousDatabase
@@ -19,8 +33,9 @@ export type ClientSession = {
   coordinator: Coordinator
 }
 
-export type SynchronousDatabase = {
+export type SynchronousDatabase<TReq = any, TMetadata extends TReq = TReq> = {
   _tag: 'SynchronousDatabase'
+  metadata: TMetadata
   prepare(queryStr: string): PreparedStatement
   execute(
     queryStr: string,
@@ -29,9 +44,38 @@ export type SynchronousDatabase = {
   ): void
   select<T>(queryStr: string, bindValues?: PreparedBindValues | undefined): ReadonlyArray<T>
   export(): Uint8Array
+  import: (data: Uint8Array | SynchronousDatabase<TReq>) => void
   close(): void
+  destroy(): void
+  session(): SynchronousDatabaseSession
+  makeChangeset: (data: Uint8Array) => SynchronousDatabaseChangeset
 }
 
+export type MakeSynchronousDatabase<
+  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<
+  SynchronousDatabase<TReq, Extract<TMetadata, { _tag: TInput['_tag'] }>>,
+  SqliteError | UnexpectedError,
+  R
+>
+
+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
+
 export type ResetMode = 'all-data' | 'only-app-db'
 
 export const NetworkStatus = Schema.Struct({
@@ -55,10 +99,11 @@ export const BootStatus = Schema.Union(
   Schema.Struct({ stage: Schema.Literal('rehydrating'), progress: BootStateProgress }),
   Schema.Struct({ stage: Schema.Literal('syncing'), progress: BootStateProgress }),
   Schema.Struct({ stage: Schema.Literal('done') }),
-)
+).annotations({ title: 'BootStatus' })
 
 export type BootStatus = typeof BootStatus.Type
 
+// TODO refactor `Coordinator` to embrace more of the "leader semantics"
 export type Coordinator = {
   devtools: {
     enabled: boolean
@@ -68,19 +113,16 @@ export type Coordinator = {
   sessionId: string
   // TODO is exposing the lock status really needed (or only relevant for web adapter?)
   lockStatus: SubscriptionRef.SubscriptionRef<LockStatus>
-  syncMutations: Stream.Stream<MutationEvent.Any, UnexpectedError>
-  execute(queryStr: string, bindValues: PreparedBindValues | undefined): Effect.Effect<void, UnexpectedError>
-  mutate(
-    mutationEventEncoded: MutationEvent.AnyEncoded,
-    options: { persisted: boolean },
-  ): Effect.Effect<void, UnexpectedError>
-  /** Can be called synchronously */
-  nextMutationEventIdPair: (opts: { localOnly: boolean }) => Effect.Effect<EventIdPair, UnexpectedError>
-  /** Used to initially get the current mutation event id to use as `parentId` for the next mutation event */
-  getCurrentMutationEventId: Effect.Effect<EventId, UnexpectedError>
-  export: Effect.Effect<Uint8Array | undefined, UnexpectedError>
+  mutations: {
+    pull: Stream.Stream<{ payload: PayloadUpstream; remaining: number }, UnexpectedError>
+    push(batch: ReadonlyArray<MutationEvent.AnyEncoded>): Effect.Effect<void, UnexpectedError | InvalidPushError>
+    initialMutationEventId: EventId
+  }
+  export: Effect.Effect<Uint8Array, UnexpectedError>
   getMutationLogData: Effect.Effect<Uint8Array, UnexpectedError>
+  getLeaderSyncState: Effect.Effect<SyncState, UnexpectedError>
   networkStatus: SubscriptionRef.SubscriptionRef<NetworkStatus>
+  shutdown: (cause: Cause.Cause<UnexpectedError | IntentionalShutdownCause>) => Effect.Effect<void>
 }
 
 /**
@@ -97,23 +139,6 @@ export type SessionIdSymbol = typeof SessionIdSymbol
 
 export type LockStatus = 'has-lock' | 'no-lock'
 
-/**
- * LiveStore event id value consisting of a globally unique event sequence number
- * and a local sequence number.
- *
- * The local sequence number is only used for localOnly mutations and starts from 0 for each global sequence number.
- */
-export type EventId = { global: number; local: number }
-
-export const EventId = Schema.Struct({
-  global: Schema.Number,
-  local: Schema.Number,
-}).annotations({ title: 'LiveStore.EventId' })
-
-export type EventIdPair = { id: EventId; parentId: EventId }
-
-export const ROOT_ID = { global: -1, local: 0 } satisfies EventId
-
 export class UnexpectedError extends Schema.TaggedError<UnexpectedError>()('LiveStore.UnexpectedError', {
   cause: Schema.Defect,
   note: Schema.optional(Schema.String),
@@ -134,7 +159,7 @@ export class UnexpectedError extends Schema.TaggedError<UnexpectedError>()('Live
 export class IntentionalShutdownCause extends Schema.TaggedError<IntentionalShutdownCause>()(
   'LiveStore.IntentionalShutdownCause',
   {
-    reason: Schema.Literal('devtools-reset', 'devtools-import'),
+    reason: Schema.Literal('devtools-reset', 'devtools-import', 'manual'),
   },
 ) {}
 
@@ -190,8 +215,8 @@ export type MigrationOptionsFromMutationLog<TSchema extends LiveStoreSchema = Li
 }
 
 export type StoreDevtoolsChannel = WebChannel.WebChannel<
-  Devtools.MessageToAppHostStore,
-  Devtools.MessageFromAppHostStore
+  Devtools.MessageToAppClientSession,
+  Devtools.MessageFromAppClientSession
 >
 
 export type ConnectDevtoolsToStore = (
@@ -202,6 +227,7 @@ export type Adapter = (opts: {
   schema: LiveStoreSchema
   storeId: string
   devtoolsEnabled: boolean
+  debugInstanceId: string
   bootStatusQueue: Queue.Queue<BootStatus>
   shutdown: (cause: Cause.Cause<any>) => Effect.Effect<void>
   connectDevtoolsToStore: ConnectDevtoolsToStore

package/src/derived-mutations.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from 'vitest'
 
 import { appConfig, todos } from './__tests__/fixture.js'
-import type { MutationEvent } from './schema/mutations.js'
+import type * as MutationEvent from './schema/MutationEvent.js'
 
 describe('derived mutations', () => {
   test('todos', () => {

package/src/derived-mutations.ts

@@ -2,7 +2,7 @@ import type { SqliteDsl } from '@livestore/db-schema'
 import type { GetValForKey } from '@livestore/utils'
 import { ReadonlyRecord, Schema } from '@livestore/utils/effect'
 
-import type { MutationEvent } from './schema/mutations.js'
+import type * as MutationEvent from './schema/MutationEvent.js'
 import { defineMutation } from './schema/mutations.js'
 import { getDefaultValuesDecoded } from './schema/schema-helpers.js'
 import type * as DbSchema from './schema/table-def.js'

package/src/devtools/devtools-bridge.ts

@@ -4,8 +4,8 @@ import type * as Devtools from './devtools-messages.js'
 
 export type PrepareDevtoolsBridge = {
   /** Messages coming from the app host (usually responses to requests) */
-  responsePubSub: PubSub.PubSub<Devtools.MessageFromAppHostCoordinator | Devtools.MessageFromAppHostStore>
-  sendToAppHost: (msg: Devtools.MessageToAppHostCoordinator | Devtools.MessageToAppHostStore) => Effect.Effect<void>
+  responsePubSub: PubSub.PubSub<Devtools.MessageFromAppLeader | Devtools.MessageFromAppClientSession>
+  sendToAppHost: (msg: Devtools.MessageToAppLeader | Devtools.MessageToAppClientSession) => Effect.Effect<void>
   appHostId: string
   copyToClipboard: (text: string) => Effect.Effect<void>
   sendEscapeKey?: Effect.Effect<void>

package/src/devtools/devtools-messages.ts

@@ -2,7 +2,7 @@ import { Schema, Transferable } from '@livestore/utils/effect'
 
 import { NetworkStatus } from '../adapter-types.js'
 import { DebugInfo } from '../debug-info.js'
-import { mutationEventSchemaEncodedAny } from '../schema/mutations.js'
+import * as MutationEvent from '../schema/MutationEvent.js'
 import { PreparedBindValues } from '../util.js'
 import { liveStoreVersion as pkgVersion } from '../version.js'
 
@@ -17,8 +17,20 @@ const LSDMessage = <Tag extends string, Fields extends Schema.Struct.Fields>(tag
   }).annotations({ identifier: tag })
 
 const LSDChannelMessage = <Tag extends string, Fields extends Schema.Struct.Fields>(tag: Tag, fields: Fields) =>
+  LSDMessage(tag, {
+    ...fields,
+  })
+
+const LSDStoreChannelMessage = <Tag extends string, Fields extends Schema.Struct.Fields>(tag: Tag, fields: Fields) =>
+  LSDMessage(tag, {
+    appHostId,
+    ...fields,
+  })
+
+const LSDStoreReqResMessage = <Tag extends string, Fields extends Schema.Struct.Fields>(tag: Tag, fields: Fields) =>
   LSDMessage(tag, {
     appHostId,
+    requestId,
     ...fields,
   })
 
@@ -28,77 +40,77 @@ const LSDReqResMessage = <Tag extends string, Fields extends Schema.Struct.Field
     ...fields,
   })
 
-export class SnapshotReq extends LSDReqResMessage('LSD.SnapshotReq', {}) {}
+export class SnapshotReq extends LSDReqResMessage('LSD.Leader.SnapshotReq', {}) {}
 
-export class SnapshotRes extends LSDReqResMessage('LSD.SnapshotRes', {
+export class SnapshotRes extends LSDReqResMessage('LSD.Leader.SnapshotRes', {
   snapshot: Transferable.Uint8Array,
 }) {}
 
-export class LoadDatabaseFileReq extends LSDReqResMessage('LSD.LoadDatabaseFileReq', {
+export class LoadDatabaseFileReq extends LSDReqResMessage('LSD.Leader.LoadDatabaseFileReq', {
   data: Transferable.Uint8Array,
 }) {}
 
-export class LoadDatabaseFileRes extends LSDReqResMessage('LSD.LoadDatabaseFileRes', {
+export class LoadDatabaseFileRes extends LSDReqResMessage('LSD.Leader.LoadDatabaseFileRes', {
   status: Schema.Literal('ok', 'unsupported-file', 'unsupported-database'),
 }) {}
 
-export class DebugInfoReq extends LSDReqResMessage('LSD.DebugInfoReq', {}) {}
+export class DebugInfoReq extends LSDStoreReqResMessage('LSD.DebugInfoReq', {}) {}
 
-export class DebugInfoRes extends LSDReqResMessage('LSD.DebugInfoRes', {
+export class DebugInfoRes extends LSDStoreReqResMessage('LSD.DebugInfoRes', {
   debugInfo: DebugInfo,
 }) {}
 
-export class DebugInfoHistorySubscribe extends LSDReqResMessage('LSD.DebugInfoHistorySubscribe', {}) {}
+export class DebugInfoHistorySubscribe extends LSDStoreReqResMessage('LSD.DebugInfoHistorySubscribe', {}) {}
 
-export class DebugInfoHistoryRes extends LSDReqResMessage('LSD.DebugInfoHistoryRes', {
+export class DebugInfoHistoryRes extends LSDStoreReqResMessage('LSD.DebugInfoHistoryRes', {
   debugInfoHistory: Schema.Array(DebugInfo),
 }) {}
 
-export class DebugInfoHistoryUnsubscribe extends LSDReqResMessage('LSD.DebugInfoHistoryUnsubscribe', {}) {}
+export class DebugInfoHistoryUnsubscribe extends LSDStoreReqResMessage('LSD.DebugInfoHistoryUnsubscribe', {}) {}
 
-export class DebugInfoResetReq extends LSDReqResMessage('LSD.DebugInfoResetReq', {}) {}
+export class DebugInfoResetReq extends LSDStoreReqResMessage('LSD.DebugInfoResetReq', {}) {}
 
-export class DebugInfoResetRes extends LSDReqResMessage('LSD.DebugInfoResetRes', {}) {}
+export class DebugInfoResetRes extends LSDStoreReqResMessage('LSD.DebugInfoResetRes', {}) {}
 
-export class DebugInfoRerunQueryReq extends LSDReqResMessage('LSD.DebugInfoRerunQueryReq', {
+export class DebugInfoRerunQueryReq extends LSDStoreReqResMessage('LSD.DebugInfoRerunQueryReq', {
   queryStr: Schema.String,
   bindValues: Schema.UndefinedOr(PreparedBindValues),
   queriedTables: Schema.ReadonlySet(Schema.String),
 }) {}
 
-export class DebugInfoRerunQueryRes extends LSDReqResMessage('LSD.DebugInfoRerunQueryRes', {}) {}
+export class DebugInfoRerunQueryRes extends LSDStoreReqResMessage('LSD.DebugInfoRerunQueryRes', {}) {}
 
-export class MutationBroadcast extends LSDMessage('LSD.MutationBroadcast', {
-  mutationEventEncoded: mutationEventSchemaEncodedAny,
-  persisted: Schema.Boolean,
+// TODO refactor this to use push/pull semantics
+export class MutationBroadcast extends LSDMessage('LSD.Leader.MutationBroadcast', {
+  mutationEventEncoded: MutationEvent.EncodedAny,
 }) {}
 
-export class RunMutationReq extends LSDReqResMessage('LSD.RunMutationReq', {
-  mutationEventEncoded: mutationEventSchemaEncodedAny.pipe(Schema.omit('id', 'parentId')),
-  persisted: Schema.Boolean,
+// TODO refactor this to use push/pull semantics
+export class RunMutationReq extends LSDReqResMessage('LSD.Leader.RunMutationReq', {
+  mutationEventEncoded: MutationEvent.EncodedAny.pipe(Schema.omit('id', 'parentId')),
 }) {}
 
-export class RunMutationRes extends LSDReqResMessage('LSD.RunMutationRes', {}) {}
+export class RunMutationRes extends LSDReqResMessage('LSD.Leader.RunMutationRes', {}) {}
 
-export class MutationLogReq extends LSDReqResMessage('LSD.MutationLogReq', {}) {}
+export class MutationLogReq extends LSDReqResMessage('LSD.Leader.MutationLogReq', {}) {}
 
-export class MutationLogRes extends LSDReqResMessage('LSD.MutationLogRes', {
+export class MutationLogRes extends LSDReqResMessage('LSD.Leader.MutationLogRes', {
   mutationLog: Transferable.Uint8Array,
 }) {}
 
-export class ReactivityGraphSubscribe extends LSDReqResMessage('LSD.ReactivityGraphSubscribe', {
+export class ReactivityGraphSubscribe extends LSDStoreReqResMessage('LSD.ReactivityGraphSubscribe', {
   includeResults: Schema.Boolean,
 }) {}
 
-export class ReactivityGraphUnsubscribe extends LSDReqResMessage('LSD.ReactivityGraphUnsubscribe', {}) {}
+export class ReactivityGraphUnsubscribe extends LSDStoreReqResMessage('LSD.ReactivityGraphUnsubscribe', {}) {}
 
-export class ReactivityGraphRes extends LSDReqResMessage('LSD.ReactivityGraphRes', {
+export class ReactivityGraphRes extends LSDStoreReqResMessage('LSD.ReactivityGraphRes', {
   reactivityGraph: Schema.Any,
 }) {}
 
-export class LiveQueriesSubscribe extends LSDReqResMessage('LSD.LiveQueriesSubscribe', {}) {}
+export class LiveQueriesSubscribe extends LSDStoreReqResMessage('LSD.LiveQueriesSubscribe', {}) {}
 
-export class LiveQueriesUnsubscribe extends LSDReqResMessage('LSD.LiveQueriesUnsubscribe', {}) {}
+export class LiveQueriesUnsubscribe extends LSDStoreReqResMessage('LSD.LiveQueriesUnsubscribe', {}) {}
 
 export class SerializedLiveQuery extends Schema.Struct({
   _tag: Schema.Literal('computed', 'db', 'graphql'),
@@ -112,95 +124,78 @@ export class SerializedLiveQuery extends Schema.Struct({
   ),
 }) {}
 
-export class LiveQueriesRes extends LSDReqResMessage('LSD.LiveQueriesRes', {
+export class LiveQueriesRes extends LSDStoreReqResMessage('LSD.LiveQueriesRes', {
   liveQueries: Schema.Array(SerializedLiveQuery),
 }) {}
 
-export class ResetAllDataReq extends LSDReqResMessage('LSD.ResetAllDataReq', {
+export class ResetAllDataReq extends LSDReqResMessage('LSD.Leader.ResetAllDataReq', {
   mode: Schema.Literal('all-data', 'only-app-db'),
 }) {}
 
-export class ResetAllDataRes extends LSDReqResMessage('LSD.ResetAllDataRes', {}) {}
+export class ResetAllDataRes extends LSDReqResMessage('LSD.Leader.ResetAllDataRes', {}) {}
 
-export class DatabaseFileInfoReq extends LSDReqResMessage('LSD.DatabaseFileInfoReq', {}) {}
+export class DatabaseFileInfoReq extends LSDReqResMessage('LSD.Leader.DatabaseFileInfoReq', {}) {}
 
 export class DatabaseFileInfo extends Schema.Struct({
   fileSize: Schema.Number,
   persistenceInfo: Schema.Struct({ fileName: Schema.String }, { key: Schema.String, value: Schema.Any }),
 }) {}
 
-export class DatabaseFileInfoRes extends LSDReqResMessage('LSD.DatabaseFileInfoRes', {
+export class DatabaseFileInfoRes extends LSDReqResMessage('LSD.Leader.DatabaseFileInfoRes', {
   db: DatabaseFileInfo,
   mutationLog: DatabaseFileInfo,
 }) {}
 
-export class MessagePortForStoreReq extends LSDReqResMessage('LSD.MessagePortForStoreReq', {}) {}
+export class NetworkStatusSubscribe extends LSDReqResMessage('LSD.Leader.NetworkStatusSubscribe', {}) {}
+export class NetworkStatusUnsubscribe extends LSDReqResMessage('LSD.Leader.NetworkStatusUnsubscribe', {}) {}
 
-export class MessagePortForStoreRes extends LSDReqResMessage('LSD.MessagePortForStoreRes', {
-  port: Transferable.MessagePort,
-}) {}
-
-export class NetworkStatusSubscribe extends LSDReqResMessage('LSD.NetworkStatusSubscribe', {}) {}
-export class NetworkStatusUnsubscribe extends LSDReqResMessage('LSD.NetworkStatusUnsubscribe', {}) {}
-
-export class NetworkStatusRes extends LSDReqResMessage('LSD.NetworkStatusRes', {
+export class NetworkStatusRes extends LSDReqResMessage('LSD.Leader.NetworkStatusRes', {
   networkStatus: NetworkStatus,
 }) {}
 
-export class SyncingInfoReq extends LSDReqResMessage('LSD.SyncingInfoReq', {}) {}
+export class SyncingInfoReq extends LSDReqResMessage('LSD.Leader.SyncingInfoReq', {}) {}
 
 export class SyncingInfo extends Schema.Struct({
   enabled: Schema.Boolean,
   metadata: Schema.Record({ key: Schema.String, value: Schema.Any }),
 }) {}
 
-export class SyncingInfoRes extends LSDReqResMessage('LSD.SyncingInfoRes', {
+export class SyncingInfoRes extends LSDReqResMessage('LSD.Leader.SyncingInfoRes', {
   syncingInfo: SyncingInfo,
 }) {}
 
-export class SyncHistorySubscribe extends LSDReqResMessage('LSD.SyncHistorySubscribe', {}) {}
-export class SyncHistoryUnsubscribe extends LSDReqResMessage('LSD.SyncHistoryUnsubscribe', {}) {}
-export class SyncHistoryRes extends LSDReqResMessage('LSD.SyncHistoryRes', {
-  mutationEventEncoded: mutationEventSchemaEncodedAny,
+export class SyncHistorySubscribe extends LSDReqResMessage('LSD.Leader.SyncHistorySubscribe', {}) {}
+export class SyncHistoryUnsubscribe extends LSDReqResMessage('LSD.Leader.SyncHistoryUnsubscribe', {}) {}
+export class SyncHistoryRes extends LSDReqResMessage('LSD.Leader.SyncHistoryRes', {
+  mutationEventEncoded: MutationEvent.EncodedAny,
   metadata: Schema.Option(Schema.JsonValue),
 }) {}
 
-export class DevtoolsReady extends LSDMessage('LSD.DevtoolsReady', {}) {}
-
-export class DevtoolsConnected extends LSDChannelMessage('LSD.DevtoolsConnected', {}) {}
-
-export class AppHostReady extends LSDChannelMessage('LSD.AppHostReady', {
-  isLeader: Schema.Boolean,
-}) {}
-
-export class Disconnect extends LSDChannelMessage('LSD.Disconnect', {}) {}
+export class Disconnect extends LSDStoreChannelMessage('LSD.Disconnect', {}) {}
 
 export class Ping extends LSDReqResMessage('LSD.Ping', {}) {}
 
 export class Pong extends LSDReqResMessage('LSD.Pong', {}) {}
 
-export const MessageToAppHostCoordinator = Schema.Union(
+export const MessageToAppLeader = Schema.Union(
   SnapshotReq,
   LoadDatabaseFileReq,
   MutationLogReq,
   ResetAllDataReq,
-  MessagePortForStoreRes,
   NetworkStatusSubscribe,
   NetworkStatusUnsubscribe,
-  DevtoolsReady,
   Disconnect,
-  DevtoolsConnected,
   RunMutationReq,
   Ping,
   DatabaseFileInfoReq,
   SyncHistorySubscribe,
   SyncHistoryUnsubscribe,
   SyncingInfoReq,
-).annotations({ identifier: 'LSD.MessageToAppHostCoordinator' })
+).annotations({ identifier: 'LSD.MessageToAppLeader' })
 
-export type MessageToAppHostCoordinator = typeof MessageToAppHostCoordinator.Type
+export type MessageToAppLeader = typeof MessageToAppLeader.Type
 
-export const MessageToAppHostStore = Schema.Union(
+export const MessageToAppClientSession = Schema.Union(
   DebugInfoReq,
   DebugInfoHistorySubscribe,
   DebugInfoHistoryUnsubscribe,
@@ -210,38 +205,39 @@ export const MessageToAppHostStore = Schema.Union(
   ReactivityGraphUnsubscribe,
   LiveQueriesSubscribe,
   LiveQueriesUnsubscribe,
+  Disconnect,
+  // TODO also introduce a ping/pong protocol for the client session <> devtools connection
   // Ping,
-).annotations({ identifier: 'LSD.MessageToAppHostStore' })
+).annotations({ identifier: 'LSD.MessageToAppClientSession' })
 
-export type MessageToAppHostStore = typeof MessageToAppHostStore.Type
+export type MessageToAppClientSession = typeof MessageToAppClientSession.Type
 
-export const MessageFromAppHostCoordinator = Schema.Union(
+export const MessageFromAppLeader = Schema.Union(
   SnapshotRes,
   LoadDatabaseFileRes,
   MutationLogRes,
   ResetAllDataRes,
-  MessagePortForStoreReq,
   Disconnect,
   MutationBroadcast,
-  AppHostReady,
   NetworkStatusRes,
   RunMutationRes,
   Pong,
   DatabaseFileInfoRes,
   SyncHistoryRes,
   SyncingInfoRes,
-).annotations({ identifier: 'LSD.MessageFromAppHostCoordinator' })
+).annotations({ identifier: 'LSD.MessageFromAppLeader' })
 
-export type MessageFromAppHostCoordinator = typeof MessageFromAppHostCoordinator.Type
+export type MessageFromAppLeader = typeof MessageFromAppLeader.Type
 
-export const MessageFromAppHostStore = Schema.Union(
+export const MessageFromAppClientSession = Schema.Union(
   DebugInfoRes,
   DebugInfoHistoryRes,
   DebugInfoResetRes,
   DebugInfoRerunQueryRes,
   ReactivityGraphRes,
   LiveQueriesRes,
+  Disconnect,
   // Pong,
-).annotations({ identifier: 'LSD.MessageFromAppHostStore' })
+).annotations({ identifier: 'LSD.MessageFromAppClientSession' })
 
-export type MessageFromAppHostStore = typeof MessageFromAppHostStore.Type
+export type MessageFromAppClientSession = typeof MessageFromAppClientSession.Type

package/src/devtools/index.ts

@@ -43,7 +43,6 @@ export namespace WebBridge {
   ): Effect.Effect<WebChannel.WebChannel<typeof All.Type, typeof All.Type>, never, Scope.Scope> =>
     WebChannel.broadcastChannel({
       channelName: `livestore-web-bridge-devtools${key ? `-${key}` : ''}`,
-      listenSchema: All,
-      sendSchema: All,
+      schema: All,
     })
 }

package/src/index.ts

@@ -1,7 +1,6 @@
 export * from './schema/system-tables.js'
 export * from './util.js'
 export * from './adapter-types.js'
-export * from './sync/next-mutation-event-id-pair.js'
 export * from './schema-management/migrations.js'
 export * from './mutation.js'
 export * from './init-singleton-tables.js'
@@ -14,6 +13,8 @@ export * from './debug-info.js'
 export * from './bounded-collections.js'
 export * from './version.js'
 export * from './query-builder/mod.js'
+export * from './sync/syncstate.js'
+export * from './otel.js'
 
 declare global {
   interface LiveStoreGlobal {

package/src/init-singleton-tables.ts

@@ -1,5 +1,5 @@
 import type { SynchronousDatabase } from './adapter-types.js'
-import type { LiveStoreSchema } from './schema/index.js'
+import type { LiveStoreSchema } from './schema/mod.js'
 import { getDefaultValuesEncoded } from './schema/schema-helpers.js'
 import { prepareBindValues, sql } from './util.js'