@dreamboard-games/sdk 0.2.0

package/dist/index-BwqPQtBu.d.ts

@@ -0,0 +1,1433 @@
+/**
+ * Supported player-count metadata for the game
+ */
+type PlayersDefinition = {
+    minPlayers: number;
+    maxPlayers: number;
+    optimalPlayers?: number;
+};
+type PresetCardSetDefinition = {
+    /**
+     * Unique local identifier for the authored card set
+     */
+    id: string;
+    /**
+     * Built-in preset card-set selector
+     */
+    presetId: string;
+    /**
+     * Display name of the card set
+     */
+    name: string;
+    /**
+     * Type of card set source
+     */
+    type: 'preset';
+};
+/**
+ * Arbitrary authored JSON value.
+ */
+type JsonValue = string | number | boolean | null | Array<JsonValue> | {
+    [key: string]: JsonValue;
+};
+type PropertySchema = {
+    /**
+     * The data type of the property.
+     */
+    type: 'string' | 'integer' | 'number' | 'boolean' | 'zoneId' | 'cardId' | 'playerId' | 'boardId' | 'edgeId' | 'vertexId' | 'spaceId' | 'pieceId' | 'dieId' | 'resourceId' | 'array' | 'object' | 'record' | 'enum';
+    /**
+     * Optional description of the property's purpose and usage.
+     */
+    description?: string;
+    /**
+     * Whether an object property may be omitted.
+     */
+    optional?: boolean;
+    /**
+     * Whether the value may be null.
+     */
+    nullable?: boolean;
+    /**
+     * Optional authored default value for this property. When present, omitted
+     * seed values materialize to the default and generated TypeScript treats
+     * the property as present even if `optional: true` is also set.
+     *
+     */
+    default?: JsonValue;
+    /**
+     * For array types, the schema of the array items. Required if type is 'array'.
+     */
+    items?: PropertySchema;
+    /**
+     * For object types, the schema of the object's properties. Required if type is 'object'.
+     */
+    properties?: {
+        [key: string]: PropertySchema;
+    };
+    /**
+     * For enum types, the list of allowed string values. Required if type is 'enum'.
+     */
+    enums?: Array<string>;
+    /**
+     * For record types, the schema of the record's values. Required if type is 'record'.
+     */
+    values?: PropertySchema;
+};
+type ObjectSchema = {
+    /**
+     * Map of property names to their schemas. Type is always 'object' and all properties are required.
+     */
+    properties: {
+        [key: string]: PropertySchema;
+    };
+};
+type CardPropertySchemaVariants = {
+    /**
+     * Property schemas present on every card-type variant.
+     */
+    shared?: {
+        [key: string]: PropertySchema;
+    };
+    /**
+     * Property schema for each card type in this manual card set.
+     */
+    variants: {
+        [key: string]: ObjectSchema;
+    };
+};
+type CardPropertySchema = ObjectSchema | CardPropertySchemaVariants;
+type DetachedHomeSpec = {
+    type: 'detached';
+};
+type ZoneHomeSpec = {
+    type: 'zone';
+    zoneId: string;
+};
+type SpaceHomeSpec = {
+    type: 'space';
+    boardId: string;
+    spaceId: string;
+};
+type ContainerHomeSpec = {
+    type: 'container';
+    boardId: string;
+    containerId: string;
+};
+/**
+ * Tiled board edge identified by the spaces that border it
+ */
+type BoardEdgeRef = {
+    spaces: Array<string>;
+};
+type EdgeHomeSpec = {
+    type: 'edge';
+    boardId: string;
+    ref: BoardEdgeRef;
+};
+/**
+ * Tiled board vertex identified by the spaces that touch it
+ */
+type BoardVertexRef = {
+    spaces: Array<string>;
+};
+type VertexHomeSpec = {
+    type: 'vertex';
+    boardId: string;
+    ref: BoardVertexRef;
+};
+type PieceSlotHostRef = {
+    kind: 'piece';
+    id: string;
+};
+type DieSlotHostRef = {
+    kind: 'die';
+    id: string;
+};
+type SlotHostRef = ({
+    kind: 'piece';
+} & PieceSlotHostRef) | ({
+    kind: 'die';
+} & DieSlotHostRef);
+type SlotHomeSpec = {
+    type: 'slot';
+    host: SlotHostRef;
+    slotId: string;
+};
+type ComponentHomeSpec = ({
+    type: 'detached';
+} & DetachedHomeSpec) | ({
+    type: 'zone';
+} & ZoneHomeSpec) | ({
+    type: 'space';
+} & SpaceHomeSpec) | ({
+    type: 'container';
+} & ContainerHomeSpec) | ({
+    type: 'edge';
+} & EdgeHomeSpec) | ({
+    type: 'vertex';
+} & VertexHomeSpec) | ({
+    type: 'slot';
+} & SlotHomeSpec);
+/**
+ * Default authored visibility for a component instance
+ */
+type ComponentVisibilitySpec = {
+    faceUp?: boolean;
+    /**
+     * When omitted, visible to all players
+     */
+    visibleTo?: Array<string>;
+};
+type BoardCard = {
+    /**
+     * Card type identifier used to generate runtime CardIds. When count > 1, runtime IDs are generated as '{type}-1', '{type}-2', etc.
+     */
+    type: string;
+    /**
+     * Display name of the card
+     */
+    name: string;
+    /**
+     * URL to the card's image
+     */
+    imageUrl?: string;
+    /**
+     * Text content on the card
+     */
+    text?: string;
+    /**
+     * Number of copies of this card
+     */
+    count: number;
+    /**
+     * Optional authored card category or subtype identifier
+     */
+    cardType?: string;
+    /**
+     * Optional authored home for this card inventory. When omitted, cards start detached until reducer setup places them.
+     */
+    home?: ComponentHomeSpec;
+    /**
+     * Default authored visibility for the card inventory
+     */
+    visibility?: ComponentVisibilitySpec;
+    /**
+     * Actual property values for this specific card instance. Keys must match the properties defined in the referenced cardSchema.
+     */
+    properties: {
+        [key: string]: JsonValue;
+    };
+};
+type ManualCardSetDefinition = {
+    /**
+     * Unique identifier for the card set
+     */
+    id: string;
+    /**
+     * Display name of the card set
+     */
+    name: string;
+    /**
+     * Type of card set source
+     */
+    type: 'manual';
+    /**
+     * Schema definition for authored card properties in this card set
+     */
+    cardSchema: CardPropertySchema;
+    /**
+     * List of authored cards in this card set
+     */
+    cards: Array<BoardCard>;
+};
+type CardSetDefinition = ({
+    type: 'preset';
+} & PresetCardSetDefinition) | ({
+    type: 'manual';
+} & ManualCardSetDefinition);
+/**
+ * Whether authored topology exists once for the table or once per player
+ */
+type TopologyScope = 'shared' | 'perPlayer';
+/**
+ * Default topology visibility for a zone or slot
+ */
+type ZoneVisibility = 'ownerOnly' | 'public' | 'hidden';
+/**
+ * Generic authored container that can hold cards, pieces, or dice
+ */
+type ZoneSpec = {
+    /**
+     * Stable zone identifier
+     */
+    id: string;
+    /**
+     * Display name for the zone
+     */
+    name: string;
+    scope: TopologyScope;
+    /**
+     * Optional card-set restriction for this zone
+     */
+    allowedCardSetIds?: Array<string>;
+    visibility?: ZoneVisibility;
+};
+/**
+ * Stable authored board space or slot anchor
+ */
+type BoardSpaceSpec = {
+    /**
+     * Stable space identifier local to the board
+     */
+    id: string;
+    /**
+     * Human-readable space name
+     */
+    name?: string;
+    /**
+     * Optional authored space type identifier
+     */
+    typeId?: string;
+    /**
+     * Typed authored fields validated against the board's spaceFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Named relation between two authored spaces
+ */
+type BoardRelationSpec = {
+    /**
+     * Optional stable relation identifier
+     */
+    id?: string;
+    /**
+     * Relation type identifier such as adjacent, covers, blocks, or linked
+     */
+    typeId: string;
+    fromSpaceId: string;
+    toSpaceId: string;
+    directed?: boolean;
+    /**
+     * Typed authored relation fields validated against relationFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+type BoardHostSpec = {
+    type: 'board';
+};
+type SpaceHostSpec = {
+    type: 'space';
+    spaceId: string;
+};
+type BoardContainerHostSpec = ({
+    type: 'board';
+} & BoardHostSpec) | ({
+    type: 'space';
+} & SpaceHostSpec);
+/**
+ * Authored board-attached or space-attached container/slot
+ */
+type BoardContainerSpec = {
+    /**
+     * Stable container identifier local to the board
+     */
+    id: string;
+    /**
+     * Display name for the container
+     */
+    name: string;
+    host: BoardContainerHostSpec;
+    allowedCardSetIds?: Array<string>;
+    /**
+     * Typed authored container fields validated against containerFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Reusable authored board topology template
+ */
+type GenericBoardTemplateSpec = {
+    /**
+     * Stable template identifier
+     */
+    id: string;
+    name: string;
+    layout: 'generic';
+    /**
+     * Optional authored board type identifier such as track, map, tableau, or grid
+     */
+    typeId?: string;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    relationFieldsSchema?: ObjectSchema;
+    containerFieldsSchema?: ObjectSchema;
+    spaces?: Array<BoardSpaceSpec>;
+    relations?: Array<BoardRelationSpec>;
+    containers?: Array<BoardContainerSpec>;
+};
+/**
+ * Visual orientation for authored hex coordinates
+ */
+type HexOrientation = 'pointy-top' | 'flat-top';
+/**
+ * One authored hex space in axial coordinates
+ */
+type HexSpaceSpec = {
+    /**
+     * Stable space identifier local to the board
+     */
+    id: string;
+    /**
+     * Axial q coordinate
+     */
+    q: number;
+    /**
+     * Axial r coordinate
+     */
+    r: number;
+    /**
+     * Optional authored space type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional hex-space label for setup or rendering
+     */
+    label?: string;
+    /**
+     * Typed authored fields validated against the board's spaceFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Hex edge identified by two adjacent hex spaces
+ */
+type HexEdgeRef = {
+    spaces: [
+        string,
+        string
+    ];
+};
+/**
+ * Authored metadata attached to one derived hex edge
+ */
+type HexEdgeSpec = {
+    ref: HexEdgeRef;
+    /**
+     * Optional authored edge type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional edge label for setup or rendering
+     */
+    label?: string;
+    tags?: Array<string>;
+    /**
+     * Typed authored edge fields validated against edgeFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Hex vertex identified by three touching hex spaces
+ */
+type HexVertexRef = {
+    spaces: [
+        string,
+        string,
+        string
+    ];
+};
+/**
+ * Authored metadata attached to one derived hex vertex
+ */
+type HexVertexSpec = {
+    ref: HexVertexRef;
+    /**
+     * Optional authored vertex type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional vertex label for setup or rendering
+     */
+    label?: string;
+    tags?: Array<string>;
+    /**
+     * Typed authored vertex fields validated against vertexFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Reusable authored hex board topology template
+ */
+type HexBoardTemplateSpec = {
+    /**
+     * Stable template identifier
+     */
+    id: string;
+    name: string;
+    layout: 'hex';
+    /**
+     * Optional authored board type identifier
+     */
+    typeId?: string;
+    orientation?: HexOrientation;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    edgeFieldsSchema?: ObjectSchema;
+    vertexFieldsSchema?: ObjectSchema;
+    spaces?: Array<HexSpaceSpec>;
+    edges?: Array<HexEdgeSpec>;
+    vertices?: Array<HexVertexSpec>;
+};
+/**
+ * One authored square space in row/column coordinates
+ */
+type SquareSpaceSpec = {
+    /**
+     * Stable space identifier local to the board
+     */
+    id: string;
+    /**
+     * Zero-based row coordinate
+     */
+    row: number;
+    /**
+     * Zero-based column coordinate
+     */
+    col: number;
+    /**
+     * Optional authored space type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional square-space label for setup or rendering
+     */
+    label?: string;
+    /**
+     * Typed authored fields validated against the board's spaceFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Authored metadata attached to one derived square edge
+ */
+type SquareEdgeSpec = {
+    ref: BoardEdgeRef;
+    /**
+     * Optional authored edge type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional edge label for setup or rendering
+     */
+    label?: string;
+    tags?: Array<string>;
+    /**
+     * Typed authored edge fields validated against edgeFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Authored metadata attached to one derived square vertex
+ */
+type SquareVertexSpec = {
+    ref: BoardVertexRef;
+    /**
+     * Optional authored vertex type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional vertex label for setup or rendering
+     */
+    label?: string;
+    tags?: Array<string>;
+    /**
+     * Typed authored vertex fields validated against vertexFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Reusable authored square board topology template
+ */
+type SquareBoardTemplateSpec = {
+    /**
+     * Stable template identifier
+     */
+    id: string;
+    name: string;
+    layout: 'square';
+    /**
+     * Optional authored board type identifier
+     */
+    typeId?: string;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    relationFieldsSchema?: ObjectSchema;
+    containerFieldsSchema?: ObjectSchema;
+    edgeFieldsSchema?: ObjectSchema;
+    vertexFieldsSchema?: ObjectSchema;
+    spaces?: Array<SquareSpaceSpec>;
+    relations?: Array<BoardRelationSpec>;
+    containers?: Array<BoardContainerSpec>;
+    edges?: Array<SquareEdgeSpec>;
+    vertices?: Array<SquareVertexSpec>;
+};
+type BoardTemplateSpec = ({
+    layout: 'generic';
+} & GenericBoardTemplateSpec) | ({
+    layout: 'hex';
+} & HexBoardTemplateSpec) | ({
+    layout: 'square';
+} & SquareBoardTemplateSpec);
+/**
+ * Shared or per-player authored board instance shell
+ */
+type GenericBoardSpec = {
+    /**
+     * Stable board identifier
+     */
+    id: string;
+    name: string;
+    layout: 'generic';
+    /**
+     * Optional authored board type identifier such as track, map, tableau, or grid
+     */
+    typeId?: string;
+    scope: TopologyScope;
+    /**
+     * Optional board template to clone before applying inline authored additions
+     */
+    templateId?: string;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    relationFieldsSchema?: ObjectSchema;
+    containerFieldsSchema?: ObjectSchema;
+    /**
+     * Typed authored board fields validated against boardFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+    spaces?: Array<BoardSpaceSpec>;
+    relations?: Array<BoardRelationSpec>;
+    containers?: Array<BoardContainerSpec>;
+};
+/**
+ * Shared or per-player authored hex board instance shell
+ */
+type HexBoardSpec = {
+    /**
+     * Stable board identifier
+     */
+    id: string;
+    name: string;
+    layout: 'hex';
+    /**
+     * Optional authored board type identifier
+     */
+    typeId?: string;
+    scope: TopologyScope;
+    /**
+     * Optional hex board template to clone before applying inline authored additions
+     */
+    templateId?: string;
+    orientation?: HexOrientation;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    edgeFieldsSchema?: ObjectSchema;
+    vertexFieldsSchema?: ObjectSchema;
+    /**
+     * Typed authored board fields validated against boardFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+    spaces?: Array<HexSpaceSpec>;
+    edges?: Array<HexEdgeSpec>;
+    vertices?: Array<HexVertexSpec>;
+};
+/**
+ * Shared or per-player authored square board instance shell
+ */
+type SquareBoardSpec = {
+    /**
+     * Stable board identifier
+     */
+    id: string;
+    name: string;
+    layout: 'square';
+    /**
+     * Optional authored board type identifier
+     */
+    typeId?: string;
+    scope: TopologyScope;
+    /**
+     * Optional square board template to clone before applying inline authored additions
+     */
+    templateId?: string;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    relationFieldsSchema?: ObjectSchema;
+    containerFieldsSchema?: ObjectSchema;
+    edgeFieldsSchema?: ObjectSchema;
+    vertexFieldsSchema?: ObjectSchema;
+    /**
+     * Typed authored board fields validated against boardFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+    spaces?: Array<SquareSpaceSpec>;
+    relations?: Array<BoardRelationSpec>;
+    containers?: Array<BoardContainerSpec>;
+    edges?: Array<SquareEdgeSpec>;
+    vertices?: Array<SquareVertexSpec>;
+};
+type BoardSpec = ({
+    layout: 'generic';
+} & GenericBoardSpec) | ({
+    layout: 'hex';
+} & HexBoardSpec) | ({
+    layout: 'square';
+} & SquareBoardSpec);
+/**
+ * Named authored slot exposed by a piece or die type
+ */
+type ComponentSlotSpec = {
+    id: string;
+    name?: string;
+};
+/**
+ * Reusable authored piece type
+ */
+type PieceTypeSpec = {
+    id: string;
+    name: string;
+    fieldsSchema?: ObjectSchema;
+    slots?: Array<ComponentSlotSpec>;
+};
+/**
+ * Authored seeded piece inventory or supply definition
+ */
+type PieceSeedSpec = {
+    /**
+     * Stable piece id seed. When count > 1, runtime ids are generated as '{id}-1', '{id}-2', etc.
+     */
+    id?: string;
+    name?: string;
+    typeId: string;
+    count?: number;
+    ownerId?: string;
+    home?: ComponentHomeSpec;
+    visibility?: ComponentVisibilitySpec;
+    /**
+     * Typed authored piece fields validated against the piece type schema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Reusable authored die type
+ */
+type DieTypeSpec$1 = {
+    id: string;
+    name: string;
+    sides?: number;
+    fieldsSchema?: ObjectSchema;
+    slots?: Array<ComponentSlotSpec>;
+};
+/**
+ * Authored seeded die inventory or supply definition
+ */
+type DieSeedSpec = {
+    /**
+     * Stable die id seed. When count > 1, runtime ids are generated as '{id}-1', '{id}-2', etc.
+     */
+    id?: string;
+    name?: string;
+    typeId: string;
+    count?: number;
+    ownerId?: string;
+    home?: ComponentHomeSpec;
+    visibility?: ComponentVisibilitySpec;
+    /**
+     * Typed authored die fields validated against the die type schema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Definition of a game resource type
+ */
+type ResourceDefinition = {
+    /**
+     * Unique identifier for the resource. Used as a typed ResourceId.
+     */
+    id: string;
+    /**
+     * Human-readable display name for the resource
+     */
+    name: string;
+    /**
+     * Optional compact icon or emoji rendered by generic UI resource controls.
+     */
+    icon?: string;
+};
+/**
+ * One authored setup option choice
+ */
+type SetupOptionChoiceSpec = {
+    id: string;
+    label: string;
+    description?: string;
+};
+/**
+ * Authored setup module/variant axis metadata
+ */
+type SetupOptionSpec = {
+    id: string;
+    name: string;
+    description?: string;
+    choices?: Array<SetupOptionChoiceSpec>;
+};
+/**
+ * Reducer-consumed authored setup profile, recipe, or loadout metadata
+ */
+type SetupProfileSpec = {
+    id: string;
+    name: string;
+    description?: string;
+    /**
+     * Selected setup-option values for this profile
+     */
+    optionValues?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Authoritative topology manifest for reducer-native games
+ */
+type GameTopologyManifest$1 = {
+    players: PlayersDefinition;
+    /**
+     * Authored card catalogs and schemas
+     */
+    cardSets: Array<CardSetDefinition>;
+    /**
+     * Shared and per-player authored containers
+     */
+    zones?: Array<ZoneSpec>;
+    /**
+     * Reusable board topology templates
+     */
+    boardTemplates?: Array<BoardTemplateSpec>;
+    /**
+     * Shared and per-player authored board shells
+     */
+    boards?: Array<BoardSpec>;
+    pieceTypes?: Array<PieceTypeSpec>;
+    pieceSeeds?: Array<PieceSeedSpec>;
+    dieTypes?: Array<DieTypeSpec$1>;
+    dieSeeds?: Array<DieSeedSpec>;
+    resources?: Array<ResourceDefinition>;
+    /**
+     * Authored setup-option metadata consumed by reducer-owned setup flows
+     */
+    setupOptions?: Array<SetupOptionSpec>;
+    /**
+     * Authored setup recipes, loadouts, or module profiles consumed by reducer setup code
+     */
+    setupProfiles?: Array<SetupProfileSpec>;
+};
+/**
+ * Authenticated user acting in a session.
+ */
+type SessionActorAuthUser = {
+    kind: 'AUTH_USER';
+    /**
+     * Internal user id
+     */
+    id: string;
+};
+/**
+ * Anonymous demo principal for one demo_sessions row (shared across tabs).
+ */
+type SessionActorDemoGuest = {
+    kind: 'DEMO_GUEST';
+    /**
+     * demo_sessions.id
+     */
+    demoActorSessionId: string;
+};
+type SessionActor = ({
+    kind: 'AUTH_USER';
+} & SessionActorAuthUser) | ({
+    kind: 'DEMO_GUEST';
+} & SessionActorDemoGuest);
+type SessionGameSourceUserCompiled = {
+    kind: 'USER_COMPILED';
+    ownerUserId: string;
+    gameId: string;
+    compiledResultId: string;
+};
+type SessionGameSourceDemoRevision = {
+    kind: 'DEMO_REVISION';
+    slug: string;
+    revisionId: string;
+};
+type SessionGameSource = ({
+    kind: 'USER_COMPILED';
+} & SessionGameSourceUserCompiled) | ({
+    kind: 'DEMO_REVISION';
+} & SessionGameSourceDemoRevision);
+type SessionSnapshotPhase = 'lobby' | 'gameplay' | 'ended';
+type HostSessionStatus = 'active' | 'ended';
+/**
+ * Summary of a game state history entry.
+ */
+type HistoryEntrySummary = {
+    id: string;
+    generation: number;
+    version: number;
+    timestamp: string;
+    description: string;
+    playerId?: string;
+    actionType?: string;
+    isCurrent: boolean;
+};
+type SessionSnapshotHistory = {
+    entries: Array<HistoryEntrySummary>;
+    currentIndex: number;
+    canGoBack: boolean;
+    canGoForward: boolean;
+};
+type HostSessionContext = {
+    /**
+     * Unique identifier for the session.
+     */
+    sessionId: string;
+    /**
+     * Memorable short code for sharing.
+     */
+    shortCode: string;
+    phase: SessionSnapshotPhase;
+    status: HostSessionStatus;
+    hostActor: SessionActor;
+    gameSource: SessionGameSource;
+    /**
+     * Selected authored setup profile for this session.
+     */
+    setupProfileId?: string;
+    /**
+     * Player IDs the authenticated session actor may select.
+     */
+    switchablePlayerIds: Array<string>;
+    history?: SessionSnapshotHistory;
+};
+type SeatAssignment = {
+    /**
+     * Player identifier (e.g., 'player-1')
+     */
+    playerId: string;
+    /**
+     * Session actor controlling this seat (null if empty)
+     */
+    controllerActor?: SessionActor;
+    /**
+     * Display name for this seat/player
+     */
+    displayName: string;
+    /**
+     * Hex color code for the player (e.g., '#FF5733')
+     */
+    playerColor?: string;
+    /**
+     * Whether this seat is the host
+     */
+    isHost?: boolean;
+};
+type HostLobbyView = {
+    /**
+     * Current public seat assignments for the session.
+     */
+    seats: Array<SeatAssignment>;
+    /**
+     * Whether the lobby can currently be started.
+     */
+    canStart: boolean;
+    /**
+     * Session actor that hosts this session.
+     */
+    hostActor: SessionActor;
+    /**
+     * Selected authored setup profile for this session.
+     */
+    setupProfileId?: string;
+};
+type HostLobbySessionSnapshot = {
+    type: 'lobby';
+    context: HostSessionContext;
+    lobby: HostLobbyView;
+};
+type SimultaneousPhaseSnapshot = {
+    phaseName: string;
+    interactionId: string;
+    actorIds: Array<string>;
+    sealedPlayerIds: Array<string>;
+    pendingPlayerIds: Array<string>;
+};
+type HostGameplaySharedView = {
+    /**
+     * Player IDs currently active in the game state.
+     */
+    activePlayers: Array<string>;
+    /**
+     * Current reducer-native gameplay phase.
+     */
+    currentPhase: string;
+    /**
+     * Current stage within the phase. Null when the phase has no active stage.
+     */
+    currentStage: string | null;
+    /**
+     * Player IDs this stage currently admits.
+     */
+    stageSeats: Array<string>;
+    /**
+     * Visibility-safe progress metadata for an active simultaneous-player phase.
+     */
+    simultaneousPhase?: SimultaneousPhaseSnapshot | null;
+    /**
+     * JSON-serialized session-scoped static view. Populated on gameplay bootstrap payloads only.
+     */
+    boardStatic?: string | null;
+    /**
+     * Content hash of the session-scoped static view held on the host.
+     */
+    boardStaticHash?: string | null;
+};
+/**
+ * Draft commit policy consumed by default UI surfaces.
+ */
+type InteractionCommitPolicy = {
+    mode: 'manual' | 'autoWhenReady';
+};
+/**
+ * Single-value input selection.
+ */
+type SingleInputSelection = {
+    mode: 'single';
+};
+/**
+ * Multi-value input selection.
+ */
+type ManyInputSelection = {
+    mode: 'many';
+    min: number;
+    max?: number;
+    distinct?: boolean;
+};
+type InputSelection = ({
+    mode: 'single';
+} & SingleInputSelection) | ({
+    mode: 'many';
+} & ManyInputSelection);
+type InputDomain = ({
+    type: 'cardTarget';
+} & CardTargetDomain) | ({
+    type: 'boardTarget';
+} & BoardTargetDomain) | ({
+    type: 'resourceMap';
+} & ResourceMapDomain) | ({
+    type: 'boundedNumber';
+} & BoundedNumberDomain) | ({
+    type: 'choice';
+} & ChoiceDomain) | ({
+    type: 'choiceList';
+} & ChoiceListDomain);
+type InputDomainDependencyCase = {
+    when: {
+        [key: string]: string;
+    };
+    domain: InputDomain;
+};
+type EagerInputDomainDependencies = {
+    mode: 'eager';
+    dependentCases: Array<InputDomainDependencyCase>;
+};
+type ResolvedCardTargetDomain = {
+    type: 'cardTarget';
+    projection: 'resolved';
+    targetKind: 'card';
+    zoneIds: Array<string>;
+    eligibleTargets: Array<string>;
+    selection?: InputSelection;
+    dependencies?: EagerInputDomainDependencies;
+};
+type InputDomainResolver = {
+    interactionKey?: string;
+    inputKey: string;
+};
+type LazyInputDomainDependencies = {
+    mode: 'lazy';
+    dependsOn: Array<string>;
+    resolver: InputDomainResolver;
+};
+type LazyCardTargetDomain = {
+    type: 'cardTarget';
+    projection: 'lazy';
+    targetKind: 'card';
+    zoneIds: Array<string>;
+    selection?: InputSelection;
+    dependencies: LazyInputDomainDependencies;
+};
+type CardTargetDomain = ({
+    projection: 'resolved';
+} & ResolvedCardTargetDomain) | ({
+    projection: 'lazy';
+} & LazyCardTargetDomain);
+type ResolvedBoardTargetDomain = {
+    type: 'boardTarget';
+    projection: 'resolved';
+    targetKind: 'edge' | 'vertex' | 'space' | 'tile';
+    boardId: string;
+    valueKind?: 'board-id' | 'player-board-space';
+    eligibleTargets: Array<string>;
+    selection?: InputSelection;
+    dependencies?: EagerInputDomainDependencies;
+};
+type LazyBoardTargetDomain = {
+    type: 'boardTarget';
+    projection: 'lazy';
+    targetKind: 'edge' | 'vertex' | 'space' | 'tile';
+    boardId: string;
+    valueKind?: 'board-id' | 'player-board-space';
+    selection?: InputSelection;
+    dependencies: LazyInputDomainDependencies;
+};
+type BoardTargetDomain = ({
+    projection: 'resolved';
+} & ResolvedBoardTargetDomain) | ({
+    projection: 'lazy';
+} & LazyBoardTargetDomain);
+type ResourceMapDomainEntry = {
+    resourceId: string;
+    label?: string;
+    icon?: string;
+    min: number;
+    max: number;
+};
+type ResourceMapDomain = {
+    type: 'resourceMap';
+    resources: Array<ResourceMapDomainEntry>;
+    selection?: InputSelection;
+};
+type BoundedNumberDomain = {
+    type: 'boundedNumber';
+    min: number;
+    max: number;
+    step?: number;
+    selection?: InputSelection;
+};
+type ChoiceDomainOption = {
+    value: string | null;
+    label: string;
+    icon?: string;
+    badge?: string;
+    description?: string;
+    disabled?: boolean;
+    disabledReason?: string;
+};
+type ChoiceDomain = {
+    type: 'choice';
+    choices: Array<ChoiceDomainOption>;
+    selection?: InputSelection;
+    dependencies?: EagerInputDomainDependencies;
+};
+type ChoiceListDomain = {
+    type: 'choiceList';
+    choices: Array<ChoiceDomainOption>;
+    min?: number;
+    max?: number;
+    selection?: InputSelection;
+    dependencies?: EagerInputDomainDependencies;
+};
+/**
+ * Canonical descriptor for one interaction input collector.
+ */
+type InteractionInputDescriptor = {
+    key: string;
+    kind: string;
+    domain: InputDomain;
+    /**
+     * Optional default value applied to this input when the player has not
+     * yet drafted a value. Mirrors the input collector's `defaultValue`
+     * from the authored interaction, so plugins can render a sensible
+     * starting state (e.g. a pre-selected resource for a bank trade).
+     *
+     */
+    defaultValue?: JsonValue;
+};
+type AvailableInteractionAvailability = {
+    status: 'available';
+};
+type NotYourTurnInteractionAvailability = {
+    status: 'notYourTurn';
+    reason: string;
+};
+type InsufficientResourcesInteractionAvailability = {
+    status: 'insufficientResources';
+    reason: string;
+    /**
+     * Resource shortfall by resource id when a costed interaction is not currently affordable.
+     */
+    missingResources: {
+        [key: string]: number;
+    };
+};
+type BlockedInteractionAvailability = {
+    status: 'blocked';
+    reason: string;
+    code?: string;
+};
+type InteractionAvailability = ({
+    status: 'available';
+} & AvailableInteractionAvailability) | ({
+    status: 'notYourTurn';
+} & NotYourTurnInteractionAvailability) | ({
+    status: 'insufficientResources';
+} & InsufficientResourcesInteractionAvailability) | ({
+    status: 'blocked';
+} & BlockedInteractionAvailability);
+/**
+ * Authoritative interaction descriptor resolved by the trusted bundle.
+ */
+type InteractionDescriptorBase = {
+    phaseName: string;
+    interactionKey: string;
+    interactionId: string;
+    zoneId?: string;
+    /**
+     * Draft commit policy materialized by the trusted reducer bundle. Omitted authoring specs default to manual before this descriptor crosses the runtime boundary.
+     */
+    commit: InteractionCommitPolicy;
+    /**
+     * Ordered input descriptors. Each entry is the canonical source for its collector key, collector kind, and valid-value domain.
+     */
+    inputs: Array<InteractionInputDescriptor>;
+    cost?: {
+        [key: string]: JsonValue;
+    };
+    currentResources?: {
+        [key: string]: JsonValue;
+    };
+    availability: InteractionAvailability;
+};
+type ActionInteractionDescriptor = InteractionDescriptorBase & {
+    kind: 'action';
+};
+type InteractionContextOption = {
+    id: string;
+    label: string;
+};
+type InteractionContext = {
+    to: string;
+    title?: string;
+    payload?: {
+        [key: string]: JsonValue;
+    };
+    options?: Array<InteractionContextOption>;
+};
+type PromptInteractionDescriptor = InteractionDescriptorBase & {
+    kind: 'prompt';
+    context: InteractionContext;
+};
+type InteractionDescriptor = ({
+    kind: 'action';
+} & ActionInteractionDescriptor) | ({
+    kind: 'prompt';
+} & PromptInteractionDescriptor);
+type ZoneHandles = {
+    cardIds: Array<string>;
+    cardViewsById: {
+        [key: string]: string;
+    };
+    playableByCardId: {
+        [key: string]: Array<string>;
+    };
+};
+type HostGameplaySeatView = {
+    /**
+     * Opaque revision token for this seat's available descriptors and input domains.
+     */
+    actionSetVersion: string;
+    /**
+     * JSON-serialized reducer-projected UI view for this player.
+     */
+    view: string | null;
+    /**
+     * Descriptor refs for interactions available to this player.
+     */
+    availableInteractionRefs: Array<string>;
+    /**
+     * Zone handles for this player, keyed by zone id.
+     */
+    zones: {
+        [key: string]: ZoneHandles;
+    };
+};
+type HostPlayerGameplayView = {
+    /**
+     * Monotonic gameplay version for stale-client detection.
+     */
+    version: number;
+    /**
+     * Opaque revision token for the returned descriptors and input domains.
+     */
+    actionSetVersion: string;
+    /**
+     * Player ID currently selected for rendering and input.
+     */
+    perspectivePlayerId: string;
+    /**
+     * Player IDs included in this normalized projection envelope.
+     */
+    controllablePlayerIds: Array<string>;
+    shared: HostGameplaySharedView;
+    /**
+     * Deduplicated interaction descriptor registry keyed by stable descriptor ref.
+     */
+    interactionsByRef: {
+        [key: string]: InteractionDescriptor;
+    };
+    /**
+     * Player-scoped projections keyed by authorized player id.
+     */
+    seats: {
+        [key: string]: HostGameplaySeatView;
+    };
+};
+type HostGameplaySessionSnapshot = {
+    type: 'gameplay';
+    context: HostSessionContext;
+    lobby: HostLobbyView;
+    gameplay: HostPlayerGameplayView;
+};
+type HostEndedSessionSnapshot = {
+    type: 'ended';
+    context: HostSessionContext;
+    lobby: HostLobbyView;
+};
+type HostSessionSnapshot = ({
+    type: 'lobby';
+} & HostLobbySessionSnapshot) | ({
+    type: 'gameplay';
+} & HostGameplaySessionSnapshot) | ({
+    type: 'ended';
+} & HostEndedSessionSnapshot);
+type HostSessionEventCausation = {
+    clientActionId?: string;
+};
+type HostSessionGameplayUpdatedEvent = {
+    type: 'session.gameplayUpdated';
+    context: HostSessionContext;
+    gameplay: HostPlayerGameplayView;
+    causation?: HostSessionEventCausation;
+};
+type HostActionSubmitResponse = {
+    success: boolean;
+    version: number;
+    actionSetVersion: string;
+    accepted?: boolean;
+    durabilityStatus?: 'COMMITTED';
+    errorCode?: string;
+    message?: string;
+    clientActionId?: string;
+    update?: HostSessionGameplayUpdatedEvent;
+};
+/**
+ * Type of parameter accepted by a runtime action
+ */
+type ParameterType = 'cardId' | 'cardType' | 'playerId' | 'string' | 'number' | 'boolean' | 'zoneId' | 'pieceId' | 'dieId' | 'boardId' | 'edgeId' | 'vertexId' | 'spaceId' | 'resourceId';
+/**
+ * Defines a parameter for an action
+ */
+type ActionParameterDefinition = {
+    name: string;
+    type: ParameterType;
+    required?: boolean;
+    array?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    /**
+     * Optional card set ID to specify which card set a CARD_ID parameter refers to
+     */
+    cardSetId?: string;
+    description?: string;
+};
+/**
+ * Defines an available player action with metadata and parameter definitions
+ */
+type ActionDefinition = {
+    /**
+     * Unique action identifier
+     */
+    actionType: string;
+    /**
+     * UI display name for this action
+     */
+    displayName: string;
+    /**
+     * Optional help text describing the action
+     */
+    description?: string;
+    /**
+     * List of parameters this action accepts
+     */
+    parameters: Array<ActionParameterDefinition>;
+    /**
+     * List of possible validation error codes
+     */
+    errorCodes?: Array<string>;
+};
+/**
+ * Type of source for the card set
+ */
+type CardSetSourceType = 'preset' | 'csv' | 'manual';
+/**
+ * Engine-level structural board layout discriminator
+ */
+type BoardLayout = 'generic' | 'hex' | 'square';
+/**
+ * Unique identifier for the player (e.g., 'player-1')
+ */
+type PlayerId = string;
+
+type DieTypeSpec = Omit<DieTypeSpec$1, "sides"> & {
+    sides?: DieTypeSpec$1["sides"];
+};
+type GameTopologyManifest = Omit<GameTopologyManifest$1, "dieTypes"> & {
+    dieTypes?: Array<DieTypeSpec>;
+};
+
+export type { HostGameplaySessionSnapshot as $, ActionDefinition as A, BlockedInteractionAvailability as B, CardPropertySchema as C, ContainerHomeSpec as D, DetachedHomeSpec as E, DieSeedSpec as F, DieSlotHostRef as G, DieTypeSpec$1 as H, DieTypeSpec as I, EagerInputDomainDependencies as J, EdgeHomeSpec as K, GameTopologyManifest as L, GameTopologyManifest$1 as M, GenericBoardSpec as N, GenericBoardTemplateSpec as O, HexBoardSpec as P, HexBoardTemplateSpec as Q, HexEdgeRef as R, HexEdgeSpec as S, HexOrientation as T, HexSpaceSpec as U, HexVertexRef as V, HexVertexSpec as W, HistoryEntrySummary as X, HostActionSubmitResponse as Y, HostEndedSessionSnapshot as Z, HostGameplaySeatView as _, ActionInteractionDescriptor as a, SquareEdgeSpec as a$, HostGameplaySharedView as a0, HostLobbySessionSnapshot as a1, HostLobbyView as a2, HostPlayerGameplayView as a3, HostSessionContext as a4, HostSessionEventCausation as a5, HostSessionGameplayUpdatedEvent as a6, HostSessionSnapshot as a7, HostSessionStatus as a8, InputDomain as a9, PromptInteractionDescriptor as aA, PropertySchema as aB, ResolvedBoardTargetDomain as aC, ResolvedCardTargetDomain as aD, ResourceDefinition as aE, ResourceMapDomain as aF, ResourceMapDomainEntry as aG, SeatAssignment as aH, SessionActor as aI, SessionActorAuthUser as aJ, SessionActorDemoGuest as aK, SessionGameSource as aL, SessionGameSourceDemoRevision as aM, SessionGameSourceUserCompiled as aN, SessionSnapshotHistory as aO, SessionSnapshotPhase as aP, SetupOptionChoiceSpec as aQ, SetupOptionSpec as aR, SetupProfileSpec as aS, SimultaneousPhaseSnapshot as aT, SingleInputSelection as aU, SlotHomeSpec as aV, SlotHostRef as aW, SpaceHomeSpec as aX, SpaceHostSpec as aY, SquareBoardSpec as aZ, SquareBoardTemplateSpec as a_, InputDomainDependencyCase as aa, InputDomainResolver as ab, InputSelection as ac, InsufficientResourcesInteractionAvailability as ad, InteractionAvailability as ae, InteractionCommitPolicy as af, InteractionContext as ag, InteractionContextOption as ah, InteractionDescriptor as ai, InteractionDescriptorBase as aj, InteractionInputDescriptor as ak, JsonValue as al, LazyBoardTargetDomain as am, LazyCardTargetDomain as an, LazyInputDomainDependencies as ao, ManualCardSetDefinition as ap, ManyInputSelection as aq, NotYourTurnInteractionAvailability as ar, ObjectSchema as as, ParameterType as at, PieceSeedSpec as au, PieceSlotHostRef as av, PieceTypeSpec as aw, PlayerId as ax, PlayersDefinition as ay, PresetCardSetDefinition as az, ActionParameterDefinition as b, SquareSpaceSpec as b0, SquareVertexSpec as b1, TopologyScope as b2, VertexHomeSpec as b3, ZoneHandles as b4, ZoneHomeSpec as b5, ZoneSpec as b6, ZoneVisibility as b7, AvailableInteractionAvailability as c, BoardCard as d, BoardContainerHostSpec as e, BoardContainerSpec as f, BoardEdgeRef as g, BoardHostSpec as h, BoardLayout as i, BoardRelationSpec as j, BoardSpaceSpec as k, BoardSpec as l, BoardTargetDomain as m, BoardTemplateSpec as n, BoardVertexRef as o, BoundedNumberDomain as p, CardPropertySchemaVariants as q, CardSetDefinition as r, CardSetSourceType as s, CardTargetDomain as t, ChoiceDomain as u, ChoiceDomainOption as v, ChoiceListDomain as w, ComponentHomeSpec as x, ComponentSlotSpec as y, ComponentVisibilitySpec as z };