@livestore/livestore 0.4.0-dev.18 → 0.4.0-dev.19

package/docs/reference/platform-adapters/cloudflare-durable-object-adapter/index.md

@@ -0,0 +1,453 @@
+# Cloudflare Durable Object Adapter
+
+The Cloudflare Durable Object adapter enables running LiveStore applications on Cloudflare Workers with stateful Durable Objects for synchronized real-time data.
+
+## Installation
+
+```bash
+pnpm add @livestore/adapter-cloudflare @livestore/sync-cf
+```
+
+## Configuration
+
+### Wrangler configuration
+
+Configure your `wrangler.toml` with the required Durable Object bindings:
+
+```toml
+name = "my-livestore-app"
+main = "./src/worker.ts"
+compatibility_date = "2025-05-07"
+compatibility_flags = [
+  "enable_request_signal", # Required for HTTP RPC streams
+]
+
+[[durable_objects.bindings]]
+name = "SYNC_BACKEND_DO"
+class_name = "SyncBackendDO"
+
+[[durable_objects.bindings]]
+name = "CLIENT_DO"
+class_name = "LiveStoreClientDO"
+
+[[migrations]]
+tag = "v1"
+new_sqlite_classes = ["SyncBackendDO", "LiveStoreClientDO"]
+
+[[d1_databases]]
+binding = "DB"
+database_name = "my-livestore-db"
+database_id = "your-database-id"
+```
+
+### Environment types
+
+Define your Worker bindings so TypeScript can guide you when wiring Durable Objects:
+
+## `reference/platform-adapters/cloudflare/env.ts`
+
+```ts filename="reference/platform-adapters/cloudflare/env.ts"
+
+export type Env = {
+  CLIENT_DO: CfTypes.DurableObjectNamespace<ClientDoWithRpcCallback>
+  SYNC_BACKEND_DO: CfTypes.DurableObjectNamespace<SyncBackendRpcInterface>
+  DB: CfTypes.D1Database
+}
+```
+
+We also use a small helper to extract the store identifier from incoming requests:
+
+## `reference/platform-adapters/cloudflare/shared.ts`
+
+```ts filename="reference/platform-adapters/cloudflare/shared.ts"
+
+export const storeIdFromRequest = (request: CfTypes.Request) => {
+  const url = new URL(request.url)
+  const storeId = url.searchParams.get('storeId')
+
+  if (storeId === null) {
+    throw new Error('storeId is required in URL search params')
+  }
+
+  return storeId
+}
+```
+
+## Basic setup
+
+### 1. Create the sync backend Durable Object
+
+The sync backend handles pushing and pulling events between clients:
+
+## `reference/platform-adapters/cloudflare/sync-backend.ts`
+
+```ts filename="reference/platform-adapters/cloudflare/sync-backend.ts"
+
+export class SyncBackendDO extends SyncBackend.makeDurableObject({
+  // Optional: Handle push events
+  // onPush: async (message, { storeId }) => {
+  //   console.log(`onPush for store (${storeId})`, message.batch)
+  // },
+}) {}
+```
+
+### 2. Create the client Durable Object
+
+Each client Durable Object hosts a LiveStore instance and exposes DO RPC callbacks:
+
+## `reference/platform-adapters/cloudflare/client-do.ts`
+
+```ts filename="reference/platform-adapters/cloudflare/client-do.ts"
+/// <reference types="@cloudflare/workers-types" />
+
+type AlarmInfo = {
+  isRetry: boolean
+  retryCount: number
+}
+
+export class LiveStoreClientDO extends DurableObject<Env> implements ClientDoWithRpcCallback {
+  __DURABLE_OBJECT_BRAND: never = undefined as never
+
+  private storeId: string | undefined
+  private cachedStore: Store<typeof schema> | undefined
+  private storeSubscription: Unsubscribe | undefined
+  private readonly todosQuery = tables.todos.select()
+
+  async fetch(request: Request): Promise<Response> {
+    // @ts-expect-error TODO remove casts once CF types are fixed in https://github.com/cloudflare/workerd/issues/4811
+    this.storeId = storeIdFromRequest(request)
+
+    const store = await this.getStore()
+    await this.subscribeToStore()
+
+    const todos = store.query(this.todosQuery)
+    return new Response(JSON.stringify(todos, null, 2), {
+      headers: { 'Content-Type': 'application/json' },
+    })
+  }
+
+  private async getStore() {
+    if (this.cachedStore !== undefined) {
+      return this.cachedStore
+    }
+
+    const storeId = this.storeId ?? nanoid()
+
+    const store = await createStoreDoPromise({
+      schema,
+      storeId,
+      clientId: 'client-do',
+      sessionId: nanoid(),
+      durableObject: {
+        // @ts-expect-error TODO remove once CF types are fixed in https://github.com/cloudflare/workerd/issues/4811
+        ctx: this.ctx,
+        env: this.env,
+        bindingName: 'CLIENT_DO',
+      },
+      syncBackendStub: this.env.SYNC_BACKEND_DO.get(this.env.SYNC_BACKEND_DO.idFromName(storeId)),
+      livePull: true,
+    })
+
+    this.cachedStore = store
+    return store
+  }
+
+  private async subscribeToStore() {
+    const store = await this.getStore()
+
+    if (this.storeSubscription === undefined) {
+      this.storeSubscription = store.subscribe(this.todosQuery, (todos: ReadonlyArray<typeof tables.todos.Type>) => {
+        console.log(`todos for store (${this.storeId})`, todos)
+      })
+    }
+
+    await this.ctx.storage.setAlarm(Date.now() + 1000)
+  }
+
+  alarm(_alarmInfo?: AlarmInfo): void | Promise<void> {
+    return this.subscribeToStore()
+  }
+
+  async syncUpdateRpc(payload: unknown) {
+    await handleSyncUpdateRpc(payload)
+  }
+}
+```
+
+### `reference/platform-adapters/cloudflare/env.ts`
+
+```ts filename="reference/platform-adapters/cloudflare/env.ts"
+
+export type Env = {
+  CLIENT_DO: CfTypes.DurableObjectNamespace<ClientDoWithRpcCallback>
+  SYNC_BACKEND_DO: CfTypes.DurableObjectNamespace<SyncBackendRpcInterface>
+  DB: CfTypes.D1Database
+}
+```
+
+### `reference/platform-adapters/cloudflare/schema.ts`
+
+```ts filename="reference/platform-adapters/cloudflare/schema.ts"
+
+export const tables = {
+  todos: State.SQLite.table({
+    name: 'todos',
+    columns: {
+      id: State.SQLite.text({ primaryKey: true }),
+      text: State.SQLite.text({ default: '' }),
+      completed: State.SQLite.boolean({ default: false }),
+      deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
+    },
+  }),
+}
+
+export const events = {
+  todoCreated: Events.synced({
+    name: 'v1.TodoCreated',
+    schema: Schema.Struct({ id: Schema.String, text: Schema.String }),
+  }),
+  todoCompleted: Events.synced({
+    name: 'v1.TodoCompleted',
+    schema: Schema.Struct({ id: Schema.String }),
+  }),
+  todoUncompleted: Events.synced({
+    name: 'v1.TodoUncompleted',
+    schema: Schema.Struct({ id: Schema.String }),
+  }),
+  todoDeleted: Events.synced({
+    name: 'v1.TodoDeleted',
+    schema: Schema.Struct({ id: Schema.String, deletedAt: Schema.Date }),
+  }),
+  todoClearedCompleted: Events.synced({
+    name: 'v1.TodoClearedCompleted',
+    schema: Schema.Struct({ deletedAt: Schema.Date }),
+  }),
+}
+
+const materializers = State.SQLite.materializers(events, {
+  'v1.TodoCreated': ({ id, text }) => tables.todos.insert({ id, text, completed: false }),
+  'v1.TodoCompleted': ({ id }) => tables.todos.update({ completed: true }).where({ id }),
+  'v1.TodoUncompleted': ({ id }) => tables.todos.update({ completed: false }).where({ id }),
+  'v1.TodoDeleted': ({ id, deletedAt }) => tables.todos.update({ deletedAt }).where({ id }),
+  'v1.TodoClearedCompleted': ({ deletedAt }) => tables.todos.update({ deletedAt }).where({ completed: true }),
+})
+
+const state = State.SQLite.makeState({ tables, materializers })
+
+export const schema = makeSchema({ events, state })
+```
+
+### `reference/platform-adapters/cloudflare/shared.ts`
+
+```ts filename="reference/platform-adapters/cloudflare/shared.ts"
+
+export const storeIdFromRequest = (request: CfTypes.Request) => {
+  const url = new URL(request.url)
+  const storeId = url.searchParams.get('storeId')
+
+  if (storeId === null) {
+    throw new Error('storeId is required in URL search params')
+  }
+
+  return storeId
+}
+```
+
+### 3. Worker fetch handler
+
+The worker routes incoming requests either to the sync backend or to the client Durable Object:
+
+## `reference/platform-adapters/cloudflare/worker.ts`
+
+```ts filename="reference/platform-adapters/cloudflare/worker.ts"
+
+export default {
+  fetch: async (request: CfTypes.Request, env: Env, ctx: CfTypes.ExecutionContext) => {
+    const url = new URL(request.url)
+
+    const searchParams = SyncBackend.matchSyncRequest(request)
+    if (searchParams !== undefined) {
+      return SyncBackend.handleSyncRequest({
+        request,
+        searchParams,
+        env,
+        ctx,
+        syncBackendBinding: 'SYNC_BACKEND_DO',
+        headers: {},
+      })
+    }
+
+    if (url.pathname.endsWith('/client-do')) {
+      const storeId = storeIdFromRequest(request)
+      const id = env.CLIENT_DO.idFromName(storeId)
+      return env.CLIENT_DO.get(id).fetch(request)
+    }
+
+    return new Response('Not found', { status: 404 }) as unknown as CfTypes.Response
+  },
+} satisfies SyncBackend.CFWorker<Env>
+```
+
+### `reference/platform-adapters/cloudflare/env.ts`
+
+```ts filename="reference/platform-adapters/cloudflare/env.ts"
+
+export type Env = {
+  CLIENT_DO: CfTypes.DurableObjectNamespace<ClientDoWithRpcCallback>
+  SYNC_BACKEND_DO: CfTypes.DurableObjectNamespace<SyncBackendRpcInterface>
+  DB: CfTypes.D1Database
+}
+```
+
+### `reference/platform-adapters/cloudflare/shared.ts`
+
+```ts filename="reference/platform-adapters/cloudflare/shared.ts"
+
+export const storeIdFromRequest = (request: CfTypes.Request) => {
+  const url = new URL(request.url)
+  const storeId = url.searchParams.get('storeId')
+
+  if (storeId === null) {
+    throw new Error('storeId is required in URL search params')
+  }
+
+  return storeId
+}
+```
+
+## API reference
+
+### `createStoreDoPromise(options)`
+
+Creates a LiveStore instance inside a Durable Object.
+
+**Options:**
+- `schema` – LiveStore schema definition
+- `storeId` – Unique identifier for the store
+- `clientId` – Client identifier
+- `sessionId` – Session identifier (use `nanoid()`)
+- `durableObject` – Context about the Durable Object hosting the store:
+  - `state` – Durable Object state handle (for example `this.ctx`)
+  - `env` – Environment bindings for the Durable Object
+  - `bindingName` – Name other workers use to reach this Durable Object
+- `syncBackendStub` – Durable Object stub used to reach the sync backend
+- `livePull` – Enable real-time updates (default: `false`)
+- `resetPersistence` – Drop LiveStore state/eventlog persistence before booting (development only, default: `false`)
+- `logger?` – Optional Effect logger layer to customize formatting/output
+- `logLevel?` – Optional minimum log level (use `LogLevel.None` to disable logs)
+
+### `syncUpdateRpc(payload)`
+
+Client Durable Objects must implement this method so the sync backend can deliver live updates. `createStoreDoPromise` wires it up automatically—just forward the payload to `handleSyncUpdateRpc` (see the client Durable Object example above).
+
+## Resetting LiveStore persistence (development only)
+
+When iterating locally, you can instruct the adapter to wipe the Durable Object’s LiveStore databases before booting by enabling `resetPersistence`. Guard this behind a protected route or admin token.
+
+## `reference/platform-adapters/cloudflare/reset.ts`
+
+```ts filename="reference/platform-adapters/cloudflare/reset.ts"
+
+export const maybeResetStore = async ({
+  request,
+  env,
+  ctx,
+}: {
+  request: Request
+  env: Env
+  ctx: CfTypes.DurableObjectState
+}) => {
+  const url = new URL(request.url)
+  const shouldReset = url.pathname === '/internal/livestore-dev-reset'
+
+  const storeId = url.searchParams.get('storeId') ?? nanoid()
+
+  const store = await createStoreDoPromise({
+    schema,
+    storeId,
+    clientId: 'client-do',
+    sessionId: nanoid(),
+    durableObject: { ctx, env, bindingName: 'CLIENT_DO' },
+    syncBackendStub: env.SYNC_BACKEND_DO.get(env.SYNC_BACKEND_DO.idFromName(storeId)),
+    livePull: true,
+    resetPersistence: shouldReset,
+  })
+
+  return store
+}
+```
+
+### `reference/platform-adapters/cloudflare/env.ts`
+
+```ts filename="reference/platform-adapters/cloudflare/env.ts"
+
+export type Env = {
+  CLIENT_DO: CfTypes.DurableObjectNamespace<ClientDoWithRpcCallback>
+  SYNC_BACKEND_DO: CfTypes.DurableObjectNamespace<SyncBackendRpcInterface>
+  DB: CfTypes.D1Database
+}
+```
+
+### `reference/platform-adapters/cloudflare/schema.ts`
+
+```ts filename="reference/platform-adapters/cloudflare/schema.ts"
+
+export const tables = {
+  todos: State.SQLite.table({
+    name: 'todos',
+    columns: {
+      id: State.SQLite.text({ primaryKey: true }),
+      text: State.SQLite.text({ default: '' }),
+      completed: State.SQLite.boolean({ default: false }),
+      deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
+    },
+  }),
+}
+
+export const events = {
+  todoCreated: Events.synced({
+    name: 'v1.TodoCreated',
+    schema: Schema.Struct({ id: Schema.String, text: Schema.String }),
+  }),
+  todoCompleted: Events.synced({
+    name: 'v1.TodoCompleted',
+    schema: Schema.Struct({ id: Schema.String }),
+  }),
+  todoUncompleted: Events.synced({
+    name: 'v1.TodoUncompleted',
+    schema: Schema.Struct({ id: Schema.String }),
+  }),
+  todoDeleted: Events.synced({
+    name: 'v1.TodoDeleted',
+    schema: Schema.Struct({ id: Schema.String, deletedAt: Schema.Date }),
+  }),
+  todoClearedCompleted: Events.synced({
+    name: 'v1.TodoClearedCompleted',
+    schema: Schema.Struct({ deletedAt: Schema.Date }),
+  }),
+}
+
+const materializers = State.SQLite.materializers(events, {
+  'v1.TodoCreated': ({ id, text }) => tables.todos.insert({ id, text, completed: false }),
+  'v1.TodoCompleted': ({ id }) => tables.todos.update({ completed: true }).where({ id }),
+  'v1.TodoUncompleted': ({ id }) => tables.todos.update({ completed: false }).where({ id }),
+  'v1.TodoDeleted': ({ id, deletedAt }) => tables.todos.update({ deletedAt }).where({ id }),
+  'v1.TodoClearedCompleted': ({ deletedAt }) => tables.todos.update({ deletedAt }).where({ completed: true }),
+})
+
+const state = State.SQLite.makeState({ tables, materializers })
+
+export const schema = makeSchema({ events, state })
+```
+
+:::caution
+Resetting persistence deletes all LiveStore state and eventlog data stored inside the Durable Object. Only expose this behaviour in guarded development flows and never to production traffic.
+:::
+
+## Advanced features
+
+- Use `livePull: true` to receive push-based updates via Durable Object RPC callbacks.
+- Subscribe to data changes inside the Durable Object to trigger side effects (see the client Durable Object example).
+- Wire additional routes in the worker fetch handler to expose debugging endpoints or admin operations.
+
+For sync backend-related APIs like `makeDurableObject`, `handleSyncRequest`, and `matchSyncRequest`, see the [Cloudflare sync provider documentation](/reference/syncing/sync-provider/cloudflare/).

package/docs/reference/platform-adapters/electron-adapter/index.md

@@ -0,0 +1,15 @@
+# Electron Adapter
+
+## Using LiveStore with Electron
+
+LiveStore can already be used in Electron through the [web adapter](/reference/platform-adapters/web-adapter), which works perfectly fine for most use cases. The web adapter leverages the browser APIs available in Electron's renderer process, providing full LiveStore functionality including reactive queries, offline-first operation, and sync capabilities.
+
+## Native Electron Adapter
+
+While the web adapter works well, there is room for further improvement through a dedicated native Electron adapter. A native adapter would leverage Electron's unique capabilities including:
+
+- **Transparent database file persistence** - Direct file system access instead of browser storage abstractions (IndexedDB/OPFS)
+- **Performance improvements** - Native SQLite bindings via Node.js integration
+- **Better integration with Electron's main process** - Coordination between main and renderer processes
+
+Development of the native Electron adapter is tracked in [this GitHub issue](https://github.com/livestorejs/livestore/issues/296). Contributors are welcome to help with the implementation, and sponsorship opportunities are available to accelerate development of this adapter.

package/docs/reference/platform-adapters/expo-adapter/index.md

@@ -0,0 +1,43 @@
+# Expo Adapter
+
+## Notes on Android
+
+- By default, Android requires `https` (including WebSocket connections) when communicating with a sync backend.
+
+To allow for `http` / `ws`, you can run `expo install expo-build-properties` and add the following to your `app.json` (see [here](https://docs.expo.dev/versions/latest/sdk/build-properties/#pluginconfigtypeandroid) for more information):
+
+```json
+{
+  "expo": {
+    "plugins": [
+      "expo-build-properties",
+      {
+        "android": {
+          "usesCleartextTraffic": true
+        },
+        "ios": {}
+      }
+    ]
+  }
+}
+```
+
+## Resetting local persistence
+
+When iterating locally you can ask the Expo adapter to drop the on-device state and eventlog databases before booting:
+
+## `reference/platform-adapters/expo-adapter/reset-persistence.ts`
+
+```ts filename="reference/platform-adapters/expo-adapter/reset-persistence.ts"
+
+const resetPersistence = process.env.EXPO_PUBLIC_LIVESTORE_RESET === 'true'
+
+const _adapter = makePersistedAdapter({
+  storage: { subDirectory: 'dev' },
+  resetPersistence,
+})
+```
+
+:::caution
+Resetting persistence deletes all local LiveStore data for the configured store. This only clears data on the device and does not touch any connected sync backend. Make sure this flag is disabled in production builds.
+:::

package/docs/reference/platform-adapters/node-adapter/index.md

@@ -0,0 +1,160 @@
+# Node Adapter
+
+Works with Node.js, Bun and Deno.
+
+## Example
+
+## `reference/platform-adapters/node-adapter/adapter.ts`
+
+```ts filename="reference/platform-adapters/node-adapter/adapter.ts"
+/** biome-ignore-all lint/correctness/noUnusedVariables: docs snippet keeps inline adapter */
+// ---cut---
+
+const adapter = makeAdapter({
+  storage: { type: 'fs' },
+  // or in-memory:
+  // storage: { type: 'in-memory' },
+  sync: { backend: makeWsSync({ url: 'ws://localhost:8787' }) },
+  // To enable devtools:
+  // devtools: { schemaPath: new URL('./schema.ts', import.meta.url) },
+})
+```
+
+## Resetting local persistence
+
+During development you can instruct the adapter to wipe the locally persisted state and eventlog databases on startup:
+
+## `reference/platform-adapters/node-adapter/reset-persistence.ts`
+
+```ts filename="reference/platform-adapters/node-adapter/reset-persistence.ts"
+/** biome-ignore-all lint/correctness/noUnusedVariables: docs snippet keeps inline adapter */
+// ---cut---
+
+const resetPersistence = process.env.NODE_ENV !== 'production' && Boolean(process.env.RESET_LIVESTORE)
+
+const adapter = makeAdapter({
+  storage: { type: 'fs' },
+  resetPersistence,
+})
+```
+
+:::caution
+This will delete all local data for the given `storeId` and `clientId`. It only clears local persistence and does not reset any connected sync backend. Only enable it for debugging scenarios.
+:::
+
+### Worker adapter
+
+The worker adapter can be used for more advanced scenarios where it's preferable to reduce the load of the main thread and run persistence/syncing in a worker thread.
+
+## `reference/platform-adapters/node-adapter/worker-main.ts`
+
+```ts filename="reference/platform-adapters/node-adapter/worker-main.ts"
+/** biome-ignore-all lint/correctness/noUnusedVariables: snippet keeps adapter inline for docs */
+// ---cut---
+
+const adapter = makeWorkerAdapter({
+  storage: { type: 'fs' },
+  workerUrl: new URL('./livestore.worker.js', import.meta.url),
+})
+```
+
+## `reference/platform-adapters/node-adapter/worker-worker.ts`
+
+```ts filename="reference/platform-adapters/node-adapter/worker-worker.ts"
+
+makeWorker({
+  schema,
+  sync: { backend: makeWsSync({ url: 'ws://localhost:8787' }) },
+})
+```
+
+### `reference/platform-adapters/node-adapter/schema.ts`
+
+```ts filename="reference/platform-adapters/node-adapter/schema.ts"
+
+const tables = {
+  todos: State.SQLite.table({
+    name: 'todos',
+    columns: {
+      id: State.SQLite.text({ primaryKey: true }),
+      text: State.SQLite.text(),
+      completed: State.SQLite.boolean({ default: false }),
+    },
+  }),
+} as const
+
+const events = {
+  todoCreated: Events.synced({
+    name: 'v1.TodoCreated',
+    schema: Schema.Struct({ id: Schema.String, text: Schema.String }),
+  }),
+} as const
+
+const materializers = State.SQLite.materializers(events, {
+  [events.todoCreated.name]: defineMaterializer(events.todoCreated, ({ id, text }) =>
+    tables.todos.insert({ id, text, completed: false }),
+  ),
+})
+
+const state = State.SQLite.makeState({ tables, materializers })
+
+export const schema = makeSchema({ events, state })
+```
+
+#### Logging
+
+You can control what the Node worker logs and how it's formatted.
+Pass two optional options to `makeWorker`:
+
+- `logger` — where/format of logs (e.g. pretty console output)
+- `logLevel` — how verbose logs are (`LogLevel.None` silences logs)
+
+## `reference/platform-adapters/node-adapter/worker-logging.ts`
+
+```ts filename="reference/platform-adapters/node-adapter/worker-logging.ts"
+
+makeWorker({
+  schema,
+  // readable console output by thread name
+  logger: Logger.prettyWithThread('livestore-node-leader-thread'),
+  // choose verbosity: None | Error | Warning | Info | Debug
+  logLevel: LogLevel.Info,
+})
+```
+
+### `reference/platform-adapters/node-adapter/schema.ts`
+
+```ts filename="reference/platform-adapters/node-adapter/schema.ts"
+
+const tables = {
+  todos: State.SQLite.table({
+    name: 'todos',
+    columns: {
+      id: State.SQLite.text({ primaryKey: true }),
+      text: State.SQLite.text(),
+      completed: State.SQLite.boolean({ default: false }),
+    },
+  }),
+} as const
+
+const events = {
+  todoCreated: Events.synced({
+    name: 'v1.TodoCreated',
+    schema: Schema.Struct({ id: Schema.String, text: Schema.String }),
+  }),
+} as const
+
+const materializers = State.SQLite.materializers(events, {
+  [events.todoCreated.name]: defineMaterializer(events.todoCreated, ({ id, text }) =>
+    tables.todos.insert({ id, text, completed: false }),
+  ),
+})
+
+const state = State.SQLite.makeState({ tables, materializers })
+
+export const schema = makeSchema({ events, state })
+```
+
+Tips:
+- Use `LogLevel.None` to keep test output quiet.
+- Keep the default (Debug) when diagnosing issues.

package/docs/reference/platform-adapters/tauri-adapter/index.md

@@ -0,0 +1,15 @@
+# Tauri Adapter
+
+## Native Tauri Adapter
+
+While LiveStore doesn't yet support a native Tauri adapter (see [this issue](https://github.com/livestorejs/livestore/issues/125) for more details), you can already use the [web adapter](./web-adapter.md) with Tauri.
+
+The goal of the native Tauri adapter is for LiveStore to leverage native platform APIs and capabilities including:
+
+- Native file system access (instead of going through the browser abstraction layer)
+- Background sync capabilities
+- ...
+
+## Example using the web adapter
+
+See this example of a Tauri app using the web adapter: [tauri-todomvc-sync-cf](https://github.com/bohdanbirdie/tauri-todomvc-sync-cf)