@livestore/adapter-web 0.3.1 → 0.3.2-dev.1

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

@@ -4,12 +4,13 @@ import {
   liveStoreVersion,
   makeClientSession,
   StoreInterrupted,
+  sessionChangesetMetaTable,
   UnexpectedError,
 } 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, SystemTables } from '@livestore/common/schema'
+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'
@@ -31,12 +32,12 @@ import {
 } from '@livestore/utils/effect'
 import { nanoid } from '@livestore/utils/nanoid'
 
-import * as OpfsUtils from '../../opfs-utils.js'
-import { readPersistedAppDbFromClientSession, resetPersistedDataFromClientSession } from '../common/persisted-sqlite.js'
-import { makeShutdownChannel } from '../common/shutdown-channel.js'
-import { DedicatedWorkerDisconnectBroadcast, makeWorkerDisconnectChannel } from '../common/worker-disconnect-channel.js'
-import * as WorkerSchema from '../common/worker-schema.js'
-import { connectWebmeshNodeClientSession } from './client-session-devtools.js'
+import * as OpfsUtils from '../../opfs-utils.ts'
+import { readPersistedAppDbFromClientSession, 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()
@@ -67,7 +68,9 @@ export type WebAdapterOptions = {
    */
   sharedWorker:
     | ((options: { name: string }) => globalThis.SharedWorker)
-    | (new (options: { name: string }) => globalThis.SharedWorker)
+    | (new (options: {
+        name: string
+      }) => globalThis.SharedWorker)
   /**
    * Specifies where to persist data for this adapter
    */
@@ -107,7 +110,7 @@ export type WebAdapterOptions = {
  * @example
  * ```ts
  * import { makePersistedAdapter } from '@livestore/adapter-web'
- * import LiveStoreWorker from './livestore.worker?worker'
+ * import LiveStoreWorker from './livestore.worker.ts?worker'
  * import LiveStoreSharedWorker from '@livestore/adapter-web/shared-worker?sharedworker'
  *
  * const adapter = makePersistedAdapter({
@@ -170,15 +173,15 @@ export const makePersistedAdapter =
 
       const sharedWebWorker = tryAsFunctionAndNew(options.sharedWorker, { name: `livestore-shared-worker-${storeId}` })
 
-      const sharedWorkerFiber = yield* Worker.makePoolSerialized<typeof WorkerSchema.SharedWorker.Request.Type>({
+      const sharedWorkerFiber = yield* Worker.makePoolSerialized<typeof WorkerSchema.SharedWorkerRequest.Type>({
         size: 1,
         concurrency: 100,
         initialMessage: () =>
-          new WorkerSchema.SharedWorker.InitialMessage({
+          new WorkerSchema.SharedWorkerInitialMessage({
             liveStoreVersion,
             payload: {
               _tag: 'FromClientSession',
-              initialMessage: new WorkerSchema.LeaderWorkerInner.InitialMessage({
+              initialMessage: new WorkerSchema.LeaderWorkerInnerInitialMessage({
                 storageOptions,
                 storeId,
                 clientId,
@@ -229,9 +232,8 @@ export const makePersistedAdapter =
         // and adding the `sessionId` to make it easier to debug which session a worker belongs to in logs
         const worker = tryAsFunctionAndNew(options.worker, { name: `livestore-worker-${storeId}-${sessionId}` })
 
-        yield* Worker.makeSerialized<WorkerSchema.LeaderWorkerOuter.Request>({
-          initialMessage: () =>
-            new WorkerSchema.LeaderWorkerOuter.InitialMessage({ port: mc.port1, storeId, clientId }),
+        yield* Worker.makeSerialized<WorkerSchema.LeaderWorkerOuterRequest>({
+          initialMessage: () => new WorkerSchema.LeaderWorkerOuterInitialMessage({ port: mc.port1, storeId, clientId }),
         }).pipe(
           Effect.provide(BrowserWorker.layer(() => worker)),
           UnexpectedError.mapToUnexpectedError,
@@ -245,12 +247,12 @@ export const makePersistedAdapter =
 
         const sharedWorker = yield* Fiber.join(sharedWorkerFiber)
         yield* sharedWorker
-          .executeEffect(new WorkerSchema.SharedWorker.UpdateMessagePort({ port: mc.port2 }))
+          .executeEffect(new WorkerSchema.SharedWorkerUpdateMessagePort({ port: mc.port2 }))
           .pipe(UnexpectedError.mapToUnexpectedError, Effect.tapErrorCause(shutdown))
 
         yield* Deferred.succeed(waitForSharedWorkerInitialized, undefined)
 
-        yield* Effect.never
+        return yield* Effect.never
       }).pipe(Effect.withSpan('@livestore/adapter-web:client-session:lock'))
 
       // TODO take/give up lock when tab becomes active/passive
@@ -273,7 +275,7 @@ export const makePersistedAdapter =
         yield* runLocked.pipe(Effect.interruptible, Effect.tapCauseLogPretty, Effect.forkScoped)
       }
 
-      const runInWorker = <TReq extends typeof WorkerSchema.SharedWorker.Request.Type>(
+      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>
@@ -300,7 +302,7 @@ export const makePersistedAdapter =
           Effect.catchAllDefect((cause) => new UnexpectedError({ cause })),
         ) as any
 
-      const runInWorkerStream = <TReq extends typeof WorkerSchema.SharedWorker.Request.Type>(
+      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>
@@ -319,7 +321,7 @@ export const makePersistedAdapter =
           )
         }).pipe(Stream.unwrap) as any
 
-      const bootStatusFiber = yield* runInWorkerStream(new WorkerSchema.LeaderWorkerInner.BootStatusStream()).pipe(
+      const bootStatusFiber = yield* runInWorkerStream(new WorkerSchema.LeaderWorkerInnerBootStatusStream()).pipe(
         Stream.tap((_) => Queue.offer(bootStatusQueue, _)),
         Stream.runDrain,
         Effect.tapErrorCause((cause) => (Cause.isInterruptedOnly(cause) ? Effect.void : shutdown(cause))),
@@ -338,7 +340,7 @@ export const makePersistedAdapter =
       // re-exporting the db
       const initialResult =
         dataFromFile === undefined
-          ? yield* runInWorker(new WorkerSchema.LeaderWorkerInner.GetRecreateSnapshot()).pipe(
+          ? yield* runInWorker(new WorkerSchema.LeaderWorkerInnerGetRecreateSnapshot()).pipe(
               Effect.map(({ snapshot, migrationsReport }) => ({
                 _tag: 'from-leader-worker' as const,
                 snapshot,
@@ -358,7 +360,7 @@ export const makePersistedAdapter =
       const numberOfTables =
         sqliteDb.select<{ count: number }>(`select count(*) as count from sqlite_master`)[0]?.count ?? 0
       if (numberOfTables === 0) {
-        yield* UnexpectedError.make({
+        return yield* UnexpectedError.make({
           cause: `Encountered empty or corrupted database`,
           payload: { snapshotByteLength: initialResult.snapshot.byteLength, storageOptions: options.storage },
         })
@@ -366,17 +368,15 @@ export const makePersistedAdapter =
 
       // We're restoring the leader head from the SESSION_CHANGESET_META_TABLE, not from the eventlog db/table
       // in order to avoid exporting/transferring the eventlog db/table, which is important to speed up the fast path.
-      const initialLeaderHeadRes = sqliteDb.select<{
-        seqNumGlobal: EventSequenceNumber.GlobalEventSequenceNumber
-        seqNumClient: EventSequenceNumber.ClientEventSequenceNumber
-      }>(
-        `select seqNumGlobal, seqNumClient from ${SystemTables.SESSION_CHANGESET_META_TABLE} order by seqNumGlobal desc, seqNumClient desc limit 1`,
-      )[0]
+      const initialLeaderHeadRes = sqliteDb.select(
+        sessionChangesetMetaTable.select('seqNumClient', 'seqNumGlobal', 'seqNumRebaseGeneration').first(),
+      )
 
       const initialLeaderHead = initialLeaderHeadRes
         ? EventSequenceNumber.make({
             global: initialLeaderHeadRes.seqNumGlobal,
             client: initialLeaderHeadRes.seqNumClient,
+            rebaseGeneration: initialLeaderHeadRes.seqNumRebaseGeneration,
           })
         : EventSequenceNumber.ROOT
 
@@ -402,7 +402,7 @@ export const makePersistedAdapter =
       )
 
       const leaderThread: ClientSession['leaderThread'] = {
-        export: runInWorker(new WorkerSchema.LeaderWorkerInner.Export()).pipe(
+        export: runInWorker(new WorkerSchema.LeaderWorkerInnerExport()).pipe(
           Effect.timeout(10_000),
           UnexpectedError.mapToUnexpectedError,
           Effect.withSpan('@livestore/adapter-web:client-session:export'),
@@ -410,9 +410,9 @@ export const makePersistedAdapter =
 
         events: {
           pull: ({ cursor }) =>
-            runInWorkerStream(new WorkerSchema.LeaderWorkerInner.PullStream({ cursor })).pipe(Stream.orDie),
+            runInWorkerStream(new WorkerSchema.LeaderWorkerInnerPullStream({ cursor })).pipe(Stream.orDie),
           push: (batch) =>
-            runInWorker(new WorkerSchema.LeaderWorkerInner.PushToLeader({ batch })).pipe(
+            runInWorker(new WorkerSchema.LeaderWorkerInnerPushToLeader({ batch })).pipe(
               Effect.withSpan('@livestore/adapter-web:client-session:pushToLeader', {
                 attributes: { batchSize: batch.length },
               }),
@@ -421,19 +421,19 @@ export const makePersistedAdapter =
 
         initialState: { leaderHead: initialLeaderHead, migrationsReport },
 
-        getEventlogData: runInWorker(new WorkerSchema.LeaderWorkerInner.ExportEventlog()).pipe(
+        getEventlogData: runInWorker(new WorkerSchema.LeaderWorkerInnerExportEventlog()).pipe(
           Effect.timeout(10_000),
           UnexpectedError.mapToUnexpectedError,
           Effect.withSpan('@livestore/adapter-web:client-session:getEventlogData'),
         ),
 
-        getSyncState: runInWorker(new WorkerSchema.LeaderWorkerInner.GetLeaderSyncState()).pipe(
+        getSyncState: runInWorker(new WorkerSchema.LeaderWorkerInnerGetLeaderSyncState()).pipe(
           UnexpectedError.mapToUnexpectedError,
           Effect.withSpan('@livestore/adapter-web:client-session:getLeaderSyncState'),
         ),
 
         sendDevtoolsMessage: (message) =>
-          runInWorker(new WorkerSchema.LeaderWorkerInner.ExtraDevtoolsMessage({ message })).pipe(
+          runInWorker(new WorkerSchema.LeaderWorkerInnerExtraDevtoolsMessage({ message })).pipe(
             UnexpectedError.mapToUnexpectedError,
             Effect.withSpan('@livestore/adapter-web:client-session:devtoolsMessageForLeader'),
           ),
@@ -500,7 +500,7 @@ const ensureBrowserRequirements = Effect.gen(function* () {
   const validate = (condition: boolean, label: string) =>
     Effect.gen(function* () {
       if (condition) {
-        yield* UnexpectedError.make({
+        return yield* UnexpectedError.make({
           cause: `[@livestore/adapter-web] Browser not supported. The LiveStore web adapter needs '${label}' to work properly`,
         })
       }

package/src/web-worker/common/persisted-sqlite.ts

@@ -3,8 +3,8 @@ import type { LiveStoreSchema } from '@livestore/common/schema'
 import { decodeSAHPoolFilename, HEADER_OFFSET_DATA } from '@livestore/sqlite-wasm/browser'
 import { Effect, Schedule, Schema } from '@livestore/utils/effect'
 
-import * as OpfsUtils from '../../opfs-utils.js'
-import type * as WorkerSchema from './worker-schema.js'
+import * as OpfsUtils from '../../opfs-utils.ts'
+import type * as WorkerSchema from './worker-schema.ts'
 
 export class PersistedSqliteError extends Schema.TaggedError<PersistedSqliteError>()('PersistedSqliteError', {
   cause: Schema.Defect,
@@ -47,7 +47,7 @@ export const readPersistedAppDbFromClientSession = ({
 
     const fileResults = await Promise.all(files.map(tryGetDbFile))
 
-    const appDbFileName = '/' + getStateDbFileName(schema)
+    const appDbFileName = `/${getStateDbFileName(schema)}`
 
     const dbFileRes = fileResults.find((_) => _?.fileName === appDbFileName)
     // console.debug('fileResults', fileResults, 'dbFileRes', dbFileRes)

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

@@ -2,7 +2,6 @@ import {
   BootStatus,
   Devtools,
   LeaderAheadError,
-  LeaderPullCursor,
   liveStoreVersion,
   MigrationsReport,
   SyncState,
@@ -44,19 +43,21 @@ export type StorageTypeEncoded = typeof StorageType.Encoded
 export const SyncBackendOptions = Schema.Record({ key: Schema.String, value: Schema.JsonValue })
 export type SyncBackendOptions = Record<string, Schema.JsonValue>
 
-export namespace LeaderWorkerOuter {
-  export class InitialMessage extends Schema.TaggedRequest<InitialMessage>()('InitialMessage', {
+export class LeaderWorkerOuterInitialMessage extends Schema.TaggedRequest<LeaderWorkerOuterInitialMessage>()(
+  'InitialMessage',
+  {
     payload: { port: Transferable.MessagePort, storeId: Schema.String, clientId: Schema.String },
     success: Schema.Void,
     failure: UnexpectedError,
-  }) {}
+  },
+) {}
 
-  export class Request extends Schema.Union(InitialMessage) {}
-}
+export class LeaderWorkerOuterRequest extends Schema.Union(LeaderWorkerOuterInitialMessage) {}
 
 // TODO unify this code with schema from node adapter
-export namespace LeaderWorkerInner {
-  export class InitialMessage extends Schema.TaggedRequest<InitialMessage>()('InitialMessage', {
+export class LeaderWorkerInnerInitialMessage extends Schema.TaggedRequest<LeaderWorkerInnerInitialMessage>()(
+  'InitialMessage',
+  {
     payload: {
       storageOptions: StorageType,
       devtoolsEnabled: Schema.Boolean,
@@ -67,137 +68,158 @@ export namespace LeaderWorkerInner {
     },
     success: Schema.Void,
     failure: UnexpectedError,
-  }) {}
+  },
+) {}
 
-  export class BootStatusStream extends Schema.TaggedRequest<BootStatusStream>()('BootStatusStream', {
+export class LeaderWorkerInnerBootStatusStream extends Schema.TaggedRequest<LeaderWorkerInnerBootStatusStream>()(
+  'BootStatusStream',
+  {
     payload: {},
     success: BootStatus,
     failure: UnexpectedError,
-  }) {}
+  },
+) {}
 
-  export class PushToLeader extends Schema.TaggedRequest<PushToLeader>()('PushToLeader', {
+export class LeaderWorkerInnerPushToLeader extends Schema.TaggedRequest<LeaderWorkerInnerPushToLeader>()(
+  'PushToLeader',
+  {
     payload: {
       batch: Schema.Array(LiveStoreEvent.AnyEncoded),
     },
     success: Schema.Void,
     failure: Schema.Union(UnexpectedError, LeaderAheadError),
-  }) {}
-
-  export class PullStream extends Schema.TaggedRequest<PullStream>()('PullStream', {
-    payload: {
-      cursor: LeaderPullCursor,
-    },
-    success: Schema.Struct({
-      payload: SyncState.PayloadUpstream,
-      mergeCounter: Schema.Number,
-    }),
-    failure: UnexpectedError,
-  }) {}
-
-  export class Export extends Schema.TaggedRequest<Export>()('Export', {
-    payload: {},
-    success: Transferable.Uint8Array,
-    failure: UnexpectedError,
-  }) {}
-
-  export class ExportEventlog extends Schema.TaggedRequest<ExportEventlog>()('ExportEventlog', {
+  },
+) {}
+
+export class LeaderWorkerInnerPullStream extends Schema.TaggedRequest<LeaderWorkerInnerPullStream>()('PullStream', {
+  payload: {
+    cursor: EventSequenceNumber.EventSequenceNumber,
+  },
+  success: Schema.Struct({
+    payload: SyncState.PayloadUpstream,
+  }),
+  failure: UnexpectedError,
+}) {}
+
+export class LeaderWorkerInnerExport extends Schema.TaggedRequest<LeaderWorkerInnerExport>()('Export', {
+  payload: {},
+  success: Transferable.Uint8Array,
+  failure: UnexpectedError,
+}) {}
+
+export class LeaderWorkerInnerExportEventlog extends Schema.TaggedRequest<LeaderWorkerInnerExportEventlog>()(
+  'ExportEventlog',
+  {
     payload: {},
     success: Transferable.Uint8Array,
     failure: UnexpectedError,
-  }) {}
+  },
+) {}
 
-  export class GetRecreateSnapshot extends Schema.TaggedRequest<GetRecreateSnapshot>()('GetRecreateSnapshot', {
+export class LeaderWorkerInnerGetRecreateSnapshot extends Schema.TaggedRequest<LeaderWorkerInnerGetRecreateSnapshot>()(
+  'GetRecreateSnapshot',
+  {
     payload: {},
     success: Schema.Struct({
       snapshot: Transferable.Uint8Array,
       migrationsReport: MigrationsReport,
     }),
     failure: UnexpectedError,
-  }) {}
+  },
+) {}
 
-  export class GetLeaderHead extends Schema.TaggedRequest<GetLeaderHead>()('GetLeaderHead', {
+export class LeaderWorkerInnerGetLeaderHead extends Schema.TaggedRequest<LeaderWorkerInnerGetLeaderHead>()(
+  'GetLeaderHead',
+  {
     payload: {},
     success: EventSequenceNumber.EventSequenceNumber,
     failure: UnexpectedError,
-  }) {}
+  },
+) {}
 
-  export class GetLeaderSyncState extends Schema.TaggedRequest<GetLeaderSyncState>()('GetLeaderSyncState', {
+export class LeaderWorkerInnerGetLeaderSyncState extends Schema.TaggedRequest<LeaderWorkerInnerGetLeaderSyncState>()(
+  'GetLeaderSyncState',
+  {
     payload: {},
     success: SyncState.SyncState,
     failure: UnexpectedError,
-  }) {}
-
-  export class Shutdown extends Schema.TaggedRequest<Shutdown>()('Shutdown', {
-    payload: {},
-    success: Schema.Void,
-    failure: UnexpectedError,
-  }) {}
-
-  export class ExtraDevtoolsMessage extends Schema.TaggedRequest<ExtraDevtoolsMessage>()('ExtraDevtoolsMessage', {
+  },
+) {}
+
+export class LeaderWorkerInnerShutdown extends Schema.TaggedRequest<LeaderWorkerInnerShutdown>()('Shutdown', {
+  payload: {},
+  success: Schema.Void,
+  failure: UnexpectedError,
+}) {}
+
+export class LeaderWorkerInnerExtraDevtoolsMessage extends Schema.TaggedRequest<LeaderWorkerInnerExtraDevtoolsMessage>()(
+  'ExtraDevtoolsMessage',
+  {
     payload: {
       message: Devtools.Leader.MessageToApp,
     },
     success: Schema.Void,
     failure: UnexpectedError,
-  }) {}
-
-  export const Request = Schema.Union(
-    InitialMessage,
-    BootStatusStream,
-    PushToLeader,
-    PullStream,
-    Export,
-    ExportEventlog,
-    GetRecreateSnapshot,
-    GetLeaderHead,
-    GetLeaderSyncState,
-    Shutdown,
-    ExtraDevtoolsMessage,
-    WebmeshWorker.Schema.CreateConnection,
-  )
-  export type Request = typeof Request.Type
-}
-
-export namespace SharedWorker {
-  export class InitialMessagePayloadFromClientSession extends Schema.TaggedStruct('FromClientSession', {
-    initialMessage: LeaderWorkerInner.InitialMessage,
-  }) {}
-
-  export class InitialMessage extends Schema.TaggedRequest<InitialMessage>()('InitialMessage', {
-    payload: {
-      payload: Schema.Union(InitialMessagePayloadFromClientSession, Schema.TaggedStruct('FromWebBridge', {})),
-      // To guard against scenarios where a client session is already running a newer version of LiveStore
-      // We should probably find a better way to handle those cases once they become more common.
-      liveStoreVersion: Schema.Literal(liveStoreVersion),
-    },
-    success: Schema.Void,
-    failure: UnexpectedError,
-  }) {}
-
-  export class UpdateMessagePort extends Schema.TaggedRequest<UpdateMessagePort>()('UpdateMessagePort', {
+  },
+) {}
+
+export const LeaderWorkerInnerRequest = Schema.Union(
+  LeaderWorkerInnerInitialMessage,
+  LeaderWorkerInnerBootStatusStream,
+  LeaderWorkerInnerPushToLeader,
+  LeaderWorkerInnerPullStream,
+  LeaderWorkerInnerExport,
+  LeaderWorkerInnerExportEventlog,
+  LeaderWorkerInnerGetRecreateSnapshot,
+  LeaderWorkerInnerGetLeaderHead,
+  LeaderWorkerInnerGetLeaderSyncState,
+  LeaderWorkerInnerShutdown,
+  LeaderWorkerInnerExtraDevtoolsMessage,
+  WebmeshWorker.Schema.CreateConnection,
+)
+export type LeaderWorkerInnerRequest = typeof LeaderWorkerInnerRequest.Type
+
+export class SharedWorkerInitialMessagePayloadFromClientSession extends Schema.TaggedStruct('FromClientSession', {
+  initialMessage: LeaderWorkerInnerInitialMessage,
+}) {}
+
+export class SharedWorkerInitialMessage extends Schema.TaggedRequest<SharedWorkerInitialMessage>()('InitialMessage', {
+  payload: {
+    payload: Schema.Union(SharedWorkerInitialMessagePayloadFromClientSession, Schema.TaggedStruct('FromWebBridge', {})),
+    // To guard against scenarios where a client session is already running a newer version of LiveStore
+    // We should probably find a better way to handle those cases once they become more common.
+    liveStoreVersion: Schema.Literal(liveStoreVersion),
+  },
+  success: Schema.Void,
+  failure: UnexpectedError,
+}) {}
+
+export class SharedWorkerUpdateMessagePort extends Schema.TaggedRequest<SharedWorkerUpdateMessagePort>()(
+  'UpdateMessagePort',
+  {
     payload: {
       port: Transferable.MessagePort,
     },
     success: Schema.Void,
     failure: UnexpectedError,
-  }) {}
-
-  export class Request extends Schema.Union(
-    InitialMessage,
-    UpdateMessagePort,
-
-    // Proxied requests
-    LeaderWorkerInner.BootStatusStream,
-    LeaderWorkerInner.PushToLeader,
-    LeaderWorkerInner.PullStream,
-    LeaderWorkerInner.Export,
-    LeaderWorkerInner.GetRecreateSnapshot,
-    LeaderWorkerInner.ExportEventlog,
-    LeaderWorkerInner.GetLeaderHead,
-    LeaderWorkerInner.GetLeaderSyncState,
-    LeaderWorkerInner.Shutdown,
-    LeaderWorkerInner.ExtraDevtoolsMessage,
-
-    WebmeshWorker.Schema.CreateConnection,
-  ) {}
-}
+  },
+) {}
+
+export class SharedWorkerRequest extends Schema.Union(
+  SharedWorkerInitialMessage,
+  SharedWorkerUpdateMessagePort,
+
+  // Proxied requests
+  LeaderWorkerInnerBootStatusStream,
+  LeaderWorkerInnerPushToLeader,
+  LeaderWorkerInnerPullStream,
+  LeaderWorkerInnerExport,
+  LeaderWorkerInnerGetRecreateSnapshot,
+  LeaderWorkerInnerExportEventlog,
+  LeaderWorkerInnerGetLeaderHead,
+  LeaderWorkerInnerGetLeaderSyncState,
+  LeaderWorkerInnerShutdown,
+  LeaderWorkerInnerExtraDevtoolsMessage,
+
+  WebmeshWorker.Schema.CreateConnection,
+) {}

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

@@ -25,10 +25,10 @@ import {
 } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 
-import * as OpfsUtils from '../../opfs-utils.js'
-import { getStateDbFileName, sanitizeOpfsDir } from '../common/persisted-sqlite.js'
-import { makeShutdownChannel } from '../common/shutdown-channel.js'
-import * as WorkerSchema from '../common/worker-schema.js'
+import * as OpfsUtils from '../../opfs-utils.ts'
+import { 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
@@ -81,7 +81,7 @@ export const makeWorkerEffect = (options: WorkerOptions) => {
 const makeWorkerRunnerOuter = (
   workerOptions: WorkerOptions,
 ): Layer.Layer<never, WorkerError.WorkerError, WorkerRunner.PlatformRunner | HttpClient.HttpClient> =>
-  WorkerRunner.layerSerialized(WorkerSchema.LeaderWorkerOuter.InitialMessage, {
+  WorkerRunner.layerSerialized(WorkerSchema.LeaderWorkerOuterInitialMessage, {
     // Port coming from client session and forwarded via the shared worker
     InitialMessage: ({ port: incomingRequestsPort, storeId, clientId }) =>
       Effect.gen(function* () {
@@ -102,7 +102,7 @@ const makeWorkerRunnerOuter = (
   })
 
 const makeWorkerRunnerInner = ({ schema, sync: syncOptions }: WorkerOptions) =>
-  WorkerRunner.layerSerialized(WorkerSchema.LeaderWorkerInner.Request, {
+  WorkerRunner.layerSerialized(WorkerSchema.LeaderWorkerInnerRequest, {
     InitialMessage: ({ storageOptions, storeId, clientId, devtoolsEnabled, debugInstanceId, syncPayload }) =>
       Effect.gen(function* () {
         const sqlite3 = yield* Effect.promise(() => loadSqlite3Wasm())

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

@@ -25,8 +25,8 @@ import {
   WorkerRunner,
 } from '@livestore/utils/effect'
 
-import { makeShutdownChannel } from '../common/shutdown-channel.js'
-import * as WorkerSchema from '../common/worker-schema.js'
+import { makeShutdownChannel } from '../common/shutdown-channel.ts'
+import * as WorkerSchema from '../common/worker-schema.ts'
 
 if (isDevEnv()) {
   globalThis.__debugLiveStoreUtils = {
@@ -39,21 +39,21 @@ if (isDevEnv()) {
 const makeWorkerRunner = Effect.gen(function* () {
   const leaderWorkerContextSubRef = yield* SubscriptionRef.make<
     | {
-        worker: Worker.SerializedWorkerPool<WorkerSchema.LeaderWorkerInner.Request>
+        worker: Worker.SerializedWorkerPool<WorkerSchema.LeaderWorkerInnerRequest>
         scope: Scope.CloseableScope
       }
     | undefined
   >(undefined)
 
   const initialMessagePayloadDeferredRef = yield* Deferred.make<
-    typeof WorkerSchema.SharedWorker.InitialMessagePayloadFromClientSession.Type
+    typeof WorkerSchema.SharedWorkerInitialMessagePayloadFromClientSession.Type
   >().pipe(Effect.andThen(Ref.make))
 
   const waitForWorker = SubscriptionRef.waitUntil(leaderWorkerContextSubRef, isNotUndefined).pipe(
     Effect.map((_) => _.worker),
   )
 
-  const forwardRequest = <TReq extends WorkerSchema.LeaderWorkerInner.Request>(
+  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>
@@ -79,7 +79,7 @@ const makeWorkerRunner = Effect.gen(function* () {
       Effect.tapCauseLogPretty,
     ) as any
 
-  const forwardRequestStream = <TReq extends WorkerSchema.LeaderWorkerInner.Request>(
+  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>
@@ -133,14 +133,14 @@ const makeWorkerRunner = Effect.gen(function* () {
     yield* Effect.logDebug('reset')
 
     const initialMessagePayloadDeferred =
-      yield* Deferred.make<typeof WorkerSchema.SharedWorker.InitialMessagePayloadFromClientSession.Type>()
+      yield* Deferred.make<typeof WorkerSchema.SharedWorkerInitialMessagePayloadFromClientSession.Type>()
     yield* Ref.set(initialMessagePayloadDeferredRef, initialMessagePayloadDeferred)
 
     yield* resetCurrentWorkerCtx
     // yield* devtoolsWebBridge.reset
   })
 
-  return WorkerRunner.layerSerialized(WorkerSchema.SharedWorker.Request, {
+  return WorkerRunner.layerSerialized(WorkerSchema.SharedWorkerRequest, {
     InitialMessage: (message) =>
       Effect.gen(function* () {
         if (message.payload._tag === 'FromWebBridge') return
@@ -151,7 +151,7 @@ const makeWorkerRunner = Effect.gen(function* () {
 
         if (deferredAlreadyDone) {
           const previousInitialMessage = yield* Deferred.await(initialMessagePayloadDeferred)
-          const messageSchema = WorkerSchema.LeaderWorkerInner.InitialMessage.pipe(
+          const messageSchema = WorkerSchema.LeaderWorkerInnerInitialMessage.pipe(
             Schema.omit('devtoolsEnabled', 'debugInstanceId'),
           )
           const isEqual = Schema.equivalence(messageSchema)
@@ -194,7 +194,7 @@ const makeWorkerRunner = Effect.gen(function* () {
 
           const workerLayer = yield* Layer.build(BrowserWorker.layer(() => port))
 
-          const worker = yield* Worker.makePoolSerialized<WorkerSchema.LeaderWorkerInner.Request>({
+          const worker = yield* Worker.makePoolSerialized<WorkerSchema.LeaderWorkerInnerRequest>({
             size: 1,
             concurrency: 100,
             initialMessage: () => initialMessagePayload.initialMessage,

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

@@ -1,9 +1,11 @@
+/// <reference lib="dom" />
+
 // @ts-expect-error TODO remove when Vite does proper treeshaking during dev
 globalThis.$RefreshReg$ = () => {}
 // @ts-expect-error TODO remove when Vite does proper treeshaking during dev
 globalThis.$RefreshSig$ = () => (type: any) => type
 
-// @ts-expect-error Needed for React
+// @ts-ignore
 globalThis.process = globalThis.process ?? { env: {} }
 
 globalThis.document = (globalThis as any)?.document ?? {