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

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

@@ -1,6 +1,7 @@
-import type { Adapter, ClientSession, LockStatus } from '@livestore/common'
+import type { Adapter, BootWarningReason, ClientSession, LockStatus } from '@livestore/common'
 import {
   IntentionalShutdownCause,
+  isWorkerTransportError,
   liveStoreVersion,
   makeClientSession,
   StoreInterrupted,
@@ -12,7 +13,7 @@ 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 { isDevEnv, shouldNeverHappen, tryAsFunctionAndNew } from '@livestore/utils'
+import { isDevEnv, omitUndefineds, shouldNeverHappen, tryAsFunctionAndNew } from '@livestore/utils'
 import {
   Cause,
   Deferred,
@@ -20,17 +21,18 @@ import {
   Exit,
   Fiber,
   Layer,
-  ParseResult,
+  Option,
   Queue,
   Schema,
   Stream,
   Subscribable,
   SubscriptionRef,
   Worker,
-  WorkerError,
 } from '@livestore/utils/effect'
-import { BrowserWorker, Opfs, WebLock } from '@livestore/utils/effect/browser'
+import { BrowserWorker, Opfs, WebError, WebLock } from '@livestore/utils/effect/browser'
 import { nanoid } from '@livestore/utils/nanoid'
+
+import { makeSingleTabAdapter } from '../../single-tab/single-tab-adapter.ts'
 import {
   readPersistedStateDbFromClientSession,
   resetPersistedDataFromClientSession,
@@ -41,7 +43,17 @@ import * as WorkerSchema from '../common/worker-schema.ts'
 import { connectWebmeshNodeClientSession } from './client-session-devtools.ts'
 import { loadSqlite3 } from './sqlite-loader.ts'
 
-if (isDevEnv()) {
+/**
+ * Checks if SharedWorker API is available in the current browser context.
+ *
+ * Returns false on Android Chrome and other browsers without SharedWorker support.
+ *
+ * @see https://github.com/livestorejs/livestore/issues/321
+ * @see https://issues.chromium.org/issues/40290702
+ */
+export const canUseSharedWorker = (): boolean => typeof SharedWorker !== 'undefined'
+
+if (isDevEnv() === true) {
   globalThis.__debugLiveStoreUtils = {
     ...globalThis.__debugLiveStoreUtils,
     opfs: Opfs.debugUtils,
@@ -120,6 +132,15 @@ export type WebAdapterOptions = {
  * Creates a web adapter with persistent storage (currently only supports OPFS).
  * Requires both a web worker and a shared worker.
  *
+ * On browsers without SharedWorker support (e.g. Android Chrome), this adapter
+ * automatically falls back to single-tab mode. In single-tab mode:
+ * - Each tab runs independently with its own leader worker
+ * - Multi-tab synchronization is not available
+ * - Devtools are not supported
+ *
+ * @see https://github.com/livestorejs/livestore/issues/321 - SharedWorker tracking issue
+ * @see https://issues.chromium.org/issues/40290702 - Chromium SharedWorker bug
+ *
  * @example
  * ```ts
  * import { makePersistedAdapter } from '@livestore/adapter-web'
@@ -137,6 +158,26 @@ export const makePersistedAdapter =
   (options: WebAdapterOptions): Adapter =>
   (adapterArgs) =>
     Effect.gen(function* () {
+      // Check SharedWorker availability first and fall back to single-tab mode if unavailable
+      if (canUseSharedWorker() === false) {
+        yield* Effect.logWarning(
+          '[@livestore/adapter-web] SharedWorker unavailable (e.g. Android Chrome). ' +
+            'Falling back to single-tab mode. Multi-tab synchronization and devtools are disabled. ' +
+            'See: https://github.com/livestorejs/livestore/issues/321',
+        )
+
+        return yield* makeSingleTabAdapter({
+          worker: options.worker,
+          storage: options.storage,
+          ...omitUndefineds({
+            resetPersistence: options.resetPersistence,
+            clientId: options.clientId,
+            sessionId: options.sessionId,
+            experimental: options.experimental,
+          }),
+        })(adapterArgs)
+      }
+
       const {
         schema,
         storeId,
@@ -168,10 +209,21 @@ export const makePersistedAdapter =
 
       const shutdownChannel = yield* makeShutdownChannel(storeId)
 
-      if (options.resetPersistence === true) {
+      // Check OPFS availability early and notify user if storage is unavailable (e.g. private browsing)
+      const opfsWarning = yield* checkOpfsAvailability
+      if (opfsWarning !== undefined) {
+        yield* Effect.logWarning('[@livestore/adapter-web:client-session] OPFS unavailable', opfsWarning)
+      }
+
+      if (options.resetPersistence === true && opfsWarning === undefined) {
         yield* shutdownChannel.send(IntentionalShutdownCause.make({ reason: 'adapter-reset' }))
 
         yield* resetPersistedDataFromClientSession({ storageOptions, storeId })
+      } else if (options.resetPersistence === true) {
+        yield* Effect.logWarning(
+          '[@livestore/adapter-web:client-session] Skipping persistence reset because storage is unavailable',
+          opfsWarning,
+        )
       }
 
       // Note on fast-path booting:
@@ -181,7 +233,7 @@ export const makePersistedAdapter =
       // We need to be extra careful though to not run into any race conditions or inconsistencies.
       // TODO also verify persisted data
       const dataFromFile =
-        options.experimental?.disableFastPath === true
+        options.experimental?.disableFastPath === true || opfsWarning !== undefined
           ? undefined
           : yield* readPersistedStateDbFromClientSession({ storageOptions, storeId, schema }).pipe(
               Effect.tapError((error) =>
@@ -203,7 +255,7 @@ export const makePersistedAdapter =
       yield* shutdownChannel.listen.pipe(
         Stream.flatten(),
         Stream.tap((cause) =>
-          shutdown(cause._tag === 'LiveStore.IntentionalShutdownCause' ? Exit.succeed(cause) : Exit.fail(cause)),
+          shutdown(cause._tag === 'IntentionalShutdownCause' ? Exit.succeed(cause) : Exit.fail(cause)),
         ),
         Stream.runDrain,
         Effect.interruptible,
@@ -213,7 +265,7 @@ export const makePersistedAdapter =
 
       const sharedWebWorker = tryAsFunctionAndNew(options.sharedWorker, { name: `livestore-shared-worker-${storeId}` })
 
-      if (options.experimental?.awaitSharedWorkerTermination) {
+      if (options.experimental?.awaitSharedWorkerTermination === true) {
         // 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))
@@ -226,7 +278,7 @@ export const makePersistedAdapter =
       }).pipe(
         Effect.provide(sharedWorkerContext),
         Effect.tapCauseLogPretty,
-        UnknownError.mapToUnknownError,
+        Effect.orDie,
         Effect.tapErrorCause((cause) => shutdown(Exit.failCause(cause))),
         Effect.withSpan('@livestore/adapter-web:client-session:setupSharedWorker'),
         Effect.forkScoped,
@@ -238,7 +290,7 @@ export const makePersistedAdapter =
       //
       // Sorry for this pun ...
       let gotLocky = yield* WebLock.tryGetDeferredLock(lockDeferred, LIVESTORE_TAB_LOCK)
-      const lockStatus = yield* SubscriptionRef.make<LockStatus>(gotLocky ? 'has-lock' : 'no-lock')
+      const lockStatus = yield* SubscriptionRef.make<LockStatus>(gotLocky === true ? 'has-lock' : 'no-lock')
 
       // Ideally we can come up with a simpler implementation that doesn't require this
       const waitForSharedWorkerInitialized = yield* Deferred.make<void>()
@@ -323,15 +375,14 @@ export const makePersistedAdapter =
         yield* runLocked.pipe(Effect.interruptible, Effect.tapCauseLogPretty, Effect.forkScoped)
       }
 
-      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, UnknownError | E, R>
-        : never =>
+      const runInWorker = <A, I, E, EI, R>(
+        req: WorkerSchema.SharedWorkerRequest & Schema.WithResult<A, I, E, EI, R>,
+      ): Effect.Effect<A, E, R> =>
         Fiber.join(sharedWorkerFiber).pipe(
           // NOTE we need to wait for the shared worker to be initialized before we can send requests to it
           Effect.tap(() => waitForSharedWorkerInitialized),
-          Effect.flatMap((worker) => worker.executeEffect(req) as any),
+          Effect.flatMap((worker) => worker.executeEffect(req)),
+          Effect.catchIf(isWorkerTransportError, (e) => Effect.die(e)),
           // NOTE we want to treat worker requests as atomic and therefore not allow them to be interrupted
           // Interruption usually only happens during leader re-election or store shutdown
           // Effect.uninterruptible,
@@ -340,40 +391,24 @@ export const makePersistedAdapter =
             duration: 2000,
           }),
           Effect.withSpan(`@livestore/adapter-web:client-session:runInWorker:${req._tag}`),
-          Effect.mapError((cause) =>
-            Schema.is(UnknownError)(cause)
-              ? cause
-              : ParseResult.isParseError(cause) || Schema.is(WorkerError.WorkerError)(cause)
-                ? new UnknownError({ cause })
-                : 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, UnknownError, R>
-        : never =>
+        )
+
+      const runInWorkerStream = <A, I, E, EI, R>(
+        req: WorkerSchema.SharedWorkerRequest & Schema.WithResult<A, I, E, EI, R>,
+      ): Stream.Stream<A, E, R> =>
         Effect.gen(function* () {
           const sharedWorker = yield* Fiber.join(sharedWorkerFiber)
-          return sharedWorker.execute(req as any).pipe(
-            Stream.mapError((cause) =>
-              Schema.is(UnknownError)(cause)
-                ? cause
-                : ParseResult.isParseError(cause) || Schema.is(WorkerError.WorkerError)(cause)
-                  ? new UnknownError({ cause })
-                  : cause,
-            ),
+          return sharedWorker.execute(req).pipe(
+            Stream.refineOrDie((e) => isWorkerTransportError(e) === true ? Option.none() : Option.some(e)),
             Stream.withSpan(`@livestore/adapter-web:client-session:runInWorkerStream:${req._tag}`),
           )
-        }).pipe(Stream.unwrap) as any
+        }).pipe(Stream.unwrap)
 
       const bootStatusFiber = yield* runInWorkerStream(new WorkerSchema.LeaderWorkerInnerBootStatusStream()).pipe(
         Stream.tap((_) => Queue.offer(bootStatusQueue, _)),
         Stream.runDrain,
         Effect.tapErrorCause((cause) =>
-          Cause.isInterruptedOnly(cause) ? Effect.void : shutdown(Exit.failCause(cause)),
+          Cause.isInterruptedOnly(cause) === true ? Effect.void : shutdown(Exit.failCause(cause)),
         ),
         Effect.interruptible,
         Effect.tapCauseLogPretty,
@@ -428,20 +463,21 @@ export const makePersistedAdapter =
           .first(),
       )
 
-      const initialLeaderHead = initialLeaderHeadRes
-        ? EventSequenceNumber.Client.Composite.make({
-            global: initialLeaderHeadRes.seqNumGlobal,
-            client: initialLeaderHeadRes.seqNumClient,
-            rebaseGeneration: initialLeaderHeadRes.seqNumRebaseGeneration,
-          })
-        : EventSequenceNumber.Client.ROOT
+      const initialLeaderHead =
+        initialLeaderHeadRes !== undefined
+          ? EventSequenceNumber.Client.Composite.make({
+              global: initialLeaderHeadRes.seqNumGlobal,
+              client: initialLeaderHeadRes.seqNumClient,
+              rebaseGeneration: initialLeaderHeadRes.seqNumRebaseGeneration,
+            })
+          : EventSequenceNumber.Client.ROOT
 
       // console.debug('[@livestore/adapter-web:client-session] initialLeaderHead', initialLeaderHead)
 
       yield* Effect.addFinalizer((ex) =>
         Effect.gen(function* () {
           if (
-            Exit.isFailure(ex) &&
+            Exit.isFailure(ex) === true &&
             Exit.isInterrupted(ex) === false &&
             Schema.is(IntentionalShutdownCause)(Cause.squash(ex.cause)) === false &&
             Schema.is(StoreInterrupted)(Cause.squash(ex.cause)) === false
@@ -451,7 +487,7 @@ export const makePersistedAdapter =
             yield* Effect.logDebug('[@livestore/adapter-web:client-session] client-session shutdown', gotLocky, ex)
           }
 
-          if (gotLocky) {
+          if (gotLocky === true) {
             yield* Deferred.succeed(lockDeferred, undefined)
           }
         }).pipe(Effect.tapCauseLogPretty, Effect.orDie),
@@ -459,8 +495,7 @@ export const makePersistedAdapter =
 
       const leaderThread: ClientSession['leaderThread'] = {
         export: runInWorker(new WorkerSchema.LeaderWorkerInnerExport()).pipe(
-          Effect.timeout(10_000),
-          UnknownError.mapToUnknownError,
+          Effect.timeoutOrDie(10_000),
           Effect.withSpan('@livestore/adapter-web:client-session:export'),
         ),
 
@@ -480,17 +515,19 @@ export const makePersistedAdapter =
             ),
         },
 
-        initialState: { leaderHead: initialLeaderHead, migrationsReport },
+        initialState: {
+          leaderHead: initialLeaderHead,
+          migrationsReport,
+          storageMode: opfsWarning === undefined ? 'persisted' : 'in-memory',
+        },
 
         getEventlogData: runInWorker(new WorkerSchema.LeaderWorkerInnerExportEventlog()).pipe(
-          Effect.timeout(10_000),
-          UnknownError.mapToUnknownError,
+          Effect.timeoutOrDie(10_000),
           Effect.withSpan('@livestore/adapter-web:client-session:getEventlogData'),
         ),
 
         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),
@@ -498,12 +535,11 @@ export const makePersistedAdapter =
 
         sendDevtoolsMessage: (message) =>
           runInWorker(new WorkerSchema.LeaderWorkerInnerExtraDevtoolsMessage({ message })).pipe(
-            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),
+          get: runInWorker(new WorkerSchema.LeaderWorkerInnerGetNetworkStatus()),
+          changes: runInWorkerStream(new WorkerSchema.LeaderWorkerInnerNetworkStatusStream()),
         }),
       }
 
@@ -546,7 +582,7 @@ const getPersistedId = (key: string, storageType: 'session' | 'local') => {
         ? sessionStorage
         : storageType === 'local'
           ? localStorage
-          : shouldNeverHappen(`[@livestore/adapter-web] Invalid storage type: ${storageType}`)
+          : shouldNeverHappen(`[@livestore/adapter-web] Invalid storage type: ${String(storageType)}`)
 
   // in case of a worker, we need the id of the parent window, to keep the id consistent
   // we also need to handle the case where there are multiple workers being spawned by the same window
@@ -557,7 +593,7 @@ const getPersistedId = (key: string, storageType: 'session' | 'local') => {
   const fullKey = `livestore:${key}`
   const storedKey = storage.getItem(fullKey)
 
-  if (storedKey) return storedKey
+  if (storedKey !== null) return storedKey
 
   const newKey = makeId()
   storage.setItem(fullKey, newKey)
@@ -568,7 +604,7 @@ const getPersistedId = (key: string, storageType: 'session' | 'local') => {
 const ensureBrowserRequirements = Effect.gen(function* () {
   const validate = (condition: boolean, label: string) =>
     Effect.gen(function* () {
-      if (condition) {
+      if (condition === true) {
         return yield* UnknownError.make({
           cause: `[@livestore/adapter-web] Browser not supported. The LiveStore web adapter needs '${label}' to work properly`,
         })
@@ -584,3 +620,29 @@ const ensureBrowserRequirements = Effect.gen(function* () {
     validate(typeof sessionStorage === 'undefined', 'sessionStorage'),
   ])
 })
+
+/**
+ * Attempts to access OPFS and returns a warning if unavailable.
+ *
+ * Common failure scenarios:
+ * - Safari/Firefox private browsing: SecurityError or NotAllowedError
+ * - Permission denied: NotAllowedError
+ * - Quota exceeded: QuotaExceededError
+ */
+const checkOpfsAvailability = Effect.gen(function* () {
+  const opfs = yield* Opfs.Opfs
+  return yield* opfs.getRootDirectoryHandle.pipe(
+    Effect.as(undefined),
+    Effect.catchAll((error) => {
+      const reason: BootWarningReason =
+        Schema.is(WebError.SecurityError)(error) === true || Schema.is(WebError.NotAllowedError)(error) === true
+          ? 'private-browsing'
+          : 'storage-unavailable'
+      const message =
+        reason === 'private-browsing'
+          ? 'Storage unavailable in private browsing mode. LiveStore will continue without persistence.'
+          : 'Storage access denied. LiveStore will continue without persistence.'
+      return Effect.succeed({ reason, message } as const)
+    }),
+  )
+})

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

@@ -16,4 +16,4 @@ if (isServerRuntime === false) {
   sqlite3Promise = loadSqlite3Wasm()
 }
 
-export const loadSqlite3 = () => (isServerRuntime ? loadSqlite3Wasm() : (sqlite3Promise ?? loadSqlite3Wasm()))
+export const loadSqlite3 = () => (isServerRuntime === true ? loadSqlite3Wasm() : (sqlite3Promise ?? loadSqlite3Wasm()))

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

@@ -8,9 +8,10 @@ import {
 import { isDevEnv } from '@livestore/utils'
 import { Chunk, Effect, Option, Order, Schedule, Schema, Stream } from '@livestore/utils/effect'
 import { Opfs, type WebError } from '@livestore/utils/effect/browser'
+
 import type * as WorkerSchema from './worker-schema.ts'
 
-export class PersistedSqliteError extends Schema.TaggedError<PersistedSqliteError>()('PersistedSqliteError', {
+export class PersistedSqliteError extends Schema.TaggedError<PersistedSqliteError>('~@livestore/adapter-web/PersistedSqliteError')('PersistedSqliteError', {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect),
 }) {}
@@ -56,7 +57,7 @@ export const readPersistedStateDbFromClientSession: (args: {
       Stream.runHead,
     )
 
-    if (Option.isNone(stateDbFileOption)) {
+    if (Option.isNone(stateDbFileOption) === true) {
       return yield* new PersistedSqliteError({
         message: `State database file not found in client session (expected '${stateDbFileName}' in '${accessHandlePoolDirString}')`,
       })
@@ -88,9 +89,9 @@ export const resetPersistedDataFromClientSession = Effect.fn(
 )(
   function* ({ storageOptions, storeId }: { storageOptions: WorkerSchema.StorageType; storeId: string }) {
     const directory = yield* sanitizeOpfsDir(storageOptions.directory, storeId)
-    yield* Opfs.remove(directory).pipe(
+    yield* Opfs.remove(directory, { recursive: true }).pipe(
       // We ignore NotFoundError here as it may not exist or have already been deleted
-      Effect.catchTag('@livestore/utils/Web/NotFoundError', () => Effect.void),
+      Effect.catchTag('NotFoundError', () => Effect.void),
     )
   },
   Effect.retry({
@@ -106,7 +107,7 @@ export const sanitizeOpfsDir = Effect.fn('@livestore/adapter-web:sanitizeOpfsDir
     return `livestore-${storeId}@${liveStoreStorageFormatVersion}`
   }
 
-  if (directory.includes('/')) {
+  if (directory.includes('/') === true) {
     return yield* new PersistedSqliteError({
       message: `Nested directories are not yet supported ('${directory}')`,
     })
@@ -183,12 +184,13 @@ export const cleanupOldStateDbFiles: (options: {
   }
 
   const absoluteArchiveDirName = `${opfsDirectory}/${ARCHIVE_DIR_NAME}`
-  if (isDev && !(yield* Opfs.exists(absoluteArchiveDirName))) yield* Opfs.makeDirectory(absoluteArchiveDirName)
+  if (isDev === true && (yield* Opfs.exists(absoluteArchiveDirName)) === false)
+    yield* Opfs.makeDirectory(absoluteArchiveDirName)
 
   for (const path of oldStateDbPaths) {
-    const fileName = path.startsWith('/') ? path.slice(1) : path
+    const fileName = path.startsWith('/') === true ? path.slice(1) : path
 
-    if (isDev) {
+    if (isDev === true) {
       const archiveFileData = yield* vfs.readFilePayload(fileName)
 
       const archiveFileName = `${Date.now()}-${fileName}`
@@ -201,7 +203,7 @@ export const cleanupOldStateDbFiles: (options: {
       const supportsCreateWritable =
         typeof FileSystemFileHandle !== 'undefined' && 'createWritable' in FileSystemFileHandle.prototype
 
-      if (supportsCreateWritable) {
+      if (supportsCreateWritable === true) {
         yield* Opfs.writeFile(archivePath, archiveData)
       } else {
         yield* Opfs.syncWriteFile(archivePath, archiveData)
@@ -225,7 +227,7 @@ export const cleanupOldStateDbFiles: (options: {
     yield* Effect.logDebug(`Deleted old state database file: ${fileName}`)
   }
 
-  if (isDev) {
+  if (isDev === true) {
     yield* pruneArchiveDirectory({
       archiveDirectory: absoluteArchiveDirName,
       keep: MAX_ARCHIVED_STATE_DBS_IN_DEV,
@@ -248,6 +250,7 @@ const pruneArchiveDirectory = Effect.fn('@livestore/adapter-web:pruneArchiveDire
     Stream.runCollect,
   )
   const filesToDelete = filesWithMetadata.pipe(
+    // oxlint-disable-next-line unicorn/no-array-sort -- false positive: Effect Chunk.sort is immutable, not Array#sort (https://github.com/oxc-project/oxc/issues/19110)
     Chunk.sort(Order.mapInput(Order.number, (entry: { lastModified: number }) => entry.lastModified)),
     Chunk.drop(keep),
     Chunk.toReadonlyArray,

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

@@ -1,7 +1,7 @@
 import {
   BootStatus,
   Devtools,
-  LeaderAheadError,
+  RejectedPushError,
   liveStoreVersion,
   MigrationsReport,
   SyncBackend,
@@ -50,7 +50,7 @@ export class LeaderWorkerOuterInitialMessage extends Schema.TaggedRequest<Leader
   {
     payload: { port: Transferable.MessagePort, storeId: Schema.String, clientId: Schema.String },
     success: Schema.Void,
-    failure: UnknownError,
+    failure: Schema.Never,
   },
 ) {}
 
@@ -78,7 +78,7 @@ export class LeaderWorkerInnerBootStatusStream extends Schema.TaggedRequest<Lead
   {
     payload: {},
     success: BootStatus,
-    failure: UnknownError,
+    failure: Schema.Never,
   },
 ) {}
 
@@ -89,7 +89,7 @@ export class LeaderWorkerInnerPushToLeader extends Schema.TaggedRequest<LeaderWo
       batch: Schema.Array(Schema.typeSchema(LiveStoreEvent.Client.Encoded)),
     },
     success: Schema.Void as Schema.Schema<void>,
-    failure: Schema.Union(UnknownError, LeaderAheadError),
+    failure: RejectedPushError,
   },
 ) {}
 
@@ -100,7 +100,7 @@ export class LeaderWorkerInnerPullStream extends Schema.TaggedRequest<LeaderWork
   success: Schema.Struct({
     payload: SyncState.PayloadUpstream,
   }),
-  failure: UnknownError,
+  failure: Schema.Never,
 }) {}
 
 export class LeaderWorkerInnerStreamEvents extends Schema.TaggedRequest<LeaderWorkerInnerStreamEvents>()(
@@ -108,14 +108,14 @@ export class LeaderWorkerInnerStreamEvents extends Schema.TaggedRequest<LeaderWo
   {
     payload: StreamEventsOptionsFields,
     success: LiveStoreEvent.Client.Encoded,
-    failure: UnknownError,
+    failure: Schema.Never,
   },
 ) {}
 
 export class LeaderWorkerInnerExport extends Schema.TaggedRequest<LeaderWorkerInnerExport>()('Export', {
   payload: {},
   success: Transferable.Uint8Array as Schema.Schema<Uint8Array<ArrayBuffer>>,
-  failure: UnknownError,
+  failure: Schema.Never,
 }) {}
 
 export class LeaderWorkerInnerExportEventlog extends Schema.TaggedRequest<LeaderWorkerInnerExportEventlog>()(
@@ -123,7 +123,7 @@ export class LeaderWorkerInnerExportEventlog extends Schema.TaggedRequest<Leader
   {
     payload: {},
     success: Transferable.Uint8Array as Schema.Schema<Uint8Array<ArrayBuffer>>,
-    failure: UnknownError,
+    failure: Schema.Never,
   },
 ) {}
 
@@ -135,7 +135,7 @@ export class LeaderWorkerInnerGetRecreateSnapshot extends Schema.TaggedRequest<L
       snapshot: Transferable.Uint8Array as Schema.Schema<Uint8Array<ArrayBuffer>>,
       migrationsReport: MigrationsReport,
     }),
-    failure: UnknownError,
+    failure: Schema.Never,
   },
 ) {}
 
@@ -144,7 +144,7 @@ export class LeaderWorkerInnerGetLeaderHead extends Schema.TaggedRequest<LeaderW
   {
     payload: {},
     success: Schema.typeSchema(EventSequenceNumber.Client.Composite),
-    failure: UnknownError,
+    failure: Schema.Never,
   },
 ) {}
 
@@ -153,7 +153,7 @@ export class LeaderWorkerInnerGetLeaderSyncState extends Schema.TaggedRequest<Le
   {
     payload: {},
     success: SyncState.SyncState,
-    failure: UnknownError,
+    failure: Schema.Never,
   },
 ) {}
 
@@ -162,7 +162,7 @@ export class LeaderWorkerInnerSyncStateStream extends Schema.TaggedRequest<Leade
   {
     payload: {},
     success: SyncState.SyncState,
-    failure: UnknownError,
+    failure: Schema.Never,
   },
 ) {}
 
@@ -171,7 +171,7 @@ export class LeaderWorkerInnerGetNetworkStatus extends Schema.TaggedRequest<Lead
   {
     payload: {},
     success: SyncBackend.NetworkStatus,
-    failure: UnknownError,
+    failure: Schema.Never,
   },
 ) {}
 
@@ -180,14 +180,14 @@ export class LeaderWorkerInnerNetworkStatusStream extends Schema.TaggedRequest<L
   {
     payload: {},
     success: SyncBackend.NetworkStatus,
-    failure: UnknownError,
+    failure: Schema.Never,
   },
 ) {}
 
 export class LeaderWorkerInnerShutdown extends Schema.TaggedRequest<LeaderWorkerInnerShutdown>()('Shutdown', {
   payload: {},
   success: Schema.Void,
-  failure: UnknownError,
+  failure: Schema.Never,
 }) {}
 
 export class LeaderWorkerInnerExtraDevtoolsMessage extends Schema.TaggedRequest<LeaderWorkerInnerExtraDevtoolsMessage>()(
@@ -197,7 +197,7 @@ export class LeaderWorkerInnerExtraDevtoolsMessage extends Schema.TaggedRequest<
       message: Devtools.Leader.MessageToApp,
     },
     success: Schema.Void,
-    failure: UnknownError,
+    failure: Schema.Never,
   },
 ) {}
 
@@ -241,7 +241,7 @@ export class SharedWorkerUpdateMessagePort extends Schema.TaggedRequest<SharedWo
   },
 ) {}
 
-export class SharedWorkerRequest extends Schema.Union(
+export const SharedWorkerRequest = Schema.Union(
   SharedWorkerUpdateMessagePort,
 
   // Proxied requests
@@ -261,4 +261,5 @@ export class SharedWorkerRequest extends Schema.Union(
   LeaderWorkerInnerExtraDevtoolsMessage,
 
   WebmeshWorker.Schema.CreateConnection,
-) {}
+)
+export type SharedWorkerRequest = typeof SharedWorkerRequest.Type