@livestore/sync-cf 0.4.0-dev.9 → 0.5.0-dev.0

package/package.json

@@ -1,6 +1,17 @@
 {
   "name": "@livestore/sync-cf",
-  "version": "0.4.0-dev.9",
+  "version": "0.5.0-dev.0",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/livestorejs/livestore.git"
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "src",
+    "README.md"
+  ],
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -8,23 +19,54 @@
     "./common": "./dist/common/mod.js",
     "./cf-worker": "./dist/cf-worker/mod.js"
   },
-  "dependencies": {
-    "@cloudflare/workers-types": "4.20250923.0",
-    "@livestore/common": "0.4.0-dev.9",
-    "@livestore/common-cf": "0.4.0-dev.9",
-    "@livestore/utils": "0.4.0-dev.9"
-  },
-  "files": [
-    "dist",
-    "src",
-    "package.json",
-    "README.md"
-  ],
-  "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@cloudflare/workers-types": "4.20251118.0",
+    "@livestore/utils": "^0.5.0-dev.0",
+    "@livestore/common": "^0.5.0-dev.0",
+    "@livestore/common-cf": "^0.5.0-dev.0"
+  },
+  "devDependencies": {
+    "@effect/opentelemetry": "4.0.0-rc.111",
+    "@effect/platform-browser": "4.0.0-rc.111",
+    "@effect/platform-bun": "4.0.0-rc.111",
+    "@effect/platform-node": "4.0.0-rc.111",
+    "@effect/platform-node-shared": "4.0.0-rc.111",
+    "@effect/vitest": "4.0.0-rc.111",
+    "@opentelemetry/api": "1.9.0",
+    "@opentelemetry/resources": "2.2.0",
+    "@standard-schema/spec": "1.1.0",
+    "effect": "4.0.0-rc.111",
+    "vitest": "4.1.9",
+    "@livestore/utils-dev": "^0.5.0-dev.0"
+  },
+  "peerDependencies": {
+    "@effect/opentelemetry": "^4.0.0-rc.111",
+    "@effect/platform-browser": "^4.0.0-rc.111",
+    "@effect/platform-bun": "^4.0.0-rc.111",
+    "@effect/platform-node": "^4.0.0-rc.111",
+    "@effect/platform-node-shared": "^4.0.0-rc.111",
+    "@effect/vitest": "^4.0.0-rc.111",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/resources": "^2.2.0",
+    "@standard-schema/spec": "^1.1.0",
+    "effect": "^4.0.0-rc.111"
+  },
+  "$genie": {
+    "source": "package.json.genie.ts",
+    "warning": "DO NOT EDIT - changes will be overwritten",
+    "workspaceClosureDirs": [
+      "packages/@livestore/common",
+      "packages/@livestore/common-cf",
+      "packages/@livestore/sync-cf",
+      "packages/@livestore/utils",
+      "packages/@livestore/utils-dev",
+      "packages/@livestore/webmesh"
+    ]
+  },
   "scripts": {
-    "test": "echo 'No tests yet'"
+    "test": "vitest run"
   }
 }

package/src/cf-worker/do/durable-object.ts

@@ -1,6 +1,7 @@
 /// <reference types="@cloudflare/workers-types" />
 
 import { DurableObject } from 'cloudflare:workers'
+
 import { type CfTypes, setupDurableObjectWebSocketRpc } from '@livestore/common-cf'
 import { CfDeclare } from '@livestore/common-cf/declare'
 import {
@@ -8,32 +9,34 @@ import {
   FetchHttpClient,
   Layer,
   Logger,
-  LogLevel,
   Otlp,
+  References,
   RpcMessage,
   Schema,
   type Scope,
 } from '@livestore/utils/effect'
+
 import {
   type Env,
+  extractForwardedHeaders,
   type MakeDurableObjectClassOptions,
   matchSyncRequest,
   type SyncBackendRpcInterface,
   WebSocketAttachmentSchema,
 } from '../shared.ts'
-import { DoCtx } from './layer.ts'
+import * as DoCtx from './layer.ts'
 import { createDoRpcHandler } from './transport/do-rpc-server.ts'
 import { createHttpRpcHandler } from './transport/http-rpc-server.ts'
 import { makeRpcServer } from './transport/ws-rpc-server.ts'
 
-// NOTE We need to redeclare runtime types here to avoid type conflicts with the lib.dom Response type.
-// TODO get rid of those once CF fixed their type mismatch in the worker types
-declare class Request extends CfDeclare.Request {}
-declare class Response extends CfDeclare.Response {}
-declare class WebSocketPair extends CfDeclare.WebSocketPair {}
-declare class WebSocketRequestResponsePair extends CfDeclare.WebSocketRequestResponsePair {}
+const Response = CfDeclare.Response
+const WebSocketPair = CfDeclare.WebSocketPair
+const WebSocketRequestResponsePair = CfDeclare.WebSocketRequestResponsePair
+
+/** Module-scoped JSON encoder; keeping the sync codec out of Effect generators avoids `schemaSyncInEffect`. */
+const jsonStringify = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown))
 
-const DurableObjectBase = DurableObject<Env> as any as new (
+const DurableObjectBase = DurableObject as any as new (
   state: CfTypes.DurableObjectState,
   env: Env,
 ) => CfTypes.DurableObject & { ctx: CfTypes.DurableObjectState; env: Env }
@@ -48,15 +51,15 @@ export type MakeDurableObjectClass = (options?: MakeDurableObjectClassOptions) =
 
 /**
  * Creates a Durable Object class for handling WebSocket-based sync.
- * A sync durable object is uniquely scoped to a specific `storeId`.
- * 
+ * A sync Durable Object is uniquely scoped to a specific `storeId`.
+ *
  * The sync DO supports 3 transport modes:
  * - HTTP JSON-RPC
  * - WebSocket
  * - Durable Object RPC calls (only works in combination with `@livestore/adapter-cf`)
  *
  * Example:
- * 
+ *
  * ```ts
  * // In your Cloudflare Worker file
  * import { makeDurableObject } from '@livestore/sync-cf/cf-worker'
@@ -85,17 +88,16 @@ export type MakeDurableObjectClass = (options?: MakeDurableObjectClassOptions) =
 export const makeDurableObject: MakeDurableObjectClass = (options) => {
   const enabledTransports = options?.enabledTransports ?? new Set(['http', 'ws', 'do-rpc'])
 
-  const Logging = Logger.consoleWithThread('SyncDo')
-
-  const Observability = options?.otel?.baseUrl
-    ? Otlp.layer({
-        baseUrl: options.otel.baseUrl,
-        tracerExportInterval: 50,
-        resource: {
-          serviceName: options.otel.serviceName ?? 'sync-cf-do',
-        },
-      }).pipe(Layer.provide(FetchHttpClient.layer))
-    : Layer.empty
+  const Observability: Layer.Layer<never> =
+    options?.otel?.baseUrl !== undefined
+      ? Otlp.layerJson({
+          baseUrl: options.otel.baseUrl,
+          tracerExportInterval: 50,
+          resource: {
+            serviceName: options.otel.serviceName ?? 'sync-cf-do',
+          },
+        }).pipe(Layer.provide(FetchHttpClient.layer))
+      : Layer.empty
 
   return class SyncBackendDOBase extends DurableObjectBase implements SyncBackendRpcInterface {
     __DURABLE_OBJECT_BRAND = 'SyncBackendDOBase' as never
@@ -106,7 +108,7 @@ export const makeDurableObject: MakeDurableObjectClass = (options) => {
       const WebSocketRpcServerLive = makeRpcServer({ doSelf: this, doOptions: options })
 
       // This registers the `webSocketMessage` and `webSocketClose` handlers
-      if (enabledTransports.has('ws')) {
+      if (enabledTransports.has('ws') === true) {
         setupDurableObjectWebSocketRpc({
           doSelf: this,
           rpcLayer: WebSocketRpcServerLive,
@@ -117,7 +119,7 @@ export const makeDurableObject: MakeDurableObjectClass = (options) => {
             if (request._tag === 'Request' && request.tag === 'SyncWsRpc.Pull') {
               // Is Pull request: add requestId to pullRequestIds
               const attachment = ws.deserializeAttachment()
-              const { pullRequestIds, ...rest } = Schema.decodeSync(WebSocketAttachmentSchema)(attachment)
+              const { pullRequestIds, ...rest } = Schema.decodeUnknownSync(WebSocketAttachmentSchema)(attachment)
               ws.serializeAttachment(
                 Schema.encodeSync(WebSocketAttachmentSchema)({
                   ...rest,
@@ -127,7 +129,7 @@ export const makeDurableObject: MakeDurableObjectClass = (options) => {
             } else if (request._tag === 'Interrupt') {
               // Is Interrupt request: remove requestId from pullRequestIds
               const attachment = ws.deserializeAttachment()
-              const { pullRequestIds, ...rest } = Schema.decodeSync(WebSocketAttachmentSchema)(attachment)
+              const { pullRequestIds, ...rest } = Schema.decodeUnknownSync(WebSocketAttachmentSchema)(attachment)
               ws.serializeAttachment(
                 Schema.encodeSync(WebSocketAttachmentSchema)({
                   ...rest,
@@ -142,8 +144,8 @@ export const makeDurableObject: MakeDurableObjectClass = (options) => {
       }
     }
 
-    fetch = async (request: Request): Promise<Response> =>
-      Effect.gen(this, function* () {
+    override fetch = async (request: CfTypes.Request): Promise<CfTypes.Response> =>
+      Effect.gen({ self: this }, function* () {
         const searchParams = matchSyncRequest(request)
         if (searchParams === undefined) {
           throw new Error('No search params found in request URL')
@@ -155,17 +157,28 @@ export const makeDurableObject: MakeDurableObjectClass = (options) => {
           throw new Error(`Transport ${transport} is not enabled (based on \`options.enabledTransports\`)`)
         }
 
+        // Extract headers to forward based on configuration (available for all transports)
+        const headers = extractForwardedHeaders(request, options?.forwardHeaders)
+
         if (transport === 'http') {
-          return yield* this.handleHttp(request)
+          return yield* this.handleHttp(request, headers)
         }
 
         if (transport === 'ws') {
           const { 0: client, 1: server } = new WebSocketPair()
 
           // Since we're using websocket hibernation, we need to remember the storeId for subsequent `webSocketMessage` calls
-          server.serializeAttachment(
-            Schema.encodeSync(WebSocketAttachmentSchema)({ storeId, payload, pullRequestIds: [] }),
-          )
+          // Also store forwarded headers so they're available after hibernation resume
+          // Encoding known-valid domain data: an encode failure is an invariant violation (a defect),
+          // so `Effect.orDie` is the correct modeling. serializeAttachment takes the value synchronously,
+          // so resolve the encoded value first, then pass it in.
+          const attachment = yield* Schema.encodeEffect(WebSocketAttachmentSchema)({
+            storeId,
+            payload,
+            pullRequestIds: [],
+            headers,
+          }).pipe(Effect.orDie)
+          server.serializeAttachment(attachment)
 
           // See https://developers.cloudflare.com/durable-objects/examples/websocket-hibernation-server
 
@@ -173,10 +186,7 @@ export const makeDurableObject: MakeDurableObjectClass = (options) => {
 
           // Ping requests are sent by Effect RPC internally
           this.ctx.setWebSocketAutoResponse(
-            new WebSocketRequestResponsePair(
-              JSON.stringify(RpcMessage.constPing),
-              JSON.stringify(RpcMessage.constPong),
-            ),
+            new WebSocketRequestResponsePair(jsonStringify(RpcMessage.constPing), jsonStringify(RpcMessage.constPong)),
           )
 
           return new Response(null, {
@@ -193,11 +203,11 @@ export const makeDurableObject: MakeDurableObjectClass = (options) => {
         })
       }).pipe(
         Effect.tapCauseLogPretty, // Also log errors to console before catching them
-        Effect.catchAllCause((cause) =>
+        Effect.catchCause((cause) =>
           Effect.succeed(new Response('Error', { status: 500, statusText: cause.toString() })),
         ),
         Effect.withSpan('@livestore/sync-cf:durable-object:fetch'),
-        Effect.provide(DoCtx.Default({ doSelf: this, doOptions: options, from: request })),
+        Effect.provide(DoCtx.layer({ doSelf: this, doOptions: options, from: request })),
         this.runEffectAsPromise,
       )
 
@@ -220,16 +230,24 @@ export const makeDurableObject: MakeDurableObjectClass = (options) => {
      *
      * Requires the `enable_request_signal` compatibility flag to properly support `pull` streaming responses
      */
-    private handleHttp = (request: CfTypes.Request) =>
+    private handleHttp = (request: CfTypes.Request, forwardedHeaders: Record<string, string> | undefined) =>
       createHttpRpcHandler({
         request,
+        ...(options?.http?.responseHeaders !== undefined ? { responseHeaders: options.http.responseHeaders } : {}),
+        ...(forwardedHeaders !== undefined ? { forwardedHeaders } : {}),
       }).pipe(Effect.withSpan('@livestore/sync-cf:durable-object:handleHttp'))
 
     private runEffectAsPromise = <T, E = never>(effect: Effect.Effect<T, E, Scope.Scope>): Promise<T> =>
       effect.pipe(
         Effect.tapCauseLogPretty,
-        Logger.withMinimumLogLevel(LogLevel.Debug),
-        Effect.provide(Layer.mergeAll(Observability, Logging)),
+        Effect.annotateLogs({ thread: 'SyncDo' }),
+        Effect.provide(
+          Layer.mergeAll(
+            Observability,
+            Logger.layer([Logger.consoleStructured]),
+            Layer.succeed(References.MinimumLogLevel, 'Debug'),
+          ),
+        ),
         Effect.scoped,
         Effect.runPromise,
       )

package/src/cf-worker/do/layer.ts

@@ -1,16 +1,18 @@
-import { UnexpectedError } from '@livestore/common'
-import { EventSequenceNumber, State } from '@livestore/common/schema'
+import { UnknownError } from '@livestore/common'
 import type { CfTypes } from '@livestore/common-cf'
+import { EventSequenceNumber, State } from '@livestore/common/schema'
 import { shouldNeverHappen } from '@livestore/utils'
-import { Effect, Predicate } from '@livestore/utils/effect'
+import { Context, Effect, Layer, Predicate, Semaphore } from '@livestore/utils/effect'
 import { nanoid } from '@livestore/utils/nanoid'
-import type { Env, MakeDurableObjectClassOptions, RpcSubscription } from '../shared.ts'
+
+import type { Env, MakeDurableObjectClassOptions } from '../shared.ts'
 import { contextTable, eventlogTable } from './sqlite.ts'
-import { makeStorage } from './sync-storage.ts'
+import { makeStorage, type StorageEngine, type SyncStorage } from './sync-storage.ts'
 
 const CacheSymbol = Symbol('Cache')
+const InitializationSemaphoreSymbol = Symbol('InitializationSemaphore')
 
-export interface DoCtxInput {
+export interface Options {
   doSelf: CfTypes.DurableObject & {
     ctx: CfTypes.DurableObjectState
     env: Env
@@ -19,89 +21,152 @@ export interface DoCtxInput {
   from: CfTypes.Request | { storeId: string }
 }
 
-export class DoCtx extends Effect.Service<DoCtx>()('DoCtx', {
-  effect: Effect.fn(
-    function* ({ doSelf, doOptions, from }: DoCtxInput) {
-      if ((doSelf as any)[CacheSymbol] !== undefined) {
-        return (doSelf as any)[CacheSymbol] as never
-      }
-
-      const getStoreId = (from: CfTypes.Request | { storeId: string }) => {
-        if (Predicate.hasProperty(from, 'url')) {
-          const url = new URL(from.url)
-          return (
-            url.searchParams.get('storeId') ?? shouldNeverHappen(`No storeId provided in request URL search params`)
+export type DoCtxInput = Options
+
+export interface Service {
+  readonly storeId: string
+  readonly backendId: string
+  readonly currentHeadRef: { current: EventSequenceNumber.Global.Type }
+  readonly updateCurrentHead: (currentHead: EventSequenceNumber.Global.Type) => void
+  /** Serializes push admission across concurrent RPC fibers for this Durable Object instance. */
+  readonly pushSemaphore: Semaphore.Semaphore
+  readonly storage: SyncStorage
+  readonly doOptions: MakeDurableObjectClassOptions | undefined
+  readonly env: Env
+  readonly ctx: CfTypes.DurableObjectState
+}
+
+export class DoCtx extends Context.Service<DoCtx, Service>()('@livestore/sync-cf/DoCtx') {}
+
+type DurableObjectCacheHost = Options['doSelf'] & {
+  [CacheSymbol]?: Service
+  [InitializationSemaphoreSymbol]?: Semaphore.Semaphore
+}
+
+export const make = Effect.fn(
+  function* ({ doSelf, doOptions, from }: Options) {
+    const cacheHost = doSelf as DurableObjectCacheHost
+    if (cacheHost[CacheSymbol] !== undefined) {
+      return DoCtx.of(cacheHost[CacheSymbol])
+    }
+
+    // Request layers can be constructed concurrently during the first RPCs to a DO.
+    // Install this lock synchronously so every contender shares the same initializer.
+    const initializationSemaphore = cacheHost[InitializationSemaphoreSymbol] ?? Semaphore.makeUnsafe(1)
+    cacheHost[InitializationSemaphoreSymbol] = initializationSemaphore
+
+    return yield* initializationSemaphore.withPermits(1)(
+      Effect.gen(function* () {
+        if (cacheHost[CacheSymbol] !== undefined) {
+          return DoCtx.of(cacheHost[CacheSymbol])
+        }
+
+        const getStoreId = (from: CfTypes.Request | { storeId: string }) => {
+          if (Predicate.hasProperty(from, 'url') === true) {
+            const url = new URL(from.url)
+            return (
+              url.searchParams.get('storeId') ?? shouldNeverHappen(`No storeId provided in request URL search params`)
+            )
+          }
+          return from.storeId
+        }
+
+        const storeId = getStoreId(from)
+        const engine = yield* resolveStorageEngine(doOptions?.storage, doSelf.env)
+
+        const storage = makeStorage(doSelf.ctx, storeId, engine)
+
+        // Initialize database tables
+        {
+          const colSpec = State.SQLite.makeColumnSpec(eventlogTable.sqliteDef.ast)
+          if (engine._tag === 'd1') {
+            // D1 database is async, so we need to use a promise
+            yield* Effect.promise(() =>
+              engine.db.exec(`CREATE TABLE IF NOT EXISTS "${storage.dbName}" (${colSpec}) strict`),
+            )
+          } else {
+            // DO SQLite table lives in Durable Object storage
+            doSelf.ctx.storage.sql.exec(`CREATE TABLE IF NOT EXISTS "${storage.dbName}" (${colSpec}) strict`)
+          }
+        }
+        {
+          const colSpec = State.SQLite.makeColumnSpec(contextTable.sqliteDef.ast)
+          doSelf.ctx.storage.sql.exec(`CREATE TABLE IF NOT EXISTS "${contextTable.sqliteDef.name}" (${colSpec}) strict`)
+        }
+
+        const storageRow = doSelf.ctx.storage.sql
+          .exec(`SELECT * FROM "${contextTable.sqliteDef.name}" WHERE storeId = ?`, storeId)
+          .toArray()[0] as typeof contextTable.rowSchema.Type | undefined
+
+        const currentHeadRef = { current: storageRow?.currentHead ?? EventSequenceNumber.Client.ROOT.global }
+        const pushSemaphore = yield* Semaphore.make(1)
+
+        // TODO: Reconcile this persisted head with the event log's highest sequence number.
+        // D1 event batches and this DO-local context row cannot be updated atomically, so a
+        // failure between those writes can leave push admission using a stale head after restart.
+
+        // Should be the same backendId for lifetime of the Durable Object
+        const backendId = storageRow?.backendId ?? nanoid()
+
+        const updateCurrentHead = (currentHead: EventSequenceNumber.Global.Type) => {
+          doSelf.ctx.storage.sql.exec(
+            `INSERT OR REPLACE INTO "${contextTable.sqliteDef.name}" (storeId, currentHead, backendId) VALUES (?, ?, ?)`,
+            storeId,
+            currentHead,
+            backendId,
           )
+
+          currentHeadRef.current = currentHead
         }
-        return from.storeId
-      }
-
-      const storeId = getStoreId(from)
-      const storage = makeStorage(doSelf.ctx, doSelf.env, storeId)
-
-      // Initialize database tables
-      {
-        const colSpec = State.SQLite.makeColumnSpec(eventlogTable.sqliteDef.ast)
-        // D1 database is async, so we need to use a promise
-        yield* Effect.promise(() =>
-          doSelf.env.DB.exec(`CREATE TABLE IF NOT EXISTS "${storage.dbName}" (${colSpec}) strict`),
-        )
-      }
-      {
-        const colSpec = State.SQLite.makeColumnSpec(contextTable.sqliteDef.ast)
-        doSelf.ctx.storage.sql.exec(`CREATE TABLE IF NOT EXISTS "${contextTable.sqliteDef.name}" (${colSpec}) strict`)
-      }
-
-      const storageRow = doSelf.ctx.storage.sql
-        .exec(`SELECT * FROM "${contextTable.sqliteDef.name}" WHERE storeId = ?`, storeId)
-        .toArray()[0] as typeof contextTable.rowSchema.Type | undefined
-
-      const currentHeadRef = { current: storageRow?.currentHead ?? EventSequenceNumber.ROOT.global }
-
-      // TODO do concistency check with eventlog table to make sure the head is consistent
-
-      // Should be the same backendId for lifetime of the durable object
-      const backendId = storageRow?.backendId ?? nanoid()
-
-      const updateCurrentHead = (currentHead: EventSequenceNumber.GlobalEventSequenceNumber) => {
-        doSelf.ctx.storage.sql.exec(
-          `INSERT OR REPLACE INTO "${contextTable.sqliteDef.name}" (storeId, currentHead, backendId) VALUES (?, ?, ?)`,
+
+        const storageCache = {
           storeId,
-          currentHead,
           backendId,
-        )
-
-        currentHeadRef.current = currentHead
-
-        // I still don't know why we need to re-assign this ref to the `doSelf` object but somehow this seems to be needed 😵‍💫
-        // @ts-expect-error
-        doSelf[CacheSymbol].currentHeadRef = { current: currentHead }
-      }
-
-      const rpcSubscriptions = new Map<string, RpcSubscription>()
-
-      const storageCache = {
-        storeId,
-        backendId,
-        currentHeadRef,
-        updateCurrentHead,
-        storage,
-        doOptions,
-        env: doSelf.env,
-        ctx: doSelf.ctx,
-        rpcSubscriptions,
-      }
-
-      ;(doSelf as any)[CacheSymbol] = storageCache
-
-      // Set initial current head to root
-      if (storageRow === undefined) {
-        updateCurrentHead(EventSequenceNumber.ROOT.global)
-      }
-
-      return storageCache
-    },
-    UnexpectedError.mapToUnexpectedError,
-    Effect.withSpan('@livestore/sync-cf:durable-object:makeDoCtx'),
-  ),
-}) {}
+          currentHeadRef,
+          updateCurrentHead,
+          pushSemaphore,
+          storage,
+          doOptions,
+          env: doSelf.env,
+          ctx: doSelf.ctx,
+        }
+
+        cacheHost[CacheSymbol] = storageCache
+
+        // Set initial current head to root
+        if (storageRow === undefined) {
+          updateCurrentHead(EventSequenceNumber.Client.ROOT.global)
+        }
+
+        return DoCtx.of(storageCache)
+      }),
+    )
+  },
+  UnknownError.mapToUnknownError,
+  Effect.withSpan('@livestore/sync-cf:durable-object:makeDoCtx'),
+)
+
+export const layer = (options: Options) => Layer.effect(DoCtx, make(options))
+
+/** Resolves storage configuration into the concrete database handle used at runtime. */
+const resolveStorageEngine = Effect.fn(function* (
+  storageOption: MakeDurableObjectClassOptions['storage'],
+  env: Env,
+): Effect.fn.Return<StorageEngine, UnknownError> {
+  if (storageOption === undefined || storageOption._tag === 'do-sqlite') {
+    return { _tag: 'do-sqlite' }
+  }
+
+  if (storageOption._tag === 'd1') {
+    const db = (env as Record<string, CfTypes.D1Database | undefined>)[storageOption.binding]
+    if (db === undefined) {
+      return yield* UnknownError.make({
+        cause: new Error(`D1 binding '${storageOption.binding}' not found on env`),
+      })
+    }
+
+    return { _tag: 'd1', db }
+  }
+
+  return shouldNeverHappen(`Invalid storage engine`, storageOption)
+})