@dreamboard-games/cli 0.1.30-alpha.1 → 0.1.30-alpha.2

package/dist/runtime-packages/ui-host-runtime/src/session-state-reducer.ts

@@ -1,1034 +0,0 @@
-import type {
-  GameplayPerspective,
-  GameplayViewport,
-  SessionContext,
-  UnifiedSessionModel,
-} from "./session-model.js";
-import {
-  gameplayViewportForPlayer,
-  getGameplayViewport,
-  getSessionContext,
-  resolveControllablePlayerIds,
-  withContext,
-} from "./session-model.js";
-import type {
-  NormalizedSessionEvent,
-  NormalizedSessionSnapshot,
-} from "./session-ingress.js";
-
-interface ActivityItemBase<
-  TType extends string,
-  TPayload extends { type: TType },
-> {
-  id: string;
-  type: TType;
-  payload: TPayload;
-  timestamp: number;
-}
-
-export type Notification =
-  | (ActivityItemBase<
-      "YOUR_TURN",
-      { type: "YOUR_TURN"; activePlayers: string[] }
-    > & {
-      read: boolean;
-    })
-  | (ActivityItemBase<
-      "PROMPT_OPENED",
-      {
-        type: "PROMPT_OPENED";
-        promptId: string;
-        promptInstanceId: string;
-        targetPlayer: string;
-        title?: string;
-      }
-    > & { read: boolean })
-  | (ActivityItemBase<
-      "ACTION_EXECUTED",
-      { type: "ACTION_EXECUTED"; playerId: string; actionType: string }
-    > & { read: boolean })
-  | (ActivityItemBase<
-      "ACTION_REJECTED",
-      { type: "ACTION_REJECTED"; reason: string; targetPlayer?: string }
-    > & { read: boolean })
-  | (ActivityItemBase<
-      "TURN_CHANGED",
-      {
-        type: "TURN_CHANGED";
-        previousPlayers: string[];
-        currentPlayers: string[];
-      }
-    > & { read: boolean })
-  | (ActivityItemBase<
-      "STATE_CHANGED",
-      { type: "STATE_CHANGED"; newState: string }
-    > & {
-      read: boolean;
-    })
-  | (ActivityItemBase<
-      "GAME_ENDED",
-      {
-        type: "GAME_ENDED";
-        winner?: string;
-        finalScores: Record<string, number>;
-        reason: string;
-      }
-    > & { read: boolean })
-  | (ActivityItemBase<
-      "ERROR",
-      { type: "ERROR"; message: string; code?: string }
-    > & {
-      read: boolean;
-    });
-
-export type NotificationType = Notification["type"];
-export type NotificationPayload = Notification["payload"];
-
-export type HostFeedback =
-  | ActivityItemBase<
-      "ACTION_REJECTED",
-      { type: "ACTION_REJECTED"; reason: string; targetPlayer?: string }
-    >
-  | ActivityItemBase<
-      "PROMPT_OPENED",
-      {
-        type: "PROMPT_OPENED";
-        promptId: string;
-        promptInstanceId: string;
-        targetPlayer: string;
-        title?: string;
-      }
-    >
-  | ActivityItemBase<
-      "YOUR_TURN",
-      { type: "YOUR_TURN"; activePlayers: string[] }
-    >;
-
-export type HostFeedbackType = HostFeedback["type"];
-export type HostFeedbackPayload = HostFeedback["payload"];
-
-export interface SSEEventEntry {
-  id: number;
-  eventType: string;
-  data: unknown;
-  timestamp: string;
-}
-
-export interface ConnectionState {
-  lobby: boolean;
-  gameplay: boolean;
-  error: string | null;
-  isConnected: boolean;
-  recovery: ConnectionRecoveryState;
-}
-
-export interface ConnectionRecoveryState {
-  active: boolean;
-  message: string | null;
-  retryAfterMs: number | null;
-  attempt: number | null;
-  since: number | null;
-}
-
-export interface ActivityState {
-  notifications: Notification[];
-  hostFeedback: HostFeedback[];
-  syncId: number;
-  lastSyncTimestamp: number | null;
-  lastAckTimestamp: number | null;
-}
-
-export interface DebugState {
-  sseEvents: SSEEventEntry[];
-  maxEvents: number;
-}
-
-export interface UnifiedSessionState {
-  session: UnifiedSessionModel;
-  connection: ConnectionState;
-  activity: ActivityState;
-  debug: DebugState;
-}
-
-export type SnapshotIngressSource =
-  | "short-code"
-  | "snapshot"
-  | "start"
-  | "dev-new";
-
-export type EventIngressSource = "sse" | "submit-response";
-
-export type SessionStateIngress =
-  | {
-      type: "command.loading";
-      target?: { sessionId?: string; shortCode?: string };
-    }
-  | { type: "command.failed"; message: string }
-  | {
-      type: "snapshot.loaded";
-      source: SnapshotIngressSource;
-      snapshot: NormalizedSessionSnapshot;
-      expectedPerspectivePlayerId?: string | null;
-    }
-  | {
-      type: "event.received";
-      source: EventIngressSource;
-      event: NormalizedSessionEvent;
-      debugEvent?: { eventType: string; data: unknown };
-      clientActionId?: string | null;
-    }
-  | {
-      type: "connection.prepared";
-      userId: string | null;
-      switchablePlayerIds: string[];
-    }
-  | {
-      type: "connection.changed";
-      channel: "lobby" | "gameplay";
-      connected: boolean;
-    }
-  | { type: "connection.failed"; message: string }
-  | {
-      type: "connection.recovering";
-      message: string;
-      retryAfterMs: number;
-      attempt: number;
-    }
-  | { type: "connection.errorCleared" }
-  | {
-      type: "feedback.actionRejected";
-      reason: string;
-      targetPlayer?: string;
-    }
-  | { type: "local.playerSelected"; playerId: string; sessionId: string }
-  | { type: "activity.stateAcked" }
-  | { type: "activity.notificationRead"; id: string }
-  | { type: "activity.notificationsCleared" }
-  | { type: "activity.hostFeedbackDismissed"; id: string }
-  | { type: "activity.hostFeedbackCleared" }
-  | { type: "debug.sseEventsCleared" }
-  | { type: "streams.closed" }
-  | { type: "session.reset" };
-
-export type SessionStateEffect =
-  | {
-      type: "requestGameplayResync";
-      sessionId: string;
-      playerId: string;
-      reason: string;
-    }
-  | {
-      type: "reconnectGameplay";
-      sessionId: string;
-      playerId: string;
-      source: "player-switch";
-    }
-  | {
-      type: "perf.storeApplied";
-      gameplayVersion: number;
-      syncId: number;
-    }
-  | {
-      type: "log.warn";
-      message: string;
-    };
-
-export interface SessionStateReducerEnvironment {
-  fallbackToAllSeatsWhenUserIdMissing: boolean;
-  nextEventId: () => number;
-  nextNotificationId: () => string;
-  nowMs: () => number;
-  nowIso: () => string;
-}
-
-export interface SessionStateReducerResult {
-  state: UnifiedSessionState;
-  effects: SessionStateEffect[];
-}
-
-export function createInitialUnifiedSessionState(): UnifiedSessionState {
-  return {
-    session: { type: "idle" },
-    connection: {
-      lobby: false,
-      gameplay: false,
-      error: null,
-      isConnected: false,
-      recovery: {
-        active: false,
-        message: null,
-        retryAfterMs: null,
-        attempt: null,
-        since: null,
-      },
-    },
-    activity: {
-      notifications: [],
-      hostFeedback: [],
-      syncId: 0,
-      lastSyncTimestamp: null,
-      lastAckTimestamp: null,
-    },
-    debug: { sseEvents: [], maxEvents: 500 },
-  };
-}
-
-function appendSseEvent(
-  state: UnifiedSessionState,
-  debugEvent: { eventType: string; data: unknown },
-  env: SessionStateReducerEnvironment,
-) {
-  const newEvent: SSEEventEntry = {
-    id: env.nextEventId(),
-    eventType: debugEvent.eventType,
-    data: debugEvent.data,
-    timestamp: env.nowIso(),
-  };
-  return [...state.debug.sseEvents, newEvent].slice(-state.debug.maxEvents);
-}
-
-function createActionRejectedArtifacts(
-  reason: string,
-  targetPlayer: string | undefined,
-  env: SessionStateReducerEnvironment,
-) {
-  return {
-    notification: {
-      id: env.nextNotificationId(),
-      type: "ACTION_REJECTED" as const,
-      payload: { type: "ACTION_REJECTED" as const, reason, targetPlayer },
-      timestamp: env.nowMs(),
-      read: false,
-    },
-    hostFeedback: {
-      id: env.nextNotificationId(),
-      type: "ACTION_REJECTED" as const,
-      payload: { type: "ACTION_REJECTED" as const, reason, targetPlayer },
-      timestamp: env.nowMs(),
-    },
-  };
-}
-
-function createPromptOpenedArtifacts(
-  prompt: {
-    interactionId: string;
-    context?: { to?: string; title?: string };
-  },
-  env: SessionStateReducerEnvironment,
-) {
-  const payload = {
-    type: "PROMPT_OPENED" as const,
-    promptId: prompt.interactionId,
-    promptInstanceId: prompt.interactionId,
-    targetPlayer: prompt.context?.to ?? "",
-    title: prompt.context?.title ?? undefined,
-  };
-  return {
-    notification: {
-      id: env.nextNotificationId(),
-      type: "PROMPT_OPENED" as const,
-      payload,
-      timestamp: env.nowMs(),
-      read: false,
-    },
-    hostFeedback: {
-      id: env.nextNotificationId(),
-      type: "PROMPT_OPENED" as const,
-      payload,
-      timestamp: env.nowMs(),
-    },
-  };
-}
-
-function getOpenedPrompts(
-  previous: ReadonlyArray<{ kind: string; interactionId: string }>,
-  next: ReadonlyArray<{
-    kind: string;
-    interactionId: string;
-    context?: { to?: string; title?: string };
-  }>,
-) {
-  const previousPromptIds = new Set(
-    previous
-      .filter((descriptor) => descriptor.kind === "prompt")
-      .map((prompt) => prompt.interactionId),
-  );
-  return next.filter(
-    (descriptor) =>
-      descriptor.kind === "prompt" &&
-      !previousPromptIds.has(descriptor.interactionId),
-  );
-}
-
-function hasBoardStaticHashMismatch(
-  gameplay: GameplayViewport | null,
-  incomingGameplay: GameplayViewport,
-): boolean {
-  const incomingHash = incomingGameplay.boardStaticHash ?? null;
-  const cachedHash = gameplay?.boardStaticHash ?? null;
-  return (
-    cachedHash !== null && incomingHash !== null && incomingHash !== cachedHash
-  );
-}
-
-function hasRenderableGameplayView(gameplay: GameplayViewport): boolean {
-  return gameplay.view !== null || gameplay.boardStatic !== null;
-}
-
-function shouldIgnoreGameplayUpdate(
-  currentGameplay: GameplayViewport | null,
-  incomingGameplay: GameplayViewport,
-): boolean {
-  if (!currentGameplay) return false;
-  if (incomingGameplay.version < currentGameplay.version) return true;
-  if (incomingGameplay.version > currentGameplay.version) return false;
-  if (
-    currentGameplay.actionSetVersion.endsWith(":history") &&
-    !incomingGameplay.actionSetVersion.endsWith(":history")
-  ) {
-    return false;
-  }
-  if (
-    !hasRenderableGameplayView(currentGameplay) &&
-    hasRenderableGameplayView(incomingGameplay)
-  ) {
-    return false;
-  }
-  return true;
-}
-
-function applyGameplaySnapshotToState(
-  state: UnifiedSessionState,
-  gameplay: GameplayViewport,
-  context: SessionContext,
-  options: {
-    nextSyncId: number;
-    perspective: GameplayPerspective;
-    debugEvent?: { eventType: string; data: unknown };
-    env: SessionStateReducerEnvironment;
-  },
-): UnifiedSessionState {
-  const previousGameplay = getGameplayViewport(state.session);
-  const promptArtifacts = getOpenedPrompts(
-    previousGameplay?.availableInteractions ?? [],
-    gameplay.availableInteractions,
-  ).map((prompt) => createPromptOpenedArtifacts(prompt, options.env));
-  return {
-    ...state,
-    session: {
-      type: "gameplay",
-      context,
-      perspective: options.perspective,
-      gameplay,
-    },
-    activity: {
-      ...state.activity,
-      notifications: [
-        ...state.activity.notifications,
-        ...promptArtifacts.map((artifact) => artifact.notification),
-      ],
-      hostFeedback: [
-        ...state.activity.hostFeedback,
-        ...promptArtifacts.map((artifact) => artifact.hostFeedback),
-      ],
-      syncId: options.nextSyncId,
-      lastSyncTimestamp: options.env.nowMs(),
-    },
-    debug: {
-      ...state.debug,
-      sseEvents: options.debugEvent
-        ? appendSseEvent(state, options.debugEvent, options.env)
-        : state.debug.sseEvents,
-    },
-    connection: {
-      ...state.connection,
-      error: null,
-      recovery: {
-        active: false,
-        message: null,
-        retryAfterMs: null,
-        attempt: null,
-        since: null,
-      },
-    },
-  };
-}
-
-function assertExpectedPerspectivePlayer(
-  snapshot: NormalizedSessionSnapshot,
-  expectedPlayerId: string | null | undefined,
-) {
-  if (!expectedPlayerId || snapshot.type !== "gameplay") {
-    return;
-  }
-  if (snapshot.perspective.playerId !== expectedPlayerId) {
-    throw new Error(
-      `Switch snapshot resolved ${snapshot.perspective.playerId} instead of ${expectedPlayerId}.`,
-    );
-  }
-}
-
-function reduceSnapshotLoaded(
-  state: UnifiedSessionState,
-  ingress: Extract<SessionStateIngress, { type: "snapshot.loaded" }>,
-  env: SessionStateReducerEnvironment,
-): UnifiedSessionState {
-  assertExpectedPerspectivePlayer(
-    ingress.snapshot,
-    ingress.expectedPerspectivePlayerId,
-  );
-  const context = ingress.snapshot.context;
-  const nextSyncId = state.activity.syncId + 1;
-
-  if (ingress.snapshot.type !== "gameplay") {
-    const session: UnifiedSessionModel =
-      ingress.snapshot.type === "ended"
-        ? { type: "ended", context }
-        : {
-            type: "lobby",
-            context,
-            preferredPlayerId: ingress.snapshot.preferredPlayerId,
-          };
-    return {
-      ...state,
-      session,
-      activity: {
-        ...state.activity,
-        syncId: nextSyncId,
-        lastSyncTimestamp: env.nowMs(),
-      },
-      connection: {
-        ...state.connection,
-        error: null,
-        recovery: {
-          active: false,
-          message: null,
-          retryAfterMs: null,
-          attempt: null,
-          since: null,
-        },
-      },
-    };
-  }
-
-  return {
-    ...applyGameplaySnapshotToState(state, ingress.snapshot.gameplay, context, {
-      nextSyncId,
-      perspective: ingress.snapshot.perspective,
-      env,
-    }),
-    connection: {
-      ...state.connection,
-      error: null,
-      recovery: {
-        active: false,
-        message: null,
-        retryAfterMs: null,
-        attempt: null,
-        since: null,
-      },
-    },
-  };
-}
-
-function reduceEventReceived(
-  state: UnifiedSessionState,
-  ingress: Extract<SessionStateIngress, { type: "event.received" }>,
-  env: SessionStateReducerEnvironment,
-): SessionStateReducerResult {
-  const context = getSessionContext(state.session);
-  const currentGameplay = getGameplayViewport(state.session);
-  const nextSyncId = state.activity.syncId + 1;
-  const debugEvent = ingress.source === "sse" ? ingress.debugEvent : undefined;
-
-  switch (ingress.event.type) {
-    case "session.snapshot": {
-      const snapshotState = reduceSnapshotLoaded(
-        state,
-        {
-          type: "snapshot.loaded",
-          source: "snapshot",
-          snapshot: ingress.event.snapshot,
-        },
-        env,
-      );
-      return {
-        state: debugEvent
-          ? {
-              ...snapshotState,
-              debug: {
-                ...snapshotState.debug,
-                sseEvents: appendSseEvent(state, debugEvent, env),
-              },
-            }
-          : snapshotState,
-        effects: [],
-      };
-    }
-    case "session.lobbyUpdated": {
-      const nextContext = ingress.event.context;
-      if (!nextContext) return { state, effects: [] };
-      return {
-        state: {
-          ...state,
-          session: withContext(state.session, nextContext),
-          activity: {
-            ...state.activity,
-            syncId: nextSyncId,
-            lastSyncTimestamp: env.nowMs(),
-          },
-          debug: {
-            ...state.debug,
-            sseEvents: debugEvent
-              ? appendSseEvent(state, debugEvent, env)
-              : state.debug.sseEvents,
-          },
-          connection: {
-            ...state.connection,
-            error: null,
-            recovery: {
-              active: false,
-              message: null,
-              retryAfterMs: null,
-              attempt: null,
-              since: null,
-            },
-          },
-        },
-        effects: [],
-      };
-    }
-    case "session.gameplayUpdated": {
-      if (!context || !ingress.event.context) return { state, effects: [] };
-      if (
-        ingress.source === "sse" &&
-        ((state.session.type === "gameplay" &&
-          ingress.event.perspective.playerId !==
-            state.session.perspective.playerId) ||
-          (state.session.type === "gameplayLoading" &&
-            ingress.event.perspective.playerId !==
-              state.session.requestedPlayerId))
-      ) {
-        return { state, effects: [] };
-      }
-      if (shouldIgnoreGameplayUpdate(currentGameplay, ingress.event.gameplay)) {
-        return { state, effects: [] };
-      }
-      const updatedState = applyGameplaySnapshotToState(
-        state,
-        ingress.event.gameplay,
-        ingress.event.context,
-        {
-          nextSyncId,
-          perspective: ingress.event.perspective,
-          debugEvent,
-          env,
-        },
-      );
-      const effects: SessionStateEffect[] = [
-        {
-          type: "perf.storeApplied",
-          gameplayVersion: ingress.event.gameplay.version,
-          syncId: nextSyncId,
-        },
-      ];
-      if (hasBoardStaticHashMismatch(currentGameplay, ingress.event.gameplay)) {
-        effects.push({
-          type: "requestGameplayResync",
-          sessionId: context.identity.sessionId,
-          playerId: ingress.event.perspective.playerId,
-          reason: `boardStaticHash mismatch cached=${currentGameplay?.boardStaticHash} incoming=${ingress.event.gameplay.boardStaticHash}`,
-        });
-      }
-      return { state: updatedState, effects };
-    }
-    case "session.historyUpdated": {
-      const nextContext = ingress.event.context;
-      if (!nextContext) return { state, effects: [] };
-      return {
-        state: {
-          ...state,
-          session: withContext(state.session, nextContext),
-          activity: {
-            ...state.activity,
-            syncId: nextSyncId,
-            lastSyncTimestamp: env.nowMs(),
-          },
-          debug: {
-            ...state.debug,
-            sseEvents: debugEvent
-              ? appendSseEvent(state, debugEvent, env)
-              : state.debug.sseEvents,
-          },
-          connection: {
-            ...state.connection,
-            error: null,
-            recovery: {
-              active: false,
-              message: null,
-              retryAfterMs: null,
-              attempt: null,
-              since: null,
-            },
-          },
-        },
-        effects: [],
-      };
-    }
-    case "session.ended": {
-      const nextContext = ingress.event.context;
-      if (!nextContext) return { state, effects: [] };
-      return {
-        state: {
-          ...state,
-          session: { type: "ended", context: nextContext },
-          activity: {
-            ...state.activity,
-            syncId: nextSyncId,
-            lastSyncTimestamp: env.nowMs(),
-          },
-          debug: {
-            ...state.debug,
-            sseEvents: debugEvent
-              ? appendSseEvent(state, debugEvent, env)
-              : state.debug.sseEvents,
-          },
-          connection: {
-            ...state.connection,
-            error: null,
-            recovery: {
-              active: false,
-              message: null,
-              retryAfterMs: null,
-              attempt: null,
-              since: null,
-            },
-          },
-        },
-        effects: [],
-      };
-    }
-    case "session.error":
-      return {
-        state: {
-          ...state,
-          session: {
-            type: "error",
-            message: ingress.event.message,
-            context: context ?? undefined,
-          },
-          activity: {
-            ...state.activity,
-            syncId: nextSyncId,
-            lastSyncTimestamp: env.nowMs(),
-          },
-          debug: {
-            ...state.debug,
-            sseEvents: debugEvent
-              ? appendSseEvent(state, debugEvent, env)
-              : state.debug.sseEvents,
-          },
-        },
-        effects: [],
-      };
-  }
-}
-
-export function reduceSessionState(
-  state: UnifiedSessionState,
-  ingress: SessionStateIngress,
-  env: SessionStateReducerEnvironment,
-): SessionStateReducerResult {
-  switch (ingress.type) {
-    case "command.loading":
-      return {
-        state: {
-          ...state,
-          session: { type: "loading", target: ingress.target },
-          connection: {
-            ...state.connection,
-            error: null,
-            recovery: {
-              active: false,
-              message: null,
-              retryAfterMs: null,
-              attempt: null,
-              since: null,
-            },
-          },
-        },
-        effects: [],
-      };
-    case "command.failed":
-      return {
-        state: {
-          ...state,
-          session: {
-            type: "error",
-            message: ingress.message,
-            context: getSessionContext(state.session) ?? undefined,
-          },
-        },
-        effects: [],
-      };
-    case "snapshot.loaded":
-      return {
-        state: reduceSnapshotLoaded(state, ingress, env),
-        effects: [],
-      };
-    case "event.received":
-      return reduceEventReceived(state, ingress, env);
-    case "connection.prepared": {
-      const context = getSessionContext(state.session);
-      if (!context) return { state, effects: [] };
-      return {
-        state: {
-          ...state,
-          session: withContext(state.session, {
-            ...context,
-            userId: ingress.userId,
-            switchablePlayerIds: ingress.switchablePlayerIds,
-          }),
-          connection: {
-            ...state.connection,
-            error: null,
-            recovery: {
-              active: false,
-              message: null,
-              retryAfterMs: null,
-              attempt: null,
-              since: null,
-            },
-          },
-        },
-        effects: [],
-      };
-    }
-    case "connection.changed": {
-      const connection = {
-        ...state.connection,
-        [ingress.channel]: ingress.connected,
-      };
-      return {
-        state: {
-          ...state,
-          connection: {
-            ...connection,
-            isConnected: connection.lobby || connection.gameplay,
-            recovery: ingress.connected
-              ? {
-                  active: false,
-                  message: null,
-                  retryAfterMs: null,
-                  attempt: null,
-                  since: null,
-                }
-              : connection.recovery,
-          },
-        },
-        effects: [],
-      };
-    }
-    case "connection.failed":
-      return {
-        state: {
-          ...state,
-          connection: {
-            ...state.connection,
-            error: ingress.message,
-            recovery: {
-              active: false,
-              message: null,
-              retryAfterMs: null,
-              attempt: null,
-              since: null,
-            },
-          },
-        },
-        effects: [],
-      };
-    case "connection.recovering":
-      return {
-        state: {
-          ...state,
-          connection: {
-            ...state.connection,
-            error: null,
-            recovery: {
-              active: true,
-              message: ingress.message,
-              retryAfterMs: ingress.retryAfterMs,
-              attempt: ingress.attempt,
-              since: state.connection.recovery.since ?? env.nowMs(),
-            },
-          },
-        },
-        effects: [],
-      };
-    case "connection.errorCleared":
-      return {
-        state: {
-          ...state,
-          connection: { ...state.connection, error: null },
-        },
-        effects: [],
-      };
-    case "feedback.actionRejected": {
-      const { notification, hostFeedback } = createActionRejectedArtifacts(
-        ingress.reason,
-        ingress.targetPlayer,
-        env,
-      );
-      return {
-        state: {
-          ...state,
-          activity: {
-            ...state.activity,
-            notifications: [...state.activity.notifications, notification],
-            hostFeedback: [...state.activity.hostFeedback, hostFeedback],
-          },
-        },
-        effects: [],
-      };
-    }
-    case "local.playerSelected": {
-      const context = getSessionContext(state.session);
-      if (!context) return { state, effects: [] };
-      const controllablePlayerIds = resolveControllablePlayerIds(
-        context.switchablePlayerIds,
-        context.seats,
-        context.userId,
-        env.fallbackToAllSeatsWhenUserIdMissing,
-      );
-      if (!controllablePlayerIds.includes(ingress.playerId)) {
-        return {
-          state,
-          effects: [
-            {
-              type: "log.warn",
-              message: `[UnifiedSession] Cannot switch to ${ingress.playerId} - not controllable`,
-            },
-          ],
-        };
-      }
-      const currentGameplay = getGameplayViewport(state.session);
-      const localGameplay = currentGameplay
-        ? gameplayViewportForPlayer(currentGameplay, ingress.playerId)
-        : null;
-      if (localGameplay) {
-        return {
-          state: applyGameplaySnapshotToState(state, localGameplay, context, {
-            nextSyncId: state.activity.syncId + 1,
-            perspective: { playerId: ingress.playerId },
-            env,
-          }),
-          effects: [
-            {
-              type: "reconnectGameplay",
-              sessionId: ingress.sessionId,
-              playerId: ingress.playerId,
-              source: "player-switch",
-            },
-          ],
-        };
-      }
-      return {
-        state: {
-          ...state,
-          session: {
-            type: "gameplayLoading",
-            context,
-            requestedPlayerId: ingress.playerId,
-          },
-        },
-        effects: [
-          {
-            type: "reconnectGameplay",
-            sessionId: ingress.sessionId,
-            playerId: ingress.playerId,
-            source: "player-switch",
-          },
-        ],
-      };
-    }
-    case "activity.stateAcked":
-      return {
-        state: {
-          ...state,
-          activity: { ...state.activity, lastAckTimestamp: env.nowMs() },
-        },
-        effects: [],
-      };
-    case "activity.notificationRead":
-      return {
-        state: {
-          ...state,
-          activity: {
-            ...state.activity,
-            notifications: state.activity.notifications.map((notification) =>
-              notification.id === ingress.id
-                ? { ...notification, read: true }
-                : notification,
-            ),
-          },
-        },
-        effects: [],
-      };
-    case "activity.notificationsCleared":
-      return {
-        state: {
-          ...state,
-          activity: { ...state.activity, notifications: [] },
-        },
-        effects: [],
-      };
-    case "activity.hostFeedbackDismissed":
-      return {
-        state: {
-          ...state,
-          activity: {
-            ...state.activity,
-            hostFeedback: state.activity.hostFeedback.filter(
-              (item) => item.id !== ingress.id,
-            ),
-          },
-        },
-        effects: [],
-      };
-    case "activity.hostFeedbackCleared":
-      return {
-        state: {
-          ...state,
-          activity: { ...state.activity, hostFeedback: [] },
-        },
-        effects: [],
-      };
-    case "debug.sseEventsCleared":
-      return {
-        state: { ...state, debug: { ...state.debug, sseEvents: [] } },
-        effects: [],
-      };
-    case "streams.closed":
-      return {
-        state: {
-          ...state,
-          connection: {
-            ...state.connection,
-            lobby: false,
-            gameplay: false,
-            isConnected: false,
-            recovery: {
-              active: false,
-              message: null,
-              retryAfterMs: null,
-              attempt: null,
-              since: null,
-            },
-          },
-        },
-        effects: [],
-      };
-    case "session.reset":
-      return { state: createInitialUnifiedSessionState(), effects: [] };
-  }
-}