@livestore/adapter-node 0.4.0-dev.9 → 0.5.0-dev.0

package/src/client-session/adapter.ts

@@ -1,6 +1,8 @@
 import { hostname } from 'node:os'
 import path from 'node:path'
+import type { URL } from 'node:url'
 import * as WT from 'node:worker_threads'
+
 import {
   type Adapter,
   type BootStatus,
@@ -9,11 +11,10 @@ import {
   type LockStatus,
   type MakeSqliteDb,
   makeClientSession,
-  type SyncError,
   type SyncOptions,
-  UnexpectedError,
+  UnknownError,
 } from '@livestore/common'
-import { Eventlog, LeaderThreadCtx } from '@livestore/common/leader-thread'
+import { Eventlog, LeaderThreadCtx, streamEventsWithSyncState } from '@livestore/common/leader-thread'
 import type { LiveStoreSchema } from '@livestore/common/schema'
 import { LiveStoreEvent } from '@livestore/common/schema'
 import { loadSqlite3Wasm } from '@livestore/sqlite-wasm/load-wasm'
@@ -27,20 +28,22 @@ import {
   Fiber,
   FileSystem,
   Layer,
-  ParseResult,
   Queue,
+  RpcClient,
+  RpcWorker,
   Schedule,
   Schema,
+  Scope,
   Stream,
+  Subscribable,
   SubscriptionRef,
-  Worker,
-  WorkerError,
 } from '@livestore/utils/effect'
 import { PlatformNode } from '@livestore/utils/node'
 import * as Webmesh from '@livestore/webmesh'
 
 import type { TestingOverrides } from '../leader-thread-shared.ts'
 import { makeLeaderThread } from '../leader-thread-shared.ts'
+import { type WithoutRpcClientError, dieOnRpcClientError, dieOnRpcClientErrorStream } from '../rpc-worker.ts'
 import { makeShutdownChannel } from '../shutdown-channel.ts'
 import * as WorkerSchema from '../worker-schema.ts'
 
@@ -87,7 +90,43 @@ export interface NodeAdapterOptions {
   }
 }
 
-/** Runs everything in the same thread. Use `makeWorkerAdapter` for multi-threaded implementation. */
+/**
+ * Creates a single-threaded LiveStore adapter for Node.js applications.
+ *
+ * This adapter runs the leader thread (persistence and sync) in the same thread as
+ * your application. Suitable for CLI tools, scripts, and applications where simplicity
+ * is preferred over maximum performance.
+ *
+ * For production servers or performance-critical applications, consider `makeWorkerAdapter`
+ * which runs persistence/sync in a separate worker thread.
+ *
+ * @example
+ * ```ts
+ * import { makeAdapter } from '@livestore/adapter-node'
+ * import { makeWsSync } from '@livestore/sync-cf/client'
+ *
+ * const adapter = makeAdapter({
+ *   storage: { type: 'fs', baseDirectory: './data' },
+ *   sync: {
+ *     backend: makeWsSync({ url: 'wss://api.example.com/sync' }),
+ *   },
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With DevTools support
+ * const adapter = makeAdapter({
+ *   storage: { type: 'fs', baseDirectory: './data' },
+ *   devtools: {
+ *     schemaPath: new URL('./schema.ts', import.meta.url),
+ *     port: 4242,
+ *   },
+ * })
+ * ```
+ *
+ * @see https://livestore.dev/docs/reference/adapters/node for setup guide
+ */
 export const makeAdapter = ({
   sync,
   ...options
@@ -96,7 +135,36 @@ export const makeAdapter = ({
 }): Adapter => makeAdapterImpl({ ...options, leaderThread: { _tag: 'single-threaded', sync } })
 
 /**
- * Runs persistence and syncing in a worker thread.
+ * Creates a multi-threaded LiveStore adapter for Node.js applications.
+ *
+ * This adapter runs the leader thread (persistence, sync, and heavy SQLite operations)
+ * in a separate worker thread, keeping your main thread responsive. Recommended for
+ * production servers and performance-critical applications.
+ *
+ * You must create a worker file that calls `makeLeaderWorker()` and pass its URL
+ * to this function.
+ *
+ * @example
+ * ```ts
+ * // In your main file:
+ * import { makeWorkerAdapter } from '@livestore/adapter-node'
+ *
+ * const adapter = makeWorkerAdapter({
+ *   storage: { type: 'fs', baseDirectory: './data' },
+ *   workerUrl: new URL('./livestore.worker.ts', import.meta.url),
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // In livestore.worker.ts:
+ * import { makeLeaderWorker } from '@livestore/adapter-node/worker'
+ * import { schema } from './schema'
+ *
+ * makeLeaderWorker({ schema })
+ * ```
+ *
+ * @see https://livestore.dev/docs/reference/adapters/node for setup guide
  */
 export const makeWorkerAdapter = ({
   workerUrl,
@@ -111,7 +179,7 @@ export const makeWorkerAdapter = ({
    * Extra arguments to pass to the worker which can be accessed in the worker
    * via `getWorkerArgs()`
    */
-  workerExtraArgs?: Schema.JsonValue
+  workerExtraArgs?: Schema.Json
 }): Adapter => makeAdapterImpl({ ...options, leaderThread: { _tag: 'multi-threaded', workerUrl, workerExtraArgs } })
 
 const makeAdapterImpl = ({
@@ -132,12 +200,13 @@ const makeAdapterImpl = ({
     | {
         _tag: 'multi-threaded'
         workerUrl: URL
-        workerExtraArgs: Schema.JsonValue | undefined
+        workerExtraArgs: Schema.Json | undefined
       }
 }): Adapter =>
   ((adapterArgs) =>
     Effect.gen(function* () {
-      const { storeId, devtoolsEnabled, shutdown, bootStatusQueue, syncPayload, schema } = adapterArgs
+      const { storeId, devtoolsEnabled, shutdown, bootStatusQueue, syncPayloadEncoded, syncPayloadSchema, schema } =
+        adapterArgs
 
       yield* Queue.offer(bootStatusQueue, { stage: 'loading' })
 
@@ -157,15 +226,15 @@ const makeAdapterImpl = ({
       if (resetPersistence === true) {
         yield* shutdownChannel
           .send(IntentionalShutdownCause.make({ reason: 'adapter-reset' }))
-          .pipe(UnexpectedError.mapToUnexpectedError)
+          .pipe(UnknownError.mapToUnknownError)
 
         yield* resetNodePersistence({ storage, storeId })
       }
 
       yield* shutdownChannel.listen.pipe(
-        Stream.flatten(),
+        Stream.mapEffect(Effect.fromResult),
         Stream.tap((cause) =>
-          shutdown(cause._tag === 'LiveStore.IntentionalShutdownCause' ? Exit.succeed(cause) : Exit.fail(cause)),
+          shutdown(cause._tag === 'IntentionalShutdownCause' ? Exit.succeed(cause) : Exit.fail(cause)),
         ),
         Stream.runDrain,
         Effect.interruptible,
@@ -178,8 +247,8 @@ const makeAdapterImpl = ({
       // TODO actually implement this multi-session support
       const lockStatus = yield* SubscriptionRef.make<LockStatus>('has-lock')
 
-      const devtoolsOptions: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools'] =
-        devtoolsEnabled && devtoolsOptionsInput !== undefined
+      const devtoolsOptions: WorkerSchema.LeaderWorkerInnerInitialMessagePayload['devtools'] =
+        devtoolsEnabled === true && devtoolsOptionsInput !== undefined
           ? {
               enabled: true,
               schemaPath:
@@ -204,10 +273,11 @@ const makeAdapterImpl = ({
               storage,
               ...omitUndefineds({
                 syncOptions: leaderThreadInput.sync,
-                syncPayload,
+                syncPayloadEncoded,
+                syncPayloadSchema,
                 testing,
               }),
-            }).pipe(UnexpectedError.mapToUnexpectedError)
+            }).pipe(UnknownError.mapToUnknownError)
           : yield* makeWorkerLeaderThread({
               shutdown,
               storeId,
@@ -218,8 +288,8 @@ const makeAdapterImpl = ({
               storage,
               devtools: devtoolsOptions,
               bootStatusQueue,
-              syncPayload,
-            })
+              syncPayloadEncoded,
+            }).pipe(UnknownError.mapToUnknownError)
 
       syncInMemoryDb.import(initialSnapshot)
       syncInMemoryDb.debug.head = leaderThread.initialState.leaderHead
@@ -229,7 +299,7 @@ const makeAdapterImpl = ({
         sqliteDb: syncInMemoryDb,
         webmeshMode: 'proxy',
         connectWebmeshNode: Effect.fnUntraced(function* ({ webmeshNode }) {
-          if (devtoolsOptions.enabled) {
+          if (devtoolsOptions.enabled === true) {
             yield* Webmesh.connectViaWebSocket({
               node: webmeshNode,
               url: `ws://${devtoolsOptions.host}:${devtoolsOptions.port}`,
@@ -244,6 +314,7 @@ const makeAdapterImpl = ({
         isLeader: true,
         // Not really applicable for node as there is no "reload the app" concept
         registerBeforeUnload: (_onBeforeUnload) => () => {},
+        origin: undefined,
       })
 
       return clientSession
@@ -258,7 +329,7 @@ const resetNodePersistence = ({
 }: {
   storage: WorkerSchema.StorageType
   storeId: string
-}): Effect.Effect<void, UnexpectedError, FileSystem.FileSystem> => {
+}): Effect.Effect<void, UnknownError, FileSystem.FileSystem> => {
   if (storage.type !== 'fs') {
     return Effect.void
   }
@@ -268,13 +339,13 @@ const resetNodePersistence = ({
   return Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem
 
-    const directoryExists = yield* fs.exists(directory).pipe(UnexpectedError.mapToUnexpectedError)
+    const directoryExists = yield* fs.exists(directory).pipe(UnknownError.mapToUnknownError)
 
     if (directoryExists === false) {
       return
     }
 
-    yield* fs.remove(directory, { recursive: true }).pipe(UnexpectedError.mapToUnexpectedError)
+    yield* fs.remove(directory, { recursive: true }).pipe(UnknownError.mapToUnknownError)
   }).pipe(
     Effect.retry({ schedule: Schedule.exponentialBackoff10Sec }),
     Effect.withSpan('@livestore/adapter-node:resetPersistence', { attributes: { directory } }),
@@ -287,7 +358,8 @@ const makeLocalLeaderThread = ({
   schema,
   makeSqliteDb,
   syncOptions,
-  syncPayload,
+  syncPayloadEncoded,
+  syncPayloadSchema,
   storage,
   devtools,
   testing,
@@ -298,29 +370,46 @@ const makeLocalLeaderThread = ({
   makeSqliteDb: MakeSqliteDb
   syncOptions: SyncOptions | undefined
   storage: WorkerSchema.StorageType
-  syncPayload: Schema.JsonValue | undefined
-  devtools: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools']
+  syncPayloadEncoded: Schema.Json | undefined
+  syncPayloadSchema: Schema.Schema<any>
+  devtools: WorkerSchema.LeaderWorkerInnerInitialMessagePayload['devtools']
   testing?: {
     overrides?: TestingOverrides
   }
 }) =>
   Effect.gen(function* () {
-    const layer = yield* Layer.build(
-      makeLeaderThread({
-        storeId,
-        clientId,
-        schema,
-        syncOptions,
-        storage,
-        syncPayload,
-        devtools,
-        makeSqliteDb,
-        ...omitUndefineds({ testing: testing?.overrides }),
-      }).pipe(Layer.unwrapScoped),
-    )
+    // The single-threaded node adapter runs the leader thread co-located in the same runtime as the
+    // client session. Unlike the worker adapters (where the leader lives on its own event loop and drains
+    // pushes independently), a co-located leader only makes progress when the surrounding fibers yield.
+    //
+    // We give the leader thread its own dedicated scope whose teardown finalizer is registered *before*
+    // `makeClientSession`. Finalizers run in reverse registration order, so on store shutdown the client
+    // session tears down first and only then is the leader thread scope closed — keeping the leader (and
+    // its SQLite connections) alive while the client-session pusher's in-flight batch is still being
+    // persisted. Building the leader into the ambient store scope instead (via `Layer.build`) interrupts
+    // the leader's push drainer concurrently with the client session, dropping the in-flight batch and
+    // causing silent data loss on commit-then-shutdown.
+    const leaderThreadScope = yield* Scope.make()
+    yield* Effect.addFinalizer((exit) => Scope.close(leaderThreadScope, exit))
+
+    const leaderThreadLayer = yield* makeLeaderThread({
+      storeId,
+      clientId,
+      schema,
+      syncOptions,
+      storage,
+      syncPayloadEncoded,
+      syncPayloadSchema,
+      devtools,
+      makeSqliteDb,
+      ...omitUndefineds({ testing: testing?.overrides }),
+    }).pipe(Scope.provide(leaderThreadScope))
+
+    const layer = yield* Layer.buildWithScope(leaderThreadLayer, leaderThreadScope)
 
     return yield* Effect.gen(function* () {
-      const { dbState, dbEventlog, syncProcessor, extraIncomingMessagesQueue, initialState } = yield* LeaderThreadCtx
+      const { dbState, dbEventlog, syncProcessor, extraIncomingMessagesQueue, initialState, networkStatus } =
+        yield* LeaderThreadCtx
 
       const initialLeaderHead = Eventlog.getClientHeadFromDb(dbEventlog)
 
@@ -329,16 +418,30 @@ const makeLocalLeaderThread = ({
           events: {
             pull: ({ cursor }) => syncProcessor.pull({ cursor }),
             push: (batch) =>
-              syncProcessor.push(
-                batch.map((item) => new LiveStoreEvent.EncodedWithMeta(item)),
-                { waitForProcessing: true },
-              ),
+              // Mirror the worker `PushToLeader` handler which runs the leader push uninterruptibly.
+              // Together with the dedicated `leaderThreadScope` above, this guarantees an in-flight batch is
+              // fully persisted by the (still-live) leader before the co-located pusher fiber is interrupted
+              // on store shutdown.
+              syncProcessor
+                .push(batch.map((item) => new LiveStoreEvent.Client.EncodedWithMeta(item)))
+                .pipe(Effect.uninterruptible),
+            stream: (options) =>
+              streamEventsWithSyncState({
+                dbEventlog,
+                syncState: syncProcessor.syncState,
+                options,
+              }),
+          },
+          initialState: {
+            leaderHead: initialLeaderHead,
+            migrationsReport: initialState.migrationsReport,
+            storageMode: 'persisted',
           },
-          initialState: { leaderHead: initialLeaderHead, migrationsReport: initialState.migrationsReport },
           export: Effect.sync(() => dbState.export()),
           getEventlogData: Effect.sync(() => dbEventlog.export()),
-          getSyncState: syncProcessor.syncState,
-          sendDevtoolsMessage: (message) => extraIncomingMessagesQueue.offer(message),
+          syncState: syncProcessor.syncState,
+          sendDevtoolsMessage: (message) => Queue.offer(extraIncomingMessagesQueue, message),
+          networkStatus,
         },
         { ...omitUndefineds({ overrides: testing?.overrides?.clientSession?.leaderThreadProxy }) },
       )
@@ -359,139 +462,140 @@ const makeWorkerLeaderThread = ({
   storage,
   devtools,
   bootStatusQueue,
-  syncPayload,
+  syncPayloadEncoded,
   testing,
 }: {
-  shutdown: (cause: Exit.Exit<IntentionalShutdownCause, UnexpectedError | SyncError>) => Effect.Effect<void>
+  shutdown: (cause: Exit.Exit<IntentionalShutdownCause, UnknownError>) => Effect.Effect<void>
   storeId: string
   clientId: string
   sessionId: string
   workerUrl: URL
-  workerExtraArgs: Schema.JsonValue | undefined
+  workerExtraArgs: Schema.Json | undefined
   storage: WorkerSchema.StorageType
-  devtools: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools']
+  devtools: WorkerSchema.LeaderWorkerInnerInitialMessagePayload['devtools']
   bootStatusQueue: Queue.Queue<BootStatus>
-  syncPayload: Schema.JsonValue | undefined
+  syncPayloadEncoded: Schema.Json | undefined
   testing?: {
     overrides?: TestingOverrides
   }
 }) =>
   Effect.gen(function* () {
     const nodeWorker = new WT.Worker(workerUrl, {
-      execArgv: process.env.DEBUG_WORKER ? ['--inspect --enable-source-maps'] : ['--enable-source-maps'],
-      argv: [Schema.encodeSync(WorkerSchema.WorkerArgv)({ storeId, clientId, sessionId, extraArgs: workerExtraArgs })],
-    })
-    const nodeWorkerLayer = yield* Layer.build(PlatformNode.NodeWorker.layer(() => nodeWorker))
-
-    const worker = yield* Worker.makePoolSerialized<typeof WorkerSchema.LeaderWorkerInnerRequest.Type>({
-      size: 1,
-      concurrency: 100,
-      initialMessage: () =>
-        new WorkerSchema.LeaderWorkerInnerInitialMessage({
+      execArgv: process.env.DEBUG_WORKER !== undefined ? ['--inspect --enable-source-maps'] : ['--enable-source-maps'],
+      argv: [
+        yield* Schema.encodeEffect(WorkerSchema.WorkerArgv)({
           storeId,
           clientId,
-          storage,
-          devtools,
-          syncPayload,
-        }),
-    }).pipe(
-      Effect.provide(nodeWorkerLayer),
-      UnexpectedError.mapToUnexpectedError,
-      Effect.tapErrorCause((cause) => shutdown(Exit.failCause(cause))),
+          sessionId,
+          extraArgs: workerExtraArgs,
+        }).pipe(Effect.orDie),
+      ],
+    })
+    const innerWorkerContext = yield* Layer.build(
+      RpcClient.layerProtocolWorker({ size: 1, concurrency: 100 }).pipe(
+        Layer.provide(PlatformNode.NodeWorker.layer(() => nodeWorker)),
+        Layer.provide(
+          RpcWorker.layerInitialMessage(
+            WorkerSchema.LeaderWorkerInnerInitialMessage.payloadSchema,
+            Effect.succeed({ storeId, clientId, storage, devtools, syncPayloadEncoded }),
+          ),
+        ),
+      ),
+    )
+
+    const worker = yield* RpcClient.make(WorkerSchema.LeaderWorkerInnerRpcs).pipe(
+      Effect.provide(innerWorkerContext),
+      UnknownError.mapToUnknownError,
+      Effect.tapCause((cause) => shutdown(Exit.failCause(cause))),
       Effect.withSpan('@livestore/adapter-node:adapter:setupLeaderThread'),
     )
 
-    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>
-      : never =>
-      (worker.executeEffect(req) as any).pipe(
+    const runInWorker = <A, E, R>(
+      tag: string,
+      effect: Effect.Effect<A, E, R>,
+    ): Effect.Effect<A, WithoutRpcClientError<E>, R> =>
+      effect.pipe(
+        dieOnRpcClientError,
         Effect.logWarnIfTakesLongerThan({
-          label: `@livestore/adapter-node:client-session:runInWorker:${req._tag}`,
+          label: `@livestore/adapter-node:client-session:runInWorker:${tag}`,
           duration: 2000,
         }),
-        Effect.withSpan(`@livestore/adapter-node:client-session:runInWorker:${req._tag}`),
-        Effect.mapError((cause) =>
-          Schema.is(UnexpectedError)(cause)
-            ? cause
-            : ParseResult.isParseError(cause) || Schema.is(WorkerError.WorkerError)(cause)
-              ? new UnexpectedError({ cause })
-              : cause,
-        ),
-        Effect.catchAllDefect((cause) => new UnexpectedError({ cause })),
-      ) as any
-
-    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>
-      : never =>
-      worker.execute(req as any).pipe(
-        Stream.mapError((cause) =>
-          Schema.is(UnexpectedError)(cause)
-            ? cause
-            : ParseResult.isParseError(cause) || Schema.is(WorkerError.WorkerError)(cause)
-              ? new UnexpectedError({ cause })
-              : cause,
-        ),
-        Stream.withSpan(`@livestore/adapter-node:client-session:runInWorkerStream:${req._tag}`),
-      ) as any
+        Effect.withSpan(`@livestore/adapter-node:client-session:runInWorker:${tag}`),
+      )
 
-    const bootStatusFiber = yield* runInWorkerStream(new WorkerSchema.LeaderWorkerInnerBootStatusStream()).pipe(
+    const runInWorkerStream = <A, E, R>(
+      tag: string,
+      stream: Stream.Stream<A, E, R>,
+    ): Stream.Stream<A, WithoutRpcClientError<E>, R> =>
+      stream.pipe(
+        dieOnRpcClientErrorStream,
+        Stream.withSpan(`@livestore/adapter-node:client-session:runInWorkerStream:${tag}`),
+      )
+
+    const bootStatusFiber = yield* runInWorkerStream('BootStatusStream', worker.BootStatusStream({})).pipe(
       Stream.tap((bootStatus) => Queue.offer(bootStatusQueue, bootStatus)),
       Stream.runDrain,
-      Effect.tapErrorCause((cause) => (Cause.isInterruptedOnly(cause) ? Effect.void : shutdown(Exit.failCause(cause)))),
+      Effect.tapCause((cause) =>
+        Cause.hasInterruptsOnly(cause) === true ? Effect.void : shutdown(Exit.failCause(cause)),
+      ),
       Effect.interruptible,
       Effect.tapCauseLogPretty,
       Effect.forkScoped,
     )
 
-    yield* Queue.awaitShutdown(bootStatusQueue).pipe(
+    yield* Queue.await(bootStatusQueue).pipe(
       Effect.andThen(Fiber.interrupt(bootStatusFiber)),
       Effect.tapCauseLogPretty,
       Effect.forkScoped,
     )
 
-    const initialLeaderHead = yield* runInWorker(new WorkerSchema.LeaderWorkerInnerGetLeaderHead())
+    const initialLeaderHead = yield* runInWorker('GetLeaderHead', worker.GetLeaderHead({}))
 
-    const bootResult = yield* runInWorker(new WorkerSchema.LeaderWorkerInnerGetRecreateSnapshot()).pipe(
-      Effect.timeout(10_000),
-      UnexpectedError.mapToUnexpectedError,
+    const bootResult = yield* runInWorker('GetRecreateSnapshot', worker.GetRecreateSnapshot({})).pipe(
+      Effect.timeoutOrDie(10_000),
       Effect.withSpan('@livestore/adapter-node:client-session:export'),
     )
 
     const leaderThread = ClientSessionLeaderThreadProxy.of(
       {
         events: {
-          pull: ({ cursor }) =>
-            runInWorkerStream(new WorkerSchema.LeaderWorkerInnerPullStream({ cursor })).pipe(Stream.orDie),
+          pull: ({ cursor }) => runInWorkerStream('PullStream', worker.PullStream({ cursor })).pipe(Stream.orDie),
           push: (batch) =>
-            runInWorker(new WorkerSchema.LeaderWorkerInnerPushToLeader({ batch })).pipe(
+            runInWorker('PushToLeader', worker.PushToLeader({ batch })).pipe(
               Effect.withSpan('@livestore/adapter-node:client-session:pushToLeader', {
                 attributes: { batchSize: batch.length },
               }),
             ),
+          stream: (options) =>
+            runInWorkerStream('StreamEvents', worker.StreamEvents(options)).pipe(
+              Stream.withSpan('@livestore/adapter-node:client-session:streamEvents'),
+              Stream.orDie,
+            ),
         },
         initialState: {
           leaderHead: initialLeaderHead,
           migrationsReport: bootResult.migrationsReport,
+          storageMode: 'persisted',
         },
-        export: runInWorker(new WorkerSchema.LeaderWorkerInnerExport()).pipe(
-          Effect.timeout(10_000),
-          UnexpectedError.mapToUnexpectedError,
+        export: runInWorker('Export', worker.Export({})).pipe(
+          Effect.timeoutOrDie(10_000),
           Effect.withSpan('@livestore/adapter-node:client-session:export'),
         ),
-        getEventlogData: Effect.dieMessage('Not implemented'),
-        getSyncState: runInWorker(new WorkerSchema.LeaderWorkerInnerGetLeaderSyncState()).pipe(
-          UnexpectedError.mapToUnexpectedError,
-          Effect.withSpan('@livestore/adapter-node:client-session:getLeaderSyncState'),
-        ),
+        getEventlogData: Effect.die('Not implemented'),
+        syncState: Subscribable.make({
+          get: runInWorker('GetLeaderSyncState', worker.GetLeaderSyncState({})).pipe(
+            Effect.withSpan('@livestore/adapter-node:client-session:getLeaderSyncState'),
+          ),
+          changes: runInWorkerStream('SyncStateStream', worker.SyncStateStream({})).pipe(Stream.orDie),
+        }),
         sendDevtoolsMessage: (message) =>
-          runInWorker(new WorkerSchema.LeaderWorkerInnerExtraDevtoolsMessage({ message })).pipe(
-            UnexpectedError.mapToUnexpectedError,
+          runInWorker('ExtraDevtoolsMessage', worker.ExtraDevtoolsMessage({ message })).pipe(
             Effect.withSpan('@livestore/adapter-node:client-session:devtoolsMessageForLeader'),
           ),
+        networkStatus: Subscribable.make({
+          get: runInWorker('GetNetworkStatus', worker.GetNetworkStatus({})).pipe(Effect.orDie),
+          changes: runInWorkerStream('NetworkStatusStream', worker.NetworkStatusStream({})).pipe(Stream.orDie),
+        }),
       },
       {
         ...omitUndefineds({ overrides: testing?.overrides?.clientSession?.leaderThreadProxy }),