@livestore/adapter-node 0.4.0-dev.2 → 0.4.0-dev.20

package/src/client-session/adapter.ts

@@ -1,33 +1,38 @@
 import { hostname } from 'node:os'
+import path from 'node:path'
 import * as WT from 'node:worker_threads'
 import {
   type Adapter,
   type BootStatus,
   ClientSessionLeaderThreadProxy,
-  type IntentionalShutdownCause,
+  IntentionalShutdownCause,
   type LockStatus,
   type MakeSqliteDb,
   makeClientSession,
   type SyncError,
   type SyncOptions,
-  UnexpectedError,
+  UnknownError,
 } from '@livestore/common'
 import { Eventlog, LeaderThreadCtx } 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'
 import { sqliteDbFactory } from '@livestore/sqlite-wasm/node'
+import { omitUndefineds } from '@livestore/utils'
 import {
   Cause,
   Effect,
   Exit,
   FetchHttpClient,
   Fiber,
+  FileSystem,
   Layer,
   ParseResult,
   Queue,
+  Schedule,
   Schema,
   Stream,
+  Subscribable,
   SubscriptionRef,
   Worker,
   WorkerError,
@@ -50,6 +55,13 @@ export interface NodeAdapterOptions {
    */
   sessionId?: string
 
+  /**
+   * Warning: This will reset both the app and eventlog database. This should only be used during development.
+   *
+   * @default false
+   */
+  resetPersistence?: boolean
+
   devtools?: {
     schemaPath: string | URL
     /**
@@ -89,13 +101,19 @@ export const makeAdapter = ({
  */
 export const makeWorkerAdapter = ({
   workerUrl,
+  workerExtraArgs,
   ...options
 }: NodeAdapterOptions & {
   /**
    * Example: `new URL('./livestore.worker.ts', import.meta.url)`
    */
   workerUrl: URL
-}): Adapter => makeAdapterImpl({ ...options, leaderThread: { _tag: 'multi-threaded', workerUrl } })
+  /**
+   * Extra arguments to pass to the worker which can be accessed in the worker
+   * via `getWorkerArgs()`
+   */
+  workerExtraArgs?: Schema.JsonValue
+}): Adapter => makeAdapterImpl({ ...options, leaderThread: { _tag: 'multi-threaded', workerUrl, workerExtraArgs } })
 
 const makeAdapterImpl = ({
   storage,
@@ -104,6 +122,7 @@ const makeAdapterImpl = ({
   // TODO make this dynamic and actually support multiple sessions
   sessionId = 'static',
   testing,
+  resetPersistence = false,
   leaderThread: leaderThreadInput,
 }: NodeAdapterOptions & {
   leaderThread:
@@ -114,11 +133,13 @@ const makeAdapterImpl = ({
     | {
         _tag: 'multi-threaded'
         workerUrl: URL
+        workerExtraArgs: Schema.JsonValue | 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' })
 
@@ -135,6 +156,14 @@ const makeAdapterImpl = ({
 
       const shutdownChannel = yield* makeShutdownChannel(storeId)
 
+      if (resetPersistence === true) {
+        yield* shutdownChannel
+          .send(IntentionalShutdownCause.make({ reason: 'adapter-reset' }))
+          .pipe(UnknownError.mapToUnknownError)
+
+        yield* resetNodePersistence({ storage, storeId })
+      }
+
       yield* shutdownChannel.listen.pipe(
         Stream.flatten(),
         Stream.tap((cause) =>
@@ -173,22 +202,26 @@ const makeAdapterImpl = ({
               clientId,
               schema,
               makeSqliteDb,
-              syncOptions: leaderThreadInput.sync,
-              syncPayload,
               devtools: devtoolsOptions,
               storage,
-              testing,
-            }).pipe(UnexpectedError.mapToUnexpectedError)
+              ...omitUndefineds({
+                syncOptions: leaderThreadInput.sync,
+                syncPayloadEncoded,
+                syncPayloadSchema,
+                testing,
+              }),
+            }).pipe(UnknownError.mapToUnknownError)
           : yield* makeWorkerLeaderThread({
               shutdown,
               storeId,
               clientId,
               sessionId,
               workerUrl: leaderThreadInput.workerUrl,
+              workerExtraArgs: leaderThreadInput.workerExtraArgs,
               storage,
               devtools: devtoolsOptions,
               bootStatusQueue,
-              syncPayload,
+              syncPayloadEncoded,
             })
 
       syncInMemoryDb.import(initialSnapshot)
@@ -214,22 +247,52 @@ const makeAdapterImpl = ({
         isLeader: true,
         // Not really applicable for node as there is no "reload the app" concept
         registerBeforeUnload: (_onBeforeUnload) => () => {},
+        origin: undefined,
       })
 
       return clientSession
     }).pipe(
       Effect.withSpan('@livestore/adapter-node:adapter'),
-      Effect.provide(PlatformNode.NodeFileSystem.layer),
-      Effect.provide(FetchHttpClient.layer),
+      Effect.provide(Layer.mergeAll(PlatformNode.NodeFileSystem.layer, FetchHttpClient.layer)),
     )) satisfies Adapter
 
+const resetNodePersistence = ({
+  storage,
+  storeId,
+}: {
+  storage: WorkerSchema.StorageType
+  storeId: string
+}): Effect.Effect<void, UnknownError, FileSystem.FileSystem> => {
+  if (storage.type !== 'fs') {
+    return Effect.void
+  }
+
+  const directory = path.join(storage.baseDirectory ?? '', storeId)
+
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+
+    const directoryExists = yield* fs.exists(directory).pipe(UnknownError.mapToUnknownError)
+
+    if (directoryExists === false) {
+      return
+    }
+
+    yield* fs.remove(directory, { recursive: true }).pipe(UnknownError.mapToUnknownError)
+  }).pipe(
+    Effect.retry({ schedule: Schedule.exponentialBackoff10Sec }),
+    Effect.withSpan('@livestore/adapter-node:resetPersistence', { attributes: { directory } }),
+  )
+}
+
 const makeLocalLeaderThread = ({
   storeId,
   clientId,
   schema,
   makeSqliteDb,
   syncOptions,
-  syncPayload,
+  syncPayloadEncoded,
+  syncPayloadSchema,
   storage,
   devtools,
   testing,
@@ -240,7 +303,8 @@ const makeLocalLeaderThread = ({
   makeSqliteDb: MakeSqliteDb
   syncOptions: SyncOptions | undefined
   storage: WorkerSchema.StorageType
-  syncPayload: Schema.JsonValue | undefined
+  syncPayloadEncoded: Schema.JsonValue | undefined
+  syncPayloadSchema: Schema.Schema<any>
   devtools: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools']
   testing?: {
     overrides?: TestingOverrides
@@ -254,15 +318,17 @@ const makeLocalLeaderThread = ({
         schema,
         syncOptions,
         storage,
-        syncPayload,
+        syncPayloadEncoded,
+        syncPayloadSchema,
         devtools,
         makeSqliteDb,
-        testing: testing?.overrides,
+        ...omitUndefineds({ testing: testing?.overrides }),
       }).pipe(Layer.unwrapScoped),
     )
 
     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)
 
@@ -272,17 +338,18 @@ const makeLocalLeaderThread = ({
             pull: ({ cursor }) => syncProcessor.pull({ cursor }),
             push: (batch) =>
               syncProcessor.push(
-                batch.map((item) => new LiveStoreEvent.EncodedWithMeta(item)),
+                batch.map((item) => new LiveStoreEvent.Client.EncodedWithMeta(item)),
                 { waitForProcessing: true },
               ),
           },
           initialState: { leaderHead: initialLeaderHead, migrationsReport: initialState.migrationsReport },
           export: Effect.sync(() => dbState.export()),
           getEventlogData: Effect.sync(() => dbEventlog.export()),
-          getSyncState: syncProcessor.syncState,
+          syncState: syncProcessor.syncState,
           sendDevtoolsMessage: (message) => extraIncomingMessagesQueue.offer(message),
+          networkStatus,
         },
-        { overrides: testing?.overrides?.clientSession?.leaderThreadProxy },
+        { ...omitUndefineds({ overrides: testing?.overrides?.clientSession?.leaderThreadProxy }) },
       )
 
       const initialSnapshot = dbState.export()
@@ -297,21 +364,23 @@ const makeWorkerLeaderThread = ({
   clientId,
   sessionId,
   workerUrl,
+  workerExtraArgs,
   storage,
   devtools,
   bootStatusQueue,
-  syncPayload,
+  syncPayloadEncoded,
   testing,
 }: {
-  shutdown: (cause: Exit.Exit<IntentionalShutdownCause, UnexpectedError | SyncError>) => Effect.Effect<void>
+  shutdown: (cause: Exit.Exit<IntentionalShutdownCause, UnknownError | SyncError>) => Effect.Effect<void>
   storeId: string
   clientId: string
   sessionId: string
   workerUrl: URL
+  workerExtraArgs: Schema.JsonValue | undefined
   storage: WorkerSchema.StorageType
   devtools: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools']
   bootStatusQueue: Queue.Queue<BootStatus>
-  syncPayload: Schema.JsonValue | undefined
+  syncPayloadEncoded: Schema.JsonValue | undefined
   testing?: {
     overrides?: TestingOverrides
   }
@@ -319,7 +388,7 @@ const makeWorkerLeaderThread = ({
   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 })],
+      argv: [Schema.encodeSync(WorkerSchema.WorkerArgv)({ storeId, clientId, sessionId, extraArgs: workerExtraArgs })],
     })
     const nodeWorkerLayer = yield* Layer.build(PlatformNode.NodeWorker.layer(() => nodeWorker))
 
@@ -332,11 +401,11 @@ const makeWorkerLeaderThread = ({
           clientId,
           storage,
           devtools,
-          syncPayload,
+          syncPayloadEncoded,
         }),
     }).pipe(
       Effect.provide(nodeWorkerLayer),
-      UnexpectedError.mapToUnexpectedError,
+      UnknownError.mapToUnknownError,
       Effect.tapErrorCause((cause) => shutdown(Exit.failCause(cause))),
       Effect.withSpan('@livestore/adapter-node:adapter:setupLeaderThread'),
     )
@@ -344,7 +413,7 @@ const makeWorkerLeaderThread = ({
     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>
+      ? Effect.Effect<A, UnknownError, R>
       : never =>
       (worker.executeEffect(req) as any).pipe(
         Effect.logWarnIfTakesLongerThan({
@@ -353,26 +422,26 @@ const makeWorkerLeaderThread = ({
         }),
         Effect.withSpan(`@livestore/adapter-node:client-session:runInWorker:${req._tag}`),
         Effect.mapError((cause) =>
-          Schema.is(UnexpectedError)(cause)
+          Schema.is(UnknownError)(cause)
             ? cause
             : ParseResult.isParseError(cause) || Schema.is(WorkerError.WorkerError)(cause)
-              ? new UnexpectedError({ cause })
+              ? new UnknownError({ cause })
               : cause,
         ),
-        Effect.catchAllDefect((cause) => new UnexpectedError({ cause })),
+        Effect.catchAllDefect((cause) => new UnknownError({ 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>
+      ? Stream.Stream<A, UnknownError, R>
       : never =>
       worker.execute(req as any).pipe(
         Stream.mapError((cause) =>
-          Schema.is(UnexpectedError)(cause)
+          Schema.is(UnknownError)(cause)
             ? cause
             : ParseResult.isParseError(cause) || Schema.is(WorkerError.WorkerError)(cause)
-              ? new UnexpectedError({ cause })
+              ? new UnknownError({ cause })
               : cause,
         ),
         Stream.withSpan(`@livestore/adapter-node:client-session:runInWorkerStream:${req._tag}`),
@@ -397,7 +466,7 @@ const makeWorkerLeaderThread = ({
 
     const bootResult = yield* runInWorker(new WorkerSchema.LeaderWorkerInnerGetRecreateSnapshot()).pipe(
       Effect.timeout(10_000),
-      UnexpectedError.mapToUnexpectedError,
+      UnknownError.mapToUnknownError,
       Effect.withSpan('@livestore/adapter-node:client-session:export'),
     )
 
@@ -419,22 +488,29 @@ const makeWorkerLeaderThread = ({
         },
         export: runInWorker(new WorkerSchema.LeaderWorkerInnerExport()).pipe(
           Effect.timeout(10_000),
-          UnexpectedError.mapToUnexpectedError,
+          UnknownError.mapToUnknownError,
           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'),
-        ),
+        syncState: Subscribable.make({
+          get: runInWorker(new WorkerSchema.LeaderWorkerInnerGetLeaderSyncState()).pipe(
+            UnknownError.mapToUnknownError,
+            Effect.withSpan('@livestore/adapter-node:client-session:getLeaderSyncState'),
+          ),
+          changes: runInWorkerStream(new WorkerSchema.LeaderWorkerInnerSyncStateStream()).pipe(Stream.orDie),
+        }),
         sendDevtoolsMessage: (message) =>
           runInWorker(new WorkerSchema.LeaderWorkerInnerExtraDevtoolsMessage({ message })).pipe(
-            UnexpectedError.mapToUnexpectedError,
+            UnknownError.mapToUnknownError,
             Effect.withSpan('@livestore/adapter-node:client-session:devtoolsMessageForLeader'),
           ),
+        networkStatus: Subscribable.make({
+          get: runInWorker(new WorkerSchema.LeaderWorkerInnerGetNetworkStatus()).pipe(Effect.orDie),
+          changes: runInWorkerStream(new WorkerSchema.LeaderWorkerInnerNetworkStatusStream()).pipe(Stream.orDie),
+        }),
       },
       {
-        overrides: testing?.overrides?.clientSession?.leaderThreadProxy,
+        ...omitUndefineds({ overrides: testing?.overrides?.clientSession?.leaderThreadProxy }),
       },
     )
 

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

@@ -1,7 +1,7 @@
 import path from 'node:path'
 
 import type { Devtools } from '@livestore/common'
-import { UnexpectedError } from '@livestore/common'
+import { UnknownError } from '@livestore/common'
 import { livestoreDevtoolsPlugin } from '@livestore/devtools-vite'
 import { isReadonlyArray } from '@livestore/utils'
 import { Effect } from '@livestore/utils/effect'
@@ -26,11 +26,11 @@ export type ViteDevtoolsOptions = {
 }
 
 // NOTE this is currently also used in @livestore/devtools-expo
-export const makeViteMiddleware = (options: ViteDevtoolsOptions): Effect.Effect<Vite.ViteDevServer, UnexpectedError> =>
+export const makeViteMiddleware = (options: ViteDevtoolsOptions): Effect.Effect<Vite.ViteDevServer, UnknownError> =>
   Effect.gen(function* () {
     const cwd = process.cwd()
 
-    const hmrPort = yield* getFreePort.pipe(UnexpectedError.mapToUnexpectedError)
+    const hmrPort = yield* getFreePort.pipe(UnknownError.mapToUnknownError)
 
     const defaultViteConfig = Vite.defineConfig({
       server: {
@@ -58,9 +58,7 @@ export const makeViteMiddleware = (options: ViteDevtoolsOptions): Effect.Effect<
 
     const viteConfig = options.viteConfig?.(defaultViteConfig) ?? defaultViteConfig
 
-    const viteServer = yield* Effect.promise(() => Vite.createServer(viteConfig)).pipe(
-      UnexpectedError.mapToUnexpectedError,
-    )
+    const viteServer = yield* Effect.promise(() => Vite.createServer(viteConfig)).pipe(UnknownError.mapToUnknownError)
 
     return viteServer
   }).pipe(Effect.withSpan('@livestore/adapter-node:devtools:makeViteServer'))

package/src/leader-thread-shared.ts

@@ -7,7 +7,7 @@ if (process.execArgv.includes('--inspect')) {
 }
 
 import type { ClientSessionLeaderThreadProxy, MakeSqliteDb, SqliteDb, SyncOptions } from '@livestore/common'
-import { Devtools, liveStoreStorageFormatVersion, migrateDb, UnexpectedError } from '@livestore/common'
+import { Devtools, liveStoreStorageFormatVersion, migrateDb, UnknownError } from '@livestore/common'
 import type { DevtoolsOptions, LeaderSqliteDb, LeaderThreadCtx } from '@livestore/common/leader-thread'
 import { configureConnection, makeLeaderThreadLayer } from '@livestore/common/leader-thread'
 import type { LiveStoreSchema } from '@livestore/common/schema'
@@ -30,7 +30,7 @@ export type TestingOverrides = {
       dbEventlog: SqliteDb
       dbState: SqliteDb
     },
-    UnexpectedError
+    UnknownError
   >
 }
 
@@ -42,7 +42,8 @@ export interface MakeLeaderThreadArgs {
   makeSqliteDb: MakeNodeSqliteDb
   devtools: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools']
   schema: LiveStoreSchema
-  syncPayload: Schema.JsonValue | undefined
+  syncPayloadEncoded: Schema.JsonValue | undefined
+  syncPayloadSchema: Schema.Schema<any> | undefined
   testing: TestingOverrides | undefined
 }
 
@@ -54,11 +55,12 @@ export const makeLeaderThread = ({
   storage,
   devtools,
   schema,
-  syncPayload,
+  syncPayloadEncoded,
+  syncPayloadSchema,
   testing,
 }: MakeLeaderThreadArgs): Effect.Effect<
-  Layer.Layer<LeaderThreadCtx, UnexpectedError, Scope.Scope | HttpClient.HttpClient | FileSystem.FileSystem>,
-  UnexpectedError,
+  Layer.Layer<LeaderThreadCtx, UnknownError, Scope.Scope | HttpClient.HttpClient | FileSystem.FileSystem>,
+  UnknownError,
   Scope.Scope
 > =>
   Effect.gen(function* () {
@@ -113,11 +115,12 @@ export const makeLeaderThread = ({
       dbEventlog,
       devtoolsOptions,
       shutdownChannel,
-      syncPayload,
+      syncPayloadEncoded,
+      syncPayloadSchema,
     })
   }).pipe(
     Effect.tapCauseLogPretty,
-    UnexpectedError.mapToUnexpectedError,
+    UnknownError.mapToUnknownError,
     Effect.withSpan('@livestore/adapter-node:makeLeaderThread', {
       attributes: { storeId, clientId, storage, devtools, syncOptions },
     }),
@@ -137,7 +140,7 @@ const makeDevtoolsOptions = ({
   storeId: string
   clientId: string
   devtools: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools']
-}): Effect.Effect<DevtoolsOptions, UnexpectedError, Scope.Scope> =>
+}): Effect.Effect<DevtoolsOptions, UnknownError, Scope.Scope> =>
   Effect.gen(function* () {
     if (devtools.enabled === false) {
       return {
@@ -161,6 +164,7 @@ const makeDevtoolsOptions = ({
               sessionId: 'static', // TODO make this dynamic
               schemaAlias: devtools.schemaAlias,
               isLeader: true,
+              origin: undefined,
             }),
             port: devtools.port,
             host: devtools.host,

package/src/make-leader-worker.ts

@@ -8,24 +8,13 @@ if (process.execArgv.includes('--inspect')) {
 }
 
 import type { SyncOptions } from '@livestore/common'
-import { UnexpectedError } from '@livestore/common'
+import { LogConfig, UnknownError } from '@livestore/common'
 import { Eventlog, LeaderThreadCtx } 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'
 import { sqliteDbFactory } from '@livestore/sqlite-wasm/node'
-import {
-  Effect,
-  FetchHttpClient,
-  identity,
-  Layer,
-  Logger,
-  LogLevel,
-  OtelTracer,
-  Schema,
-  Stream,
-  WorkerRunner,
-} from '@livestore/utils/effect'
+import { Effect, FetchHttpClient, Layer, OtelTracer, Schema, Stream, WorkerRunner } from '@livestore/utils/effect'
 import { PlatformNode } from '@livestore/utils/node'
 import type * as otel from '@opentelemetry/api'
 
@@ -36,21 +25,19 @@ import * as WorkerSchema from './worker-schema.ts'
 export type WorkerOptions = {
   schema: LiveStoreSchema
   sync?: SyncOptions
+  syncPayloadSchema?: Schema.Schema<any>
   otelOptions?: {
     tracer?: otel.Tracer
     /** @default 'livestore-node-leader-thread' */
     serviceName?: string
   }
   testing?: TestingOverrides
-}
+} & LogConfig.WithLoggerOptions
 
 export const getWorkerArgs = () => Schema.decodeSync(WorkerSchema.WorkerArgv)(process.argv[2]!)
 
 export const makeWorker = (options: WorkerOptions) => {
-  makeWorkerEffect(options).pipe(
-    Effect.provide(Logger.prettyWithThread(options.otelOptions?.serviceName ?? 'livestore-node-leader-thread')),
-    PlatformNode.NodeRuntime.runMain,
-  )
+  makeWorkerEffect(options).pipe(PlatformNode.NodeRuntime.runMain)
 }
 
 export const makeWorkerEffect = (options: WorkerOptions) => {
@@ -60,6 +47,13 @@ export const makeWorkerEffect = (options: WorkerOptions) => {
       )
     : undefined
 
+  // Merge the runtime dependencies once so we can provide them together without chaining Effect.provide.
+  const runtimeLayer = Layer.mergeAll(
+    FetchHttpClient.layer,
+    PlatformNode.NodeFileSystem.layer,
+    TracingLive ?? Layer.empty,
+  )
+
   return WorkerRunner.layerSerialized(WorkerSchema.LeaderWorkerInnerRequest, {
     InitialMessage: (args) =>
       Effect.gen(function* () {
@@ -73,12 +67,14 @@ export const makeWorkerEffect = (options: WorkerOptions) => {
           schema: options.schema,
           testing: options.testing,
           makeSqliteDb,
+          syncPayloadEncoded: args.syncPayloadEncoded,
+          syncPayloadSchema: options.syncPayloadSchema,
         })
       }).pipe(Layer.unwrapScoped),
     PushToLeader: ({ batch }) =>
       Effect.andThen(LeaderThreadCtx, (_) =>
         _.syncProcessor.push(
-          batch.map((item) => new LiveStoreEvent.EncodedWithMeta(item)),
+          batch.map((item) => new LiveStoreEvent.Client.EncodedWithMeta(item)),
           // We'll wait in order to keep back pressure on the client session
           { waitForProcessing: true },
         ),
@@ -92,27 +88,39 @@ export const makeWorkerEffect = (options: WorkerOptions) => {
       }).pipe(Stream.unwrapScoped),
     Export: () =>
       Effect.andThen(LeaderThreadCtx, (_) => _.dbState.export()).pipe(
-        UnexpectedError.mapToUnexpectedError,
+        UnknownError.mapToUnknownError,
         Effect.withSpan('@livestore/adapter-node:worker:Export'),
       ),
     ExportEventlog: () =>
       Effect.andThen(LeaderThreadCtx, (_) => _.dbEventlog.export()).pipe(
-        UnexpectedError.mapToUnexpectedError,
+        UnknownError.mapToUnknownError,
         Effect.withSpan('@livestore/adapter-node:worker:ExportEventlog'),
       ),
     GetLeaderHead: () =>
       Effect.gen(function* () {
         const workerCtx = yield* LeaderThreadCtx
         return Eventlog.getClientHeadFromDb(workerCtx.dbEventlog)
-      }).pipe(UnexpectedError.mapToUnexpectedError, Effect.withSpan('@livestore/adapter-node:worker:GetLeaderHead')),
+      }).pipe(UnknownError.mapToUnknownError, Effect.withSpan('@livestore/adapter-node:worker:GetLeaderHead')),
     GetLeaderSyncState: () =>
       Effect.gen(function* () {
         const workerCtx = yield* LeaderThreadCtx
         return yield* workerCtx.syncProcessor.syncState
-      }).pipe(
-        UnexpectedError.mapToUnexpectedError,
-        Effect.withSpan('@livestore/adapter-node:worker:GetLeaderSyncState'),
-      ),
+      }).pipe(UnknownError.mapToUnknownError, Effect.withSpan('@livestore/adapter-node:worker:GetLeaderSyncState')),
+    SyncStateStream: () =>
+      Effect.gen(function* () {
+        const workerCtx = yield* LeaderThreadCtx
+        return workerCtx.syncProcessor.syncState.changes
+      }).pipe(Stream.unwrapScoped),
+    GetNetworkStatus: () =>
+      Effect.gen(function* () {
+        const workerCtx = yield* LeaderThreadCtx
+        return yield* workerCtx.networkStatus
+      }).pipe(UnknownError.mapToUnknownError, Effect.withSpan('@livestore/adapter-node:worker:GetNetworkStatus')),
+    NetworkStatusStream: () =>
+      Effect.gen(function* () {
+        const workerCtx = yield* LeaderThreadCtx
+        return workerCtx.networkStatus.changes
+      }).pipe(Stream.unwrapScoped),
     GetRecreateSnapshot: () =>
       Effect.gen(function* () {
         const workerCtx = yield* LeaderThreadCtx
@@ -123,11 +131,9 @@ export const makeWorkerEffect = (options: WorkerOptions) => {
         // return cachedSnapshot ?? workerCtx.db.export()
         const snapshot = workerCtx.dbState.export()
         return { snapshot, migrationsReport: workerCtx.initialState.migrationsReport }
-      }).pipe(
-        UnexpectedError.mapToUnexpectedError,
-        Effect.withSpan('@livestore/adapter-node:worker:GetRecreateSnapshot'),
-      ),
+      }).pipe(UnknownError.mapToUnknownError, Effect.withSpan('@livestore/adapter-node:worker:GetRecreateSnapshot')),
     Shutdown: () =>
+      // @effect-diagnostics-next-line unnecessaryEffectGen:off
       Effect.gen(function* () {
         // const { db, dbEventlog } = yield* LeaderThreadCtx
         yield* Effect.logDebug('[@livestore/adapter-node:worker] Shutdown')
@@ -141,10 +147,10 @@ export const makeWorkerEffect = (options: WorkerOptions) => {
         // 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')),
+      }).pipe(UnknownError.mapToUnknownError, Effect.withSpan('@livestore/adapter-node:worker:Shutdown')),
     ExtraDevtoolsMessage: ({ message }) =>
       Effect.andThen(LeaderThreadCtx, (_) => _.extraIncomingMessagesQueue.offer(message)).pipe(
-        UnexpectedError.mapToUnexpectedError,
+        UnknownError.mapToUnknownError,
         Effect.withSpan('@livestore/adapter-node:worker:ExtraDevtoolsMessage'),
       ),
   }).pipe(
@@ -156,12 +162,13 @@ export const makeWorkerEffect = (options: WorkerOptions) => {
       thread: options.otelOptions?.serviceName ?? 'livestore-node-leader-thread',
       processId: process.pid,
     }),
+    LogConfig.withLoggerConfig(
+      { logger: options.logger, logLevel: options.logLevel },
+      { threadName: 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,
-    Logger.withMinimumLogLevel(LogLevel.Debug),
+    Effect.provide(runtimeLayer),
   )
 }