@livestore/adapter-web 0.4.0-dev.10 → 0.4.0-dev.11

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

@@ -12,7 +12,6 @@ import {
 // 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,
@@ -40,9 +39,7 @@ 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 = {
@@ -147,7 +144,7 @@ export const makePersistedAdapter =
 
       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}`
@@ -463,10 +460,13 @@ export const makePersistedAdapter =
           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(
+            UnexpectedError.mapToUnexpectedError,
+            Effect.withSpan('@livestore/adapter-web:client-session:getLeaderSyncState'),
+          ),
+          changes: runInWorkerStream(new WorkerSchema.LeaderWorkerInnerSyncStateStream()).pipe(Stream.orDie),
+        }),
 
         sendDevtoolsMessage: (message) =>
           runInWorker(new WorkerSchema.LeaderWorkerInnerExtraDevtoolsMessage({ message })).pipe(

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'
+
+let sqlite3Promise: ReturnType<typeof loadSqlite3Wasm> | undefined
+
+if (isServerRuntime === false) {
+  sqlite3Promise = loadSqlite3Wasm()
+}
+
+export const loadSqlite3 = () => (isServerRuntime ? loadSqlite3Wasm() : (sqlite3Promise ?? loadSqlite3Wasm()))

package/src/web-worker/common/worker-schema.ts

@@ -147,6 +147,15 @@ export class LeaderWorkerInnerGetLeaderSyncState extends Schema.TaggedRequest<Le
   },
 ) {}
 
+export class LeaderWorkerInnerSyncStateStream extends Schema.TaggedRequest<LeaderWorkerInnerSyncStateStream>()(
+  'SyncStateStream',
+  {
+    payload: {},
+    success: SyncState.SyncState,
+    failure: UnexpectedError,
+  },
+) {}
+
 export class LeaderWorkerInnerGetNetworkStatus extends Schema.TaggedRequest<LeaderWorkerInnerGetNetworkStatus>()(
   'GetNetworkStatus',
   {
@@ -192,6 +201,7 @@ export const LeaderWorkerInnerRequest = Schema.Union(
   LeaderWorkerInnerGetRecreateSnapshot,
   LeaderWorkerInnerGetLeaderHead,
   LeaderWorkerInnerGetLeaderSyncState,
+  LeaderWorkerInnerSyncStateStream,
   LeaderWorkerInnerGetNetworkStatus,
   LeaderWorkerInnerNetworkStatusStream,
   LeaderWorkerInnerShutdown,
@@ -239,6 +249,7 @@ export class SharedWorkerRequest extends Schema.Union(
   LeaderWorkerInnerExportEventlog,
   LeaderWorkerInnerGetLeaderHead,
   LeaderWorkerInnerGetLeaderSyncState,
+  LeaderWorkerInnerSyncStateStream,
   LeaderWorkerInnerGetNetworkStatus,
   LeaderWorkerInnerNetworkStatusStream,
   LeaderWorkerInnerShutdown,

package/src/web-worker/leader-worker/make-leader-worker.ts

@@ -222,6 +222,11 @@ const makeWorkerRunnerInner = ({ schema, sync: syncOptions }: WorkerOptions) =>
         UnexpectedError.mapToUnexpectedError,
         Effect.withSpan('@livestore/adapter-web:worker:GetLeaderSyncState'),
       ),
+    SyncStateStream: () =>
+      Effect.gen(function* () {
+        const workerCtx = yield* LeaderThreadCtx
+        return workerCtx.syncProcessor.syncState.changes
+      }).pipe(Stream.unwrapScoped),
     GetNetworkStatus: () =>
       Effect.gen(function* () {
         const workerCtx = yield* LeaderThreadCtx

package/src/web-worker/shared-worker/make-shared-worker.ts

@@ -70,12 +70,15 @@ const makeWorkerRunner = Effect.gen(function* () {
 
   const forwardRequest = <TReq extends WorkerSchema.LeaderWorkerInnerRequest>(
     req: TReq,
-  ): TReq extends Schema.WithResult<infer A, infer _I, infer _E, infer _EI, infer _R>
-    ? Effect.Effect<A, UnexpectedError, never>
-    : never =>
+  ): Effect.Effect<
+    Schema.WithResult.Success<TReq>,
+    UnexpectedError | Schema.WithResult.Failure<TReq>,
+    Schema.WithResult.Context<TReq>
+  > =>
+    // Forward the request to the active worker and normalize platform errors into UnexpectedError.
     waitForWorker.pipe(
       // Effect.logBefore(`forwardRequest: ${req._tag}`),
-      Effect.andThen((worker) => worker.executeEffect(req) as Effect.Effect<unknown, unknown, never>),
+      Effect.andThen((worker) => worker.executeEffect(req) as Effect.Effect<unknown, unknown, unknown>),
       // Effect.tap((_) => Effect.log(`forwardRequest: ${req._tag}`, _)),
       // Effect.tapError((cause) => Effect.logError(`forwardRequest err: ${req._tag}`, cause)),
       Effect.interruptible,
@@ -92,17 +95,23 @@ const makeWorkerRunner = Effect.gen(function* () {
       ),
       Effect.catchAllDefect((cause) => new UnexpectedError({ cause })),
       Effect.tapCauseLogPretty,
-    ) as any
+    ) as Effect.Effect<
+      Schema.WithResult.Success<TReq>,
+      UnexpectedError | Schema.WithResult.Failure<TReq>,
+      Schema.WithResult.Context<TReq>
+    >
 
   const forwardRequestStream = <TReq extends WorkerSchema.LeaderWorkerInnerRequest>(
     req: TReq,
-  ): TReq extends Schema.WithResult<infer A, infer _I, infer _E, infer _EI, infer _R>
-    ? Stream.Stream<A, UnexpectedError, never>
-    : never =>
+  ): Stream.Stream<
+    Schema.WithResult.Success<TReq>,
+    UnexpectedError | Schema.WithResult.Failure<TReq>,
+    Schema.WithResult.Context<TReq>
+  > =>
     Effect.gen(function* () {
       yield* Effect.logDebug(`forwardRequestStream: ${req._tag}`)
       const { worker, scope } = yield* SubscriptionRef.waitUntil(leaderWorkerContextSubRef, isNotUndefined)
-      const stream = worker.execute(req) as Stream.Stream<unknown, unknown, never>
+      const stream = worker.execute(req) as Stream.Stream<unknown, unknown, unknown>
 
       // It seems the request stream is not automatically interrupted when the scope shuts down
       // so we need to manually interrupt it when the scope shuts down
@@ -123,7 +132,11 @@ const makeWorkerRunner = Effect.gen(function* () {
       Stream.unwrap,
       Stream.ensuring(Effect.logDebug(`shutting down stream for ${req._tag}`)),
       UnexpectedError.mapToUnexpectedErrorStream,
-    ) as any
+    ) as Stream.Stream<
+      Schema.WithResult.Success<TReq>,
+      UnexpectedError | Schema.WithResult.Failure<TReq>,
+      Schema.WithResult.Context<TReq>
+    >
 
   const resetCurrentWorkerCtx = Effect.gen(function* () {
     const prevWorker = yield* SubscriptionRef.get(leaderWorkerContextSubRef)
@@ -245,6 +258,7 @@ const makeWorkerRunner = Effect.gen(function* () {
     ExportEventlog: forwardRequest,
     Setup: forwardRequest,
     GetLeaderSyncState: forwardRequest,
+    SyncStateStream: forwardRequestStream,
     GetLeaderHead: forwardRequest,
     GetNetworkStatus: forwardRequest,
     NetworkStatusStream: forwardRequestStream,
@@ -257,6 +271,12 @@ const makeWorkerRunner = Effect.gen(function* () {
 }).pipe(Layer.unwrapScoped)
 
 export const makeWorker = () => {
+  const layer = Layer.mergeAll(
+    Logger.prettyWithThread(self.name),
+    FetchHttpClient.layer,
+    WebmeshWorker.CacheService.layer({ nodeName: DevtoolsWeb.makeNodeName.sharedWorker({ storeId }) }),
+  )
+
   makeWorkerRunner.pipe(
     Layer.provide(BrowserWorkerRunner.layer),
     // WorkerRunner.launch,
@@ -264,9 +284,7 @@ export const makeWorker = () => {
     Effect.scoped,
     Effect.tapCauseLogPretty,
     Effect.annotateLogs({ thread: self.name }),
-    Effect.provide(Logger.prettyWithThread(self.name)),
-    Effect.provide(FetchHttpClient.layer),
-    Effect.provide(WebmeshWorker.CacheService.layer({ nodeName: DevtoolsWeb.makeNodeName.sharedWorker({ storeId }) })),
+    Effect.provide(layer),
     LS_DEV ? TaskTracing.withAsyncTaggingTracing((name) => (console as any).createTask(name)) : identity,
     // TODO remove type-cast (currently needed to silence a tsc bug)
     (_) => _ as any as Effect.Effect<void, any>,