@livestore/adapter-web 0.4.0-dev.8 → 0.4.0

package/package.json

@@ -1,37 +1,75 @@
 {
   "name": "@livestore/adapter-web",
-  "version": "0.4.0-dev.8",
+  "version": "0.4.0",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/livestorejs/livestore.git"
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "src"
+  ],
   "type": "module",
   "sideEffects": false,
   "exports": {
     ".": "./dist/index.js",
     "./worker": "./dist/web-worker/leader-worker/make-leader-worker.js",
     "./worker-vite-dev-polyfill": "./dist/web-worker/vite-dev-polyfill.js",
-    "./shared-worker": "./dist/web-worker/shared-worker/make-shared-worker.js",
-    "./sqlite": "./dist/sqlite/index.js",
-    "./opfs-utils": "./dist/opfs-utils.js"
+    "./shared-worker": "./dist/web-worker/shared-worker/make-shared-worker.js"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
     "@opentelemetry/api": "1.9.0",
-    "@livestore/common": "0.4.0-dev.8",
-    "@livestore/devtools-web-common": "0.4.0-dev.8",
-    "@livestore/sqlite-wasm": "0.4.0-dev.8",
-    "@livestore/utils": "0.4.0-dev.8",
-    "@livestore/webmesh": "0.4.0-dev.8"
+    "@livestore/common": "^0.4.0",
+    "@livestore/devtools-web-common": "^0.4.0",
+    "@livestore/sqlite-wasm": "^0.4.0",
+    "@livestore/utils": "^0.4.0",
+    "@livestore/webmesh": "^0.4.0"
   },
   "devDependencies": {
     "@types/chrome": "0.1.4",
-    "@types/wicg-file-system-access": "^2023.10.6",
+    "@types/wicg-file-system-access": "2023.10.6",
     "vitest": "3.2.4"
   },
-  "files": [
-    "package.json",
-    "src",
-    "dist"
-  ],
-  "license": "Apache-2.0",
-  "publishConfig": {
-    "access": "public"
+  "peerDependencies": {
+    "@effect/ai": "^0.35.0",
+    "@effect/cli": "^0.75.1",
+    "@effect/cluster": "^0.58.2",
+    "@effect/experimental": "^0.60.0",
+    "@effect/opentelemetry": "^0.63.0",
+    "@effect/platform": "^0.96.1",
+    "@effect/platform-browser": "^0.76.0",
+    "@effect/platform-bun": "^0.89.0",
+    "@effect/platform-node": "^0.106.0",
+    "@effect/printer": "^0.49.0",
+    "@effect/printer-ansi": "^0.49.0",
+    "@effect/rpc": "^0.75.1",
+    "@effect/sql": "^0.51.1",
+    "@effect/typeclass": "^0.40.0",
+    "@effect/vitest": "^0.29.0",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/resources": "^2.2.0",
+    "@standard-schema/spec": "^1.1.0",
+    "effect": "^3.21.2"
+  },
+  "$genie": {
+    "source": "package.json.genie.ts",
+    "warning": "DO NOT EDIT - changes will be overwritten",
+    "workspaceClosureDirs": [
+      "packages/@livestore/adapter-web",
+      "packages/@livestore/common",
+      "packages/@livestore/common-cf",
+      "packages/@livestore/devtools-web-common",
+      "packages/@livestore/sqlite-wasm",
+      "packages/@livestore/utils",
+      "packages/@livestore/utils-dev",
+      "packages/@livestore/wa-sqlite",
+      "packages/@livestore/webmesh"
+    ]
   },
   "scripts": {
     "test": "echo No tests yet"

package/src/in-memory/in-memory-adapter.ts

@@ -6,29 +6,33 @@ import {
   makeClientSession,
   migrateDb,
   type SyncOptions,
-  UnexpectedError,
+  UnknownError,
 } from '@livestore/common'
 import type { DevtoolsOptions, LeaderSqliteDb } from '@livestore/common/leader-thread'
-import { configureConnection, Eventlog, LeaderThreadCtx, makeLeaderThreadLayer } from '@livestore/common/leader-thread'
+import {
+  configureConnection,
+  Eventlog,
+  LeaderThreadCtx,
+  makeLeaderThreadLayer,
+  streamEventsWithSyncState,
+} from '@livestore/common/leader-thread'
 import type { LiveStoreSchema } from '@livestore/common/schema'
 import { LiveStoreEvent } from '@livestore/common/schema'
 import * as DevtoolsWeb from '@livestore/devtools-web-common/web-channel'
 import type * as WebmeshWorker from '@livestore/devtools-web-common/worker'
 import type { MakeWebSqliteDb } from '@livestore/sqlite-wasm/browser'
 import { sqliteDbFactory } from '@livestore/sqlite-wasm/browser'
-import { loadSqlite3Wasm } from '@livestore/sqlite-wasm/load-wasm'
 import { tryAsFunctionAndNew } from '@livestore/utils'
-import type { Schema, Scope } from '@livestore/utils/effect'
-import { BrowserWorker, Effect, FetchHttpClient, Fiber, Layer, SubscriptionRef, Worker } from '@livestore/utils/effect'
+import type { Scope } from '@livestore/utils/effect'
+import { Effect, FetchHttpClient, Fiber, Layer, type Schema, SubscriptionRef, Worker } from '@livestore/utils/effect'
+import { BrowserWorker } from '@livestore/utils/effect/browser'
 import { nanoid } from '@livestore/utils/nanoid'
 import * as Webmesh from '@livestore/webmesh'
 
 import { connectWebmeshNodeClientSession } from '../web-worker/client-session/client-session-devtools.ts'
+import { loadSqlite3 } from '../web-worker/client-session/sqlite-loader.ts'
 import { makeShutdownChannel } from '../web-worker/common/shutdown-channel.ts'
 
-// NOTE we're starting to initialize the sqlite wasm binary here to speed things up
-const sqlite3Promise = loadSqlite3Wasm()
-
 export interface InMemoryAdapterOptions {
   importSnapshot?: Uint8Array<ArrayBuffer>
   sync?: SyncOptions
@@ -55,32 +59,76 @@ export interface InMemoryAdapterOptions {
   }
 }
 
+/**
+ * Creates a web-only in-memory LiveStore adapter.
+ *
+ * This adapter runs entirely in memory with no persistence. Ideal for:
+ * - Unit tests and integration tests
+ * - Sandboxes and demos
+ * - Ephemeral sessions where persistence isn't needed
+ *
+ * **Characteristics:**
+ * - Fast, zero I/O overhead
+ * - Works in all browser contexts: Window, WebWorker, SharedWorker, ServiceWorker
+ * - Supports optional sync backends for real-time collaboration
+ * - No data persists after page reload
+ *
+ * For persistent storage, use `makePersistedAdapter` instead.
+ *
+ * @example
+ * ```ts
+ * import { makeInMemoryAdapter } from '@livestore/adapter-web'
+ *
+ * const adapter = makeInMemoryAdapter()
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With sync backend for real-time collaboration
+ * import { makeInMemoryAdapter } from '@livestore/adapter-web'
+ * import { makeWsSync } from '@livestore/sync-cf/client'
+ *
+ * const adapter = makeInMemoryAdapter({
+ *   sync: {
+ *     backend: makeWsSync({ url: 'wss://api.example.com/sync' }),
+ *   },
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Pre-populate with existing data
+ * const adapter = makeInMemoryAdapter({
+ *   importSnapshot: existingDbSnapshot,
+ * })
+ * ```
+ */
 export const makeInMemoryAdapter =
   (options: InMemoryAdapterOptions = {}): Adapter =>
   (adapterArgs) =>
     Effect.gen(function* () {
-      const { schema, shutdown, syncPayload, storeId, devtoolsEnabled } = adapterArgs
-      const sqlite3 = yield* Effect.promise(() => sqlite3Promise)
+      const { schema, shutdown, syncPayloadEncoded, syncPayloadSchema, storeId, devtoolsEnabled } = adapterArgs
+      const sqlite3 = yield* Effect.promise(() => loadSqlite3())
 
       const sqliteDb = yield* sqliteDbFactory({ sqlite3 })({ _tag: 'in-memory' })
 
       const clientId = options.clientId ?? nanoid(6)
       const sessionId = options.sessionId ?? nanoid(6)
 
-      const sharedWebWorker = options.devtools?.sharedWorker
+      const sharedWebWorker = options.devtools?.sharedWorker !== undefined
         ? tryAsFunctionAndNew(options.devtools.sharedWorker, {
             name: `livestore-shared-worker-${storeId}`,
           })
         : undefined
 
-      const sharedWorkerFiber = sharedWebWorker
+      const sharedWorkerFiber = sharedWebWorker !== undefined
         ? yield* Worker.makePoolSerialized<typeof WebmeshWorker.Schema.Request.Type>({
             size: 1,
             concurrency: 100,
           }).pipe(
             Effect.provide(BrowserWorker.layer(() => sharedWebWorker)),
             Effect.tapCauseLogPretty,
-            UnexpectedError.mapToUnexpectedError,
+            UnknownError.mapToUnknownError,
             Effect.forkScoped,
           )
         : undefined
@@ -91,7 +139,8 @@ export const makeInMemoryAdapter =
         clientId,
         makeSqliteDb: sqliteDbFactory({ sqlite3 }),
         syncOptions: options.sync,
-        syncPayload,
+        syncPayloadEncoded,
+        syncPayloadSchema,
         importSnapshot: options.importSnapshot,
         devtoolsEnabled,
         sharedWorkerFiber,
@@ -111,6 +160,8 @@ export const makeInMemoryAdapter =
         lockStatus,
         shutdown,
         webmeshMode: 'direct',
+        // Can be undefined in Node.js
+        origin: globalThis.location?.origin,
         connectWebmeshNode: ({ sessionInfo, webmeshNode }) =>
           Effect.gen(function* () {
             if (sharedWorkerFiber === undefined || devtoolsEnabled === false) {
@@ -132,7 +183,7 @@ export const makeInMemoryAdapter =
       })
 
       return clientSession
-    }).pipe(UnexpectedError.mapToUnexpectedError, Effect.provide(FetchHttpClient.layer))
+    }).pipe(UnknownError.mapToUnknownError, Effect.provide(FetchHttpClient.layer))
 
 export interface MakeLeaderThreadArgs {
   schema: LiveStoreSchema
@@ -140,7 +191,8 @@ export interface MakeLeaderThreadArgs {
   clientId: string
   makeSqliteDb: MakeWebSqliteDb
   syncOptions: SyncOptions | undefined
-  syncPayload: Schema.JsonValue | undefined
+  syncPayloadEncoded: Schema.JsonValue | undefined
+  syncPayloadSchema: Schema.Schema<any> | undefined
   importSnapshot: Uint8Array<ArrayBuffer> | undefined
   devtoolsEnabled: boolean
   sharedWorkerFiber: SharedWorkerFiber | undefined
@@ -152,13 +204,14 @@ const makeLeaderThread = ({
   clientId,
   makeSqliteDb,
   syncOptions,
-  syncPayload,
+  syncPayloadEncoded,
+  syncPayloadSchema,
   importSnapshot,
   devtoolsEnabled,
   sharedWorkerFiber,
 }: MakeLeaderThreadArgs) =>
   Effect.gen(function* () {
-    const runtime = yield* Effect.runtime<never>()
+    const runtime = yield* Effect.runtime()
 
     const makeDb = (_kind: 'state' | 'eventlog') => {
       return makeSqliteDb({
@@ -173,7 +226,7 @@ const makeLeaderThread = ({
     // Might involve some async work, so we're running them concurrently
     const [dbState, dbEventlog] = yield* Effect.all([makeDb('state'), makeDb('eventlog')], { concurrency: 2 })
 
-    if (importSnapshot) {
+    if (importSnapshot !== undefined) {
       dbState.import(importSnapshot)
 
       const _migrationsReport = yield* migrateDb({ db: dbState, schema })
@@ -199,12 +252,14 @@ const makeLeaderThread = ({
         dbEventlog,
         devtoolsOptions,
         shutdownChannel,
-        syncPayload,
+        syncPayloadEncoded,
+        syncPayloadSchema,
       }),
     )
 
     return yield* Effect.gen(function* () {
-      const { dbState, dbEventlog, syncProcessor, extraIncomingMessagesQueue, initialState } = yield* LeaderThreadCtx
+      const { dbState, dbEventlog, syncProcessor, extraIncomingMessagesQueue, initialState, networkStatus } =
+        yield* LeaderThreadCtx
 
       const initialLeaderHead = Eventlog.getClientHeadFromDb(dbEventlog)
 
@@ -213,15 +268,26 @@ const makeLeaderThread = ({
           pull: ({ cursor }) => syncProcessor.pull({ cursor }),
           push: (batch) =>
             syncProcessor.push(
-              batch.map((item) => new LiveStoreEvent.EncodedWithMeta(item)),
+              batch.map((item) => new LiveStoreEvent.Client.EncodedWithMeta(item)),
               { waitForProcessing: true },
             ),
+          stream: (options) =>
+            streamEventsWithSyncState({
+              dbEventlog,
+              syncState: syncProcessor.syncState,
+              options,
+            }),
+        },
+        initialState: {
+          leaderHead: initialLeaderHead,
+          migrationsReport: initialState.migrationsReport,
+          storageMode: 'in-memory',
         },
-        initialState: { leaderHead: initialLeaderHead, migrationsReport: initialState.migrationsReport },
         export: Effect.sync(() => dbState.export()),
         getEventlogData: Effect.sync(() => dbEventlog.export()),
-        getSyncState: syncProcessor.syncState,
+        syncState: syncProcessor.syncState,
         sendDevtoolsMessage: (message) => extraIncomingMessagesQueue.offer(message),
+        networkStatus,
       })
 
       const initialSnapshot = dbState.export()
@@ -232,7 +298,7 @@ const makeLeaderThread = ({
 
 type SharedWorkerFiber = Fiber.Fiber<
   Worker.SerializedWorkerPool<typeof WebmeshWorker.Schema.Request.Type>,
-  UnexpectedError
+  UnknownError
 >
 
 const makeDevtoolsOptions = ({
@@ -249,7 +315,7 @@ const makeDevtoolsOptions = ({
   dbEventlog: LeaderSqliteDb
   storeId: string
   clientId: string
-}): Effect.Effect<DevtoolsOptions, UnexpectedError, Scope.Scope> =>
+}): Effect.Effect<DevtoolsOptions, UnknownError, Scope.Scope> =>
   Effect.gen(function* () {
     if (devtoolsEnabled === false || sharedWorkerFiber === undefined) {
       return { enabled: false }

package/src/index.ts

@@ -1,3 +1,17 @@
 export { makeInMemoryAdapter } from './in-memory/in-memory-adapter.ts'
-export { makePersistedAdapter, type WebAdapterOptions } from './web-worker/client-session/persisted-adapter.ts'
+/**
+ * Single-tab adapter for browsers without SharedWorker support (e.g. Android Chrome).
+ *
+ * In most cases, you should use `makePersistedAdapter` instead, which automatically
+ * falls back to single-tab mode when SharedWorker is unavailable.
+ *
+ * @see https://github.com/livestorejs/livestore/issues/321
+ * @see https://issues.chromium.org/issues/40290702
+ */
+export { makeSingleTabAdapter, type SingleTabAdapterOptions } from './single-tab/mod.ts'
+export {
+  canUseSharedWorker,
+  makePersistedAdapter,
+  type WebAdapterOptions,
+} from './web-worker/client-session/persisted-adapter.ts'
 export * as WorkerSchema from './web-worker/common/worker-schema.ts'

package/src/single-tab/mod.ts

@@ -0,0 +1,15 @@
+/**
+ * Single-tab adapter module for browsers without SharedWorker support.
+ *
+ * **NOTE**: This module exists as a fallback for Android Chrome and similar browsers
+ * that don't support SharedWorker. It is intended to be deprecated and removed once
+ * SharedWorker support is available in these browsers.
+ *
+ * Track progress:
+ * - LiveStore issue: https://github.com/livestorejs/livestore/issues/321
+ * - Chromium bug: https://issues.chromium.org/issues/40290702
+ *
+ * @module
+ */
+
+export { makeSingleTabAdapter, type SingleTabAdapterOptions } from './single-tab-adapter.ts'