@livestore/adapter-node 0.3.2-dev.0 → 0.3.2-dev.5

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@livestore/adapter-node",
-  "version": "0.3.2-dev.0",
+  "version": "0.3.2-dev.5",
   "type": "module",
   "sideEffects": false,
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
       "default": "./dist/index.js"
     },
     "./devtools": {
@@ -26,13 +27,13 @@
     }
   },
   "dependencies": {
-    "@livestore/devtools-vite": "0.3.2-dev.0",
+    "@livestore/devtools-vite": "0.3.2-dev.5",
     "@opentelemetry/api": "1.9.0",
     "vite": "7.0.0",
-    "@livestore/common": "0.3.2-dev.0",
-    "@livestore/sqlite-wasm": "0.3.2-dev.0",
-    "@livestore/webmesh": "0.3.2-dev.0",
-    "@livestore/utils": "0.3.2-dev.0"
+    "@livestore/common": "0.3.2-dev.5",
+    "@livestore/sqlite-wasm": "0.3.2-dev.5",
+    "@livestore/utils": "0.3.2-dev.5",
+    "@livestore/webmesh": "0.3.2-dev.5"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^28.0.3",

package/src/client-session/adapter.ts

@@ -1,6 +1,5 @@
 import { hostname } from 'node:os'
 import * as WT from 'node:worker_threads'
-
 import {
   type Adapter,
   type BootStatus,
@@ -8,9 +7,10 @@ import {
   type IntentionalShutdownCause,
   type LockStatus,
   type MakeSqliteDb,
+  makeClientSession,
   type SyncOptions,
+  UnexpectedError,
 } from '@livestore/common'
-import { makeClientSession, UnexpectedError } from '@livestore/common'
 import { Eventlog, LeaderThreadCtx } from '@livestore/common/leader-thread'
 import type { LiveStoreSchema } from '@livestore/common/schema'
 import { LiveStoreEvent } from '@livestore/common/schema'
@@ -33,10 +33,10 @@ import {
 import { PlatformNode } from '@livestore/utils/node'
 import * as Webmesh from '@livestore/webmesh'
 
-import type { TestingOverrides } from '../leader-thread-shared.js'
-import { makeLeaderThread } from '../leader-thread-shared.js'
-import { makeShutdownChannel } from '../shutdown-channel.js'
-import * as WorkerSchema from '../worker-schema.js'
+import type { TestingOverrides } from '../leader-thread-shared.ts'
+import { makeLeaderThread } from '../leader-thread-shared.ts'
+import { makeShutdownChannel } from '../shutdown-channel.ts'
+import * as WorkerSchema from '../worker-schema.ts'
 
 export interface NodeAdapterOptions {
   storage: WorkerSchema.StorageType
@@ -90,7 +90,7 @@ export const makeWorkerAdapter = ({
   ...options
 }: NodeAdapterOptions & {
   /**
-   * Example: `new URL('./livestore.worker.js', import.meta.url)`
+   * Example: `new URL('./livestore.worker.ts', import.meta.url)`
    */
   workerUrl: URL
 }): Adapter => makeAdapterImpl({ ...options, leaderThread: { _tag: 'multi-threaded', workerUrl } })
@@ -147,7 +147,7 @@ const makeAdapterImpl = ({
       // TODO actually implement this multi-session support
       const lockStatus = yield* SubscriptionRef.make<LockStatus>('has-lock')
 
-      const devtoolsOptions: WorkerSchema.LeaderWorkerInner.InitialMessage['devtools'] =
+      const devtoolsOptions: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools'] =
         devtoolsEnabled && devtoolsOptionsInput !== undefined
           ? {
               enabled: true,
@@ -215,7 +215,6 @@ const makeAdapterImpl = ({
       return clientSession
     }).pipe(
       Effect.withSpan('@livestore/adapter-node:adapter'),
-      Effect.parallelFinalizers,
       Effect.provide(PlatformNode.NodeFileSystem.layer),
       Effect.provide(FetchHttpClient.layer),
     )) satisfies Adapter
@@ -238,7 +237,7 @@ const makeLocalLeaderThread = ({
   syncOptions: SyncOptions | undefined
   storage: WorkerSchema.StorageType
   syncPayload: Schema.JsonValue | undefined
-  devtools: WorkerSchema.LeaderWorkerInner.InitialMessage['devtools']
+  devtools: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools']
   testing?: {
     overrides?: TestingOverrides
   }
@@ -306,7 +305,7 @@ const makeWorkerLeaderThread = ({
   sessionId: string
   workerUrl: URL
   storage: WorkerSchema.StorageType
-  devtools: WorkerSchema.LeaderWorkerInner.InitialMessage['devtools']
+  devtools: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools']
   bootStatusQueue: Queue.Queue<BootStatus>
   syncPayload: Schema.JsonValue | undefined
   testing?: {
@@ -320,11 +319,11 @@ const makeWorkerLeaderThread = ({
     })
     const nodeWorkerLayer = yield* Layer.build(PlatformNode.NodeWorker.layer(() => nodeWorker))
 
-    const worker = yield* Worker.makePoolSerialized<typeof WorkerSchema.LeaderWorkerInner.Request.Type>({
+    const worker = yield* Worker.makePoolSerialized<typeof WorkerSchema.LeaderWorkerInnerRequest.Type>({
       size: 1,
       concurrency: 100,
       initialMessage: () =>
-        new WorkerSchema.LeaderWorkerInner.InitialMessage({
+        new WorkerSchema.LeaderWorkerInnerInitialMessage({
           storeId,
           clientId,
           storage,
@@ -338,21 +337,7 @@ const makeWorkerLeaderThread = ({
       Effect.withSpan('@livestore/adapter-node:adapter:setupLeaderThread'),
     )
 
-    yield* Effect.addFinalizer(() =>
-      Effect.gen(function* () {
-        // We first try to gracefully shutdown the leader worker and then forcefully terminate it
-        yield* Effect.raceFirst(
-          runInWorker(new WorkerSchema.LeaderWorkerInner.Shutdown()).pipe(Effect.andThen(() => nodeWorker.terminate())),
-
-          Effect.sync(() => {
-            console.warn('[@livestore/adapter-node:adapter] Worker did not gracefully shutdown in time, terminating it')
-            nodeWorker.terminate()
-          }).pipe(Effect.delay(1000)),
-        ).pipe(Effect.exit) // The disconnect is to prevent the interrupt to bubble out
-      }).pipe(Effect.withSpan('@livestore/adapter-node:adapter:shutdown'), Effect.tapCauseLogPretty, Effect.orDie),
-    )
-
-    const runInWorker = <TReq extends typeof WorkerSchema.LeaderWorkerInner.Request.Type>(
+    const runInWorker = <TReq extends typeof WorkerSchema.LeaderWorkerInnerRequest.Type>(
       req: TReq,
     ): TReq extends Schema.WithResult<infer A, infer _I, infer _E, infer _EI, infer R>
       ? Effect.Effect<A, UnexpectedError, R>
@@ -373,7 +358,7 @@ const makeWorkerLeaderThread = ({
         Effect.catchAllDefect((cause) => new UnexpectedError({ cause })),
       ) as any
 
-    const runInWorkerStream = <TReq extends typeof WorkerSchema.LeaderWorkerInner.Request.Type>(
+    const runInWorkerStream = <TReq extends typeof WorkerSchema.LeaderWorkerInnerRequest.Type>(
       req: TReq,
     ): TReq extends Schema.WithResult<infer A, infer _I, infer _E, infer _EI, infer R>
       ? Stream.Stream<A, UnexpectedError, R>
@@ -389,7 +374,7 @@ const makeWorkerLeaderThread = ({
         Stream.withSpan(`@livestore/adapter-node:client-session:runInWorkerStream:${req._tag}`),
       ) as any
 
-    const bootStatusFiber = yield* runInWorkerStream(new WorkerSchema.LeaderWorkerInner.BootStatusStream()).pipe(
+    const bootStatusFiber = yield* runInWorkerStream(new WorkerSchema.LeaderWorkerInnerBootStatusStream()).pipe(
       Stream.tap((bootStatus) => Queue.offer(bootStatusQueue, bootStatus)),
       Stream.runDrain,
       Effect.tapErrorCause((cause) => (Cause.isInterruptedOnly(cause) ? Effect.void : shutdown(cause))),
@@ -404,9 +389,9 @@ const makeWorkerLeaderThread = ({
       Effect.forkScoped,
     )
 
-    const initialLeaderHead = yield* runInWorker(new WorkerSchema.LeaderWorkerInner.GetLeaderHead())
+    const initialLeaderHead = yield* runInWorker(new WorkerSchema.LeaderWorkerInnerGetLeaderHead())
 
-    const bootResult = yield* runInWorker(new WorkerSchema.LeaderWorkerInner.GetRecreateSnapshot()).pipe(
+    const bootResult = yield* runInWorker(new WorkerSchema.LeaderWorkerInnerGetRecreateSnapshot()).pipe(
       Effect.timeout(10_000),
       UnexpectedError.mapToUnexpectedError,
       Effect.withSpan('@livestore/adapter-node:client-session:export'),
@@ -416,9 +401,9 @@ const makeWorkerLeaderThread = ({
       {
         events: {
           pull: ({ cursor }) =>
-            runInWorkerStream(new WorkerSchema.LeaderWorkerInner.PullStream({ cursor })).pipe(Stream.orDie),
+            runInWorkerStream(new WorkerSchema.LeaderWorkerInnerPullStream({ cursor })).pipe(Stream.orDie),
           push: (batch) =>
-            runInWorker(new WorkerSchema.LeaderWorkerInner.PushToLeader({ batch })).pipe(
+            runInWorker(new WorkerSchema.LeaderWorkerInnerPushToLeader({ batch })).pipe(
               Effect.withSpan('@livestore/adapter-node:client-session:pushToLeader', {
                 attributes: { batchSize: batch.length },
               }),
@@ -428,18 +413,18 @@ const makeWorkerLeaderThread = ({
           leaderHead: initialLeaderHead,
           migrationsReport: bootResult.migrationsReport,
         },
-        export: runInWorker(new WorkerSchema.LeaderWorkerInner.Export()).pipe(
+        export: runInWorker(new WorkerSchema.LeaderWorkerInnerExport()).pipe(
           Effect.timeout(10_000),
           UnexpectedError.mapToUnexpectedError,
           Effect.withSpan('@livestore/adapter-node:client-session:export'),
         ),
         getEventlogData: Effect.dieMessage('Not implemented'),
-        getSyncState: runInWorker(new WorkerSchema.LeaderWorkerInner.GetLeaderSyncState()).pipe(
+        getSyncState: runInWorker(new WorkerSchema.LeaderWorkerInnerGetLeaderSyncState()).pipe(
           UnexpectedError.mapToUnexpectedError,
           Effect.withSpan('@livestore/adapter-node:client-session:getLeaderSyncState'),
         ),
         sendDevtoolsMessage: (message) =>
-          runInWorker(new WorkerSchema.LeaderWorkerInner.ExtraDevtoolsMessage({ message })).pipe(
+          runInWorker(new WorkerSchema.LeaderWorkerInnerExtraDevtoolsMessage({ message })).pipe(
             UnexpectedError.mapToUnexpectedError,
             Effect.withSpan('@livestore/adapter-node:client-session:devtoolsMessageForLeader'),
           ),

package/src/devtools/devtools-server.ts

@@ -2,7 +2,7 @@ import http from 'node:http'
 import path from 'node:path'
 
 import type { Devtools } from '@livestore/common'
-import { LS_DEV } from '@livestore/utils'
+import { isReadonlyArray, LS_DEV } from '@livestore/utils'
 import type { HttpClient } from '@livestore/utils/effect'
 import {
   Deferred,
@@ -18,7 +18,7 @@ import {
 import { PlatformNode } from '@livestore/utils/node'
 import { makeMeshNode, makeWebSocketEdge } from '@livestore/webmesh'
 
-import { makeViteMiddleware } from './vite-dev-server.js'
+import { makeViteMiddleware } from './vite-dev-server.ts'
 
 /**
  * Starts a devtools HTTP/WS server which serves ...
@@ -31,7 +31,7 @@ export const startDevtoolsServer = ({
   port,
   host,
 }: {
-  schemaPath: string
+  schemaPath: string | ReadonlyArray<string>
   clientSessionInfo: Devtools.SessionInfo.SessionInfo | undefined
   host: string
   port: number
@@ -39,7 +39,9 @@ export const startDevtoolsServer = ({
   Effect.gen(function* () {
     const viteMiddleware = yield* makeViteMiddleware({
       mode: { _tag: 'node', url: `http://${host}:${port}` },
-      schemaPath: path.resolve(process.cwd(), schemaPath),
+      schemaPath: isReadonlyArray(schemaPath)
+        ? schemaPath.map((schemaPath) => path.resolve(process.cwd(), schemaPath))
+        : path.resolve(process.cwd(), schemaPath),
       viteConfig: (viteConfig) => {
         if (LS_DEV) {
           viteConfig.server ??= {}
@@ -85,7 +87,7 @@ export const startDevtoolsServer = ({
             }
 
             // We want to keep the websocket open until the client disconnects or the server shuts down
-            yield* Effect.never
+            return yield* Effect.never
           }),
           webChannel.closedDeferred,
         )

package/src/devtools/mod.ts

@@ -1,3 +1,3 @@
-export { makeViteMiddleware } from './vite-dev-server.js'
-export type { ViteDevtoolsOptions } from './vite-dev-server.js'
-export { startDevtoolsServer } from './devtools-server.js'
+export { startDevtoolsServer } from './devtools-server.ts'
+export type { ViteDevtoolsOptions } from './vite-dev-server.ts'
+export { makeViteMiddleware } from './vite-dev-server.ts'

package/src/devtools/vite-dev-server.ts

@@ -3,6 +3,7 @@ import path from 'node:path'
 import type { Devtools } from '@livestore/common'
 import { UnexpectedError } from '@livestore/common'
 import { livestoreDevtoolsPlugin } from '@livestore/devtools-vite'
+import { isReadonlyArray } from '@livestore/utils'
 import { Effect } from '@livestore/utils/effect'
 import { getFreePort } from '@livestore/utils/node'
 import * as Vite from 'vite'
@@ -15,7 +16,7 @@ export type ViteDevtoolsOptions = {
    *
    * Example: `./src/schema.ts`
    */
-  schemaPath: string
+  schemaPath: string | ReadonlyArray<string>
   /**
    * The mode of the devtools server.
    *
@@ -44,7 +45,9 @@ export const makeViteMiddleware = (options: ViteDevtoolsOptions): Effect.Effect<
       base: '/_livestore/',
       plugins: [
         livestoreDevtoolsPlugin({
-          schemaPath: path.resolve(cwd, options.schemaPath),
+          schemaPath: isReadonlyArray(options.schemaPath)
+            ? options.schemaPath.map((schemaPath) => path.resolve(cwd, schemaPath))
+            : path.resolve(cwd, options.schemaPath),
           mode: options.mode,
           path: '/',
         }),

package/src/index.ts

@@ -1 +1 @@
-export { makeAdapter, makeWorkerAdapter } from './client-session/adapter.js'
+export { makeAdapter, makeWorkerAdapter } from './client-session/adapter.ts'

package/src/leader-thread-lazy.ts

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

package/src/leader-thread-shared.ts

@@ -16,8 +16,8 @@ import type { FileSystem, HttpClient, Layer, Schema, Scope } from '@livestore/ut
 import { Effect } from '@livestore/utils/effect'
 import * as Webmesh from '@livestore/webmesh'
 
-import { makeShutdownChannel } from './shutdown-channel.js'
-import type * as WorkerSchema from './worker-schema.js'
+import { makeShutdownChannel } from './shutdown-channel.ts'
+import type * as WorkerSchema from './worker-schema.ts'
 
 export type TestingOverrides = {
   clientSession?: {
@@ -40,7 +40,7 @@ export interface MakeLeaderThreadArgs {
   syncOptions: SyncOptions | undefined
   storage: WorkerSchema.StorageType
   makeSqliteDb: MakeNodeSqliteDb
-  devtools: WorkerSchema.LeaderWorkerInner.InitialMessage['devtools']
+  devtools: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools']
   schema: LiveStoreSchema
   syncPayload: Schema.JsonValue | undefined
   testing: TestingOverrides | undefined
@@ -131,7 +131,7 @@ const makeDevtoolsOptions = ({
   dbEventlog: LeaderSqliteDb
   storeId: string
   clientId: string
-  devtools: WorkerSchema.LeaderWorkerInner.InitialMessage['devtools']
+  devtools: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools']
 }): Effect.Effect<DevtoolsOptions, UnexpectedError, Scope.Scope> =>
   Effect.gen(function* () {
     if (devtools.enabled === false) {
@@ -144,7 +144,7 @@ const makeDevtoolsOptions = ({
       enabled: true,
       boot: Effect.gen(function* () {
         // Lazy import to improve startup time
-        const { startDevtoolsServer } = yield* Effect.promise(() => import('./devtools/devtools-server.js'))
+        const { startDevtoolsServer } = yield* Effect.promise(() => import('./devtools/devtools-server.ts'))
 
         // 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
         if (devtools.useExistingDevtoolsServer === false) {

package/src/make-leader-worker.ts

@@ -1,4 +1,4 @@
-import './thread-polyfill.js'
+import './thread-polyfill.ts'
 
 import inspector from 'node:inspector'
 
@@ -29,9 +29,9 @@ import {
 import { PlatformNode } from '@livestore/utils/node'
 import type * as otel from '@opentelemetry/api'
 
-import type { TestingOverrides } from './leader-thread-shared.js'
-import { makeLeaderThread } from './leader-thread-shared.js'
-import * as WorkerSchema from './worker-schema.js'
+import type { TestingOverrides } from './leader-thread-shared.ts'
+import { makeLeaderThread } from './leader-thread-shared.ts'
+import * as WorkerSchema from './worker-schema.ts'
 
 export type WorkerOptions = {
   schema: LiveStoreSchema
@@ -47,7 +47,10 @@ export type WorkerOptions = {
 export const getWorkerArgs = () => Schema.decodeSync(WorkerSchema.WorkerArgv)(process.argv[2]!)
 
 export const makeWorker = (options: WorkerOptions) => {
-  makeWorkerEffect(options).pipe(PlatformNode.NodeRuntime.runMain)
+  makeWorkerEffect(options).pipe(
+    Effect.provide(Logger.prettyWithThread(options.otelOptions?.serviceName ?? 'livestore-node-leader-thread')),
+    PlatformNode.NodeRuntime.runMain,
+  )
 }
 
 export const makeWorkerEffect = (options: WorkerOptions) => {
@@ -57,7 +60,7 @@ export const makeWorkerEffect = (options: WorkerOptions) => {
       )
     : undefined
 
-  return WorkerRunner.layerSerialized(WorkerSchema.LeaderWorkerInner.Request, {
+  return WorkerRunner.layerSerialized(WorkerSchema.LeaderWorkerInnerRequest, {
     InitialMessage: (args) =>
       Effect.gen(function* () {
         const sqlite3 = yield* Effect.promise(() => loadSqlite3Wasm()).pipe(
@@ -153,7 +156,9 @@ export const makeWorkerEffect = (options: WorkerOptions) => {
       thread: options.otelOptions?.serviceName ?? 'livestore-node-leader-thread',
       processId: process.pid,
     }),
-    Effect.provide(Logger.prettyWithThread(options.otelOptions?.serviceName ?? 'livestore-node-leader-thread')),
+    // TODO bring back with Effect 4 once it's easier to work with replacing loggers.
+    // We basically only want to provide this logger if it's replacing the default logger, not if there's a custom logger already provided.
+    // 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,

package/src/shutdown-channel.ts

@@ -1,6 +1,6 @@
 import { ShutdownChannel } from '@livestore/common/leader-thread'
 
-import { makeBroadcastChannel } from './webchannel.js'
+import { makeBroadcastChannel } from './webchannel.ts'
 
 export const makeShutdownChannel = (storeId: string) =>
   makeBroadcastChannel({

package/src/webchannel.ts

@@ -37,7 +37,6 @@ export const makeBroadcastChannel = <Msg, MsgEncoded>({
       const listen = Stream.asyncPush<Either.Either<Msg, ParseResult.ParseError>>((emit) =>
         Effect.acquireRelease(
           Effect.gen(function* () {
-            // eslint-disable-next-line unicorn/prefer-add-event-listener
             channel.onmessage = (event: any) => {
               return emit.single(Schema.decodeEither(schema)(event.data))
             }

package/src/worker-schema.ts

@@ -42,18 +42,20 @@ export type StorageTypeEncoded = typeof StorageType.Encoded
 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', {
+export class LeaderWorkerOuterInitialMessage extends Schema.TaggedRequest<LeaderWorkerOuterInitialMessage>()(
+  'InitialMessage',
+  {
     payload: { port: Transferable.MessagePort },
     success: Schema.Void,
     failure: UnexpectedError,
-  }) {}
+  },
+) {}
 
-  export class Request extends Schema.Union(InitialMessage) {}
-}
+export class LeaderWorkerOuterRequest extends Schema.Union(LeaderWorkerOuterInitialMessage) {}
 
-export namespace LeaderWorkerInner {
-  export class InitialMessage extends Schema.TaggedRequest<InitialMessage>()('InitialMessage', {
+export class LeaderWorkerInnerInitialMessage extends Schema.TaggedRequest<LeaderWorkerInnerInitialMessage>()(
+  'InitialMessage',
+  {
     payload: {
       storeId: Schema.String,
       clientId: Schema.String,
@@ -73,91 +75,112 @@ export namespace LeaderWorkerInner {
     },
     success: Schema.Void,
     failure: UnexpectedError,
-  }) {}
+  },
+) {}
 
-  export class BootStatusStream extends Schema.TaggedRequest<BootStatusStream>()('BootStatusStream', {
+export class LeaderWorkerInnerBootStatusStream extends Schema.TaggedRequest<LeaderWorkerInnerBootStatusStream>()(
+  'BootStatusStream',
+  {
     payload: {},
     success: BootStatus,
     failure: UnexpectedError,
-  }) {}
-
-  export class PullStream extends Schema.TaggedRequest<PullStream>()('PullStream', {
-    payload: {
-      cursor: EventSequenceNumber.EventSequenceNumber,
-    },
-    success: Schema.Struct({
-      payload: SyncState.PayloadUpstream,
-    }),
-    failure: UnexpectedError,
-  }) {}
+  },
+) {}
+
+export class LeaderWorkerInnerPullStream extends Schema.TaggedRequest<LeaderWorkerInnerPullStream>()('PullStream', {
+  payload: {
+    cursor: EventSequenceNumber.EventSequenceNumber,
+  },
+  success: Schema.Struct({
+    payload: SyncState.PayloadUpstream,
+  }),
+  failure: UnexpectedError,
+}) {}
 
-  export class PushToLeader extends Schema.TaggedRequest<PushToLeader>()('PushToLeader', {
+export class LeaderWorkerInnerPushToLeader extends Schema.TaggedRequest<LeaderWorkerInnerPushToLeader>()(
+  'PushToLeader',
+  {
     payload: {
       batch: Schema.Array(LiveStoreEvent.AnyEncoded),
     },
     success: Schema.Void,
     failure: Schema.Union(UnexpectedError, LeaderAheadError),
-  }) {}
-
-  export class Export extends Schema.TaggedRequest<Export>()('Export', {
-    payload: {},
-    success: Transferable.Uint8Array,
-    failure: UnexpectedError,
-  }) {}
-
-  export class GetRecreateSnapshot extends Schema.TaggedRequest<GetRecreateSnapshot>()('GetRecreateSnapshot', {
+  },
+) {}
+
+export class LeaderWorkerInnerExport extends Schema.TaggedRequest<LeaderWorkerInnerExport>()('Export', {
+  payload: {},
+  success: Transferable.Uint8Array,
+  failure: UnexpectedError,
+}) {}
+
+export class LeaderWorkerInnerGetRecreateSnapshot extends Schema.TaggedRequest<LeaderWorkerInnerGetRecreateSnapshot>()(
+  'GetRecreateSnapshot',
+  {
     payload: {},
     success: Schema.Struct({
       snapshot: Transferable.Uint8Array,
       migrationsReport: MigrationsReport,
     }),
     failure: UnexpectedError,
-  }) {}
+  },
+) {}
 
-  export class ExportEventlog extends Schema.TaggedRequest<ExportEventlog>()('ExportEventlog', {
+export class LeaderWorkerInnerExportEventlog extends Schema.TaggedRequest<LeaderWorkerInnerExportEventlog>()(
+  'ExportEventlog',
+  {
     payload: {},
     success: Transferable.Uint8Array,
     failure: UnexpectedError,
-  }) {}
+  },
+) {}
 
-  export class GetLeaderHead extends Schema.TaggedRequest<GetLeaderHead>()('GetLeaderHead', {
+export class LeaderWorkerInnerGetLeaderHead extends Schema.TaggedRequest<LeaderWorkerInnerGetLeaderHead>()(
+  'GetLeaderHead',
+  {
     payload: {},
     success: EventSequenceNumber.EventSequenceNumber,
     failure: UnexpectedError,
-  }) {}
+  },
+) {}
 
-  export class GetLeaderSyncState extends Schema.TaggedRequest<GetLeaderSyncState>()('GetLeaderSyncState', {
+export class LeaderWorkerInnerGetLeaderSyncState extends Schema.TaggedRequest<LeaderWorkerInnerGetLeaderSyncState>()(
+  'GetLeaderSyncState',
+  {
     payload: {},
     success: SyncState.SyncState,
     failure: UnexpectedError,
-  }) {}
-
-  export class Shutdown extends Schema.TaggedRequest<Shutdown>()('Shutdown', {
-    payload: {},
-    success: Schema.Void,
-    failure: UnexpectedError,
-  }) {}
-
-  export class ExtraDevtoolsMessage extends Schema.TaggedRequest<ExtraDevtoolsMessage>()('ExtraDevtoolsMessage', {
+  },
+) {}
+
+export class LeaderWorkerInnerShutdown extends Schema.TaggedRequest<LeaderWorkerInnerShutdown>()('Shutdown', {
+  payload: {},
+  success: Schema.Void,
+  failure: UnexpectedError,
+}) {}
+
+export class LeaderWorkerInnerExtraDevtoolsMessage extends Schema.TaggedRequest<LeaderWorkerInnerExtraDevtoolsMessage>()(
+  'ExtraDevtoolsMessage',
+  {
     payload: {
       message: Devtools.Leader.MessageToApp,
     },
     success: Schema.Void,
     failure: UnexpectedError,
-  }) {}
-
-  export const Request = Schema.Union(
-    InitialMessage,
-    BootStatusStream,
-    PullStream,
-    PushToLeader,
-    Export,
-    GetRecreateSnapshot,
-    ExportEventlog,
-    GetLeaderHead,
-    GetLeaderSyncState,
-    Shutdown,
-    ExtraDevtoolsMessage,
-  )
-  export type Request = typeof Request.Type
-}
+  },
+) {}
+
+export const LeaderWorkerInnerRequest = Schema.Union(
+  LeaderWorkerInnerInitialMessage,
+  LeaderWorkerInnerBootStatusStream,
+  LeaderWorkerInnerPullStream,
+  LeaderWorkerInnerPushToLeader,
+  LeaderWorkerInnerExport,
+  LeaderWorkerInnerGetRecreateSnapshot,
+  LeaderWorkerInnerExportEventlog,
+  LeaderWorkerInnerGetLeaderHead,
+  LeaderWorkerInnerGetLeaderSyncState,
+  LeaderWorkerInnerShutdown,
+  LeaderWorkerInnerExtraDevtoolsMessage,
+)
+export type LeaderWorkerInnerRequest = typeof LeaderWorkerInnerRequest.Type