dreamboard 0.1.21 → 0.1.22

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

@@ -0,0 +1,112 @@
+import type { HostSessionWireEvent } from "./session-ingress.js";
+import type { SSEManager } from "./sse-manager.js";
+
+export interface SSEManagerLike {
+  connect: (
+    sessionId: string,
+    options: {
+      source?: string;
+      playerId?: string;
+    },
+  ) => Promise<void> | void;
+  disconnect: () => void;
+  on: SSEManager["on"];
+  onAnyMessage: SSEManager["onAnyMessage"];
+}
+
+export interface SessionLiveRuntime {
+  connectSession: (
+    sessionId: string,
+    options: { source?: string; playerId?: string },
+  ) => void;
+  reconnectGameplay: (
+    sessionId: string,
+    playerId: string,
+    source: string,
+  ) => void;
+  requestGameplayResync: (
+    sessionId: string,
+    playerId: string,
+    source: string,
+  ) => void;
+  closeStreams: () => void;
+  getConnectedSessionId: () => string | null;
+}
+
+export function createSessionLiveRuntime(options: {
+  createSseManager: () => SSEManagerLike;
+  onConnectionChange: (
+    channel: "lobby" | "gameplay",
+    connected: boolean,
+  ) => void;
+  onConnectionError: (error: unknown) => void;
+  onLiveMessage: (message: HostSessionWireEvent) => void;
+}): SessionLiveRuntime {
+  let connectedSessionId: string | null = null;
+  let sessionManager: SSEManagerLike | null = null;
+  let unsubscribeSession: (() => void) | null = null;
+
+  const attachConnectionHandlers = (
+    manager: SSEManagerLike,
+    channel: "lobby" | "gameplay",
+  ) => {
+    manager.on("connected", () => options.onConnectionChange(channel, true));
+    manager.on("disconnected", () =>
+      options.onConnectionChange(channel, false),
+    );
+    manager.on("error", (error) => {
+      options.onConnectionChange(channel, false);
+      options.onConnectionError(error);
+    });
+  };
+
+  const closeStreams = () => {
+    unsubscribeSession?.();
+    unsubscribeSession = null;
+    sessionManager?.disconnect();
+    sessionManager = null;
+    connectedSessionId = null;
+    options.onConnectionChange("lobby", false);
+    options.onConnectionChange("gameplay", false);
+  };
+
+  const openSession = (
+    sessionId: string,
+    playerId: string | undefined,
+    source: string,
+  ) => {
+    closeStreams();
+    connectedSessionId = sessionId;
+    sessionManager = options.createSseManager();
+    attachConnectionHandlers(sessionManager, playerId ? "gameplay" : "lobby");
+    unsubscribeSession = sessionManager.onAnyMessage(options.onLiveMessage);
+    void sessionManager.connect(sessionId, {
+      source,
+      playerId,
+    });
+  };
+
+  return {
+    connectSession: (sessionId, connectOptions) => {
+      openSession(
+        sessionId,
+        connectOptions.playerId,
+        connectOptions.source ?? "connect-session",
+      );
+    },
+    reconnectGameplay: (sessionId, playerId, source) => {
+      openSession(sessionId, playerId, source);
+    },
+    requestGameplayResync: (sessionId, playerId, source) => {
+      if (!sessionManager) {
+        return;
+      }
+      void sessionManager.connect(sessionId, {
+        source,
+        playerId,
+      });
+    },
+    closeStreams,
+    getConnectedSessionId: () => connectedSessionId,
+  };
+}

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

@@ -0,0 +1,318 @@
+import type {
+  HistoryEntrySummary,
+  InteractionDescriptor,
+  SeatAssignment,
+  SessionActor,
+  SessionGameSource,
+  ZoneHandles,
+} from "@dreamboard/api-client";
+import type { PluginStateSnapshot } from "@dreamboard/ui-sdk/reducer";
+import {
+  seatControlledByPrincipal,
+  gameIdFromGameSource,
+} from "./actor-principal.js";
+
+type LayoutConfig = unknown;
+type CardDisplayConfig = unknown;
+
+export interface SessionIdentity {
+  sessionId: string;
+  shortCode: string;
+  gameId: string;
+}
+
+export interface HistoryState {
+  entries: HistoryEntrySummary[];
+  currentIndex: number;
+  canGoBack: boolean;
+  canGoForward: boolean;
+}
+
+export interface SessionContextIngress {
+  sessionId: string;
+  shortCode: string;
+  gameSource: SessionGameSource;
+  hostActor: SessionActor;
+  switchablePlayerIds: string[];
+  history?: HistoryState | null;
+}
+
+export interface LobbyIngress {
+  seats: SeatAssignment[];
+  canStart: boolean;
+}
+
+export interface GameplayViewportIngress {
+  version: number;
+  actionSetVersion: string;
+  playerId: string;
+  activePlayers: string[];
+  currentPhase: string | null;
+  currentStage?: string | null;
+  stageSeats?: string[];
+  simultaneousPhase?: SimultaneousPhaseSnapshot | null;
+  view?: string | null;
+  availableInteractions?: InteractionDescriptor[];
+  zones?: Record<string, ZoneHandles>;
+  boardStatic?: string | null;
+  boardStaticHash?: string | null;
+}
+
+export interface SessionContext {
+  identity: SessionIdentity;
+  userId: string | null;
+  seats: SeatAssignment[];
+  canStart: boolean;
+  hostActor: SessionActor;
+  switchablePlayerIds: string[];
+  history: HistoryState | null;
+}
+
+export interface GameplayPerspective {
+  playerId: string;
+}
+
+export interface GameplayViewport {
+  version: number;
+  actionSetVersion: string;
+  activePlayers: string[];
+  currentPhase: string | null;
+  currentStage: string | null;
+  stageSeats: string[];
+  simultaneousPhase: SimultaneousPhaseSnapshot | null;
+  view: PluginStateSnapshot["view"];
+  availableInteractions: InteractionDescriptor[];
+  zones: Record<string, ZoneHandles>;
+  boardStatic: Record<string, unknown> | null;
+  boardStaticHash: string | null;
+  layout?: LayoutConfig | null;
+  cardDisplayConfigs?: CardDisplayConfig[] | null;
+}
+
+export interface SimultaneousPhaseSnapshot {
+  phaseName: string;
+  interactionId: string;
+  actorIds: string[];
+  sealedPlayerIds: string[];
+  pendingPlayerIds: string[];
+}
+
+export type UnifiedSessionModel =
+  | { type: "idle" }
+  | { type: "loading"; target?: { sessionId?: string; shortCode?: string } }
+  | { type: "lobby"; context: SessionContext; preferredPlayerId: string | null }
+  | {
+      type: "gameplayLoading";
+      context: SessionContext;
+      requestedPlayerId: string;
+    }
+  | {
+      type: "gameplay";
+      context: SessionContext;
+      perspective: GameplayPerspective;
+      gameplay: GameplayViewport;
+    }
+  | { type: "ended"; context: SessionContext }
+  | { type: "error"; message: string; context?: SessionContext };
+
+export type SessionPhase = UnifiedSessionModel["type"];
+
+export function toHistoryState(
+  history: SessionContextIngress["history"] | undefined,
+): HistoryState | null {
+  return history
+    ? {
+        entries: history.entries,
+        currentIndex: history.currentIndex,
+        canGoBack: history.canGoBack,
+        canGoForward: history.canGoForward,
+      }
+    : null;
+}
+
+export function identityFromHostContext(
+  context: SessionContextIngress,
+): SessionIdentity {
+  return {
+    sessionId: context.sessionId,
+    shortCode: context.shortCode,
+    gameId: gameIdFromGameSource(context.gameSource),
+  };
+}
+
+export function deriveControlledPlayerIdsFromSeats(
+  seats: SeatAssignment[],
+  userId: string | null,
+  fallbackToAllSeatsWhenUserIdMissing = false,
+): string[] {
+  if (!userId) {
+    return fallbackToAllSeatsWhenUserIdMissing
+      ? seats.map((seat) => seat.playerId)
+      : [];
+  }
+  return seats
+    .filter((seat) => seatControlledByPrincipal(seat, userId))
+    .map((seat) => seat.playerId);
+}
+
+export function resolveControllablePlayerIds(
+  preferredPlayerIds: string[] | null | undefined,
+  seats: SeatAssignment[],
+  userId: string | null,
+  fallbackToAllSeatsWhenUserIdMissing = false,
+): string[] {
+  return preferredPlayerIds && preferredPlayerIds.length > 0
+    ? preferredPlayerIds
+    : deriveControlledPlayerIdsFromSeats(
+        seats,
+        userId,
+        fallbackToAllSeatsWhenUserIdMissing,
+      );
+}
+
+export function contextFromHostParts(
+  wireContext: SessionContextIngress,
+  lobby: LobbyIngress,
+  userId: string | null,
+): SessionContext {
+  return {
+    identity: identityFromHostContext(wireContext),
+    userId,
+    seats: lobby.seats,
+    canStart: lobby.canStart,
+    hostActor: wireContext.hostActor,
+    switchablePlayerIds: wireContext.switchablePlayerIds,
+    history: toHistoryState(wireContext.history),
+  };
+}
+
+export function contextFromHostSnapshot(
+  snapshot: { context: SessionContextIngress; lobby: LobbyIngress },
+  userId: string | null,
+): SessionContext {
+  return contextFromHostParts(snapshot.context, snapshot.lobby, userId);
+}
+
+export function contextFromHostEventContext(
+  context: SessionContext,
+  wireContext: SessionContextIngress,
+  lobby?: LobbyIngress,
+): SessionContext {
+  return {
+    ...context,
+    identity: identityFromHostContext(wireContext),
+    seats: lobby?.seats ?? context.seats,
+    canStart: lobby?.canStart ?? context.canStart,
+    hostActor: wireContext.hostActor,
+    switchablePlayerIds: wireContext.switchablePlayerIds,
+    history:
+      wireContext.history !== undefined
+        ? toHistoryState(wireContext.history)
+        : context.history,
+  };
+}
+
+export function contextWithHistory(
+  context: SessionContext,
+  history: SessionContextIngress["history"],
+): SessionContext {
+  return { ...context, history: toHistoryState(history) };
+}
+
+export function safeJsonParseValue(jsonString: string): unknown {
+  try {
+    return JSON.parse(jsonString);
+  } catch {
+    return null;
+  }
+}
+
+export function transformView(
+  serializedView: string | null | undefined,
+): PluginStateSnapshot["view"] {
+  return serializedView
+    ? (safeJsonParseValue(serializedView) as PluginStateSnapshot["view"])
+    : null;
+}
+
+export function gameplayViewportFromSnapshot(
+  snapshot: GameplayViewportIngress,
+  previous?: GameplayViewport | null,
+): GameplayViewport {
+  const incomingBoardStatic = snapshot.boardStatic
+    ? (safeJsonParseValue(snapshot.boardStatic) as Record<
+        string,
+        unknown
+      > | null)
+    : null;
+  const incomingBoardStaticHash = snapshot.boardStaticHash ?? null;
+  const hashDisagrees =
+    previous?.boardStaticHash !== null &&
+    previous?.boardStaticHash !== undefined &&
+    incomingBoardStaticHash !== null &&
+    incomingBoardStaticHash !== previous.boardStaticHash;
+
+  return {
+    version: snapshot.version,
+    actionSetVersion: snapshot.actionSetVersion,
+    activePlayers: snapshot.activePlayers,
+    currentPhase: snapshot.currentPhase,
+    currentStage: snapshot.currentStage ?? previous?.currentStage ?? null,
+    stageSeats: snapshot.stageSeats ?? previous?.stageSeats ?? [],
+    simultaneousPhase: snapshot.simultaneousPhase ?? null,
+    view: transformView(snapshot.view),
+    availableInteractions: snapshot.availableInteractions ?? [],
+    zones: snapshot.zones ?? previous?.zones ?? {},
+    boardStatic: hashDisagrees
+      ? (previous?.boardStatic ?? null)
+      : (incomingBoardStatic ?? previous?.boardStatic ?? null),
+    boardStaticHash:
+      incomingBoardStaticHash ?? previous?.boardStaticHash ?? null,
+    layout: previous?.layout ?? null,
+    cardDisplayConfigs: previous?.cardDisplayConfigs ?? null,
+  };
+}
+
+export function getSessionContext(
+  session: UnifiedSessionModel,
+): SessionContext | null {
+  switch (session.type) {
+    case "lobby":
+    case "gameplayLoading":
+    case "gameplay":
+    case "ended":
+      return session.context;
+    case "error":
+      return session.context ?? null;
+    case "idle":
+    case "loading":
+      return null;
+  }
+}
+
+export function getGameplayViewport(
+  session: UnifiedSessionModel,
+): GameplayViewport | null {
+  return session.type === "gameplay" ? session.gameplay : null;
+}
+
+export function withContext(
+  session: UnifiedSessionModel,
+  context: SessionContext,
+): UnifiedSessionModel {
+  switch (session.type) {
+    case "lobby":
+      return { ...session, context };
+    case "gameplayLoading":
+      return { ...session, context };
+    case "gameplay":
+      return { ...session, context };
+    case "ended":
+      return { type: "ended", context };
+    case "error":
+      return { type: "error", message: session.message, context };
+    case "idle":
+    case "loading":
+      return { type: "lobby", context, preferredPlayerId: null };
+  }
+}

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

@@ -0,0 +1,211 @@
+import type {
+  InteractionDescriptor,
+  ZoneHandles,
+} from "@dreamboard/api-client";
+import type { PluginStateSnapshot } from "@dreamboard/ui-sdk/reducer";
+import {
+  principalKey,
+  principalMatchesActor,
+  seatsForPluginSnapshot,
+} from "./actor-principal.js";
+import type {
+  GameplayViewport,
+  HistoryState,
+  SessionContext,
+  SessionIdentity,
+  UnifiedSessionModel,
+} from "./session-model.js";
+import {
+  getGameplayViewport,
+  getSessionContext,
+  resolveControllablePlayerIds,
+} from "./session-model.js";
+
+export interface NotificationProjectionState {
+  notifications: PluginStateSnapshot["notifications"];
+  syncId: number;
+}
+
+export interface ProjectionState {
+  session: UnifiedSessionModel;
+  activity: NotificationProjectionState;
+}
+
+export interface LobbyViewModel {
+  identity: SessionIdentity;
+  seats: SessionContext["seats"];
+  canStart: boolean;
+  hostActor: SessionContext["hostActor"];
+  shortCode: string;
+  isSessionHost: boolean;
+}
+
+export interface GameplayViewModel {
+  context: SessionContext;
+  perspective: { playerId: string };
+  gameplay: GameplayViewport;
+}
+
+export type BootstrapStatus = "loading" | "lobby" | "renderable" | "error";
+
+const lobbyViewModelCache = new WeakMap<SessionContext, LobbyViewModel>();
+const gameplayViewModelCache = new WeakMap<
+  GameplayViewport,
+  { context: SessionContext; value: GameplayViewModel }
+>();
+
+export function selectSessionContext(
+  state: Pick<ProjectionState, "session">,
+): SessionContext | null {
+  return getSessionContext(state.session);
+}
+
+export function selectGameplayViewport(
+  state: Pick<ProjectionState, "session">,
+): GameplayViewport | null {
+  return getGameplayViewport(state.session);
+}
+
+export function selectSessionType(
+  state: Pick<ProjectionState, "session">,
+): UnifiedSessionModel["type"] {
+  return state.session.type;
+}
+
+export function selectBootstrapStatus(
+  state: Pick<ProjectionState, "session">,
+): BootstrapStatus {
+  switch (state.session.type) {
+    case "idle":
+    case "loading":
+    case "gameplayLoading":
+      return "loading";
+    case "lobby":
+    case "ended":
+      return "lobby";
+    case "gameplay":
+      return "renderable";
+    case "error":
+      return "error";
+  }
+}
+
+export function selectSessionError(
+  state: Pick<ProjectionState, "session">,
+): string | null {
+  return state.session.type === "error" ? state.session.message : null;
+}
+
+export function selectLobbyViewModel(
+  state: Pick<ProjectionState, "session">,
+): LobbyViewModel | null {
+  const context = getSessionContext(state.session);
+  if (!context) return null;
+  const cached = lobbyViewModelCache.get(context);
+  if (cached) return cached;
+  const viewModel = {
+    identity: context.identity,
+    seats: context.seats,
+    canStart: context.canStart,
+    hostActor: context.hostActor,
+    shortCode: context.identity.shortCode,
+    isSessionHost:
+      Boolean(context.userId) &&
+      principalMatchesActor(context.userId, context.hostActor),
+  };
+  lobbyViewModelCache.set(context, viewModel);
+  return viewModel;
+}
+
+export function selectGameplayViewModel(
+  state: Pick<ProjectionState, "session">,
+): GameplayViewModel | null {
+  if (state.session.type !== "gameplay") return null;
+  const cached = gameplayViewModelCache.get(state.session.gameplay);
+  if (cached?.context === state.session.context) return cached.value;
+  const value = {
+    context: state.session.context,
+    perspective: state.session.perspective,
+    gameplay: state.session.gameplay,
+  };
+  gameplayViewModelCache.set(state.session.gameplay, {
+    context: state.session.context,
+    value,
+  });
+  return value;
+}
+
+export function selectPluginSnapshot(
+  state: ProjectionState,
+  fallbackToAllSeatsWhenUserIdMissing = false,
+): PluginStateSnapshot {
+  const context = getSessionContext(state.session);
+  const gameplay = getGameplayViewport(state.session);
+  const perspectivePlayerId =
+    state.session.type === "gameplay"
+      ? state.session.perspective.playerId
+      : null;
+  const controllablePlayerIds = context
+    ? resolveControllablePlayerIds(
+        context.switchablePlayerIds,
+        context.seats,
+        context.userId,
+        fallbackToAllSeatsWhenUserIdMissing,
+      )
+    : [];
+  const controllingPlayerId = perspectivePlayerId;
+  const gameplayIsRenderable =
+    gameplay !== null && perspectivePlayerId !== null;
+  const visibleInteractions: InteractionDescriptor[] = gameplayIsRenderable
+    ? gameplay.availableInteractions
+    : [];
+  const seatView = gameplayIsRenderable ? gameplay.view : null;
+  const boardStatic = gameplay?.boardStatic ?? null;
+  const view: PluginStateSnapshot["view"] =
+    boardStatic && seatView && typeof seatView === "object"
+      ? ({
+          ...(seatView as Record<string, unknown>),
+          board: {
+            ...((seatView as { board?: Record<string, unknown> }).board ?? {}),
+            ...boardStatic,
+          },
+        } as PluginStateSnapshot["view"])
+      : boardStatic && !seatView
+        ? ({ board: boardStatic } as unknown as PluginStateSnapshot["view"])
+        : seatView;
+  const visibleZones: Record<string, ZoneHandles> = gameplayIsRenderable
+    ? gameplay.zones
+    : {};
+
+  return {
+    view,
+    gameplay: {
+      currentPhase: gameplay?.currentPhase ?? null,
+      currentStage: gameplay?.currentStage ?? null,
+      activePlayers: gameplay?.activePlayers ?? [],
+      simultaneousPhase: gameplay?.simultaneousPhase ?? null,
+      availableInteractions: visibleInteractions,
+      zones: visibleZones,
+    },
+    lobby: {
+      seats: seatsForPluginSnapshot(context?.seats ?? []),
+      canStart: context?.canStart ?? false,
+      hostUserId: context ? principalKey(context.hostActor) : "",
+    },
+    notifications: state.activity.notifications,
+    session: {
+      sessionId: context?.identity.sessionId ?? null,
+      controllablePlayerIds,
+      controllingPlayerId,
+      userId: context?.userId ?? null,
+    },
+    history: context?.history ?? null,
+    syncId: state.activity.syncId,
+  };
+}
+
+export function selectHistory(
+  state: Pick<ProjectionState, "session">,
+): HistoryState | null {
+  return getSessionContext(state.session)?.history ?? null;
+}