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

package/src/client-session/adapter.ts

@@ -8,7 +8,6 @@ import {
   type BootStatus,
   ClientSessionLeaderThreadProxy,
   IntentionalShutdownCause,
-  isWorkerTransportError,
   type LockStatus,
   type MakeSqliteDb,
   makeClientSession,
@@ -29,20 +28,22 @@ import {
   Fiber,
   FileSystem,
   Layer,
-  Option,
   Queue,
+  RpcClient,
+  RpcWorker,
   Schedule,
   Schema,
+  Scope,
   Stream,
   Subscribable,
   SubscriptionRef,
-  Worker,
 } 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'
 
@@ -178,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 = ({
@@ -199,7 +200,7 @@ const makeAdapterImpl = ({
     | {
         _tag: 'multi-threaded'
         workerUrl: URL
-        workerExtraArgs: Schema.JsonValue | undefined
+        workerExtraArgs: Schema.Json | undefined
       }
 }): Adapter =>
   ((adapterArgs) =>
@@ -231,7 +232,7 @@ const makeAdapterImpl = ({
       }
 
       yield* shutdownChannel.listen.pipe(
-        Stream.flatten(),
+        Stream.mapEffect(Effect.fromResult),
         Stream.tap((cause) =>
           shutdown(cause._tag === 'IntentionalShutdownCause' ? Exit.succeed(cause) : Exit.fail(cause)),
         ),
@@ -246,7 +247,7 @@ const makeAdapterImpl = ({
       // TODO actually implement this multi-session support
       const lockStatus = yield* SubscriptionRef.make<LockStatus>('has-lock')
 
-      const devtoolsOptions: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools'] =
+      const devtoolsOptions: WorkerSchema.LeaderWorkerInnerInitialMessagePayload['devtools'] =
         devtoolsEnabled === true && devtoolsOptionsInput !== undefined
           ? {
               enabled: true,
@@ -288,7 +289,7 @@ const makeAdapterImpl = ({
               devtools: devtoolsOptions,
               bootStatusQueue,
               syncPayloadEncoded,
-            })
+            }).pipe(UnknownError.mapToUnknownError)
 
       syncInMemoryDb.import(initialSnapshot)
       syncInMemoryDb.debug.head = leaderThread.initialState.leaderHead
@@ -369,28 +370,42 @@ const makeLocalLeaderThread = ({
   makeSqliteDb: MakeSqliteDb
   syncOptions: SyncOptions | undefined
   storage: WorkerSchema.StorageType
-  syncPayloadEncoded: Schema.JsonValue | undefined
+  syncPayloadEncoded: Schema.Json | undefined
   syncPayloadSchema: Schema.Schema<any>
-  devtools: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools']
+  devtools: WorkerSchema.LeaderWorkerInnerInitialMessagePayload['devtools']
   testing?: {
     overrides?: TestingOverrides
   }
 }) =>
   Effect.gen(function* () {
-    const layer = yield* Layer.build(
-      makeLeaderThread({
-        storeId,
-        clientId,
-        schema,
-        syncOptions,
-        storage,
-        syncPayloadEncoded,
-        syncPayloadSchema,
-        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, networkStatus } =
@@ -403,10 +418,13 @@ const makeLocalLeaderThread = ({
           events: {
             pull: ({ cursor }) => syncProcessor.pull({ cursor }),
             push: (batch) =>
-              syncProcessor.push(
-                batch.map((item) => new LiveStoreEvent.Client.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,
@@ -422,7 +440,7 @@ const makeLocalLeaderThread = ({
           export: Effect.sync(() => dbState.export()),
           getEventlogData: Effect.sync(() => dbEventlog.export()),
           syncState: syncProcessor.syncState,
-          sendDevtoolsMessage: (message) => extraIncomingMessagesQueue.offer(message),
+          sendDevtoolsMessage: (message) => Queue.offer(extraIncomingMessagesQueue, message),
           networkStatus,
         },
         { ...omitUndefineds({ overrides: testing?.overrides?.clientSession?.leaderThreadProxy }) },
@@ -452,11 +470,11 @@ const makeWorkerLeaderThread = ({
   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>
-  syncPayloadEncoded: Schema.JsonValue | undefined
+  syncPayloadEncoded: Schema.Json | undefined
   testing?: {
     overrides?: TestingOverrides
   }
@@ -464,66 +482,76 @@ const makeWorkerLeaderThread = ({
   Effect.gen(function* () {
     const nodeWorker = new WT.Worker(workerUrl, {
       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))
-
-    const worker = yield* Worker.makePoolSerialized<typeof WorkerSchema.LeaderWorkerInnerRequest.Type>({
-      size: 1,
-      concurrency: 100,
-      initialMessage: () =>
-        new WorkerSchema.LeaderWorkerInnerInitialMessage({
+      argv: [
+        yield* Schema.encodeEffect(WorkerSchema.WorkerArgv)({
           storeId,
           clientId,
-          storage,
-          devtools,
-          syncPayloadEncoded,
-        }),
-    }).pipe(
-      Effect.provide(nodeWorkerLayer),
+          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.tapErrorCause((cause) => shutdown(Exit.failCause(cause))),
+      Effect.tapCause((cause) => shutdown(Exit.failCause(cause))),
       Effect.withSpan('@livestore/adapter-node:adapter:setupLeaderThread'),
     )
 
-    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)),
+    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.withSpan(`@livestore/adapter-node:client-session:runInWorker:${tag}`),
       )
 
-    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}`),
+    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(new WorkerSchema.LeaderWorkerInnerBootStatusStream()).pipe(
+    const bootStatusFiber = yield* runInWorkerStream('BootStatusStream', worker.BootStatusStream({})).pipe(
       Stream.tap((bootStatus) => Queue.offer(bootStatusQueue, bootStatus)),
       Stream.runDrain,
-      Effect.tapErrorCause((cause) => (Cause.isInterruptedOnly(cause) === true ? 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(
+    const bootResult = yield* runInWorker('GetRecreateSnapshot', worker.GetRecreateSnapshot({})).pipe(
       Effect.timeoutOrDie(10_000),
       Effect.withSpan('@livestore/adapter-node:client-session:export'),
     )
@@ -531,16 +559,15 @@ const makeWorkerLeaderThread = ({
     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(new WorkerSchema.LeaderWorkerInnerStreamEvents(options)).pipe(
+            runInWorkerStream('StreamEvents', worker.StreamEvents(options)).pipe(
               Stream.withSpan('@livestore/adapter-node:client-session:streamEvents'),
               Stream.orDie,
             ),
@@ -550,24 +577,24 @@ const makeWorkerLeaderThread = ({
           migrationsReport: bootResult.migrationsReport,
           storageMode: 'persisted',
         },
-        export: runInWorker(new WorkerSchema.LeaderWorkerInnerExport()).pipe(
+        export: runInWorker('Export', worker.Export({})).pipe(
           Effect.timeoutOrDie(10_000),
           Effect.withSpan('@livestore/adapter-node:client-session:export'),
         ),
-        getEventlogData: Effect.dieMessage('Not implemented'),
+        getEventlogData: Effect.die('Not implemented'),
         syncState: Subscribable.make({
-          get: runInWorker(new WorkerSchema.LeaderWorkerInnerGetLeaderSyncState()).pipe(
+          get: runInWorker('GetLeaderSyncState', worker.GetLeaderSyncState({})).pipe(
             Effect.withSpan('@livestore/adapter-node:client-session:getLeaderSyncState'),
           ),
-          changes: runInWorkerStream(new WorkerSchema.LeaderWorkerInnerSyncStateStream()).pipe(Stream.orDie),
+          changes: runInWorkerStream('SyncStateStream', worker.SyncStateStream({})).pipe(Stream.orDie),
         }),
         sendDevtoolsMessage: (message) =>
-          runInWorker(new WorkerSchema.LeaderWorkerInnerExtraDevtoolsMessage({ message })).pipe(
+          runInWorker('ExtraDevtoolsMessage', worker.ExtraDevtoolsMessage({ message })).pipe(
             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),
+          get: runInWorker('GetNetworkStatus', worker.GetNetworkStatus({})).pipe(Effect.orDie),
+          changes: runInWorkerStream('NetworkStatusStream', worker.NetworkStatusStream({})).pipe(Stream.orDie),
         }),
       },
       {

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 { isReadonlyArray, LS_DEV } from '@livestore/utils'
+import { LS_DEV } from '@livestore/utils'
 import type { HttpClient } from '@livestore/utils/effect'
 import {
   Deferred,
@@ -47,25 +47,28 @@ export const startDevtoolsServer = ({
   port: number
 }): Effect.Effect<never, never, HttpClient.HttpClient> =>
   Effect.gen(function* () {
-    const viteMiddleware = yield* makeViteMiddleware({
-      mode: { _tag: 'node', url: `http://${host}:${port}` },
-      schemaPath:
-        isReadonlyArray(schemaPath) === true
-          ? schemaPath.map((schemaPath) => path.resolve(process.cwd(), schemaPath))
-          : path.resolve(process.cwd(), schemaPath),
-      viteConfig: (viteConfig) => {
-        if (LS_DEV === true) {
-          viteConfig.server ??= {}
-          viteConfig.server.fs ??= {}
-          viteConfig.server.fs.strict = false
-
-          viteConfig.optimizeDeps ??= {}
-          viteConfig.optimizeDeps.force = true
-        }
-
-        return viteConfig
-      },
-    }).pipe(Effect.acquireRelease((viteMiddleware) => Effect.promise(() => viteMiddleware.close())))
+    const viteMiddleware = yield* Effect.acquireRelease(
+      makeViteMiddleware({
+        mode: { _tag: 'node', url: `http://${host}:${port}` },
+        schemaPath:
+          typeof schemaPath === 'string'
+            ? path.resolve(process.cwd(), schemaPath)
+            : schemaPath.map((schemaPath) => path.resolve(process.cwd(), schemaPath)),
+        viteConfig: (viteConfig) => {
+          if (LS_DEV === true) {
+            viteConfig.server ??= {}
+            viteConfig.server.fs ??= {}
+            viteConfig.server.fs.strict = false
+
+            viteConfig.optimizeDeps ??= {}
+            viteConfig.optimizeDeps.force = true
+          }
+
+          return viteConfig
+        },
+      }),
+      (viteMiddleware) => Effect.promise(() => viteMiddleware.close()),
+    )
 
     const relayNodeName = 'ws'
 
@@ -88,9 +91,10 @@ export const startDevtoolsServer = ({
         // To handle websocket closing, we need to race the `webChannel.closedDeferred` to properly interrupt the handler
         yield* Effect.raceFirst(
           Effect.gen(function* () {
-            yield* node
-              .addEdge({ target: from, edgeChannel: webChannel, replaceIfExists: true })
-              .pipe(Effect.acquireRelease(() => node.removeEdge(from).pipe(Effect.orDie)))
+            yield* Effect.acquireRelease(
+              node.addEdge({ target: from, edgeChannel: webChannel, replaceIfExists: true }),
+              () => node.removeEdge(from).pipe(Effect.orDie),
+            )
 
             if (LS_DEV === true) {
               yield* Effect.log(`WS Relay ${relayNodeName}: added edge from '${from}'`)
@@ -100,7 +104,7 @@ export const startDevtoolsServer = ({
             // We want to keep the websocket open until the client disconnects or the server shuts down
             return yield* Effect.never
           }),
-          webChannel.closedDeferred,
+          Deferred.await(webChannel.closedDeferred),
         )
 
         return HttpServerResponse.empty({ status: 101 })
@@ -113,9 +117,9 @@ export const startDevtoolsServer = ({
           // TODO replace this once @effect/platform-node supports Node HTTP middlewares
           const nodeReq = PlatformNode.NodeHttpServerRequest.toIncomingMessage(req)
           const nodeRes = PlatformNode.NodeHttpServerRequest.toServerResponse(req)
-          const deferred = yield* Deferred.make()
-          viteMiddleware.middlewares(nodeReq, nodeRes, () => Deferred.unsafeDone(deferred, Exit.void))
-          yield* deferred
+          const deferred = yield* Deferred.make<void>()
+          viteMiddleware.middlewares(nodeReq, nodeRes, () => Deferred.doneUnsafe(deferred, Exit.void))
+          yield* Deferred.await(deferred)
 
           // The response is already sent, so we need to return an empty response (which won't be sent)
           return HttpServerResponse.empty()
@@ -123,7 +127,7 @@ export const startDevtoolsServer = ({
       }
 
       return HttpServerResponse.text('Not found')
-    }).pipe(Effect.tapCauseLogPretty, Effect.interruptible)
+    }).pipe(Effect.tapCauseLogPretty, Effect.interruptible, HttpMiddleware.withLoggerDisabled)
 
     const sessionSuffix =
       clientSessionInfo !== undefined
@@ -141,8 +145,7 @@ export const startDevtoolsServer = ({
     Effect.withSpan('@livestore/adapter-node:startDevtoolsServer', {
       attributes: { clientSessionInfo, port, host, schemaPath },
     }),
-    HttpMiddleware.withLoggerDisabled,
-    Layer.unwrapScoped,
+    Layer.unwrap,
     Layer.provide(PlatformNode.NodeHttpServer.layer(() => http.createServer(), { port, host })),
     Layer.launch,
     Effect.orDie,

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

@@ -1,12 +1,9 @@
 import path from 'node:path'
-
-import type * as Vite from 'vite'
-
 import type { Devtools } from '@livestore/common'
 import { UnknownError } from '@livestore/common'
-import { isReadonlyArray } from '@livestore/utils'
 import { Effect, Schema } from '@livestore/utils/effect'
 import { getFreePort } from '@livestore/utils/node'
+import type * as Vite from 'vite'
 
 /**
  * Error thrown when @livestore/devtools-vite is not installed.
@@ -15,7 +12,7 @@ import { getFreePort } from '@livestore/utils/node'
 export class DevtoolsViteNotInstalledError extends Schema.TaggedError<DevtoolsViteNotInstalledError>(
   '~@livestore/adapter-node/DevtoolsViteNotInstalledError',
 )('DevtoolsViteNotInstalledError', {
-  cause: Schema.Defect,
+  cause: Schema.Defect(),
 }) {
   override get message(): string {
     return (
@@ -30,7 +27,7 @@ export class DevtoolsViteNotInstalledError extends Schema.TaggedError<DevtoolsVi
 export class ViteNotInstalledError extends Schema.TaggedError<ViteNotInstalledError>(
   '~@livestore/adapter-node/ViteNotInstalledError',
 )('ViteNotInstalledError', {
-  cause: Schema.Defect,
+  cause: Schema.Defect(),
 }) {
   override get message(): string {
     return (
@@ -82,9 +79,10 @@ export const makeViteMiddleware = (
       base: '/_livestore/',
       plugins: [
         livestoreDevtoolsPlugin({
-          schemaPath: isReadonlyArray(options.schemaPath) === true
-            ? options.schemaPath.map((schemaPath) => path.resolve(cwd, schemaPath))
-            : path.resolve(cwd, options.schemaPath),
+          schemaPath:
+            typeof options.schemaPath === 'string'
+              ? path.resolve(cwd, options.schemaPath)
+              : options.schemaPath.map((schemaPath) => path.resolve(cwd, schemaPath)),
           mode: options.mode,
           path: '/',
         }),

package/src/leader-thread-shared.ts

@@ -7,13 +7,14 @@ if (process.execArgv.includes('--inspect') === true) {
 }
 
 import type { ClientSessionLeaderThreadProxy, MakeSqliteDb, SqliteDb, SyncOptions } from '@livestore/common'
-import { Devtools, liveStoreStorageFormatVersion, migrateDb, UnknownError } from '@livestore/common'
+import { Devtools, liveStoreStorageFormatVersion, migrateDb, StateHead, 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'
+import { getStateDbBaseName } from '@livestore/common/schema'
 import type { MakeNodeSqliteDb } from '@livestore/sqlite-wasm/node'
-import type { FileSystem, HttpClient, Layer, Schema, Scope } from '@livestore/utils/effect'
-import { Effect } from '@livestore/utils/effect'
+import type { FileSystem, HttpClient, Schema, Scope } from '@livestore/utils/effect'
+import { Effect, Layer } from '@livestore/utils/effect'
 import * as Webmesh from '@livestore/webmesh'
 
 import { makeShutdownChannel } from './shutdown-channel.ts'
@@ -40,9 +41,9 @@ export interface MakeLeaderThreadArgs {
   syncOptions: SyncOptions | undefined
   storage: WorkerSchema.StorageType
   makeSqliteDb: MakeNodeSqliteDb
-  devtools: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools']
+  devtools: WorkerSchema.LeaderWorkerInnerInitialMessagePayload['devtools']
   schema: LiveStoreSchema
-  syncPayloadEncoded: Schema.JsonValue | undefined
+  syncPayloadEncoded: Schema.Json | undefined
   syncPayloadSchema: Schema.Schema<any> | undefined
   testing: TestingOverrides | undefined
 }
@@ -64,10 +65,7 @@ export const makeLeaderThread = ({
   Scope.Scope
 > =>
   Effect.gen(function* () {
-    const runtime = yield* Effect.runtime()
-
-    const schemaHashSuffix =
-      schema.state.sqlite.migrations.strategy === 'manual' ? 'fixed' : schema.state.sqlite.hash.toString()
+    const services = yield* Effect.context()
 
     const makeDb = (kind: 'state' | 'eventlog') => {
       if (testing?.makeLeaderThread !== undefined) {
@@ -79,18 +77,21 @@ export const makeLeaderThread = ({
       return storage.type === 'in-memory'
         ? makeSqliteDb({
             _tag: 'in-memory',
-            configureDb: (db) =>
-              configureConnection(db, { foreignKeys: true }).pipe(Effect.provide(runtime), Effect.runSync),
+            configureDb: (db) => configureConnection(db, { foreignKeys: true }).pipe(Effect.runSyncWith(services)),
           })
-        : makeSqliteDb({
-            _tag: 'fs',
-            directory: path.join(storage.baseDirectory ?? '', storeId),
-            fileName:
-              kind === 'state' ? getStateDbFileName(schemaHashSuffix) : `eventlog@${liveStoreStorageFormatVersion}.db`,
-            // TODO enable WAL for nodejs
-            configureDb: (db) =>
-              configureConnection(db, { foreignKeys: true }).pipe(Effect.provide(runtime), Effect.runSync),
-          }).pipe(Effect.acquireRelease((db) => Effect.sync(() => db.close())))
+        : Effect.acquireRelease(
+            makeSqliteDb({
+              _tag: 'fs',
+              directory: path.join(storage.baseDirectory ?? '', storeId),
+              fileName:
+                kind === 'state'
+                  ? `${getStateDbBaseName(schema)}@${liveStoreStorageFormatVersion}.db`
+                  : `eventlog@${liveStoreStorageFormatVersion}.db`,
+              // TODO enable WAL for nodejs
+              configureDb: (db) => configureConnection(db, { foreignKeys: true }).pipe(Effect.runSyncWith(services)),
+            }),
+            (db) => Effect.sync(() => db.close()),
+          )
     }
 
     // Might involve some async work, so we're running them concurrently
@@ -116,8 +117,8 @@ export const makeLeaderThread = ({
       devtoolsOptions,
       shutdownChannel,
       syncPayloadEncoded,
-      syncPayloadSchema,
-    })
+      syncPayloadSchema: syncPayloadSchema as Schema.Decoder<Schema.Json, never> | undefined,
+    }).pipe(Layer.provide(StateHead.layer({ dbState })))
   }).pipe(
     Effect.tapCauseLogPretty,
     UnknownError.mapToUnknownError,
@@ -126,8 +127,6 @@ export const makeLeaderThread = ({
     }),
   )
 
-const getStateDbFileName = (suffix: string) => `state${suffix}@${liveStoreStorageFormatVersion}.db`
-
 const makeDevtoolsOptions = ({
   dbState,
   dbEventlog,
@@ -139,7 +138,7 @@ const makeDevtoolsOptions = ({
   dbEventlog: LeaderSqliteDb
   storeId: string
   clientId: string
-  devtools: WorkerSchema.LeaderWorkerInnerInitialMessage['devtools']
+  devtools: WorkerSchema.LeaderWorkerInnerInitialMessagePayload['devtools']
 }): Effect.Effect<DevtoolsOptions, UnknownError, Scope.Scope> =>
   Effect.gen(function* () {
     if (devtools.enabled === false) {