@dreamboard-games/cli 0.1.30-alpha.0 → 0.1.30-alpha.10

package/dist/runtime-packages/ui-host-runtime/src/sse-manager.ts

@@ -1,416 +0,0 @@
-import type { HostSessionTransport } from "./host-session-transport.js";
-import { defaultHostSessionTransport } from "./host-session-transport.js";
-import type { LoggerLike } from "./logger.js";
-import { consoleLogger } from "./logger.js";
-import { PERF_MARK_NAMES, findActionIdByVersion, recordMark } from "./perf.js";
-import type { HostSessionWireEvent } from "./session-ingress.js";
-import {
-  getSessionRecoveryDetails,
-  type SessionRecoveryDetails,
-} from "./session-recovery.js";
-
-type HostSessionEventType = HostSessionWireEvent["type"];
-
-type ExtractHostSessionEvent<T extends HostSessionEventType> = Extract<
-  HostSessionWireEvent,
-  { type: T }
->;
-
-type HostSessionEventHandler<
-  T extends HostSessionEventType = HostSessionEventType,
-> = (data: ExtractHostSessionEvent<T>) => void;
-type ConnectionEventHandler = () => void;
-type ErrorEventHandler = (error: unknown) => void;
-type RecoveryEventHandler = (details: LongPollRecoveryEvent) => void;
-type AnyHostSessionEventHandler = (data: HostSessionWireEvent) => void;
-type EventHandler =
-  | AnyHostSessionEventHandler
-  | ConnectionEventHandler
-  | ErrorEventHandler
-  | RecoveryEventHandler;
-
-export interface LongPollRecoveryEvent extends SessionRecoveryDetails {
-  attempt: number;
-}
-
-export type SSERecoveryEvent = LongPollRecoveryEvent;
-
-export interface LongPollSessionManagerOptions {
-  clientId?: string;
-  logger?: LoggerLike;
-  recoveryRetryMaxAttempts?: number;
-  recoveryRetrySleep?: (ms: number) => Promise<void>;
-  transport?: Pick<
-    HostSessionTransport,
-    "subscribeToSessionEvents" | "disconnectSessionEvents"
-  >;
-}
-
-export type SSEManagerOptions = LongPollSessionManagerOptions;
-
-export interface SSEConnectOptions {
-  source?: string;
-  playerId?: string;
-}
-
-interface ActiveConnection {
-  connectionAttemptId: string;
-  sessionId: string;
-  playerId?: string;
-  source?: string;
-}
-
-const TAB_ID_SESSION_STORAGE_KEY = "dreamboard.sse.tab-id";
-
-function randomId(): string {
-  if (
-    typeof crypto !== "undefined" &&
-    typeof crypto.randomUUID === "function"
-  ) {
-    return crypto.randomUUID();
-  }
-  return `sse-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-}
-
-function getOrCreateTabId(): string {
-  if (typeof window === "undefined") {
-    return randomId();
-  }
-
-  try {
-    const existing = window.sessionStorage.getItem(TAB_ID_SESSION_STORAGE_KEY);
-    if (existing) {
-      return existing;
-    }
-
-    const created = randomId();
-    window.sessionStorage.setItem(TAB_ID_SESSION_STORAGE_KEY, created);
-    return created;
-  } catch {
-    return randomId();
-  }
-}
-
-function isAbortLikeError(error: unknown): boolean {
-  return error instanceof Error && error.name === "AbortError";
-}
-
-export class LongPollSessionManager {
-  private abortController: AbortController | null = null;
-  private activeConnection: ActiveConnection | null = null;
-  private readonly clientId: string;
-  private readonly transport: Pick<
-    HostSessionTransport,
-    "subscribeToSessionEvents" | "disconnectSessionEvents"
-  >;
-  private handlers: Map<string, Set<EventHandler>> = new Map();
-  private anyMessageHandlers: Set<AnyHostSessionEventHandler> = new Set();
-  private isConnected = false;
-  private messageBuffer: HostSessionWireEvent[] = [];
-  private logger: LoggerLike;
-  private pageHideHandler: (() => void) | null = null;
-  private readonly recoveryRetryMaxAttempts: number;
-  private readonly recoveryRetrySleep: (ms: number) => Promise<void>;
-
-  constructor(options: LongPollSessionManagerOptions = {}) {
-    this.clientId = options.clientId ?? getOrCreateTabId();
-    this.logger = options.logger ?? consoleLogger;
-    this.transport = options.transport ?? defaultHostSessionTransport;
-    this.recoveryRetryMaxAttempts = options.recoveryRetryMaxAttempts ?? 60;
-    this.recoveryRetrySleep =
-      options.recoveryRetrySleep ??
-      ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-  }
-
-  async connect(sessionId: string, options: SSEConnectOptions) {
-    if (this.abortController) {
-      this.disconnect();
-    }
-
-    this.abortController = new AbortController();
-    const connection: ActiveConnection = {
-      sessionId,
-      playerId: options.playerId,
-      connectionAttemptId: randomId(),
-      source: options.source,
-    };
-    this.activeConnection = connection;
-    this.registerPageHideHandler();
-
-    try {
-      let recoveryAttempt = 0;
-
-      while (!this.abortController.signal.aborted) {
-        let connected = false;
-        let streamError: unknown = null;
-        let stream: AsyncIterable<HostSessionWireEvent | null | undefined>;
-
-        try {
-          stream = (
-            await this.transport.subscribeToSessionEvents({
-              sessionId,
-              clientId: this.clientId,
-              connectionAttemptId: connection.connectionAttemptId,
-              clientSource: options.source,
-              playerId: connection.playerId,
-              signal: this.abortController.signal,
-              onSseError: (error) => {
-                if (
-                  this.abortController?.signal.aborted ||
-                  isAbortLikeError(error)
-                ) {
-                  return;
-                }
-                streamError = error;
-              },
-            })
-          ).stream;
-        } catch (error) {
-          const recovered = await this.retryRecovery(error, ++recoveryAttempt);
-          if (recovered) {
-            continue;
-          }
-          throw error;
-        }
-
-        try {
-          for await (const event of stream) {
-            if (!event) continue;
-            if (!connected) {
-              connected = true;
-              recoveryAttempt = 0;
-              this.isConnected = true;
-              this.emit("connected", null);
-            }
-
-            const eventType = event.type;
-
-            if (eventType) {
-              // Tier-0 perf: record `t4_sse_received` the moment the SSE
-              // stream yields a gameplay.updated for a version we submitted.
-              // Stitching is done via the version -> actionId map populated
-              // at t3 in runtime-api.
-              if (eventType === "session.gameplayUpdated") {
-                const version = event.gameplay?.version;
-                if (typeof version === "number") {
-                  const actionId = findActionIdByVersion(version);
-                  if (actionId) {
-                    recordMark(actionId, PERF_MARK_NAMES.T4_SSE_RECEIVED, {
-                      extra: { version },
-                    });
-                  }
-                }
-              }
-              this.emit(eventType, event);
-            } else {
-              this.logger.error(
-                "[LongPollSessionManager] Received event without type:",
-                event,
-              );
-            }
-          }
-        } catch (error) {
-          streamError = streamError ?? error;
-        }
-
-        if (streamError) {
-          const recovered = await this.retryRecovery(
-            streamError,
-            ++recoveryAttempt,
-          );
-          if (recovered) {
-            continue;
-          }
-          this.logger.error(
-            "[LongPollSessionManager] stream error:",
-            streamError,
-          );
-          this.emit("error", streamError);
-          this.isConnected = false;
-          this.emit("disconnected", null);
-          return;
-        }
-
-        this.isConnected = false;
-        this.emit("disconnected", null);
-        return;
-      }
-
-      this.isConnected = false;
-      this.emit("disconnected", null);
-    } catch (error) {
-      if (isAbortLikeError(error)) {
-        return;
-      }
-
-      this.logger.error("[LongPollSessionManager] stream error:", error);
-      this.emit("error", error);
-      this.isConnected = false;
-      this.emit("disconnected", null);
-    } finally {
-      if (
-        this.activeConnection?.connectionAttemptId ===
-        connection.connectionAttemptId
-      ) {
-        this.activeConnection = null;
-        this.unregisterPageHideHandler();
-      }
-    }
-  }
-
-  on<T extends HostSessionEventType>(
-    eventType: T,
-    handler: HostSessionEventHandler<T>,
-  ): () => void;
-  on(
-    eventType: "connected" | "disconnected",
-    handler: ConnectionEventHandler,
-  ): () => void;
-  on(eventType: "error", handler: ErrorEventHandler): () => void;
-  on(eventType: "recovering", handler: RecoveryEventHandler): () => void;
-  on(eventType: string, handler: EventHandler): () => void {
-    if (!this.handlers.has(eventType)) {
-      this.handlers.set(eventType, new Set());
-    }
-    const handlers = this.handlers.get(eventType);
-    if (handlers) {
-      handlers.add(handler);
-    }
-
-    return () => {
-      this.handlers.get(eventType)?.delete(handler);
-    };
-  }
-
-  onAnyMessage(handler: AnyHostSessionEventHandler): () => void {
-    this.anyMessageHandlers.add(handler);
-
-    if (this.messageBuffer.length > 0) {
-      this.messageBuffer.forEach((message) => {
-        handler(message);
-      });
-    }
-
-    return () => {
-      this.anyMessageHandlers.delete(handler);
-    };
-  }
-
-  private emit(eventType: string, data: HostSessionWireEvent): void;
-  private emit(eventType: "connected" | "disconnected", data: null): void;
-  private emit(eventType: "error", error: unknown): void;
-  private emit(eventType: "recovering", data: LongPollRecoveryEvent): void;
-  private emit(
-    eventType: string,
-    data: HostSessionWireEvent | null | unknown,
-  ): void {
-    const handlers = this.handlers.get(eventType);
-    if (handlers) {
-      handlers.forEach((handler) => {
-        if (eventType === "connected" || eventType === "disconnected") {
-          (handler as ConnectionEventHandler)();
-        } else if (eventType === "error") {
-          (handler as ErrorEventHandler)(data);
-        } else if (eventType === "recovering") {
-          (handler as RecoveryEventHandler)(data as LongPollRecoveryEvent);
-        } else {
-          (handler as AnyHostSessionEventHandler)(data as HostSessionWireEvent);
-        }
-      });
-    }
-
-    if (
-      eventType !== "connected" &&
-      eventType !== "disconnected" &&
-      eventType !== "error" &&
-      eventType !== "recovering"
-    ) {
-      this.messageBuffer.push(data as HostSessionWireEvent);
-
-      this.anyMessageHandlers.forEach((handler) => {
-        handler(data as HostSessionWireEvent);
-      });
-    }
-  }
-
-  disconnect() {
-    const activeConnection = this.activeConnection;
-    if (activeConnection) {
-      this.notifyDisconnect(activeConnection, true);
-    }
-
-    if (this.abortController) {
-      this.abortController.abort();
-      this.abortController = null;
-    }
-    this.activeConnection = null;
-    this.unregisterPageHideHandler();
-    this.isConnected = false;
-    this.handlers.clear();
-    this.anyMessageHandlers.clear();
-    this.messageBuffer = [];
-  }
-
-  isStreamConnected(): boolean {
-    return this.isConnected;
-  }
-
-  private async retryRecovery(
-    error: unknown,
-    attempt: number,
-  ): Promise<boolean> {
-    const recovery = getSessionRecoveryDetails(error);
-    if (!recovery || attempt > this.recoveryRetryMaxAttempts) {
-      return false;
-    }
-    this.isConnected = false;
-    this.emit("disconnected", null);
-    this.emit("recovering", { ...recovery, attempt });
-    await this.recoveryRetrySleep(recovery.retryAfterMs);
-    return this.abortController?.signal.aborted !== true;
-  }
-
-  private notifyDisconnect(
-    connection: ActiveConnection,
-    _keepalive: boolean,
-  ): void {
-    const request = this.transport.disconnectSessionEvents({
-      sessionId: connection.sessionId,
-      clientId: this.clientId,
-      connectionAttemptId: connection.connectionAttemptId,
-      playerId: connection.playerId,
-    });
-
-    void request.catch((error) => {
-      this.logger.error(
-        "[LongPollSessionManager] Failed to notify disconnect:",
-        error,
-      );
-    });
-  }
-
-  private registerPageHideHandler(): void {
-    if (typeof window === "undefined" || this.pageHideHandler) {
-      return;
-    }
-
-    this.pageHideHandler = () => {
-      if (this.activeConnection) {
-        this.notifyDisconnect(this.activeConnection, true);
-      }
-    };
-
-    window.addEventListener("pagehide", this.pageHideHandler);
-  }
-
-  private unregisterPageHideHandler(): void {
-    if (typeof window === "undefined" || !this.pageHideHandler) {
-      return;
-    }
-
-    window.removeEventListener("pagehide", this.pageHideHandler);
-    this.pageHideHandler = null;
-  }
-}
-
-export { LongPollSessionManager as SSEManager };

package/dist/runtime-packages/ui-host-runtime/src/unified-session-store.ts

@@ -1,184 +0,0 @@
-import { createStore } from "zustand/vanilla";
-import { subscribeWithSelector } from "zustand/middleware";
-import type { StoreApi } from "zustand/vanilla";
-import type { PluginStateSnapshot as UiSdkPluginStateSnapshot } from "@dreamboard-games/sdk/runtime/runtime-api";
-import type { LoggerLike } from "./logger.js";
-import { consoleLogger } from "./logger.js";
-import type { HostSessionTransport } from "./host-session-transport.js";
-import { defaultHostSessionTransport } from "./host-session-transport.js";
-import type { GameplayViewport } from "./session-model.js";
-import {
-  getGameplayViewport,
-  getSessionContext,
-  resolveControllablePlayerIds,
-} from "./session-model.js";
-import type { SSEManagerLike } from "./session-live-runtime.js";
-import { createSessionIngressController } from "./session-ingress-controller.js";
-import type { SessionIngressControllerActions } from "./session-ingress-controller.js";
-import {
-  createInitialUnifiedSessionState,
-  type UnifiedSessionState,
-} from "./session-state-reducer.js";
-import {
-  selectBootstrapStatus,
-  selectGameplayViewModel,
-  selectGameplayViewport,
-  selectHistory,
-  selectLobbyViewModel,
-  selectPluginSnapshot,
-  selectSessionContext,
-  selectSessionError,
-  selectSessionType,
-} from "./session-projection.js";
-
-export type {
-  GameplayViewport,
-  HistoryState,
-  SessionContext,
-  SessionIdentity,
-  SessionPhase,
-  UnifiedSessionModel,
-} from "./session-model.js";
-export type {
-  BootstrapStatus,
-  GameplayViewModel,
-  LobbyViewModel,
-} from "./session-projection.js";
-export type { SSEManagerLike } from "./session-live-runtime.js";
-export type {
-  ActivityState,
-  ConnectionState,
-  ConnectionRecoveryState,
-  DebugState,
-  HostFeedback,
-  HostFeedbackPayload,
-  HostFeedbackType,
-  Notification,
-  NotificationPayload,
-  NotificationType,
-  SSEEventEntry,
-  UnifiedSessionState,
-} from "./session-state-reducer.js";
-
-export type PluginStateSnapshot = UiSdkPluginStateSnapshot;
-export type GameplayState = GameplayViewport;
-
-export interface UnifiedSessionActions extends SessionIngressControllerActions {
-  getPluginSnapshot: () => PluginStateSnapshot;
-  getRenderableGameplay: () => GameplayViewport | null;
-}
-
-export type UnifiedSessionStore = UnifiedSessionState & UnifiedSessionActions;
-
-export interface CreateUnifiedSessionStoreOptions {
-  createSseManager: () => SSEManagerLike;
-  transport?: HostSessionTransport;
-  logger?: LoggerLike;
-  fallbackToAllSeatsWhenUserIdMissing?: boolean;
-}
-
-let sseEventIdCounter = 0;
-let notificationIdCounter = 0;
-const EMPTY_ARRAY: never[] = [];
-
-function generateNotificationId(): string {
-  return `notif-${++notificationIdCounter}-${Date.now()}`;
-}
-
-export function createUnifiedSessionStore(
-  options: CreateUnifiedSessionStoreOptions,
-): StoreApi<UnifiedSessionStore> {
-  const logger = options.logger ?? consoleLogger;
-  const transport = options.transport ?? defaultHostSessionTransport;
-  const fallbackToAllSeatsWhenUserIdMissing =
-    options.fallbackToAllSeatsWhenUserIdMissing ?? false;
-
-  return createStore<UnifiedSessionStore>()(
-    subscribeWithSelector((_, get, store) => {
-      const controller = createSessionIngressController({
-        store,
-        createSseManager: options.createSseManager,
-        transport,
-        logger,
-        fallbackToAllSeatsWhenUserIdMissing,
-        reducerEnvironment: {
-          fallbackToAllSeatsWhenUserIdMissing,
-          nextEventId: () => ++sseEventIdCounter,
-          nextNotificationId: generateNotificationId,
-          nowMs: () => Date.now(),
-          nowIso: () => new Date().toISOString(),
-        },
-      });
-
-      return {
-        ...createInitialUnifiedSessionState(),
-        ...controller,
-        getPluginSnapshot: () =>
-          selectPluginSnapshot(get(), fallbackToAllSeatsWhenUserIdMissing),
-        getRenderableGameplay: () => getGameplayViewport(get().session),
-      };
-    }),
-  );
-}
-
-export const unifiedSessionSelectors = {
-  sessionType: selectSessionType,
-  bootstrapStatus: selectBootstrapStatus,
-  sessionContext: selectSessionContext,
-  lobby: selectLobbyViewModel,
-  gameplay: selectGameplayViewModel,
-  gameplayViewport: selectGameplayViewport,
-  hasGameplayPayload: (s: UnifiedSessionStore) =>
-    getGameplayViewport(s.session) !== null,
-  history: selectHistory,
-  isConnected: (s: UnifiedSessionStore) => s.connection.isConnected,
-  connectionError: (s: UnifiedSessionStore) => s.connection.error,
-  connectionRecovery: (s: UnifiedSessionStore) => s.connection.recovery,
-  isLoading: (s: UnifiedSessionStore) =>
-    s.session.type === "loading" ||
-    s.session.type === "gameplayLoading" ||
-    s.connection.recovery.active,
-  error: selectSessionError,
-  sessionId: (s: UnifiedSessionStore) =>
-    getSessionContext(s.session)?.identity.sessionId ?? null,
-  shortCode: (s: UnifiedSessionStore) =>
-    getSessionContext(s.session)?.identity.shortCode ?? "",
-  gameId: (s: UnifiedSessionStore) =>
-    getSessionContext(s.session)?.identity.gameId ?? null,
-  seats: (s: UnifiedSessionStore) =>
-    getSessionContext(s.session)?.seats ?? EMPTY_ARRAY,
-  canStart: (s: UnifiedSessionStore) =>
-    getSessionContext(s.session)?.canStart ?? false,
-  hostActor: (s: UnifiedSessionStore) =>
-    getSessionContext(s.session)?.hostActor ?? null,
-  isSessionHost: (s: UnifiedSessionStore) =>
-    selectLobbyViewModel(s)?.isSessionHost ?? false,
-  controllablePlayerIds: (s: UnifiedSessionStore) => {
-    const context = getSessionContext(s.session);
-    return context
-      ? resolveControllablePlayerIds(
-          context.switchablePlayerIds,
-          context.seats,
-          context.userId,
-        )
-      : EMPTY_ARRAY;
-  },
-  controllingPlayerId: (s: UnifiedSessionStore) =>
-    s.session.type === "gameplay" ? s.session.perspective.playerId : null,
-  currentPlayerId: (s: UnifiedSessionStore) =>
-    s.session.type === "gameplay"
-      ? s.session.perspective.playerId
-      : s.session.type === "gameplayLoading"
-        ? s.session.requestedPlayerId
-        : s.session.type === "lobby"
-          ? s.session.preferredPlayerId
-          : null,
-  userId: (s: UnifiedSessionStore) =>
-    getSessionContext(s.session)?.userId ?? null,
-  notifications: (s: UnifiedSessionStore) => s.activity.notifications,
-  hostFeedback: (s: UnifiedSessionStore) => s.activity.hostFeedback,
-  sseEvents: (s: UnifiedSessionStore) => s.debug.sseEvents,
-  syncId: (s: UnifiedSessionStore) => s.activity.syncId,
-  activity: (s: UnifiedSessionStore) => s.activity,
-  debug: (s: UnifiedSessionStore) => s.debug,
-};