@livestore/adapter-web 0.4.0-dev.2 → 0.4.0-dev.21

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,12 +59,56 @@ 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' })
 
@@ -80,7 +128,7 @@ export const makeInMemoryAdapter =
           }).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,7 +204,8 @@ const makeLeaderThread = ({
   clientId,
   makeSqliteDb,
   syncOptions,
-  syncPayload,
+  syncPayloadEncoded,
+  syncPayloadSchema,
   importSnapshot,
   devtoolsEnabled,
   sharedWorkerFiber,
@@ -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,22 @@ 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 },
         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 +294,7 @@ const makeLeaderThread = ({
 
 type SharedWorkerFiber = Fiber.Fiber<
   Worker.SerializedWorkerPool<typeof WebmeshWorker.Schema.Request.Type>,
-  UnexpectedError
+  UnknownError
 >
 
 const makeDevtoolsOptions = ({
@@ -249,7 +311,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/web-worker/ambient.d.ts

@@ -1,23 +1,3 @@
-// TODO remove OPFS stuff
-// https://developer.mozilla.org/en-US/docs/Web/API/FileSystemSyncAccessHandle
-interface FileSystemSyncAccessHandle {
-  close: () => void
-  flush: () => Promise<void>
-  getSize: () => number
-  read: (buffer: ArrayBuffer, options?: FileSystemReadWriteOptions) => number
-  truncate: (newSize: number) => void
-  write: (buffer: ArrayBuffer, options?: FileSystemReadWriteOptions) => number
-  seek: (offset: number) => void
-}
-
-interface FileSystemReadWriteOptions {
-  at?: number
-}
-
-interface FileSystemFileHandle {
-  createSyncAccessHandle: () => Promise<FileSystemSyncAccessHandle>
-}
-
 // TODO bring back when Vite limitation is resolved https://github.com/vitejs/vite/issues/8427
 // declare module '*?sharedworker' {
 //   const sharedWorkerConstructor: {
@@ -26,11 +6,14 @@ interface FileSystemFileHandle {
 //   export default sharedWorkerConstructor
 // }
 
+declare interface ImportMetaEnv {
+  readonly SSR?: string | boolean
+  readonly DEV: boolean | undefined
+  readonly VITE_LIVESTORE_EXPERIMENTAL_SYNC_NEXT: boolean | undefined
+}
+
 declare interface ImportMeta {
-  env: {
-    DEV: boolean | undefined
-    VITE_LIVESTORE_EXPERIMENTAL_SYNC_NEXT: boolean | undefined
-  }
+  readonly env: ImportMetaEnv
 }
 
 declare var __debugLiveStoreUtils: any

package/src/web-worker/client-session/client-session-devtools.ts

@@ -1,9 +1,10 @@
-import { Devtools } from '@livestore/common'
+import { Devtools, liveStoreVersion } from '@livestore/common'
 import type { LiveStoreSchema } from '@livestore/common/schema'
 import * as DevtoolsWeb from '@livestore/devtools-web-common/web-channel'
 import { isDevEnv } from '@livestore/utils'
 import type { Worker } from '@livestore/utils/effect'
-import { Effect, Stream, WebChannel } from '@livestore/utils/effect'
+import { Effect, Stream } from '@livestore/utils/effect'
+import { WebChannelBrowser } from '@livestore/utils/effect/browser'
 import * as Webmesh from '@livestore/webmesh'
 
 export const logDevtoolsUrl = ({
@@ -30,6 +31,20 @@ export const logDevtoolsUrl = ({
           const url = `${devtoolsBaseUrl}/web/${storeId}/${clientId}/${sessionId}/${schema.devtools.alias}`
           yield* Effect.log(`[@livestore/adapter-web] Devtools ready on ${url}`)
         }
+
+        // Check for DevTools Chrome extension presence via iframe container the extension injects
+        const hasExt = document.querySelector('[id^="livestore-devtools-iframe-"]') !== null
+        if (!hasExt) {
+          const g = globalThis as { __livestoreDevtoolsChromeNoticeShown?: boolean }
+          if (g.__livestoreDevtoolsChromeNoticeShown !== true) {
+            g.__livestoreDevtoolsChromeNoticeShown = true
+
+            const urlToLog = `https://github.com/livestorejs/livestore/releases/download/v${liveStoreVersion}/livestore-devtools-chrome-${liveStoreVersion}.zip`
+            yield* Effect.log(
+              `[@livestore/adapter-web] LiveStore DevTools Chrome extension not detected. Install v${liveStoreVersion}: ${urlToLog}`,
+            )
+          }
+        }
       }
     }
   }).pipe(Effect.withSpan('@livestore/adapter-web:client-session:devtools:logDevtoolsUrl'))
@@ -69,7 +84,7 @@ export const connectWebmeshNodeClientSession = Effect.fn(function* ({
 
       const contentscriptMainNodeName = DevtoolsWeb.makeNodeName.browserExtension.contentscriptMain(tabId)
 
-      const contentscriptMainChannel = yield* WebChannel.windowChannel({
+      const contentscriptMainChannel = yield* WebChannelBrowser.windowChannel({
         listenWindow: window,
         sendWindow: window,
         schema: Webmesh.WebmeshSchema.Packet,

package/src/web-worker/client-session/persisted-adapter.ts

@@ -5,48 +5,46 @@ import {
   makeClientSession,
   StoreInterrupted,
   sessionChangesetMetaTable,
-  UnexpectedError,
+  UnknownError,
 } from '@livestore/common'
 // TODO bring back - this currently doesn't work due to https://github.com/vitejs/vite/issues/8427
 // NOTE We're using a non-relative import here for Vite to properly resolve the import during app builds
 // import LiveStoreSharedWorker from '@livestore/adapter-web/internal-shared-worker?sharedworker'
 import { EventSequenceNumber } from '@livestore/common/schema'
 import { sqliteDbFactory } from '@livestore/sqlite-wasm/browser'
-import { loadSqlite3Wasm } from '@livestore/sqlite-wasm/load-wasm'
 import { isDevEnv, shouldNeverHappen, tryAsFunctionAndNew } from '@livestore/utils'
 import {
-  BrowserWorker,
   Cause,
   Deferred,
   Effect,
   Exit,
   Fiber,
+  Layer,
   ParseResult,
   Queue,
   Schema,
   Stream,
+  Subscribable,
   SubscriptionRef,
-  WebLock,
   Worker,
   WorkerError,
 } from '@livestore/utils/effect'
+import { BrowserWorker, Opfs, WebLock } from '@livestore/utils/effect/browser'
 import { nanoid } from '@livestore/utils/nanoid'
-
-import * as OpfsUtils from '../../opfs-utils.ts'
-import { readPersistedAppDbFromClientSession, resetPersistedDataFromClientSession } from '../common/persisted-sqlite.ts'
+import {
+  readPersistedStateDbFromClientSession,
+  resetPersistedDataFromClientSession,
+} from '../common/persisted-sqlite.ts'
 import { makeShutdownChannel } from '../common/shutdown-channel.ts'
 import { DedicatedWorkerDisconnectBroadcast, makeWorkerDisconnectChannel } from '../common/worker-disconnect-channel.ts'
 import * as WorkerSchema from '../common/worker-schema.ts'
 import { connectWebmeshNodeClientSession } from './client-session-devtools.ts'
-
-// NOTE we're starting to initialize the sqlite wasm binary here to speed things up
-const sqlite3Promise = loadSqlite3Wasm()
+import { loadSqlite3 } from './sqlite-loader.ts'
 
 if (isDevEnv()) {
   globalThis.__debugLiveStoreUtils = {
-    opfs: OpfsUtils,
-    runSync: (effect: Effect.Effect<any, any, never>) => Effect.runSync(effect),
-    runFork: (effect: Effect.Effect<any, any, never>) => Effect.runFork(effect),
+    ...globalThis.__debugLiveStoreUtils,
+    opfs: Opfs.debugUtils,
   }
 }
 
@@ -100,6 +98,21 @@ export type WebAdapterOptions = {
      * @default false
      */
     disableFastPath?: boolean
+    /**
+     * Controls whether to wait for the shared worker to be terminated when LiveStore gets shut down.
+     * This prevents a race condition where a new LiveStore instance connects to a shutting-down shared
+     * worker from a previous instance.
+     *
+     * @default false
+     *
+     * @remarks
+     *
+     * In multi-tab scenarios, we don't want to await shared worker termination because the shared worker
+     * won't actually shut down when one tab closes - it stays alive to serve other tabs. Awaiting
+     * termination would cause unnecessary blocking since the termination will never happen until all
+     * tabs are closed.
+     */
+    awaitSharedWorkerTermination?: boolean
   }
 }
 
@@ -124,15 +137,32 @@ export const makePersistedAdapter =
   (options: WebAdapterOptions): Adapter =>
   (adapterArgs) =>
     Effect.gen(function* () {
-      const { schema, storeId, devtoolsEnabled, debugInstanceId, bootStatusQueue, shutdown, syncPayload } = adapterArgs
+      const {
+        schema,
+        storeId,
+        devtoolsEnabled,
+        debugInstanceId,
+        bootStatusQueue,
+        shutdown,
+        syncPayloadSchema: _syncPayloadSchema,
+        syncPayloadEncoded,
+      } = adapterArgs
+
+      // NOTE: The schema travels with the worker bundle (developers call
+      // `makeWorker({ schema, syncPayloadSchema })`). We only keep the
+      // destructured value here to document availability on the client session
+      // side—structured cloning the Effect schema into the worker is not
+      // possible, so we intentionally do not forward it.
+      void _syncPayloadSchema
 
       yield* ensureBrowserRequirements
 
       yield* Queue.offer(bootStatusQueue, { stage: 'loading' })
 
-      const sqlite3 = yield* Effect.promise(() => sqlite3Promise)
+      const sqlite3 = yield* Effect.promise(() => loadSqlite3())
 
       const LIVESTORE_TAB_LOCK = `livestore-tab-lock-${storeId}`
+      const LIVESTORE_SHARED_WORKER_TERMINATION_LOCK = `livestore-shared-worker-termination-lock-${storeId}`
 
       const storageOptions = yield* Schema.decode(WorkerSchema.StorageType)(options.storage)
 
@@ -153,7 +183,15 @@ export const makePersistedAdapter =
       const dataFromFile =
         options.experimental?.disableFastPath === true
           ? undefined
-          : yield* readPersistedAppDbFromClientSession({ storageOptions, storeId, schema })
+          : yield* readPersistedStateDbFromClientSession({ storageOptions, storeId, schema }).pipe(
+              Effect.tapError((error) =>
+                Effect.logDebug('[@livestore/adapter-web:client-session] Could not read persisted state db', error, {
+                  storeId,
+                }),
+              ),
+              // If we get any error here, we return `undefined` to fall back to the slow path
+              Effect.orElseSucceed(() => undefined),
+            )
 
       // The same across all client sessions (i.e. tabs, windows)
       const clientId = options.clientId ?? getPersistedId(`clientId:${storeId}`, 'local')
@@ -175,28 +213,20 @@ export const makePersistedAdapter =
 
       const sharedWebWorker = tryAsFunctionAndNew(options.sharedWorker, { name: `livestore-shared-worker-${storeId}` })
 
+      if (options.experimental?.awaitSharedWorkerTermination) {
+        // Relying on the lock being available is currently the only mechanism we're aware of
+        // to know whether the shared worker has terminated.
+        yield* Effect.addFinalizer(() => WebLock.waitForLock(LIVESTORE_SHARED_WORKER_TERMINATION_LOCK))
+      }
+
+      const sharedWorkerContext = yield* Layer.build(BrowserWorker.layer(() => sharedWebWorker))
       const sharedWorkerFiber = yield* Worker.makePoolSerialized<typeof WorkerSchema.SharedWorkerRequest.Type>({
         size: 1,
         concurrency: 100,
-        initialMessage: () =>
-          new WorkerSchema.SharedWorkerInitialMessage({
-            liveStoreVersion,
-            payload: {
-              _tag: 'FromClientSession',
-              initialMessage: new WorkerSchema.LeaderWorkerInnerInitialMessage({
-                storageOptions,
-                storeId,
-                clientId,
-                devtoolsEnabled,
-                debugInstanceId,
-                syncPayload,
-              }),
-            },
-          }),
       }).pipe(
-        Effect.provide(BrowserWorker.layer(() => sharedWebWorker)),
+        Effect.provide(sharedWorkerContext),
         Effect.tapCauseLogPretty,
-        UnexpectedError.mapToUnexpectedError,
+        UnknownError.mapToUnknownError,
         Effect.tapErrorCause((cause) => shutdown(Exit.failCause(cause))),
         Effect.withSpan('@livestore/adapter-web:client-session:setupSharedWorker'),
         Effect.forkScoped,
@@ -238,7 +268,7 @@ export const makePersistedAdapter =
           initialMessage: () => new WorkerSchema.LeaderWorkerOuterInitialMessage({ port: mc.port1, storeId, clientId }),
         }).pipe(
           Effect.provide(BrowserWorker.layer(() => worker)),
-          UnexpectedError.mapToUnexpectedError,
+          UnknownError.mapToUnknownError,
           Effect.tapErrorCause((cause) => shutdown(Exit.failCause(cause))),
           Effect.withSpan('@livestore/adapter-web:client-session:setupDedicatedWorker'),
           Effect.tapCauseLogPretty,
@@ -248,10 +278,25 @@ export const makePersistedAdapter =
         yield* workerDisconnectChannel.send(DedicatedWorkerDisconnectBroadcast.make({}))
 
         const sharedWorker = yield* Fiber.join(sharedWorkerFiber)
-        yield* sharedWorker.executeEffect(new WorkerSchema.SharedWorkerUpdateMessagePort({ port: mc.port2 })).pipe(
-          UnexpectedError.mapToUnexpectedError,
-          Effect.tapErrorCause((cause) => shutdown(Exit.failCause(cause))),
-        )
+        yield* sharedWorker
+          .executeEffect(
+            new WorkerSchema.SharedWorkerUpdateMessagePort({
+              port: mc.port2,
+              liveStoreVersion,
+              initial: new WorkerSchema.LeaderWorkerInnerInitialMessage({
+                storageOptions,
+                storeId,
+                clientId,
+                devtoolsEnabled,
+                debugInstanceId,
+                syncPayloadEncoded,
+              }),
+            }),
+          )
+          .pipe(
+            UnknownError.mapToUnknownError,
+            Effect.tapErrorCause((cause) => shutdown(Exit.failCause(cause))),
+          )
 
         yield* Deferred.succeed(waitForSharedWorkerInitialized, undefined)
 
@@ -281,7 +326,7 @@ export const makePersistedAdapter =
       const runInWorker = <TReq extends typeof WorkerSchema.SharedWorkerRequest.Type>(
         req: TReq,
       ): TReq extends Schema.WithResult<infer A, infer _I, infer E, infer _EI, infer R>
-        ? Effect.Effect<A, UnexpectedError | E, R>
+        ? Effect.Effect<A, UnknownError | E, R>
         : never =>
         Fiber.join(sharedWorkerFiber).pipe(
           // NOTE we need to wait for the shared worker to be initialized before we can send requests to it
@@ -296,28 +341,28 @@ export const makePersistedAdapter =
           }),
           Effect.withSpan(`@livestore/adapter-web:client-session:runInWorker:${req._tag}`),
           Effect.mapError((cause) =>
-            Schema.is(UnexpectedError)(cause)
+            Schema.is(UnknownError)(cause)
               ? cause
               : ParseResult.isParseError(cause) || Schema.is(WorkerError.WorkerError)(cause)
-                ? new UnexpectedError({ cause })
+                ? new UnknownError({ cause })
                 : cause,
           ),
-          Effect.catchAllDefect((cause) => new UnexpectedError({ cause })),
+          Effect.catchAllDefect((cause) => new UnknownError({ cause })),
         ) as any
 
       const runInWorkerStream = <TReq extends typeof WorkerSchema.SharedWorkerRequest.Type>(
         req: TReq,
       ): TReq extends Schema.WithResult<infer A, infer _I, infer _E, infer _EI, infer R>
-        ? Stream.Stream<A, UnexpectedError, R>
+        ? Stream.Stream<A, UnknownError, R>
         : never =>
         Effect.gen(function* () {
           const sharedWorker = yield* Fiber.join(sharedWorkerFiber)
           return sharedWorker.execute(req as any).pipe(
             Stream.mapError((cause) =>
-              Schema.is(UnexpectedError)(cause)
+              Schema.is(UnknownError)(cause)
                 ? cause
                 : ParseResult.isParseError(cause) || Schema.is(WorkerError.WorkerError)(cause)
-                  ? new UnexpectedError({ cause })
+                  ? new UnknownError({ cause })
                   : cause,
             ),
             Stream.withSpan(`@livestore/adapter-web:client-session:runInWorkerStream:${req._tag}`),
@@ -365,7 +410,7 @@ export const makePersistedAdapter =
       const numberOfTables =
         sqliteDb.select<{ count: number }>(`select count(*) as count from sqlite_master`)[0]?.count ?? 0
       if (numberOfTables === 0) {
-        return yield* UnexpectedError.make({
+        return yield* UnknownError.make({
           cause: `Encountered empty or corrupted database`,
           payload: { snapshotByteLength: initialResult.snapshot.byteLength, storageOptions: options.storage },
         })
@@ -384,12 +429,12 @@ export const makePersistedAdapter =
       )
 
       const initialLeaderHead = initialLeaderHeadRes
-        ? EventSequenceNumber.make({
+        ? EventSequenceNumber.Client.Composite.make({
             global: initialLeaderHeadRes.seqNumGlobal,
             client: initialLeaderHeadRes.seqNumClient,
             rebaseGeneration: initialLeaderHeadRes.seqNumRebaseGeneration,
           })
-        : EventSequenceNumber.ROOT
+        : EventSequenceNumber.Client.ROOT
 
       // console.debug('[@livestore/adapter-web:client-session] initialLeaderHead', initialLeaderHead)
 
@@ -415,7 +460,7 @@ export const makePersistedAdapter =
       const leaderThread: ClientSession['leaderThread'] = {
         export: runInWorker(new WorkerSchema.LeaderWorkerInnerExport()).pipe(
           Effect.timeout(10_000),
-          UnexpectedError.mapToUnexpectedError,
+          UnknownError.mapToUnknownError,
           Effect.withSpan('@livestore/adapter-web:client-session:export'),
         ),
 
@@ -428,26 +473,38 @@ export const makePersistedAdapter =
                 attributes: { batchSize: batch.length },
               }),
             ),
+          stream: (options) =>
+            runInWorkerStream(new WorkerSchema.LeaderWorkerInnerStreamEvents(options)).pipe(
+              Stream.withSpan('@livestore/adapter-web:client-session:streamEvents'),
+              Stream.orDie,
+            ),
         },
 
         initialState: { leaderHead: initialLeaderHead, migrationsReport },
 
         getEventlogData: runInWorker(new WorkerSchema.LeaderWorkerInnerExportEventlog()).pipe(
           Effect.timeout(10_000),
-          UnexpectedError.mapToUnexpectedError,
+          UnknownError.mapToUnknownError,
           Effect.withSpan('@livestore/adapter-web:client-session:getEventlogData'),
         ),
 
-        getSyncState: runInWorker(new WorkerSchema.LeaderWorkerInnerGetLeaderSyncState()).pipe(
-          UnexpectedError.mapToUnexpectedError,
-          Effect.withSpan('@livestore/adapter-web:client-session:getLeaderSyncState'),
-        ),
+        syncState: Subscribable.make({
+          get: runInWorker(new WorkerSchema.LeaderWorkerInnerGetLeaderSyncState()).pipe(
+            UnknownError.mapToUnknownError,
+            Effect.withSpan('@livestore/adapter-web:client-session:getLeaderSyncState'),
+          ),
+          changes: runInWorkerStream(new WorkerSchema.LeaderWorkerInnerSyncStateStream()).pipe(Stream.orDie),
+        }),
 
         sendDevtoolsMessage: (message) =>
           runInWorker(new WorkerSchema.LeaderWorkerInnerExtraDevtoolsMessage({ message })).pipe(
-            UnexpectedError.mapToUnexpectedError,
+            UnknownError.mapToUnknownError,
             Effect.withSpan('@livestore/adapter-web:client-session:devtoolsMessageForLeader'),
           ),
+        networkStatus: Subscribable.make({
+          get: runInWorker(new WorkerSchema.LeaderWorkerInnerGetNetworkStatus()).pipe(Effect.orDie),
+          changes: runInWorkerStream(new WorkerSchema.LeaderWorkerInnerNetworkStatusStream()).pipe(Stream.orDie),
+        }),
       }
 
       const sharedWorker = yield* Fiber.join(sharedWorkerFiber)
@@ -458,10 +515,11 @@ export const makePersistedAdapter =
         lockStatus,
         clientId,
         sessionId,
-        // isLeader: gotLocky, // TODO update when leader is changing
-        isLeader: true,
+        isLeader: gotLocky,
         leaderThread,
         webmeshMode: 'direct',
+        // Can be undefined in Node.js
+        origin: globalThis.location?.origin,
         connectWebmeshNode: ({ sessionInfo, webmeshNode }) =>
           connectWebmeshNodeClientSession({ webmeshNode, sessionInfo, sharedWorker, devtoolsEnabled, schema }),
         registerBeforeUnload: (onBeforeUnload) => {
@@ -475,7 +533,7 @@ export const makePersistedAdapter =
       })
 
       return clientSession
-    }).pipe(UnexpectedError.mapToUnexpectedError)
+    }).pipe(Effect.provide(Opfs.Opfs.Default), UnknownError.mapToUnknownError)
 
 // NOTE for `local` storage we could also use the eventlog db to store the data
 const getPersistedId = (key: string, storageType: 'session' | 'local') => {
@@ -511,7 +569,7 @@ const ensureBrowserRequirements = Effect.gen(function* () {
   const validate = (condition: boolean, label: string) =>
     Effect.gen(function* () {
       if (condition) {
-        return yield* UnexpectedError.make({
+        return yield* UnknownError.make({
           cause: `[@livestore/adapter-web] Browser not supported. The LiveStore web adapter needs '${label}' to work properly`,
         })
       }

package/src/web-worker/client-session/sqlite-loader.ts

@@ -0,0 +1,19 @@
+import { loadSqlite3Wasm } from '@livestore/sqlite-wasm/load-wasm'
+
+/**
+ * Browser sessions benefit from downloading and compiling the wasm binary as soon as
+ * possible to hide network and IO latency behind the rest of the boot process. We kick
+ * that work off eagerly on the client while still returning the shared promise.
+ *
+ * The Cloudflare / Workerd runtime has stricter rules: async fetches during module
+ * evaluation are blocked, so we defer loading until the worker asks for it.
+ */
+const isServerRuntime = String(import.meta.env?.SSR) === 'true' || typeof window === 'undefined'
+
+let sqlite3Promise: ReturnType<typeof loadSqlite3Wasm> | undefined
+
+if (isServerRuntime === false) {
+  sqlite3Promise = loadSqlite3Wasm()
+}
+
+export const loadSqlite3 = () => (isServerRuntime ? loadSqlite3Wasm() : (sqlite3Promise ?? loadSqlite3Wasm()))