@livestore/adapter-node 0.0.0-snapshot-a953343ad2d7468c6573bcb5e26f0eab4302078f

package/src/in-memory/index.ts

@@ -0,0 +1,133 @@
+import type {
+  Adapter,
+  ClientSession,
+  ClientSessionLeaderThreadProxy,
+  LockStatus,
+  MakeSqliteDb,
+  SyncOptions,
+} from '@livestore/common'
+import { UnexpectedError } from '@livestore/common'
+import { getClientHeadFromDb, LeaderThreadCtx, makeLeaderThreadLayer } from '@livestore/common/leader-thread'
+import type { LiveStoreSchema } from '@livestore/common/schema'
+import { MutationEvent } from '@livestore/common/schema'
+import { sqliteDbFactory } from '@livestore/sqlite-wasm/browser'
+import { loadSqlite3Wasm } from '@livestore/sqlite-wasm/load-wasm'
+import { Effect, FetchHttpClient, Layer, Stream, SubscriptionRef, WebChannel } from '@livestore/utils/effect'
+import { nanoid } from '@livestore/utils/nanoid'
+
+// TODO unify in-memory adapter with other in-memory adapter implementations
+
+export interface InMemoryAdapterOptions {
+  sync?: SyncOptions
+  /**
+   * @default 'in-memory'
+   */
+  clientId?: string
+}
+
+/** NOTE: This adapter is currently only used for testing */
+export const makeInMemoryAdapter =
+  ({ sync: syncOptions, clientId = 'in-memory' }: InMemoryAdapterOptions): Adapter =>
+  ({
+    schema,
+    storeId,
+    // devtoolsEnabled, bootStatusQueue, shutdown, connectDevtoolsToStore
+  }) =>
+    Effect.gen(function* () {
+      const sqlite3 = yield* Effect.promise(() => loadSqlite3Wasm())
+
+      const makeSqliteDb = sqliteDbFactory({ sqlite3 })
+      const sqliteDb = yield* makeSqliteDb({ _tag: 'in-memory' })
+
+      const lockStatus = SubscriptionRef.make<LockStatus>('has-lock').pipe(Effect.runSync)
+
+      const sessionId = nanoid(6)
+
+      const { leaderThread, initialSnapshot } = yield* makeLeaderThread({
+        storeId,
+        clientId,
+        schema,
+        makeSqliteDb,
+        syncOptions,
+      })
+
+      sqliteDb.import(initialSnapshot)
+
+      const clientSession = {
+        sqliteDb,
+        devtools: { enabled: false },
+        clientId,
+        sessionId,
+        lockStatus,
+        leaderThread,
+        shutdown: () => Effect.dieMessage('TODO implement shutdown'),
+      } satisfies ClientSession
+
+      return clientSession
+    }).pipe(UnexpectedError.mapToUnexpectedError)
+
+const makeLeaderThread = ({
+  storeId,
+  clientId,
+  schema,
+  makeSqliteDb,
+  syncOptions,
+}: {
+  storeId: string
+  clientId: string
+  schema: LiveStoreSchema
+  makeSqliteDb: MakeSqliteDb
+  syncOptions: SyncOptions | undefined
+}) =>
+  Effect.gen(function* () {
+    const layer = yield* Layer.memoize(
+      makeLeaderThreadLayer({
+        clientId,
+        dbReadModel: yield* makeSqliteDb({ _tag: 'in-memory' }),
+        dbMutationLog: yield* makeSqliteDb({ _tag: 'in-memory' }),
+        devtoolsOptions: { enabled: false },
+        makeSqliteDb,
+        schema,
+        shutdownChannel: yield* WebChannel.noopChannel<any, any>(),
+        storeId,
+        syncOptions,
+      }).pipe(Layer.provideMerge(FetchHttpClient.layer)),
+    )
+
+    return yield* Effect.gen(function* () {
+      const {
+        dbReadModel: db,
+        dbMutationLog,
+        syncProcessor,
+        connectedClientSessionPullQueues,
+        extraIncomingMessagesQueue,
+        initialState,
+      } = yield* LeaderThreadCtx
+
+      const initialLeaderHead = getClientHeadFromDb(dbMutationLog)
+      const pullQueue = yield* connectedClientSessionPullQueues.makeQueue(initialLeaderHead)
+
+      const leaderThread = {
+        mutations: {
+          pull: Stream.fromQueue(pullQueue),
+          push: (batch) =>
+            syncProcessor
+              .push(batch.map((item) => new MutationEvent.EncodedWithMeta(item)))
+              .pipe(Effect.provide(layer), Effect.scoped),
+        },
+        initialState: { leaderHead: initialLeaderHead, migrationsReport: initialState.migrationsReport },
+        export: Effect.sync(() => db.export()),
+        getMutationLogData: Effect.sync(() => dbMutationLog.export()),
+        // TODO
+        networkStatus: SubscriptionRef.make({ isConnected: false, timestampMs: Date.now(), latchClosed: false }).pipe(
+          Effect.runSync,
+        ),
+        getSyncState: syncProcessor.syncState,
+        sendDevtoolsMessage: (message) => extraIncomingMessagesQueue.offer(message),
+      } satisfies ClientSessionLeaderThreadProxy
+
+      const initialSnapshot = db.export()
+
+      return { leaderThread, initialSnapshot }
+    }).pipe(Effect.provide(layer))
+  })

package/src/index.ts

@@ -0,0 +1,2 @@
+export { makeInMemoryAdapter } from './in-memory/index.js'
+export { makeNodeAdapter } from './client-session/index.js'

package/src/leader-thread-lazy.ts

@@ -0,0 +1,9 @@
+const run = async () => {
+  const start = Date.now()
+  // @ts-expect-error todo
+  const _module = await import('./leader-thread.bundle.js')
+  const end = Date.now()
+  console.log(`[@livestore/adapter-node:leader] Loaded in ${end - start}ms`)
+}
+
+run()

package/src/make-leader-worker.ts

@@ -0,0 +1,285 @@
+import './thread-polyfill.js'
+
+import inspector from 'node:inspector'
+import path from 'node:path'
+
+if (process.execArgv.includes('--inspect')) {
+  inspector.open()
+  inspector.waitForDebugger()
+}
+
+import type { NetworkStatus, SyncOptions } from '@livestore/common'
+import { Devtools, liveStoreStorageFormatVersion, UnexpectedError } from '@livestore/common'
+import type { DevtoolsOptions, LeaderSqliteDb } from '@livestore/common/leader-thread'
+import {
+  configureConnection,
+  getClientHeadFromDb,
+  LeaderThreadCtx,
+  makeLeaderThreadLayer,
+} from '@livestore/common/leader-thread'
+import type { LiveStoreSchema } from '@livestore/common/schema'
+import { MutationEvent } from '@livestore/common/schema'
+import { makeNodeDevtoolsChannel } from '@livestore/devtools-node-common/web-channel'
+import { loadSqlite3Wasm } from '@livestore/sqlite-wasm/load-wasm'
+import { sqliteDbFactory } from '@livestore/sqlite-wasm/node'
+import type { FileSystem, HttpClient, Scope } from '@livestore/utils/effect'
+import {
+  Effect,
+  FetchHttpClient,
+  identity,
+  Layer,
+  Logger,
+  LogLevel,
+  OtelTracer,
+  Schema,
+  Stream,
+  WorkerRunner,
+} from '@livestore/utils/effect'
+import { PlatformNode } from '@livestore/utils/node'
+import type * as otel from '@opentelemetry/api'
+
+import { startDevtoolsServer } from './devtools/devtools-server.js'
+import { makeShutdownChannel } from './shutdown-channel.js'
+import * as WorkerSchema from './worker-schema.js'
+
+export type WorkerOptions = {
+  sync?: SyncOptions
+  otelOptions?: {
+    tracer?: otel.Tracer
+    /** @default 'livestore-node-leader-thread' */
+    serviceName?: string
+  }
+}
+
+export const getWorkerArgs = () => Schema.decodeSync(WorkerSchema.WorkerArgv)(process.argv[2]!)
+
+export const makeWorker = (options: WorkerOptions) => {
+  makeWorkerEffect(options).pipe(Effect.runFork)
+}
+
+export const makeWorkerEffect = (options: WorkerOptions) => {
+  const TracingLive = options.otelOptions?.tracer
+    ? Layer.unwrapEffect(Effect.map(OtelTracer.make, Layer.setTracer)).pipe(
+        Layer.provideMerge(Layer.succeed(OtelTracer.OtelTracer, options.otelOptions.tracer)),
+      )
+    : undefined
+
+  return WorkerRunner.layerSerialized(WorkerSchema.LeaderWorkerInner.Request, {
+    InitialMessage: (args) => makeLeaderThread({ ...args, syncOptions: options.sync }),
+    PushToLeader: ({ batch }) =>
+      Effect.andThen(LeaderThreadCtx, (_) =>
+        _.syncProcessor.push(batch.map((item) => new MutationEvent.EncodedWithMeta(item))),
+      ).pipe(Effect.uninterruptible, Effect.withSpan('@livestore/adapter-node:worker:PushToLeader')),
+    BootStatusStream: () =>
+      Effect.andThen(LeaderThreadCtx, (_) => Stream.fromQueue(_.bootStatusQueue)).pipe(Stream.unwrap),
+    PullStream: ({ cursor }) =>
+      Effect.gen(function* () {
+        const { connectedClientSessionPullQueues } = yield* LeaderThreadCtx
+        const pullQueue = yield* connectedClientSessionPullQueues.makeQueue(cursor)
+        return Stream.fromQueue(pullQueue)
+      }).pipe(Stream.unwrapScoped),
+    Export: () =>
+      Effect.andThen(LeaderThreadCtx, (_) => _.dbReadModel.export()).pipe(
+        UnexpectedError.mapToUnexpectedError,
+        Effect.withSpan('@livestore/adapter-node:worker:Export'),
+      ),
+    ExportMutationlog: () =>
+      Effect.andThen(LeaderThreadCtx, (_) => _.dbMutationLog.export()).pipe(
+        UnexpectedError.mapToUnexpectedError,
+        Effect.withSpan('@livestore/adapter-node:worker:ExportMutationlog'),
+      ),
+    GetLeaderHead: () =>
+      Effect.gen(function* () {
+        const workerCtx = yield* LeaderThreadCtx
+        return getClientHeadFromDb(workerCtx.dbMutationLog)
+      }).pipe(UnexpectedError.mapToUnexpectedError, Effect.withSpan('@livestore/adapter-node:worker:GetLeaderHead')),
+    NetworkStatusStream: () =>
+      Effect.gen(function* (_) {
+        const ctx = yield* LeaderThreadCtx
+
+        if (ctx.syncBackend === undefined) {
+          return Stream.make<[NetworkStatus]>({ isConnected: false, timestampMs: Date.now(), latchClosed: false })
+        }
+
+        return ctx.syncBackend.isConnected.changes.pipe(
+          Stream.map((isConnected) => ({ isConnected, timestampMs: Date.now(), latchClosed: false })),
+        )
+      }).pipe(Stream.unwrap),
+    GetLeaderSyncState: () =>
+      Effect.gen(function* () {
+        const workerCtx = yield* LeaderThreadCtx
+        return yield* workerCtx.syncProcessor.syncState
+      }).pipe(
+        UnexpectedError.mapToUnexpectedError,
+        Effect.withSpan('@livestore/adapter-node:worker:GetLeaderSyncState'),
+      ),
+    GetRecreateSnapshot: () =>
+      Effect.gen(function* () {
+        const workerCtx = yield* LeaderThreadCtx
+        // const result = yield* Deferred.await(workerCtx.initialSetupDeferred)
+        // NOTE we can only return the cached snapshot once as it's transferred (i.e. disposed), so we need to set it to undefined
+        // const cachedSnapshot =
+        //   result._tag === 'Recreate' ? yield* Ref.getAndSet(result.snapshotRef, undefined) : undefined
+        // return cachedSnapshot ?? workerCtx.db.export()
+        const snapshot = workerCtx.dbReadModel.export()
+        return { snapshot, migrationsReport: workerCtx.initialState.migrationsReport }
+      }).pipe(
+        UnexpectedError.mapToUnexpectedError,
+        Effect.withSpan('@livestore/adapter-node:worker:GetRecreateSnapshot'),
+      ),
+    Shutdown: () =>
+      Effect.gen(function* () {
+        // const { db, dbMutationLog } = yield* LeaderThreadCtx
+        yield* Effect.logDebug('[@livestore/adapter-node:worker] Shutdown')
+
+        // if (devtools.enabled) {
+        //   yield* FiberSet.clear(devtools.connections)
+        // }
+        // db.close()
+        // dbMutationLog.close()
+
+        // Buy some time for Otel to flush
+        // TODO find a cleaner way to do this
+        // yield* Effect.sleep(1000)
+      }).pipe(UnexpectedError.mapToUnexpectedError, Effect.withSpan('@livestore/adapter-node:worker:Shutdown')),
+    ExtraDevtoolsMessage: ({ message }) =>
+      Effect.andThen(LeaderThreadCtx, (_) => _.extraIncomingMessagesQueue.offer(message)).pipe(
+        UnexpectedError.mapToUnexpectedError,
+        Effect.withSpan('@livestore/adapter-node:worker:ExtraDevtoolsMessage'),
+      ),
+  }).pipe(
+    Layer.provide(PlatformNode.NodeWorkerRunner.layer),
+    Layer.launch,
+    Effect.scoped,
+    Effect.tapCauseLogPretty,
+    Effect.annotateLogs({ thread: options.otelOptions?.serviceName ?? 'livestore-node-leader-thread' }),
+    Effect.provide(Logger.prettyWithThread(options.otelOptions?.serviceName ?? 'livestore-node-leader-thread')),
+    Effect.provide(FetchHttpClient.layer),
+    Effect.provide(PlatformNode.NodeFileSystem.layer),
+    TracingLive ? Effect.provide(TracingLive) : identity,
+    Logger.withMinimumLogLevel(LogLevel.Debug),
+  )
+}
+
+const makeLeaderThread = ({
+  storeId,
+  clientId,
+  syncOptions,
+  baseDirectory,
+  devtools,
+  schemaPath,
+}: WorkerSchema.LeaderWorkerInner.InitialMessage & {
+  syncOptions: SyncOptions | undefined
+  schemaPath: string
+}): Layer.Layer<LeaderThreadCtx, UnexpectedError, Scope.Scope | HttpClient.HttpClient | FileSystem.FileSystem> =>
+  Effect.gen(function* () {
+    const schema = yield* Effect.promise(() => import(schemaPath).then((m) => m.schema as LiveStoreSchema))
+
+    const sqlite3 = yield* Effect.promise(() => loadSqlite3Wasm()).pipe(
+      Effect.withSpan('@livestore/adapter-node:leader-thread:loadSqlite3Wasm'),
+    )
+    const makeSqliteDb = yield* sqliteDbFactory({ sqlite3 })
+    const runtime = yield* Effect.runtime<never>()
+
+    const schemaHashSuffix = schema.migrationOptions.strategy === 'manual' ? 'fixed' : schema.hash.toString()
+
+    const makeDb = (kind: 'app' | 'mutationlog') =>
+      makeSqliteDb({
+        _tag: 'fs',
+        directory: path.join(baseDirectory ?? '', storeId),
+        fileName:
+          kind === 'app' ? getAppDbFileName(schemaHashSuffix) : `mutationlog@${liveStoreStorageFormatVersion}.db`,
+        // TODO enable WAL for nodejs
+        configureDb: (db) =>
+          configureConnection(db, { foreignKeys: true }).pipe(Effect.provide(runtime), Effect.runSync),
+      }).pipe(Effect.acquireRelease((db) => Effect.sync(() => db.close())))
+
+    // Might involve some async work, so we're running them concurrently
+    const [dbReadModel, dbMutationLog] = yield* Effect.all([makeDb('app'), makeDb('mutationlog')], { concurrency: 2 })
+
+    const devtoolsOptions = yield* makeDevtoolsOptions({
+      devtoolsEnabled: devtools.enabled,
+      devtoolsPort: devtools.port,
+      dbReadModel,
+      dbMutationLog,
+      storeId,
+      clientId,
+      schemaPath,
+    })
+
+    const shutdownChannel = yield* makeShutdownChannel(storeId)
+
+    return makeLeaderThreadLayer({
+      schema,
+      storeId,
+      clientId,
+      makeSqliteDb,
+      syncOptions,
+      dbReadModel,
+      dbMutationLog,
+      devtoolsOptions,
+      shutdownChannel,
+    })
+  }).pipe(
+    Effect.tapCauseLogPretty,
+    UnexpectedError.mapToUnexpectedError,
+    Effect.withSpan('@livestore/adapter-node:worker:InitialMessage'),
+    Layer.unwrapScoped,
+  )
+
+const getAppDbFileName = (suffix: string) => `app${suffix}@${liveStoreStorageFormatVersion}.db`
+
+const makeDevtoolsOptions = ({
+  devtoolsEnabled,
+  dbReadModel,
+  dbMutationLog,
+  storeId,
+  clientId,
+  devtoolsPort,
+  schemaPath,
+}: {
+  devtoolsEnabled: boolean
+  dbReadModel: LeaderSqliteDb
+  dbMutationLog: LeaderSqliteDb
+  storeId: string
+  clientId: string
+  devtoolsPort: number
+  schemaPath: string
+}): Effect.Effect<DevtoolsOptions, UnexpectedError, Scope.Scope> =>
+  Effect.gen(function* () {
+    if (devtoolsEnabled === false) {
+      return {
+        enabled: false,
+      }
+    }
+
+    return {
+      enabled: true,
+      makeBootContext: Effect.gen(function* () {
+        // TODO instead of failing when the port is already in use, we should try to use that WS server instead of starting a new one
+        yield* startDevtoolsServer({
+          schemaPath,
+          storeId,
+          clientId,
+          sessionId: 'static', // TODO make this dynamic
+          port: devtoolsPort,
+        })
+
+        return {
+          devtoolsWebChannel: yield* makeNodeDevtoolsChannel({
+            nodeName: `leader-${storeId}-${clientId}`,
+            target: `devtools`,
+            url: `ws://localhost:${devtoolsPort}`,
+            schema: {
+              listen: Devtools.Leader.MessageToApp,
+              send: Devtools.Leader.MessageFromApp,
+            },
+          }),
+          persistenceInfo: {
+            readModel: dbReadModel.metadata.persistenceInfo,
+            mutationLog: dbMutationLog.metadata.persistenceInfo,
+          },
+        }
+      }),
+    }
+  })

package/src/shutdown-channel.ts

@@ -0,0 +1,9 @@
+import { ShutdownChannel } from '@livestore/common/leader-thread'
+
+import { makeBroadcastChannel } from './webchannel.js'
+
+export const makeShutdownChannel = (storeId: string) =>
+  makeBroadcastChannel({
+    channelName: `livestore.shutdown.${storeId}`,
+    schema: ShutdownChannel.All,
+  })

package/src/thread-polyfill.ts

@@ -0,0 +1 @@
+process.stdout.isTTY = true

package/src/webchannel.ts

@@ -0,0 +1,54 @@
+import { BroadcastChannel } from 'node:worker_threads'
+
+import type { Either, ParseResult } from '@livestore/utils/effect'
+import { Deferred, Effect, Exit, Schema, Scope, Stream, WebChannel } from '@livestore/utils/effect'
+
+export const makeBroadcastChannel = <Msg, MsgEncoded>({
+  channelName,
+  schema,
+}: {
+  channelName: string
+  schema: Schema.Schema<Msg, MsgEncoded>
+}): Effect.Effect<WebChannel.WebChannel<Msg, Msg>, never, Scope.Scope> =>
+  Effect.scopeWithCloseable((scope) =>
+    Effect.gen(function* () {
+      const channel = new BroadcastChannel(channelName)
+
+      yield* Effect.addFinalizer(() => Effect.try(() => channel.close()).pipe(Effect.ignoreLogged))
+
+      const send = (message: Msg) =>
+        Effect.gen(function* () {
+          const messageEncoded = yield* Schema.encode(schema)(message)
+          channel.postMessage(messageEncoded)
+        })
+
+      // TODO also listen to `messageerror` in parallel
+      // const listen = Stream.fromEventListener<MessageEvent>(channel, 'message').pipe(
+      //   Stream.map((_) => Schema.decodeEither(listenSchema)(_.data)),
+      // )
+
+      const listen = Stream.asyncPush<Either.Either<Msg, ParseResult.ParseError>>((emit) =>
+        Effect.gen(function* () {
+          // eslint-disable-next-line unicorn/prefer-add-event-listener
+          channel.onmessage = (event: any) => {
+            return emit.single(Schema.decodeEither(schema)(event.data))
+          }
+
+          return () => channel.unref()
+        }),
+      )
+
+      const closedDeferred = yield* Deferred.make<void>().pipe(Effect.acquireRelease(Deferred.done(Exit.void)))
+      const supportsTransferables = false
+
+      return {
+        [WebChannel.WebChannelSymbol]: WebChannel.WebChannelSymbol,
+        send,
+        listen,
+        closedDeferred,
+        schema: { listen: schema, send: schema },
+        supportsTransferables,
+        shutdown: Scope.close(scope, Exit.void),
+      }
+    }).pipe(Effect.withSpan(`WebChannel:broadcastChannel(${channelName})`)),
+  )

package/src/worker-schema.ts

@@ -0,0 +1,175 @@
+import { BootStatus, Devtools, InvalidPushError, MigrationsReport, SyncState, UnexpectedError } from '@livestore/common'
+import { EventId, MutationEvent } from '@livestore/common/schema'
+import { Schema, Transferable } from '@livestore/utils/effect'
+
+export const WorkerArgv = Schema.parseJson(
+  Schema.Struct({
+    clientId: Schema.String,
+    storeId: Schema.String,
+    sessionId: Schema.String,
+  }),
+)
+
+export const StorageTypeOpfs = Schema.Struct({
+  type: Schema.Literal('opfs'),
+  /**
+   * Default is `livestore-${storeId}`
+   *
+   * When providing this option, make sure to include the `storeId` in the path to avoid
+   * conflicts with other LiveStore apps.
+   */
+  directory: Schema.optional(Schema.String),
+})
+
+export type StorageTypeOpfs = typeof StorageTypeOpfs.Type
+
+// export const StorageTypeIndexeddb = Schema.Struct({
+//   type: Schema.Literal('indexeddb'),
+//   /** @default "livestore" */
+//   databaseName: Schema.optionalWith(Schema.String, { default: () => 'livestore' }),
+//   /** @default "livestore-" */
+//   storeNamePrefix: Schema.optionalWith(Schema.String, { default: () => 'livestore-' }),
+// })
+
+export const StorageType = Schema.Union(
+  StorageTypeOpfs,
+  // StorageTypeIndexeddb
+)
+export type StorageType = typeof StorageType.Type
+export type StorageTypeEncoded = typeof StorageType.Encoded
+
+// export const SyncBackendOptionsWebsocket = Schema.Struct({
+//   type: Schema.Literal('websocket'),
+//   url: Schema.String,
+//   storeId: Schema.String,
+// })
+
+// export const SyncBackendOptions = Schema.Union(SyncBackendOptionsWebsocket)
+export const SyncBackendOptions = Schema.Record({ key: Schema.String, value: Schema.JsonValue })
+export type SyncBackendOptions = Record<string, Schema.JsonValue>
+
+export namespace LeaderWorkerOuter {
+  export class InitialMessage extends Schema.TaggedRequest<InitialMessage>()('InitialMessage', {
+    payload: { port: Transferable.MessagePort },
+    success: Schema.Void,
+    failure: UnexpectedError,
+  }) {}
+
+  export class Request extends Schema.Union(InitialMessage) {}
+}
+
+export namespace LeaderWorkerInner {
+  export class InitialMessage extends Schema.TaggedRequest<InitialMessage>()('InitialMessage', {
+    payload: {
+      storeId: Schema.String,
+      clientId: Schema.String,
+      baseDirectory: Schema.optional(Schema.String),
+      schemaPath: Schema.String,
+      devtools: Schema.Struct({
+        port: Schema.Number,
+        enabled: Schema.Boolean,
+      }),
+    },
+    success: Schema.Void,
+    failure: UnexpectedError,
+  }) {}
+
+  export class BootStatusStream extends Schema.TaggedRequest<BootStatusStream>()('BootStatusStream', {
+    payload: {},
+    success: BootStatus,
+    failure: UnexpectedError,
+  }) {}
+
+  export class PullStream extends Schema.TaggedRequest<PullStream>()('PullStream', {
+    payload: {
+      cursor: EventId.EventId,
+    },
+    success: Schema.Struct({
+      // mutationEvents: Schema.Array(EncodedAny),
+      // backendHead: Schema.Number,
+      payload: SyncState.PayloadUpstream,
+      remaining: Schema.Number,
+    }),
+    failure: UnexpectedError,
+  }) {}
+
+  export class PushToLeader extends Schema.TaggedRequest<PushToLeader>()('PushToLeader', {
+    payload: {
+      batch: Schema.Array(MutationEvent.AnyEncoded),
+    },
+    success: Schema.Void,
+    failure: Schema.Union(UnexpectedError, InvalidPushError),
+  }) {}
+
+  export class Export extends Schema.TaggedRequest<Export>()('Export', {
+    payload: {},
+    success: Transferable.Uint8Array,
+    failure: UnexpectedError,
+  }) {}
+
+  export class GetRecreateSnapshot extends Schema.TaggedRequest<GetRecreateSnapshot>()('GetRecreateSnapshot', {
+    payload: {},
+    success: Schema.Struct({
+      snapshot: Transferable.Uint8Array,
+      migrationsReport: MigrationsReport,
+    }),
+    failure: UnexpectedError,
+  }) {}
+
+  export class ExportMutationlog extends Schema.TaggedRequest<ExportMutationlog>()('ExportMutationlog', {
+    payload: {},
+    success: Transferable.Uint8Array,
+    failure: UnexpectedError,
+  }) {}
+
+  export class GetLeaderHead extends Schema.TaggedRequest<GetLeaderHead>()('GetLeaderHead', {
+    payload: {},
+    success: EventId.EventId,
+    failure: UnexpectedError,
+  }) {}
+
+  export class GetLeaderSyncState extends Schema.TaggedRequest<GetLeaderSyncState>()('GetLeaderSyncState', {
+    payload: {},
+    success: SyncState.SyncState,
+    failure: UnexpectedError,
+  }) {}
+
+  export class NetworkStatusStream extends Schema.TaggedRequest<NetworkStatusStream>()('NetworkStatusStream', {
+    payload: {},
+    success: Schema.Struct({
+      isConnected: Schema.Boolean,
+      timestampMs: Schema.Number,
+    }),
+    failure: UnexpectedError,
+  }) {}
+
+  export class Shutdown extends Schema.TaggedRequest<Shutdown>()('Shutdown', {
+    payload: {},
+    success: Schema.Void,
+    failure: UnexpectedError,
+  }) {}
+
+  export class ExtraDevtoolsMessage extends Schema.TaggedRequest<ExtraDevtoolsMessage>()('ExtraDevtoolsMessage', {
+    payload: {
+      message: Devtools.Leader.MessageToApp,
+    },
+    success: Schema.Void,
+    failure: UnexpectedError,
+  }) {}
+
+  export const Request = Schema.Union(
+    InitialMessage,
+    BootStatusStream,
+    PullStream,
+    PushToLeader,
+    Export,
+    GetRecreateSnapshot,
+    ExportMutationlog,
+    GetLeaderHead,
+    GetLeaderSyncState,
+    NetworkStatusStream,
+    Shutdown,
+    ExtraDevtoolsMessage,
+  )
+  export type Request = typeof Request.Type
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "resolveJsonModule": true,
+    "tsBuildInfoFile": "./dist/.tsbuildinfo"
+  },
+  "include": ["./src"],
+  "references": [
+    { "path": "../common" },
+    { "path": "../utils" },
+    { "path": "../devtools-node-common" },
+    { "path": "../webmesh" },
+    { "path": "../sqlite-wasm" }
+  ]
+}