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

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

@@ -1,7 +1,13 @@
 import type { SqliteDb, SyncOptions } from '@livestore/common'
-import { Devtools, UnexpectedError } from '@livestore/common'
-import type { DevtoolsOptions } from '@livestore/common/leader-thread'
-import { configureConnection, Eventlog, LeaderThreadCtx, makeLeaderThreadLayer } from '@livestore/common/leader-thread'
+import { Devtools, LogConfig, UnknownError } from '@livestore/common'
+import type { DevtoolsOptions, StreamEventsOptions } 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 WebmeshWorker from '@livestore/devtools-web-common/worker'
@@ -10,37 +16,36 @@ import { loadSqlite3Wasm } from '@livestore/sqlite-wasm/load-wasm'
 import { isDevEnv, LS_DEV } from '@livestore/utils'
 import type { HttpClient, Scope, WorkerError } from '@livestore/utils/effect'
 import {
-  BrowserWorkerRunner,
   Effect,
   FetchHttpClient,
   identity,
   Layer,
-  Logger,
-  LogLevel,
   OtelTracer,
   Scheduler,
+  type Schema,
   Stream,
   TaskTracing,
   WorkerRunner,
 } from '@livestore/utils/effect'
+import { BrowserWorkerRunner, Opfs } from '@livestore/utils/effect/browser'
 import type * as otel from '@opentelemetry/api'
 
-import * as OpfsUtils from '../../opfs-utils.ts'
-import { getStateDbFileName, sanitizeOpfsDir } from '../common/persisted-sqlite.ts'
+import { cleanupOldStateDbFiles, getStateDbFileName, sanitizeOpfsDir } from '../common/persisted-sqlite.ts'
 import { makeShutdownChannel } from '../common/shutdown-channel.ts'
 import * as WorkerSchema from '../common/worker-schema.ts'
 
 export type WorkerOptions = {
   schema: LiveStoreSchema
   sync?: SyncOptions
+  syncPayloadSchema?: Schema.Schema<any>
   otelOptions?: {
     tracer?: otel.Tracer
   }
-}
+} & LogConfig.WithLoggerOptions
 
 if (isDevEnv()) {
   globalThis.__debugLiveStoreUtils = {
-    opfs: OpfsUtils,
+    opfs: Opfs.debugUtils,
     blobUrl: (buffer: Uint8Array<ArrayBuffer>) =>
       URL.createObjectURL(new Blob([buffer], { type: 'application/octet-stream' })),
     runSync: (effect: Effect.Effect<any, any, never>) => Effect.runSync(effect),
@@ -59,23 +64,23 @@ export const makeWorkerEffect = (options: WorkerOptions) => {
       )
     : undefined
 
+  const runtimeLayer = Layer.mergeAll(FetchHttpClient.layer, TracingLive ?? Layer.empty)
+
   return makeWorkerRunnerOuter(options).pipe(
     Layer.provide(BrowserWorkerRunner.layer),
     WorkerRunner.launch,
     Effect.scoped,
     Effect.tapCauseLogPretty,
     Effect.annotateLogs({ thread: self.name }),
-    Effect.provide(Logger.prettyWithThread(self.name)),
-    Effect.provide(FetchHttpClient.layer),
+    Effect.provide(runtimeLayer),
     LS_DEV ? TaskTracing.withAsyncTaggingTracing((name) => (console as any).createTask(name)) : identity,
-    TracingLive ? Effect.provide(TracingLive) : identity,
     // We're using this custom scheduler to improve op batching behaviour and reduce the overhead
     // of the Effect fiber runtime given we have different tradeoffs on a worker thread.
     // Despite the "message channel" name, is has nothing to do with the `incomingRequestsPort` above.
     Effect.withScheduler(Scheduler.messageChannel()),
     // We're increasing the Effect ops limit here to allow for larger chunks of operations at a time
     Effect.withMaxOpsBeforeYield(4096),
-    Logger.withMinimumLogLevel(LogLevel.Debug),
+    LogConfig.withLoggerConfig({ logger: options.logger, logLevel: options.logLevel }, { threadName: self.name }),
   )
 }
 
@@ -93,7 +98,12 @@ const makeWorkerRunnerOuter = (
           Effect.withSpan('@livestore/adapter-web:worker:wrapper:InitialMessage:innerFiber'),
           Effect.tapCauseLogPretty,
           Effect.provide(
-            WebmeshWorker.CacheService.layer({ nodeName: Devtools.makeNodeName.client.leader({ storeId, clientId }) }),
+            Layer.mergeAll(
+              Opfs.Opfs.Default,
+              WebmeshWorker.CacheService.layer({
+                nodeName: Devtools.makeNodeName.client.leader({ storeId, clientId }),
+              }),
+            ),
           ),
           Effect.forkScoped,
         )
@@ -102,18 +112,19 @@ const makeWorkerRunnerOuter = (
       }).pipe(Effect.withSpan('@livestore/adapter-web:worker:wrapper:InitialMessage'), Layer.unwrapScoped),
   })
 
-const makeWorkerRunnerInner = ({ schema, sync: syncOptions }: WorkerOptions) =>
+const makeWorkerRunnerInner = ({ schema, sync: syncOptions, syncPayloadSchema }: WorkerOptions) =>
   WorkerRunner.layerSerialized(WorkerSchema.LeaderWorkerInnerRequest, {
-    InitialMessage: ({ storageOptions, storeId, clientId, devtoolsEnabled, debugInstanceId, syncPayload }) =>
+    InitialMessage: ({ storageOptions, storeId, clientId, devtoolsEnabled, debugInstanceId, syncPayloadEncoded }) =>
       Effect.gen(function* () {
         const sqlite3 = yield* Effect.promise(() => loadSqlite3Wasm())
         const makeSqliteDb = sqliteDbFactory({ sqlite3 })
+        const opfsDirectory = yield* sanitizeOpfsDir(storageOptions.directory, storeId)
         const runtime = yield* Effect.runtime<never>()
 
         const makeDb = (kind: 'state' | 'eventlog') =>
           makeSqliteDb({
             _tag: 'opfs',
-            opfsDirectory: sanitizeOpfsDir(storageOptions.directory, storeId),
+            opfsDirectory,
             fileName: kind === 'state' ? getStateDbFileName(schema) : 'eventlog.db',
             configureDb: (db) =>
               configureConnection(db, {
@@ -131,6 +142,16 @@ const makeWorkerRunnerInner = ({ schema, sync: syncOptions }: WorkerOptions) =>
           concurrency: 2,
         })
 
+        // Clean up old state database files after successful database creation
+        // This prevents OPFS file pool capacity exhaustion from accumulated state db files after schema changes/migrations
+        if (dbState.metadata._tag === 'opfs') {
+          yield* cleanupOldStateDbFiles({
+            vfs: dbState.metadata.vfs,
+            currentSchema: schema,
+            opfsDirectory: dbState.metadata.persistenceInfo.opfsDirectory,
+          })
+        }
+
         const devtoolsOptions = yield* makeDevtoolsOptions({ devtoolsEnabled, dbState, dbEventlog })
         const shutdownChannel = yield* makeShutdownChannel(storeId)
 
@@ -144,11 +165,12 @@ const makeWorkerRunnerInner = ({ schema, sync: syncOptions }: WorkerOptions) =>
           dbEventlog,
           devtoolsOptions,
           shutdownChannel,
-          syncPayload,
+          syncPayloadEncoded,
+          syncPayloadSchema,
         })
       }).pipe(
         Effect.tapCauseLogPretty,
-        UnexpectedError.mapToUnexpectedError,
+        UnknownError.mapToUnknownError,
         Effect.withPerformanceMeasure('@livestore/adapter-web:worker:InitialMessage'),
         Effect.withSpan('@livestore/adapter-web:worker:InitialMessage'),
         Effect.annotateSpans({ debugInstanceId }),
@@ -166,13 +188,10 @@ const makeWorkerRunnerInner = ({ schema, sync: syncOptions }: WorkerOptions) =>
 
         const snapshot = workerCtx.dbState.export()
         return { snapshot, migrationsReport: workerCtx.initialState.migrationsReport }
-      }).pipe(
-        UnexpectedError.mapToUnexpectedError,
-        Effect.withSpan('@livestore/adapter-web:worker:GetRecreateSnapshot'),
-      ),
+      }).pipe(UnknownError.mapToUnknownError, Effect.withSpan('@livestore/adapter-web:worker:GetRecreateSnapshot')),
     PullStream: ({ cursor }) =>
       Effect.gen(function* () {
-        const { syncProcessor } = yield* LeaderThreadCtx
+        const { syncProcessor } = yield* LeaderThreadCtx // <- syncState comes from here
         return syncProcessor.pull({ cursor })
       }).pipe(
         Stream.unwrapScoped,
@@ -182,19 +201,33 @@ const makeWorkerRunnerInner = ({ schema, sync: syncOptions }: WorkerOptions) =>
     PushToLeader: ({ batch }) =>
       Effect.andThen(LeaderThreadCtx, ({ syncProcessor }) =>
         syncProcessor.push(
-          batch.map((event) => new LiveStoreEvent.EncodedWithMeta(event)),
+          batch.map((event) => new LiveStoreEvent.Client.EncodedWithMeta(event)),
           // We'll wait in order to keep back pressure on the client session
           { waitForProcessing: true },
         ),
       ).pipe(Effect.uninterruptible, Effect.withSpan('@livestore/adapter-web:worker:PushToLeader')),
+    StreamEvents: (options) =>
+      LeaderThreadCtx.pipe(
+        Effect.map(({ dbEventlog, syncProcessor }) => {
+          const { _tag: _ignored, ...payload } = options as any
+          const streamOptions = payload as StreamEventsOptions
+          return streamEventsWithSyncState({
+            dbEventlog,
+            syncState: syncProcessor.syncState,
+            options: streamOptions,
+          })
+        }),
+        Stream.unwrapScoped,
+        Stream.withSpan('@livestore/adapter-web:worker:StreamEvents'),
+      ),
     Export: () =>
       Effect.andThen(LeaderThreadCtx, (_) => _.dbState.export()).pipe(
-        UnexpectedError.mapToUnexpectedError,
+        UnknownError.mapToUnknownError,
         Effect.withSpan('@livestore/adapter-web:worker:Export'),
       ),
     ExportEventlog: () =>
       Effect.andThen(LeaderThreadCtx, (_) => _.dbEventlog.export()).pipe(
-        UnexpectedError.mapToUnexpectedError,
+        UnknownError.mapToUnknownError,
         Effect.withSpan('@livestore/adapter-web:worker:ExportEventlog'),
       ),
     BootStatusStream: () =>
@@ -203,15 +236,27 @@ const makeWorkerRunnerInner = ({ schema, sync: syncOptions }: WorkerOptions) =>
       Effect.gen(function* () {
         const workerCtx = yield* LeaderThreadCtx
         return Eventlog.getClientHeadFromDb(workerCtx.dbEventlog)
-      }).pipe(UnexpectedError.mapToUnexpectedError, Effect.withSpan('@livestore/adapter-web:worker:GetLeaderHead')),
+      }).pipe(UnknownError.mapToUnknownError, Effect.withSpan('@livestore/adapter-web:worker:GetLeaderHead')),
     GetLeaderSyncState: () =>
       Effect.gen(function* () {
         const workerCtx = yield* LeaderThreadCtx
         return yield* workerCtx.syncProcessor.syncState
-      }).pipe(
-        UnexpectedError.mapToUnexpectedError,
-        Effect.withSpan('@livestore/adapter-web:worker:GetLeaderSyncState'),
-      ),
+      }).pipe(UnknownError.mapToUnknownError, 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
+        return yield* workerCtx.networkStatus
+      }).pipe(UnknownError.mapToUnknownError, Effect.withSpan('@livestore/adapter-web:worker:GetNetworkStatus')),
+    NetworkStatusStream: () =>
+      Effect.gen(function* () {
+        const workerCtx = yield* LeaderThreadCtx
+        return workerCtx.networkStatus.changes
+      }).pipe(Stream.unwrapScoped),
     Shutdown: () =>
       Effect.gen(function* () {
         yield* Effect.logDebug('[@livestore/adapter-web:worker] Shutdown')
@@ -219,10 +264,10 @@ const makeWorkerRunnerInner = ({ schema, sync: syncOptions }: WorkerOptions) =>
         // Buy some time for Otel to flush
         // TODO find a cleaner way to do this
         yield* Effect.sleep(300)
-      }).pipe(UnexpectedError.mapToUnexpectedError, Effect.withSpan('@livestore/adapter-web:worker:Shutdown')),
+      }).pipe(UnknownError.mapToUnknownError, Effect.withSpan('@livestore/adapter-web:worker:Shutdown')),
     ExtraDevtoolsMessage: ({ message }) =>
       Effect.andThen(LeaderThreadCtx, (_) => _.extraIncomingMessagesQueue.offer(message)).pipe(
-        UnexpectedError.mapToUnexpectedError,
+        UnknownError.mapToUnknownError,
         Effect.withSpan('@livestore/adapter-web:worker:ExtraDevtoolsMessage'),
       ),
     'DevtoolsWebCommon.CreateConnection': WebmeshWorker.CreateConnection,
@@ -236,7 +281,7 @@ const makeDevtoolsOptions = ({
   devtoolsEnabled: boolean
   dbState: SqliteDb
   dbEventlog: SqliteDb
-}): Effect.Effect<DevtoolsOptions, UnexpectedError, Scope.Scope | WebmeshWorker.CacheService> =>
+}): Effect.Effect<DevtoolsOptions, UnknownError, Scope.Scope | WebmeshWorker.CacheService> =>
   Effect.gen(function* () {
     if (devtoolsEnabled === false) {
       return { enabled: false }
@@ -246,13 +291,13 @@ const makeDevtoolsOptions = ({
 
     return {
       enabled: true,
-      boot: Effect.gen(function* () {
-        const persistenceInfo = {
+      boot: Effect.succeed({
+        node,
+        persistenceInfo: {
           state: dbState.metadata.persistenceInfo,
           eventlog: dbEventlog.metadata.persistenceInfo,
-        }
-
-        return { node, persistenceInfo, mode: 'direct' }
+        },
+        mode: 'direct' as const,
       }),
     }
   })

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

@@ -1,18 +1,14 @@
-import { Devtools, UnexpectedError } from '@livestore/common'
+import { Devtools, LogConfig, liveStoreVersion, UnknownError } from '@livestore/common'
 import * as DevtoolsWeb from '@livestore/devtools-web-common/web-channel'
 import * as WebmeshWorker from '@livestore/devtools-web-common/worker'
 import { isDevEnv, isNotUndefined, LS_DEV } from '@livestore/utils'
 import {
-  BrowserWorker,
-  BrowserWorkerRunner,
   Deferred,
   Effect,
   Exit,
   FetchHttpClient,
   identity,
   Layer,
-  Logger,
-  LogLevel,
   ParseResult,
   Ref,
   Schema,
@@ -24,10 +20,25 @@ import {
   WorkerError,
   WorkerRunner,
 } from '@livestore/utils/effect'
+import { BrowserWorker, BrowserWorkerRunner } from '@livestore/utils/effect/browser'
 
 import { makeShutdownChannel } from '../common/shutdown-channel.ts'
 import * as WorkerSchema from '../common/worker-schema.ts'
 
+// Extract from `livestore-shared-worker-${storeId}`
+const storeId = self.name.replace('livestore-shared-worker-', '')
+
+// We acquire a lock that is held as long as this shared worker is alive.
+// This way, when the shared worker is terminated (e.g. by the browser when the page is closed),
+// the lock is released and any thread waiting for the lock can be notified.
+const LIVESTORE_SHARED_WORKER_TERMINATION_LOCK = `livestore-shared-worker-termination-lock-${storeId}`
+navigator.locks.request(
+  LIVESTORE_SHARED_WORKER_TERMINATION_LOCK,
+  { steal: true },
+  // We use a never-resolving promise to hold the lock
+  async () => new Promise(() => {}),
+)
+
 if (isDevEnv()) {
   globalThis.__debugLiveStoreUtils = {
     blobUrl: (buffer: Uint8Array<ArrayBuffer>) =>
@@ -46,22 +57,21 @@ const makeWorkerRunner = Effect.gen(function* () {
     | undefined
   >(undefined)
 
-  const initialMessagePayloadDeferredRef = yield* Deferred.make<
-    typeof WorkerSchema.SharedWorkerInitialMessagePayloadFromClientSession.Type
-  >().pipe(Effect.andThen(Ref.make))
-
   const waitForWorker = SubscriptionRef.waitUntil(leaderWorkerContextSubRef, isNotUndefined).pipe(
     Effect.map((_) => _.worker),
   )
 
   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>,
+    UnknownError | Schema.WithResult.Failure<TReq>,
+    Schema.WithResult.Context<TReq>
+  > =>
+    // Forward the request to the active worker and normalize platform errors into UnknownError.
     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,
@@ -70,25 +80,31 @@ const makeWorkerRunner = Effect.gen(function* () {
         duration: 500,
       }),
       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 })),
       Effect.tapCauseLogPretty,
-    ) as any
+    ) as Effect.Effect<
+      Schema.WithResult.Success<TReq>,
+      UnknownError | 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>,
+    UnknownError | 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
@@ -104,12 +120,16 @@ const makeWorkerRunner = Effect.gen(function* () {
       return Stream.merge(stream, scopeShutdownStream, { haltStrategy: 'either' })
     }).pipe(
       Effect.interruptible,
-      UnexpectedError.mapToUnexpectedError,
+      UnknownError.mapToUnknownError,
       Effect.tapCauseLogPretty,
       Stream.unwrap,
       Stream.ensuring(Effect.logDebug(`shutting down stream for ${req._tag}`)),
-      UnexpectedError.mapToUnexpectedErrorStream,
-    ) as any
+      UnknownError.mapToUnknownErrorStream,
+    ) as Stream.Stream<
+      Schema.WithResult.Success<TReq>,
+      UnknownError | Schema.WithResult.Failure<TReq>,
+      Schema.WithResult.Context<TReq>
+    >
 
   const resetCurrentWorkerCtx = Effect.gen(function* () {
     const prevWorker = yield* SubscriptionRef.get(leaderWorkerContextSubRef)
@@ -128,62 +148,59 @@ const makeWorkerRunner = Effect.gen(function* () {
     }
   }).pipe(Effect.withSpan('@livestore/adapter-web:shared-worker:resetCurrentWorkerCtx'))
 
-  // const devtoolsWebBridge = yield* makeDevtoolsWebBridge
-
   const reset = Effect.gen(function* () {
     yield* Effect.logDebug('reset')
-
-    const initialMessagePayloadDeferred =
-      yield* Deferred.make<typeof WorkerSchema.SharedWorkerInitialMessagePayloadFromClientSession.Type>()
-    yield* Ref.set(initialMessagePayloadDeferredRef, initialMessagePayloadDeferred)
-
+    // Clear cached invariants so a fresh configuration can be accepted after shutdown
+    yield* Ref.set(invariantsRef, undefined)
+    // Tear down current leader worker context
     yield* resetCurrentWorkerCtx
-    // yield* devtoolsWebBridge.reset
   })
 
-  return WorkerRunner.layerSerialized(WorkerSchema.SharedWorkerRequest, {
-    InitialMessage: (message) =>
-      Effect.gen(function* () {
-        if (message.payload._tag === 'FromWebBridge') return
-
-        const initialMessagePayloadDeferred = yield* Ref.get(initialMessagePayloadDeferredRef)
-        const deferredAlreadyDone = yield* Deferred.isDone(initialMessagePayloadDeferred)
-        const initialMessage = message.payload.initialMessage
-
-        if (deferredAlreadyDone) {
-          const previousInitialMessage = yield* Deferred.await(initialMessagePayloadDeferred)
-          const messageSchema = WorkerSchema.LeaderWorkerInnerInitialMessage.pipe(
-            Schema.omit('devtoolsEnabled', 'debugInstanceId'),
-          )
-          const isEqual = Schema.equivalence(messageSchema)
-          if (isEqual(initialMessage, previousInitialMessage.initialMessage) === false) {
-            const diff = Schema.debugDiff(messageSchema)(previousInitialMessage.initialMessage, initialMessage)
+  // Cache first-applied invariants to enforce stability across leader transitions
+  const InvariantsSchema = Schema.Struct({
+    storeId: Schema.String,
+    storageOptions: WorkerSchema.StorageType,
+    syncPayloadEncoded: Schema.UndefinedOr(Schema.JsonValue),
+    liveStoreVersion: Schema.Literal(liveStoreVersion),
+    devtoolsEnabled: Schema.Boolean,
+  })
+  type Invariants = typeof InvariantsSchema.Type
+  const invariantsRef = yield* Ref.make<Invariants | undefined>(undefined)
+  const sameInvariants = Schema.equivalence(InvariantsSchema)
 
-            return yield* new UnexpectedError({
-              cause: 'Initial message already sent and was different now',
-              payload: {
-                diff,
-                previousInitialMessage: previousInitialMessage.initialMessage,
-                newInitialMessage: initialMessage,
-              },
-            })
-          }
-        } else {
-          yield* Deferred.succeed(initialMessagePayloadDeferred, message.payload)
-        }
-      }),
+  return WorkerRunner.layerSerialized(WorkerSchema.SharedWorkerRequest, {
     // Whenever the client session leader changes (and thus creates a new leader thread), the new client session leader
     // sends a new MessagePort to the shared worker which proxies messages to the new leader thread.
-    UpdateMessagePort: ({ port }) =>
+    UpdateMessagePort: ({ port, initial, liveStoreVersion: clientLiveStoreVersion }) =>
       Effect.gen(function* () {
-        const initialMessagePayload = yield* initialMessagePayloadDeferredRef.get.pipe(Effect.andThen(Deferred.await))
+        // Enforce invariants: storeId, storageOptions, syncPayloadEncoded, liveStoreVersion must remain stable
+        const invariants: Invariants = {
+          storeId: initial.storeId,
+          storageOptions: initial.storageOptions,
+          syncPayloadEncoded: initial.syncPayloadEncoded,
+          liveStoreVersion: clientLiveStoreVersion,
+          devtoolsEnabled: initial.devtoolsEnabled,
+        }
+        const prev = yield* Ref.get(invariantsRef)
+        // Early return on mismatch to keep happy path linear
+        if (prev !== undefined && !sameInvariants(prev, invariants)) {
+          const diff = Schema.debugDiff(InvariantsSchema)(prev, invariants)
+          return yield* new UnknownError({
+            cause: 'Store invariants changed across leader transitions',
+            payload: { diff, previous: prev, next: invariants },
+          })
+        }
+        // First writer records invariants
+        if (prev === undefined) {
+          yield* Ref.set(invariantsRef, invariants)
+        }
 
         yield* resetCurrentWorkerCtx
 
         const scope = yield* Scope.make()
 
         yield* Effect.gen(function* () {
-          const shutdownChannel = yield* makeShutdownChannel(initialMessagePayload.initialMessage.storeId)
+          const shutdownChannel = yield* makeShutdownChannel(initial.storeId)
 
           yield* shutdownChannel.listen.pipe(
             Stream.flatten(),
@@ -198,7 +215,7 @@ const makeWorkerRunner = Effect.gen(function* () {
           const worker = yield* Worker.makePoolSerialized<WorkerSchema.LeaderWorkerInnerRequest>({
             size: 1,
             concurrency: 100,
-            initialMessage: () => initialMessagePayload.initialMessage,
+            initialMessage: () => initial,
           }).pipe(
             Effect.provide(workerLayer),
             Effect.withSpan('@livestore/adapter-web:shared-worker:makeWorkerProxyFromPort'),
@@ -206,7 +223,7 @@ const makeWorkerRunner = Effect.gen(function* () {
 
           // Prepare the web mesh connection for leader worker to be able to connect to the devtools
           const { node } = yield* WebmeshWorker.CacheService
-          const { storeId, clientId } = initialMessagePayload.initialMessage
+          const { storeId, clientId } = initial
 
           yield* DevtoolsWeb.connectViaWorker({
             node,
@@ -218,7 +235,7 @@ const makeWorkerRunner = Effect.gen(function* () {
         }).pipe(Effect.tapCauseLogPretty, Scope.extend(scope), Effect.forkIn(scope))
       }).pipe(
         Effect.withSpan('@livestore/adapter-web:shared-worker:updateMessagePort'),
-        UnexpectedError.mapToUnexpectedError,
+        UnknownError.mapToUnknownError,
         Effect.tapCauseLogPretty,
       ),
 
@@ -226,12 +243,16 @@ const makeWorkerRunner = Effect.gen(function* () {
     BootStatusStream: forwardRequestStream,
     PushToLeader: forwardRequest,
     PullStream: forwardRequestStream,
+    StreamEvents: forwardRequestStream,
     Export: forwardRequest,
     GetRecreateSnapshot: forwardRequest,
     ExportEventlog: forwardRequest,
     Setup: forwardRequest,
     GetLeaderSyncState: forwardRequest,
+    SyncStateStream: forwardRequestStream,
     GetLeaderHead: forwardRequest,
+    GetNetworkStatus: forwardRequest,
+    NetworkStatusStream: forwardRequestStream,
     Shutdown: forwardRequest,
     ExtraDevtoolsMessage: forwardRequest,
 
@@ -240,9 +261,11 @@ const makeWorkerRunner = Effect.gen(function* () {
   })
 }).pipe(Layer.unwrapScoped)
 
-export const makeWorker = () => {
-  // Extract from `livestore-shared-worker-${storeId}`
-  const storeId = self.name.replace('livestore-shared-worker-', '')
+export const makeWorker = (options?: LogConfig.WithLoggerOptions): void => {
+  const runtimeLayer = Layer.mergeAll(
+    FetchHttpClient.layer,
+    WebmeshWorker.CacheService.layer({ nodeName: DevtoolsWeb.makeNodeName.sharedWorker({ storeId }) }),
+  )
 
   makeWorkerRunner.pipe(
     Layer.provide(BrowserWorkerRunner.layer),
@@ -251,13 +274,11 @@ 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(runtimeLayer),
     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>,
-    Logger.withMinimumLogLevel(LogLevel.Debug),
+    LogConfig.withLoggerConfig(options, { threadName: self.name }),
     Effect.runFork,
   )
 }

package/src/web-worker/vite-dev-polyfill.ts

@@ -5,6 +5,7 @@ globalThis.$RefreshReg$ = () => {}
 // @ts-expect-error TODO remove when Vite does proper treeshaking during dev
 globalThis.$RefreshSig$ = () => (type: any) => type
 
+// biome-ignore lint/suspicious/noTsIgnore: sometimes @types/node is there, sometimes not.
 // @ts-ignore
 globalThis.process = globalThis.process ?? { env: {} }
 

package/dist/opfs-utils.d.ts

@@ -1,5 +0,0 @@
-export declare const rootHandlePromise: Promise<FileSystemDirectoryHandle>;
-export declare const getDirHandle: (absDirPath: string | undefined) => Promise<FileSystemDirectoryHandle>;
-export declare const printTree: (directoryHandle_?: FileSystemDirectoryHandle | Promise<FileSystemDirectoryHandle>, depth?: number, prefix?: string) => Promise<void>;
-export declare const deleteAll: (directoryHandle: FileSystemDirectoryHandle) => Promise<void>;
-//# sourceMappingURL=opfs-utils.d.ts.map

package/dist/opfs-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"opfs-utils.d.ts","sourceRoot":"","sources":["../src/opfs-utils.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,iBAAiB,oCAYQ,CAAA;AAEtC,eAAO,MAAM,YAAY,GAAU,YAAY,MAAM,GAAG,SAAS,uCAWhE,CAAA;AAED,eAAO,MAAM,SAAS,GACpB,mBAAkB,yBAAyB,GAAG,OAAO,CAAC,yBAAyB,CAAqB,EACpG,QAAO,MAAiC,EACxC,eAAW,KACV,OAAO,CAAC,IAAI,CAgBd,CAAA;AAED,eAAO,MAAM,SAAS,GAAU,iBAAiB,yBAAyB,kBAMzE,CAAA"}

package/dist/opfs-utils.js

@@ -1,43 +0,0 @@
-// NOTE we're already firing off this promise call here since we'll need it anyway and need it cached
-import { prettyBytes } from '@livestore/utils';
-// To improve LiveStore compatibility with e.g. Node.js we're guarding for `navigator` / `navigator.storage` to be defined.
-export const rootHandlePromise = typeof navigator === 'undefined' || navigator.storage === undefined
-    ? // We're using a proxy here to make the promise reject lazy
-        new Proxy({}, {
-            get: () => Promise.reject(new Error(`Can't get OPFS root handle in this environment as navigator.storage is undefined`)),
-        })
-    : navigator.storage.getDirectory();
-export const getDirHandle = async (absDirPath) => {
-    const rootHandle = await rootHandlePromise;
-    if (absDirPath === undefined)
-        return rootHandle;
-    let dirHandle = rootHandle;
-    const directoryStack = absDirPath?.split('/').filter(Boolean);
-    while (directoryStack.length > 0) {
-        dirHandle = await dirHandle.getDirectoryHandle(directoryStack.shift());
-    }
-    return dirHandle;
-};
-export const printTree = async (directoryHandle_ = rootHandlePromise, depth = Number.POSITIVE_INFINITY, prefix = '') => {
-    if (depth < 0)
-        return;
-    const directoryHandle = await directoryHandle_;
-    const entries = directoryHandle.values();
-    for await (const entry of entries) {
-        const isDirectory = entry.kind === 'directory';
-        const size = entry.kind === 'file' ? await entry.getFile().then((file) => prettyBytes(file.size)) : undefined;
-        console.log(`${prefix}${isDirectory ? '📁' : '📄'} ${entry.name} ${size ? `(${size})` : ''}`);
-        if (isDirectory) {
-            const nestedDirectoryHandle = await directoryHandle.getDirectoryHandle(entry.name);
-            await printTree(nestedDirectoryHandle, depth - 1, `${prefix}  `);
-        }
-    }
-};
-export const deleteAll = async (directoryHandle) => {
-    if (directoryHandle.kind !== 'directory')
-        return;
-    for await (const entryName of directoryHandle.keys()) {
-        await directoryHandle.removeEntry(entryName, { recursive: true });
-    }
-};
-//# sourceMappingURL=opfs-utils.js.map

package/dist/opfs-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"opfs-utils.js","sourceRoot":"","sources":["../src/opfs-utils.ts"],"names":[],"mappings":"AAAA,qGAAqG;AAErG,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAE9C,2HAA2H;AAC3H,MAAM,CAAC,MAAM,iBAAiB,GAC5B,OAAO,SAAS,KAAK,WAAW,IAAI,SAAS,CAAC,OAAO,KAAK,SAAS;IACjE,CAAC,CAAC,2DAA2D;QAC1D,IAAI,KAAK,CACR,EAAE,EACF;YACE,GAAG,EAAE,GAAG,EAAE,CACR,OAAO,CAAC,MAAM,CACZ,IAAI,KAAK,CAAC,kFAAkF,CAAC,CAC9F;SACJ,CACQ;IACb,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,YAAY,EAAE,CAAA;AAEtC,MAAM,CAAC,MAAM,YAAY,GAAG,KAAK,EAAE,UAA8B,EAAE,EAAE;IACnE,MAAM,UAAU,GAAG,MAAM,iBAAiB,CAAA;IAC1C,IAAI,UAAU,KAAK,SAAS;QAAE,OAAO,UAAU,CAAA;IAE/C,IAAI,SAAS,GAAG,UAAU,CAAA;IAC1B,MAAM,cAAc,GAAG,UAAU,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;IAC7D,OAAO,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACjC,SAAS,GAAG,MAAM,SAAS,CAAC,kBAAkB,CAAC,cAAc,CAAC,KAAK,EAAG,CAAC,CAAA;IACzE,CAAC;IAED,OAAO,SAAS,CAAA;AAClB,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,SAAS,GAAG,KAAK,EAC5B,mBAAmF,iBAAiB,EACpG,QAAgB,MAAM,CAAC,iBAAiB,EACxC,MAAM,GAAG,EAAE,EACI,EAAE;IACjB,IAAI,KAAK,GAAG,CAAC;QAAE,OAAM;IAErB,MAAM,eAAe,GAAG,MAAM,gBAAgB,CAAA;IAC9C,MAAM,OAAO,GAAG,eAAe,CAAC,MAAM,EAAE,CAAA;IAExC,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAClC,MAAM,WAAW,GAAG,KAAK,CAAC,IAAI,KAAK,WAAW,CAAA;QAC9C,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;QAC7G,OAAO,CAAC,GAAG,CAAC,GAAG,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,KAAK,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;QAE7F,IAAI,WAAW,EAAE,CAAC;YAChB,MAAM,qBAAqB,GAAG,MAAM,eAAe,CAAC,kBAAkB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;YAClF,MAAM,SAAS,CAAC,qBAAqB,EAAE,KAAK,GAAG,CAAC,EAAE,GAAG,MAAM,IAAI,CAAC,CAAA;QAClE,CAAC;IACH,CAAC;AACH,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,SAAS,GAAG,KAAK,EAAE,eAA0C,EAAE,EAAE;IAC5E,IAAI,eAAe,CAAC,IAAI,KAAK,WAAW;QAAE,OAAM;IAEhD,IAAI,KAAK,EAAE,MAAM,SAAS,IAAI,eAAe,CAAC,IAAI,EAAE,EAAE,CAAC;QACrD,MAAM,eAAe,CAAC,WAAW,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;IACnE,CAAC;AACH,CAAC,CAAA"}