@dreamboard-games/sdk 0.4.0-alpha.1 → 0.4.0-alpha.3

package/dist/index-BLwlj7mO.d.ts

@@ -0,0 +1,191 @@
+import { ReactNode, ReactElement, ButtonHTMLAttributes } from 'react';
+import { l as BoardSpaceTargetProps, bh as ZoneListProps, b1 as UIContract } from './ui-contract-CY7cxsCC.js';
+import { H as HandRole } from './ResourceCounter-BuiNstXs.js';
+
+interface ClientParamSchema {
+    safeParse: (value: unknown) => {
+        success: true;
+        data: Record<string, unknown>;
+    } | {
+        success: false;
+        error: {
+            issues: ReadonlyArray<{
+                path: readonly PropertyKey[];
+                message: string;
+            }>;
+        };
+    };
+}
+type ClientParamSchemaMap = Readonly<Record<string, Readonly<Record<string, ClientParamSchema>>>>;
+
+type WorkspaceInteractionSlotComponent<Props = object> = (props: Props extends {
+    children: unknown;
+} ? Props : Props & {
+    children?: ReactNode;
+}) => ReactElement | null;
+interface WorkspaceFormInputSlot<Input extends string = string> {
+    readonly Field: WorkspaceInteractionSlotComponent;
+    readonly Options: WorkspaceInteractionSlotComponent<{
+        children?: (option: {
+            value: unknown;
+            label: string;
+        }) => ReactNode;
+    }>;
+    readonly Value: WorkspaceInteractionSlotComponent<{
+        children: (value: unknown | undefined) => ReactNode;
+    }>;
+    readonly Default: WorkspaceInteractionSlotComponent;
+    readonly __input?: Input;
+}
+interface WorkspaceCardInputSlot<Card extends string = string> {
+    readonly Card: WorkspaceInteractionSlotComponent<{
+        value: Card;
+    } & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children" | "disabled" | "aria-disabled" | "aria-pressed" | "onClick" | "type" | "value">>;
+    readonly Cards: WorkspaceInteractionSlotComponent<{
+        children: (card: {
+            id: Card;
+        }) => ReactNode;
+    }>;
+    readonly Value: WorkspaceInteractionSlotComponent<{
+        children: (value: unknown | undefined) => ReactNode;
+    }>;
+    readonly Default: WorkspaceInteractionSlotComponent;
+}
+interface WorkspaceBoardTargetInputSlot<Kind extends "space" | "edge" | "vertex" | "tile", Target extends string = string> {
+    readonly Target: WorkspaceInteractionSlotComponent<{
+        value: Target;
+    } & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children" | "disabled" | "aria-disabled" | "aria-pressed" | "onClick" | "type" | "value">>;
+    readonly Value: WorkspaceInteractionSlotComponent<{
+        children: (value: unknown | undefined) => ReactNode;
+    }>;
+    readonly Default: WorkspaceInteractionSlotComponent;
+    readonly __kind?: Kind;
+}
+interface WorkspaceBoardSurface<Space extends string = string, Edge extends string = string, Vertex extends string = string, Tile extends string = string> {
+    readonly Root: WorkspaceInteractionSlotComponent;
+    readonly Space: <Target extends Space>(props: BoardSpaceTargetProps<Target>) => ReactElement | null;
+    readonly slot: {
+        readonly space: WorkspaceBoardTargetInputSlot<"space", Space>;
+        readonly playerSpace: WorkspaceBoardTargetInputSlot<"space", Space>;
+        readonly edge: WorkspaceBoardTargetInputSlot<"edge", Edge>;
+        readonly vertex: WorkspaceBoardTargetInputSlot<"vertex", Vertex>;
+        readonly tile: WorkspaceBoardTargetInputSlot<"tile", Tile>;
+    };
+}
+type WorkspaceZoneCardsComponent<Card> = WorkspaceInteractionSlotComponent<Omit<ZoneListProps, "children" | "empty"> & {
+    empty?: ReactNode;
+    children: (card: Card) => ReactNode;
+}>;
+type WorkspaceZoneCardComponent<Card> = WorkspaceInteractionSlotComponent<Omit<ButtonHTMLAttributes<HTMLButtonElement>, "type" | "value"> & {
+    card: Card;
+}>;
+type WorkspaceZoneStagingComponent<Card> = WorkspaceInteractionSlotComponent<{
+    children: (card: Card) => ReactNode;
+    label?: ReactNode;
+    renderEmptySlot?: (index: number) => ReactNode;
+    cardSize?: "sm" | "md" | "lg";
+    ariaLabel?: string;
+    className?: string;
+}>;
+type WorkspaceHandCardsComponent<Card> = WorkspaceInteractionSlotComponent<{
+    children: (card: Card, state: unknown) => ReactNode;
+}>;
+type WorkspaceHandSummaryComponent = WorkspaceInteractionSlotComponent<{
+    children?: ReactNode | ((summary: unknown) => ReactNode);
+}>;
+interface WorkspaceHandSurface<Zone extends string, Card> {
+    readonly Hand: WorkspaceInteractionSlotComponent<{
+        children: ReactNode;
+    }>;
+    readonly Cards: WorkspaceHandCardsComponent<Card>;
+    readonly Summary: WorkspaceHandSummaryComponent;
+    readonly Actions: WorkspaceHandSummaryComponent;
+    readonly Card: WorkspaceZoneCardComponent<Card>;
+    readonly Staging: WorkspaceZoneStagingComponent<Card>;
+    readonly slot: {
+        readonly card: WorkspaceCardInputSlot<Zone>;
+    };
+}
+interface WorkspacePileSurface<Card> {
+    readonly Pile: WorkspaceZoneCardsComponent<Card>;
+    readonly Card: WorkspaceZoneCardComponent<Card>;
+}
+interface WorkspaceCardCollectionSurface<Zone extends string, Card> {
+    readonly Collection: WorkspaceZoneCardsComponent<Card>;
+    readonly Card: WorkspaceZoneCardComponent<Card>;
+    readonly slot: {
+        readonly card: WorkspaceCardInputSlot<Zone>;
+    };
+}
+interface WorkspaceBoardSurfaceDescriptor<Board extends string = string> {
+    readonly kind: "board";
+    readonly board: Board;
+}
+interface WorkspaceHandSurfaceDescriptor<Zone extends string = string> {
+    readonly kind: "hand";
+    readonly zone: Zone;
+    readonly role: HandRole;
+    readonly label: string;
+    readonly order?: number;
+}
+interface WorkspacePileSurfaceDescriptor<Zone extends string = string> {
+    readonly kind: "pile";
+    readonly zone: Zone;
+}
+interface WorkspacePilesSurfaceDescriptor<Zones extends readonly string[] = readonly string[]> {
+    readonly kind: "piles";
+    readonly zones: Zones;
+}
+interface WorkspaceCardCollectionSurfaceDescriptor<Zones extends readonly string[] = readonly string[]> {
+    readonly kind: "cardCollection";
+    readonly zones: Zones;
+    readonly mode?: "all" | "top-card";
+}
+interface WorkspaceInteractionFormsDescriptor<Interactions extends Readonly<Record<string, string>> = Readonly<Record<string, string>>> {
+    readonly kind: "forms";
+    readonly interactions: Interactions;
+}
+interface WorkspaceInteractionFormDescriptor<Interaction extends string = string> {
+    readonly kind: "form";
+    readonly interaction: Interaction;
+}
+type WorkspaceSurfaceDescriptor = WorkspaceBoardSurfaceDescriptor | WorkspaceHandSurfaceDescriptor | WorkspacePileSurfaceDescriptor | WorkspacePilesSurfaceDescriptor | WorkspaceCardCollectionSurfaceDescriptor | WorkspaceInteractionFormDescriptor | WorkspaceInteractionFormsDescriptor;
+interface WorkspaceSurfaceSpec {
+    readonly [key: string]: WorkspaceSurfaceDescriptor | WorkspaceSurfaceSpec;
+}
+interface WorkspaceContractOptions<Contract extends UIContract, Resource extends string, Card, HexBoards extends Record<string, unknown>> {
+    readonly uiContract: Contract;
+    readonly clientParamSchemasByPhase?: ClientParamSchemaMap;
+    readonly formInputKeysForInteraction: (interaction: string) => ReadonlySet<string>;
+    readonly resourceIds: readonly Resource[];
+    readonly resourcePresentationById?: Partial<Record<string, {
+        label?: string;
+        icon?: string;
+    }>>;
+    readonly hexStaticBoards: HexBoards;
+    readonly cardIdFromZoneCard: (card: Card) => string;
+    readonly zoneIdFromZoneCard: (card: Card) => string;
+}
+
+interface DefineGameUIConfig<GameState, Surfaces> {
+    useSurfaces: () => Surfaces;
+    interactionRoutes?: (context: {
+        game: GameState;
+        surfaces: Surfaces;
+    }) => Record<string, {
+        collect: Record<string, unknown>;
+    }>;
+    phases: Record<string, (context: {
+        game: GameState;
+        surfaces: Surfaces;
+    }) => ReactNode>;
+    renderInteractions?: (context: {
+        game: GameState;
+        surfaces: Surfaces;
+    }) => ReactNode;
+    fallback?: ReactNode | ((phase: string | null) => ReactNode);
+    includeUnavailableInteractions?: boolean | null;
+}
+declare function createWorkspaceUIContract<WorkspaceUI, Contract extends UIContract, Resource extends string, Card, HexBoards extends Record<string, unknown>>(options: WorkspaceContractOptions<Contract, Resource, Card, HexBoards>): WorkspaceUI;
+
+export { type ClientParamSchemaMap as C, type DefineGameUIConfig as D, type WorkspaceBoardSurface as W, type WorkspaceBoardSurfaceDescriptor as a, type WorkspaceBoardTargetInputSlot as b, type WorkspaceCardCollectionSurface as c, type WorkspaceCardCollectionSurfaceDescriptor as d, type WorkspaceCardInputSlot as e, type WorkspaceFormInputSlot as f, type WorkspaceHandSurface as g, type WorkspaceHandSurfaceDescriptor as h, type WorkspaceInteractionFormDescriptor as i, type WorkspaceInteractionFormsDescriptor as j, type WorkspaceInteractionSlotComponent as k, type WorkspacePileSurface as l, type WorkspacePileSurfaceDescriptor as m, type WorkspacePilesSurfaceDescriptor as n, type WorkspaceSurfaceSpec as o, createWorkspaceUIContract as p };

package/dist/index.js

@@ -2,7 +2,8 @@ import {
   DREAMBOARD_SDK_PACKAGES,
   DREAMBOARD_SDK_PACKAGE_SET,
   DREAMBOARD_SDK_VERSION
-} from "./chunk-IUGKW2GS.js";
+} from "./chunk-BKD7XAWB.js";
+import "./chunk-DQ7GCD6C.js";
 import "./chunk-PZ5AY32C.js";
 export {
   DREAMBOARD_SDK_PACKAGES,

package/dist/package-set.d.ts

@@ -1,6 +1,6 @@
-declare const DREAMBOARD_SDK_VERSION = "0.4.0-alpha.1";
+declare const DREAMBOARD_SDK_VERSION: "0.4.0-alpha.3";
 declare const DREAMBOARD_SDK_PACKAGES: {
-    readonly "@dreamboard-games/sdk": "0.4.0-alpha.1";
+    readonly "@dreamboard-games/sdk": "0.4.0-alpha.3";
 };
 type DreamboardSdkPackageName = keyof typeof DREAMBOARD_SDK_PACKAGES;
 type DreamboardSdkPackageSet = {

package/dist/package-set.js

@@ -2,7 +2,8 @@ import {
   DREAMBOARD_SDK_PACKAGES,
   DREAMBOARD_SDK_PACKAGE_SET,
   DREAMBOARD_SDK_VERSION
-} from "./chunk-IUGKW2GS.js";
+} from "./chunk-BKD7XAWB.js";
+import "./chunk-DQ7GCD6C.js";
 import "./chunk-PZ5AY32C.js";
 export {
   DREAMBOARD_SDK_PACKAGES,

package/dist/player-state-Cqpyeql0.d.ts

@@ -0,0 +1,371 @@
+import { ViewCard } from './types.js';
+
+type HexColor = string & {
+    readonly __brand: "HexColor";
+};
+declare function isHexColor(value: unknown): value is HexColor;
+declare function parseHexColor(value: unknown): HexColor | undefined;
+declare function hexColor(value: string): HexColor;
+
+type PlayerId = string;
+type CardId = string;
+type DeckId = string;
+type BoardBaseId = string;
+type BoardId = string;
+type PieceId = string;
+type SpaceId = string;
+type DieId = string;
+type EdgeTypeId = string;
+type VertexTypeId = string;
+type PieceTypeId = string;
+type SpaceTypeId = string;
+type CardProperties = Record<string, unknown>;
+type CardIdsByDeckId = Record<DeckId, readonly CardId[]>;
+interface PerPlayer<Value> {
+    readonly __perPlayer: true;
+    readonly entries: ReadonlyArray<readonly [PlayerId, Value]>;
+}
+interface SharedBoardRef<BaseId extends string = BoardBaseId> {
+    readonly baseId: BaseId;
+    readonly seat?: undefined;
+}
+interface PerPlayerBoardRef<BaseId extends string = BoardBaseId, Id extends string = PlayerId> {
+    readonly baseId: BaseId;
+    readonly seat: Id;
+}
+type BoardRef<BaseId extends string = BoardBaseId, Id extends string = PlayerId> = SharedBoardRef<BaseId> | PerPlayerBoardRef<BaseId, Id>;
+/**
+ * Hands are keyed by the authored hand id and split per seat. The per-seat
+ * entries are populated from the runtime seat list, not the static manifest
+ * upper bound, so views always match what the backend actually computed.
+ */
+type CardIdsByHandId = Record<string, PerPlayer<CardId[]>>;
+type StateName = string;
+type TilePropertiesByBoardId = Record<BoardId, Record<string, unknown>>;
+type EdgePropertiesByBoardId = Record<BoardId, Record<string, unknown>>;
+type VertexPropertiesByBoardId = Record<BoardId, Record<string, unknown>>;
+interface Player {
+    /** Player ID */
+    playerId: PlayerId;
+    /** Player display name */
+    name: string;
+    /** Whether this player is the host */
+    isHost?: boolean;
+    /** Player's assigned color */
+    color?: HexColor;
+}
+interface HexTileState<B extends string = BoardId, SpaceIdValue extends string = SpaceId, Properties = B extends keyof TilePropertiesByBoardId ? TilePropertiesByBoardId[B] : undefined, View = unknown> {
+    /** Unique tile identifier */
+    id: SpaceIdValue;
+    /** Axial coordinate Q */
+    q: number;
+    /** Axial coordinate R */
+    r: number;
+    /** Tile type identifier for rendering */
+    typeId?: SpaceTypeId;
+    /** Display label on the tile */
+    label?: string;
+    /** Player ID who owns this tile */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: Properties;
+    /**
+     * Optional view-projection overlay merged onto the static topology by
+     * component-first board helpers such as `Board.HexView`. Authored boards can
+     * also supply this directly when building tiles by hand.
+     */
+    view?: View;
+}
+/** State of an edge on a reducer-projected hex board. */
+interface HexEdgeState<B extends string = BoardId, SpaceIdValue extends string = SpaceId, EdgeIdValue extends string = string, Properties = B extends keyof EdgePropertiesByBoardId ? EdgePropertiesByBoardId[B] : undefined> {
+    /** Unique edge identifier (serialized string, e.g., "tile1-tile2") */
+    id: EdgeIdValue;
+    /** First hex tile ID this edge borders */
+    hex1: SpaceIdValue;
+    /** Second hex tile ID this edge borders */
+    hex2: SpaceIdValue;
+    /** Edge type identifier for rendering */
+    typeId?: EdgeTypeId;
+    /** Display label for setup or rendering */
+    label?: string;
+    /** Player ID who owns this edge */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: Properties;
+}
+/** State of a vertex on a reducer-projected hex board. */
+interface HexVertexState<B extends string = BoardId, SpaceIdValue extends string = SpaceId, VertexIdValue extends string = string, Properties = B extends keyof VertexPropertiesByBoardId ? VertexPropertiesByBoardId[B] : undefined> {
+    /** Unique vertex identifier (serialized string, e.g., "tile1-tile2-tile3") */
+    id: VertexIdValue;
+    /** The hex tile IDs this vertex touches */
+    hexes: readonly SpaceIdValue[];
+    /** Vertex type identifier for rendering */
+    typeId?: VertexTypeId;
+    /** Display label for setup or rendering */
+    label?: string;
+    /** Player ID who owns this vertex */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: Properties;
+}
+/** Complete state of a reducer-projected hex board. */
+interface HexBoardState<B extends string = BoardId, SpaceIdValue extends string = SpaceId, EdgeIdValue extends string = string, VertexIdValue extends string = string, TileProperties = B extends keyof TilePropertiesByBoardId ? TilePropertiesByBoardId[B] : undefined, EdgeProperties = B extends keyof EdgePropertiesByBoardId ? EdgePropertiesByBoardId[B] : undefined, VertexProperties = B extends keyof VertexPropertiesByBoardId ? VertexPropertiesByBoardId[B] : undefined> {
+    /** Unique board identifier */
+    id: B;
+    /** All tiles on the board */
+    tiles: ReadonlyArray<HexTileState<B, SpaceIdValue, TileProperties>>;
+    /** All edges on the board */
+    edges: ReadonlyArray<HexEdgeState<B, SpaceIdValue, EdgeIdValue, EdgeProperties>>;
+    /** All vertices on the board */
+    vertices: ReadonlyArray<HexVertexState<B, SpaceIdValue, VertexIdValue, VertexProperties>>;
+}
+/** State of a node in a reducer-projected network board. */
+interface NetworkNodeState {
+    /** Unique node identifier */
+    id: SpaceId;
+    /** X coordinate position */
+    x: number;
+    /** Y coordinate position */
+    y: number;
+    /** Node type identifier for rendering */
+    typeId?: SpaceTypeId;
+    /** Display label on the node */
+    label?: string;
+    /** Player ID who owns this node */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: string;
+}
+/** State of an edge connecting two nodes in a reducer-projected network board. */
+interface NetworkEdgeState {
+    /** Unique edge identifier */
+    id: string;
+    /** Source node ID */
+    from: SpaceId;
+    /** Target node ID */
+    to: SpaceId;
+    /** Edge type identifier for rendering */
+    typeId?: string;
+    /** Display label on the edge */
+    label?: string;
+    /** Player ID who owns this edge */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: string;
+}
+/** State of a piece placed on a reducer-projected network node. */
+interface NetworkPieceState {
+    /** Unique piece identifier */
+    id: PieceId;
+    /** Node ID where this piece is placed */
+    nodeId: SpaceId;
+    /** Piece type identifier for rendering */
+    typeId?: PieceTypeId;
+    /** Player ID who owns this piece */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: string;
+}
+/** Complete state of a reducer-projected network board. */
+interface NetworkBoardState {
+    /** Unique board identifier */
+    id: BoardId;
+    /** All nodes on the board */
+    nodes: NetworkNodeState[];
+    /** All edges on the board */
+    edges: NetworkEdgeState[];
+    /** All pieces on the board */
+    pieces: NetworkPieceState[];
+}
+/** State of a cell on a reducer-projected square grid board. */
+interface SquareCellState<SpaceIdValue extends string = SpaceId, Properties = Record<string, unknown>> {
+    /** Unique cell identifier */
+    id: SpaceIdValue;
+    /** Row index (0-based) */
+    row: number;
+    /** Column index (0-based) */
+    col: number;
+    /** Cell type identifier for rendering */
+    typeId?: SpaceTypeId;
+    /** Display label on the cell */
+    label?: string;
+    /** Player ID who owns this cell */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: Properties;
+}
+/** State of an edge on a reducer-projected square grid board. */
+interface SquareEdgeState<SpaceIdValue extends string = SpaceId, EdgeIdValue extends string = string, Properties = Record<string, unknown>> {
+    /** Unique edge identifier */
+    id: EdgeIdValue;
+    /** The cell IDs this edge borders */
+    spaceIds: readonly SpaceIdValue[];
+    /** Edge type identifier for rendering */
+    typeId?: EdgeTypeId;
+    /** Display label for setup or rendering */
+    label?: string;
+    /** Player ID who owns this edge */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: Properties;
+}
+/** State of a vertex on a reducer-projected square grid board. */
+interface SquareVertexState<SpaceIdValue extends string = SpaceId, VertexIdValue extends string = string, Properties = Record<string, unknown>> {
+    /** Unique vertex identifier */
+    id: VertexIdValue;
+    /** The cell IDs that touch this corner */
+    spaceIds: readonly SpaceIdValue[];
+    /** Vertex type identifier for rendering */
+    typeId?: VertexTypeId;
+    /** Display label for setup or rendering */
+    label?: string;
+    /** Player ID who owns this vertex */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: Properties;
+}
+/** State of a piece placed on a reducer-projected square grid cell. */
+interface SquarePieceState<PieceIdValue extends string = PieceId, Properties = Record<string, unknown>> {
+    /** Unique piece identifier */
+    id: PieceIdValue;
+    /** Row index where piece is located */
+    row: number;
+    /** Column index where piece is located */
+    col: number;
+    /** Piece type identifier for rendering */
+    typeId: PieceTypeId;
+    /** Player ID who owns this piece */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: Properties;
+}
+/** Complete state of a reducer-projected square grid board. */
+interface SquareBoardState<B extends string = BoardId, SpaceIdValue extends string = SpaceId, EdgeIdValue extends string = string, VertexIdValue extends string = string, PieceIdValue extends string = PieceId, CellProperties = Record<string, unknown>, EdgeProperties = Record<string, unknown>, VertexProperties = Record<string, unknown>, PieceProperties = Record<string, unknown>> {
+    /** Unique board identifier */
+    id: B;
+    /** Number of rows in the grid */
+    rows: number;
+    /** Number of columns in the grid */
+    cols: number;
+    /** All authored cells on the board */
+    cells: ReadonlyArray<SquareCellState<SpaceIdValue, CellProperties>>;
+    /** All edges on the board */
+    edges: ReadonlyArray<SquareEdgeState<SpaceIdValue, EdgeIdValue, EdgeProperties>>;
+    /** All vertices on the board */
+    vertices: ReadonlyArray<SquareVertexState<SpaceIdValue, VertexIdValue, VertexProperties>>;
+    /** All pieces on the board */
+    pieces: ReadonlyArray<SquarePieceState<PieceIdValue, PieceProperties>>;
+}
+/** State of a space on a reducer-projected track board. */
+interface TrackSpaceState {
+    /** Unique space identifier */
+    id: SpaceId;
+    /** Position index in the track sequence */
+    index: number;
+    /** X coordinate for rendering */
+    x: number;
+    /** Y coordinate for rendering */
+    y: number;
+    /** Display name of the space */
+    name?: string;
+    /** Space type identifier for rendering */
+    typeId?: SpaceTypeId;
+    /** Player ID who owns this space */
+    owner?: PlayerId;
+    /** IDs of spaces that can be reached from here (for branching tracks) */
+    nextSpaces?: SpaceId[];
+    /** JSON-serialized custom properties */
+    properties?: string;
+}
+/** State of a piece on a reducer-projected track board. */
+interface TrackPieceState {
+    /** Unique piece identifier */
+    id: PieceId;
+    /** ID of the space this piece occupies */
+    spaceId: SpaceId;
+    /** Player ID who owns this piece */
+    owner: PlayerId;
+    /** Piece type identifier for rendering */
+    typeId?: PieceTypeId;
+    /** JSON-serialized custom properties */
+    properties?: string;
+}
+/** Complete state of a reducer-projected track board. */
+interface TrackBoardState {
+    /** Unique board identifier */
+    id: BoardId;
+    /** All spaces on the track */
+    spaces: TrackSpaceState[];
+    /** All pieces on the track */
+    pieces: TrackPieceState[];
+}
+/** State of a reducer-projected die component. */
+interface DieState {
+    /** Unique die identifier */
+    id: DieId;
+    /** Number of sides on the die (e.g., 6 for standard die) */
+    sides: number;
+    /** Current face value (1 to sides, undefined if not rolled) */
+    currentValue?: number;
+    /** Optional color for visual identification */
+    color?: string;
+}
+/**
+ * Collection of boards of a particular kind, split into shared boards
+ * (indexed by base id, e.g. `"market-board"`) and per-player boards
+ * (indexed by base id, then by the runtime seat list via `PerPlayer<T>`).
+ *
+ * Splitting by the `BoardRef` discriminator keeps the UI types honest about
+ * what the runtime actually produced: per-player board state only exists
+ * for the seats that are currently playing, never for a static `maxPlayers`
+ * upper bound.
+ */
+interface BoardKindStates<State> {
+    /** Shared boards keyed by base id. */
+    shared: Record<BoardBaseId, State>;
+    /** Per-player boards keyed by base id, then by seat via `PerPlayer<T>`. */
+    perPlayer: Record<BoardBaseId, PerPlayer<State>>;
+}
+/**
+ * Container for all board states organized by kind.
+ * This is the strongly-typed board payload authored UIs consume from reducer views.
+ */
+interface BoardStates {
+    /** Hex boards split into shared vs per-player collections. */
+    hex: BoardKindStates<HexBoardState>;
+    /** Network boards split into shared vs per-player collections. */
+    network: BoardKindStates<NetworkBoardState>;
+    /** Square grid boards split into shared vs per-player collections. */
+    square: BoardKindStates<SquareBoardState>;
+    /** Track boards split into shared vs per-player collections. */
+    track: BoardKindStates<TrackBoardState>;
+}
+/**
+ * Container for all dice states.
+ * Maps die IDs to their die state.
+ */
+type DiceStates = Record<DieId, DieState>;
+interface GameState {
+    /** All currently active players (supports MULTIPLE_ACTIVE_PLAYER states) */
+    currentPlayerIds: PlayerId[];
+    decks: CardIdsByDeckId;
+    /**
+     * Player-scoped hands keyed by the authored hand id. The inner
+     * `PerPlayer<CardId[]>` is keyed by the runtime seat list and only
+     * contains entries for players who actually hold the hand.
+     */
+    hands: CardIdsByHandId;
+    /** Map of card IDs to their card info including type and properties */
+    cards: Record<CardId, ViewCard<CardId, string, CardProperties>>;
+    /**
+     * Per-player resource totals keyed by the runtime seat list. The inner
+     * record maps resource id → amount for that seat.
+     */
+    playerResources: PerPlayer<Record<string, number>>;
+    currentState: StateName;
+    isMyTurn: boolean;
+    boards: BoardStates;
+    dice: DiceStates;
+}
+
+export { type SquarePieceState as A, type BoardBaseId as B, type CardId as C, type DeckId as D, type EdgeTypeId as E, type SquareVertexState as F, type GameState as G, type HexBoardState as H, type TrackPieceState as I, type TrackSpaceState as J, hexColor as K, isHexColor as L, parseHexColor as M, type NetworkBoardState as N, type PerPlayer as P, type SharedBoardRef as S, type TrackBoardState as T, type VertexTypeId as V, type BoardId as a, type BoardKindStates as b, type BoardRef as c, type BoardStates as d, type CardIdsByDeckId as e, type CardProperties as f, type DiceStates as g, type DieId as h, type DieState as i, type HexColor as j, type HexEdgeState as k, type HexTileState as l, type HexVertexState as m, type NetworkEdgeState as n, type NetworkNodeState as o, type NetworkPieceState as p, type PerPlayerBoardRef as q, type PieceId as r, type PieceTypeId as s, type Player as t, type PlayerId as u, type SpaceId as v, type SpaceTypeId as w, type SquareBoardState as x, type SquareCellState as y, type SquareEdgeState as z };