@livestore/adapter-cloudflare 0.0.0-snapshot-8452e32b7fbfc129741b253b9c853f866b52129f

package/dist/sync-provider-client.js

@@ -0,0 +1,24 @@
+import { makeCfSync } from '@livestore/sync-cf';
+import { Effect, Schedule } from '@livestore/utils/effect';
+import { makeWebSocket } from "./WebSocket.js";
+/**
+ * Specialized sync backend used for Cloudflare Workers compatible only with `@livestore/sync-cf`
+ */
+export const makeSyncProviderClient = ({ durableObject }) => (args) => {
+    // Create a WebSocket factory that uses Cloudflare Durable Objects
+    const webSocketFactory = (wsUrl) => Effect.gen(function* () {
+        const url = new URL(wsUrl);
+        const socket = yield* makeWebSocket({
+            durableObject,
+            url,
+            reconnect: Schedule.exponential(100),
+        });
+        return socket;
+    });
+    // Use the unified ws-impl with the Cloudflare WebSocket factory
+    return makeCfSync({
+        url: 'https://unused.com', // URL is constructed internally by ws-impl
+        webSocketFactory,
+    })(args);
+};
+//# sourceMappingURL=sync-provider-client.js.map

package/dist/sync-provider-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-provider-client.js","sourceRoot":"","sources":["../src/sync-provider-client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAE/C,OAAO,EAAE,MAAM,EAAE,QAAQ,EAA8B,MAAM,yBAAyB,CAAA;AAEtF,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAO9C;;GAEG;AACH,MAAM,CAAC,MAAM,sBAAsB,GACjC,CAAC,EAAE,aAAa,EAAuC,EAAkD,EAAE,CAC3G,CAAC,IAAI,EAAE,EAAE;IACP,kEAAkE;IAClE,MAAM,gBAAgB,GAAG,CACvB,KAAa,EAC+D,EAAE,CAC9E,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QAClB,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAA;QAC1B,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,aAAa,CAAC;YAClC,aAAa;YACb,GAAG;YACH,SAAS,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC;SACrC,CAAC,CAAA;QACF,OAAO,MAAyC,CAAA;IAClD,CAAC,CAAC,CAAA;IAEJ,gEAAgE;IAChE,OAAO,UAAU,CAAC;QAChB,GAAG,EAAE,oBAAoB,EAAE,2CAA2C;QACtE,gBAAgB;KACjB,CAAC,CAAC,IAAI,CAAC,CAAA;AACV,CAAC,CAAA"}

package/dist/sync-provider-rpc-client.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sync-provider-rpc-client.d.ts.map

package/dist/sync-provider-rpc-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-provider-rpc-client.d.ts","sourceRoot":"","sources":["../src/sync-provider-rpc-client.ts"],"names":[],"mappings":""}

package/dist/sync-provider-rpc-client.js

@@ -0,0 +1,139 @@
+// import { InvalidPullError, InvalidPushError, SyncBackend } from '@livestore/common'
+// import { layerProtocolDurableObject } from '@livestore/common-cf'
+// import * as CfSyncBackend from '@livestore/sync-cf/cf-worker'
+// import {
+//   Effect,
+//   Layer,
+//   Option,
+//   Queue,
+//   RpcClient,
+//   RpcSerialization,
+//   Stream,
+//   SubscriptionRef,
+// } from '@livestore/utils/effect'
+// import { nanoid } from '@livestore/utils/nanoid'
+// import type * as CfWorker from './cf-types.ts'
+export {};
+// // Extended RPC interface for sync backend stub
+// interface SyncBackendRpcStub extends CfWorker.DurableObjectStub, CfSyncBackend.SyncBackendRpcInterface {}
+// export type MakeRpcSyncBackendOptions = {
+//   /** Sync backend Durable Object stub for RPC calls */
+//   syncBackendStub: SyncBackendRpcStub
+//   /** This client's ID for subscription callbacks */
+//   clientId: string
+//   /** This client's Durable Object ID for subscription callbacks */
+//   durableObjectId: string
+// }
+// /**
+//  * RPC-based sync client that uses direct Durable Object RPC calls
+//  * instead of WebSocket connections
+//  */
+// export const makeRpcSyncProviderClient =
+//   ({
+//     syncBackendStub,
+//     clientId,
+//     durableObjectId,
+//   }: MakeRpcSyncBackendOptions): SyncBackend.SyncBackendConstructor<{ createdAt: string }> =>
+//   ({ storeId, payload }) =>
+//     Effect.gen(function* () {
+//       const isConnected = yield* SubscriptionRef.make(true)
+//       // PubSub for incoming messages from RPC callbacks
+//       const ProtocolLive = layerProtocolDurableObject((payload) => syncBackendStub.rpc(payload)).pipe(
+//         Layer.provide(RpcSerialization.layerJson),
+//       )
+//       const rpcClient = yield* RpcClient.make(CfSyncBackend.SyncDoRpc).pipe(Effect.provide(ProtocolLive))
+//       // Nothing to do here
+//       const connect = Effect.void
+//       const pull: SyncBackend.SyncBackend<{ createdAt: string }>['pull'] = (args) =>
+//         Effect.gen(function* () {
+//           const initialCursor = Option.getOrUndefined(args)?.cursor.global
+//           const cursorRef = { current: initialCursor }
+//           // const incomingMessages = yield* PubSub.unbounded<SyncBackend.PullResItem>()
+//           const messagesQueue =
+//             yield* Queue.unbounded<SyncBackend.PullResItem<{ createdAt: string }>>().pipe(
+//               // Effect.acquireRelease(Queue.shutdown),
+//             )
+//           const requestId = nanoid()
+//           const runPull = Effect.gen(function* () {
+//             yield* rpcClient.SyncDoRpc.Pull({
+//               requestId,
+//               cursor: cursorRef.current,
+//               storeId,
+//             }).pipe(
+//               Stream.mapError((cause) => new InvalidPullError({ cause })),
+//               Stream.map((_) => ({ batch: _.batch, remaining: _.remaining })),
+//               Stream.tap((msg) => Effect.log(`RPC pulled ${msg.batch.length} events from sync provider`)),
+//               Stream.tap((msg) =>
+//                 Effect.sync(() => {
+//                   if (msg.batch.length > 0) {
+//                     cursorRef.current = msg.batch.at(-1)!.eventEncoded.seqNum
+//                   }
+//                 }),
+//               ),
+//               Stream.withSpan('rpc-sync-client:pull'),
+//               Stream.tapErrorCause((cause) => Effect.logError(cause)),
+//               Stream.tapChunk((msg) => Queue.offerAll(messagesQueue, msg)),
+//               Stream.runDrain,
+//             )
+//           })
+//           yield* rpcClient.SyncDoRpc.Subscribe({ clientId, storeId, requestId, durableObjectId, payload }).pipe(
+//             // yield* Stream.succeed('ok').pipe(
+//             //   Stream.repeat(Schedule.spaced(1000)),
+//             Stream.tapLogWithLabel('rpc-sync-client:subscribe'),
+//             Stream.tap(() => runPull),
+//             Stream.onDone(() => Effect.log('rpc-sync-client:subscribe done')),
+//             Stream.onEnd(Effect.log('rpc-sync-client:subscribe end')),
+//             Stream.runDrain,
+//             Effect.tapCauseLogPretty,
+//             Effect.tap(() => Effect.log('rpc-sync-client:subscribe tap')),
+//             // Effect.forkScoped,
+//             Effect.fork,
+//             Effect.tapCauseLogPretty,
+//           )
+//           // setInterval(() => {
+//           //   console.log('runPull')
+//           // }, 1000)
+//           yield* runPull
+//           yield* Effect.addFinalizerLog('rpc-sync-client:finalizer')
+//           // console.log('client do pull', args)
+//           // return Stream.empty
+//           return Stream.fromQueue(messagesQueue)
+//         }).pipe(Stream.unwrapScoped)
+//       const push: SyncBackend.SyncBackend<{ createdAt: string }>['push'] = (batch) =>
+//         Effect.gen(function* () {
+//           yield* Effect.log(`RPC Sync Client: Pushing ${batch.length} events`)
+//           if (batch.length === 0) {
+//             return
+//           }
+//           yield* rpcClient.SyncDoRpc.Push({ requestId: nanoid(), batch, storeId }).pipe(
+//             Effect.tapCauseLogPretty,
+//             Effect.mapError((cause) => new InvalidPushError({ reason: { _tag: 'Unexpected', cause } })),
+//             // Effect.orDie,
+//           )
+//           yield* Effect.log(`RPC Sync Client: Successfully pushed ${batch.length} events`)
+//           // console.log(`RPC Sync Client: Pushing ${batch.length} events`)
+//           // const pushReq = WSMessage.PushReq.make({
+//           //   requestId: `rpc-push-${Date.now()}`,
+//           //   batch,
+//           // })
+//           // // Direct RPC call to sync backend
+//           // // yield* Effect.tryPromise({
+//           // //   try: () => syncBackendStub.push(pushReq),
+//           // //   catch: (error) => new InvalidPushError({ reason: { _tag: 'Unexpected', message: String(error) } }),
+//           // // })
+//           // console.log(`RPC Sync Client: Successfully pushed ${batch.length} events`)
+//         }).pipe(Effect.withSpan('rpc-sync-client:push'))
+//       return SyncBackend.of({
+//         connect,
+//         isConnected,
+//         pull,
+//         push,
+//         metadata: {
+//           name: 'rpc-sync-client',
+//           description: 'Cloudflare Durable Object RPC Sync Client',
+//           protocol: 'rpc',
+//           storeId,
+//         },
+//       })
+//     }).pipe(Effect.withSpan('makeRpcSyncProviderClient'))
+//# sourceMappingURL=sync-provider-rpc-client.js.map

package/dist/sync-provider-rpc-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-provider-rpc-client.js","sourceRoot":"","sources":["../src/sync-provider-rpc-client.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,oEAAoE;AACpE,gEAAgE;AAChE,WAAW;AACX,YAAY;AACZ,WAAW;AACX,YAAY;AACZ,WAAW;AACX,eAAe;AACf,sBAAsB;AACtB,YAAY;AACZ,qBAAqB;AACrB,mCAAmC;AACnC,mDAAmD;AACnD,iDAAiD;;AAEjD,kDAAkD;AAElD,4GAA4G;AAE5G,4CAA4C;AAC5C,0DAA0D;AAC1D,wCAAwC;AACxC,uDAAuD;AACvD,qBAAqB;AACrB,sEAAsE;AACtE,4BAA4B;AAC5B,IAAI;AAEJ,MAAM;AACN,qEAAqE;AACrE,sCAAsC;AACtC,MAAM;AACN,2CAA2C;AAC3C,OAAO;AACP,uBAAuB;AACvB,gBAAgB;AAChB,uBAAuB;AACvB,gGAAgG;AAChG,8BAA8B;AAC9B,gCAAgC;AAChC,8DAA8D;AAE9D,2DAA2D;AAE3D,yGAAyG;AACzG,qDAAqD;AACrD,UAAU;AAEV,4GAA4G;AAE5G,8BAA8B;AAC9B,oCAAoC;AAEpC,uFAAuF;AACvF,oCAAoC;AACpC,6EAA6E;AAE7E,yDAAyD;AAEzD,2FAA2F;AAC3F,kCAAkC;AAClC,6FAA6F;AAC7F,0DAA0D;AAC1D,gBAAgB;AAEhB,uCAAuC;AAEvC,sDAAsD;AACtD,gDAAgD;AAChD,2BAA2B;AAC3B,2CAA2C;AAC3C,yBAAyB;AACzB,uBAAuB;AACvB,6EAA6E;AAC7E,iFAAiF;AACjF,6GAA6G;AAC7G,oCAAoC;AACpC,sCAAsC;AACtC,gDAAgD;AAChD,gFAAgF;AAChF,sBAAsB;AACtB,sBAAsB;AACtB,mBAAmB;AACnB,yDAAyD;AACzD,yEAAyE;AACzE,8EAA8E;AAC9E,iCAAiC;AACjC,gBAAgB;AAChB,eAAe;AAEf,mHAAmH;AACnH,mDAAmD;AACnD,yDAAyD;AACzD,mEAAmE;AACnE,yCAAyC;AACzC,iFAAiF;AACjF,yEAAyE;AACzE,+BAA+B;AAC/B,wCAAwC;AACxC,6EAA6E;AAC7E,oCAAoC;AACpC,2BAA2B;AAC3B,wCAAwC;AACxC,cAAc;AAEd,mCAAmC;AACnC,wCAAwC;AACxC,wBAAwB;AAExB,2BAA2B;AAE3B,uEAAuE;AAEvE,mDAAmD;AACnD,mCAAmC;AAEnC,mDAAmD;AACnD,uCAAuC;AAEvC,wFAAwF;AACxF,oCAAoC;AACpC,iFAAiF;AAEjF,sCAAsC;AACtC,qBAAqB;AACrB,cAAc;AAEd,2FAA2F;AAC3F,wCAAwC;AACxC,2GAA2G;AAC3G,+BAA+B;AAC/B,cAAc;AAEd,6FAA6F;AAE7F,8EAA8E;AAE9E,wDAAwD;AACxD,sDAAsD;AACtD,wBAAwB;AACxB,kBAAkB;AAElB,kDAAkD;AAClD,6CAA6C;AAC7C,8DAA8D;AAC9D,wHAAwH;AACxH,qBAAqB;AAErB,0FAA0F;AAC1F,2DAA2D;AAE3D,gCAAgC;AAChC,mBAAmB;AACnB,uBAAuB;AACvB,gBAAgB;AAChB,gBAAgB;AAChB,sBAAsB;AACtB,qCAAqC;AACrC,sEAAsE;AACtE,6BAA6B;AAC7B,qBAAqB;AACrB,aAAa;AACb,WAAW;AACX,4DAA4D"}

package/dist/sync-provider-ws-client.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sync-provider-ws-client.d.ts.map

package/dist/sync-provider-ws-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-provider-ws-client.d.ts","sourceRoot":"","sources":["../src/sync-provider-ws-client.ts"],"names":[],"mappings":""}

package/dist/sync-provider-ws-client.js

@@ -0,0 +1,40 @@
+// import type { SyncBackend } from '@livestore/common'
+// import { makeCfSync } from '@livestore/sync-cf'
+// import type * as CfSyncBackend from '@livestore/sync-cf/cf-worker'
+// import type { WSMessage } from '@livestore/sync-cf/common'
+// import { Effect, Schedule, type Scope, type WebSocket } from '@livestore/utils/effect'
+// import type * as CfWorker from './cf-types.ts'
+// import { makeWebSocket } from './WebSocket.ts'
+export {};
+// export type MakeDurableObjectSyncBackendOptions = {
+//   /** WebSocket URL to connect to the sync backend Durable Object */
+//   durableObject: CfWorker.DurableObjectStub<CfSyncBackend.SyncBackendRpcInterface>
+// }
+// /**
+//  * Specialized sync backend used for Cloudflare Workers compatible only with `@livestore/sync-cf`
+//  */
+// export const makeWsSyncProviderClient =
+//   ({
+//     durableObject,
+//   }: MakeDurableObjectSyncBackendOptions): SyncBackend.SyncBackendConstructor<WSMessage.SyncMetadata> =>
+//   (args) => {
+//     // Create a WebSocket factory that uses Cloudflare Durable Objects
+//     const webSocketFactory = (
+//       wsUrl: string,
+//     ): Effect.Effect<globalThis.WebSocket, WebSocket.WebSocketError, Scope.Scope> =>
+//       Effect.gen(function* () {
+//         const url = new URL(wsUrl)
+//         const socket = yield* makeWebSocket({
+//           durableObject,
+//           url,
+//           reconnect: Schedule.exponential(100),
+//         })
+//         return socket as unknown as globalThis.WebSocket
+//       })
+//     // Use the unified ws-impl with the Cloudflare WebSocket factory
+//     return makeCfSync({
+//       url: 'https://unused.com', // URL is constructed internally by ws-impl
+//       webSocketFactory,
+//     })(args)
+//   }
+//# sourceMappingURL=sync-provider-ws-client.js.map

package/dist/sync-provider-ws-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-provider-ws-client.js","sourceRoot":"","sources":["../src/sync-provider-ws-client.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,kDAAkD;AAClD,qEAAqE;AACrE,6DAA6D;AAC7D,yFAAyF;AACzF,iDAAiD;AACjD,iDAAiD;;AAEjD,sDAAsD;AACtD,uEAAuE;AACvE,qFAAqF;AACrF,IAAI;AAEJ,MAAM;AACN,oGAAoG;AACpG,MAAM;AACN,0CAA0C;AAC1C,OAAO;AACP,qBAAqB;AACrB,2GAA2G;AAC3G,gBAAgB;AAChB,yEAAyE;AACzE,iCAAiC;AACjC,uBAAuB;AACvB,uFAAuF;AACvF,kCAAkC;AAClC,qCAAqC;AACrC,gDAAgD;AAChD,2BAA2B;AAC3B,iBAAiB;AACjB,kDAAkD;AAClD,aAAa;AACb,2DAA2D;AAC3D,WAAW;AAEX,uEAAuE;AACvE,0BAA0B;AAC1B,+EAA+E;AAC/E,0BAA0B;AAC1B,eAAe;AACf,MAAM"}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@livestore/adapter-cloudflare",
+  "version": "0.0.0-snapshot-8452e32b7fbfc129741b253b9c853f866b52129f",
+  "type": "module",
+  "sideEffects": [
+    "./src/polyfill.ts"
+  ],
+  "exports": {
+    ".": "./dist/mod.js"
+  },
+  "dependencies": {
+    "@cloudflare/workers-types": "4.20250807.0",
+    "@livestore/common": "0.0.0-snapshot-8452e32b7fbfc129741b253b9c853f866b52129f",
+    "@livestore/common-cf": "0.0.0-snapshot-8452e32b7fbfc129741b253b9c853f866b52129f",
+    "@livestore/livestore": "0.0.0-snapshot-8452e32b7fbfc129741b253b9c853f866b52129f",
+    "@livestore/sqlite-wasm": "0.0.0-snapshot-8452e32b7fbfc129741b253b9c853f866b52129f",
+    "@livestore/utils": "0.0.0-snapshot-8452e32b7fbfc129741b253b9c853f866b52129f",
+    "@livestore/sync-cf": "0.0.0-snapshot-8452e32b7fbfc129741b253b9c853f866b52129f"
+  },
+  "devDependencies": {
+    "wrangler": "^4.30.0"
+  },
+  "files": [
+    "package.json",
+    "src",
+    "dist"
+  ],
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public",
+    "sideEffects": [
+      "./dist/polyfill.js"
+    ]
+  },
+  "scripts": {
+    "test": "echo No tests yet"
+  }
+}

package/src/WebSocket.ts

@@ -0,0 +1,69 @@
+import type { Schedule, Scope } from '@livestore/utils/effect'
+import { Effect, Exit, identity, WebSocket } from '@livestore/utils/effect'
+import type * as CfWorker from './cf-types.ts'
+
+// TODO refactor using Effect socket implementation
+// https://github.com/Effect-TS/effect/blob/main/packages%2Fexperimental%2Fsrc%2FDevTools%2FClient.ts#L113
+// "In a Stream pipeline everything above the pipeThrough is the outgoing (send) messages. Everything below is the incoming (message event) messages."
+// https://github.com/Effect-TS/effect/blob/main/packages%2Fplatform%2Fsrc%2FSocket.ts#L451
+
+/**
+ * Creates a WebSocket connection and waits for the connection to be established.
+ * Automatically closes the connection when the scope is closed.
+ */
+export const makeWebSocket = ({
+  // do,
+  reconnect,
+  url,
+  durableObject,
+}: {
+  /** CF Sync Backend DO with `/sync` endpoint */
+  durableObject: CfWorker.DurableObjectStub
+  url: URL
+  reconnect?: Schedule.Schedule<unknown> | false
+}): Effect.Effect<CfWorker.WebSocket, WebSocket.WebSocketError, Scope.Scope> =>
+  Effect.gen(function* () {
+    // yield* validateUrl(url)
+
+    const socket = yield* Effect.tryPromise({
+      try: () =>
+        durableObject.fetch(url, { headers: { Upgrade: 'websocket' } }).then((res: any) => {
+          if (!res.webSocket) {
+            throw new Error('WebSocket upgrade failed')
+          }
+          return res.webSocket as CfWorker.WebSocket
+        }),
+      catch: (cause) => new WebSocket.WebSocketError({ cause }),
+    }).pipe(reconnect ? Effect.retry(reconnect) : identity, Effect.withSpan('make-websocket-durable-object'))
+
+    socket.accept()
+
+    /**
+     * Common WebSocket close codes: https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close
+     *   1000: Normal closure
+     *   1001: Endpoint is going away, a server is terminating the connection because it has received a request that indicates the client is ending the connection.
+     *   1002: Protocol error, a server is terminating the connection because it has received data on the connection that was not consistent with the type of the connection.
+     *   1011: Internal server error, a server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.
+     *
+     * For reference, here are the valid WebSocket close code ranges:
+     *   1000-1999: Reserved for protocol usage
+     *   2000-2999: Reserved for WebSocket extensions
+     *   3000-3999: Available for libraries and frameworks
+     *   4000-4999: Available for applications
+     */
+    yield* Effect.addFinalizer(
+      Effect.fn(function* (exit) {
+        try {
+          if (Exit.isFailure(exit)) {
+            socket.close(3000)
+          } else {
+            socket.close(1000)
+          }
+        } catch (error) {
+          yield* Effect.die(new WebSocket.WebSocketError({ cause: error }))
+        }
+      }),
+    )
+
+    return socket
+  })

package/src/cf-types.ts

@@ -0,0 +1,20 @@
+export {
+  type D1Database,
+  type D1Result,
+  type DurableObject,
+  type DurableObjectNamespace,
+  type DurableObjectState,
+  type DurableObjectStorage,
+  type DurableObjectStub,
+  type MessageEvent,
+  Request,
+  Response,
+  Rpc,
+  type SqlStorage,
+  SqlStorageCursor,
+  SqlStorageStatement,
+  type SqlStorageValue,
+  WebSocket,
+  WebSocketPair,
+  WebSocketRequestResponsePair,
+} from '@cloudflare/workers-types'

package/src/make-adapter.ts

@@ -0,0 +1,144 @@
+import {
+  type Adapter,
+  ClientSessionLeaderThreadProxy,
+  type LockStatus,
+  liveStoreStorageFormatVersion,
+  makeClientSession,
+  type SyncOptions,
+  UnexpectedError,
+} from '@livestore/common'
+import { type DevtoolsOptions, Eventlog, LeaderThreadCtx, makeLeaderThreadLayer } from '@livestore/common/leader-thread'
+import { LiveStoreEvent } from '@livestore/livestore'
+import { sqliteDbFactory } from '@livestore/sqlite-wasm/cf'
+import { loadSqlite3Wasm } from '@livestore/sqlite-wasm/load-wasm'
+import { Effect, FetchHttpClient, Layer, SubscriptionRef, WebChannel } from '@livestore/utils/effect'
+import type * as CfWorker from './cf-types.ts'
+
+export const makeAdapter =
+  ({
+    storage,
+    clientId,
+    syncOptions,
+    sessionId,
+  }: {
+    storage: CfWorker.DurableObjectStorage
+    clientId: string
+    syncOptions: SyncOptions
+    sessionId: string
+  }): Adapter =>
+  (adapterArgs) =>
+    Effect.gen(function* () {
+      const { storeId, /* devtoolsEnabled, shutdown, bootStatusQueue,  */ syncPayload, schema } = adapterArgs
+
+      const devtoolsOptions = { enabled: false } as DevtoolsOptions
+
+      const sqlite3 = yield* Effect.promise(() => loadSqlite3Wasm())
+
+      const makeSqliteDb = sqliteDbFactory({ sqlite3 })
+
+      const syncInMemoryDb = yield* makeSqliteDb({ _tag: 'in-memory', storage, configureDb: () => {} }).pipe(
+        UnexpectedError.mapToUnexpectedError,
+      )
+
+      const schemaHashSuffix =
+        schema.state.sqlite.migrations.strategy === 'manual' ? 'fixed' : schema.state.sqlite.hash.toString()
+
+      const dbState = yield* makeSqliteDb({
+        _tag: 'storage',
+        storage,
+        fileName: getStateDbFileName(schemaHashSuffix),
+        configureDb: () => {},
+      }).pipe(UnexpectedError.mapToUnexpectedError)
+
+      const dbEventlog = yield* makeSqliteDb({
+        _tag: 'storage',
+        storage,
+        fileName: `eventlog@${liveStoreStorageFormatVersion}.db`,
+        configureDb: () => {},
+      }).pipe(UnexpectedError.mapToUnexpectedError)
+
+      const shutdownChannel = yield* WebChannel.noopChannel<any, any>()
+
+      // Use Durable Object sync backend if no backend is specified
+
+      const layer = yield* Layer.build(
+        makeLeaderThreadLayer({
+          schema,
+          storeId,
+          clientId,
+          makeSqliteDb,
+          syncOptions,
+          dbState,
+          dbEventlog,
+          devtoolsOptions,
+          shutdownChannel,
+          syncPayload,
+        }),
+      )
+
+      const { leaderThread, initialSnapshot } = yield* Effect.gen(function* () {
+        const { dbState, dbEventlog, syncProcessor, extraIncomingMessagesQueue, initialState } = yield* LeaderThreadCtx
+
+        const initialLeaderHead = Eventlog.getClientHeadFromDb(dbEventlog)
+        // const initialLeaderHead = EventSequenceNumber.ROOT
+
+        const leaderThread = ClientSessionLeaderThreadProxy.of(
+          {
+            events: {
+              pull: ({ cursor }) => syncProcessor.pull({ cursor }),
+              push: (batch) =>
+                syncProcessor.push(
+                  batch.map((item) => new LiveStoreEvent.EncodedWithMeta(item)),
+                  { waitForProcessing: true },
+                ),
+            },
+            initialState: { leaderHead: initialLeaderHead, migrationsReport: initialState.migrationsReport },
+            export: Effect.sync(() => dbState.export()),
+            getEventlogData: Effect.sync(() => dbEventlog.export()),
+            getSyncState: syncProcessor.syncState,
+            sendDevtoolsMessage: (message) => extraIncomingMessagesQueue.offer(message),
+          },
+          {
+            // overrides: testing?.overrides?.clientSession?.leaderThreadProxy
+          },
+        )
+
+        const initialSnapshot = dbState.export()
+
+        return { leaderThread, initialSnapshot }
+      }).pipe(Effect.provide(layer))
+
+      syncInMemoryDb.import(initialSnapshot)
+
+      const lockStatus = yield* SubscriptionRef.make<LockStatus>('has-lock')
+
+      const clientSession = yield* makeClientSession({
+        ...adapterArgs,
+        sqliteDb: syncInMemoryDb,
+        webmeshMode: 'proxy',
+        connectWebmeshNode: Effect.fnUntraced(function* ({ webmeshNode }) {
+          console.log('connectWebmeshNode', { webmeshNode })
+          // if (devtoolsOptions.enabled) {
+          //   yield* Webmesh.connectViaWebSocket({
+          //     node: webmeshNode,
+          //     url: `ws://${devtoolsOptions.host}:${devtoolsOptions.port}`,
+          //     openTimeout: 500,
+          //   }).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
+          // }
+        }),
+        leaderThread,
+        lockStatus,
+        clientId,
+        sessionId,
+        isLeader: true,
+        // Not really applicable for node as there is no "reload the app" concept
+        registerBeforeUnload: (_onBeforeUnload) => () => {},
+      })
+
+      return clientSession
+    }).pipe(
+      Effect.withSpan('@livestore/adapter-cloudflare:makeAdapter', { attributes: { clientId, sessionId } }),
+      Effect.provide(FetchHttpClient.layer),
+    )
+
+const getStateDbFileName = (suffix: string) => `state${suffix}@${liveStoreStorageFormatVersion}.db`

package/src/make-client-durable-object.ts

@@ -0,0 +1,91 @@
+import type { UnexpectedError } from '@livestore/common'
+import { createStore, type LiveStoreSchema, provideOtel, type Store, type Unsubscribe } from '@livestore/livestore'
+import type * as CfSyncBackend from '@livestore/sync-cf/cf-worker'
+import { makeDoRpcSync } from '@livestore/sync-cf/client'
+import { Effect, Logger, LogLevel, Scope } from '@livestore/utils/effect'
+import type * as CfWorker from './cf-types.ts'
+import { makeAdapter } from './make-adapter.ts'
+
+declare class Response extends CfWorker.Response {}
+
+export type MakeDurableObjectClassOptions<TSchema extends LiveStoreSchema = LiveStoreSchema.Any> = {
+  schema: TSchema
+  // storeId: string
+  clientId: string
+  sessionId: string
+  onStoreReady?: (store: Store<TSchema>) => Effect.SyncOrPromiseOrEffect<void, UnexpectedError>
+  // makeStore?: (adapter: Adapter) => Promise<Store<TSchema>>
+  // onLiveStoreEvent?: (event: LiveStoreEvent.ForSchema<TSchema>) => Promise<void>
+  registerQueries?: (store: Store<TSchema>) => Effect.SyncOrPromiseOrEffect<ReadonlyArray<Unsubscribe>>
+  syncBackendUrl?: string
+  // Hook for custom request handling (e.g., testing endpoints)
+  handleCustomRequest?: (
+    request: CfWorker.Request,
+    ensureStore: Effect.Effect<Store<TSchema>, UnexpectedError, never>,
+  ) => Effect.SyncOrPromiseOrEffect<CfWorker.Response | undefined, UnexpectedError>
+}
+
+export type Env = {
+  SYNC_BACKEND_DO: CfWorker.DurableObjectNamespace
+}
+
+export type MakeDurableObjectClass = <TSchema extends LiveStoreSchema = LiveStoreSchema.Any>(
+  options: MakeDurableObjectClassOptions<TSchema>,
+) => {
+  new (ctx: CfWorker.DurableObjectState, env: Env): CfWorker.DurableObject & CfWorker.Rpc.DurableObjectBranded
+}
+
+export type CreateStoreDoOptions<TSchema extends LiveStoreSchema = LiveStoreSchema.Any> = {
+  schema: TSchema
+  storeId: string
+  clientId: string
+  sessionId: string
+  storage: CfWorker.DurableObjectStorage
+  syncBackendDurableObject: CfWorker.DurableObjectStub<CfSyncBackend.SyncBackendRpcInterface>
+  durableObjectId: string
+  bindingName: string
+  livePull?: boolean
+}
+
+export const createStoreDo = <TSchema extends LiveStoreSchema = LiveStoreSchema.Any>({
+  schema,
+  storeId,
+  clientId,
+  sessionId,
+  storage,
+  syncBackendDurableObject,
+  durableObjectId,
+  bindingName,
+  livePull = false,
+}: CreateStoreDoOptions<TSchema>) =>
+  Effect.gen(function* () {
+    const scope = yield* Scope.make()
+
+    const adapter = makeAdapter({
+      clientId,
+      sessionId,
+      storage,
+      syncOptions: {
+        backend: makeDoRpcSync({
+          syncBackendStub: syncBackendDurableObject,
+          durableObjectContext: { bindingName, durableObjectId },
+        }),
+        livePull, // Uses DO RPC callbacks for reactive pull
+        // backend: makeHttpSync({ url: `http://localhost:8787`, livePull: { pollInterval: 500 } }),
+        initialSyncOptions: { _tag: 'Blocking', timeout: 500 },
+        // backend: makeWsSyncProviderClient({ durableObject: syncBackendDurableObject }),
+      },
+    })
+
+    return yield* createStore({ schema, adapter, storeId }).pipe(Scope.extend(scope), provideOtel({}))
+  })
+
+export const createStoreDoPromise = <TSchema extends LiveStoreSchema = LiveStoreSchema.Any>(
+  options: CreateStoreDoOptions<TSchema>,
+) =>
+  createStoreDo(options).pipe(
+    Logger.withMinimumLogLevel(LogLevel.Debug),
+    Effect.provide(Logger.consoleWithThread('DoClient')),
+    Effect.tapCauseLogPretty,
+    Effect.runPromise,
+  )