@livestore/sync-cf 0.4.0-dev.1 → 0.4.0-dev.10

package/src/client/transport/http-rpc-client.ts

@@ -0,0 +1,225 @@
+import { InvalidPullError, InvalidPushError, SyncBackend, UnexpectedError } from '@livestore/common'
+import type { EventSequenceNumber } from '@livestore/common/schema'
+import { splitChunkBySize } from '@livestore/common/sync'
+import { omit } from '@livestore/utils'
+import {
+  Chunk,
+  type Duration,
+  Effect,
+  HttpClient,
+  HttpClientRequest,
+  identity,
+  Layer,
+  Option,
+  RpcClient,
+  RpcSerialization,
+  Schedule,
+  Schema,
+  Stream,
+  SubscriptionRef,
+  UrlParams,
+} from '@livestore/utils/effect'
+import { MAX_HTTP_REQUEST_BYTES, MAX_PUSH_EVENTS_PER_REQUEST } from '../../common/constants.ts'
+import { SyncHttpRpc } from '../../common/http-rpc-schema.ts'
+import { SearchParamsSchema } from '../../common/mod.ts'
+import type { SyncMetadata } from '../../common/sync-message-types.ts'
+
+export interface HttpSyncOptions {
+  /**
+   * URL of the sync backend
+   *
+   * @example
+   * ```ts
+   * const syncBackend = makeHttpSync({ url: 'https://sync.example.com' })
+   * ```
+   */
+  url: string
+  headers?: Record<string, string>
+  livePull?: {
+    /**
+     * How often to poll for new events
+     * @default 5 seconds
+     */
+    pollInterval?: Duration.DurationInput
+  }
+  ping?: {
+    /**
+     * @default true
+     */
+    enabled?: boolean
+    /**
+     * How long to wait for a ping response before timing out
+     * @default 10 seconds
+     */
+    requestTimeout?: Duration.DurationInput
+    /**
+     * How often to send ping requests
+     * @default 10 seconds
+     */
+    requestInterval?: Duration.DurationInput
+  }
+}
+
+/**
+ * Note: This implementation requires the `enable_request_signal` compatibility flag to properly support `pull` streaming responses
+ */
+export const makeHttpSync =
+  (options: HttpSyncOptions): SyncBackend.SyncBackendConstructor<SyncMetadata> =>
+  ({ storeId, payload }) =>
+    Effect.gen(function* () {
+      // Based on ping responses
+      const isConnected = yield* SubscriptionRef.make(false)
+
+      const livePullInterval = options.livePull?.pollInterval ?? 5_000
+
+      const urlParamsData = yield* Schema.encode(SearchParamsSchema)({
+        storeId,
+        payload,
+        transport: 'http',
+      }).pipe(UnexpectedError.mapToUnexpectedError)
+
+      const urlParams = UrlParams.fromInput(urlParamsData)
+
+      // Setup HTTP RPC Protocol
+      const HttpProtocolLive = RpcClient.layerProtocolHttp({
+        url: `${options.url}?${UrlParams.toString(urlParams)}`,
+        transformClient: HttpClient.mapRequest((request) =>
+          request.pipe(
+            HttpClientRequest.setHeaders({
+              ...options.headers,
+              // Used in CF Worker to identify the store (additionally to storeId embedded in the RPC requests)
+              'x-livestore-store-id': storeId,
+            }),
+          ),
+        ),
+      }).pipe(Layer.provide(RpcSerialization.layerJson))
+
+      const rpcClient = yield* RpcClient.make(SyncHttpRpc).pipe(Effect.provide(HttpProtocolLive))
+
+      const pingTimeout = options.ping?.requestTimeout ?? 10_000
+
+      const ping: SyncBackend.SyncBackend<SyncMetadata>['ping'] = Effect.gen(function* () {
+        yield* rpcClient.SyncHttpRpc.Ping({ storeId, payload })
+
+        yield* SubscriptionRef.set(isConnected, true)
+      }).pipe(
+        UnexpectedError.mapToUnexpectedError,
+        Effect.timeout(pingTimeout),
+        Effect.catchTag('TimeoutException', () => SubscriptionRef.set(isConnected, false)),
+      )
+
+      const pingInterval = options.ping?.requestInterval ?? 10_000
+
+      if (options.ping?.enabled !== false) {
+        // Automatically ping the server to keep the connection alive
+        yield* ping.pipe(Effect.repeat(Schedule.spaced(pingInterval)), Effect.tapCauseLogPretty, Effect.forkScoped)
+      }
+
+      // Helps already establish a TCP connection to the server
+      const connect = ping.pipe(UnexpectedError.mapToUnexpectedError)
+
+      const backendIdHelper = yield* SyncBackend.makeBackendIdHelper
+
+      const mapCursor = (cursor: Option.Option<{ eventSequenceNumber: number }>) =>
+        cursor.pipe(
+          Option.map((a) => ({
+            eventSequenceNumber: a.eventSequenceNumber as EventSequenceNumber.GlobalEventSequenceNumber,
+            backendId: backendIdHelper.get().pipe(Option.getOrThrow),
+          })),
+        )
+
+      const pull: SyncBackend.SyncBackend<SyncMetadata>['pull'] = (cursor, options) =>
+        rpcClient.SyncHttpRpc.Pull({
+          storeId,
+          payload,
+          cursor: mapCursor(cursor),
+        }).pipe(
+          options?.live
+            ? // Phase 2: Simulate `live` pull by polling for new events
+              Stream.concatWithLastElement((lastElement) => {
+                const initialPhase2Cursor = lastElement.pipe(
+                  Option.flatMap((_) => Option.fromNullable(_.batch.at(-1)?.eventEncoded.seqNum)),
+                  Option.map((eventSequenceNumber) => ({ eventSequenceNumber })),
+                  Option.orElse(() => cursor),
+                  mapCursor,
+                )
+
+                return Stream.unfoldChunkEffect(initialPhase2Cursor, (currentCursor) =>
+                  Effect.gen(function* () {
+                    yield* Effect.sleep(livePullInterval)
+
+                    const items = yield* rpcClient.SyncHttpRpc.Pull({ storeId, payload, cursor: currentCursor }).pipe(
+                      Stream.runCollect,
+                    )
+
+                    const nextCursor = Chunk.last(items).pipe(
+                      Option.flatMap((item) => Option.fromNullable(item.batch.at(-1)?.eventEncoded.seqNum)),
+                      Option.map((eventSequenceNumber) => ({ eventSequenceNumber })),
+                      Option.orElse(() => currentCursor),
+                      mapCursor,
+                    )
+
+                    return Option.some([items, nextCursor])
+                  }),
+                )
+              })
+            : identity,
+          Stream.tap((res) => backendIdHelper.lazySet(res.backendId)),
+          Stream.map((res) => omit(res, ['backendId'])),
+          Stream.mapError((cause) => (cause._tag === 'InvalidPullError' ? cause : InvalidPullError.make({ cause }))),
+          Stream.withSpan('http-sync-client:pull'),
+        )
+
+      const pushSemaphore = yield* Effect.makeSemaphore(1)
+
+      const push: SyncBackend.SyncBackend<SyncMetadata>['push'] = (batch) =>
+        Effect.gen(function* () {
+          if (batch.length === 0) {
+            return
+          }
+
+          const backendId = backendIdHelper.get()
+          const batchChunks = yield* Chunk.fromIterable(batch).pipe(
+            splitChunkBySize({
+              maxItems: MAX_PUSH_EVENTS_PER_REQUEST,
+              maxBytes: MAX_HTTP_REQUEST_BYTES,
+              encode: (items) => ({
+                batch: items,
+                storeId,
+                payload,
+                backendId,
+              }),
+            }),
+            Effect.mapError((cause) => new InvalidPushError({ cause: new UnexpectedError({ cause }) })),
+          )
+
+          for (const chunk of Chunk.toReadonlyArray(batchChunks)) {
+            const chunkArray = Chunk.toReadonlyArray(chunk)
+            yield* rpcClient.SyncHttpRpc.Push({ storeId, payload, batch: chunkArray, backendId })
+          }
+        }).pipe(
+          pushSemaphore.withPermits(1),
+          Effect.mapError((cause) =>
+            cause._tag === 'InvalidPushError' ? cause : new InvalidPushError({ cause: new UnexpectedError({ cause }) }),
+          ),
+          Effect.withSpan('http-sync-client:push'),
+        )
+
+      return SyncBackend.of({
+        connect,
+        isConnected,
+        pull,
+        push,
+        ping,
+        metadata: {
+          name: '@livestore/cf-sync-http',
+          description: 'LiveStore sync backend implementation using HTTP RPC',
+          protocol: 'http',
+          url: options.url,
+        },
+        supports: {
+          pullPageInfoKnown: true,
+          pullLive: true,
+        },
+      })
+    })

package/src/client/transport/ws-rpc-client.ts

@@ -0,0 +1,202 @@
+import { InvalidPullError, InvalidPushError, IsOfflineError, SyncBackend, UnexpectedError } from '@livestore/common'
+import type { LiveStoreEvent } from '@livestore/common/schema'
+import { splitChunkBySize } from '@livestore/common/sync'
+import { omit } from '@livestore/utils'
+import {
+  Chunk,
+  type Duration,
+  Effect,
+  Layer,
+  Option,
+  RpcClient,
+  RpcSerialization,
+  Schedule,
+  Schema,
+  type Scope,
+  Socket,
+  Stream,
+  SubscriptionRef,
+  UrlParams,
+  type WebSocket,
+} from '@livestore/utils/effect'
+import { MAX_PUSH_EVENTS_PER_REQUEST, MAX_WS_MESSAGE_BYTES } from '../../common/constants.ts'
+import { SearchParamsSchema } from '../../common/mod.ts'
+import type { SyncMetadata } from '../../common/sync-message-types.ts'
+import { SyncWsRpc } from '../../common/ws-rpc-schema.ts'
+
+export interface WsSyncOptions {
+  /**
+   * URL of the sync backend
+   *
+   * The protocol can either `http`/`https` or `ws`/`wss`
+   *
+   * @example 'https://sync.example.com'
+   */
+  url: string
+  /**
+   * Optional WebSocket factory for custom WebSocket implementations (e.g., Cloudflare Durable Objects)
+   * If not provided, uses standard WebSocket from @livestore/utils/effect
+   */
+  webSocketFactory?: (wsUrl: string) => Effect.Effect<globalThis.WebSocket, WebSocket.WebSocketError, Scope.Scope>
+  ping?: {
+    /**
+     * @default true
+     */
+    enabled?: boolean
+    /**
+     * How long to wait for a ping response before timing out
+     * @default 10 seconds
+     */
+    requestTimeout?: Duration.DurationInput
+    /**
+     * How often to send ping requests
+     * @default 10 seconds
+     */
+    requestInterval?: Duration.DurationInput
+  }
+}
+
+/**
+ * Creates a sync backend that uses WebSocket to communicate with the sync backend.
+ *
+ * @example
+ * ```ts
+ * import { makeWsSync } from '@livestore/sync-cf/client'
+ *
+ * const syncBackend = makeWsSync({ url: 'wss://sync.example.com' })
+ */
+export const makeWsSync =
+  (options: WsSyncOptions): SyncBackend.SyncBackendConstructor<SyncMetadata> =>
+  ({ storeId, payload }) =>
+    Effect.gen(function* () {
+      const urlParamsData = yield* Schema.encode(SearchParamsSchema)({
+        storeId,
+        payload,
+        transport: 'ws',
+      }).pipe(UnexpectedError.mapToUnexpectedError)
+
+      const urlParams = UrlParams.fromInput(urlParamsData)
+      const wsUrl = `${options.url}?${UrlParams.toString(urlParams)}`
+
+      const isConnected = yield* SubscriptionRef.make(false)
+
+      // TODO bring this back in a cross-platform way
+      // If the browser already tells us we're offline, then we'll at least wait until the browser
+      // thinks we're online again. (We'll only know for sure once the WS conneciton is established.)
+      // while (typeof navigator !== 'undefined' && navigator.onLine === false) {
+      //   yield* Effect.sleep(1000)
+      // }
+      // TODO bring this back in a cross-platform way
+      // if (navigator.onLine === false) {
+      //   yield* Effect.async((cb) => self.addEventListener('online', () => cb(Effect.void)))
+      // }
+
+      const pingInterval = options.ping?.requestInterval ?? 10_000
+
+      const ProtocolLive = RpcClient.layerProtocolSocketWithIsConnected({
+        isConnected,
+        retryTransientErrors: Schedule.fixed(1000),
+        pingSchedule: Schedule.once.pipe(Schedule.andThen(Schedule.fixed(pingInterval))),
+        url: wsUrl,
+      }).pipe(
+        Layer.provide(Socket.layerWebSocket(wsUrl)),
+        Layer.provide(Socket.layerWebSocketConstructorGlobal),
+        Layer.provide(RpcSerialization.layerJson),
+      )
+
+      // Warning: we need to build the layer here eagerly to tie it to the scope
+      // instead of using `Effect.provide(ProtocolLive)` which would close the layer scope too early
+      const ctx = yield* Layer.build(ProtocolLive)
+
+      const rpcClient = yield* RpcClient.make(SyncWsRpc).pipe(Effect.provide(ctx))
+
+      const pingTimeout = options.ping?.requestTimeout ?? 10_000
+
+      const ping = Effect.gen(function* () {
+        const pinger = yield* RpcClient.SocketPinger.pipe(Effect.provide(ctx))
+        yield* pinger.ping
+        yield* SubscriptionRef.set(isConnected, true)
+      }).pipe(
+        Effect.timeout(pingTimeout),
+        Effect.catchTag('TimeoutException', () => SubscriptionRef.set(isConnected, false)),
+        UnexpectedError.mapToUnexpectedError,
+        Effect.withSpan('ping'),
+      )
+
+      const backendIdHelper = yield* SyncBackend.makeBackendIdHelper
+
+      return SyncBackend.of<SyncMetadata>({
+        isConnected,
+        connect: ping,
+        pull: (cursor, options) =>
+          rpcClient.SyncWsRpc.Pull({
+            storeId,
+            payload,
+            cursor: cursor.pipe(
+              Option.map((a) => ({
+                eventSequenceNumber: a.eventSequenceNumber,
+                backendId: backendIdHelper.get().pipe(Option.getOrThrow),
+              })),
+            ),
+            live: options?.live ?? false,
+          }).pipe(
+            Stream.tap((res) => backendIdHelper.lazySet(res.backendId)),
+            Stream.map((res) => omit(res, ['backendId'])),
+            Stream.mapError((cause) =>
+              cause._tag === 'RpcClientError' && Socket.isSocketError(cause.cause)
+                ? new IsOfflineError({ cause: cause.cause })
+                : cause._tag === 'InvalidPullError'
+                  ? cause
+                  : InvalidPullError.make({ cause }),
+            ),
+            Stream.withSpan('pull'),
+          ),
+
+        push: (batch) =>
+          Effect.gen(function* () {
+            if (batch.length === 0) return
+
+            const encodePayload = (batch: ReadonlyArray<LiveStoreEvent.AnyEncodedGlobal>) => ({
+              storeId,
+              payload,
+              batch,
+              backendId: backendIdHelper.get(),
+            })
+
+            const chunksChunk = yield* Chunk.fromIterable(batch).pipe(
+              splitChunkBySize({
+                maxItems: MAX_PUSH_EVENTS_PER_REQUEST,
+                maxBytes: MAX_WS_MESSAGE_BYTES,
+                encode: encodePayload,
+              }),
+              Effect.mapError((cause) => new InvalidPushError({ cause: new UnexpectedError({ cause }) })),
+            )
+
+            for (const sub of chunksChunk) {
+              yield* rpcClient.SyncWsRpc.Push({
+                storeId,
+                payload,
+                batch: Chunk.toReadonlyArray(sub),
+                backendId: backendIdHelper.get(),
+              }).pipe(
+                Effect.mapError((cause) =>
+                  cause._tag === 'InvalidPushError'
+                    ? cause
+                    : new InvalidPushError({ cause: new UnexpectedError({ cause }) }),
+                ),
+              )
+            }
+          }).pipe(Effect.withSpan('push')),
+        ping,
+        metadata: {
+          name: '@livestore/cf-sync',
+          description: 'LiveStore sync backend implementation using Cloudflare Workers & Durable Objects',
+          protocol: 'ws',
+          url: options.url,
+        },
+        supports: {
+          pullPageInfoKnown: true,
+          pullLive: true,
+        },
+      })
+    })

package/src/common/constants.ts

@@ -0,0 +1,18 @@
+// Shared transport limits for Cloudflare sync provider
+// Keep payloads comfortably below ~1MB frame caps across Cloudflare transports.
+// References:
+// - Durable Objects WebSockets + hibernation best practices:
+//   https://developers.cloudflare.com/durable-objects/best-practices/websockets/
+// - Workers platform limits (general context):
+//   https://developers.cloudflare.com/workers/platform/limits/
+// Empirically, frames just below 1MB can fail on hibernated DO WebSockets; we use 900_000 bytes to keep a safety margin.
+export const MAX_TRANSPORT_PAYLOAD_BYTES = 900_000
+
+export const MAX_WS_MESSAGE_BYTES = MAX_TRANSPORT_PAYLOAD_BYTES
+export const MAX_DO_RPC_REQUEST_BYTES = MAX_TRANSPORT_PAYLOAD_BYTES
+export const MAX_HTTP_REQUEST_BYTES = MAX_TRANSPORT_PAYLOAD_BYTES
+
+// Upper bound for items per message/request. Mirrors server broadcast chunking.
+// Not Cloudflare-enforced; chosen to balance payload size and latency.
+export const MAX_PULL_EVENTS_PER_MESSAGE = 100
+export const MAX_PUSH_EVENTS_PER_REQUEST = 100

package/src/common/do-rpc-schema.ts

@@ -0,0 +1,54 @@
+import { InvalidPullError, InvalidPushError } from '@livestore/common'
+import { Rpc, RpcGroup, Schema } from '@livestore/utils/effect'
+import * as SyncMessage from './sync-message-types.ts'
+
+const commonPayloadFields = {
+  /**
+   * While the storeId is already implied by the durable object, we still need the explicit storeId
+   * since a DO doesn't know its own id.name value. 🫠
+   * https://community.cloudflare.com/t/how-can-i-get-the-name-of-a-durable-object-from-itself/505961/8
+   */
+  storeId: Schema.String,
+  /** Needed for various reasons (e.g. auth) */
+  payload: Schema.optional(Schema.JsonValue),
+}
+
+export class SyncDoRpc extends RpcGroup.make(
+  Rpc.make('SyncDoRpc.Pull', {
+    payload: {
+      /** Omitting the cursor will start from the beginning */
+      cursor: SyncMessage.PullRequest.fields.cursor,
+      // TODO rename
+      /** Whether to keep the pull stream alive and wait for more events */
+      rpcContext: Schema.optional(
+        Schema.Struct({
+          callerContext: Schema.Struct({
+            bindingName: Schema.String,
+            durableObjectId: Schema.String,
+          }),
+        }),
+      ),
+      ...commonPayloadFields,
+    },
+    success: Schema.Struct({
+      rpcRequestId: Schema.String,
+      ...SyncMessage.PullResponse.fields,
+    }),
+    error: InvalidPullError,
+    stream: true,
+  }),
+  Rpc.make('SyncDoRpc.Push', {
+    payload: {
+      ...SyncMessage.PushRequest.fields,
+      ...commonPayloadFields,
+    },
+    success: SyncMessage.PushAck,
+    error: InvalidPushError,
+  }),
+  Rpc.make('SyncDoRpc.Ping', {
+    payload: {
+      ...commonPayloadFields,
+    },
+    success: Schema.Void,
+  }),
+) {}

package/src/common/http-rpc-schema.ts

@@ -0,0 +1,40 @@
+import { InvalidPullError, InvalidPushError, UnexpectedError } from '@livestore/common'
+import { Rpc, RpcGroup, Schema } from '@livestore/utils/effect'
+import * as SyncMessage from './sync-message-types.ts'
+
+/**
+ * HTTP RPC Schema for LiveStore CF Sync Provider
+ *
+ * This defines the RPC endpoints available over HTTP transport.
+ * Unlike WebSocket transport which maintains persistent connections,
+ * HTTP transport uses request/response patterns for each operation.
+ */
+export class SyncHttpRpc extends RpcGroup.make(
+  Rpc.make('SyncHttpRpc.Pull', {
+    payload: Schema.Struct({
+      storeId: Schema.String,
+      payload: Schema.optional(Schema.JsonValue),
+      ...SyncMessage.PullRequest.fields,
+    }),
+    success: SyncMessage.PullResponse,
+    error: InvalidPullError,
+    stream: true,
+  }),
+  Rpc.make('SyncHttpRpc.Push', {
+    payload: Schema.Struct({
+      storeId: Schema.String,
+      payload: Schema.optional(Schema.JsonValue),
+      ...SyncMessage.PushRequest.fields,
+    }),
+    success: SyncMessage.PushAck,
+    error: InvalidPushError,
+  }),
+  Rpc.make('SyncHttpRpc.Ping', {
+    payload: Schema.Struct({
+      storeId: Schema.String,
+      payload: Schema.optional(Schema.JsonValue),
+    }),
+    success: SyncMessage.Pong,
+    error: UnexpectedError,
+  }),
+) {}

package/src/common/mod.ts

@@ -1,8 +1,17 @@
+import { OversizeChunkItemError, splitChunkBySize } from '@livestore/common/sync'
 import { Schema } from '@livestore/utils/effect'
 
-export * as WSMessage from './ws-message-types.ts'
+export type { CfTypes } from '@livestore/common-cf'
+export * from './constants.ts'
+export { SyncHttpRpc } from './http-rpc-schema.ts'
+export * as SyncMessage from './sync-message-types.ts'
+export { OversizeChunkItemError, splitChunkBySize }
 
 export const SearchParamsSchema = Schema.Struct({
   storeId: Schema.String,
   payload: Schema.compose(Schema.StringFromUriComponent, Schema.parseJson(Schema.JsonValue)).pipe(Schema.UndefinedOr),
+  // NOTE `do-rpc` is handled differently
+  transport: Schema.Union(Schema.Literal('http'), Schema.Literal('ws')),
 })
+
+export type SearchParams = typeof SearchParamsSchema.Type

package/src/common/sync-message-types.ts

@@ -0,0 +1,117 @@
+import { BackendId, SyncBackend } from '@livestore/common'
+import { EventSequenceNumber, LiveStoreEvent } from '@livestore/common/schema'
+import { Schema } from '@livestore/utils/effect'
+
+/**
+ * Common sync message types shared between different transport modes (WS, HTTP, RPC)
+ *
+ * These are the canonical message definitions used across all transport implementations.
+ */
+
+export const SyncMetadata = Schema.TaggedStruct('SyncMessage.SyncMetadata', {
+  /** ISO date format */
+  createdAt: Schema.String,
+}).annotations({ title: '@livestore/sync-cf:SyncMetadata' })
+
+export type SyncMetadata = typeof SyncMetadata.Type
+
+export const PullRequest = Schema.Struct({
+  /** Omitting the cursor will start from the beginning */
+  cursor: Schema.Option(
+    Schema.Struct({
+      backendId: BackendId,
+      eventSequenceNumber: EventSequenceNumber.GlobalEventSequenceNumber,
+    }),
+  ),
+}).annotations({ title: '@livestore/sync-cf:PullRequest' })
+
+export type PullRequest = typeof PullRequest.Type
+
+export const PullResponse = Schema.Struct({
+  batch: Schema.Array(
+    Schema.Struct({
+      eventEncoded: LiveStoreEvent.AnyEncodedGlobal,
+      metadata: Schema.Option(SyncMetadata),
+    }),
+  ),
+  pageInfo: SyncBackend.PullResPageInfo,
+  backendId: BackendId,
+}).annotations({ title: '@livestore/sync-cf:PullResponse' })
+
+export const emptyPullResponse = (backendId: string) =>
+  PullResponse.make({
+    batch: [],
+    pageInfo: SyncBackend.pageInfoNoMore,
+    backendId,
+  })
+
+export type PullResponse = typeof PullResponse.Type
+
+export const PushRequest = Schema.Struct({
+  batch: Schema.Array(LiveStoreEvent.AnyEncodedGlobal),
+  backendId: Schema.Option(BackendId),
+}).annotations({ title: '@livestore/sync-cf:PushRequest' })
+
+export type PushRequest = typeof PushRequest.Type
+
+export const PushAck = Schema.Struct({}).annotations({
+  title: '@livestore/sync-cf:PushAck',
+})
+
+export type PushAck = typeof PushAck.Type
+
+export const Ping = Schema.TaggedStruct('SyncMessage.Ping', {}).annotations({ title: '@livestore/sync-cf:Ping' })
+
+export type Ping = typeof Ping.Type
+
+export const Pong = Schema.TaggedStruct('SyncMessage.Pong', {}).annotations({ title: '@livestore/sync-cf:Pong' })
+
+export type Pong = typeof Pong.Type
+
+// Admin operations
+export const AdminResetRoomRequest = Schema.TaggedStruct('SyncMessage.AdminResetRoomRequest', {
+  adminSecret: Schema.String,
+}).annotations({ title: '@livestore/sync-cf:AdminResetRoomRequest' })
+
+export type AdminResetRoomRequest = typeof AdminResetRoomRequest.Type
+
+export const AdminResetRoomResponse = Schema.TaggedStruct('SyncMessage.AdminResetRoomResponse', {}).annotations({
+  title: '@livestore/sync-cf:AdminResetRoomResponse',
+})
+
+export type AdminResetRoomResponse = typeof AdminResetRoomResponse.Type
+
+export const AdminInfoRequest = Schema.TaggedStruct('SyncMessage.AdminInfoRequest', {
+  adminSecret: Schema.String,
+}).annotations({ title: '@livestore/sync-cf:AdminInfoRequest' })
+
+export type AdminInfoRequest = typeof AdminInfoRequest.Type
+
+export const AdminInfoResponse = Schema.TaggedStruct('SyncMessage.AdminInfoResponse', {
+  info: Schema.Struct({
+    durableObjectId: Schema.String,
+  }),
+}).annotations({ title: '@livestore/sync-cf:AdminInfoResponse' })
+
+export type AdminInfoResponse = typeof AdminInfoResponse.Type
+
+export const BackendToClientMessage = Schema.Union(
+  PullResponse,
+  PushAck,
+  Pong,
+  AdminResetRoomResponse,
+  AdminInfoResponse,
+)
+export type BackendToClientMessage = typeof BackendToClientMessage.Type
+
+export const ClientToBackendMessage = Schema.Union(
+  PullRequest,
+  PushRequest,
+  Ping,
+  AdminResetRoomRequest,
+  AdminInfoRequest,
+)
+export type ClientToBackendMessage = typeof ClientToBackendMessage.Type
+
+export const Message = Schema.Union(BackendToClientMessage, ClientToBackendMessage)
+export type Message = typeof Message.Type