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

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

@@ -1,143 +1,261 @@
-import { liveStoreStorageFormatVersion, UnexpectedError } from '@livestore/common'
+import { liveStoreStorageFormatVersion } from '@livestore/common'
 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.ts'
+import {
+  decodeAccessHandlePoolFilename,
+  HEADER_OFFSET_DATA,
+  type WebDatabaseMetadataOpfs,
+} from '@livestore/sqlite-wasm/browser'
+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', {
-  cause: Schema.Defect,
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
 }) {}
 
-export const readPersistedAppDbFromClientSession = ({
-  storageOptions,
-  storeId,
-  schema,
-}: {
+export const readPersistedStateDbFromClientSession: (args: {
   storageOptions: WorkerSchema.StorageType
   storeId: string
   schema: LiveStoreSchema
-}) =>
-  Effect.promise(async () => {
-    const directory = sanitizeOpfsDir(storageOptions.directory, storeId)
-    const sahPoolOpaqueDir = await OpfsUtils.getDirHandle(directory).catch(() => undefined)
+}) => Effect.Effect<
+  Uint8Array<ArrayBuffer>,
+  // All the following errors could actually happen:
+  | PersistedSqliteError
+  | WebError.UnknownError
+  | WebError.TypeError
+  | WebError.NotFoundError
+  | WebError.NotAllowedError
+  | WebError.TypeMismatchError
+  | WebError.SecurityError
+  | Opfs.OpfsError,
+  Opfs.Opfs
+> = Effect.fn('@livestore/adapter-web:readPersistedStateDbFromClientSession')(
+  function* ({ storageOptions, storeId, schema }) {
+    const accessHandlePoolDirString = yield* sanitizeOpfsDir(storageOptions.directory, storeId)
 
-    if (sahPoolOpaqueDir === undefined) {
-      return undefined
-    }
+    const accessHandlePoolDirHandle = yield* Opfs.getDirectoryHandleByPath(accessHandlePoolDirString)
+
+    const stateDbFileName = `/${getStateDbFileName(schema)}`
+
+    const handlesStream = yield* Opfs.Opfs.values(accessHandlePoolDirHandle)
+
+    const stateDbFileOption = yield* handlesStream.pipe(
+      Stream.filter((handle): handle is FileSystemFileHandle => handle.kind === 'file'),
+      Stream.mapEffect(
+        (fileHandle) =>
+          Effect.gen(function* () {
+            const file = yield* Opfs.Opfs.getFile(fileHandle)
+            const fileName = yield* Effect.promise(() => decodeAccessHandlePoolFilename(file))
+            return { file, fileName }
+          }),
+        { concurrency: 'unbounded' },
+      ),
+      Stream.find(({ fileName }) => fileName === stateDbFileName),
+      Stream.runHead,
+    )
 
-    const tryGetDbFile = async (fileHandle: FileSystemFileHandle) => {
-      const file = await fileHandle.getFile()
-      const fileName = await decodeSAHPoolFilename(file)
-      return fileName ? { fileName, file } : undefined
+    if (Option.isNone(stateDbFileOption)) {
+      return yield* new PersistedSqliteError({
+        message: `State database file not found in client session (expected '${stateDbFileName}' in '${accessHandlePoolDirString}')`,
+      })
     }
 
-    const getAllFiles = async (asyncIterator: AsyncIterable<FileSystemHandle>): Promise<FileSystemFileHandle[]> => {
-      const results: FileSystemFileHandle[] = []
-      for await (const value of asyncIterator) {
-        if (value.kind === 'file') {
-          results.push(value as FileSystemFileHandle)
-        }
-      }
-      return results
+    const stateDbBuffer = yield* Effect.promise(() =>
+      stateDbFileOption.value.file.slice(HEADER_OFFSET_DATA).arrayBuffer(),
+    )
+
+    // Given the access handle pool always eagerly creates files with empty non-header data,
+    // we want to return undefined if the file exists but is empty
+    if (stateDbBuffer.byteLength === 0) {
+      return yield* new PersistedSqliteError({
+        message: `State database file is empty in client session (expected '${stateDbFileName}' in '${accessHandlePoolDirString}')`,
+      })
     }
 
-    const files = await getAllFiles(sahPoolOpaqueDir.values())
+    return new Uint8Array(stateDbBuffer)
+  },
+  Effect.logWarnIfTakesLongerThan({
+    duration: 1000,
+    label: '@livestore/adapter-web:readPersistedStateDbFromClientSession',
+  }),
+  Effect.withPerformanceMeasure('@livestore/adapter-web:readPersistedStateDbFromClientSession'),
+)
 
-    const fileResults = await Promise.all(files.map(tryGetDbFile))
+export const resetPersistedDataFromClientSession = Effect.fn(
+  '@livestore/adapter-web:resetPersistedDataFromClientSession',
+)(
+  function* ({ storageOptions, storeId }: { storageOptions: WorkerSchema.StorageType; storeId: string }) {
+    const directory = yield* sanitizeOpfsDir(storageOptions.directory, storeId)
+    yield* Opfs.remove(directory).pipe(
+      // We ignore NotFoundError here as it may not exist or have already been deleted
+      Effect.catchTag('@livestore/utils/Web/NotFoundError', () => Effect.void),
+    )
+  },
+  Effect.retry({
+    schedule: Schedule.exponentialBackoff10Sec,
+  }),
+)
 
-    const appDbFileName = `/${getStateDbFileName(schema)}`
+export const sanitizeOpfsDir = Effect.fn('@livestore/adapter-web:sanitizeOpfsDir')(function* (
+  directory: string | undefined,
+  storeId: string,
+) {
+  if (directory === undefined || directory === '' || directory === '/') {
+    return `livestore-${storeId}@${liveStoreStorageFormatVersion}`
+  }
 
-    const dbFileRes = fileResults.find((_) => _?.fileName === appDbFileName)
-    // console.debug('fileResults', fileResults, 'dbFileRes', dbFileRes)
+  if (directory.includes('/')) {
+    return yield* new PersistedSqliteError({
+      message: `Nested directories are not yet supported ('${directory}')`,
+    })
+  }
 
-    if (dbFileRes !== undefined) {
-      const data = await dbFileRes.file.slice(HEADER_OFFSET_DATA).arrayBuffer()
-      // console.debug('readPersistedAppDbFromClientSession', data.byteLength, data)
+  return `${directory}@${liveStoreStorageFormatVersion}`
+})
 
-      // Given the SAH pool always eagerly creates files with empty non-header data,
-      // we want to return undefined if the file exists but is empty
-      if (data.byteLength === 0) {
-        return undefined
-      }
+export const getStateDbFileName = (schema: LiveStoreSchema) => {
+  const schemaHashSuffix =
+    schema.state.sqlite.migrations.strategy === 'manual' ? 'fixed' : schema.state.sqlite.hash.toString()
+  return `state${schemaHashSuffix}.db`
+}
 
-      return new Uint8Array(data)
-    }
+export const MAX_ARCHIVED_STATE_DBS_IN_DEV = 3
+export const ARCHIVE_DIR_NAME = 'archive'
 
-    return undefined
-  }).pipe(
-    Effect.logWarnIfTakesLongerThan({
-      duration: 1000,
-      label: '@livestore/adapter-web:readPersistedAppDbFromClientSession',
-    }),
-    Effect.withPerformanceMeasure('@livestore/adapter-web:readPersistedAppDbFromClientSession'),
-    Effect.withSpan('@livestore/adapter-web:readPersistedAppDbFromClientSession'),
-  )
+/**
+ * Cleanup old state database files after successful migration.
+ * This prevents OPFS file pool capacity from being exhausted by accumulated schema files.
+ *
+ * @param vfs - The AccessHandlePoolVFS instance for safe file operations
+ * @param currentSchema - Current schema (to avoid deleting the active database)
+ */
+export const cleanupOldStateDbFiles: (options: {
+  vfs: WebDatabaseMetadataOpfs['vfs']
+  currentSchema: LiveStoreSchema
+  opfsDirectory: string
+}) => Effect.Effect<
+  void,
+  // All the following errors could actually happen:
+  | WebError.AbortError
+  | WebError.DataCloneError
+  | WebError.EvalError
+  | WebError.InvalidModificationError
+  | WebError.InvalidStateError
+  | WebError.NoModificationAllowedError
+  | WebError.NotAllowedError
+  | WebError.NotFoundError
+  | WebError.QuotaExceededError
+  | WebError.RangeError
+  | WebError.ReferenceError
+  | WebError.SecurityError
+  | WebError.TypeError
+  | WebError.TypeMismatchError
+  | WebError.URIError
+  | WebError.UnknownError
+  | Opfs.OpfsError
+  | PersistedSqliteError,
+  Opfs.Opfs
+> = Effect.fn('@livestore/adapter-web:cleanupOldStateDbFiles')(function* ({ vfs, currentSchema, opfsDirectory }) {
+  // Only cleanup for auto migration strategy because:
+  // - Auto strategy: Creates new database files per schema change (e.g., state123.db, state456.db)
+  //   which accumulate over time and can exhaust OPFS file pool capacity
+  // - Manual strategy: Always reuses the same database file (statefixed.db) across schema changes,
+  //   so there are never multiple old files to clean up
+  if (currentSchema.state.sqlite.migrations.strategy === 'manual') {
+    yield* Effect.logDebug('Skipping state db cleanup - manual migration strategy uses fixed filename')
+    return
+  }
 
-export const resetPersistedDataFromClientSession = ({
-  storageOptions,
-  storeId,
-}: {
-  storageOptions: WorkerSchema.StorageType
-  storeId: string
-}) =>
-  Effect.gen(function* () {
-    const directory = sanitizeOpfsDir(storageOptions.directory, storeId)
-    yield* opfsDeleteAbs(directory)
-  }).pipe(
-    Effect.retry({
-      schedule: Schedule.exponentialBackoff10Sec,
-    }),
-    Effect.withSpan('@livestore/adapter-web:resetPersistedDataFromClientSession'),
+  const isDev = isDevEnv()
+  const currentDbFileName = getStateDbFileName(currentSchema)
+  const currentPath = `/${currentDbFileName}`
+
+  const allPaths = yield* Effect.sync(() => vfs.getTrackedFilePaths())
+  const oldStateDbPaths = allPaths.filter(
+    (path) => path.startsWith('/state') && path.endsWith('.db') && path !== currentPath,
   )
 
-const opfsDeleteAbs = (absPath: string) =>
-  Effect.promise(async () => {
-    // Get the root directory handle
-    const root = await OpfsUtils.rootHandlePromise
+  if (oldStateDbPaths.length === 0) {
+    yield* Effect.logDebug('No old database files found')
+    return
+  }
 
-    // Split the absolute path to traverse directories
-    const pathParts = absPath.split('/').filter((part) => part.length)
+  const absoluteArchiveDirName = `${opfsDirectory}/${ARCHIVE_DIR_NAME}`
+  if (isDev && !(yield* Opfs.exists(absoluteArchiveDirName))) yield* Opfs.makeDirectory(absoluteArchiveDirName)
 
-    try {
-      // Traverse to the target file handle
-      let currentDir = root
-      for (let i = 0; i < pathParts.length - 1; i++) {
-        currentDir = await currentDir.getDirectoryHandle(pathParts[i]!)
-      }
+  for (const path of oldStateDbPaths) {
+    const fileName = path.startsWith('/') ? path.slice(1) : path
+
+    if (isDev) {
+      const archiveFileData = yield* vfs.readFilePayload(fileName)
+
+      const archiveFileName = `${Date.now()}-${fileName}`
+      const archivePath = `${opfsDirectory}/archive/${archiveFileName}`
+      const archiveData = new Uint8Array(archiveFileData)
+
+      // Prefer writeFile (atomic) when createWritable is available (Chrome, Firefox, Safari 26+),
+      // fall back to syncWriteFile (non-atomic) for Safari 18.x compatibility.
+      // TODO: Remove feature detection and use writeFile directly when Safari >= 26 is widely available.
+      const supportsCreateWritable =
+        typeof FileSystemFileHandle !== 'undefined' && 'createWritable' in FileSystemFileHandle.prototype
 
-      // Delete the file
-      await currentDir.removeEntry(pathParts.at(-1)!, { recursive: true })
-    } catch (error) {
-      if (error instanceof DOMException && error.name === 'NotFoundError') {
-        // Can ignore as it's already been deleted or not there in the first place
-        return
+      if (supportsCreateWritable) {
+        yield* Opfs.writeFile(archivePath, archiveData)
       } else {
-        throw error
+        yield* Opfs.syncWriteFile(archivePath, archiveData)
       }
     }
-  }).pipe(
-    UnexpectedError.mapToUnexpectedError,
-    Effect.withSpan('@livestore/adapter-web:worker:opfsDeleteFile', { attributes: { absFilePath: absPath } }),
-  )
 
-export const sanitizeOpfsDir = (directory: string | undefined, storeId: string) => {
-  // Root dir should be `''` not `/`
-  if (directory === undefined || directory === '' || directory === '/')
-    return `livestore-${storeId}@${liveStoreStorageFormatVersion}`
+    const vfsResultCode = yield* Effect.try({
+      try: () => vfs.jDelete(fileName, 0),
+      catch: (cause) =>
+        new PersistedSqliteError({ message: `Failed to delete old state database file: ${fileName}`, cause }),
+    })
 
-  if (directory.includes('/')) {
-    throw new Error(
-      `@livestore/adapter-web:worker:sanitizeOpfsDir: Nested directories are not yet supported ('${directory}')`,
-    )
+    // 0 indicates a successful result in SQLite.
+    // See https://www.sqlite.org/c3ref/c_abort.html
+    if (vfsResultCode !== 0) {
+      return yield* new PersistedSqliteError({
+        message: `Failed to delete old state database file: ${fileName}, got result code: ${vfsResultCode}`,
+      })
+    }
+
+    yield* Effect.logDebug(`Deleted old state database file: ${fileName}`)
   }
 
-  return `${directory}@${liveStoreStorageFormatVersion}`
-}
+  if (isDev) {
+    yield* pruneArchiveDirectory({
+      archiveDirectory: absoluteArchiveDirName,
+      keep: MAX_ARCHIVED_STATE_DBS_IN_DEV,
+    })
+  }
+})
 
-export const getStateDbFileName = (schema: LiveStoreSchema) => {
-  const schemaHashSuffix =
-    schema.state.sqlite.migrations.strategy === 'manual' ? 'fixed' : schema.state.sqlite.hash.toString()
-  return `state${schemaHashSuffix}.db`
-}
+const pruneArchiveDirectory = Effect.fn('@livestore/adapter-web:pruneArchiveDirectory')(function* ({
+  archiveDirectory,
+  keep,
+}: {
+  archiveDirectory: string
+  keep: number
+}) {
+  const archiveDirHandle = yield* Opfs.getDirectoryHandleByPath(archiveDirectory)
+  const handlesStream = yield* Opfs.Opfs.values(archiveDirHandle)
+  const filesWithMetadata = yield* handlesStream.pipe(
+    Stream.filter((handle): handle is FileSystemFileHandle => handle.kind === 'file'),
+    Stream.mapEffect((fileHandle) => Opfs.getMetadata(fileHandle)),
+    Stream.runCollect,
+  )
+  const filesToDelete = filesWithMetadata.pipe(
+    Chunk.sort(Order.mapInput(Order.number, (entry: { lastModified: number }) => entry.lastModified)),
+    Chunk.drop(keep),
+    Chunk.toReadonlyArray,
+  )
+
+  if (filesToDelete.length === 0) return
+
+  yield* Effect.forEach(filesToDelete, ({ name }) => Opfs.Opfs.removeEntry(archiveDirHandle, name))
+
+  yield* Effect.logDebug(`Pruned ${filesToDelete.length} old database file(s) from archive directory`)
+})

package/src/web-worker/common/shutdown-channel.ts

@@ -1,8 +1,15 @@
 import { ShutdownChannel } from '@livestore/common/leader-thread'
-import { WebChannel } from '@livestore/utils/effect'
+import type { Effect, Scope, WebChannel } from '@livestore/utils/effect'
+import { WebChannelBrowser } from '@livestore/utils/effect/browser'
 
-export const makeShutdownChannel = (storeId: string) =>
-  WebChannel.broadcastChannel({
+export const makeShutdownChannel = (
+  storeId: string,
+): Effect.Effect<
+  WebChannel.WebChannel<typeof ShutdownChannel.All.Type, typeof ShutdownChannel.All.Type>,
+  never,
+  Scope.Scope
+> =>
+  WebChannelBrowser.broadcastChannel({
     channelName: `livestore.shutdown.${storeId}`,
     schema: ShutdownChannel.All,
   })

package/src/web-worker/common/worker-disconnect-channel.ts

@@ -1,10 +1,17 @@
-import { Schema, WebChannel } from '@livestore/utils/effect'
+import { type Effect, Schema, type Scope, type WebChannel } from '@livestore/utils/effect'
+import { WebChannelBrowser } from '@livestore/utils/effect/browser'
 
 export class DedicatedWorkerDisconnectBroadcast extends Schema.TaggedStruct('DedicatedWorkerDisconnectBroadcast', {}) {}
 
 /** Used across workers for leader election purposes */
-export const makeWorkerDisconnectChannel = (storeId: string) =>
-  WebChannel.broadcastChannel({
+export const makeWorkerDisconnectChannel = (
+  storeId: string,
+): Effect.Effect<
+  WebChannel.WebChannel<typeof DedicatedWorkerDisconnectBroadcast.Type, typeof DedicatedWorkerDisconnectBroadcast.Type>,
+  never,
+  Scope.Scope
+> =>
+  WebChannelBrowser.broadcastChannel({
     channelName: `livestore.worker-disconnect.${storeId}`,
     schema: DedicatedWorkerDisconnectBroadcast,
   })

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

@@ -4,9 +4,11 @@ import {
   LeaderAheadError,
   liveStoreVersion,
   MigrationsReport,
+  SyncBackend,
   SyncState,
-  UnexpectedError,
+  UnknownError,
 } from '@livestore/common'
+import { StreamEventsOptionsFields } from '@livestore/common/leader-thread'
 import { EventSequenceNumber, LiveStoreEvent } from '@livestore/common/schema'
 import * as WebmeshWorker from '@livestore/devtools-web-common/worker'
 import { Schema, Transferable } from '@livestore/utils/effect'
@@ -48,7 +50,7 @@ export class LeaderWorkerOuterInitialMessage extends Schema.TaggedRequest<Leader
   {
     payload: { port: Transferable.MessagePort, storeId: Schema.String, clientId: Schema.String },
     success: Schema.Void,
-    failure: UnexpectedError,
+    failure: UnknownError,
   },
 ) {}
 
@@ -64,10 +66,10 @@ export class LeaderWorkerInnerInitialMessage extends Schema.TaggedRequest<Leader
       storeId: Schema.String,
       clientId: Schema.String,
       debugInstanceId: Schema.String,
-      syncPayload: Schema.UndefinedOr(Schema.JsonValue),
+      syncPayloadEncoded: Schema.UndefinedOr(Schema.JsonValue),
     },
     success: Schema.Void,
-    failure: UnexpectedError,
+    failure: UnknownError,
   },
 ) {}
 
@@ -76,7 +78,7 @@ export class LeaderWorkerInnerBootStatusStream extends Schema.TaggedRequest<Lead
   {
     payload: {},
     success: BootStatus,
-    failure: UnexpectedError,
+    failure: UnknownError,
   },
 ) {}
 
@@ -84,27 +86,36 @@ export class LeaderWorkerInnerPushToLeader extends Schema.TaggedRequest<LeaderWo
   'PushToLeader',
   {
     payload: {
-      batch: Schema.Array(LiveStoreEvent.AnyEncoded),
+      batch: Schema.Array(Schema.typeSchema(LiveStoreEvent.Client.Encoded)),
     },
-    success: Schema.Void,
-    failure: Schema.Union(UnexpectedError, LeaderAheadError),
+    success: Schema.Void as Schema.Schema<void>,
+    failure: Schema.Union(UnknownError, LeaderAheadError),
   },
 ) {}
 
 export class LeaderWorkerInnerPullStream extends Schema.TaggedRequest<LeaderWorkerInnerPullStream>()('PullStream', {
   payload: {
-    cursor: EventSequenceNumber.EventSequenceNumber,
+    cursor: Schema.typeSchema(EventSequenceNumber.Client.Composite),
   },
   success: Schema.Struct({
     payload: SyncState.PayloadUpstream,
   }),
-  failure: UnexpectedError,
+  failure: UnknownError,
 }) {}
 
+export class LeaderWorkerInnerStreamEvents extends Schema.TaggedRequest<LeaderWorkerInnerStreamEvents>()(
+  'StreamEvents',
+  {
+    payload: StreamEventsOptionsFields,
+    success: LiveStoreEvent.Client.Encoded,
+    failure: UnknownError,
+  },
+) {}
+
 export class LeaderWorkerInnerExport extends Schema.TaggedRequest<LeaderWorkerInnerExport>()('Export', {
   payload: {},
   success: Transferable.Uint8Array as Schema.Schema<Uint8Array<ArrayBuffer>>,
-  failure: UnexpectedError,
+  failure: UnknownError,
 }) {}
 
 export class LeaderWorkerInnerExportEventlog extends Schema.TaggedRequest<LeaderWorkerInnerExportEventlog>()(
@@ -112,7 +123,7 @@ export class LeaderWorkerInnerExportEventlog extends Schema.TaggedRequest<Leader
   {
     payload: {},
     success: Transferable.Uint8Array as Schema.Schema<Uint8Array<ArrayBuffer>>,
-    failure: UnexpectedError,
+    failure: UnknownError,
   },
 ) {}
 
@@ -124,7 +135,7 @@ export class LeaderWorkerInnerGetRecreateSnapshot extends Schema.TaggedRequest<L
       snapshot: Transferable.Uint8Array as Schema.Schema<Uint8Array<ArrayBuffer>>,
       migrationsReport: MigrationsReport,
     }),
-    failure: UnexpectedError,
+    failure: UnknownError,
   },
 ) {}
 
@@ -132,8 +143,8 @@ export class LeaderWorkerInnerGetLeaderHead extends Schema.TaggedRequest<LeaderW
   'GetLeaderHead',
   {
     payload: {},
-    success: EventSequenceNumber.EventSequenceNumber,
-    failure: UnexpectedError,
+    success: Schema.typeSchema(EventSequenceNumber.Client.Composite),
+    failure: UnknownError,
   },
 ) {}
 
@@ -142,14 +153,41 @@ export class LeaderWorkerInnerGetLeaderSyncState extends Schema.TaggedRequest<Le
   {
     payload: {},
     success: SyncState.SyncState,
-    failure: UnexpectedError,
+    failure: UnknownError,
+  },
+) {}
+
+export class LeaderWorkerInnerSyncStateStream extends Schema.TaggedRequest<LeaderWorkerInnerSyncStateStream>()(
+  'SyncStateStream',
+  {
+    payload: {},
+    success: SyncState.SyncState,
+    failure: UnknownError,
+  },
+) {}
+
+export class LeaderWorkerInnerGetNetworkStatus extends Schema.TaggedRequest<LeaderWorkerInnerGetNetworkStatus>()(
+  'GetNetworkStatus',
+  {
+    payload: {},
+    success: SyncBackend.NetworkStatus,
+    failure: UnknownError,
+  },
+) {}
+
+export class LeaderWorkerInnerNetworkStatusStream extends Schema.TaggedRequest<LeaderWorkerInnerNetworkStatusStream>()(
+  'NetworkStatusStream',
+  {
+    payload: {},
+    success: SyncBackend.NetworkStatus,
+    failure: UnknownError,
   },
 ) {}
 
 export class LeaderWorkerInnerShutdown extends Schema.TaggedRequest<LeaderWorkerInnerShutdown>()('Shutdown', {
   payload: {},
   success: Schema.Void,
-  failure: UnexpectedError,
+  failure: UnknownError,
 }) {}
 
 export class LeaderWorkerInnerExtraDevtoolsMessage extends Schema.TaggedRequest<LeaderWorkerInnerExtraDevtoolsMessage>()(
@@ -159,7 +197,7 @@ export class LeaderWorkerInnerExtraDevtoolsMessage extends Schema.TaggedRequest<
       message: Devtools.Leader.MessageToApp,
     },
     success: Schema.Void,
-    failure: UnexpectedError,
+    failure: UnknownError,
   },
 ) {}
 
@@ -168,56 +206,57 @@ export const LeaderWorkerInnerRequest = Schema.Union(
   LeaderWorkerInnerBootStatusStream,
   LeaderWorkerInnerPushToLeader,
   LeaderWorkerInnerPullStream,
+  LeaderWorkerInnerStreamEvents,
   LeaderWorkerInnerExport,
   LeaderWorkerInnerExportEventlog,
   LeaderWorkerInnerGetRecreateSnapshot,
   LeaderWorkerInnerGetLeaderHead,
   LeaderWorkerInnerGetLeaderSyncState,
+  LeaderWorkerInnerSyncStateStream,
+  LeaderWorkerInnerGetNetworkStatus,
+  LeaderWorkerInnerNetworkStatusStream,
   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,
+      // Version gate to prevent mixed LiveStore builds talking to the same SharedWorker
+      liveStoreVersion: Schema.Literal(liveStoreVersion),
+      /**
+       * Initial configuration for the leader worker. This replaces the previous
+       * two-phase SharedWorker handshake and is sent under the tab lock by the
+       * elected leader. Subsequent calls can omit changes and will simply rebind
+       * the port (join) without reinitializing the store.
+       */
+      initial: LeaderWorkerInnerInitialMessage,
     },
     success: Schema.Void,
-    failure: UnexpectedError,
+    failure: UnknownError,
   },
 ) {}
 
 export class SharedWorkerRequest extends Schema.Union(
-  SharedWorkerInitialMessage,
   SharedWorkerUpdateMessagePort,
 
   // Proxied requests
   LeaderWorkerInnerBootStatusStream,
   LeaderWorkerInnerPushToLeader,
   LeaderWorkerInnerPullStream,
+  LeaderWorkerInnerStreamEvents,
   LeaderWorkerInnerExport,
   LeaderWorkerInnerGetRecreateSnapshot,
   LeaderWorkerInnerExportEventlog,
   LeaderWorkerInnerGetLeaderHead,
   LeaderWorkerInnerGetLeaderSyncState,
+  LeaderWorkerInnerSyncStateStream,
+  LeaderWorkerInnerGetNetworkStatus,
+  LeaderWorkerInnerNetworkStatusStream,
   LeaderWorkerInnerShutdown,
   LeaderWorkerInnerExtraDevtoolsMessage,