@livestore/common 0.3.0-dev.4 → 0.3.0-dev.41

package/src/devtools/devtools-messages-client-session.ts

@@ -0,0 +1,142 @@
+import { Schema } from '@livestore/utils/effect'
+
+import { DebugInfo } from '../debug-info.js'
+import { EventId } from '../schema/mod.js'
+import { PreparedBindValues } from '../util.js'
+import { LSDClientSessionChannelMessage, LSDClientSessionReqResMessage } from './devtools-messages-common.js'
+
+export class DebugInfoReq extends LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoReq', {}) {}
+
+export class DebugInfoRes extends LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoRes', {
+  debugInfo: DebugInfo,
+}) {}
+
+export class DebugInfoHistorySubscribe extends LSDClientSessionReqResMessage(
+  'LSD.ClientSession.DebugInfoHistorySubscribe',
+  {
+    subscriptionId: Schema.String,
+  },
+) {}
+
+export class DebugInfoHistoryRes extends LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoHistoryRes', {
+  debugInfoHistory: Schema.Array(DebugInfo),
+  subscriptionId: Schema.String,
+}) {}
+
+export class DebugInfoHistoryUnsubscribe extends LSDClientSessionReqResMessage(
+  'LSD.ClientSession.DebugInfoHistoryUnsubscribe',
+  {
+    subscriptionId: Schema.String,
+  },
+) {}
+
+export class DebugInfoResetReq extends LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoResetReq', {}) {}
+
+export class DebugInfoResetRes extends LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoResetRes', {}) {}
+
+export class DebugInfoRerunQueryReq extends LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoRerunQueryReq', {
+  queryStr: Schema.String,
+  bindValues: Schema.UndefinedOr(PreparedBindValues),
+  queriedTables: Schema.ReadonlySet(Schema.String),
+}) {}
+
+export class DebugInfoRerunQueryRes extends LSDClientSessionReqResMessage(
+  'LSD.ClientSession.DebugInfoRerunQueryRes',
+  {},
+) {}
+
+export class SyncHeadSubscribe extends LSDClientSessionReqResMessage('LSD.ClientSession.SyncHeadSubscribe', {
+  subscriptionId: Schema.String,
+}) {}
+export class SyncHeadUnsubscribe extends LSDClientSessionReqResMessage('LSD.ClientSession.SyncHeadUnsubscribe', {
+  subscriptionId: Schema.String,
+}) {}
+export class SyncHeadRes extends LSDClientSessionReqResMessage('LSD.ClientSession.SyncHeadRes', {
+  local: EventId.EventId,
+  upstream: EventId.EventId,
+  subscriptionId: Schema.String,
+}) {}
+
+export class ReactivityGraphSubscribe extends LSDClientSessionReqResMessage(
+  'LSD.ClientSession.ReactivityGraphSubscribe',
+  {
+    includeResults: Schema.Boolean,
+    subscriptionId: Schema.String,
+  },
+) {}
+
+export class ReactivityGraphUnsubscribe extends LSDClientSessionReqResMessage(
+  'LSD.ClientSession.ReactivityGraphUnsubscribe',
+  {
+    subscriptionId: Schema.String,
+  },
+) {}
+
+export class ReactivityGraphRes extends LSDClientSessionReqResMessage('LSD.ClientSession.ReactivityGraphRes', {
+  reactivityGraph: Schema.Any,
+  subscriptionId: Schema.String,
+}) {}
+
+export class LiveQueriesSubscribe extends LSDClientSessionReqResMessage('LSD.ClientSession.LiveQueriesSubscribe', {
+  subscriptionId: Schema.String,
+}) {}
+
+export class LiveQueriesUnsubscribe extends LSDClientSessionReqResMessage('LSD.ClientSession.LiveQueriesUnsubscribe', {
+  subscriptionId: Schema.String,
+}) {}
+
+export class SerializedLiveQuery extends Schema.Struct({
+  _tag: Schema.Literal('computed', 'db', 'graphql'),
+  id: Schema.Number,
+  label: Schema.String,
+  hash: Schema.String,
+  runs: Schema.Number,
+  executionTimes: Schema.Array(Schema.Number),
+  lastestResult: Schema.Any,
+  activeSubscriptions: Schema.Array(
+    Schema.Struct({ frames: Schema.Array(Schema.Struct({ name: Schema.String, filePath: Schema.String })) }),
+  ),
+}) {}
+
+export class LiveQueriesRes extends LSDClientSessionReqResMessage('LSD.ClientSession.LiveQueriesRes', {
+  liveQueries: Schema.Array(SerializedLiveQuery),
+  subscriptionId: Schema.String,
+}) {}
+
+export class Ping extends LSDClientSessionReqResMessage('LSD.ClientSession.Ping', {}) {}
+
+export class Pong extends LSDClientSessionReqResMessage('LSD.ClientSession.Pong', {}) {}
+
+export class Disconnect extends LSDClientSessionChannelMessage('LSD.ClientSession.Disconnect', {}) {}
+
+export const MessageToApp = Schema.Union(
+  DebugInfoReq,
+  DebugInfoHistorySubscribe,
+  DebugInfoHistoryUnsubscribe,
+  DebugInfoResetReq,
+  DebugInfoRerunQueryReq,
+  ReactivityGraphSubscribe,
+  ReactivityGraphUnsubscribe,
+  LiveQueriesSubscribe,
+  LiveQueriesUnsubscribe,
+  Disconnect,
+  Ping,
+  SyncHeadSubscribe,
+  SyncHeadUnsubscribe,
+).annotations({ identifier: 'LSD.ClientSession.MessageToApp' })
+
+export type MessageToApp = typeof MessageToApp.Type
+
+export const MessageFromApp = Schema.Union(
+  DebugInfoRes,
+  DebugInfoHistoryRes,
+  DebugInfoResetRes,
+  DebugInfoRerunQueryRes,
+  ReactivityGraphRes,
+  LiveQueriesRes,
+  Disconnect,
+  Pong,
+  SyncHeadRes,
+).annotations({ identifier: 'LSD.ClientSession.MessageFromApp' })
+
+export type MessageFromApp = typeof MessageFromApp.Type

package/src/devtools/devtools-messages-common.ts

@@ -0,0 +1,115 @@
+import { Schema } from '@livestore/utils/effect'
+
+import { liveStoreVersion as pkgVersion } from '../version.js'
+
+export const NetworkStatus = Schema.Struct({
+  isConnected: Schema.Boolean,
+  timestampMs: Schema.Number,
+  /** Whether the network status devtools latch is closed. Used to simulate network disconnection. */
+  latchClosed: Schema.Boolean,
+})
+
+export type NetworkStatus = typeof NetworkStatus.Type
+
+export const requestId = Schema.String
+export const clientId = Schema.String
+export const sessionId = Schema.String
+export const liveStoreVersion = Schema.Literal(pkgVersion)
+
+export const LSDMessage = <Tag extends string, Fields extends Schema.Struct.Fields>(tag: Tag, fields: Fields) =>
+  Schema.TaggedStruct(tag, {
+    liveStoreVersion,
+    ...fields,
+  }).annotations({ identifier: tag })
+
+export const LSDChannelMessage = <Tag extends string, Fields extends Schema.Struct.Fields>(tag: Tag, fields: Fields) =>
+  LSDMessage(tag, {
+    clientId,
+    ...fields,
+  })
+
+export const LSDClientSessionChannelMessage = <Tag extends string, Fields extends Schema.Struct.Fields>(
+  tag: Tag,
+  fields: Fields,
+) =>
+  LSDMessage(tag, {
+    clientId,
+    sessionId,
+    ...fields,
+  })
+
+export const LSDClientSessionReqResMessage = <Tag extends string, Fields extends Schema.Struct.Fields>(
+  tag: Tag,
+  fields: Fields,
+) =>
+  LSDMessage(tag, {
+    clientId,
+    sessionId,
+    requestId,
+    ...fields,
+  })
+
+export const LSDReqResMessage = <Tag extends string, Fields extends Schema.Struct.Fields>(tag: Tag, fields: Fields) =>
+  LSDChannelMessage(tag, {
+    requestId,
+    ...fields,
+  })
+
+type DefaultFields = {
+  readonly requestId: typeof Schema.String
+  readonly liveStoreVersion: typeof liveStoreVersion
+  readonly clientId: typeof Schema.String
+}
+
+export type LeaderReqResSchema<
+  Tag extends string,
+  PayloadFields extends Schema.Struct.Fields,
+  SuccessFields extends Schema.Struct.Fields,
+  ErrorFields extends Schema.Struct.Fields = never,
+> = {
+  Request: Schema.TaggedStruct<`${Tag}.Request`, PayloadFields & DefaultFields>
+  Response:
+    | Schema.TaggedStruct<`${Tag}.Response.Success`, SuccessFields & DefaultFields>
+    | (ErrorFields extends never ? never : Schema.TaggedStruct<`${Tag}.Response.Error`, ErrorFields & DefaultFields>)
+  Success: Schema.TaggedStruct<`${Tag}.Response.Success`, SuccessFields & DefaultFields>
+  Error: ErrorFields extends never ? never : Schema.TaggedStruct<`${Tag}.Response.Error`, ErrorFields & DefaultFields>
+}
+
+export const LeaderReqResMessage = <
+  Tag extends string,
+  PayloadFields extends Schema.Struct.Fields,
+  SuccessFields extends Schema.Struct.Fields,
+  ErrorFields extends Schema.Struct.Fields = never,
+>(
+  tag: Tag,
+  fields: {
+    payload: PayloadFields
+    success: SuccessFields
+    error?: ErrorFields
+  },
+): LeaderReqResSchema<Tag, PayloadFields, SuccessFields, ErrorFields> => {
+  const Success = Schema.TaggedStruct(`${tag}.Response.Success`, {
+    requestId,
+    liveStoreVersion,
+    ...fields.success,
+  }).annotations({ identifier: `${tag}.Response.Success` })
+
+  const Error = fields.error
+    ? Schema.TaggedStruct(`${tag}.Response.Error`, {
+        requestId,
+        liveStoreVersion,
+        ...fields.error,
+      }).annotations({ identifier: `${tag}.Response.Error` })
+    : Schema.Never
+
+  return {
+    Request: Schema.TaggedStruct(`${tag}.Request`, {
+      requestId,
+      liveStoreVersion,
+      ...fields.payload,
+    }).annotations({ identifier: `${tag}.Request` }),
+    Response: Schema.Union(Success, Error),
+    Success,
+    Error,
+  } as any
+}

package/src/devtools/devtools-messages-leader.ts

@@ -0,0 +1,191 @@
+import { Schema, Transferable } from '@livestore/utils/effect'
+
+import * as LiveStoreEvent from '../schema/LiveStoreEvent.js'
+import { EventId } from '../schema/mod.js'
+import * as SyncState from '../sync/syncstate.js'
+import { LeaderReqResMessage, LSDMessage, LSDReqResMessage, NetworkStatus } from './devtools-messages-common.js'
+
+export class ResetAllDataReq extends LSDReqResMessage('LSD.Leader.ResetAllDataReq', {
+  mode: Schema.Literal('all-data', 'only-app-db'),
+}) {}
+
+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.Leader.DatabaseFileInfoRes', {
+  state: DatabaseFileInfo,
+  eventlog: DatabaseFileInfo,
+}) {}
+
+export class NetworkStatusSubscribe extends LSDReqResMessage('LSD.Leader.NetworkStatusSubscribe', {
+  subscriptionId: Schema.String,
+}) {}
+export class NetworkStatusUnsubscribe extends LSDReqResMessage('LSD.Leader.NetworkStatusUnsubscribe', {
+  subscriptionId: Schema.String,
+}) {}
+
+export class NetworkStatusRes extends LSDReqResMessage('LSD.Leader.NetworkStatusRes', {
+  networkStatus: NetworkStatus,
+  subscriptionId: Schema.String,
+}) {}
+
+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.Leader.SyncingInfoRes', {
+  syncingInfo: SyncingInfo,
+}) {}
+
+export class SyncHistorySubscribe extends LSDReqResMessage('LSD.Leader.SyncHistorySubscribe', {
+  subscriptionId: Schema.String,
+}) {}
+export class SyncHistoryUnsubscribe extends LSDReqResMessage('LSD.Leader.SyncHistoryUnsubscribe', {
+  subscriptionId: Schema.String,
+}) {}
+export class SyncHistoryRes extends LSDReqResMessage('LSD.Leader.SyncHistoryRes', {
+  eventEncoded: LiveStoreEvent.AnyEncodedGlobal,
+  metadata: Schema.Option(Schema.JsonValue),
+  subscriptionId: Schema.String,
+}) {}
+
+export class SyncHeadSubscribe extends LSDReqResMessage('LSD.Leader.SyncHeadSubscribe', {
+  subscriptionId: Schema.String,
+}) {}
+export class SyncHeadUnsubscribe extends LSDReqResMessage('LSD.Leader.SyncHeadUnsubscribe', {
+  subscriptionId: Schema.String,
+}) {}
+export class SyncHeadRes extends LSDReqResMessage('LSD.Leader.SyncHeadRes', {
+  local: EventId.EventId,
+  upstream: EventId.EventId,
+  subscriptionId: Schema.String,
+}) {}
+
+export class SnapshotReq extends LSDReqResMessage('LSD.Leader.SnapshotReq', {}) {}
+
+export class SnapshotRes extends LSDReqResMessage('LSD.Leader.SnapshotRes', {
+  snapshot: Transferable.Uint8Array,
+}) {}
+
+export const LoadDatabaseFile = LeaderReqResMessage('LSD.Leader.LoadDatabaseFile', {
+  payload: {
+    data: Transferable.Uint8Array,
+  },
+  success: {},
+  error: {
+    cause: Schema.Union(
+      Schema.TaggedStruct('unsupported-file', {}),
+      Schema.TaggedStruct('unsupported-database', {}),
+      Schema.TaggedStruct('unexpected-error', { cause: Schema.Defect }),
+    ),
+  },
+})
+
+// TODO refactor this to use push/pull semantics
+export class SyncPull extends LSDMessage('LSD.Leader.SyncPull', {
+  payload: SyncState.PayloadUpstream,
+}) {}
+
+// TODO refactor this to use push/pull semantics
+export class CommitEventReq extends LSDReqResMessage('LSD.Leader.CommitEventReq', {
+  eventEncoded: LiveStoreEvent.PartialAnyEncoded,
+}) {}
+
+export class CommitEventRes extends LSDReqResMessage('LSD.Leader.CommitEventRes', {}) {}
+
+export class EventlogReq extends LSDReqResMessage('LSD.Leader.EventlogReq', {}) {}
+
+export class EventlogRes extends LSDReqResMessage('LSD.Leader.EventlogRes', {
+  eventlog: Transferable.Uint8Array,
+}) {}
+
+export class Ping extends LSDReqResMessage('LSD.Leader.Ping', {}) {}
+
+export class Pong extends LSDReqResMessage('LSD.Leader.Pong', {}) {}
+
+export class Disconnect extends LSDReqResMessage('LSD.Leader.Disconnect', {}) {}
+
+export const SetSyncLatch = LeaderReqResMessage('LSD.Leader.SetSyncLatch', {
+  payload: {
+    closeLatch: Schema.Boolean,
+  },
+  success: {},
+})
+
+export const ResetAllData = LeaderReqResMessage('LSD.Leader.ResetAllData', {
+  payload: {
+    mode: Schema.Literal('all-data', 'only-app-db'),
+  },
+  success: {},
+})
+
+// TODO move to `Schema.TaggedRequest` once new RPC is ready https://github.com/Effect-TS/effect/pull/4362
+// export class DatabaseFileInfo_ extends Schema.TaggedRequest<DatabaseFileInfo_>()('LSD.Leader.DatabaseFileInfo', {
+//   payload: {
+//     requestId,
+//     liveStoreVersion,
+//   },
+//   success: DatabaseFileInfo,
+//   failure: UnexpectedError,
+// }) {}
+
+// export class NetworkStatus_ extends Schema.TaggedRequest<NetworkStatus_>()('LSD.Leader.NetworkStatus', {
+//   payload: {
+//     requestId,
+//     liveStoreVersion,
+//   },
+//   success: NetworkStatus,
+//   failure: UnexpectedError,
+// }) {}
+
+// export const MessageToApp_ = Schema.Union(DatabaseFileInfo_, NetworkStatus_)
+
+// export type MessageToApp_ = typeof MessageToApp_.Type
+//
+
+export const MessageToApp = Schema.Union(
+  SnapshotReq,
+  LoadDatabaseFile.Request,
+  EventlogReq,
+  ResetAllData.Request,
+  NetworkStatusSubscribe,
+  NetworkStatusUnsubscribe,
+  Disconnect,
+  CommitEventReq,
+  Ping,
+  DatabaseFileInfoReq,
+  SyncHistorySubscribe,
+  SyncHistoryUnsubscribe,
+  SyncingInfoReq,
+  SyncHeadSubscribe,
+  SyncHeadUnsubscribe,
+  SetSyncLatch.Request,
+).annotations({ identifier: 'LSD.Leader.MessageToApp' })
+
+export type MessageToApp = typeof MessageToApp.Type
+
+export const MessageFromApp = Schema.Union(
+  SnapshotRes,
+  LoadDatabaseFile.Response,
+  EventlogRes,
+  Disconnect,
+  SyncPull,
+  NetworkStatusRes,
+  CommitEventRes,
+  Pong,
+  DatabaseFileInfoRes,
+  SyncHistoryRes,
+  SyncingInfoRes,
+  SyncHeadRes,
+  ResetAllData.Success,
+  SetSyncLatch.Success,
+).annotations({ identifier: 'LSD.Leader.MessageFromApp' })
+
+export type MessageFromApp = typeof MessageFromApp.Type

package/src/devtools/devtools-messages.ts

@@ -1,243 +1,3 @@
-import { Schema, Transferable } from '@livestore/utils/effect'
-
-import { NetworkStatus } from '../adapter-types.js'
-import { DebugInfo } from '../debug-info.js'
-import * as MutationEvent from '../schema/MutationEvent.js'
-import { PreparedBindValues } from '../util.js'
-import { liveStoreVersion as pkgVersion } from '../version.js'
-
-const requestId = Schema.String
-const appHostId = Schema.String
-const liveStoreVersion = Schema.Literal(pkgVersion)
-
-const LSDMessage = <Tag extends string, Fields extends Schema.Struct.Fields>(tag: Tag, fields: Fields) =>
-  Schema.TaggedStruct(tag, {
-    liveStoreVersion,
-    ...fields,
-  }).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,
-  })
-
-const LSDReqResMessage = <Tag extends string, Fields extends Schema.Struct.Fields>(tag: Tag, fields: Fields) =>
-  LSDChannelMessage(tag, {
-    requestId,
-    ...fields,
-  })
-
-export class SnapshotReq extends LSDReqResMessage('LSD.Leader.SnapshotReq', {}) {}
-
-export class SnapshotRes extends LSDReqResMessage('LSD.Leader.SnapshotRes', {
-  snapshot: Transferable.Uint8Array,
-}) {}
-
-export class LoadDatabaseFileReq extends LSDReqResMessage('LSD.Leader.LoadDatabaseFileReq', {
-  data: Transferable.Uint8Array,
-}) {}
-
-export class LoadDatabaseFileRes extends LSDReqResMessage('LSD.Leader.LoadDatabaseFileRes', {
-  status: Schema.Literal('ok', 'unsupported-file', 'unsupported-database'),
-}) {}
-
-export class DebugInfoReq extends LSDStoreReqResMessage('LSD.DebugInfoReq', {}) {}
-
-export class DebugInfoRes extends LSDStoreReqResMessage('LSD.DebugInfoRes', {
-  debugInfo: DebugInfo,
-}) {}
-
-export class DebugInfoHistorySubscribe extends LSDStoreReqResMessage('LSD.DebugInfoHistorySubscribe', {}) {}
-
-export class DebugInfoHistoryRes extends LSDStoreReqResMessage('LSD.DebugInfoHistoryRes', {
-  debugInfoHistory: Schema.Array(DebugInfo),
-}) {}
-
-export class DebugInfoHistoryUnsubscribe extends LSDStoreReqResMessage('LSD.DebugInfoHistoryUnsubscribe', {}) {}
-
-export class DebugInfoResetReq extends LSDStoreReqResMessage('LSD.DebugInfoResetReq', {}) {}
-
-export class DebugInfoResetRes extends LSDStoreReqResMessage('LSD.DebugInfoResetRes', {}) {}
-
-export class DebugInfoRerunQueryReq extends LSDStoreReqResMessage('LSD.DebugInfoRerunQueryReq', {
-  queryStr: Schema.String,
-  bindValues: Schema.UndefinedOr(PreparedBindValues),
-  queriedTables: Schema.ReadonlySet(Schema.String),
-}) {}
-
-export class DebugInfoRerunQueryRes extends LSDStoreReqResMessage('LSD.DebugInfoRerunQueryRes', {}) {}
-
-// TODO refactor this to use push/pull semantics
-export class MutationBroadcast extends LSDMessage('LSD.Leader.MutationBroadcast', {
-  mutationEventEncoded: MutationEvent.EncodedAny,
-}) {}
-
-// 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.Leader.RunMutationRes', {}) {}
-
-export class MutationLogReq extends LSDReqResMessage('LSD.Leader.MutationLogReq', {}) {}
-
-export class MutationLogRes extends LSDReqResMessage('LSD.Leader.MutationLogRes', {
-  mutationLog: Transferable.Uint8Array,
-}) {}
-
-export class ReactivityGraphSubscribe extends LSDStoreReqResMessage('LSD.ReactivityGraphSubscribe', {
-  includeResults: Schema.Boolean,
-}) {}
-
-export class ReactivityGraphUnsubscribe extends LSDStoreReqResMessage('LSD.ReactivityGraphUnsubscribe', {}) {}
-
-export class ReactivityGraphRes extends LSDStoreReqResMessage('LSD.ReactivityGraphRes', {
-  reactivityGraph: Schema.Any,
-}) {}
-
-export class LiveQueriesSubscribe extends LSDStoreReqResMessage('LSD.LiveQueriesSubscribe', {}) {}
-
-export class LiveQueriesUnsubscribe extends LSDStoreReqResMessage('LSD.LiveQueriesUnsubscribe', {}) {}
-
-export class SerializedLiveQuery extends Schema.Struct({
-  _tag: Schema.Literal('computed', 'db', 'graphql'),
-  id: Schema.Number,
-  label: Schema.String,
-  runs: Schema.Number,
-  executionTimes: Schema.Array(Schema.Number),
-  lastestResult: Schema.Any,
-  activeSubscriptions: Schema.Array(
-    Schema.Struct({ frames: Schema.Array(Schema.Struct({ name: Schema.String, filePath: Schema.String })) }),
-  ),
-}) {}
-
-export class LiveQueriesRes extends LSDStoreReqResMessage('LSD.LiveQueriesRes', {
-  liveQueries: Schema.Array(SerializedLiveQuery),
-}) {}
-
-export class ResetAllDataReq extends LSDReqResMessage('LSD.Leader.ResetAllDataReq', {
-  mode: Schema.Literal('all-data', 'only-app-db'),
-}) {}
-
-export class ResetAllDataRes extends LSDReqResMessage('LSD.Leader.ResetAllDataRes', {}) {}
-
-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.Leader.DatabaseFileInfoRes', {
-  db: DatabaseFileInfo,
-  mutationLog: DatabaseFileInfo,
-}) {}
-
-export class NetworkStatusSubscribe extends LSDReqResMessage('LSD.Leader.NetworkStatusSubscribe', {}) {}
-export class NetworkStatusUnsubscribe extends LSDReqResMessage('LSD.Leader.NetworkStatusUnsubscribe', {}) {}
-
-export class NetworkStatusRes extends LSDReqResMessage('LSD.Leader.NetworkStatusRes', {
-  networkStatus: NetworkStatus,
-}) {}
-
-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.Leader.SyncingInfoRes', {
-  syncingInfo: SyncingInfo,
-}) {}
-
-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 Disconnect extends LSDStoreChannelMessage('LSD.Disconnect', {}) {}
-
-export class Ping extends LSDReqResMessage('LSD.Ping', {}) {}
-
-export class Pong extends LSDReqResMessage('LSD.Pong', {}) {}
-
-export const MessageToAppLeader = Schema.Union(
-  SnapshotReq,
-  LoadDatabaseFileReq,
-  MutationLogReq,
-  ResetAllDataReq,
-  NetworkStatusSubscribe,
-  NetworkStatusUnsubscribe,
-  Disconnect,
-  RunMutationReq,
-  Ping,
-  DatabaseFileInfoReq,
-  SyncHistorySubscribe,
-  SyncHistoryUnsubscribe,
-  SyncingInfoReq,
-).annotations({ identifier: 'LSD.MessageToAppLeader' })
-
-export type MessageToAppLeader = typeof MessageToAppLeader.Type
-
-export const MessageToAppClientSession = Schema.Union(
-  DebugInfoReq,
-  DebugInfoHistorySubscribe,
-  DebugInfoHistoryUnsubscribe,
-  DebugInfoResetReq,
-  DebugInfoRerunQueryReq,
-  ReactivityGraphSubscribe,
-  ReactivityGraphUnsubscribe,
-  LiveQueriesSubscribe,
-  LiveQueriesUnsubscribe,
-  Disconnect,
-  // TODO also introduce a ping/pong protocol for the client session <> devtools connection
-  // Ping,
-).annotations({ identifier: 'LSD.MessageToAppClientSession' })
-
-export type MessageToAppClientSession = typeof MessageToAppClientSession.Type
-
-export const MessageFromAppLeader = Schema.Union(
-  SnapshotRes,
-  LoadDatabaseFileRes,
-  MutationLogRes,
-  ResetAllDataRes,
-  Disconnect,
-  MutationBroadcast,
-  NetworkStatusRes,
-  RunMutationRes,
-  Pong,
-  DatabaseFileInfoRes,
-  SyncHistoryRes,
-  SyncingInfoRes,
-).annotations({ identifier: 'LSD.MessageFromAppLeader' })
-
-export type MessageFromAppLeader = typeof MessageFromAppLeader.Type
-
-export const MessageFromAppClientSession = Schema.Union(
-  DebugInfoRes,
-  DebugInfoHistoryRes,
-  DebugInfoResetRes,
-  DebugInfoRerunQueryRes,
-  ReactivityGraphRes,
-  LiveQueriesRes,
-  Disconnect,
-  // Pong,
-).annotations({ identifier: 'LSD.MessageFromAppClientSession' })
-
-export type MessageFromAppClientSession = typeof MessageFromAppClientSession.Type
+export * as ClientSession from './devtools-messages-client-session.js'
+export * as Leader from './devtools-messages-leader.js'
+export * from './devtools-messages-common.js'