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

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

@@ -1,431 +0,0 @@
-import type {
-  HistoryEntrySummary,
-  HostGameplaySeatView,
-  HostSessionStatus,
-  InteractionDescriptor,
-  SeatAssignment,
-  SessionActor,
-  SessionGameSource,
-  ZoneHandles as WireZoneHandles,
-} from "@dreamboard-games/api-client";
-import type {
-  PluginStateSnapshot,
-  ZoneHandlesSnapshot,
-} from "@dreamboard-games/sdk/runtime/runtime-api";
-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;
-  status: HostSessionStatus;
-  gameSource: SessionGameSource;
-  setupProfileId?: string | null;
-  hostActor: SessionActor;
-  switchablePlayerIds: string[];
-  history?: HistoryState | null;
-}
-
-export interface LobbyIngress {
-  seats: SeatAssignment[];
-  canStart: boolean;
-}
-
-export interface GameplayViewportIngress {
-  version: number;
-  actionSetVersion: string;
-  perspectivePlayerId: string;
-  controllablePlayerIds: string[];
-  shared: {
-    activePlayers: string[];
-    currentPhase: string | null;
-    currentStage?: string | null;
-    stageSeats?: string[];
-    simultaneousPhase?: SimultaneousPhaseSnapshot | null;
-    boardStatic?: string | null;
-    boardStaticHash?: string | null;
-  };
-  interactionsByRef: Record<string, InteractionDescriptor | null | undefined>;
-  seats: Record<string, HostGameplaySeatView | null | undefined>;
-}
-
-export interface SessionContext {
-  identity: SessionIdentity;
-  userId: string | null;
-  seats: SeatAssignment[];
-  canStart: boolean;
-  status: HostSessionStatus;
-  gameSource: SessionGameSource;
-  setupProfileId?: string | null;
-  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, ZoneHandlesSnapshot>;
-  boardStatic: Record<string, unknown> | null;
-  boardStaticHash: string | null;
-  layout?: LayoutConfig | null;
-  cardDisplayConfigs?: CardDisplayConfig[] | null;
-  seatProjectionsByPlayerId: Record<string, GameplaySeatProjection>;
-}
-
-export interface GameplaySeatProjection {
-  version: number;
-  actionSetVersion: string;
-  view: PluginStateSnapshot["view"];
-  availableInteractions: InteractionDescriptor[];
-  zones: Record<string, ZoneHandlesSnapshot>;
-}
-
-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,
-    status: wireContext.status,
-    gameSource: wireContext.gameSource,
-    setupProfileId: wireContext.setupProfileId ?? null,
-    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),
-    status: wireContext.status,
-    gameSource: wireContext.gameSource,
-    setupProfileId: wireContext.setupProfileId ?? null,
-    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.shared.boardStatic
-    ? (safeJsonParseValue(snapshot.shared.boardStatic) as Record<
-        string,
-        unknown
-      > | null)
-    : null;
-  const incomingBoardStaticHash = snapshot.shared.boardStaticHash ?? null;
-  const hashDisagrees =
-    previous?.boardStaticHash !== null &&
-    previous?.boardStaticHash !== undefined &&
-    incomingBoardStaticHash !== null &&
-    incomingBoardStaticHash !== previous.boardStaticHash;
-  const interactionsByRef = snapshot.interactionsByRef ?? {};
-  const hydrateInteractionRefs = (
-    refs: readonly string[] | null | undefined,
-  ): InteractionDescriptor[] =>
-    (refs ?? [])
-      .map((ref) => interactionsByRef[ref])
-      .filter((descriptor): descriptor is InteractionDescriptor =>
-        Boolean(descriptor),
-      );
-  const incomingSeatProjections = Object.fromEntries(
-    Object.entries(snapshot.seats ?? {}).flatMap(([playerId, seat]) => {
-      if (!seat) return [];
-      return [
-        [
-          playerId,
-          {
-            version: snapshot.version,
-            actionSetVersion:
-              seat.actionSetVersion ?? snapshot.actionSetVersion,
-            view: transformView(seat.view),
-            availableInteractions: hydrateInteractionRefs(
-              seat.availableInteractionRefs,
-            ),
-            zones: hydrateZones(seat.zones, hydrateInteractionRefs),
-          } satisfies GameplaySeatProjection,
-        ],
-      ];
-    }),
-  );
-  const seatProjectionsByPlayerId =
-    previous?.version === snapshot.version
-      ? {
-          ...previous.seatProjectionsByPlayerId,
-          ...incomingSeatProjections,
-        }
-      : incomingSeatProjections;
-  const perspectiveSeat =
-    seatProjectionsByPlayerId[snapshot.perspectivePlayerId] ?? null;
-
-  return {
-    version: snapshot.version,
-    actionSetVersion:
-      perspectiveSeat?.actionSetVersion ?? snapshot.actionSetVersion,
-    activePlayers: snapshot.shared.activePlayers,
-    currentPhase: snapshot.shared.currentPhase,
-    currentStage:
-      snapshot.shared.currentStage ?? previous?.currentStage ?? null,
-    stageSeats: snapshot.shared.stageSeats ?? previous?.stageSeats ?? [],
-    simultaneousPhase: snapshot.shared.simultaneousPhase ?? null,
-    view: perspectiveSeat?.view ?? null,
-    availableInteractions: perspectiveSeat?.availableInteractions ?? [],
-    zones: perspectiveSeat?.zones ?? {},
-    boardStatic: hashDisagrees
-      ? (previous?.boardStatic ?? null)
-      : (incomingBoardStatic ?? previous?.boardStatic ?? null),
-    boardStaticHash:
-      incomingBoardStaticHash ?? previous?.boardStaticHash ?? null,
-    layout: previous?.layout ?? null,
-    cardDisplayConfigs: previous?.cardDisplayConfigs ?? null,
-    seatProjectionsByPlayerId,
-  };
-}
-
-export function gameplayViewportForPlayer(
-  gameplay: GameplayViewport,
-  playerId: string,
-): GameplayViewport | null {
-  const seatProjection = gameplay.seatProjectionsByPlayerId[playerId];
-  if (!seatProjection || seatProjection.version !== gameplay.version) {
-    return null;
-  }
-  return {
-    ...gameplay,
-    actionSetVersion: seatProjection.actionSetVersion,
-    view: seatProjection.view,
-    availableInteractions: seatProjection.availableInteractions,
-    zones: seatProjection.zones,
-  };
-}
-
-function hydrateZones(
-  zones: Record<string, WireZoneHandles | null | undefined> | null | undefined,
-  hydrateInteractionRefs: (
-    refs: readonly string[] | null | undefined,
-  ) => InteractionDescriptor[],
-): Record<string, ZoneHandlesSnapshot> {
-  return Object.fromEntries(
-    Object.entries(zones ?? {}).flatMap(([zoneId, zone]) => {
-      if (!zone) return [];
-      return [
-        [
-          zoneId,
-          {
-            cardIds: zone.cardIds,
-            cardViewsById: zone.cardViewsById,
-            playableByCardId: Object.fromEntries(
-              Object.entries(zone.playableByCardId).map(([cardId, refs]) => [
-                cardId,
-                hydrateInteractionRefs(refs ?? []),
-              ]),
-            ),
-          },
-        ],
-      ];
-    }),
-  );
-}
-
-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

@@ -1,211 +0,0 @@
-import type { InteractionDescriptor } from "@dreamboard-games/api-client";
-import type {
-  PluginStateSnapshot,
-  ZoneHandlesSnapshot,
-} from "@dreamboard-games/sdk/runtime/runtime-api";
-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, ZoneHandlesSnapshot> = 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;
-}

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

@@ -1,80 +0,0 @@
-export interface SessionRecoveryDetails {
-  message: string;
-  retryAfterMs: number;
-}
-
-const DEFAULT_RECOVERY_RETRY_AFTER_MS = 2_000;
-
-function asRecord(value: unknown): Record<string, unknown> | null {
-  return value && typeof value === "object"
-    ? (value as Record<string, unknown>)
-    : null;
-}
-
-function parseRetryAfterMs(value: unknown): number | null {
-  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
-    return value;
-  }
-  if (typeof value !== "string") {
-    return null;
-  }
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
-}
-
-function getProblemPayload(error: unknown): Record<string, unknown> | null {
-  const direct = asRecord(error);
-  if (!direct) {
-    return null;
-  }
-  if (typeof direct.title === "string" && typeof direct.status === "number") {
-    return direct;
-  }
-  for (const key of ["error", "data", "body", "cause"]) {
-    const nested = asRecord(direct[key]);
-    if (
-      nested &&
-      typeof nested.title === "string" &&
-      typeof nested.status === "number"
-    ) {
-      return nested;
-    }
-  }
-  return null;
-}
-
-export function getSessionRecoveryDetails(
-  error: unknown,
-): SessionRecoveryDetails | null {
-  const problem = getProblemPayload(error);
-  if (problem) {
-    const title = typeof problem.title === "string" ? problem.title : "";
-    const detail = typeof problem.detail === "string" ? problem.detail : "";
-    const retryable = problem.retryable === true;
-    const isRecovery =
-      problem.status === 503 &&
-      retryable &&
-      (title === "Session recovering" ||
-        detail.toLowerCase().includes("recovering"));
-    if (!isRecovery) {
-      return null;
-    }
-    const context = asRecord(problem.context);
-    return {
-      message:
-        detail.trim() || "Session state is recovering. Retrying shortly.",
-      retryAfterMs:
-        parseRetryAfterMs(context?.retryAfterMs) ??
-        DEFAULT_RECOVERY_RETRY_AFTER_MS,
-    };
-  }
-
-  if (error instanceof Error && /SSE failed:\s*503\b/i.test(error.message)) {
-    return {
-      message: "Session state is recovering. Retrying shortly.",
-      retryAfterMs: DEFAULT_RECOVERY_RETRY_AFTER_MS,
-    };
-  }
-
-  return null;
-}