oysterun 1.5.7 → 1.6.0-beta.0

package/dev/client/connectivity/completed-message-visibility.d.mts

@@ -0,0 +1,30 @@
+export type VisibilityRect = {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+  width: number;
+  height: number;
+};
+
+export function isCompletedMessageViewportVisible(input: {
+  elementRect: VisibilityRect | DOMRect;
+  viewportRect: VisibilityRect | DOMRect;
+}): boolean;
+
+export function evaluateCompletedMessageVisibilityAcknowledgement(input: {
+  routeCChatShell: boolean;
+  currentHostSessionId?: string;
+  targetHostSessionId?: string;
+  currentMatrixRoomId?: string;
+  targetMatrixRoomId?: string;
+  latestCompletedEventId?: string | null;
+  renderedEventId?: string | null;
+  hasUnreadCompletedMessage?: boolean;
+  documentVisibilityState?: string;
+  documentHasFocus?: boolean;
+  elementConnected?: boolean;
+  elementHidden?: boolean;
+  elementRect?: VisibilityRect | DOMRect;
+  viewportRect?: VisibilityRect | DOMRect;
+}): { qualified: boolean; reason: string };

package/dev/client/connectivity/completed-message-visibility.mjs

@@ -0,0 +1,67 @@
+function finite(value) {
+  return Number.isFinite(value) ? Number(value) : 0;
+}
+
+export function isCompletedMessageViewportVisible({
+  elementRect,
+  viewportRect,
+}) {
+  if (!elementRect || !viewportRect) return false;
+  const width = Math.max(
+    0,
+    Math.min(finite(elementRect.right), finite(viewportRect.right)) -
+      Math.max(finite(elementRect.left), finite(viewportRect.left))
+  );
+  const height = Math.max(
+    0,
+    Math.min(finite(elementRect.bottom), finite(viewportRect.bottom)) -
+      Math.max(finite(elementRect.top), finite(viewportRect.top))
+  );
+  return (
+    width >= Math.min(16, Math.max(1, finite(elementRect.width))) &&
+    height >= Math.min(16, Math.max(1, finite(elementRect.height)))
+  );
+}
+
+export function evaluateCompletedMessageVisibilityAcknowledgement({
+  routeCChatShell,
+  currentHostSessionId,
+  targetHostSessionId,
+  currentMatrixRoomId,
+  targetMatrixRoomId,
+  latestCompletedEventId,
+  renderedEventId,
+  hasUnreadCompletedMessage,
+  documentVisibilityState,
+  documentHasFocus,
+  elementConnected,
+  elementHidden,
+  elementRect,
+  viewportRect,
+}) {
+  if (routeCChatShell !== true)
+    return { qualified: false, reason: "not_current_chat" };
+  if (!currentHostSessionId || currentHostSessionId !== targetHostSessionId) {
+    return { qualified: false, reason: "other_session" };
+  }
+  if (!currentMatrixRoomId || currentMatrixRoomId !== targetMatrixRoomId) {
+    return { qualified: false, reason: "other_room" };
+  }
+  if (hasUnreadCompletedMessage !== true)
+    return { qualified: false, reason: "not_unread" };
+  if (!latestCompletedEventId || latestCompletedEventId !== renderedEventId) {
+    return { qualified: false, reason: "stale_or_unrendered_event" };
+  }
+  if (documentVisibilityState !== "visible") {
+    return { qualified: false, reason: "hidden_document" };
+  }
+  if (documentHasFocus !== true)
+    return { qualified: false, reason: "unfocused_document" };
+  if (elementConnected !== true || elementHidden === true) {
+    return { qualified: false, reason: "event_not_materially_rendered" };
+  }
+  if (!isCompletedMessageViewportVisible({ elementRect, viewportRect })) {
+    return { qualified: false, reason: "event_outside_viewport" };
+  }
+  return { qualified: true, reason: "visible_latest_successful_final" };
+}

package/dev/client/connectivity/internal-connectivity-status.d.mts

@@ -1,3 +1,12 @@
+export type ManagedWebRtcStageStatus =
+  | "Configuration"
+  | "Browser offer"
+  | "ICE gathering"
+  | "Browser ticket"
+  | "Signaling"
+  | "Answer application"
+  | "Data channel";
+
 export type InternalConnectivityStatus = {
   matrix: "Connected" | "Reconnecting" | "Error" | "Offline";
   activePath:
@@ -10,6 +19,8 @@ export type InternalConnectivityStatus = {
     | "Direct"
     | "None";
   promotion: "Idle" | `Attempt ${number}/4` | "Quiesced" | "Not applicable";
+  stage?: ManagedWebRtcStageStatus;
+  lastIssue?: `${ManagedWebRtcStageStatus} timeout`;
 };
 
 export const INTERNAL_CONNECTIVITY_PROMOTION_ATTEMPT_LIMIT: 4;

package/dev/client/connectivity/internal-connectivity-status.mjs

@@ -21,6 +21,26 @@ const WEBRTC_SELECTED_PATH_STATUS = Object.freeze({
   ipv6: "WebRTC (IPv6 Direct)",
 });
 
+const MANAGED_WEBRTC_STAGE_STATUS = Object.freeze({
+  configuration_fetch: "Configuration",
+  browser_offer: "Browser offer",
+  browser_ice_gathering: "ICE gathering",
+  browser_ticket: "Browser ticket",
+  signaling_exchange: "Signaling",
+  answer_application: "Answer application",
+  datachannel_open: "Data channel",
+});
+
+const MANAGED_WEBRTC_STAGE_TIMEOUT_CODE = Object.freeze({
+  configuration_fetch: "managed_webrtc_configuration_fetch_timeout",
+  browser_offer: "managed_webrtc_browser_offer_timeout",
+  browser_ice_gathering: "managed_webrtc_browser_ice_gather_timeout",
+  browser_ticket: "managed_webrtc_browser_ticket_timeout",
+  signaling_exchange: "managed_webrtc_signaling_exchange_timeout",
+  answer_application: "managed_webrtc_answer_application_timeout",
+  datachannel_open: "managed_webrtc_datachannel_open_timeout",
+});
+
 export const INTERNAL_CONNECTIVITY_PROMOTION_ATTEMPT_LIMIT = 4;
 
 function finiteNonNegativeInteger(value) {
@@ -62,9 +82,32 @@ export function deriveInternalConnectivityStatus({
         : "Idle";
   }
 
-  return Object.freeze({ matrix, activePath, promotion });
+  const activeStageKey = transportStatus.managed_webrtc_active_stage;
+  const activeStage = MANAGED_WEBRTC_STAGE_STATUS[activeStageKey];
+  const lastIssueStageKey = transportStatus.managed_webrtc_last_issue_stage;
+  const lastIssueStage = MANAGED_WEBRTC_STAGE_STATUS[lastIssueStageKey];
+  const lastIssue =
+    !activeStage &&
+    lastIssueStage &&
+    transportStatus.managed_webrtc_last_issue_code ===
+      MANAGED_WEBRTC_STAGE_TIMEOUT_CODE[lastIssueStageKey]
+      ? `${lastIssueStage} timeout`
+      : null;
+
+  return Object.freeze({
+    matrix,
+    activePath,
+    promotion,
+    ...(activeStage ? { stage: activeStage } : {}),
+    ...(lastIssue ? { lastIssue } : {}),
+  });
 }
 
 export function internalConnectivityStatusText(status) {
-  return `Debug Network Connection Status · Matrix: ${status.matrix} · Active path: ${status.activePath} · WebRTC promotion: ${status.promotion}`;
+  const detail = status.stage
+    ? ` · Stage: ${status.stage}`
+    : status.lastIssue
+    ? ` · Last issue: ${status.lastIssue}`
+    : "";
+  return `Debug Network Connection Status · Matrix: ${status.matrix} · Active path: ${status.activePath} · WebRTC promotion: ${status.promotion}${detail}`;
 }

package/dev/client/connectivity/managed-host-browser.d.mts

@@ -25,6 +25,7 @@ export type ManagedHostTicketProvider = (input: {
   configuration: Record<string, unknown>;
   connectionAttemptId: string;
   dtlsFingerprintSha256: string;
+  signal?: AbortSignal | null;
 }) => Promise<{
   credential: string;
   client_authority_kind: "app_installation" | "host_owner_browser";

package/dev/client/connectivity/managed-host-browser.mjs

@@ -11,6 +11,7 @@ const REQUIRED_CHANNELS = Object.freeze(["control", "events", "bulk"]);
 const SUPPORTED_TRANSPORT_PROTOCOL_VERSIONS = Object.freeze([1]);
 const MANAGED_TRANSPORT_CONTRACT = "oysterun.managed_webrtc.v1";
 const SIGNALING_TIMEOUT_MS = 20_000;
+const MANAGED_WEBRTC_STAGE_TIMEOUT_MS = 30_000;
 const MANAGED_ICE_CANDIDATE_SETTLE_MS = 100;
 const BOOTSTRAP_SAFE_REQUEST_TIMEOUT_MS = 12_000;
 const BOOTSTRAP_MATRIX_SYNC_TIMEOUT_MS = 45_000;
@@ -80,6 +81,15 @@ const MANAGED_WEBRTC_STAGE_FAILURE_CODES = Object.freeze({
   datachannel_open: "managed_webrtc_datachannel_open_timeout",
   logical_path_promotion: "managed_webrtc_logical_path_promotion_failed",
 });
+const MANAGED_WEBRTC_STAGE_TIMEOUT_CODES = Object.freeze({
+  configuration_fetch: "managed_webrtc_configuration_fetch_timeout",
+  browser_offer: "managed_webrtc_browser_offer_timeout",
+  browser_ice_gathering: "managed_webrtc_browser_ice_gather_timeout",
+  browser_ticket: "managed_webrtc_browser_ticket_timeout",
+  signaling_exchange: "managed_webrtc_signaling_exchange_timeout",
+  answer_application: "managed_webrtc_answer_application_timeout",
+  datachannel_open: "managed_webrtc_datachannel_open_timeout",
+});
 const PRESERVED_MANAGED_WEBRTC_ERROR_CODES = new Set([
   "managed_webrtc_not_enabled",
   "managed_webrtc_protocol_incompatible",
@@ -89,6 +99,7 @@ const PRESERVED_MANAGED_WEBRTC_ERROR_CODES = new Set([
   "managed_webrtc_host_answer_timeout",
   "managed_webrtc_host_ice_gather_timeout",
   "managed_webrtc_host_datachannel_open_timeout",
+  ...Object.values(MANAGED_WEBRTC_STAGE_TIMEOUT_CODES),
 ]);
 const MANAGED_MATRIX_DIAGNOSTIC_EVENTS = new Set([
   "matrix_sync_state_changed",
@@ -371,6 +382,10 @@ function browserConnectionStatusKey(status) {
     status.promotion_attempt_count,
     status.retry_quiesced,
     status.reconnect_pending,
+    status.managed_webrtc_active_stage,
+    status.managed_webrtc_active_stage_started_at,
+    status.managed_webrtc_last_issue_stage,
+    status.managed_webrtc_last_issue_code,
     status.managed_host_unavailable,
     status.closed,
     status.origin_kind,
@@ -393,9 +408,7 @@ export function readManagedWebRtcSelectedPath(hostStatus, connectionId) {
   }
   const matchingPeers = hostStatus.peers.filter(
     (peer) =>
-      peer &&
-      typeof peer === "object" &&
-      peer.connection_id === connectionId
+      peer && typeof peer === "object" && peer.connection_id === connectionId
   );
   if (matchingPeers.length !== 1) return null;
   return normalizeManagedWebRtcSelectedPath(matchingPeers[0].selected_path);
@@ -683,9 +696,7 @@ function createManagedIceCandidateReadiness(
         } else if (!settled) {
           timeoutTimer = setTimeout(
             () =>
-              reject(
-                new Error("Browser ICE candidate gathering timed out")
-              ),
+              reject(new Error("Browser ICE candidate gathering timed out")),
             timeoutMs
           );
         }
@@ -1063,6 +1074,7 @@ export class ManagedHostBrowserConnection {
     bootstrapSafeRequestTimeoutMs = BOOTSTRAP_SAFE_REQUEST_TIMEOUT_MS,
     bootstrapMatrixSyncTimeoutMs = BOOTSTRAP_MATRIX_SYNC_TIMEOUT_MS,
     presenceHealthRecoveryDelaysMs = PRESENCE_HEALTH_RECOVERY_DELAYS_MS,
+    managedWebRtcStageTimeoutMs = MANAGED_WEBRTC_STAGE_TIMEOUT_MS,
   } = {}) {
     this.origin = origin.replace(/\/+$/, "");
     this.fetchImpl = fetchImpl;
@@ -1076,6 +1088,14 @@ export class ManagedHostBrowserConnection {
     ) {
       throw new Error("Managed Bootstrap request timeouts must be positive");
     }
+    if (
+      !Number.isInteger(managedWebRtcStageTimeoutMs) ||
+      managedWebRtcStageTimeoutMs <= 0
+    ) {
+      throw new Error(
+        "Managed WebRTC stage timeout must be a positive integer"
+      );
+    }
     if (
       !Array.isArray(presenceHealthRecoveryDelaysMs) ||
       presenceHealthRecoveryDelaysMs.length === 0 ||
@@ -1096,6 +1116,7 @@ export class ManagedHostBrowserConnection {
     this.presenceHealthRecoveryDelaysMs = Object.freeze([
       ...presenceHealthRecoveryDelaysMs,
     ]);
+    this.managedWebRtcStageTimeoutMs = managedWebRtcStageTimeoutMs;
     this.clientInstanceId = getClientInstanceId();
     this.bootstrapTransport = new BootstrapFetchTransport({
       origin: this.origin,
@@ -1144,6 +1165,8 @@ export class ManagedHostBrowserConnection {
     this.selectedPathStatusReadConnectionId = null;
     this.selectedPathStatusReadPromise = null;
     this.lastRequestFailed = false;
+    this.activeWebRtcStage = null;
+    this.lastWebRtcStageIssue = null;
     this.accounting = createTransportAccounting();
     this.reconciliationOwner = new EpochBoundTransportReconciliationOwner({
       reconcile: (request) => this.runRestartWebRtc(request),
@@ -1190,9 +1213,7 @@ export class ManagedHostBrowserConnection {
       status.active_path_kind === "webrtc" &&
       this.activeConnection?.connectionId
     ) {
-      void this.refreshSelectedWebRtcPath(
-        this.activeConnection.connectionId
-      );
+      void this.refreshSelectedWebRtcPath(this.activeConnection.connectionId);
     }
     return () => {
       this.statusListeners.delete(listener);
@@ -1243,6 +1264,17 @@ export class ManagedHostBrowserConnection {
 
   async runConnectionStage(stage, attempt, operation) {
     const startedAt = Date.now();
+    const timeoutCode = MANAGED_WEBRTC_STAGE_TIMEOUT_CODES[stage] || null;
+    const abortController = timeoutCode ? new AbortController() : null;
+    const activeStage = timeoutCode
+      ? {
+          stage,
+          startedAt,
+          startedAtIso: new Date(startedAt).toISOString(),
+          attempt,
+          abortController,
+        }
+      : null;
     const fields = {
       connection_attempt_id: attempt.connectionAttemptId,
       connection_generation: attempt.connectionGeneration,
@@ -1255,8 +1287,31 @@ export class ManagedHostBrowserConnection {
       event_type: "managed_webrtc_stage_started",
       ...fields,
     });
+    if (activeStage) {
+      this.activeWebRtcStage = activeStage;
+      this.notifyStatusListeners();
+    }
+    let timeoutTimer = null;
     try {
-      const result = await operation();
+      const operationPromise = Promise.resolve().then(() =>
+        operation({ signal: abortController?.signal || null })
+      );
+      const result = timeoutCode
+        ? await Promise.race([
+            operationPromise,
+            new Promise((_, reject) => {
+              timeoutTimer = setTimeout(() => {
+                const timeoutError = managedWebRtcAttemptError(
+                  timeoutCode,
+                  `Managed WebRTC ${stage} stage timed out`
+                );
+                reject(timeoutError);
+                abortController.abort(timeoutError);
+                this.cancelTimedOutWebRtcAttempt(attempt, timeoutError);
+              }, this.managedWebRtcStageTimeoutMs);
+            }),
+          ])
+        : await operationPromise;
       this.emitDiagnostic({
         event_type: "managed_webrtc_stage_completed",
         ...fields,
@@ -1265,6 +1320,13 @@ export class ManagedHostBrowserConnection {
       return result;
     } catch (error) {
       const normalized = stageSpecificManagedWebRtcError(error, stage);
+      if (normalized.code === timeoutCode) {
+        this.lastWebRtcStageIssue = {
+          stage,
+          errorCode: normalized.code,
+          at: new Date().toISOString(),
+        };
+      }
       this.emitDiagnostic({
         event_type: "managed_webrtc_stage_failed",
         ...fields,
@@ -1272,10 +1334,31 @@ export class ManagedHostBrowserConnection {
         stage_duration_ms: Math.max(0, Date.now() - startedAt),
       });
       throw normalized;
+    } finally {
+      if (timeoutTimer !== null) clearTimeout(timeoutTimer);
+      if (this.activeWebRtcStage === activeStage) {
+        this.activeWebRtcStage = null;
+        this.notifyStatusListeners();
+      }
     }
   }
 
-  async nativeJson(path, body) {
+  cancelTimedOutWebRtcAttempt(attempt, timeoutError) {
+    if (this.connectionGeneration === attempt.connectionGeneration) {
+      this.connectionGeneration += 1;
+    }
+    const peer = attempt.peer || null;
+    if (peer && this.pendingIceCandidateReadiness?.peer === peer) {
+      this.pendingIceCandidateReadiness.cancel(timeoutError);
+      this.pendingIceCandidateReadiness = null;
+    }
+    if (peer && this.connectingPeer === peer) {
+      this.connectingPeer = null;
+      peer.close();
+    }
+  }
+
+  async nativeJson(path, body, { signal = null } = {}) {
     const token = getStoredDashboardToken();
     if (!token) throw new Error("Dashboard authentication is unavailable");
     const response = await this.fetchImpl(`${this.origin}${path}`, {
@@ -1289,6 +1372,7 @@ export class ManagedHostBrowserConnection {
         ...body,
       }),
       credentials: "same-origin",
+      ...(signal ? { signal } : {}),
     });
     const data = await response.json().catch(() => ({}));
     if (!response.ok) {
@@ -1492,7 +1576,14 @@ export class ManagedHostBrowserConnection {
     const configurationPayload = await this.runConnectionStage(
       "configuration_fetch",
       attempt,
-      () => this.nativeJson(SIGNALING_PATH_PREFIX + "configuration", {})
+      ({ signal }) =>
+        this.nativeJson(
+          SIGNALING_PATH_PREFIX + "configuration",
+          {},
+          {
+            signal,
+          }
+        )
     );
     const configuration = await this.runConnectionStage(
       "configuration_validation",
@@ -1515,6 +1606,7 @@ export class ManagedHostBrowserConnection {
       iceServers: configuration.ice_servers,
       iceTransportPolicy,
     });
+    attempt.peer = peer;
     this.connectingPeer = peer;
     let iceCandidateReadiness = null;
     try {
@@ -1551,12 +1643,13 @@ export class ManagedHostBrowserConnection {
       const ticket = await this.runConnectionStage(
         "browser_ticket",
         attempt,
-        async () =>
+        async ({ signal }) =>
           this.ticketProvider
             ? await this.ticketProvider({
                 configuration,
                 connectionAttemptId,
                 dtlsFingerprintSha256,
+                signal,
               })
             : {
                 ...(await this.nativeJson(
@@ -1564,7 +1657,8 @@ export class ManagedHostBrowserConnection {
                   {
                     connection_attempt_id: connectionAttemptId,
                     dtls_fingerprint_sha256: dtlsFingerprintSha256,
-                  }
+                  },
+                  { signal }
                 )),
                 client_authority_kind: "host_owner_browser",
               }
@@ -1584,18 +1678,22 @@ export class ManagedHostBrowserConnection {
       const answer = await this.runConnectionStage(
         "signaling_exchange",
         attempt,
-        () =>
-          this.nativeJson(SIGNALING_PATH_PREFIX + "connect", {
-            ticket: ticket.credential,
-            client_authority_kind: ticket.client_authority_kind,
-            connection_attempt_id: connectionAttemptId,
-            dtls_fingerprint_sha256: dtlsFingerprintSha256,
-            offer: {
-              type: localDescription.type,
-              sdp: localDescription.sdp,
+        ({ signal }) =>
+          this.nativeJson(
+            SIGNALING_PATH_PREFIX + "connect",
+            {
+              ticket: ticket.credential,
+              client_authority_kind: ticket.client_authority_kind,
+              connection_attempt_id: connectionAttemptId,
+              dtls_fingerprint_sha256: dtlsFingerprintSha256,
+              offer: {
+                type: localDescription.type,
+                sdp: localDescription.sdp,
+              },
+              candidates: iceCandidateReadiness.candidates,
             },
-            candidates: iceCandidateReadiness.candidates,
-          })
+            { signal }
+          )
       );
       assertCurrentAttempt(peer);
       await this.runConnectionStage("answer_application", attempt, async () => {
@@ -1654,6 +1752,7 @@ export class ManagedHostBrowserConnection {
       );
       assertCurrentAttempt(peer);
       this.lastRequestFailed = false;
+      this.lastWebRtcStageIssue = null;
       this.webrtcSelectedPath = null;
       this.webrtcSelectedPathConnectionId = answer.connection_id;
       this.notifyStatusListeners();
@@ -2495,6 +2594,12 @@ export class ManagedHostBrowserConnection {
       promotion_attempt_count: this.promotionAttemptCount,
       retry_quiesced: this.retryQuiesced,
       reconnect_pending: Boolean(this.reconnectTimer || this.startPromise),
+      managed_webrtc_active_stage: this.activeWebRtcStage?.stage || null,
+      managed_webrtc_active_stage_started_at:
+        this.activeWebRtcStage?.startedAtIso || null,
+      managed_webrtc_last_issue_stage: this.lastWebRtcStageIssue?.stage || null,
+      managed_webrtc_last_issue_code:
+        this.lastWebRtcStageIssue?.errorCode || null,
       reconciliation_epoch: this.reconciliationOwner.status().epoch,
       reconciliation_pending:
         this.reconciliationOwner.status().in_flight ||

package/dev/client/connectivity/session-switcher-state.d.mts

@@ -0,0 +1,16 @@
+export function deriveSessionSwitcherViewportBounds(input: {
+  viewport?: { offsetTop?: number; height?: number } | null;
+  innerHeight: number;
+  headerHeight?: number;
+  bottomObstructionHeight?: number;
+}): { top: number; height: number; bottomInset: number };
+
+export function hasOtherUnreadSession(input: {
+  previews?: Array<{
+    session_id?: string;
+    has_unread_completed_message?: boolean;
+  }>;
+  currentSessionId: string;
+}): boolean;
+
+export function assertSessionSwitcherProjection<T>(value: T): T;

package/dev/client/connectivity/session-switcher-state.mjs

@@ -0,0 +1,72 @@
+export function deriveSessionSwitcherViewportBounds({
+  viewport,
+  innerHeight,
+  headerHeight = 56,
+  bottomObstructionHeight = 0,
+}) {
+  const visibleTop = Number.isFinite(viewport?.offsetTop)
+    ? Math.max(0, viewport.offsetTop)
+    : 0;
+  const visibleHeight = Number.isFinite(viewport?.height)
+    ? Math.max(0, viewport.height)
+    : Math.max(0, Number(innerHeight) || 0);
+  const top = Math.max(headerHeight, visibleTop);
+  return {
+    top,
+    height: Math.max(0, visibleTop + visibleHeight - top),
+    bottomInset: Math.max(0, Number(bottomObstructionHeight) || 0),
+  };
+}
+
+export function hasOtherUnreadSession({ previews, currentSessionId }) {
+  return (Array.isArray(previews) ? previews : []).some(
+    (preview) =>
+      preview?.session_id !== currentSessionId &&
+      preview?.has_unread_completed_message === true
+  );
+}
+
+export function assertSessionSwitcherProjection(value) {
+  const rows = Array.isArray(value?.session_rows) ? value.session_rows : [];
+  const rowIds = rows.map((row) => row?.session_id);
+  const nullableString = (entry) => typeof entry === "string" || entry === null;
+  const validRows = rows.every(
+    (row) =>
+      row &&
+      row.kind === "running" &&
+      typeof row.session_id === "string" &&
+      row.session_id.trim() === row.session_id &&
+      row.session_id.length > 0 &&
+      typeof row.agent_id === "string" &&
+      row.agent_id.trim() === row.agent_id &&
+      row.agent_id.length > 0 &&
+      typeof row.session_name === "string" &&
+      row.session_name.trim().length > 0 &&
+      nullableString(row.agent_folder) &&
+      nullableString(row.runtime) &&
+      nullableString(row.model) &&
+      nullableString(row.started_at) &&
+      nullableString(row.last_active_at) &&
+      nullableString(row.matrix_room_id) &&
+      nullableString(row.resume_unavailable_reason) &&
+      typeof row.running === "boolean" &&
+      row.running === true &&
+      typeof row.resume_supported === "boolean" &&
+      row.resume_supported === false
+  );
+  if (
+    value?.status !== "session_list_previews" ||
+    value.session_switcher_projection_contract !==
+      "routec.p217_live_session_switcher_projection.v1" ||
+    value.session_switcher_projection_batched !== true ||
+    value.session_switcher_per_row_http_requests !== 0 ||
+    value.session_switcher_matrix_query_count !== 0 ||
+    !Number.isSafeInteger(value.session_count) ||
+    value.session_count !== rows.length ||
+    new Set(rowIds).size !== rows.length ||
+    !validRows
+  ) {
+    throw new Error("Session switcher projection is unavailable.");
+  }
+  return value;
+}