@livestore/adapter-node 0.4.0-dev.21 → 0.4.0-dev.23

package/src/client-session/adapter.ts

@@ -1,15 +1,17 @@
 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,
   ClientSessionLeaderThreadProxy,
   IntentionalShutdownCause,
+  isWorkerTransportError,
   type LockStatus,
   type MakeSqliteDb,
   makeClientSession,
-  type SyncError,
   type SyncOptions,
   UnknownError,
 } from '@livestore/common'
@@ -27,7 +29,7 @@ import {
   Fiber,
   FileSystem,
   Layer,
-  ParseResult,
+  Option,
   Queue,
   Schedule,
   Schema,
@@ -35,7 +37,6 @@ import {
   Subscribable,
   SubscriptionRef,
   Worker,
-  WorkerError,
 } from '@livestore/utils/effect'
 import { PlatformNode } from '@livestore/utils/node'
 import * as Webmesh from '@livestore/webmesh'
@@ -232,7 +233,7 @@ const makeAdapterImpl = ({
       yield* shutdownChannel.listen.pipe(
         Stream.flatten(),
         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,
@@ -246,7 +247,7 @@ const makeAdapterImpl = ({
       const lockStatus = yield* SubscriptionRef.make<LockStatus>('has-lock')
 
       const devtoolsOptions: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools'] =
-        devtoolsEnabled && devtoolsOptionsInput !== undefined
+        devtoolsEnabled === true && devtoolsOptionsInput !== undefined
           ? {
               enabled: true,
               schemaPath:
@@ -297,7 +298,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}`,
@@ -413,7 +414,11 @@ const makeLocalLeaderThread = ({
                 options,
               }),
           },
-          initialState: { leaderHead: initialLeaderHead, migrationsReport: initialState.migrationsReport },
+          initialState: {
+            leaderHead: initialLeaderHead,
+            migrationsReport: initialState.migrationsReport,
+            storageMode: 'persisted',
+          },
           export: Effect.sync(() => dbState.export()),
           getEventlogData: Effect.sync(() => dbEventlog.export()),
           syncState: syncProcessor.syncState,
@@ -442,7 +447,7 @@ const makeWorkerLeaderThread = ({
   syncPayloadEncoded,
   testing,
 }: {
-  shutdown: (cause: Exit.Exit<IntentionalShutdownCause, UnknownError | SyncError>) => Effect.Effect<void>
+  shutdown: (cause: Exit.Exit<IntentionalShutdownCause, UnknownError>) => Effect.Effect<void>
   storeId: string
   clientId: string
   sessionId: string
@@ -458,8 +463,8 @@ 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, extraArgs: workerExtraArgs })],
+      execArgv: process.env.DEBUG_WORKER !== undefined ? ['--inspect --enable-source-maps'] : ['--enable-source-maps'],
+      argv: [yield* Schema.encode(WorkerSchema.WorkerArgv)({ storeId, clientId, sessionId, extraArgs: workerExtraArgs }).pipe(Effect.orDie)],
     })
     const nodeWorkerLayer = yield* Layer.build(PlatformNode.NodeWorker.layer(() => nodeWorker))
 
@@ -481,47 +486,30 @@ const makeWorkerLeaderThread = ({
       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, UnknownError, R>
-      : never =>
-      (worker.executeEffect(req) as any).pipe(
+    const runInWorker = <A, I, E, EI, R>(
+      req: WorkerSchema.LeaderWorkerInnerRequest & Schema.WithResult<A, I, E, EI, R>,
+    ): Effect.Effect<A, E, R> =>
+      worker.executeEffect(req).pipe(
+        Effect.catchIf(isWorkerTransportError, (e) => Effect.die(e)),
         Effect.logWarnIfTakesLongerThan({
           label: `@livestore/adapter-node:client-session:runInWorker:${req._tag}`,
           duration: 2000,
         }),
         Effect.withSpan(`@livestore/adapter-node:client-session:runInWorker:${req._tag}`),
-        Effect.mapError((cause) =>
-          Schema.is(UnknownError)(cause)
-            ? cause
-            : ParseResult.isParseError(cause) || Schema.is(WorkerError.WorkerError)(cause)
-              ? new UnknownError({ cause })
-              : 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, UnknownError, R>
-      : never =>
-      worker.execute(req as any).pipe(
-        Stream.mapError((cause) =>
-          Schema.is(UnknownError)(cause)
-            ? cause
-            : ParseResult.isParseError(cause) || Schema.is(WorkerError.WorkerError)(cause)
-              ? new UnknownError({ cause })
-              : cause,
-        ),
+      )
+
+    const runInWorkerStream = <A, I, E, EI, R>(
+      req: WorkerSchema.LeaderWorkerInnerRequest & Schema.WithResult<A, I, E, EI, R>,
+    ): Stream.Stream<A, E, R> =>
+      worker.execute(req).pipe(
+        Stream.refineOrDie((e) => isWorkerTransportError(e) === true ? Option.none() : Option.some(e)),
         Stream.withSpan(`@livestore/adapter-node:client-session:runInWorkerStream:${req._tag}`),
-      ) as any
+      )
 
     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(Exit.failCause(cause)))),
+      Effect.tapErrorCause((cause) => (Cause.isInterruptedOnly(cause) === true ? Effect.void : shutdown(Exit.failCause(cause)))),
       Effect.interruptible,
       Effect.tapCauseLogPretty,
       Effect.forkScoped,
@@ -536,8 +524,7 @@ const makeWorkerLeaderThread = ({
     const initialLeaderHead = yield* runInWorker(new WorkerSchema.LeaderWorkerInnerGetLeaderHead())
 
     const bootResult = yield* runInWorker(new WorkerSchema.LeaderWorkerInnerGetRecreateSnapshot()).pipe(
-      Effect.timeout(10_000),
-      UnknownError.mapToUnknownError,
+      Effect.timeoutOrDie(10_000),
       Effect.withSpan('@livestore/adapter-node:client-session:export'),
     )
 
@@ -561,23 +548,21 @@ const makeWorkerLeaderThread = ({
         initialState: {
           leaderHead: initialLeaderHead,
           migrationsReport: bootResult.migrationsReport,
+          storageMode: 'persisted',
         },
         export: runInWorker(new WorkerSchema.LeaderWorkerInnerExport()).pipe(
-          Effect.timeout(10_000),
-          UnknownError.mapToUnknownError,
+          Effect.timeoutOrDie(10_000),
           Effect.withSpan('@livestore/adapter-node:client-session:export'),
         ),
         getEventlogData: Effect.dieMessage('Not implemented'),
         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(
-            UnknownError.mapToUnknownError,
             Effect.withSpan('@livestore/adapter-node:client-session:devtoolsMessageForLeader'),
           ),
         networkStatus: Subscribable.make({

package/src/devtools/devtools-server.ts

@@ -20,6 +20,16 @@ import { makeMeshNode, makeWebSocketEdge } from '@livestore/webmesh'
 
 import { makeViteMiddleware } from './vite-dev-server.ts'
 
+/**
+ * Determines if a request URL should be routed to the Vite middleware.
+ * Includes LiveStore devtools paths and Vite internal paths like `/@fs/`, `/@vite/`, etc.
+ */
+const shouldRouteToVite = (url: string): boolean =>
+  url.startsWith('/_livestore') ||
+  url.startsWith('/@fs') ||
+  url.startsWith('/@vite') ||
+  url.startsWith('/@react-refresh')
+
 /**
  * Starts a devtools HTTP/WS server which serves ...
  * - the Devtools UI via Vite
@@ -39,11 +49,12 @@ export const startDevtoolsServer = ({
   Effect.gen(function* () {
     const viteMiddleware = yield* makeViteMiddleware({
       mode: { _tag: 'node', url: `http://${host}:${port}` },
-      schemaPath: isReadonlyArray(schemaPath)
-        ? schemaPath.map((schemaPath) => path.resolve(process.cwd(), schemaPath))
-        : path.resolve(process.cwd(), schemaPath),
+      schemaPath:
+        isReadonlyArray(schemaPath) === true
+          ? schemaPath.map((schemaPath) => path.resolve(process.cwd(), schemaPath))
+          : path.resolve(process.cwd(), schemaPath),
       viteConfig: (viteConfig) => {
-        if (LS_DEV) {
+        if (LS_DEV === true) {
           viteConfig.server ??= {}
           viteConfig.server.fs ??= {}
           viteConfig.server.fs.strict = false
@@ -63,7 +74,7 @@ export const startDevtoolsServer = ({
     const handler = Effect.gen(function* () {
       const req = yield* HttpServerRequest.HttpServerRequest
 
-      if (Headers.has(req.headers, 'upgrade')) {
+      if (Headers.has(req.headers, 'upgrade') === true) {
         // yield* Effect.logDebug(`WS Relay ${relayNodeName}: WS upgrade request ${req.url}`)
 
         const socket = yield* req.upgrade
@@ -81,7 +92,7 @@ export const startDevtoolsServer = ({
               .addEdge({ target: from, edgeChannel: webChannel, replaceIfExists: true })
               .pipe(Effect.acquireRelease(() => node.removeEdge(from).pipe(Effect.orDie)))
 
-            if (LS_DEV) {
+            if (LS_DEV === true) {
               yield* Effect.log(`WS Relay ${relayNodeName}: added edge from '${from}'`)
               yield* Effect.addFinalizerLog(`WS Relay ${relayNodeName}: removed edge from '${from}'`)
             }
@@ -96,7 +107,7 @@ export const startDevtoolsServer = ({
       } else {
         if (req.url === '/' || req.url === '') {
           return HttpServerResponse.redirect('/_livestore/node')
-        } else if (req.url.startsWith('/_livestore')) {
+        } else if (shouldRouteToVite(req.url) === true) {
           // Here we're delegating to the Vite middleware
 
           // TODO replace this once @effect/platform-node supports Node HTTP middlewares
@@ -114,9 +125,10 @@ export const startDevtoolsServer = ({
       return HttpServerResponse.text('Not found')
     }).pipe(Effect.tapCauseLogPretty, Effect.interruptible)
 
-    const sessionSuffix = clientSessionInfo
-      ? `/${clientSessionInfo.storeId}/${clientSessionInfo.clientId}/${clientSessionInfo.sessionId}/${clientSessionInfo.schemaAlias}`
-      : '?autoconnect'
+    const sessionSuffix =
+      clientSessionInfo !== undefined
+        ? `/${clientSessionInfo.storeId}/${clientSessionInfo.clientId}/${clientSessionInfo.sessionId}/${clientSessionInfo.schemaAlias}`
+        : '?autoconnect'
 
     // Use `localhost` instead of `0.0.0.0` as it doesn't have the `navigator.locks` web adapter limitation (https://share.cleanshot.com/nHBnmk6S)
     const maybeLocalhost = host === '0.0.0.0' ? 'localhost' : host

package/src/devtools/mod.ts

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

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

@@ -1,12 +1,44 @@
 import path from 'node:path'
 
+import type * as Vite from 'vite'
+
 import type { Devtools } 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'
+import { Effect, Schema } from '@livestore/utils/effect'
 import { getFreePort } from '@livestore/utils/node'
-import * as Vite from 'vite'
+
+/**
+ * Error thrown when @livestore/devtools-vite is not installed.
+ * This is a peer dependency that must be installed separately.
+ */
+export class DevtoolsViteNotInstalledError extends Schema.TaggedError<DevtoolsViteNotInstalledError>(
+  '~@livestore/adapter-node/DevtoolsViteNotInstalledError',
+)('DevtoolsViteNotInstalledError', {
+  cause: Schema.Defect,
+}) {
+  override get message(): string {
+    return (
+      `@livestore/devtools-vite is required for devtools but not installed. ` +
+      `Install it with: pnpm add @livestore/devtools-vite@<version>. ` +
+      `Make sure to use the same version as @livestore/adapter-node.`
+    )
+  }
+}
+
+/** Error thrown when vite is not installed for the devtools server path. */
+export class ViteNotInstalledError extends Schema.TaggedError<ViteNotInstalledError>(
+  '~@livestore/adapter-node/ViteNotInstalledError',
+)('ViteNotInstalledError', {
+  cause: Schema.Defect,
+}) {
+  override get message(): string {
+    return (
+      `vite is required for @livestore/adapter-node/devtools but not installed. ` +
+      `Install it with: pnpm add -D vite@<version>.`
+    )
+  }
+}
 
 export type ViteDevtoolsOptions = {
   viteConfig?: (config: Vite.UserConfig) => Vite.UserConfig
@@ -26,8 +58,13 @@ export type ViteDevtoolsOptions = {
 }
 
 // NOTE this is currently also used in @livestore/devtools-expo
-export const makeViteMiddleware = (options: ViteDevtoolsOptions): Effect.Effect<Vite.ViteDevServer, UnknownError> =>
+export const makeViteMiddleware = (
+  options: ViteDevtoolsOptions,
+): Effect.Effect<Vite.ViteDevServer, DevtoolsViteNotInstalledError | ViteNotInstalledError | UnknownError> =>
   Effect.gen(function* () {
+    const { livestoreDevtoolsPlugin } = yield* importDevtoolsVite()
+    const Vite = yield* importVite()
+
     const cwd = process.cwd()
 
     const hmrPort = yield* getFreePort.pipe(UnknownError.mapToUnknownError)
@@ -39,13 +76,13 @@ export const makeViteMiddleware = (options: ViteDevtoolsOptions): Effect.Effect<
           port: hmrPort,
         },
         // Relaxing fs access for monorepo setup
-        fs: { strict: process.env.LS_DEV ? false : true },
+        fs: { strict: process.env.LS_DEV !== undefined ? false : true },
       },
       appType: 'spa',
       base: '/_livestore/',
       plugins: [
         livestoreDevtoolsPlugin({
-          schemaPath: isReadonlyArray(options.schemaPath)
+          schemaPath: isReadonlyArray(options.schemaPath) === true
             ? options.schemaPath.map((schemaPath) => path.resolve(cwd, schemaPath))
             : path.resolve(cwd, options.schemaPath),
           mode: options.mode,
@@ -62,3 +99,20 @@ export const makeViteMiddleware = (options: ViteDevtoolsOptions): Effect.Effect<
 
     return viteServer
   }).pipe(Effect.withSpan('@livestore/adapter-node:devtools:makeViteServer'))
+
+/**
+ * Dynamically imports @livestore/devtools-vite.
+ * This package is a peer dependency and may not be installed.
+ */
+const importDevtoolsVite = () =>
+  Effect.tryPromise({
+    try: () => import('@livestore/devtools-vite'),
+    catch: (cause) => new DevtoolsViteNotInstalledError({ cause }),
+  })
+
+/** Dynamically imports vite for the devtools-only server path. */
+const importVite = () =>
+  Effect.tryPromise({
+    try: () => import('vite'),
+    catch: (cause) => new ViteNotInstalledError({ cause }),
+  })

package/src/leader-thread-shared.ts

@@ -1,7 +1,7 @@
 import inspector from 'node:inspector'
 import path from 'node:path'
 
-if (process.execArgv.includes('--inspect')) {
+if (process.execArgv.includes('--inspect') === true) {
   inspector.open()
   inspector.waitForDebugger()
 }
@@ -64,13 +64,13 @@ export const makeLeaderThread = ({
   Scope.Scope
 > =>
   Effect.gen(function* () {
-    const runtime = yield* Effect.runtime<never>()
+    const runtime = yield* Effect.runtime()
 
     const schemaHashSuffix =
       schema.state.sqlite.migrations.strategy === 'manual' ? 'fixed' : schema.state.sqlite.hash.toString()
 
     const makeDb = (kind: 'state' | 'eventlog') => {
-      if (testing?.makeLeaderThread) {
+      if (testing?.makeLeaderThread !== undefined) {
         return testing
           .makeLeaderThread(makeSqliteDb)
           .pipe(Effect.map(({ dbEventlog, dbState }) => (kind === 'state' ? dbState : dbEventlog)))
@@ -184,7 +184,7 @@ const makeDevtoolsOptions = ({
           eventlog: dbEventlog.metadata.persistenceInfo,
         }
 
-        return { node, persistenceInfo, mode: 'proxy' }
+        return { node, persistenceInfo, mode: 'proxy' as const }
       }),
     }
   })

package/src/make-leader-worker.ts

@@ -1,12 +1,13 @@
 import './thread-polyfill.ts'
-
 import inspector from 'node:inspector'
 
-if (process.execArgv.includes('--inspect')) {
+if (process.execArgv.includes('--inspect') === true) {
   inspector.open()
   inspector.waitForDebugger()
 }
 
+import type * as otel from '@opentelemetry/api'
+
 import type { SyncOptions } from '@livestore/common'
 import { LogConfig, UnknownError } from '@livestore/common'
 import type { StreamEventsOptions } from '@livestore/common/leader-thread'
@@ -17,7 +18,6 @@ import { loadSqlite3Wasm } from '@livestore/sqlite-wasm/load-wasm'
 import { sqliteDbFactory } from '@livestore/sqlite-wasm/node'
 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'
 
 import type { TestingOverrides } from './leader-thread-shared.ts'
 import { makeLeaderThread } from './leader-thread-shared.ts'
@@ -42,7 +42,7 @@ export const makeWorker = (options: WorkerOptions) => {
 }
 
 export const makeWorkerEffect = (options: WorkerOptions) => {
-  const TracingLive = options.otelOptions?.tracer
+  const TracingLive = options.otelOptions?.tracer !== undefined
     ? Layer.unwrapEffect(Effect.map(OtelTracer.make, Layer.setTracer)).pipe(
         Layer.provideMerge(Layer.succeed(OtelTracer.OtelTracer, options.otelOptions.tracer)),
       )
@@ -103,69 +103,60 @@ export const makeWorkerEffect = (options: WorkerOptions) => {
       ),
     Export: () =>
       Effect.andThen(LeaderThreadCtx, (_) => _.dbState.export()).pipe(
-        UnknownError.mapToUnknownError,
         Effect.withSpan('@livestore/adapter-node:worker:Export'),
       ),
     ExportEventlog: () =>
       Effect.andThen(LeaderThreadCtx, (_) => _.dbEventlog.export()).pipe(
-        UnknownError.mapToUnknownError,
         Effect.withSpan('@livestore/adapter-node:worker:ExportEventlog'),
       ),
-    GetLeaderHead: () =>
-      Effect.gen(function* () {
-        const workerCtx = yield* LeaderThreadCtx
-        return Eventlog.getClientHeadFromDb(workerCtx.dbEventlog)
-      }).pipe(UnknownError.mapToUnknownError, Effect.withSpan('@livestore/adapter-node:worker:GetLeaderHead')),
-    GetLeaderSyncState: () =>
-      Effect.gen(function* () {
-        const workerCtx = yield* LeaderThreadCtx
-        return yield* workerCtx.syncProcessor.syncState
-      }).pipe(UnknownError.mapToUnknownError, Effect.withSpan('@livestore/adapter-node:worker:GetLeaderSyncState')),
+    GetLeaderHead: Effect.fn('@livestore/adapter-node:worker:GetLeaderHead')(function* () {
+      const workerCtx = yield* LeaderThreadCtx
+      return Eventlog.getClientHeadFromDb(workerCtx.dbEventlog)
+    }),
+    GetLeaderSyncState: Effect.fn('@livestore/adapter-node:worker:GetLeaderSyncState')(function* () {
+      const workerCtx = yield* LeaderThreadCtx
+      return yield* workerCtx.syncProcessor.syncState
+    }),
     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')),
+    GetNetworkStatus: Effect.fn('@livestore/adapter-node:worker:GetNetworkStatus')(function* () {
+      const workerCtx = yield* LeaderThreadCtx
+      return yield* workerCtx.networkStatus
+    }),
     NetworkStatusStream: () =>
       Effect.gen(function* () {
         const workerCtx = yield* LeaderThreadCtx
         return workerCtx.networkStatus.changes
       }).pipe(Stream.unwrapScoped),
-    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.dbState.export()
-        return { snapshot, migrationsReport: workerCtx.initialState.migrationsReport }
-      }).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')
+    GetRecreateSnapshot: Effect.fn('@livestore/adapter-node:worker:GetRecreateSnapshot')(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.dbState.export()
+      return { snapshot, migrationsReport: workerCtx.initialState.migrationsReport }
+    }),
+    Shutdown: Effect.fn('@livestore/adapter-node:worker:Shutdown')(function* () {
+      // const { db, dbEventlog } = yield* LeaderThreadCtx
+      yield* Effect.logDebug('[@livestore/adapter-node:worker] Shutdown')
 
-        // if (devtools.enabled) {
-        //   yield* FiberSet.clear(devtools.connections)
-        // }
-        // db.close()
-        // dbEventlog.close()
+      // if (devtools.enabled) {
+      //   yield* FiberSet.clear(devtools.connections)
+      // }
+      // db.close()
+      // dbEventlog.close()
 
-        // Buy some time for Otel to flush
-        // TODO find a cleaner way to do this
-        // yield* Effect.sleep(1000)
-      }).pipe(UnknownError.mapToUnknownError, Effect.withSpan('@livestore/adapter-node:worker:Shutdown')),
+      // Buy some time for Otel to flush
+      // TODO find a cleaner way to do this
+      // yield* Effect.sleep(1000)
+    }),
     ExtraDevtoolsMessage: ({ message }) =>
       Effect.andThen(LeaderThreadCtx, (_) => _.extraIncomingMessagesQueue.offer(message)).pipe(
-        UnknownError.mapToUnknownError,
         Effect.withSpan('@livestore/adapter-node:worker:ExtraDevtoolsMessage'),
       ),
   }).pipe(

package/src/shutdown-channel.ts

@@ -1,5 +1,6 @@
 import { ShutdownChannel } from '@livestore/common/leader-thread'
 import type { Effect, Scope } from '@livestore/utils/effect'
+
 import { makeBroadcastChannel } from './webchannel.ts'
 
 export const makeShutdownChannel = (