@dreamboard-games/ui-sdk 0.0.43 → 0.0.46

package/dist/ui-sdk.d.ts

@@ -1,268 +1,16 @@
-import { PlayerId as PlayerId$1, BoardId, SpaceId, SpaceTypeId, EdgeTypeId, VertexTypeId, PieceId, PieceTypeId, BoardBaseId, PerPlayer, DieId, CardIdsByDeckId, CardId, CardProperties, ResourceId } from '@dreamboard/manifest-contract';
-export { BoardRef, PerPlayer, PerPlayerBoardRef, SharedBoardRef } from '@dreamboard/manifest-contract';
-import { GameView, PhaseName } from '@dreamboard/ui-contract';
 import * as React$1 from 'react';
 import React__default, { ReactNode, CSSProperties, AriaAttributes, HTMLAttributes, JSX, ReactElement, ButtonHTMLAttributes, InputHTMLAttributes, RefObject, Component, ErrorInfo, ComponentType, ComponentProps } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
+import { BoardId, SpaceId, SpaceTypeId, PlayerId, EdgeTypeId, VertexTypeId, PieceId, PieceTypeId, BoardBaseId, DieId, CardIdsByDeckId, CardId, CardProperties, ResourceId } from '@dreamboard/manifest-contract';
 import { HTMLMotionProps } from 'framer-motion';
 
-declare function useActivePlayers(): readonly PlayerId$1[];
-
-type ActionName = string;
-interface SeatAssignment {
-    playerId: PlayerId$1;
-    controllerUserId?: string;
-    displayName: string;
-    playerColor?: string;
-    isHost?: boolean;
-}
-interface HistoryEntrySummary {
-    id: string;
-    version: number;
-    timestamp: string;
-    description: string;
-    playerId?: PlayerId$1;
-    actionType?: ActionName;
-    isCurrent: boolean;
-}
-
-interface LobbyState {
-    
-    seats: SeatAssignment[];
-    
-    canStart: boolean;
-    
-    hostUserId: string;
-}
-
-type NotificationType = "YOUR_TURN" | "PROMPT_OPENED" | "ACTION_EXECUTED" | "ACTION_REJECTED" | "TURN_CHANGED" | "STATE_CHANGED" | "GAME_ENDED" | "ERROR";
-
-interface YourTurnPayload {
-    type: "YOUR_TURN";
-    activePlayers: PlayerId$1[];
-}
-
-interface PromptOpenedPayload {
-    type: "PROMPT_OPENED";
-    promptId: string;
-    promptInstanceId: string;
-    targetPlayer: PlayerId$1;
-    title?: string;
-}
-
-interface ActionExecutedPayload {
-    type: "ACTION_EXECUTED";
-    playerId: PlayerId$1;
-    actionType: string;
-}
-
-interface ActionRejectedPayload {
-    type: "ACTION_REJECTED";
-    reason: string;
-    targetPlayer?: string;
-}
-
-interface StateChangedPayload {
-    type: "STATE_CHANGED";
-    newState: string;
-}
-
-interface TurnChangedPayload {
-    type: "TURN_CHANGED";
-    previousPlayers: PlayerId$1[];
-    currentPlayers: PlayerId$1[];
-}
-
-interface GameEndedPayload {
-    type: "GAME_ENDED";
-    winner?: string;
-    finalScores: Record<string, number>;
-    reason: string;
-}
-
-interface ErrorPayload {
-    type: "ERROR";
-    message: string;
-    code?: string;
-}
-
-type NotificationPayload = YourTurnPayload | PromptOpenedPayload | ActionExecutedPayload | ActionRejectedPayload | TurnChangedPayload | StateChangedPayload | GameEndedPayload | ErrorPayload;
-
-interface Notification {
-    
-    id: string;
-    
-    type: NotificationType;
-    
-    payload: NotificationPayload;
-    
-    timestamp: number;
-    
-    read: boolean;
-}
-
-interface PluginSessionState$1 {
-    
-    sessionId: string | null;
-    
-    controllablePlayerIds: PlayerId$1[];
-    
-    controllingPlayerId: PlayerId$1 | null;
-    
-    userId: string | null;
-}
-
-interface HistoryState {
-    
-    entries: HistoryEntrySummary[];
-    
-    currentIndex: number;
-    
-    canGoBack: boolean;
-    
-    canGoForward: boolean;
-}
-interface GameplayPromptOption {
-    id: string;
-    label: string;
-}
-
-interface InteractionContextOption {
-    id: string;
-    label?: string;
-    data?: unknown;
-}
-
-interface InteractionContext {
-    
-    to: string;
-    title?: string;
-    
-    payload?: Record<string, unknown>;
-    
-    options?: readonly InteractionContextOption[];
+interface UIRootProps {
+    children: ReactNode;
 }
-
-type InteractionKind = "action" | "prompt";
-type InteractionCommitPolicy = {
-    mode: "manual";
-} | {
-    mode: "autoWhenReady";
+declare function UIRoot({ children }: UIRootProps): react_jsx_runtime.JSX.Element;
+declare const UI: {
+    Root: typeof UIRoot;
 };
-interface InputSelection {
-    mode: "single" | "many";
-    min?: number;
-    max?: number;
-    distinct?: boolean;
-}
-interface InputDomain {
-    type: "target" | "resourceMap" | "boundedNumber" | "choice" | "choiceList";
-    targetKind?: string;
-    boardId?: string;
-    zoneId?: string;
-    zoneIds?: readonly string[];
-    eligibleTargets?: readonly string[];
-    resources?: ReadonlyArray<{
-        resourceId: string;
-        label?: string;
-        icon?: string;
-        min: number;
-        max: number;
-    }>;
-    min?: number;
-    max?: number;
-    step?: number;
-    choices?: readonly InteractionChoiceOption[];
-    selection?: InputSelection;
-}
-interface InteractionChoiceOption {
-    value: string;
-    label: string;
-    icon?: string;
-    badge?: string;
-    description?: string;
-    disabled?: boolean;
-    disabledReason?: string;
-}
-interface InteractionInputDescriptor {
-    key: string;
-    kind: string;
-    domain: InputDomain;
-    defaultValue?: unknown;
-}
-interface InteractionDescriptor<Key extends string = string> {
-    phaseName: string;
-    interactionKey: Key;
-    interactionId: string;
-    
-    kind: InteractionKind;
-    
-    commit: InteractionCommitPolicy;
-    
-    zoneId?: string;
-    
-    zoneIds?: readonly string[];
-    
-    inputs: readonly InteractionInputDescriptor[];
-    
-    cost?: Record<string, unknown>;
-    
-    currentResources?: Record<string, unknown>;
-    
-    available: boolean;
-    unavailableReason?: string;
-    
-    context?: InteractionContext;
-}
-
-interface ZoneHandlesSnapshot<InteractionType extends string = string> {
-    cardIds: readonly string[];
-    cardsById: Readonly<Record<string, string>>;
-    playableByCardId: Readonly<Record<string, ReadonlyArray<InteractionDescriptor<InteractionType>>>>;
-}
-interface SimultaneousPhaseSnapshot {
-    phaseName: string;
-    interactionId: string;
-    actorIds: PlayerId$1[];
-    sealedPlayerIds: PlayerId$1[];
-    pendingPlayerIds: PlayerId$1[];
-}
-interface GameplaySnapshot$1<PhaseType extends string = string, StageType extends string = string, InteractionType extends string = string> {
-    currentPhase: PhaseType | null;
-    currentStage: StageType | null;
-    activePlayers: PlayerId$1[];
-    simultaneousPhase?: SimultaneousPhaseSnapshot | null;
-    availableInteractions: ReadonlyArray<InteractionDescriptor<InteractionType>>;
-    
-    zones: Readonly<Record<string, ZoneHandlesSnapshot<InteractionType>>>;
-}
-
-interface PluginStateSnapshot<View = unknown, PhaseType extends string = string, StageType extends string = string, InteractionType extends string = string> {
-    
-    view: View | null;
-    
-    gameplay: GameplaySnapshot$1<PhaseType, StageType, InteractionType>;
-    
-    lobby: LobbyState | null;
-    
-    notifications: Notification[];
-    
-    session: PluginSessionState$1;
-    
-    history: HistoryState | null;
-    
-    syncId: number;
-}
-
-declare function useSimultaneousPhase(): SimultaneousPhaseSnapshot | null;
-
-declare function usePlayerTurnOrder(): readonly PlayerId$1[];
-
-type EqualityFn<T> = (left: T, right: T) => boolean;
-
-declare function useGameSelector<T>(selector: (state: GameView) => T, equalityFn?: EqualityFn<T>): T;
-
-declare function useIsMyTurn(): boolean;
 
 interface ViewCard<CardIdValue extends string = string, CardTypeValue extends string = string, Properties extends Record<string, unknown> = Record<string, unknown>> {
     id: CardIdValue;
@@ -283,11 +31,26 @@ interface ViewSlotOccupant<PieceIdValue extends string = string, PlayerIdValue e
     data?: Data;
 }
 
-declare function useCards<CardIdValue extends string, CardValue extends ViewCard<CardIdValue>>(collection: CardCollection<CardIdValue, CardValue>): CardValue[];
-
-declare function useGameView(): GameView;
+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;
 
-declare function useLobby(): LobbyState;
+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>;
 
 type CardIdsByHandId = Record<string, PerPlayer<CardId[]>>;
 type StateName = string;
@@ -296,15 +59,15 @@ type EdgePropertiesByBoardId = Record<BoardId, Record<string, unknown>>;
 type VertexPropertiesByBoardId = Record<BoardId, Record<string, unknown>>;
 interface Player {
     
-    playerId: PlayerId$1;
+    playerId: PlayerId;
     
     name: string;
     
     isHost?: boolean;
     
-    color?: string;
+    color?: HexColor;
 }
-interface HexTileState<B extends string = BoardId, SpaceIdValue extends SpaceId = SpaceId, Properties = B extends keyof TilePropertiesByBoardId ? TilePropertiesByBoardId[B] : undefined, View = unknown> {
+interface HexTileState<B extends string = BoardId, SpaceIdValue extends string = SpaceId, Properties = B extends keyof TilePropertiesByBoardId ? TilePropertiesByBoardId[B] : undefined, View = unknown> {
     
     id: SpaceIdValue;
     
@@ -316,14 +79,14 @@ interface HexTileState<B extends string = BoardId, SpaceIdValue extends SpaceId
     
     label?: string;
     
-    owner?: PlayerId$1;
+    owner?: PlayerId;
     
     properties?: Properties;
     
     view?: View;
 }
 
-interface HexEdgeState<B extends string = BoardId, SpaceIdValue extends SpaceId = SpaceId, EdgeIdValue extends string = string, Properties = B extends keyof EdgePropertiesByBoardId ? EdgePropertiesByBoardId[B] : undefined> {
+interface HexEdgeState<B extends string = BoardId, SpaceIdValue extends string = SpaceId, EdgeIdValue extends string = string, Properties = B extends keyof EdgePropertiesByBoardId ? EdgePropertiesByBoardId[B] : undefined> {
     
     id: EdgeIdValue;
     
@@ -335,12 +98,12 @@ interface HexEdgeState<B extends string = BoardId, SpaceIdValue extends SpaceId
     
     label?: string;
     
-    owner?: PlayerId$1;
+    owner?: PlayerId;
     
     properties?: Properties;
 }
 
-interface HexVertexState<B extends string = BoardId, SpaceIdValue extends SpaceId = SpaceId, VertexIdValue extends string = string, Properties = B extends keyof VertexPropertiesByBoardId ? VertexPropertiesByBoardId[B] : undefined> {
+interface HexVertexState<B extends string = BoardId, SpaceIdValue extends string = SpaceId, VertexIdValue extends string = string, Properties = B extends keyof VertexPropertiesByBoardId ? VertexPropertiesByBoardId[B] : undefined> {
     
     id: VertexIdValue;
     
@@ -350,12 +113,12 @@ interface HexVertexState<B extends string = BoardId, SpaceIdValue extends SpaceI
     
     label?: string;
     
-    owner?: PlayerId$1;
+    owner?: PlayerId;
     
     properties?: Properties;
 }
 
-interface HexBoardState<B extends string = BoardId, SpaceIdValue extends SpaceId = 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> {
+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> {
     
     id: B;
     
@@ -378,7 +141,7 @@ interface NetworkNodeState {
     
     label?: string;
     
-    owner?: PlayerId$1;
+    owner?: PlayerId;
     
     properties?: string;
 }
@@ -395,7 +158,7 @@ interface NetworkEdgeState {
     
     label?: string;
     
-    owner?: PlayerId$1;
+    owner?: PlayerId;
     
     properties?: string;
 }
@@ -408,7 +171,7 @@ interface NetworkPieceState {
     
     typeId?: PieceTypeId;
     
-    owner?: PlayerId$1;
+    owner?: PlayerId;
     
     properties?: string;
 }
@@ -424,7 +187,7 @@ interface NetworkBoardState {
     pieces: NetworkPieceState[];
 }
 
-interface SquareCellState<SpaceIdValue extends SpaceId = SpaceId, Properties = Record<string, unknown>> {
+interface SquareCellState<SpaceIdValue extends string = SpaceId, Properties = Record<string, unknown>> {
     
     id: SpaceIdValue;
     
@@ -436,12 +199,12 @@ interface SquareCellState<SpaceIdValue extends SpaceId = SpaceId, Properties = R
     
     label?: string;
     
-    owner?: PlayerId$1;
+    owner?: PlayerId;
     
     properties?: Properties;
 }
 
-interface SquareEdgeState<SpaceIdValue extends SpaceId = SpaceId, EdgeIdValue extends string = string, Properties = Record<string, unknown>> {
+interface SquareEdgeState<SpaceIdValue extends string = SpaceId, EdgeIdValue extends string = string, Properties = Record<string, unknown>> {
     
     id: EdgeIdValue;
     
@@ -451,12 +214,12 @@ interface SquareEdgeState<SpaceIdValue extends SpaceId = SpaceId, EdgeIdValue ex
     
     label?: string;
     
-    owner?: PlayerId$1;
+    owner?: PlayerId;
     
     properties?: Properties;
 }
 
-interface SquareVertexState<SpaceIdValue extends SpaceId = SpaceId, VertexIdValue extends string = string, Properties = Record<string, unknown>> {
+interface SquareVertexState<SpaceIdValue extends string = SpaceId, VertexIdValue extends string = string, Properties = Record<string, unknown>> {
     
     id: VertexIdValue;
     
@@ -466,12 +229,12 @@ interface SquareVertexState<SpaceIdValue extends SpaceId = SpaceId, VertexIdValu
     
     label?: string;
     
-    owner?: PlayerId$1;
+    owner?: PlayerId;
     
     properties?: Properties;
 }
 
-interface SquarePieceState<PieceIdValue extends PieceId = PieceId, Properties = Record<string, unknown>> {
+interface SquarePieceState<PieceIdValue extends string = PieceId, Properties = Record<string, unknown>> {
     
     id: PieceIdValue;
     
@@ -481,12 +244,12 @@ interface SquarePieceState<PieceIdValue extends PieceId = PieceId, Properties =
     
     typeId: PieceTypeId;
     
-    owner?: PlayerId$1;
+    owner?: PlayerId;
     
     properties?: Properties;
 }
 
-interface SquareBoardState<B extends string = BoardId, SpaceIdValue extends SpaceId = SpaceId, EdgeIdValue extends string = string, VertexIdValue extends string = string, PieceIdValue extends PieceId = PieceId, CellProperties = Record<string, unknown>, EdgeProperties = Record<string, unknown>, VertexProperties = Record<string, unknown>, PieceProperties = Record<string, unknown>> {
+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>> {
     
     id: B;
     
@@ -517,7 +280,7 @@ interface TrackSpaceState {
     
     typeId?: SpaceTypeId;
     
-    owner?: PlayerId$1;
+    owner?: PlayerId;
     
     nextSpaces?: SpaceId[];
     
@@ -530,7 +293,7 @@ interface TrackPieceState {
     
     spaceId: SpaceId;
     
-    owner: PlayerId$1;
+    owner: PlayerId;
     
     typeId?: PieceTypeId;
     
@@ -578,7 +341,7 @@ interface BoardStates {
 type DiceStates = Record<DieId, DieState>;
 interface GameState {
     
-    currentPlayerIds: PlayerId$1[];
+    currentPlayerIds: PlayerId[];
     decks: CardIdsByDeckId;
     
     hands: CardIdsByHandId;
@@ -592,188 +355,776 @@ interface GameState {
     dice: DiceStates;
 }
 
-declare function useMe(): Player;
-
-declare function usePlayerInfo(): Map<PlayerId$1, Player>;
-
-interface SeatInbox {
-    
-    bySurface: Record<string, readonly InteractionDescriptor[]>;
-    
-    prompts: readonly InteractionDescriptor[];
-    
-    all: readonly InteractionDescriptor[];
+type RuntimeFields = Record<string, unknown>;
+interface GeneratedTiledEdgeStateLike<SpaceIdValue extends string = string, EdgeIdValue extends string = string, Fields = RuntimeFields> {
+    id: EdgeIdValue;
+    spaceIds: readonly SpaceIdValue[];
+    typeId?: EdgeTypeId | null;
+    label?: string | null;
+    ownerId?: PlayerId | null;
+    fields?: Fields;
 }
-
-declare function useSeatInbox(): SeatInbox;
-
-type InteractionParamsShape = Record<string, unknown>;
-type InteractionHandleStatus = "open" | "submitting" | "submitted";
-type DraftValidation<Params extends InteractionParamsShape = InteractionParamsShape> = {
-    ok: true;
-    params: Params;
-    fieldErrors: Partial<Record<keyof Params & string, readonly string[]>>;
-    formErrors: readonly string[];
-    missing: ReadonlyArray<keyof Params & string>;
-} | {
-    ok: false;
-    fieldErrors: Partial<Record<keyof Params & string, readonly string[]>>;
-    formErrors: readonly string[];
-    missing: ReadonlyArray<keyof Params & string>;
+interface GeneratedTiledVertexStateLike<SpaceIdValue extends string = string, VertexIdValue extends string = string, Fields = RuntimeFields> {
+    id: VertexIdValue;
+    spaceIds: readonly SpaceIdValue[];
+    typeId?: VertexTypeId | null;
+    label?: string | null;
+    ownerId?: PlayerId | null;
+    fields?: Fields;
+}
+interface GeneratedHexSpaceStateLike<SpaceIdValue extends string = string, Fields = RuntimeFields> {
+    id: SpaceIdValue;
+    q: number;
+    r: number;
+    typeId?: SpaceTypeId | null;
+    label?: string | null;
+    ownerId?: PlayerId | null;
+    fields?: Fields;
+}
+interface GeneratedSquareSpaceStateLike<SpaceIdValue extends string = string, Fields = RuntimeFields> {
+    id: SpaceIdValue;
+    row: number;
+    col: number;
+    typeId?: SpaceTypeId | null;
+    label?: string | null;
+    ownerId?: PlayerId | null;
+    fields?: Fields;
+}
+interface GeneratedHexBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields> {
+    id: BoardIdValue;
+    layout?: "hex";
+    orientation?: "pointy-top" | "flat-top";
+    spaces: Readonly<Record<SpaceIdValue, GeneratedHexSpaceStateLike<SpaceIdValue, SpaceFields>>>;
+    edges: ReadonlyArray<HexEdgeState<BoardIdValue, SpaceIdValue, EdgeIdValue, EdgeFields> | GeneratedTiledEdgeStateLike<SpaceIdValue, EdgeIdValue, EdgeFields>>;
+    vertices: ReadonlyArray<HexVertexState<BoardIdValue, SpaceIdValue, VertexIdValue, VertexFields> | GeneratedTiledVertexStateLike<SpaceIdValue, VertexIdValue, VertexFields>>;
+}
+interface AuthoredHexBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields, SpaceView = unknown> {
+    id: BoardIdValue;
+    layout?: "hex";
+    orientation?: "pointy-top" | "flat-top";
+    tiles: ReadonlyArray<HexTileState<BoardIdValue, SpaceIdValue, SpaceFields, SpaceView>>;
+    edges: ReadonlyArray<HexEdgeState<BoardIdValue, SpaceIdValue, EdgeIdValue, EdgeFields> | GeneratedTiledEdgeStateLike<SpaceIdValue, EdgeIdValue, EdgeFields>>;
+    vertices: ReadonlyArray<HexVertexState<BoardIdValue, SpaceIdValue, VertexIdValue, VertexFields> | GeneratedTiledVertexStateLike<SpaceIdValue, VertexIdValue, VertexFields>>;
+}
+type HexBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields> = AuthoredHexBoardInput<BoardIdValue, SpaceIdValue, EdgeIdValue, VertexIdValue, SpaceFields, EdgeFields, VertexFields> | GeneratedHexBoardInput<BoardIdValue, SpaceIdValue, EdgeIdValue, VertexIdValue, SpaceFields, EdgeFields, VertexFields>;
+interface GeneratedSquareBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, PieceIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields, PieceFields = RuntimeFields> {
+    id: BoardIdValue;
+    layout?: "square";
+    spaces: Readonly<Record<SpaceIdValue, GeneratedSquareSpaceStateLike<SpaceIdValue, SpaceFields>>>;
+    edges: ReadonlyArray<SquareEdgeState<SpaceIdValue, EdgeIdValue, EdgeFields> | GeneratedTiledEdgeStateLike<SpaceIdValue, EdgeIdValue, EdgeFields>>;
+    vertices: ReadonlyArray<SquareVertexState<SpaceIdValue, VertexIdValue, VertexFields> | GeneratedTiledVertexStateLike<SpaceIdValue, VertexIdValue, VertexFields>>;
+    pieces?: ReadonlyArray<SquarePieceState<PieceIdValue, PieceFields>>;
+}
+interface AuthoredSquareBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, PieceIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields, PieceFields = RuntimeFields> {
+    id: BoardIdValue;
+    layout?: "square";
+    rows: number;
+    cols: number;
+    cells: ReadonlyArray<SquareCellState<SpaceIdValue, SpaceFields>>;
+    edges: ReadonlyArray<SquareEdgeState<SpaceIdValue, EdgeIdValue, EdgeFields> | GeneratedTiledEdgeStateLike<SpaceIdValue, EdgeIdValue, EdgeFields>>;
+    vertices: ReadonlyArray<SquareVertexState<SpaceIdValue, VertexIdValue, VertexFields> | GeneratedTiledVertexStateLike<SpaceIdValue, VertexIdValue, VertexFields>>;
+    pieces: ReadonlyArray<SquarePieceState<PieceIdValue, PieceFields>>;
+}
+type SquareBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, PieceIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields, PieceFields = RuntimeFields> = AuthoredSquareBoardInput<BoardIdValue, SpaceIdValue, EdgeIdValue, VertexIdValue, PieceIdValue, SpaceFields, EdgeFields, VertexFields, PieceFields> | GeneratedSquareBoardInput<BoardIdValue, SpaceIdValue, EdgeIdValue, VertexIdValue, PieceIdValue, SpaceFields, EdgeFields, VertexFields, PieceFields>;
+type AnyHexBoardInput = HexBoardInput<string, string, string, string, RuntimeFields, RuntimeFields, RuntimeFields>;
+type AnySquareBoardInput = SquareBoardInput<string, string, string, string, string, RuntimeFields, RuntimeFields, RuntimeFields, RuntimeFields>;
+type BoardIdOf<TBoard> = TBoard extends {
+    id: infer Id extends string;
+} ? Id : string;
+type SpaceRecordValueOf<TBoard> = TBoard extends {
+    spaces: Readonly<Record<string, infer Space>>;
+} ? Space : never;
+type TileValueOf<TBoard> = TBoard extends {
+    tiles: ReadonlyArray<infer Tile>;
+} ? Tile : never;
+type CellValueOf<TBoard> = TBoard extends {
+    cells: ReadonlyArray<infer Cell>;
+} ? Cell : never;
+type EdgeValueOf<TBoard> = TBoard extends {
+    edges: ReadonlyArray<infer Edge>;
+} ? Edge : never;
+type VertexValueOf<TBoard> = TBoard extends {
+    vertices: ReadonlyArray<infer Vertex>;
+} ? Vertex : never;
+type PieceValueOf<TBoard> = TBoard extends {
+    pieces?: ReadonlyArray<infer Piece>;
+} ? Piece : never;
+type BoardSpaceIdOf<TBoard> = SpaceRecordValueOf<TBoard> extends {
+    id: infer Id extends string;
+} ? Id : TileValueOf<TBoard> extends {
+    id: infer Id extends string;
+} ? Id : CellValueOf<TBoard> extends {
+    id: infer Id extends string;
+} ? Id : never;
+type BoardEdgeIdOf<TBoard> = EdgeValueOf<TBoard> extends {
+    id: infer Id extends string;
+} ? Id : never;
+type BoardVertexIdOf<TBoard> = VertexValueOf<TBoard> extends {
+    id: infer Id extends string;
+} ? Id : never;
+type HexTilePropertiesOf<TBoard> = SpaceRecordValueOf<TBoard> extends {
+    fields?: infer Fields;
+} ? Fields : TileValueOf<TBoard> extends {
+    properties?: infer Properties;
+} ? Properties : RuntimeFields;
+type HexTileViewOf<TBoard> = TileValueOf<TBoard> extends {
+    view: infer View;
+} ? View : TileValueOf<TBoard> extends {
+    view?: infer View;
+} ? View | undefined : unknown;
+type HexEdgePropertiesOf<TBoard> = EdgeValueOf<TBoard> extends {
+    fields?: infer Fields;
+} ? Fields : EdgeValueOf<TBoard> extends {
+    properties?: infer Properties;
+} ? Properties : RuntimeFields;
+type HexVertexPropertiesOf<TBoard> = VertexValueOf<TBoard> extends {
+    fields?: infer Fields;
+} ? Fields : VertexValueOf<TBoard> extends {
+    properties?: infer Properties;
+} ? Properties : RuntimeFields;
+type SquareCellPropertiesOf<TBoard> = SpaceRecordValueOf<TBoard> extends {
+    fields?: infer Fields;
+} ? Fields : CellValueOf<TBoard> extends {
+    properties?: infer Properties;
+} ? Properties : RuntimeFields;
+type SquareEdgePropertiesOf<TBoard> = EdgeValueOf<TBoard> extends {
+    fields?: infer Fields;
+} ? Fields : EdgeValueOf<TBoard> extends {
+    properties?: infer Properties;
+} ? Properties : RuntimeFields;
+type SquareVertexPropertiesOf<TBoard> = VertexValueOf<TBoard> extends {
+    fields?: infer Fields;
+} ? Fields : VertexValueOf<TBoard> extends {
+    properties?: infer Properties;
+} ? Properties : RuntimeFields;
+type SquarePiecePropertiesOf<TBoard> = PieceValueOf<TBoard> extends {
+    properties?: infer Properties;
+} ? Properties : RuntimeFields;
+
+type NormalizedHexTileOf<TBoard extends AnyHexBoardInput> = Omit<HexTileState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, HexTilePropertiesOf<TBoard>, HexTileViewOf<TBoard>>, "view"> & {
+    view: HexTileViewOf<TBoard>;
 };
+type NormalizedHexEdgeOf<TBoard extends AnyHexBoardInput> = HexEdgeState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, BoardEdgeIdOf<TBoard>, HexEdgePropertiesOf<TBoard>>;
+type NormalizedHexVertexOf<TBoard extends AnyHexBoardInput> = HexVertexState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, BoardVertexIdOf<TBoard>, HexVertexPropertiesOf<TBoard>>;
+type NormalizedSquareCellOf<TBoard extends AnySquareBoardInput> = SquareCellState<BoardSpaceIdOf<TBoard>, SquareCellPropertiesOf<TBoard>>;
+type NormalizedSquareEdgeOf<TBoard extends AnySquareBoardInput> = SquareEdgeState<BoardSpaceIdOf<TBoard>, BoardEdgeIdOf<TBoard>, SquareEdgePropertiesOf<TBoard>>;
+type NormalizedSquareVertexOf<TBoard extends AnySquareBoardInput> = SquareVertexState<BoardSpaceIdOf<TBoard>, BoardVertexIdOf<TBoard>, SquareVertexPropertiesOf<TBoard>>;
+type NormalizedSquarePieceOf<TBoard extends AnySquareBoardInput> = SquarePieceState<PieceValueOf<TBoard> extends {
+    id: infer PieceIdValue extends string;
+} ? PieceIdValue : string, SquarePiecePropertiesOf<TBoard>>;
+type NormalizedHexBoard<TBoard extends AnyHexBoardInput> = Omit<Pick<HexBoardState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, BoardEdgeIdOf<TBoard>, BoardVertexIdOf<TBoard>, HexTilePropertiesOf<TBoard>, HexEdgePropertiesOf<TBoard>, HexVertexPropertiesOf<TBoard>>, "id" | "tiles" | "edges" | "vertices">, "tiles"> & {
+    tiles: ReadonlyArray<NormalizedHexTileOf<TBoard>>;
+    orientation?: "pointy-top" | "flat-top";
+};
+type NormalizedSquareBoard<TBoard extends AnySquareBoardInput> = Pick<SquareBoardState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, BoardEdgeIdOf<TBoard>, BoardVertexIdOf<TBoard>, PieceValueOf<TBoard> extends {
+    id: infer PieceIdValue extends string;
+} ? PieceIdValue : string, SquareCellPropertiesOf<TBoard>, SquareEdgePropertiesOf<TBoard>, SquareVertexPropertiesOf<TBoard>, SquarePiecePropertiesOf<TBoard>>, "id" | "rows" | "cols" | "cells" | "edges" | "vertices" | "pieces">;
+declare function normalizeHexBoardInput<TBoard extends AnyHexBoardInput>(board: TBoard): NormalizedHexBoard<TBoard>;
+declare function normalizeSquareBoardInput<TBoard extends AnySquareBoardInput>(board: TBoard): NormalizedSquareBoard<TBoard>;
 
-interface InteractionHandle<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never> {
-    descriptor: InteractionDescriptor;
+type HexBoardViewTile<TBoard extends AnyHexBoardInput, TSpaceView extends {
+    id: BoardSpaceIdOf<TBoard>;
+}> = Omit<NormalizedHexTileOf<TBoard>, "view"> & {
+    view: TSpaceView;
+};
+
+interface HexBoardView<TBoard extends AnyHexBoardInput, TSpaceView extends {
+    id: BoardSpaceIdOf<TBoard>;
+}> {
+    id: BoardIdOf<TBoard>;
+    layout?: "hex";
+    orientation?: "pointy-top" | "flat-top";
+    tiles: ReadonlyArray<HexBoardViewTile<TBoard, TSpaceView>>;
+    edges: TBoard["edges"];
+    vertices: TBoard["vertices"];
+}
+interface CreateHexBoardViewOptions<TSpaceView> {
+    spaces: readonly TSpaceView[];
+}
+
+declare function createHexBoardView<const TBoard extends AnyHexBoardInput, const TSpaceView extends {
+    id: BoardSpaceIdOf<TBoard>;
+}>(board: TBoard, options: CreateHexBoardViewOptions<TSpaceView>): HexBoardView<TBoard, TSpaceView>;
+
+type ActionName = string;
+interface SeatAssignment {
+    playerId: PlayerId;
+    controllerUserId?: string;
+    displayName: string;
+    playerColor?: HexColor;
+    isHost?: boolean;
+}
+interface HistoryEntrySummary {
+    id: string;
+    version: number;
+    timestamp: string;
+    description: string;
+    playerId?: PlayerId;
+    actionType?: ActionName;
+    isCurrent: boolean;
+}
+
+interface LobbyState {
     
-    commit: InteractionDescriptor["commit"];
+    seats: SeatAssignment[];
     
-    submit: (params?: Params) => Promise<void>;
+    canStart: boolean;
     
-    validate: (params?: Params) => Promise<void>;
+    hostUserId: string;
+}
+
+type NotificationType = "YOUR_TURN" | "PROMPT_OPENED" | "ACTION_EXECUTED" | "ACTION_REJECTED" | "TURN_CHANGED" | "STATE_CHANGED" | "GAME_ENDED" | "ERROR";
+
+interface YourTurnPayload {
+    type: "YOUR_TURN";
+    activePlayers: PlayerId[];
+}
+
+interface PromptOpenedPayload {
+    type: "PROMPT_OPENED";
+    promptId: string;
+    promptInstanceId: string;
+    targetPlayer: PlayerId;
+    title?: string;
+}
+
+interface ActionExecutedPayload {
+    type: "ACTION_EXECUTED";
+    playerId: PlayerId;
+    actionType: string;
+}
+
+interface ActionRejectedPayload {
+    type: "ACTION_REJECTED";
+    reason: string;
+    targetPlayer?: string;
+}
+
+interface StateChangedPayload {
+    type: "STATE_CHANGED";
+    newState: string;
+}
+
+interface TurnChangedPayload {
+    type: "TURN_CHANGED";
+    previousPlayers: PlayerId[];
+    currentPlayers: PlayerId[];
+}
+
+interface GameEndedPayload {
+    type: "GAME_ENDED";
+    winner?: string;
+    finalScores: Record<string, number>;
+    reason: string;
+}
+
+interface ErrorPayload {
+    type: "ERROR";
+    message: string;
+    code?: string;
+}
+
+type NotificationPayload = YourTurnPayload | PromptOpenedPayload | ActionExecutedPayload | ActionRejectedPayload | TurnChangedPayload | StateChangedPayload | GameEndedPayload | ErrorPayload;
+
+interface Notification {
     
-    validateDraft: () => DraftValidation<Params>;
+    id: string;
     
-    validateDraftServer: () => Promise<void>;
+    type: NotificationType;
+    
+    payload: NotificationPayload;
+    
+    timestamp: number;
+    
+    read: boolean;
+}
+
+interface PluginSessionState$1 {
+    
+    sessionId: string | null;
+    
+    controllablePlayerIds: PlayerId[];
+    
+    controllingPlayerId: PlayerId | null;
+    
+    userId: string | null;
+}
+
+interface HistoryState {
+    
+    entries: HistoryEntrySummary[];
+    
+    currentIndex: number;
+    
+    canGoBack: boolean;
+    
+    canGoForward: boolean;
+}
+
+interface InteractionContextOption {
+    id: string;
+    label?: string;
+}
+
+interface InteractionContext {
+    
+    to: string;
+    title?: string;
+    
+    payload?: Record<string, unknown>;
+    
+    options?: readonly InteractionContextOption[];
+}
+
+type InteractionKind = "action" | "prompt";
+type InteractionCommitPolicy = {
+    mode: "manual";
+} | {
+    mode: "autoWhenReady";
+};
+interface InputSelection {
+    mode: "single" | "many";
+    min?: number;
+    max?: number;
+    distinct?: boolean;
+}
+interface InputDomain {
+    type: "target" | "resourceMap" | "boundedNumber" | "choice" | "choiceList";
+    targetKind?: string;
+    boardId?: string;
+    zoneId?: string;
+    zoneIds?: readonly string[];
+    eligibleTargets?: readonly string[];
+    resources?: ReadonlyArray<{
+        resourceId: string;
+        label?: string;
+        icon?: string;
+        min: number;
+        max: number;
+    }>;
+    min?: number;
+    max?: number;
+    step?: number;
+    choices?: readonly InteractionChoiceOption[];
+    selection?: InputSelection;
+    dependsOn?: readonly string[];
+    dependentCases?: readonly InputDomainDependencyCase[];
+}
+interface InputDomainDependencyCase {
+    when: Readonly<Record<string, string>>;
+    domain: InputDomain;
+}
+interface InteractionChoiceOption {
+    value: string | null;
+    label: string;
+    icon?: string;
+    badge?: string;
+    description?: string;
+    disabled?: boolean;
+    disabledReason?: string;
+}
+interface InteractionInputDescriptor {
+    key: string;
+    kind: string;
+    domain: InputDomain;
+    defaultValue?: unknown;
+}
+interface InteractionDescriptor<Key extends string = string> {
+    phaseName: string;
+    interactionKey: Key;
+    interactionId: string;
+    
+    kind: InteractionKind;
+    
+    commit: InteractionCommitPolicy;
+    
+    zoneId?: string;
+    
+    zoneIds?: readonly string[];
+    
+    inputs: readonly InteractionInputDescriptor[];
+    
+    cost?: Record<string, unknown>;
     
-    submitDraft: () => Promise<void>;
+    currentResources?: Record<string, unknown>;
     
     available: boolean;
-    
     unavailableReason?: string;
     
-    status: InteractionHandleStatus;
+    context?: InteractionContext;
+}
+
+interface ZoneHandlesSnapshot<InteractionType extends string = string> {
+    cardIds: readonly string[];
+    cardsById: Readonly<Record<string, string>>;
+    playableByCardId: Readonly<Record<string, ReadonlyArray<InteractionDescriptor<InteractionType>>>>;
+}
+interface SimultaneousPhaseSnapshot {
+    phaseName: string;
+    interactionId: string;
+    actorIds: PlayerId[];
+    sealedPlayerIds: PlayerId[];
+    pendingPlayerIds: PlayerId[];
+}
+interface GameplaySnapshot<PhaseType extends string = string, StageType extends string = string, InteractionType extends string = string> {
+    currentPhase: PhaseType | null;
+    currentStage: StageType | null;
+    activePlayers: PlayerId[];
+    simultaneousPhase?: SimultaneousPhaseSnapshot | null;
+    availableInteractions: ReadonlyArray<InteractionDescriptor<InteractionType>>;
     
-    draft: Readonly<Partial<Params>>;
+    zones: Readonly<Record<string, ZoneHandlesSnapshot<InteractionType>>>;
+}
+
+interface PluginStateSnapshot<View = unknown, PhaseType extends string = string, StageType extends string = string, InteractionType extends string = string> {
     
-    values: Readonly<Partial<Params> & Pick<Params, DefaultedKeys>>;
+    view: View | null;
     
-    setInput: <K extends keyof Params & string>(key: K, value: Params[K]) => void;
+    gameplay: GameplaySnapshot<PhaseType, StageType, InteractionType>;
     
-    clearInput: (key?: keyof Params & string) => void;
+    lobby: LobbyState | null;
     
-    isReady: boolean;
+    notifications: Notification[];
     
-    isArmed: boolean;
+    session: PluginSessionState$1;
     
-    arm: () => void;
+    history: HistoryState | null;
     
-    disarm: () => void;
+    syncId: number;
 }
 
-declare function useInteractionHandle<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never>(descriptor: InteractionDescriptor): InteractionHandle<Params, DefaultedKeys>;
+type BoardTargetKind = "edge" | "vertex" | "space" | "tile";
+
+interface InteractiveTargetState {
+    kind?: BoardTargetKind;
+    id: string;
+    eligible: boolean;
+    selectable: boolean;
+    hovered: boolean;
+    interactionKey?: string;
+    interactionId?: string;
+    inputKey?: string;
+    pending: boolean;
+    conflict: boolean;
+    unavailableReason?: string;
+    select?: () => unknown | Promise<unknown>;
+}
+interface InteractiveTargetLayer {
+    enabled?: boolean;
+    eligible?: ReadonlySet<string>;
+    selectTargetId?: (targetId: string) => unknown | Promise<unknown>;
+    targetState?: (targetId: string) => Partial<InteractiveTargetState>;
+}
+interface InteractiveTargetRenderState extends InteractiveTargetState {
+    isEnabled: boolean;
+    isEligible: boolean;
+    isHovered: boolean;
+}
 
-declare function useInteractionByKey<Key extends string = string, Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never>(interactionKey: Key | null | undefined): InteractionHandle<Params, DefaultedKeys> | null;
+type HexOrientation = "pointy-top" | "flat-top";
 
-interface ValidationResult {
+interface HexTileGeometry {
+    size: number;
+    orientation: HexOrientation;
+    center: {
+        x: 0;
+        y: 0;
+    };
+    position: {
+        x: number;
+        y: number;
+    };
+    corners: (options?: {
+        inset?: number;
+    }) => Array<{
+        x: number;
+        y: number;
+    }>;
+    points: (options?: {
+        inset?: number;
+    }) => string;
+    bounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+        width: number;
+        height: number;
+    };
+}
+interface EdgePosition {
     
-    valid: boolean;
+    x1: number;
+    y1: number;
     
-    errorCode?: string;
+    x2: number;
+    y2: number;
     
-    message?: string;
-}
-
-interface SubmissionError extends Error {
+    midX: number;
+    midY: number;
     
-    errorCode?: string;
+    centerAngle: number;
+    
+    edgeAngle: number;
 }
-
-interface PluginSessionState {
+interface InteractiveHexVertex<TBoard extends AnyHexBoardInput = AnyHexBoardInput> extends NormalizedHexVertexOf<TBoard> {
+    position: {
+        x: number;
+        y: number;
+    };
+    spaceIds: ReadonlyArray<BoardSpaceIdOf<TBoard>>;
+}
+interface InteractiveHexEdge<TBoard extends AnyHexBoardInput = AnyHexBoardInput> extends NormalizedHexEdgeOf<TBoard> {
+    position: EdgePosition;
+    spaceIds: ReadonlyArray<BoardSpaceIdOf<TBoard>>;
+}
+type InteractiveHexSpace<TBoard extends AnyHexBoardInput = AnyHexBoardInput> = NormalizedHexTileOf<TBoard>;
+interface HexGeneratedGridInputProps {
+    id?: string;
+    layout?: "hex";
+    orientation?: HexOrientation;
+    spaces: Extract<AnyHexBoardInput, {
+        spaces: unknown;
+    }>["spaces"];
+    edges?: AnyHexBoardInput["edges"];
+    vertices?: AnyHexBoardInput["vertices"];
+}
+interface HexAuthoredGridInputProps {
+    id?: string;
+    layout?: "hex";
+    orientation?: HexOrientation;
+    tiles: Extract<AnyHexBoardInput, {
+        tiles: unknown;
+    }>["tiles"];
+    edges?: AnyHexBoardInput["edges"];
+    vertices?: AnyHexBoardInput["vertices"];
+}
+type HexGridInputProps = HexGeneratedGridInputProps | HexAuthoredGridInputProps;
+type ResolvedArrayProp<Value> = Exclude<Value, undefined> extends readonly unknown[] ? Exclude<Value, undefined> : readonly [];
+type HexBoardLikeOfProps<TProps extends HexGridInputProps> = TProps extends {
+    id?: infer Id;
+    layout?: infer Layout;
+    orientation?: infer Orientation;
+    spaces: infer Spaces;
+    edges?: infer Edges;
+    vertices?: infer Vertices;
+} ? {
+    id: Extract<Id, string> extends never ? string : Extract<Id, string>;
+    layout?: Extract<Layout, "hex">;
+    orientation?: Extract<Orientation, HexOrientation>;
+    spaces: Spaces;
+    edges: ResolvedArrayProp<Edges>;
+    vertices: ResolvedArrayProp<Vertices>;
+} & GeneratedHexBoardInput : TProps extends {
+    id?: infer Id;
+    layout?: infer Layout;
+    orientation?: infer Orientation;
+    tiles: infer Tiles;
+    edges?: infer Edges;
+    vertices?: infer Vertices;
+} ? {
+    id: Extract<Id, string> extends never ? string : Extract<Id, string>;
+    layout?: Extract<Layout, "hex">;
+    orientation?: Extract<Orientation, HexOrientation>;
+    tiles: Tiles;
+    edges: ResolvedArrayProp<Edges>;
+    vertices: ResolvedArrayProp<Vertices>;
+} & AuthoredHexBoardInput : never;
+type HexGridProps<TProps extends HexGridInputProps = HexGridInputProps> = TProps & {
+    orientation?: HexOrientation;
     
-    status: "loading" | "ready";
+    hexSize?: number;
     
-    sessionId: string | null;
+    renderTile: (tile: NormalizedHexTileOf<NoInfer<HexBoardLikeOfProps<TProps>>>, geometry: HexTileGeometry) => ReactNode;
+    
+    renderEdge: (edge: NormalizedHexEdgeOf<NoInfer<HexBoardLikeOfProps<TProps>>>, position: EdgePosition) => ReactNode;
+    renderVertex: (vertex: NormalizedHexVertexOf<NoInfer<HexBoardLikeOfProps<TProps>>>, position: {
+        x: number;
+        y: number;
+    }) => ReactNode;
+    width?: number | string;
+    height?: number | string;
+    enablePanZoom?: boolean;
+    initialZoom?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    className?: string;
     
-    controllablePlayerIds: PlayerId$1[];
+    interactiveSpaces?: InteractiveTargetLayer;
     
-    controllingPlayerId: PlayerId$1 | null;
+    interactiveVertices?: InteractiveTargetLayer;
     
-    userId: string | null;
-}
-
-interface RuntimeAPI {
+    interactiveEdges?: InteractiveTargetLayer;
     
-    validateInteraction: (playerId: PlayerId$1, interactionId: string, params: unknown) => Promise<ValidationResult>;
+    renderInteractiveSpace?: (space: InteractiveHexSpace<NoInfer<HexBoardLikeOfProps<TProps>>>, state: InteractiveTargetRenderState) => ReactNode;
     
-    submitInteraction: (playerId: PlayerId$1, interactionId: string, params: unknown) => Promise<void>;
+    renderInteractiveVertex?: (vertex: InteractiveHexVertex<NoInfer<HexBoardLikeOfProps<TProps>>>, position: {
+        x: number;
+        y: number;
+    }, state: InteractiveTargetRenderState) => ReactNode;
     
-    getSessionState: () => PluginSessionState;
+    renderInteractiveEdge?: (edge: InteractiveHexEdge<NoInfer<HexBoardLikeOfProps<TProps>>>, position: EdgePosition, state: InteractiveTargetRenderState) => ReactNode;
+    interactiveVertexSize?: number;
+    interactiveEdgeSize?: number;
+};
+interface HexGridBoardProps<TBoard extends AnyHexBoardInput = AnyHexBoardInput> {
+    board: TBoard;
+    orientation?: HexOrientation;
+    hexSize?: number;
     
-    disconnect: () => void;
+    renderTile: (tile: NormalizedHexTileOf<NoInfer<TBoard>>, geometry: HexTileGeometry) => ReactNode;
+    
+    renderEdge: (edge: NormalizedHexEdgeOf<NoInfer<TBoard>>, position: EdgePosition) => ReactNode;
+    renderVertex: (vertex: NormalizedHexVertexOf<NoInfer<TBoard>>, position: {
+        x: number;
+        y: number;
+    }) => ReactNode;
+    width?: number | string;
+    height?: number | string;
+    enablePanZoom?: boolean;
+    initialZoom?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    className?: string;
+    interactiveSpaces?: InteractiveTargetLayer;
+    interactiveVertices?: InteractiveTargetLayer;
+    interactiveEdges?: InteractiveTargetLayer;
     
-    switchPlayer?: (playerId: PlayerId$1) => void;
+    renderInteractiveSpace?: (space: InteractiveHexSpace<NoInfer<TBoard>>, state: InteractiveTargetRenderState) => ReactNode;
+    
+    renderInteractiveVertex?: (vertex: InteractiveHexVertex<NoInfer<TBoard>>, position: {
+        x: number;
+        y: number;
+    }, state: InteractiveTargetRenderState) => ReactNode;
+    
+    renderInteractiveEdge?: (edge: InteractiveHexEdge<NoInfer<TBoard>>, position: EdgePosition, state: InteractiveTargetRenderState) => ReactNode;
+    interactiveVertexSize?: number;
+    interactiveEdgeSize?: number;
 }
-
-declare function usePluginSession(): PluginSessionState;
-
-interface ClientParamSchema {
-    safeParse: (value: unknown) => {
-        success: true;
-        data: Record<string, unknown>;
-    } | {
-        success: false;
-        error: {
-            issues: ReadonlyArray<{
-                path: readonly PropertyKey[];
-                message: string;
-            }>;
-        };
+interface DefaultHexTileProps {
+    
+    size: number;
+    fill: string;
+    stroke?: string;
+    strokeWidth?: number;
+    isSelected?: boolean;
+    isHighlighted?: boolean;
+    label?: string;
+    showCoordinates?: boolean;
+    coordinates?: {
+        q: number;
+        r: number;
     };
+    orientation?: HexOrientation;
+    onClick?: () => void;
+    onPointerEnter?: () => void;
+    onPointerLeave?: () => void;
+    className?: string;
 }
-type ClientParamSchemaMap = Readonly<Record<string, Readonly<Record<string, ClientParamSchema>>>>;
 
-type StageName = string;
-type InteractionId = string;
-type GameplaySnapshot = GameplaySnapshot$1<PhaseName, StageName, InteractionId>;
-
-interface PromptDialogHostProps {
-    contentClassName?: string;
-    messageClassName?: string;
-    optionClassName?: string;
-    optionsClassName?: string;
-    overlayClassName?: string;
-    titleClassName?: string;
-    renderBody?: (prompt: InteractionDescriptor) => ReactNode;
-    renderOptionLabel?: (option: InteractionContextOption, prompt: InteractionDescriptor) => ReactNode;
-    onSubmitError?: (error: unknown, prompt: InteractionDescriptor, option: InteractionContextOption) => void;
+declare function DefaultHexTile({ size, fill, stroke, strokeWidth, isSelected, isHighlighted, label, showCoordinates, coordinates, orientation, onClick, onPointerEnter, onPointerLeave, className, }: DefaultHexTileProps): react_jsx_runtime.JSX.Element;
+interface DefaultHexEdgeProps {
+    position: EdgePosition;
+    color: string;
+    hasOwner?: boolean;
+    strokeWidth?: number;
+    touchTargetSize?: number;
+    onClick?: () => void;
+    className?: string;
 }
-declare function PromptDialogHost(props: PromptDialogHostProps): react_jsx_runtime.JSX.Element | null;
 
-interface InteractiveTargetLayer {
-    enabled?: boolean;
-    eligible?: ReadonlySet<string>;
-    selectTargetId?: (targetId: string) => void | Promise<void>;
-}
-interface InteractiveTargetRenderState {
-    isEnabled: boolean;
-    isEligible: boolean;
-    isHovered: boolean;
+declare function DefaultHexEdge({ position, color, hasOwner, strokeWidth, touchTargetSize, onClick, className, }: DefaultHexEdgeProps): react_jsx_runtime.JSX.Element;
+interface DefaultHexVertexProps {
+    position: {
+        x: number;
+        y: number;
+    };
+    color: string;
+    stroke?: string;
+    strokeWidth?: number;
+    hasOwner?: boolean;
+    isSelected?: boolean;
+    isHighlighted?: boolean;
+    size?: number;
+    touchTargetSize?: number;
+    shape?: "circle" | "square";
+    onClick?: () => void;
+    onPointerEnter?: () => void;
+    onPointerLeave?: () => void;
+    className?: string;
 }
 
-type BoardTargetKind = "edge" | "vertex" | "space" | "tile";
+declare function DefaultHexVertex({ position, color, stroke, strokeWidth, hasOwner, isSelected, isHighlighted, size, touchTargetSize, shape, onClick, onPointerEnter, onPointerLeave, className, }: DefaultHexVertexProps): react_jsx_runtime.JSX.Element;
+declare const hexUtils: {
+    
+    axialToPixel(q: number, r: number, size: number, orientation: HexOrientation): {
+        x: number;
+        y: number;
+    };
+    getNeighbors(q: number, r: number): Array<{
+        q: number;
+        r: number;
+    }>;
+    getDistance(q1: number, r1: number, q2: number, r2: number): number;
+    getHexCorners(centerX: number, centerY: number, size: number, orientation: HexOrientation): Array<{
+        x: number;
+        y: number;
+    }>;
+    getHexPoints(centerX: number, centerY: number, size: number, orientation: HexOrientation): string;
+    getEdgePosition(hex1Pos: {
+        x: number;
+        y: number;
+    }, hex2Pos: {
+        x: number;
+        y: number;
+    }, size: number): EdgePosition;
+    getVertexPosition(hex1Pos: {
+        x: number;
+        y: number;
+    }, hex2Pos: {
+        x: number;
+        y: number;
+    }, hex3Pos: {
+        x: number;
+        y: number;
+    }): {
+        x: number;
+        y: number;
+    };
+};
+interface HexGridComponent {
+    <const TBoard extends AnyHexBoardInput>(props: HexGridBoardProps<TBoard>): ReactNode;
+    <const TProps extends HexGeneratedGridInputProps>(props: HexGridProps<TProps>): ReactNode;
+    <const TProps extends HexAuthoredGridInputProps>(props: HexGridProps<TProps>): ReactNode;
+}
+declare const HexGrid: HexGridComponent;
 
 type BoardEligibleTargets = Readonly<Record<BoardTargetKind, ReadonlySet<string>>>;
 interface BoardTargetLayerOptions {
     enabled?: boolean;
+    interactionKeys?: readonly string[];
     extraInputs?: Record<string, unknown> | ((targetId: string) => Record<string, unknown>);
     onBeforeSelect?: () => void;
     onError?: (error: unknown) => void;
 }
 type BoardTargetLayerFactory = (options?: BoardTargetLayerOptions) => InteractiveTargetLayer;
-interface BoardInteractionsOptions {
-    
-    targetKinds?: readonly BoardTargetKind[];
-}
-declare class BoardInteractionConflictError extends Error {
-    readonly name = "BoardInteractionConflictError";
-    readonly targetKind: BoardTargetKind;
-    readonly targetId: string;
-    readonly interactionKeys: readonly string[];
-    constructor({ targetKind, targetId, interactionKeys, }: {
-        targetKind: BoardTargetKind;
-        targetId: string;
-        interactionKeys: readonly string[];
-    });
+type BoardSelectionResult<I extends string = string> = {
+    status: "none";
+} | {
+    status: "pending";
+    interactionKey: I;
+    descriptor: InteractionDescriptor<I>;
+    missingInputs: readonly string[];
+} | {
+    status: "submitted";
+    interactionKey: I;
+    descriptor: InteractionDescriptor<I>;
+};
+interface BoardPendingInteraction<I extends string = string> {
+    interactionKey: I;
+    descriptor: InteractionDescriptor<I>;
+    missingInputs: readonly string[];
+    clear(): void;
 }
 
 interface BoardInteractionsContext<I extends string = string> {
@@ -784,11 +1135,12 @@ interface BoardInteractionsContext<I extends string = string> {
     
     isEligible(targetId: string, targetKind?: BoardTargetKind): boolean;
     
+    pendingInteraction: BoardPendingInteraction<I> | null;
     select: {
-        edge(targetId: string, extraInputs?: Record<string, unknown>): Promise<string | null>;
-        vertex(targetId: string, extraInputs?: Record<string, unknown>): Promise<string | null>;
-        space(targetId: string, extraInputs?: Record<string, unknown>): Promise<string | null>;
-        tile(targetId: string, extraInputs?: Record<string, unknown>): Promise<string | null>;
+        edge(targetId: string, extraInputs?: Record<string, unknown>): Promise<BoardSelectionResult<I>>;
+        vertex(targetId: string, extraInputs?: Record<string, unknown>): Promise<BoardSelectionResult<I>>;
+        space(targetId: string, extraInputs?: Record<string, unknown>): Promise<BoardSelectionResult<I>>;
+        tile(targetId: string, extraInputs?: Record<string, unknown>): Promise<BoardSelectionResult<I>>;
     };
     
     targetLayers: {
@@ -797,10 +1149,10 @@ interface BoardInteractionsContext<I extends string = string> {
         space: BoardTargetLayerFactory;
         tile: BoardTargetLayerFactory;
     };
+    targetState(targetKind: BoardTargetKind, targetId: string, options?: Pick<BoardTargetLayerOptions, "enabled" | "interactionKeys">): InteractiveTargetState;
+    selectTarget(descriptor: InteractionDescriptor<I>, targetKind: BoardTargetKind, targetId: string, inputKey: string, extraInputs?: Record<string, unknown>): Promise<BoardSelectionResult<I>>;
 }
 
-declare function useBoardInteractions<I extends string = string>(options?: BoardInteractionsOptions): BoardInteractionsContext<I>;
-
 type PrimitiveDataAttributes = Record<`data-${string}`, string | boolean | number | undefined>;
 type PrimitiveCommonProps = {
     asChild?: boolean;
@@ -814,13 +1166,48 @@ declare function composeEventHandlers<Event extends {
 }>(authorHandler: EventHandler<Event> | undefined, primitiveHandler: EventHandler<Event> | undefined): EventHandler<Event> | undefined;
 declare function renderPrimitive<ElementProps extends HTMLAttributes<HTMLElement>>(tagName: keyof JSX.IntrinsicElements, props: ElementProps & PrimitiveCommonProps): ReactElement;
 
-type BoardContextValue = ReturnType<typeof useBoardInteractions>;
+type BoardContextValue = BoardInteractionsContext;
 declare function useBoardPrimitiveContext(): BoardContextValue;
 interface BoardRootProps extends PrimitiveCommonProps {
     children: ReactNode;
     targetKinds?: readonly BoardTargetKind[];
 }
 declare function BoardRoot({ children, targetKinds, ...props }: BoardRootProps): react_jsx_runtime.JSX.Element;
+interface BoardStateProps {
+    children: (board: BoardInteractionsContext) => ReactNode;
+}
+declare function BoardState({ children }: BoardStateProps): react_jsx_runtime.JSX.Element;
+interface BoardHexViewProps<TBoard extends AnyHexBoardInput, TSpaceView extends {
+    id: BoardSpaceIdOf<TBoard>;
+}> {
+    board: TBoard;
+    spaces: readonly TSpaceView[];
+    children: (view: HexBoardView<TBoard, TSpaceView>) => ReactNode;
+}
+declare function BoardHexView<const TBoard extends AnyHexBoardInput, const TSpaceView extends {
+    id: BoardSpaceIdOf<TBoard>;
+}>({ board, spaces, children }: BoardHexViewProps<TBoard, TSpaceView>): react_jsx_runtime.JSX.Element;
+interface BoardHexGridInteractions {
+    edge?: BoardTargetLayerOptions;
+    vertex?: BoardTargetLayerOptions;
+    space?: BoardTargetLayerOptions;
+}
+type BoardHexGridInteractionFilter = "auto" | false | {
+    edge?: readonly string[];
+    vertex?: readonly string[];
+    space?: readonly string[];
+};
+type BoardHexGridView<TBoard extends AnyHexBoardInput, TSpaceView extends {
+    id: BoardSpaceIdOf<TBoard>;
+}> = HexBoardView<TBoard, TSpaceView> & AnyHexBoardInput;
+type BoardHexGridProps<TBoard extends AnyHexBoardInput, TSpaceView extends {
+    id: BoardSpaceIdOf<TBoard>;
+}> = Omit<HexGridBoardProps<BoardHexGridView<TBoard, TSpaceView>>, "board" | "interactiveEdges" | "interactiveVertices" | "interactiveSpaces"> & Omit<BoardHexViewProps<TBoard, TSpaceView>, "children"> & {
+    interactions?: BoardHexGridInteractionFilter;
+};
+declare function BoardHexGrid<const TBoard extends AnyHexBoardInput, const TSpaceView extends {
+    id: BoardSpaceIdOf<TBoard>;
+}>({ board, spaces, interactions, ...props }: BoardHexGridProps<TBoard, TSpaceView>): react_jsx_runtime.JSX.Element;
 type BoardTargetExtraInputs = Record<string, unknown> | ((targetId: string) => Record<string, unknown>);
 type BoardTargetProps<Target extends string = BoardTargetKey> = PrimitiveCommonProps & ButtonHTMLAttributes<HTMLButtonElement> & {
     kind: BoardTargetKind;
@@ -828,15 +1215,229 @@ type BoardTargetProps<Target extends string = BoardTargetKey> = PrimitiveCommonP
     interaction?: string;
     input?: string;
     extraInputs?: BoardTargetExtraInputs;
-    onSelect?: (interactionKey: string | null) => void;
+    onSelect?: (result: BoardSelectionResult) => void;
     onSelectError?: (error: unknown) => void;
 };
 declare function BoardTarget<Target extends string = BoardTargetKey>({ interaction, input, ...props }: BoardTargetProps<Target>): react_jsx_runtime.JSX.Element;
+type BoardSpaceTargetProps<Target extends string = BoardTargetKey> = Omit<BoardTargetProps<Target>, "kind">;
+declare function BoardSpaceTarget<Target extends string = BoardTargetKey>(props: BoardSpaceTargetProps<Target>): react_jsx_runtime.JSX.Element;
+type BoardEdgeTargetProps<Target extends string = BoardTargetKey> = Omit<BoardTargetProps<Target>, "kind">;
+declare function BoardEdgeTarget<Target extends string = BoardTargetKey>(props: BoardEdgeTargetProps<Target>): react_jsx_runtime.JSX.Element;
+type BoardVertexTargetProps<Target extends string = BoardTargetKey> = Omit<BoardTargetProps<Target>, "kind">;
+declare function BoardVertexTarget<Target extends string = BoardTargetKey>(props: BoardVertexTargetProps<Target>): react_jsx_runtime.JSX.Element;
 declare const Board: {
     Root: typeof BoardRoot;
+    State: typeof BoardState;
+    HexGrid: typeof BoardHexGrid;
+    HexView: typeof BoardHexView;
     Target: typeof BoardTarget;
+    SpaceTarget: typeof BoardSpaceTarget;
+    EdgeTarget: typeof BoardEdgeTarget;
+    VertexTarget: typeof BoardVertexTarget;
+};
+
+interface ValidationResult {
+    
+    valid: boolean;
+    
+    errorCode?: string;
+    
+    message?: string;
+}
+
+interface SubmissionError extends Error {
+    
+    errorCode?: string;
+}
+
+interface PluginSessionState {
+    
+    status: "loading" | "ready";
+    
+    sessionId: string | null;
+    
+    controllablePlayerIds: PlayerId[];
+    
+    controllingPlayerId: PlayerId | null;
+    
+    userId: string | null;
+}
+
+interface RuntimeAPI {
+    
+    validateInteraction: (playerId: PlayerId, interactionId: string, params: unknown) => Promise<ValidationResult>;
+    
+    submitInteraction: (playerId: PlayerId, interactionId: string, params: unknown) => Promise<void>;
+    
+    getSessionState: () => PluginSessionState;
+    
+    disconnect: () => void;
+    
+    switchPlayer?: (playerId: PlayerId) => void;
+}
+
+declare function usePluginSession(): PluginSessionState;
+
+type GamePlayer<PlayerIdValue extends string = PlayerId> = Omit<Player, "playerId"> & {
+    playerId: PlayerIdValue;
+};
+type GamePlayerEntry<PlayerIdValue extends string = PlayerId> = GamePlayer<PlayerIdValue> & {
+    index: number;
+    isActive: boolean;
+    isCurrentPlayer: boolean;
+    isControllable: boolean;
+};
+interface GamePlayersState<PlayerIdValue extends string = PlayerId> {
+    byId: ReadonlyMap<PlayerIdValue, GamePlayer<PlayerIdValue>>;
+    order: readonly PlayerIdValue[];
+    entries: ReadonlyArray<GamePlayerEntry<PlayerIdValue>>;
+    active: readonly PlayerIdValue[];
+    current: GamePlayer<PlayerIdValue> | null;
+}
+interface GameMeState<PlayerIdValue extends string = PlayerId> {
+    playerId: PlayerIdValue | null;
+    player: GamePlayer<PlayerIdValue> | null;
+    controllablePlayerIds: readonly PlayerIdValue[];
+    canAct: boolean;
+}
+interface GameTurnState<PlayerIdValue extends string = PlayerId, PhaseValue extends string = string> {
+    phase: PhaseValue | null;
+    stage: string | null;
+    activePlayerIds: readonly PlayerIdValue[];
+    currentPlayerId: PlayerIdValue | null;
+    order: readonly PlayerIdValue[];
+    isMine: boolean;
+}
+interface GameRenderState<ViewValue = unknown, PlayerIdValue extends string = PlayerId, PhaseValue extends string = string> {
+    view: ViewValue;
+    phase: PhaseValue | null;
+    stage: string | null;
+    session: ReturnType<typeof usePluginSession>;
+    me: GameMeState<PlayerIdValue>;
+    turn: GameTurnState<PlayerIdValue, PhaseValue>;
+    players: GamePlayersState<PlayerIdValue>;
+}
+interface GameRootProps<ViewValue = unknown, PlayerIdValue extends string = PlayerId, PhaseValue extends string = string> {
+    onActionError?: (error: unknown) => void;
+    children: (state: GameRenderState<ViewValue, PlayerIdValue, PhaseValue>) => ReactNode;
+}
+type GameActionErrorHandler = (error: unknown) => void;
+declare function useGameActionError(): GameActionErrorHandler | null;
+declare function GameRoot<ViewValue = unknown, PlayerIdValue extends string = PlayerId, PhaseValue extends string = string>({ children, onActionError, }: GameRootProps<ViewValue, PlayerIdValue, PhaseValue>): react_jsx_runtime.JSX.Element;
+declare const Game: {
+    Root: typeof GameRoot;
 };
 
+type InteractionParamsShape = Record<string, unknown>;
+type InteractionHandleStatus = "open" | "submitting" | "submitted";
+type DraftValidation<Params extends InteractionParamsShape = InteractionParamsShape> = {
+    ok: true;
+    params: Params;
+    fieldErrors: Partial<Record<keyof Params & string, readonly string[]>>;
+    formErrors: readonly string[];
+    missing: ReadonlyArray<keyof Params & string>;
+} | {
+    ok: false;
+    fieldErrors: Partial<Record<keyof Params & string, readonly string[]>>;
+    formErrors: readonly string[];
+    missing: ReadonlyArray<keyof Params & string>;
+};
+
+interface InteractionHandle<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never> {
+    descriptor: InteractionDescriptor;
+    
+    commit: InteractionDescriptor["commit"];
+    
+    submit: (params?: Params) => Promise<void>;
+    
+    validate: (params?: Params) => Promise<void>;
+    
+    validateDraft: () => DraftValidation<Params>;
+    
+    validateDraftServer: () => Promise<void>;
+    
+    submitDraft: () => Promise<void>;
+    
+    available: boolean;
+    
+    unavailableReason?: string;
+    
+    status: InteractionHandleStatus;
+    
+    draft: Readonly<Partial<Params>>;
+    
+    values: Readonly<Partial<Params> & Pick<Params, DefaultedKeys>>;
+    
+    setInput: <K extends keyof Params & string>(key: K, value: Params[K]) => void;
+    
+    clearInput: (key?: keyof Params & string) => void;
+    
+    isReady: boolean;
+    
+    isArmed: boolean;
+    
+    arm: () => void;
+    
+    disarm: () => void;
+}
+
+declare function useInteractionHandle<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never>(descriptor: InteractionDescriptor): InteractionHandle<Params, DefaultedKeys>;
+
+interface InteractionFieldRenderProps<Params extends InteractionParamsShape = InteractionParamsShape, Key extends keyof Params & string = keyof Params & string> {
+    descriptor: InteractionDescriptor;
+    input: InteractionInputDescriptor & {
+        key: Key;
+    };
+    handle: InteractionHandle<Params>;
+    value: Params[Key] | undefined;
+    setValue: (value: Params[Key]) => void;
+    clearValue: () => void;
+    errors: readonly string[];
+    missing: boolean;
+    disabled: boolean;
+}
+type InteractionFieldRenderMap<Params extends InteractionParamsShape = InteractionParamsShape> = Partial<{
+    [K in keyof Params & string]: (props: InteractionFieldRenderProps<Params, K>) => ReactNode;
+}>;
+interface InteractionFieldProps<Params extends InteractionParamsShape = InteractionParamsShape, Key extends keyof Params & string = keyof Params & string> {
+    descriptor: InteractionDescriptor;
+    inputKey: Key;
+    handle: InteractionHandle<Params>;
+    errors?: readonly string[];
+    missing?: boolean;
+    disabled?: boolean;
+    render?: InteractionFieldRenderMap<Params>[Key];
+}
+interface InteractionFormProps<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never> {
+    descriptor: InteractionDescriptor;
+    handle: InteractionHandle<Params, DefaultedKeys>;
+    fields?: ReadonlyArray<keyof Params & string>;
+    hiddenFields?: ReadonlyArray<keyof Params & string>;
+    renderFields?: InteractionFieldRenderMap<Params>;
+    title?: ReactNode;
+    description?: ReactNode;
+    submitLabel?: ReactNode;
+    cancelLabel?: ReactNode;
+    onCancel?: () => void;
+    onSubmitSuccess?: () => void;
+    disabled?: boolean;
+    accordion?: boolean;
+    defaultOpen?: boolean;
+    style?: CSSProperties;
+}
+declare function InteractionForm<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never>({ descriptor, handle, fields, hiddenFields, renderFields, title, description, submitLabel, cancelLabel, onCancel, onSubmitSuccess, disabled, accordion, defaultOpen, style, }: InteractionFormProps<Params, DefaultedKeys>): react_jsx_runtime.JSX.Element;
+declare function hasDefaultInteractionFormFields(descriptor: Pick<InteractionDescriptor, "inputs">): boolean;
+declare function defaultFormInputs(descriptor: Pick<InteractionDescriptor, "inputs">, values?: Readonly<Record<string, unknown>>): InteractionInputDescriptor[];
+
+type BoundInteractionFormProps<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never> = Omit<InteractionFormProps<Params, DefaultedKeys>, "descriptor" | "handle">;
+
+interface InteractionSubmitCallbacks {
+    onSubmitSuccess?: () => void;
+    onSubmitError?: (error: unknown) => void;
+}
+
+type DialogLifecycleState = "open" | "minimized" | "dismissed";
+
 interface InteractionContextValue {
     interaction: string;
     descriptor: InteractionDescriptor | null;
@@ -849,6 +1450,37 @@ interface InteractionRootProps<Interaction extends string = InteractionKey> {
     unavailable?: "render" | "hide";
 }
 declare function InteractionRoot<Interaction extends string = InteractionKey>({ interaction, children, unavailable, }: InteractionRootProps<Interaction>): react_jsx_runtime.JSX.Element | null;
+type InteractionDialogState = DialogLifecycleState;
+interface InteractionDialogRenderState<Interaction extends string = InteractionKey> {
+    interaction: Interaction;
+    state: InteractionDialogState;
+    open: boolean;
+    minimized: boolean;
+    dismissed: boolean;
+    setOpen: (open: boolean) => void;
+    restore: () => void;
+    minimize: () => void;
+    dismiss: () => void;
+}
+interface InteractionDialogProps<Interaction extends string = InteractionKey> {
+    defaultOpen?: boolean;
+    onStateChange?: (state: InteractionDialogState) => void;
+    children: (state: InteractionDialogRenderState<Interaction>) => ReactNode;
+}
+declare function InteractionDialog<Interaction extends string = InteractionKey>({ defaultOpen, onStateChange, children, }: InteractionDialogProps<Interaction>): react_jsx_runtime.JSX.Element;
+interface InteractionSwitchRenderState<Interaction extends string = InteractionKey> {
+    interaction: Interaction;
+    descriptor: InteractionDescriptor<Interaction>;
+}
+type InteractionRouteMap<Interaction extends string = InteractionKey> = {
+    [Key in Interaction]?: (state: InteractionSwitchRenderState<Key>) => ReactNode;
+};
+interface InteractionSwitchProps<Interaction extends string = InteractionKey> {
+    interaction?: Interaction;
+    routes: InteractionRouteMap<Interaction>;
+    fallback?: ReactNode;
+}
+declare function InteractionSwitch<Interaction extends string = InteractionKey>({ interaction, routes, fallback, }: InteractionSwitchProps<Interaction>): react_jsx_runtime.JSX.Element;
 type InteractionPartProps = PrimitiveCommonProps & HTMLAttributes<HTMLElement>;
 declare function InteractionLabel({ children, ...props }: InteractionPartProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
 declare function InteractionDescription({ children, ...props }: InteractionPartProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
@@ -856,8 +1488,39 @@ declare function InteractionUnavailableMessage({ children, ...props }: Interacti
 declare function InteractionValidationMessage({ children, ...props }: InteractionPartProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
 type InteractionTriggerProps = PrimitiveCommonProps & ButtonHTMLAttributes<HTMLButtonElement>;
 declare function InteractionTrigger({ disabled, onClick, ...props }: InteractionTriggerProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
-type InteractionSubmitProps = PrimitiveCommonProps & ButtonHTMLAttributes<HTMLButtonElement>;
-declare function InteractionSubmit({ disabled, onClick, ...props }: InteractionSubmitProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+interface InteractionStateSnapshot<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never> {
+    interaction: string;
+    descriptor: InteractionDescriptor;
+    handle: InteractionHandle<Params, DefaultedKeys>;
+    draft: InteractionHandle<Params, DefaultedKeys>["draft"];
+    values: InteractionHandle<Params, DefaultedKeys>["values"];
+    status: InteractionHandle<Params, DefaultedKeys>["status"];
+    available: boolean;
+    isReady: boolean;
+    isArmed: boolean;
+    inputKeys: readonly string[];
+    missingInputs: readonly string[];
+    readyFrontier: readonly string[];
+    blockedInputs: readonly string[];
+    hasInputs: boolean;
+}
+interface InteractionStateProps<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never> {
+    unavailable: ReactNode;
+    children: (state: InteractionStateSnapshot<Params, DefaultedKeys>) => ReactNode;
+}
+declare function InteractionState<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never>({ children, unavailable }: InteractionStateProps<Params, DefaultedKeys>): react_jsx_runtime.JSX.Element;
+type InteractionFormPrimitiveProps<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never> = BoundInteractionFormProps<Params, DefaultedKeys>;
+declare function InteractionFormPrimitive<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never>(props: InteractionFormPrimitiveProps<Params, DefaultedKeys>): react_jsx_runtime.JSX.Element | null;
+type InteractionFieldPrimitiveProps<Params extends InteractionParamsShape = InteractionParamsShape, Input extends keyof Params & string = keyof Params & string> = Omit<InteractionFieldProps<Params, Input>, "descriptor" | "handle" | "inputKey"> & {
+    input: Input;
+};
+declare function InteractionFieldPrimitive<Params extends InteractionParamsShape = InteractionParamsShape, Input extends keyof Params & string = keyof Params & string>({ input, ...props }: InteractionFieldPrimitiveProps<Params, Input>): react_jsx_runtime.JSX.Element | null;
+type InteractionSubmitProps = PrimitiveCommonProps & ButtonHTMLAttributes<HTMLButtonElement> & {
+    params?: InteractionParamsShape | (() => InteractionParamsShape | null | undefined);
+    onSubmitSuccess?: InteractionSubmitCallbacks["onSubmitSuccess"];
+    onSubmitError?: InteractionSubmitCallbacks["onSubmitError"];
+};
+declare function InteractionSubmit({ disabled, onClick, params, onSubmitSuccess, onSubmitError, ...props }: InteractionSubmitProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
 type InteractionInputProps = PrimitiveCommonProps & Omit<InputHTMLAttributes<HTMLInputElement>, "name"> & {
     name: string;
     parse?: (value: string) => unknown;
@@ -865,21 +1528,25 @@ type InteractionInputProps = PrimitiveCommonProps & Omit<InputHTMLAttributes<HTM
 declare function InteractionInput({ name, parse, onChange, disabled, ...props }: InteractionInputProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
 type InteractionCardInputProps<Input extends string = InteractionInputKey> = PrimitiveCommonProps & ButtonHTMLAttributes<HTMLButtonElement> & {
     input: Input;
-    value?: string;
-    card?: string;
+    unsafeCardId?: string;
     selected?: boolean;
     onSelectedChange?: (selected: boolean) => void;
 };
-declare function InteractionCardInput<Input extends string = InteractionInputKey>({ input, value, card, selected, onSelectedChange, onClick, disabled, children, ...props }: InteractionCardInputProps<Input>): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function InteractionCardInput<Input extends string = InteractionInputKey>({ input, unsafeCardId, selected, onSelectedChange, onClick, disabled, children, ...props }: InteractionCardInputProps<Input>): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
 declare const Interaction: {
     Root: typeof InteractionRoot;
+    State: typeof InteractionState;
+    Switch: typeof InteractionSwitch;
+    Dialog: typeof InteractionDialog;
     Trigger: typeof InteractionTrigger;
     Label: typeof InteractionLabel;
     Description: typeof InteractionDescription;
     UnavailableMessage: typeof InteractionUnavailableMessage;
     ValidationMessage: typeof InteractionValidationMessage;
     Input: typeof InteractionInput;
+    Field: typeof InteractionFieldPrimitive;
     CardInput: typeof InteractionCardInput;
+    Form: typeof InteractionFormPrimitive;
     Submit: typeof InteractionSubmit;
 };
 
@@ -903,9 +1570,9 @@ interface PlayerRosterBadge {
     tooltip?: string;
 }
 interface PlayerRosterEntry {
-    playerId: PlayerId$1;
+    playerId: PlayerId;
     name: string;
-    color?: string;
+    color?: HexColor;
     index: number;
     isActive: boolean;
     isCurrentPlayer: boolean;
@@ -920,10 +1587,10 @@ interface PlayerRosterRootProps {
     children: ReactNode;
     order?: "turn" | "self-first";
     include?: "all" | "self" | "opponents";
-    score?: (playerId: PlayerId$1) => number | undefined;
-    scoreLabel?: string | ((playerId: PlayerId$1) => string | undefined);
-    badges?: (playerId: PlayerId$1) => ReadonlyArray<PlayerRosterBadge | null | false | undefined>;
-    metadata?: (playerId: PlayerId$1) => Record<string, unknown> | undefined;
+    score?: (playerId: PlayerId) => number | undefined;
+    scoreLabel?: string | ((playerId: PlayerId) => string | undefined);
+    badges?: (playerId: PlayerId) => ReadonlyArray<PlayerRosterBadge | null | false | undefined>;
+    metadata?: (playerId: PlayerId) => Record<string, unknown> | undefined;
 }
 declare function PlayerRosterRoot({ children, order, include, score, scoreLabel, badges, metadata, }: PlayerRosterRootProps): react_jsx_runtime.JSX.Element;
 type PlayerRosterListProps = Omit<PrimitiveCommonProps, "children"> & Omit<HTMLAttributes<HTMLElement>, "children"> & {
@@ -964,31 +1631,54 @@ declare function PromptMessage(props: InteractionPartProps): react_jsx_runtime.J
 type PromptOptionProps<Option extends string = PromptOptionKey> = PrimitiveCommonProps & ButtonHTMLAttributes<HTMLButtonElement> & {
     value: Option;
     disableWhenUnavailable?: boolean;
-    onSubmitError?: (error: unknown) => void;
-    onSubmitSuccess?: () => void;
+    onSubmitError?: InteractionSubmitCallbacks["onSubmitError"];
+    onSubmitSuccess?: InteractionSubmitCallbacks["onSubmitSuccess"];
 };
 declare function PromptOption<Option extends string = PromptOptionKey>({ value, disabled, disableWhenUnavailable, onClick, onSubmitError, onSubmitSuccess, children, ...props }: PromptOptionProps<Option>): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
-declare function PromptOptions({ children, }: {
-    children?: (option: {
-        id: string;
-        label?: string;
-    }) => ReactNode;
-}): react_jsx_runtime.JSX.Element;
+interface PromptOptionRenderItem {
+    id: string;
+    label?: string;
+}
+interface PromptOptionsProps {
+    children: (option: PromptOptionRenderItem) => ReactNode;
+}
+declare function PromptOptions({ children }: PromptOptionsProps): react_jsx_runtime.JSX.Element;
+type PromptDialogState = DialogLifecycleState;
+interface PromptDialogRenderState<Prompt extends string = PromptKey> {
+    prompt: Prompt;
+    state: PromptDialogState;
+    open: boolean;
+    minimized: boolean;
+    dismissed: boolean;
+    setOpen: (open: boolean) => void;
+    restore: () => void;
+    minimize: () => void;
+    dismiss: () => void;
+}
+interface PromptDialogProps<Prompt extends string = PromptKey> {
+    prompt: Prompt;
+    defaultOpen?: boolean;
+    onStateChange?: (state: PromptDialogState) => void;
+    children: (state: PromptDialogRenderState<Prompt>) => ReactNode;
+}
+declare function PromptDialog<Prompt extends string = PromptKey>({ prompt, defaultOpen, onStateChange, children, }: PromptDialogProps<Prompt>): react_jsx_runtime.JSX.Element;
 declare function PromptInboxRoot({ children }: {
     children: ReactNode;
 }): react_jsx_runtime.JSX.Element;
 declare function PromptInboxEmpty({ children }: {
     children?: ReactNode;
 }): react_jsx_runtime.JSX.Element | null;
-declare function PromptInboxItems({ children, }: {
-    children?: (prompt: InteractionDescriptor) => ReactNode;
-}): react_jsx_runtime.JSX.Element;
+interface PromptInboxItemsProps {
+    children: (prompt: InteractionDescriptor) => ReactNode;
+}
+declare function PromptInboxItems({ children }: PromptInboxItemsProps): react_jsx_runtime.JSX.Element;
 declare const Prompt: {
     Root: typeof PromptRoot;
     Title: typeof PromptTitle;
     Message: typeof PromptMessage;
     Option: typeof PromptOption;
     Options: typeof PromptOptions;
+    Dialog: typeof PromptDialog;
 };
 declare const PromptInbox: {
     Root: typeof PromptInboxRoot;
@@ -996,6 +1686,36 @@ declare const PromptInbox: {
     Items: typeof PromptInboxItems;
 };
 
+type DiceValue = number | null | undefined;
+interface DiceState {
+    values: ReadonlyArray<number | undefined> | undefined;
+    
+    sum: number | undefined;
+    diceCount: number;
+    allRolled: boolean;
+}
+interface DiceRootProps {
+    values?: readonly DiceValue[] | null;
+    
+    count?: number;
+    children: ReactNode;
+}
+interface DiceValuesProps {
+    children: (state: DiceState) => ReactNode;
+}
+interface DiceComponents {
+    Root(props: DiceRootProps): ReactNode;
+    Values(props: DiceValuesProps): ReactNode;
+}
+declare function normalizeDiceState({ values, count, }: {
+    values?: readonly DiceValue[] | null;
+    count?: number;
+}): DiceState;
+declare function DiceRoot({ values, count, children }: DiceRootProps): react_jsx_runtime.JSX.Element;
+declare function useDicePrimitiveContext(): DiceState;
+declare function DiceValues({ children }: DiceValuesProps): ReactNode;
+declare const Dice: DiceComponents;
+
 interface ZoneContextValue {
     zone: string;
     snapshot: ZoneHandlesSnapshot | null;
@@ -1004,22 +1724,114 @@ interface ZoneCardContextValue {
     zone: string;
     cardId: string;
 }
+
+type ZoneCardRenderItem<CardIdValue extends string = string, CardTypeValue extends string = string, Properties extends Record<string, unknown> = Record<string, unknown>> = HydratedZoneCardRenderItem<CardIdValue, CardTypeValue, Properties> | HiddenZoneCardRenderItem<CardIdValue>;
+interface HydratedZoneCardRenderItem<CardIdValue extends string = string, CardTypeValue extends string = string, Properties extends Record<string, unknown> = Record<string, unknown>> extends ViewCard<CardIdValue, CardTypeValue, Properties> {
+    zone: string;
+    index: number;
+    hidden: false;
+    playable: boolean;
+    interactions: readonly InteractionDescriptor[];
+}
+interface HiddenZoneCardRenderItem<CardIdValue extends string = string> {
+    id: CardIdValue;
+    zone: string;
+    index: number;
+    hidden: true;
+}
+interface ZonePileContextValue {
+    zone: string;
+    label: string;
+    count: number;
+    cards: readonly string[];
+    items: readonly ZoneCardRenderItem[];
+    hasVisibleCards: boolean;
+    isHidden: boolean;
+    description: string | null;
+}
 declare function useZonePrimitiveContext(): ZoneContextValue;
+declare function useOptionalZonePrimitiveContext(): ZoneContextValue | null;
 declare function useZoneCardContext(): ZoneCardContextValue | null;
+declare function useZonePileContext(): ZonePileContextValue;
 interface ZoneRootProps<Zone extends string = ZoneKey> extends PrimitiveCommonProps, HTMLAttributes<HTMLElement> {
     zone: Zone;
 }
 declare function ZoneRoot<Zone extends string = ZoneKey>({ zone, children, ...props }: ZoneRootProps<Zone>): react_jsx_runtime.JSX.Element;
-type ZoneListProps = PrimitiveCommonProps & HTMLAttributes<HTMLElement>;
-declare function ZoneList({ children, ...props }: ZoneListProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+interface ZoneListProps extends Omit<PrimitiveCommonProps, "children">, Omit<HTMLAttributes<HTMLElement>, "children"> {
+    children?: ReactNode | ((card: ZoneCardRenderItem) => ReactNode);
+    empty?: ReactNode;
+    sort?: (a: ZoneCardRenderItem, b: ZoneCardRenderItem) => number;
+}
+declare function ZoneList({ children, empty, sort, ...props }: ZoneListProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
 interface ZoneItemProps extends PrimitiveCommonProps, HTMLAttributes<HTMLElement> {
-    card: string;
+    card: string | ZoneCardRenderItem;
 }
 declare function ZoneItem({ card, children, ...props }: ZoneItemProps): react_jsx_runtime.JSX.Element;
+interface ZoneCardAtProps<Zone extends string = ZoneKey> extends Omit<ZoneItemProps, "card" | "children"> {
+    zone?: Zone;
+    index: number;
+    children?: ReactNode | ((card: ZoneCardRenderItem) => ReactNode);
+    empty?: ReactNode;
+}
+declare function ZoneCardAt<Zone extends string = ZoneKey>({ zone, ...props }: ZoneCardAtProps<Zone>): react_jsx_runtime.JSX.Element;
+type ZoneTopCardProps<Zone extends string = ZoneKey> = Omit<ZoneCardAtProps<Zone>, "index">;
+declare function ZoneTopCard<Zone extends string = ZoneKey>(props: ZoneTopCardProps<Zone>): react_jsx_runtime.JSX.Element;
+type ZoneCardActionExtraInputs = Record<string, unknown> | ((cardId: string) => Record<string, unknown>);
+interface ZoneCardActionProps<Card extends string = string> extends PrimitiveCommonProps, Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onSelect"> {
+    card?: Card;
+    interaction?: string;
+    input?: string;
+    extraInputs?: ZoneCardActionExtraInputs;
+    onSelect?: (result: ZoneCardActionResult) => void;
+    onSelectError?: (error: unknown) => void;
+}
+type ZoneCardActionResult = {
+    status: "none";
+} | {
+    status: "pending";
+    interactionKey: string;
+    descriptor: InteractionDescriptor;
+    missingInputs: readonly string[];
+} | {
+    status: "submitted";
+    interactionKey: string;
+    descriptor: InteractionDescriptor;
+};
+declare function ZoneCardAction<Card extends string = string>({ card, interaction, input, extraInputs, onSelect, onSelectError, disabled, onClick, children, ...props }: ZoneCardActionProps<Card>): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+interface ZonePileRootProps<Zone extends string = ZoneKey> extends Omit<ZoneRootProps<Zone>, "children"> {
+    label: string;
+    children?: ReactNode;
+    hiddenDescription?: string | null;
+    emptyDescription?: string | null;
+    visibleDescription?: ((count: number) => string) | null;
+}
+declare function ZonePileRoot<Zone extends string = ZoneKey>({ zone, label, hiddenDescription, emptyDescription, visibleDescription, children, ...props }: ZonePileRootProps<Zone>): react_jsx_runtime.JSX.Element;
+interface ZonePileTriggerProps extends PrimitiveCommonProps, ButtonHTMLAttributes<HTMLButtonElement> {
+}
+declare function ZonePileTrigger({ children, ...props }: ZonePileTriggerProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+type ZonePileLabelProps = PrimitiveCommonProps & HTMLAttributes<HTMLElement>;
+declare function ZonePileLabel({ children, ...props }: ZonePileLabelProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+type ZonePileCountProps = PrimitiveCommonProps & HTMLAttributes<HTMLElement>;
+declare function ZonePileCount({ children, ...props }: ZonePileCountProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+type ZonePileDescriptionProps = PrimitiveCommonProps & HTMLAttributes<HTMLElement>;
+declare function ZonePileDescription({ children, ...props }: ZonePileDescriptionProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
+interface ZonePileCardsProps extends Omit<ZoneListProps, "children"> {
+    renderCard: (card: ZoneCardRenderItem) => ReactNode;
+}
+declare function ZonePileCards({ renderCard, ...props }: ZonePileCardsProps): react_jsx_runtime.JSX.Element | null;
 declare const Zone: {
     Root: typeof ZoneRoot;
     List: typeof ZoneList;
     Item: typeof ZoneItem;
+    CardAt: typeof ZoneCardAt;
+    TopCard: typeof ZoneTopCard;
+    CardAction: typeof ZoneCardAction;
+    PileRoot: typeof ZonePileRoot;
+    PileTrigger: typeof ZonePileTrigger;
+    PileLabel: typeof ZonePileLabel;
+    PileCount: typeof ZonePileCount;
+    PileDescription: typeof ZonePileDescription;
+    PileCards: typeof ZonePileCards;
 };
 
 interface DreamboardUIRegister {
@@ -1030,6 +1842,7 @@ interface UIContract {
     inputs?: UIContractBucket;
     prompts?: UIContractBucket;
     promptOptions?: UIContractBucket;
+    players?: UIContractBucket;
     zones?: UIContractBucket;
     cards?: UIContractBucket;
     phases?: UIContractBucket;
@@ -1039,339 +1852,158 @@ type RegisteredUIContract = DreamboardUIRegister extends {
     ui: infer Registered extends UIContract;
 } ? Registered : UIContract;
 type BucketOf<Contract extends UIContract, Key extends keyof UIContract> = NonNullable<Contract[Key]> extends UIContractBucket ? NonNullable<Contract[Key]> : UIContractBucket;
-type StringKeysOrFallback<Bucket extends UIContractBucket> = string extends Extract<keyof Bucket, string> ? string : Extract<keyof Bucket, string>;
+type StringKeyOf<Bucket extends UIContractBucket> = Extract<keyof Bucket, string>;
+type StringKeysOrFallback<Bucket extends UIContractBucket> = [
+    StringKeyOf<Bucket>
+] extends [never] ? string : string extends StringKeyOf<Bucket> ? string : StringKeyOf<Bucket>;
 type RegisteredUI = RegisteredUIContract;
 type InteractionKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "interactions">>;
 type InteractionInputKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "inputs">>;
 type PromptKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "prompts">>;
 type PromptOptionKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "promptOptions">>;
+type PlayerKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "players">>;
 type ZoneKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "zones">>;
 type CardKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "cards">>;
 type PhaseKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "phases">>;
 type BoardTargetKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "boardTargets">>;
-type TypedInteraction<Contract extends UIContract> = Omit<typeof Interaction, "Root" | "CardInput"> & {
-    Root<Interaction extends InteractionKey<Contract>>(props: InteractionRootProps<Interaction>): ReactElement | null;
-    CardInput<Input extends InteractionInputKey<Contract>>(props: Omit<InteractionCardInputProps, "input"> & {
-        input: Input;
-    }): ReactElement;
-};
-type TypedPrompt<Contract extends UIContract> = Omit<typeof Prompt, "Root" | "Option"> & {
-    Root<Prompt extends PromptKey<Contract>>(props: PromptRootProps<Prompt>): ReactElement | null;
-    Option<Option extends PromptOptionKey<Contract>>(props: Omit<PromptOptionProps, "value"> & {
-        value: Option;
-    }): ReactElement;
-};
-type TypedPromptInbox = typeof PromptInbox;
-type TypedPlayerRoster = PlayerRosterComponents;
-type TypedPhase<Contract extends UIContract> = Omit<typeof Phase, "Switch"> & {
-    Switch(props: PhaseSwitchProps<PhaseKey<Contract>>): ReactElement | null;
-};
-type TypedZone<Contract extends UIContract> = Omit<typeof Zone, "Root"> & {
-    Root<Zone extends ZoneKey<Contract>>(props: Omit<ZoneRootProps, "zone"> & {
-        zone: Zone;
-    }): ReactElement;
-};
-type TypedBoard<Contract extends UIContract> = Omit<typeof Board, "Target"> & {
-    Target<Target extends BoardTargetKey<Contract>>(props: Omit<BoardTargetProps, "value"> & {
-        value: Target;
-    }): ReactElement;
-};
-interface DreamboardUI<Contract extends UIContract = RegisteredUI> {
-    readonly contract: Contract;
-    readonly Interaction: TypedInteraction<Contract>;
-    readonly Prompt: TypedPrompt<Contract>;
-    readonly PromptInbox: TypedPromptInbox;
-    readonly PlayerRoster: TypedPlayerRoster;
-    readonly PromptDialogHost: (props: PromptDialogHostProps) => ReactElement | null;
-    readonly Phase: TypedPhase<Contract>;
-    readonly Zone: TypedZone<Contract>;
-    readonly Board: TypedBoard<Contract>;
-}
-declare function createDreamboardUI<const Contract extends UIContract>(contract: Contract): DreamboardUI<Contract>;
-
-type RuntimeFields = Record<string, unknown>;
-interface GeneratedTiledEdgeStateLike<SpaceIdValue extends string = string, EdgeIdValue extends string = string, Fields = RuntimeFields> {
-    id: EdgeIdValue;
-    spaceIds: readonly SpaceIdValue[];
-    typeId?: EdgeTypeId | null;
-    label?: string | null;
-    ownerId?: PlayerId$1 | null;
-    fields?: Fields;
-}
-interface GeneratedTiledVertexStateLike<SpaceIdValue extends string = string, VertexIdValue extends string = string, Fields = RuntimeFields> {
-    id: VertexIdValue;
-    spaceIds: readonly SpaceIdValue[];
-    typeId?: VertexTypeId | null;
-    label?: string | null;
-    ownerId?: PlayerId$1 | null;
-    fields?: Fields;
-}
-interface GeneratedHexSpaceStateLike<SpaceIdValue extends string = string, Fields = RuntimeFields> {
-    id: SpaceIdValue;
-    q: number;
-    r: number;
-    typeId?: SpaceTypeId | null;
-    label?: string | null;
-    ownerId?: PlayerId$1 | null;
-    fields?: Fields;
-}
-interface GeneratedSquareSpaceStateLike<SpaceIdValue extends string = string, Fields = RuntimeFields> {
-    id: SpaceIdValue;
-    row: number;
-    col: number;
-    typeId?: SpaceTypeId | null;
-    label?: string | null;
-    ownerId?: PlayerId$1 | null;
-    fields?: Fields;
-}
-interface GeneratedHexBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields> {
-    id: BoardIdValue;
-    layout?: "hex";
-    orientation?: "pointy-top" | "flat-top";
-    spaces: Readonly<Record<SpaceIdValue, GeneratedHexSpaceStateLike<SpaceIdValue, SpaceFields>>>;
-    edges: ReadonlyArray<HexEdgeState<BoardIdValue, SpaceIdValue, EdgeIdValue, EdgeFields> | GeneratedTiledEdgeStateLike<SpaceIdValue, EdgeIdValue, EdgeFields>>;
-    vertices: ReadonlyArray<HexVertexState<BoardIdValue, SpaceIdValue, VertexIdValue, VertexFields> | GeneratedTiledVertexStateLike<SpaceIdValue, VertexIdValue, VertexFields>>;
-}
-interface AuthoredHexBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields, SpaceView = unknown> {
-    id: BoardIdValue;
-    layout?: "hex";
-    orientation?: "pointy-top" | "flat-top";
-    tiles: ReadonlyArray<HexTileState<BoardIdValue, SpaceIdValue, SpaceFields, SpaceView>>;
-    edges: ReadonlyArray<HexEdgeState<BoardIdValue, SpaceIdValue, EdgeIdValue, EdgeFields> | GeneratedTiledEdgeStateLike<SpaceIdValue, EdgeIdValue, EdgeFields>>;
-    vertices: ReadonlyArray<HexVertexState<BoardIdValue, SpaceIdValue, VertexIdValue, VertexFields> | GeneratedTiledVertexStateLike<SpaceIdValue, VertexIdValue, VertexFields>>;
-}
-type HexBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields> = AuthoredHexBoardInput<BoardIdValue, SpaceIdValue, EdgeIdValue, VertexIdValue, SpaceFields, EdgeFields, VertexFields> | GeneratedHexBoardInput<BoardIdValue, SpaceIdValue, EdgeIdValue, VertexIdValue, SpaceFields, EdgeFields, VertexFields>;
-interface GeneratedSquareBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, PieceIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields, PieceFields = RuntimeFields> {
-    id: BoardIdValue;
-    layout?: "square";
-    spaces: Readonly<Record<SpaceIdValue, GeneratedSquareSpaceStateLike<SpaceIdValue, SpaceFields>>>;
-    edges: ReadonlyArray<SquareEdgeState<SpaceIdValue, EdgeIdValue, EdgeFields> | GeneratedTiledEdgeStateLike<SpaceIdValue, EdgeIdValue, EdgeFields>>;
-    vertices: ReadonlyArray<SquareVertexState<SpaceIdValue, VertexIdValue, VertexFields> | GeneratedTiledVertexStateLike<SpaceIdValue, VertexIdValue, VertexFields>>;
-    pieces?: ReadonlyArray<SquarePieceState<PieceIdValue, PieceFields>>;
-}
-interface AuthoredSquareBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, PieceIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields, PieceFields = RuntimeFields> {
-    id: BoardIdValue;
-    layout?: "square";
-    rows: number;
-    cols: number;
-    cells: ReadonlyArray<SquareCellState<SpaceIdValue, SpaceFields>>;
-    edges: ReadonlyArray<SquareEdgeState<SpaceIdValue, EdgeIdValue, EdgeFields> | GeneratedTiledEdgeStateLike<SpaceIdValue, EdgeIdValue, EdgeFields>>;
-    vertices: ReadonlyArray<SquareVertexState<SpaceIdValue, VertexIdValue, VertexFields> | GeneratedTiledVertexStateLike<SpaceIdValue, VertexIdValue, VertexFields>>;
-    pieces: ReadonlyArray<SquarePieceState<PieceIdValue, PieceFields>>;
-}
-type SquareBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, PieceIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields, PieceFields = RuntimeFields> = AuthoredSquareBoardInput<BoardIdValue, SpaceIdValue, EdgeIdValue, VertexIdValue, PieceIdValue, SpaceFields, EdgeFields, VertexFields, PieceFields> | GeneratedSquareBoardInput<BoardIdValue, SpaceIdValue, EdgeIdValue, VertexIdValue, PieceIdValue, SpaceFields, EdgeFields, VertexFields, PieceFields>;
-type AnyHexBoardInput = HexBoardInput<string, string, string, string, RuntimeFields, RuntimeFields, RuntimeFields>;
-type AnySquareBoardInput = SquareBoardInput<string, string, string, string, string, RuntimeFields, RuntimeFields, RuntimeFields, RuntimeFields>;
-type BoardIdOf<TBoard> = TBoard extends {
-    id: infer Id extends string;
-} ? Id : string;
-type SpaceRecordValueOf<TBoard> = TBoard extends {
-    spaces: Readonly<Record<string, infer Space>>;
-} ? Space : never;
-type TileValueOf<TBoard> = TBoard extends {
-    tiles: ReadonlyArray<infer Tile>;
-} ? Tile : never;
-type CellValueOf<TBoard> = TBoard extends {
-    cells: ReadonlyArray<infer Cell>;
-} ? Cell : never;
-type EdgeValueOf<TBoard> = TBoard extends {
-    edges: ReadonlyArray<infer Edge>;
-} ? Edge : never;
-type VertexValueOf<TBoard> = TBoard extends {
-    vertices: ReadonlyArray<infer Vertex>;
-} ? Vertex : never;
-type PieceValueOf<TBoard> = TBoard extends {
-    pieces?: ReadonlyArray<infer Piece>;
-} ? Piece : never;
-type BoardSpaceIdOf<TBoard> = SpaceRecordValueOf<TBoard> extends {
-    id: infer Id extends string;
-} ? Id : TileValueOf<TBoard> extends {
-    id: infer Id extends string;
-} ? Id : CellValueOf<TBoard> extends {
-    id: infer Id extends string;
-} ? Id : never;
-type BoardEdgeIdOf<TBoard> = EdgeValueOf<TBoard> extends {
-    id: infer Id extends string;
-} ? Id : never;
-type BoardVertexIdOf<TBoard> = VertexValueOf<TBoard> extends {
-    id: infer Id extends string;
-} ? Id : never;
-type HexTilePropertiesOf<TBoard> = SpaceRecordValueOf<TBoard> extends {
-    fields?: infer Fields;
-} ? Fields : TileValueOf<TBoard> extends {
-    properties?: infer Properties;
-} ? Properties : RuntimeFields;
-type HexTileViewOf<TBoard> = TileValueOf<TBoard> extends {
-    view: infer View;
-} ? View : TileValueOf<TBoard> extends {
-    view?: infer View;
-} ? View | undefined : unknown;
-type HexEdgePropertiesOf<TBoard> = EdgeValueOf<TBoard> extends {
-    fields?: infer Fields;
-} ? Fields : EdgeValueOf<TBoard> extends {
-    properties?: infer Properties;
-} ? Properties : RuntimeFields;
-type HexVertexPropertiesOf<TBoard> = VertexValueOf<TBoard> extends {
-    fields?: infer Fields;
-} ? Fields : VertexValueOf<TBoard> extends {
-    properties?: infer Properties;
-} ? Properties : RuntimeFields;
-type SquareCellPropertiesOf<TBoard> = SpaceRecordValueOf<TBoard> extends {
-    fields?: infer Fields;
-} ? Fields : CellValueOf<TBoard> extends {
-    properties?: infer Properties;
-} ? Properties : RuntimeFields;
-type SquareEdgePropertiesOf<TBoard> = EdgeValueOf<TBoard> extends {
-    fields?: infer Fields;
-} ? Fields : EdgeValueOf<TBoard> extends {
-    properties?: infer Properties;
-} ? Properties : RuntimeFields;
-type SquareVertexPropertiesOf<TBoard> = VertexValueOf<TBoard> extends {
-    fields?: infer Fields;
-} ? Fields : VertexValueOf<TBoard> extends {
-    properties?: infer Properties;
-} ? Properties : RuntimeFields;
-type SquarePiecePropertiesOf<TBoard> = PieceValueOf<TBoard> extends {
-    properties?: infer Properties;
-} ? Properties : RuntimeFields;
-
-type NormalizedHexTileOf<TBoard extends AnyHexBoardInput> = Omit<HexTileState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, HexTilePropertiesOf<TBoard>, HexTileViewOf<TBoard>>, "view"> & {
-    view: HexTileViewOf<TBoard>;
+type TypedZoneCardRenderItem<Contract extends UIContract> = ZoneCardRenderItem<CardKey<Contract> & string> extends infer Item ? Item extends {
+    id: string;
+    zone: string;
+} ? Omit<Item, "id" | "zone"> & {
+    id: CardKey<Contract>;
+    zone: ZoneKey<Contract>;
+} : never : never;
+type TypedInteraction<Contract extends UIContract> = Omit<typeof Interaction, "Root" | "CardInput" | "Dialog" | "Field" | "Form" | "Switch"> & {
+    Root<Interaction extends InteractionKey<Contract>>(props: InteractionRootProps<Interaction>): ReactElement | null;
+    Switch(props: Omit<InteractionSwitchProps<InteractionKey<Contract>>, "routes"> & {
+        routes: InteractionRouteMap<InteractionKey<Contract>>;
+    }): ReactElement;
+    CardInput<Input extends InteractionInputKey<Contract>>(props: Omit<InteractionCardInputProps, "input" | "unsafeCardId"> & {
+        input: Input;
+        unsafeCardId?: CardKey<Contract>;
+    }): ReactElement;
+    Dialog<Interaction extends InteractionKey<Contract>>(props: InteractionDialogProps<Interaction>): ReactElement;
+    Field<Input extends InteractionInputKey<Contract>>(props: Omit<InteractionFieldPrimitiveProps, "input"> & {
+        input: Input;
+    }): ReactElement | null;
+    Form(props: InteractionFormPrimitiveProps): ReactElement | null;
 };
-type NormalizedHexEdgeOf<TBoard extends AnyHexBoardInput> = HexEdgeState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, BoardEdgeIdOf<TBoard>, HexEdgePropertiesOf<TBoard>>;
-type NormalizedHexVertexOf<TBoard extends AnyHexBoardInput> = HexVertexState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, BoardVertexIdOf<TBoard>, HexVertexPropertiesOf<TBoard>>;
-type NormalizedSquareCellOf<TBoard extends AnySquareBoardInput> = SquareCellState<BoardSpaceIdOf<TBoard>, SquareCellPropertiesOf<TBoard>>;
-type NormalizedSquareEdgeOf<TBoard extends AnySquareBoardInput> = SquareEdgeState<BoardSpaceIdOf<TBoard>, BoardEdgeIdOf<TBoard>, SquareEdgePropertiesOf<TBoard>>;
-type NormalizedSquareVertexOf<TBoard extends AnySquareBoardInput> = SquareVertexState<BoardSpaceIdOf<TBoard>, BoardVertexIdOf<TBoard>, SquareVertexPropertiesOf<TBoard>>;
-type NormalizedSquarePieceOf<TBoard extends AnySquareBoardInput> = SquarePieceState<PieceValueOf<TBoard> extends {
-    id: infer PieceIdValue extends string;
-} ? PieceIdValue : string, SquarePiecePropertiesOf<TBoard>>;
-type NormalizedHexBoard<TBoard extends AnyHexBoardInput> = Omit<Pick<HexBoardState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, BoardEdgeIdOf<TBoard>, BoardVertexIdOf<TBoard>, HexTilePropertiesOf<TBoard>, HexEdgePropertiesOf<TBoard>, HexVertexPropertiesOf<TBoard>>, "id" | "tiles" | "edges" | "vertices">, "tiles"> & {
-    tiles: ReadonlyArray<NormalizedHexTileOf<TBoard>>;
-    orientation?: "pointy-top" | "flat-top";
+type TypedPrompt<Contract extends UIContract> = Omit<typeof Prompt, "Root" | "Option" | "Options" | "Dialog"> & {
+    Root<Prompt extends PromptKey<Contract>>(props: PromptRootProps<Prompt>): ReactElement | null;
+    Option<Option extends PromptOptionKey<Contract>>(props: Omit<PromptOptionProps, "value"> & {
+        value: Option;
+    }): ReactElement;
+    Options(props: Omit<PromptOptionsProps, "children"> & {
+        children: (option: Omit<PromptOptionRenderItem, "id"> & {
+            id: PromptOptionKey<Contract>;
+        }) => ReactNode;
+    }): ReactElement;
+    Dialog<Prompt extends PromptKey<Contract>>(props: PromptDialogProps<Prompt>): ReactElement;
 };
-type NormalizedSquareBoard<TBoard extends AnySquareBoardInput> = Pick<SquareBoardState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, BoardEdgeIdOf<TBoard>, BoardVertexIdOf<TBoard>, PieceValueOf<TBoard> extends {
-    id: infer PieceIdValue extends string;
-} ? PieceIdValue : string, SquareCellPropertiesOf<TBoard>, SquareEdgePropertiesOf<TBoard>, SquareVertexPropertiesOf<TBoard>, SquarePiecePropertiesOf<TBoard>>, "id" | "rows" | "cols" | "cells" | "edges" | "vertices" | "pieces">;
-declare function normalizeHexBoardInput<TBoard extends AnyHexBoardInput>(board: TBoard): NormalizedHexBoard<TBoard>;
-declare function normalizeSquareBoardInput<TBoard extends AnySquareBoardInput>(board: TBoard): NormalizedSquareBoard<TBoard>;
-
-type BoardTopologyData = AnyHexBoardInput | AnySquareBoardInput;
-type BoardSpaceOf$1<TBoard extends BoardTopologyData> = TBoard extends AnyHexBoardInput ? NormalizedHexTileOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareCellOf<TBoard> : never;
-type BoardEdgeOf<TBoard extends BoardTopologyData> = TBoard extends AnyHexBoardInput ? NormalizedHexEdgeOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareEdgeOf<TBoard> : never;
-type BoardVertexOf<TBoard extends BoardTopologyData> = TBoard extends AnyHexBoardInput ? NormalizedHexVertexOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareVertexOf<TBoard> : never;
-type NormalizedBoardOf<TBoard extends BoardTopologyData> = TBoard extends AnyHexBoardInput ? NormalizedHexBoard<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareBoard<TBoard> : never;
-type BoardLayoutOf<TBoard extends BoardTopologyData> = TBoard extends AnyHexBoardInput ? "hex" : "square";
-interface UseBoardTopologyReturn<TBoard extends BoardTopologyData> {
-    layout: BoardLayoutOf<TBoard>;
-    board: NormalizedBoardOf<TBoard>;
-    getSpace: (spaceId: BoardSpaceIdOf<TBoard>) => BoardSpaceOf$1<TBoard> | undefined;
-    getEdge: (edgeId: BoardEdgeIdOf<TBoard>) => BoardEdgeOf<TBoard> | undefined;
-    getVertex: (vertexId: BoardVertexIdOf<TBoard>) => BoardVertexOf<TBoard> | undefined;
-    getAdjacentSpaces: (spaceId: BoardSpaceIdOf<TBoard>) => Array<BoardSpaceOf$1<TBoard>>;
-    getDistance: (fromSpaceId: BoardSpaceIdOf<TBoard>, toSpaceId: BoardSpaceIdOf<TBoard>) => number;
-    getSpaceEdges: (spaceId: BoardSpaceIdOf<TBoard>) => Array<BoardEdgeOf<TBoard>>;
-    getSpaceVertices: (spaceId: BoardSpaceIdOf<TBoard>) => Array<BoardVertexOf<TBoard>>;
-    getIncidentEdges: (vertexId: BoardVertexIdOf<TBoard>) => Array<BoardEdgeOf<TBoard>>;
-    getIncidentVertices: (edgeId: BoardEdgeIdOf<TBoard>) => Array<BoardVertexOf<TBoard>>;
-}
-declare function useBoardTopology<const TBoard extends BoardTopologyData>(board: TBoard): UseBoardTopologyReturn<TBoard>;
-
-declare function useHexBoard<const TBoard extends AnyHexBoardInput>(board: TBoard): {
-    board: NormalizedHexBoard<TBoard>;
-    getTile: (tileId: BoardSpaceIdOf<TBoard>) => NormalizedHexTileOf<TBoard> | undefined;
-    getTileAt: (q: number, r: number) => NormalizedHexTileOf<TBoard> | undefined;
-    getNeighbors: (tileId: BoardSpaceIdOf<TBoard>) => Array<NormalizedHexTileOf<TBoard>>;
-    getTilesInRange: (centerTileId: BoardSpaceIdOf<TBoard>, range: number) => Array<NormalizedHexTileOf<TBoard>>;
-    layout: TBoard extends AnyHexBoardInput ? "hex" : "square";
-    getSpace: (spaceId: BoardSpaceIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexTileOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareCellOf<TBoard> : never) | undefined;
-    getEdge: (edgeId: BoardEdgeIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexEdgeOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareEdgeOf<TBoard> : never) | undefined;
-    getVertex: (vertexId: BoardVertexIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexVertexOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareVertexOf<TBoard> : never) | undefined;
-    getAdjacentSpaces: (spaceId: BoardSpaceIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexTileOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareCellOf<TBoard> : never)[];
-    getDistance: (fromSpaceId: BoardSpaceIdOf<TBoard>, toSpaceId: BoardSpaceIdOf<TBoard>) => number;
-    getSpaceEdges: (spaceId: BoardSpaceIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexEdgeOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareEdgeOf<TBoard> : never)[];
-    getSpaceVertices: (spaceId: BoardSpaceIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexVertexOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareVertexOf<TBoard> : never)[];
-    getIncidentEdges: (vertexId: BoardVertexIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexEdgeOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareEdgeOf<TBoard> : never)[];
-    getIncidentVertices: (edgeId: BoardEdgeIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexVertexOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareVertexOf<TBoard> : never)[];
+type TypedPromptInbox<Contract extends UIContract> = Omit<typeof PromptInbox, "Items"> & {
+    Items(props: Omit<PromptInboxItemsProps, "children"> & {
+        children: (prompt: Omit<InteractionDescriptor, "interactionKey"> & {
+            interactionKey: PromptKey<Contract>;
+        }) => ReactNode;
+    }): ReactElement;
 };
-
-type NeighborMode = "orthogonal" | "diagonal" | "all";
-type DistanceMetric = "manhattan" | "chebyshev";
-declare function useSquareBoard<const TBoard extends AnySquareBoardInput>(board: TBoard): {
-    board: NormalizedSquareBoard<TBoard>;
-    getCell: (cellId: BoardSpaceIdOf<TBoard>) => NormalizedSquareCellOf<TBoard> | undefined;
-    getCellAt: (row: number, col: number) => NormalizedSquareCellOf<TBoard> | undefined;
-    getNeighbors: (cellId: BoardSpaceIdOf<TBoard>, mode?: NeighborMode) => NormalizedSquareCellOf<TBoard>[];
-    getDistance: (fromCellId: BoardSpaceIdOf<TBoard>, toCellId: BoardSpaceIdOf<TBoard>, metric?: DistanceMetric) => number;
-    layout: TBoard extends AnyHexBoardInput ? "hex" : "square";
-    getSpace: (spaceId: BoardSpaceIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexTileOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareCellOf<TBoard> : never) | undefined;
-    getEdge: (edgeId: BoardEdgeIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexEdgeOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareEdgeOf<TBoard> : never) | undefined;
-    getVertex: (vertexId: BoardVertexIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexVertexOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareVertexOf<TBoard> : never) | undefined;
-    getAdjacentSpaces: (spaceId: BoardSpaceIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexTileOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareCellOf<TBoard> : never)[];
-    getSpaceEdges: (spaceId: BoardSpaceIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexEdgeOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareEdgeOf<TBoard> : never)[];
-    getSpaceVertices: (spaceId: BoardSpaceIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexVertexOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareVertexOf<TBoard> : never)[];
-    getIncidentEdges: (vertexId: BoardVertexIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexEdgeOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareEdgeOf<TBoard> : never)[];
-    getIncidentVertices: (edgeId: BoardEdgeIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexVertexOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareVertexOf<TBoard> : never)[];
+type TypedPlayerRosterEntry<Player extends string> = Omit<PlayerRosterEntry, "playerId"> & {
+    playerId: Player;
 };
-
-type CardSize = "sm" | "md" | "lg";
-type HandLayout = "spread" | "stack" | "overlap";
-interface CardPositionProps {
-    
-    x: number;
-    
-    y: number;
-    
-    zIndex: number;
-    
-    transformOrigin: string;
-}
-interface UseHandLayoutOptions {
-    
-    cardCount: number;
-    
-    cardSize?: CardSize;
-    
-    layout?: HandLayout;
-    
-    containerPadding?: number;
-}
-interface UseHandLayoutReturn {
-    
-    containerRef: RefObject<HTMLDivElement | null>;
-    
-    cardsContainerRef: RefObject<HTMLDivElement | null>;
-    
-    containerWidth: number;
-    
-    cardOffset: number;
-    
-    totalWidth: number;
-    
-    useDrawerMode: boolean;
-    
-    cardDimensions: {
-        width: number;
-        height: number;
-    };
-    
-    constants: {
-        hoverLift: number;
-        selectedLift: number;
-    };
-    
-    hoveredIndex: number | null;
-    
-    handleMouseMove: (e: React.MouseEvent<HTMLDivElement>) => void;
-    
-    handleMouseLeave: () => void;
-    
-    getCardPosition: (index: number, isHovered: boolean, isSelected: boolean) => CardPositionProps;
+type TypedPlayerRosterRootProps<Player extends string> = Omit<PlayerRosterRootProps, "score" | "scoreLabel" | "badges" | "metadata"> & {
+    score?: (playerId: Player) => number | undefined;
+    scoreLabel?: string | ((playerId: Player) => string | undefined);
+    badges?: (playerId: Player) => ReadonlyArray<PlayerRosterBadge | null | false | undefined>;
+    metadata?: (playerId: Player) => Record<string, unknown> | undefined;
+};
+type TypedPlayerRosterListProps<Player extends string> = Omit<PlayerRosterListProps, "children"> & {
+    children?: (player: TypedPlayerRosterEntry<Player>) => ReactNode;
+};
+type TypedPlayerRosterPartProps<Player extends string> = Omit<PlayerRosterPartProps, "player"> & {
+    player: TypedPlayerRosterEntry<Player>;
+};
+type TypedPlayerRosterSwitchButtonProps<Player extends string> = Omit<PlayerRosterSwitchButtonProps, "player"> & {
+    player: TypedPlayerRosterEntry<Player>;
+};
+type TypedPlayerRoster<Contract extends UIContract> = Omit<PlayerRosterComponents, "Root" | "List" | "SwitchButton" | "Name" | "Score" | "Badges"> & {
+    Root(props: TypedPlayerRosterRootProps<PlayerKey<Contract>>): ReactElement | null;
+    List(props: TypedPlayerRosterListProps<PlayerKey<Contract>>): ReactElement;
+    SwitchButton(props: TypedPlayerRosterSwitchButtonProps<PlayerKey<Contract>>): ReactElement;
+    Name(props: TypedPlayerRosterPartProps<PlayerKey<Contract>>): ReactElement;
+    Score(props: TypedPlayerRosterPartProps<PlayerKey<Contract>>): ReactElement | null;
+    Badges(props: TypedPlayerRosterPartProps<PlayerKey<Contract>>): ReactElement | null;
+};
+type TypedPhase<Contract extends UIContract> = Omit<typeof Phase, "Switch"> & {
+    Switch(props: PhaseSwitchProps<PhaseKey<Contract>>): ReactElement | null;
+};
+type TypedZone<Contract extends UIContract> = Omit<typeof Zone, "Root" | "Item" | "CardAt" | "TopCard" | "CardAction" | "List" | "PileRoot" | "PileCards"> & {
+    Root<Zone extends ZoneKey<Contract>>(props: Omit<ZoneRootProps, "zone"> & {
+        zone: Zone;
+    }): ReactElement;
+    Item<Card extends CardKey<Contract>>(props: Omit<ZoneItemProps, "card"> & {
+        card: Card;
+    }): ReactElement;
+    CardAction<Card extends CardKey<Contract>>(props: Omit<ZoneCardActionProps, "card"> & {
+        card?: Card;
+    }): ReactElement;
+    CardAt<Zone extends ZoneKey<Contract>>(props: Omit<ZoneCardAtProps<Zone>, "zone" | "children"> & {
+        zone?: Zone;
+        children?: ReactNode | ((card: TypedZoneCardRenderItem<Contract>) => ReactNode);
+    }): ReactElement | null;
+    TopCard<Zone extends ZoneKey<Contract>>(props: Omit<ZoneCardAtProps<Zone>, "zone" | "index" | "children"> & {
+        zone?: Zone;
+        children?: ReactNode | ((card: TypedZoneCardRenderItem<Contract>) => ReactNode);
+    }): ReactElement | null;
+    List(props: Omit<ZoneListProps, "children"> & {
+        children?: ReactNode | ((card: TypedZoneCardRenderItem<Contract>) => ReactNode);
+    }): ReactElement;
+    PileRoot<Zone extends ZoneKey<Contract>>(props: Omit<ZonePileRootProps<Zone>, "zone"> & {
+        zone: Zone;
+    }): ReactElement;
+    PileCards(props: Omit<ZonePileCardsProps, "renderCard"> & {
+        renderCard: (card: TypedZoneCardRenderItem<Contract>) => ReactNode;
+    }): ReactElement | null;
+};
+type TypedBoard<Contract extends UIContract> = Omit<typeof Board, "Target" | "SpaceTarget" | "EdgeTarget" | "VertexTarget" | "HexGrid"> & {
+    Target<Target extends BoardTargetKey<Contract>>(props: Omit<BoardTargetProps, "value"> & {
+        value: Target;
+    }): ReactElement;
+    SpaceTarget<Target extends BoardTargetKey<Contract>>(props: Omit<BoardSpaceTargetProps, "value"> & {
+        value: Target;
+    }): ReactElement;
+    EdgeTarget<Target extends BoardTargetKey<Contract>>(props: Omit<BoardEdgeTargetProps, "value"> & {
+        value: Target;
+    }): ReactElement;
+    VertexTarget<Target extends BoardTargetKey<Contract>>(props: Omit<BoardVertexTargetProps, "value"> & {
+        value: Target;
+    }): ReactElement;
+    HexGrid<TBoard extends AnyHexBoardInput, TSpaceView extends {
+        id: BoardSpaceIdOf<TBoard>;
+    }>(props: Omit<BoardHexGridProps<TBoard, TSpaceView>, "interactions"> & {
+        interactions?: Exclude<BoardHexGridInteractionFilter, object> | {
+            edge?: ReadonlyArray<InteractionKey<Contract>>;
+            vertex?: ReadonlyArray<InteractionKey<Contract>>;
+            space?: ReadonlyArray<InteractionKey<Contract>>;
+        };
+    }): ReactElement;
+};
+type TypedGame<_Contract extends UIContract, View = unknown, Player extends string = PlayerKey<_Contract>, Phase extends string = PhaseKey<_Contract>> = Omit<typeof Game, "Root"> & {
+    Root(props: GameRootProps<View, Player, Phase>): ReactElement;
+};
+interface DreamboardUI<Contract extends UIContract = RegisteredUI> {
+    readonly contract: Contract;
+    Root(props: UIRootProps): ReactElement;
+    readonly Game: TypedGame<Contract>;
+    readonly Interaction: TypedInteraction<Contract>;
+    readonly Prompt: TypedPrompt<Contract>;
+    readonly PromptInbox: TypedPromptInbox<Contract>;
+    readonly PlayerRoster: TypedPlayerRoster<Contract>;
+    readonly Dice: DiceComponents;
+    readonly Phase: TypedPhase<Contract>;
+    readonly Zone: TypedZone<Contract>;
+    readonly Board: TypedBoard<Contract>;
 }
-
-declare function useHandLayout({ cardCount, cardSize, layout, containerPadding, }: UseHandLayoutOptions): UseHandLayoutReturn;
-
-declare function useIsMobile(breakpoint?: number): boolean;
+declare function createDreamboardUI<const Contract extends UIContract>(contract: Contract): DreamboardUI<Contract>;
 
 interface PanZoomTransform {
     
@@ -1436,32 +2068,6 @@ declare function calculateViewBox(bounds: {
     height: number;
 }, transform: PanZoomTransform): string;
 
-interface PluginRuntimeAPI extends RuntimeAPI {
-    
-    getSnapshot: () => PluginStateSnapshot | null;
-    
-    subscribeToState: (listener: (state: PluginStateSnapshot) => void) => () => void;
-    
-    _subscribeToSessionState: (listener: (state: PluginSessionState) => void) => () => void;
-    
-    restoreHistory?: (entryId: string) => void;
-}
-
-interface UsePluginRuntimeOptions {
-    
-    timeout?: number;
-}
-interface UsePluginRuntimeResult {
-    
-    runtime: PluginRuntimeAPI;
-    
-    isReady: boolean;
-    
-    error: string | null;
-}
-
-declare function usePluginRuntime(options?: UsePluginRuntimeOptions): UsePluginRuntimeResult;
-
 interface TrackSpace<SpaceIdValue extends string = string, Data = unknown> {
     id: SpaceIdValue;
     index: number;
@@ -1647,8 +2253,6 @@ declare function toTrackBoardData<TBoard extends GenericBoardLike, TPiece extend
     pieces: Array<TrackPiece<PieceIdOf<TPiece>, SpaceIdOf<TBoard>, PieceOwnerOf<TPiece>, PieceFieldsOf<TPiece>>>;
 };
 
-type PlayerId = string;
-
 interface PluginStateProviderProps {
     children: React__default.ReactNode;
     
@@ -1657,26 +2261,29 @@ interface PluginStateProviderProps {
 
 declare function PluginStateProvider({ children, loadingComponent, }: PluginStateProviderProps): react_jsx_runtime.JSX.Element;
 
-declare function usePluginState<T>(selector: (state: PluginStateSnapshot) => T): T;
-
-declare function usePluginActions(): {
-    
-    markNotificationRead: (notificationId: string) => void;
-    
-    switchPlayer: (playerId: string) => void;
-    
-    submitInteraction: (playerId: PlayerId, interactionId: string, params: unknown) => Promise<void>;
-};
-
 declare const RuntimeContext: React__default.Context<RuntimeAPI | null>;
 
-declare function useRuntimeContext(): RuntimeAPI;
-
 declare function RuntimeProvider({ runtime, children, }: {
     runtime: RuntimeAPI;
     children: React__default.ReactNode;
 }): react_jsx_runtime.JSX.Element;
 
+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>>>>;
+
 interface ThemeMeta {
     
     readonly id: string;
@@ -2041,53 +2648,6 @@ declare function useBoardTheme(): BoardTheme;
 
 declare function deriveBoardTheme(theme: Theme): BoardTheme;
 
-interface InteractionFieldRenderProps<Params extends InteractionParamsShape = InteractionParamsShape, Key extends keyof Params & string = keyof Params & string> {
-    descriptor: InteractionDescriptor;
-    input: InteractionInputDescriptor & {
-        key: Key;
-    };
-    handle: InteractionHandle<Params>;
-    value: Params[Key] | undefined;
-    setValue: (value: Params[Key]) => void;
-    clearValue: () => void;
-    errors: readonly string[];
-    missing: boolean;
-    disabled: boolean;
-}
-type InteractionFieldRenderMap<Params extends InteractionParamsShape = InteractionParamsShape> = Partial<{
-    [K in keyof Params & string]: (props: InteractionFieldRenderProps<Params, K>) => ReactNode;
-}>;
-interface InteractionFieldProps<Params extends InteractionParamsShape = InteractionParamsShape, Key extends keyof Params & string = keyof Params & string> {
-    descriptor: InteractionDescriptor;
-    inputKey: Key;
-    handle: InteractionHandle<Params>;
-    errors?: readonly string[];
-    missing?: boolean;
-    disabled?: boolean;
-    render?: InteractionFieldRenderMap<Params>[Key];
-}
-interface InteractionFormProps<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never> {
-    descriptor: InteractionDescriptor;
-    handle: InteractionHandle<Params, DefaultedKeys>;
-    fields?: ReadonlyArray<keyof Params & string>;
-    hiddenFields?: ReadonlyArray<keyof Params & string>;
-    renderFields?: InteractionFieldRenderMap<Params>;
-    title?: ReactNode;
-    description?: ReactNode;
-    submitLabel?: ReactNode;
-    cancelLabel?: ReactNode;
-    onCancel?: () => void;
-    onSubmitSuccess?: () => void;
-    disabled?: boolean;
-    accordion?: boolean;
-    defaultOpen?: boolean;
-    style?: CSSProperties;
-}
-declare function InteractionForm<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never>({ descriptor, handle, fields, hiddenFields, renderFields, title, description, submitLabel, cancelLabel, onCancel, onSubmitSuccess, disabled, accordion, defaultOpen, style, }: InteractionFormProps<Params, DefaultedKeys>): react_jsx_runtime.JSX.Element;
-declare function InteractionField<Params extends InteractionParamsShape = InteractionParamsShape, Key extends keyof Params & string = keyof Params & string>({ descriptor, inputKey, handle, errors, missing, disabled, render, }: InteractionFieldProps<Params, Key>): react_jsx_runtime.JSX.Element | null;
-declare function hasDefaultInteractionFormFields(descriptor: Pick<InteractionDescriptor, "inputs">): boolean;
-declare function defaultFormInputs(descriptor: Pick<InteractionDescriptor, "inputs">): InteractionInputDescriptor[];
-
 interface CardProps<CardData extends ViewCard = ViewCard> extends Omit<HTMLMotionProps<"button">, "children"> {
     card: CardData;
     selected?: boolean;
@@ -2095,11 +2655,68 @@ interface CardProps<CardData extends ViewCard = ViewCard> extends Omit<HTMLMotio
     size?: "sm" | "md" | "lg";
     faceDown?: boolean;
     renderContent?: (card: CardData) => React.ReactNode;
-    onCardClick?: (cardId: string) => void;
+    onCardClick?: (cardId: CardData["id"]) => void;
     "aria-label"?: string;
 }
 
-declare function Card<CardData extends ViewCard = ViewCard>({ card, selected, disabled, size, faceDown, renderContent, onCardClick, className, "aria-label": ariaLabel, ...motionProps }: CardProps<CardData>): react_jsx_runtime.JSX.Element;
+declare function Card<CardData extends ViewCard = ViewCard>({ card, selected, disabled, size, faceDown, renderContent, onCardClick, className, "aria-label": ariaLabel, ...motionProps }: CardProps<CardData>): react_jsx_runtime.JSX.Element;
+
+type CardSize = "sm" | "md" | "lg";
+type HandLayout = "spread" | "stack" | "overlap";
+interface CardPositionProps {
+    
+    x: number;
+    
+    y: number;
+    
+    zIndex: number;
+    
+    transformOrigin: string;
+}
+interface UseHandLayoutOptions {
+    
+    cardCount: number;
+    
+    cardSize?: CardSize;
+    
+    layout?: HandLayout;
+    
+    containerPadding?: number;
+}
+interface UseHandLayoutReturn {
+    
+    containerRef: RefObject<HTMLDivElement | null>;
+    
+    cardsContainerRef: RefObject<HTMLDivElement | null>;
+    
+    containerWidth: number;
+    
+    cardOffset: number;
+    
+    totalWidth: number;
+    
+    useDrawerMode: boolean;
+    
+    cardDimensions: {
+        width: number;
+        height: number;
+    };
+    
+    constants: {
+        hoverLift: number;
+        selectedLift: number;
+    };
+    
+    hoveredIndex: number | null;
+    
+    handleMouseMove: (e: React.MouseEvent<HTMLDivElement>) => void;
+    
+    handleMouseLeave: () => void;
+    
+    getCardPosition: (index: number, isHovered: boolean, isSelected: boolean) => CardPositionProps;
+}
+
+declare function useHandLayout({ cardCount, cardSize, layout, containerPadding, }: UseHandLayoutOptions): UseHandLayoutReturn;
 
 interface HandCardRenderProps<CardData extends ViewCard = ViewCard> {
     card: CardData;
@@ -2215,14 +2832,14 @@ interface GameSkeletonProps {
 declare function GameSkeleton({ variant, message, className, }: GameSkeletonProps): react_jsx_runtime.JSX.Element;
 
 type ToastType = "success" | "error" | "info" | "warning";
-interface Toast {
+interface ToastNotification {
     id: string;
     type: ToastType;
     message: string;
     duration?: number;
 }
 interface ToastContextValue {
-    toasts: Toast[];
+    toasts: ToastNotification[];
     show: (message: string, type?: ToastType, duration?: number) => void;
     dismiss: (id: string) => void;
     success: (message: string, duration?: number) => void;
@@ -2230,11 +2847,18 @@ interface ToastContextValue {
     info: (message: string, duration?: number) => void;
     warning: (message: string, duration?: number) => void;
 }
+type ToastActionsValue = ToastContextValue;
 interface ToastProviderProps {
     children: ReactNode;
 }
 declare function ToastProvider({ children }: ToastProviderProps): react_jsx_runtime.JSX.Element;
-declare function useToast(): ToastContextValue;
+interface ToastActionsProps {
+    children: (actions: ToastActionsValue) => ReactNode;
+}
+declare function ToastActions({ children }: ToastActionsProps): react_jsx_runtime.JSX.Element;
+declare const Toast: {
+    readonly Actions: typeof ToastActions;
+};
 
 interface ErrorBoundaryProps {
     children: ReactNode;
@@ -2480,30 +3104,74 @@ declare function DialogFooter({ className, ...props }: React$1.ComponentProps<"d
 declare function DialogTitle({ className, ...props }: React$1.ComponentProps<typeof Title>): react_jsx_runtime.JSX.Element;
 declare function DialogDescription({ className, ...props }: React$1.ComponentProps<typeof Description>): react_jsx_runtime.JSX.Element;
 
-interface ResourceDisplayConfig {
-    type: ResourceId;
+interface ResourceDisplayConfig<Resource extends string = ResourceId> {
+    type: Resource;
     label: string;
     icon: ReactNode | ComponentType<{
         className?: string;
         strokeWidth?: number;
-        "aria-hidden"?: string;
+        "aria-hidden"?: boolean | "true" | "false";
     }>;
     iconColor?: string;
     bgColor?: string;
     textColor?: string;
 }
-interface ResourceCounterProps {
-    resources: ResourceDisplayConfig[];
-    counts: Record<ResourceId, number>;
-    layout?: "row" | "grid" | "compact";
-    
-    columns?: number;
-    showZero?: boolean;
-    size?: "sm" | "md" | "lg";
-    onResourceClick?: (resourceType: ResourceId) => void;
+interface ResourceCounterItemState<Resource extends string = ResourceId> {
+    type: Resource;
+    label: string;
+    icon: ResourceDisplayConfig<Resource>["icon"];
+    iconColor?: string;
+    bgColor?: string;
+    textColor?: string;
+    count: number;
+    isZero: boolean;
+    interactive: boolean;
+    select: () => void;
+    renderIcon: (props?: ResourceIconProps) => ReactNode;
+    dataAttributes: {
+        "data-resource-id": Resource;
+        "data-resource-count": number;
+        "data-resource-zero": boolean | undefined;
+        "data-interactive": boolean | undefined;
+    };
+}
+interface ResourceIconProps {
     className?: string;
+    strokeWidth?: number;
+    "aria-hidden"?: boolean | "true" | "false";
 }
-declare function ResourceCounter({ resources, counts, layout, columns, showZero, size, onResourceClick, className, }: ResourceCounterProps): react_jsx_runtime.JSX.Element;
+type ResourceCounterRootProps<Resource extends string = ResourceId> = Omit<PrimitiveCommonProps, "children"> & Omit<HTMLAttributes<HTMLElement>, "children"> & {
+    resources: ReadonlyArray<ResourceDisplayConfig<Resource>>;
+    counts: Partial<Record<Resource, number>>;
+    zero?: "show" | "hide";
+    onResourceClick?: (resourceType: Resource) => void;
+    children: ReactNode;
+};
+type BoundResourceCounterRootProps<Resource extends string = ResourceId> = Omit<ResourceCounterRootProps<Resource>, "resources">;
+type ResourceCounterProps<Resource extends string = ResourceId> = ResourceCounterRootProps<Resource>;
+type ResourceCounterPartProps<Resource extends string = ResourceId> = Omit<PrimitiveCommonProps, "children"> & Omit<HTMLAttributes<HTMLElement>, "children"> & {
+    children?: ReactNode | ((resource: ResourceCounterItemState<Resource>) => ReactNode);
+};
+declare function ResourceCounterRoot<Resource extends string = ResourceId>({ resources, counts, zero, onResourceClick, children, "aria-label": ariaLabel, ...props }: ResourceCounterRootProps<Resource>): ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function ResourceCounterItem<Resource extends string = ResourceId>({ children, onClick, "aria-label": ariaLabel, ...props }: ResourceCounterPartProps<Resource>): ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function ResourceCounterIcon<Resource extends string = ResourceId>({ className, strokeWidth, "aria-hidden": ariaHidden, }: ResourceIconProps): ReactNode;
+declare function ResourceCounterCount<Resource extends string = ResourceId>({ children, ...props }: ResourceCounterPartProps<Resource>): ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function ResourceCounterLabel<Resource extends string = ResourceId>({ children, ...props }: ResourceCounterPartProps<Resource>): ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+interface ResourceCounterComponents<Resource extends string = ResourceId> {
+    Root(props: BoundResourceCounterRootProps<Resource>): ReactElement;
+    Item(props: ResourceCounterPartProps<Resource>): ReactElement;
+    Icon(props: ResourceIconProps): ReactNode;
+    Count(props: ResourceCounterPartProps<Resource>): ReactElement;
+    Label(props: ResourceCounterPartProps<Resource>): ReactElement;
+}
+declare function createResourceCounter<Resource extends string>(resources: ReadonlyArray<ResourceDisplayConfig<Resource>>): ResourceCounterComponents<Resource>;
+declare const ResourceCounter: {
+    Root: typeof ResourceCounterRoot;
+    Item: typeof ResourceCounterItem;
+    Icon: typeof ResourceCounterIcon;
+    Count: typeof ResourceCounterCount;
+    Label: typeof ResourceCounterLabel;
+};
 
 interface ResourceDefinition {
     type: string;
@@ -2628,7 +3296,7 @@ interface MoreActionsProps {
 declare function MoreActions({ children, label, count, defaultOpen, style, }: MoreActionsProps): react_jsx_runtime.JSX.Element;
 
 interface DiceRollerRenderProps {
-    values: Array<number | undefined> | undefined;
+    values: ReadonlyArray<number | undefined> | undefined;
     
     sum: number | undefined;
     diceCount: number;
@@ -2645,7 +3313,7 @@ interface DiceRollerRollAction<Params extends InteractionParamsShape = Interacti
     revealHoldMs?: number;
 }
 interface DiceRollerProps<Params extends InteractionParamsShape = InteractionParamsShape> {
-    values?: Array<number | undefined>;
+    values?: readonly DiceValue[] | null;
     
     diceCount?: number;
     render?: (props: DiceRollerRenderProps) => ReactNode;
@@ -2976,254 +3644,45 @@ type SquareBoardLikeOfProps<TProps extends SquareGridInputProps> = TProps extend
     id?: infer Id;
     layout?: infer Layout;
     spaces: infer Spaces;
-    pieces?: infer Pieces;
-    edges?: infer Edges;
-    vertices?: infer Vertices;
-} ? {
-    id: Extract<Id, string> extends never ? string : Extract<Id, string>;
-    layout?: Extract<Layout, "square">;
-    spaces: Spaces;
-    pieces: ResolvedSquareArrayProp<Pieces>;
-    edges: ResolvedSquareArrayProp<Edges>;
-    vertices: ResolvedSquareArrayProp<Vertices>;
-} & GeneratedSquareBoardInput : TProps extends {
-    id?: infer Id;
-    layout?: infer Layout;
-    rows?: infer Rows;
-    cols?: infer Cols;
-    cells: infer Cells;
-    pieces?: infer Pieces;
-    edges?: infer Edges;
-    vertices?: infer Vertices;
-} ? {
-    id: Extract<Id, string> extends never ? string : Extract<Id, string>;
-    layout?: Extract<Layout, "square">;
-    rows: Extract<Rows, number> extends never ? number : Extract<Rows, number>;
-    cols: Extract<Cols, number> extends never ? number : Extract<Cols, number>;
-    cells: Cells;
-    pieces: ResolvedSquareArrayProp<Pieces>;
-    edges: ResolvedSquareArrayProp<Edges>;
-    vertices: ResolvedSquareArrayProp<Vertices>;
-} & AuthoredSquareBoardInput : never;
-type SquareGridProps<TProps extends SquareGridInputProps = SquareGridInputProps> = TProps & {
-    cellSize?: number;
-    
-    renderCell: (row: number, col: number) => ReactNode;
-    
-    renderPiece: (piece: NormalizedSquarePieceOf<NoInfer<SquareBoardLikeOfProps<TProps>>>) => ReactNode;
-    renderEdge?: (edge: NormalizedSquareEdgeOf<NoInfer<SquareBoardLikeOfProps<TProps>>>, position: SquareEdgePosition) => ReactNode;
-    renderVertex?: (vertex: NormalizedSquareVertexOf<NoInfer<SquareBoardLikeOfProps<TProps>>>, position: SquareVertexPosition) => ReactNode;
-    showCoordinates?: boolean;
-    coordinateStyle?: "algebraic" | "numeric" | "none";
-    width?: number | string;
-    height?: number | string;
-    enablePanZoom?: boolean;
-    initialZoom?: number;
-    minZoom?: number;
-    maxZoom?: number;
-    className?: string;
-    interactiveSpaces?: InteractiveTargetLayer;
-    interactiveEdges?: InteractiveTargetLayer;
-    interactiveVertices?: InteractiveTargetLayer;
-    renderInteractiveSpace?: (space: InteractiveSquareSpace<NoInfer<SquareBoardLikeOfProps<TProps>>>, state: InteractiveTargetRenderState) => ReactNode;
-    renderInteractiveEdge?: (edge: InteractiveSquareEdge<NoInfer<SquareBoardLikeOfProps<TProps>>>, position: SquareEdgePosition, state: InteractiveTargetRenderState) => ReactNode;
-    renderInteractiveVertex?: (vertex: InteractiveSquareVertex<NoInfer<SquareBoardLikeOfProps<TProps>>>, position: SquareVertexPosition, state: InteractiveTargetRenderState) => ReactNode;
-};
-interface SquareGridBoardProps<TBoard extends AnySquareBoardInput = AnySquareBoardInput> {
-    board: TBoard;
-    cellSize?: number;
-    renderCell: (row: number, col: number) => ReactNode;
-    renderPiece: (piece: NormalizedSquarePieceOf<NoInfer<TBoard>>) => ReactNode;
-    renderEdge?: (edge: NormalizedSquareEdgeOf<NoInfer<TBoard>>, position: SquareEdgePosition) => ReactNode;
-    renderVertex?: (vertex: NormalizedSquareVertexOf<NoInfer<TBoard>>, position: SquareVertexPosition) => ReactNode;
-    showCoordinates?: boolean;
-    coordinateStyle?: "algebraic" | "numeric" | "none";
-    width?: number | string;
-    height?: number | string;
-    enablePanZoom?: boolean;
-    initialZoom?: number;
-    minZoom?: number;
-    maxZoom?: number;
-    className?: string;
-    interactiveSpaces?: InteractiveTargetLayer;
-    interactiveEdges?: InteractiveTargetLayer;
-    interactiveVertices?: InteractiveTargetLayer;
-    renderInteractiveSpace?: (space: InteractiveSquareSpace<NoInfer<TBoard>>, state: InteractiveTargetRenderState) => ReactNode;
-    renderInteractiveEdge?: (edge: InteractiveSquareEdge<NoInfer<TBoard>>, position: SquareEdgePosition, state: InteractiveTargetRenderState) => ReactNode;
-    renderInteractiveVertex?: (vertex: InteractiveSquareVertex<NoInfer<TBoard>>, position: SquareVertexPosition, state: InteractiveTargetRenderState) => ReactNode;
-}
-interface DefaultGridCellProps {
-    size: number;
-    isLight?: boolean;
-    lightColor?: string;
-    darkColor?: string;
-    isHighlighted?: boolean;
-    highlightColor?: string;
-    isSelected?: boolean;
-    selectedColor?: string;
-    isValidMove?: boolean;
-    isCapture?: boolean;
-    onClick?: () => void;
-    onPointerEnter?: () => void;
-    onPointerLeave?: () => void;
-    className?: string;
-}
-
-declare function DefaultGridCell({ size, isLight, lightColor, darkColor, isHighlighted, highlightColor, isSelected, selectedColor, isValidMove, isCapture, onClick, onPointerEnter, onPointerLeave, className, }: DefaultGridCellProps): react_jsx_runtime.JSX.Element;
-interface DefaultGridPieceProps {
-    size: number;
-    color?: string;
-    strokeColor?: string;
-    label?: string;
-    isDragging?: boolean;
-    onClick?: () => void;
-    onPointerDown?: (e: React.PointerEvent) => void;
-    className?: string;
-}
-
-declare function DefaultGridPiece({ size, color, strokeColor, label, isDragging, onClick, onPointerDown, className, }: DefaultGridPieceProps): react_jsx_runtime.JSX.Element;
-interface DefaultChessPieceProps {
-    size: number;
-    type: string;
-    owner: "white" | "black";
-    onClick?: () => void;
-    onPointerDown?: (e: React.PointerEvent) => void;
-    className?: string;
-}
-
-declare function DefaultChessPiece({ size, type, owner, onClick, onPointerDown, className, }: DefaultChessPieceProps): react_jsx_runtime.JSX.Element;
-
-declare function toAlgebraic(row: number, col: number, totalRows: number): string;
-
-declare function toNumeric(row: number, col: number): string;
-interface SquareGridComponent {
-    <const TBoard extends AnySquareBoardInput>(props: SquareGridBoardProps<TBoard>): ReactNode;
-    <const TProps extends SquareGeneratedGridInputProps>(props: SquareGridProps<TProps>): ReactNode;
-    <const TProps extends SquareAuthoredGridInputProps>(props: SquareGridProps<TProps>): ReactNode;
-}
-declare const SquareGrid: SquareGridComponent;
-
-type HexOrientation = "pointy-top" | "flat-top";
-
-interface HexTileGeometry {
-    size: number;
-    orientation: HexOrientation;
-    center: {
-        x: 0;
-        y: 0;
-    };
-    position: {
-        x: number;
-        y: number;
-    };
-    corners: (options?: {
-        inset?: number;
-    }) => Array<{
-        x: number;
-        y: number;
-    }>;
-    points: (options?: {
-        inset?: number;
-    }) => string;
-    bounds: {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-        width: number;
-        height: number;
-    };
-}
-interface EdgePosition {
-    
-    x1: number;
-    y1: number;
-    
-    x2: number;
-    y2: number;
-    
-    midX: number;
-    midY: number;
-    
-    centerAngle: number;
-    
-    edgeAngle: number;
-}
-interface InteractiveHexVertex<TBoard extends AnyHexBoardInput = AnyHexBoardInput> extends NormalizedHexVertexOf<TBoard> {
-    position: {
-        x: number;
-        y: number;
-    };
-    spaceIds: ReadonlyArray<BoardSpaceIdOf<TBoard>>;
-}
-interface InteractiveHexEdge<TBoard extends AnyHexBoardInput = AnyHexBoardInput> extends NormalizedHexEdgeOf<TBoard> {
-    position: EdgePosition;
-    spaceIds: ReadonlyArray<BoardSpaceIdOf<TBoard>>;
-}
-type InteractiveHexSpace<TBoard extends AnyHexBoardInput = AnyHexBoardInput> = NormalizedHexTileOf<TBoard>;
-interface HexGeneratedGridInputProps {
-    id?: string;
-    layout?: "hex";
-    orientation?: HexOrientation;
-    spaces: Extract<AnyHexBoardInput, {
-        spaces: unknown;
-    }>["spaces"];
-    edges?: AnyHexBoardInput["edges"];
-    vertices?: AnyHexBoardInput["vertices"];
-}
-interface HexAuthoredGridInputProps {
-    id?: string;
-    layout?: "hex";
-    orientation?: HexOrientation;
-    tiles: Extract<AnyHexBoardInput, {
-        tiles: unknown;
-    }>["tiles"];
-    edges?: AnyHexBoardInput["edges"];
-    vertices?: AnyHexBoardInput["vertices"];
-}
-type HexGridInputProps = HexGeneratedGridInputProps | HexAuthoredGridInputProps;
-type ResolvedArrayProp<Value> = Exclude<Value, undefined> extends readonly unknown[] ? Exclude<Value, undefined> : readonly [];
-type HexBoardLikeOfProps<TProps extends HexGridInputProps> = TProps extends {
-    id?: infer Id;
-    layout?: infer Layout;
-    orientation?: infer Orientation;
-    spaces: infer Spaces;
+    pieces?: infer Pieces;
     edges?: infer Edges;
     vertices?: infer Vertices;
 } ? {
     id: Extract<Id, string> extends never ? string : Extract<Id, string>;
-    layout?: Extract<Layout, "hex">;
-    orientation?: Extract<Orientation, HexOrientation>;
+    layout?: Extract<Layout, "square">;
     spaces: Spaces;
-    edges: ResolvedArrayProp<Edges>;
-    vertices: ResolvedArrayProp<Vertices>;
-} & GeneratedHexBoardInput : TProps extends {
+    pieces: ResolvedSquareArrayProp<Pieces>;
+    edges: ResolvedSquareArrayProp<Edges>;
+    vertices: ResolvedSquareArrayProp<Vertices>;
+} & GeneratedSquareBoardInput : TProps extends {
     id?: infer Id;
     layout?: infer Layout;
-    orientation?: infer Orientation;
-    tiles: infer Tiles;
+    rows?: infer Rows;
+    cols?: infer Cols;
+    cells: infer Cells;
+    pieces?: infer Pieces;
     edges?: infer Edges;
     vertices?: infer Vertices;
 } ? {
     id: Extract<Id, string> extends never ? string : Extract<Id, string>;
-    layout?: Extract<Layout, "hex">;
-    orientation?: Extract<Orientation, HexOrientation>;
-    tiles: Tiles;
-    edges: ResolvedArrayProp<Edges>;
-    vertices: ResolvedArrayProp<Vertices>;
-} & AuthoredHexBoardInput : never;
-type HexGridProps<TProps extends HexGridInputProps = HexGridInputProps> = TProps & {
-    orientation?: HexOrientation;
-    
-    hexSize?: number;
+    layout?: Extract<Layout, "square">;
+    rows: Extract<Rows, number> extends never ? number : Extract<Rows, number>;
+    cols: Extract<Cols, number> extends never ? number : Extract<Cols, number>;
+    cells: Cells;
+    pieces: ResolvedSquareArrayProp<Pieces>;
+    edges: ResolvedSquareArrayProp<Edges>;
+    vertices: ResolvedSquareArrayProp<Vertices>;
+} & AuthoredSquareBoardInput : never;
+type SquareGridProps<TProps extends SquareGridInputProps = SquareGridInputProps> = TProps & {
+    cellSize?: number;
     
-    renderTile: (tile: NormalizedHexTileOf<NoInfer<HexBoardLikeOfProps<TProps>>>, geometry: HexTileGeometry) => ReactNode;
+    renderCell: (row: number, col: number) => ReactNode;
     
-    renderEdge: (edge: NormalizedHexEdgeOf<NoInfer<HexBoardLikeOfProps<TProps>>>, position: EdgePosition) => ReactNode;
-    renderVertex: (vertex: NormalizedHexVertexOf<NoInfer<HexBoardLikeOfProps<TProps>>>, position: {
-        x: number;
-        y: number;
-    }) => ReactNode;
+    renderPiece: (piece: NormalizedSquarePieceOf<NoInfer<SquareBoardLikeOfProps<TProps>>>) => ReactNode;
+    renderEdge?: (edge: NormalizedSquareEdgeOf<NoInfer<SquareBoardLikeOfProps<TProps>>>, position: SquareEdgePosition) => ReactNode;
+    renderVertex?: (vertex: NormalizedSquareVertexOf<NoInfer<SquareBoardLikeOfProps<TProps>>>, position: SquareVertexPosition) => ReactNode;
+    showCoordinates?: boolean;
+    coordinateStyle?: "algebraic" | "numeric" | "none";
     width?: number | string;
     height?: number | string;
     enablePanZoom?: boolean;
@@ -3231,36 +3690,22 @@ type HexGridProps<TProps extends HexGridInputProps = HexGridInputProps> = TProps
     minZoom?: number;
     maxZoom?: number;
     className?: string;
-    
     interactiveSpaces?: InteractiveTargetLayer;
-    
-    interactiveVertices?: InteractiveTargetLayer;
-    
     interactiveEdges?: InteractiveTargetLayer;
-    
-    renderInteractiveSpace?: (space: InteractiveHexSpace<NoInfer<HexBoardLikeOfProps<TProps>>>, state: InteractiveTargetRenderState) => ReactNode;
-    
-    renderInteractiveVertex?: (vertex: InteractiveHexVertex<NoInfer<HexBoardLikeOfProps<TProps>>>, position: {
-        x: number;
-        y: number;
-    }, state: InteractiveTargetRenderState) => ReactNode;
-    
-    renderInteractiveEdge?: (edge: InteractiveHexEdge<NoInfer<HexBoardLikeOfProps<TProps>>>, position: EdgePosition, state: InteractiveTargetRenderState) => ReactNode;
-    interactiveVertexSize?: number;
-    interactiveEdgeSize?: number;
+    interactiveVertices?: InteractiveTargetLayer;
+    renderInteractiveSpace?: (space: InteractiveSquareSpace<NoInfer<SquareBoardLikeOfProps<TProps>>>, state: InteractiveTargetRenderState) => ReactNode;
+    renderInteractiveEdge?: (edge: InteractiveSquareEdge<NoInfer<SquareBoardLikeOfProps<TProps>>>, position: SquareEdgePosition, state: InteractiveTargetRenderState) => ReactNode;
+    renderInteractiveVertex?: (vertex: InteractiveSquareVertex<NoInfer<SquareBoardLikeOfProps<TProps>>>, position: SquareVertexPosition, state: InteractiveTargetRenderState) => ReactNode;
 };
-interface HexGridBoardProps<TBoard extends AnyHexBoardInput = AnyHexBoardInput> {
+interface SquareGridBoardProps<TBoard extends AnySquareBoardInput = AnySquareBoardInput> {
     board: TBoard;
-    orientation?: HexOrientation;
-    hexSize?: number;
-    
-    renderTile: (tile: NormalizedHexTileOf<NoInfer<TBoard>>, geometry: HexTileGeometry) => ReactNode;
-    
-    renderEdge: (edge: NormalizedHexEdgeOf<NoInfer<TBoard>>, position: EdgePosition) => ReactNode;
-    renderVertex: (vertex: NormalizedHexVertexOf<NoInfer<TBoard>>, position: {
-        x: number;
-        y: number;
-    }) => ReactNode;
+    cellSize?: number;
+    renderCell: (row: number, col: number) => ReactNode;
+    renderPiece: (piece: NormalizedSquarePieceOf<NoInfer<TBoard>>) => ReactNode;
+    renderEdge?: (edge: NormalizedSquareEdgeOf<NoInfer<TBoard>>, position: SquareEdgePosition) => ReactNode;
+    renderVertex?: (vertex: NormalizedSquareVertexOf<NoInfer<TBoard>>, position: SquareVertexPosition) => ReactNode;
+    showCoordinates?: boolean;
+    coordinateStyle?: "algebraic" | "numeric" | "none";
     width?: number | string;
     height?: number | string;
     enablePanZoom?: boolean;
@@ -3269,141 +3714,88 @@ interface HexGridBoardProps<TBoard extends AnyHexBoardInput = AnyHexBoardInput>
     maxZoom?: number;
     className?: string;
     interactiveSpaces?: InteractiveTargetLayer;
-    interactiveVertices?: InteractiveTargetLayer;
     interactiveEdges?: InteractiveTargetLayer;
-    
-    renderInteractiveSpace?: (space: InteractiveHexSpace<NoInfer<TBoard>>, state: InteractiveTargetRenderState) => ReactNode;
-    
-    renderInteractiveVertex?: (vertex: InteractiveHexVertex<NoInfer<TBoard>>, position: {
-        x: number;
-        y: number;
-    }, state: InteractiveTargetRenderState) => ReactNode;
-    
-    renderInteractiveEdge?: (edge: InteractiveHexEdge<NoInfer<TBoard>>, position: EdgePosition, state: InteractiveTargetRenderState) => ReactNode;
-    interactiveVertexSize?: number;
-    interactiveEdgeSize?: number;
+    interactiveVertices?: InteractiveTargetLayer;
+    renderInteractiveSpace?: (space: InteractiveSquareSpace<NoInfer<TBoard>>, state: InteractiveTargetRenderState) => ReactNode;
+    renderInteractiveEdge?: (edge: InteractiveSquareEdge<NoInfer<TBoard>>, position: SquareEdgePosition, state: InteractiveTargetRenderState) => ReactNode;
+    renderInteractiveVertex?: (vertex: InteractiveSquareVertex<NoInfer<TBoard>>, position: SquareVertexPosition, state: InteractiveTargetRenderState) => ReactNode;
 }
-interface DefaultHexTileProps {
-    
+interface DefaultGridCellProps {
     size: number;
-    fill: string;
-    stroke?: string;
-    strokeWidth?: number;
-    isSelected?: boolean;
+    isLight?: boolean;
+    lightColor?: string;
+    darkColor?: string;
     isHighlighted?: boolean;
-    label?: string;
-    showCoordinates?: boolean;
-    coordinates?: {
-        q: number;
-        r: number;
-    };
-    orientation?: HexOrientation;
+    highlightColor?: string;
+    isSelected?: boolean;
+    selectedColor?: string;
+    isValidMove?: boolean;
+    isCapture?: boolean;
     onClick?: () => void;
     onPointerEnter?: () => void;
     onPointerLeave?: () => void;
     className?: string;
 }
 
-declare function DefaultHexTile({ size, fill, stroke, strokeWidth, isSelected, isHighlighted, label, showCoordinates, coordinates, orientation, onClick, onPointerEnter, onPointerLeave, className, }: DefaultHexTileProps): react_jsx_runtime.JSX.Element;
-interface DefaultHexEdgeProps {
-    position: EdgePosition;
-    color: string;
-    hasOwner?: boolean;
-    strokeWidth?: number;
-    touchTargetSize?: number;
+declare function DefaultGridCell({ size, isLight, lightColor, darkColor, isHighlighted, highlightColor, isSelected, selectedColor, isValidMove, isCapture, onClick, onPointerEnter, onPointerLeave, className, }: DefaultGridCellProps): react_jsx_runtime.JSX.Element;
+interface DefaultGridPieceProps {
+    size: number;
+    color?: string;
+    strokeColor?: string;
+    label?: string;
+    isDragging?: boolean;
     onClick?: () => void;
+    onPointerDown?: (e: React.PointerEvent) => void;
     className?: string;
 }
 
-declare function DefaultHexEdge({ position, color, hasOwner, strokeWidth, touchTargetSize, onClick, className, }: DefaultHexEdgeProps): react_jsx_runtime.JSX.Element;
-interface DefaultHexVertexProps {
-    position: {
-        x: number;
-        y: number;
-    };
-    color: string;
-    stroke?: string;
-    strokeWidth?: number;
-    hasOwner?: boolean;
-    isSelected?: boolean;
-    isHighlighted?: boolean;
-    size?: number;
-    touchTargetSize?: number;
-    shape?: "circle" | "square";
+declare function DefaultGridPiece({ size, color, strokeColor, label, isDragging, onClick, onPointerDown, className, }: DefaultGridPieceProps): react_jsx_runtime.JSX.Element;
+interface DefaultChessPieceProps {
+    size: number;
+    type: string;
+    owner: "white" | "black";
     onClick?: () => void;
-    onPointerEnter?: () => void;
-    onPointerLeave?: () => void;
+    onPointerDown?: (e: React.PointerEvent) => void;
     className?: string;
 }
 
-declare function DefaultHexVertex({ position, color, stroke, strokeWidth, hasOwner, isSelected, isHighlighted, size, touchTargetSize, shape, onClick, onPointerEnter, onPointerLeave, className, }: DefaultHexVertexProps): react_jsx_runtime.JSX.Element;
-declare const hexUtils: {
-    
-    axialToPixel(q: number, r: number, size: number, orientation: HexOrientation): {
-        x: number;
-        y: number;
-    };
-    getNeighbors(q: number, r: number): Array<{
-        q: number;
-        r: number;
-    }>;
-    getDistance(q1: number, r1: number, q2: number, r2: number): number;
-    getHexCorners(centerX: number, centerY: number, size: number, orientation: HexOrientation): Array<{
-        x: number;
-        y: number;
-    }>;
-    getHexPoints(centerX: number, centerY: number, size: number, orientation: HexOrientation): string;
-    getEdgePosition(hex1Pos: {
-        x: number;
-        y: number;
-    }, hex2Pos: {
-        x: number;
-        y: number;
-    }, size: number): EdgePosition;
-    getVertexPosition(hex1Pos: {
-        x: number;
-        y: number;
-    }, hex2Pos: {
-        x: number;
-        y: number;
-    }, hex3Pos: {
-        x: number;
-        y: number;
-    }): {
-        x: number;
-        y: number;
-    };
-};
-interface HexGridComponent {
-    <const TBoard extends AnyHexBoardInput>(props: HexGridBoardProps<TBoard>): ReactNode;
-    <const TProps extends HexGeneratedGridInputProps>(props: HexGridProps<TProps>): ReactNode;
-    <const TProps extends HexAuthoredGridInputProps>(props: HexGridProps<TProps>): ReactNode;
+declare function DefaultChessPiece({ size, type, owner, onClick, onPointerDown, className, }: DefaultChessPieceProps): react_jsx_runtime.JSX.Element;
+
+declare function toAlgebraic(row: number, col: number, totalRows: number): string;
+
+declare function toNumeric(row: number, col: number): string;
+interface SquareGridComponent {
+    <const TBoard extends AnySquareBoardInput>(props: SquareGridBoardProps<TBoard>): ReactNode;
+    <const TProps extends SquareGeneratedGridInputProps>(props: SquareGridProps<TProps>): ReactNode;
+    <const TProps extends SquareAuthoredGridInputProps>(props: SquareGridProps<TProps>): ReactNode;
 }
-declare const HexGrid: HexGridComponent;
+declare const SquareGrid: SquareGridComponent;
 
-type HexBoardViewTile<TBoard extends AnyHexBoardInput, TSpaceView extends {
-    id: BoardSpaceIdOf<TBoard>;
-}> = Omit<NormalizedHexTileOf<TBoard>, "view"> & {
-    view: TSpaceView;
-};
+interface PluginRuntimeAPI extends RuntimeAPI {
+    
+    getSnapshot: () => PluginStateSnapshot | null;
+    
+    subscribeToState: (listener: (state: PluginStateSnapshot) => void) => () => void;
+    
+    _subscribeToSessionState: (listener: (state: PluginSessionState) => void) => () => void;
+    
+    restoreHistory?: (entryId: string) => void;
+}
 
-interface HexBoardView<TBoard extends AnyHexBoardInput, TSpaceView extends {
-    id: BoardSpaceIdOf<TBoard>;
-}> {
-    id: BoardIdOf<TBoard>;
-    layout?: "hex";
-    orientation?: "pointy-top" | "flat-top";
-    tiles: ReadonlyArray<HexBoardViewTile<TBoard, TSpaceView>>;
-    edges: TBoard["edges"];
-    vertices: TBoard["vertices"];
+interface UsePluginRuntimeOptions {
+    
+    timeout?: number;
 }
-interface CreateHexBoardViewOptions<TSpaceView> {
-    spaces: readonly TSpaceView[];
+interface UsePluginRuntimeResult {
+    
+    runtime: PluginRuntimeAPI;
+    
+    isReady: boolean;
+    
+    error: string | null;
 }
 
-declare function createHexBoardView<const TBoard extends AnyHexBoardInput, const TSpaceView extends {
-    id: BoardSpaceIdOf<TBoard>;
-}>(board: TBoard, options: CreateHexBoardViewOptions<TSpaceView>): HexBoardView<TBoard, TSpaceView>;
+declare function usePluginRuntime(options?: UsePluginRuntimeOptions): UsePluginRuntimeResult;
 
-export { ActionButton, ActionGroup, ActionPanel, Board, BoardInteractionConflictError, BoardRoot, BoardTarget, Card, CostDisplay, DefaultChessPiece, DefaultEmptySlot, DefaultGridCell, DefaultGridPiece, DefaultHexEdge, DefaultHexTile, DefaultHexVertex, DefaultNetworkEdge, DefaultNetworkNode, DefaultNetworkPiece, DefaultSlotItem, DefaultSlotOccupant, DefaultTrackConnection, DefaultTrackJump, DefaultTrackPiece, DefaultTrackSpace, DefaultZone, DefaultZonePiece, DefaultZonePieces, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DiceRoller, Drawer, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, DrawerPortal, DrawerTitle, DrawerTrigger, ErrorBoundary, GameEndDisplay, GameSkeleton, Hand, HandDock, HexGrid, Interaction, InteractionCardInput, InteractionDescription, InteractionField, InteractionForm, InteractionInput, InteractionLabel, InteractionRoot, InteractionSubmit, InteractionTrigger, InteractionUnavailableMessage, InteractionValidationMessage, MoreActions, NetworkGraph, Phase, PhaseIndicator, PhaseSwitch, PlayArea, PlayerRoster, PlayerRosterBadges, PlayerRosterEmpty, PlayerRosterList, PlayerRosterName, PlayerRosterRoot, PlayerRosterScore, PlayerRosterSwitchButton, PluginRuntime, PluginStateProvider, PrimaryActionButton, PrimaryButton, Prompt, PromptDialogHost, PromptInbox, PromptInboxEmpty, PromptInboxItems, PromptInboxRoot, PromptMessage, PromptOption, PromptOptions, PromptRoot, PromptTitle, ResourceCounter, RuntimeContext, RuntimeProvider, SlotSystem, SquareGrid, ThemeProvider, ThemedButton, ToastProvider, TrackBoard, Zone, ZoneItem, ZoneList, ZoneMap, ZoneRoot, arcadeTheme, buttonStyle, calculateViewBox, chipStyle, composeEventHandlers, createDreamboardUI, createHexBoardView, cssVar, cssVarOr, defaultFormInputs, deriveBoardTheme, getThemePreset, hasDefaultInteractionFormFields, hexUtils, intentForVariant, mergeTheme, motionDuration, normalizeHexBoardInput, normalizeSquareBoardInput, playerColor, renderPrimitive, resolveTheme, studioTheme, surfaceStyle, tabletopTheme, themeToCssVars, toAlgebraic, toNumeric, toTrackBoardData, useActivePlayers, useBoardInteractions, useBoardPrimitiveContext, useBoardTheme, useBoardTopology, useCards, useGameSelector, useGameView, useHandLayout, useHexBoard, useInteractionByKey, useInteractionHandle, useInteractionPrimitiveContext, useIsMobile, useIsMyTurn, useLobby, useMe, usePanZoom, usePlayerInfo, usePlayerTurnOrder, usePluginActions, usePluginRuntime, usePluginSession, usePluginState, useRuntimeContext, useSeatInbox, useSimultaneousPhase, useSquareBoard, useTheme, useThemeCssVars, useToast, useZoneCardContext, useZonePrimitiveContext };
-export type { ActionButtonProps, ActionGroupProps, ActionPanelProps, AnyHexBoardInput, AnySquareBoardInput, AuthoredHexBoardInput, AuthoredSquareBoardInput, BoardEdgeIdOf, BoardInteractionsContext, BoardInteractionsOptions, BoardKindStates, BoardRootProps, BoardSpaceIdOf, BoardStates, BoardTargetExtraInputs, BoardTargetKey, BoardTargetLayerFactory, BoardTargetLayerOptions, BoardTargetProps, BoardTheme, BoardVertexIdOf, ButtonSize$1 as ButtonSize, ButtonVariant$1 as ButtonVariant, CardCollection, CardKey, CardPositionProps, CardProps, CardSize, ClientParamSchema, ClientParamSchemaMap, ColorRamp, ComponentTokens, CostDisplayProps, DefaultChessPieceProps, DefaultEmptySlotProps, DefaultGridCellProps, DefaultGridPieceProps, DefaultHexEdgeProps, DefaultHexTileProps, DefaultHexVertexProps, DefaultNetworkEdgeProps, DefaultNetworkNodeProps, DefaultNetworkPieceProps, DefaultSlotItemProps, DefaultSlotOccupantProps, DefaultTrackConnectionProps, DefaultTrackJumpProps, DefaultTrackPieceProps, DefaultTrackSpaceProps, DefaultZonePieceProps, DefaultZonePiecesProps, DefaultZoneProps, DiceRollerProps, DiceStates, DieState, DraftValidation, DreamboardUI, DreamboardUIRegister, EdgePosition, Elevation, ErrorBoundaryProps, FoundationColor, GameEndDisplayProps, GameSkeletonProps, GameState, GameplayPromptOption, GameplaySnapshot, GeneratedHexBoardInput, GeneratedHexSpaceStateLike, GeneratedSquareBoardInput, GeneratedSquareSpaceStateLike, GeneratedTiledEdgeStateLike, GeneratedTiledVertexStateLike, HandDockMode, HandDockPlacement, HandDockPresentation, HandDockProps, HandDockToggleContext, HandLayout, HandProps, HexBoardInput, HexBoardState, HexBoardView, HexBoardViewTile, HexEdgeState, HexGridBoardProps, HexGridProps, HexOrientation, HexTileGeometry, HexTileState, HexVertexState, IntentColor, InteractionCardInputProps, InteractionContext, InteractionContextOption, InteractionDescriptor, InteractionFieldProps, InteractionFieldRenderMap, InteractionFieldRenderProps, InteractionFormProps, InteractionHandle, InteractionHandleStatus, InteractionInputKey, InteractionInputProps, InteractionKey, InteractionParamsShape, InteractionPartProps, InteractionRootProps, InteractionSubmitProps, InteractionTriggerProps, InteractiveHexEdge, InteractiveHexVertex, InteractiveSquareEdge, InteractiveSquareVertex, InteractiveTargetLayer, InteractiveTargetRenderState, LobbyState, MoreActionsProps, Motion, NetworkBoardState, NetworkEdge, NetworkEdgeState, NetworkGraphProps, NetworkNode, NetworkNodeState, NetworkPiece, NetworkPieceState, NormalizedHexBoard, NormalizedHexEdgeOf, NormalizedHexTileOf, NormalizedHexVertexOf, NormalizedSquareBoard, NormalizedSquareCellOf, NormalizedSquareEdgeOf, NormalizedSquarePieceOf, NormalizedSquareVertexOf, PanZoomTransform, PhaseFallback, PhaseIndicatorProps, PhaseKey, PhaseRouteMap, PhaseSwitchProps, PlayAreaProps, Player, PlayerColor, PlayerRosterBadge, PlayerRosterComponents, PlayerRosterEntry, PlayerRosterListProps, PlayerRosterPartProps, PlayerRosterRootProps, PlayerRosterSwitchButtonProps, PlayerScore, PluginRuntimeProps, PluginSessionState, PluginStateSnapshot, PrimaryActionAttention, PrimaryActionButtonProps, PrimaryButtonProps, PrimitiveCommonProps, PrimitiveDataAttributes, PromptDialogHostProps, PromptKey, PromptOptionKey, PromptOptionProps, PromptRootProps, Radius, RegisteredUI, ResourceCounterProps, ResourceDefinition, ResourceDisplayConfig, RuntimeAPI, SeatInbox, SemanticColor, SlotDefinition, SlotOccupant, SlotSystemProps, Space, SquareBoardInput, SquareBoardState, SquareCellState, SquareEdgePosition, SquareEdgeState, SquareGridBoardProps, SquareGridProps, SquarePieceState, SquareVertexPosition, SquareVertexState, SubmissionError, Theme, ThemeContextValue, ThemeMeta, ThemeOverride, ThemePresetId, ThemeProviderProps, ThemedButtonProps, Toast, ToastType, TrackBoardProps, TrackBoardState, TrackPiece, TrackPieceState, TrackSpace, TrackSpaceState, TypedBoard, TypedInteraction, TypedPhase, TypedPlayerRoster, TypedPrompt, TypedPromptInbox, TypedZone, Typography, UIContract, UIContractBucket, UseHandLayoutOptions, UseHandLayoutReturn, UsePanZoomOptions, UsePanZoomReturn, UsePluginRuntimeOptions, UsePluginRuntimeResult, ValidationResult, ViewCard, ViewSlotOccupant, ZoneDefinition, ZoneHighlightType, ZoneItemProps, ZoneKey, ZoneListProps, ZoneMapProps, ZonePiece, ZoneRootProps, ZoneShape };
+export { ActionButton, ActionGroup, ActionPanel, Board, BoardEdgeTarget, BoardHexGrid, BoardHexView, BoardRoot, BoardSpaceTarget, BoardState, BoardTarget, BoardVertexTarget, Card, CostDisplay, DefaultChessPiece, DefaultEmptySlot, DefaultGridCell, DefaultGridPiece, DefaultHexEdge, DefaultHexTile, DefaultHexVertex, DefaultNetworkEdge, DefaultNetworkNode, DefaultNetworkPiece, DefaultSlotItem, DefaultSlotOccupant, DefaultTrackConnection, DefaultTrackJump, DefaultTrackPiece, DefaultTrackSpace, DefaultZone, DefaultZonePiece, DefaultZonePieces, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, Dice, DiceRoller, DiceRoot, DiceValues, Drawer, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, DrawerPortal, DrawerTitle, DrawerTrigger, ErrorBoundary, Game, GameEndDisplay, GameRoot, GameSkeleton, Hand, HandDock, HexGrid, Interaction, InteractionCardInput, InteractionDescription, InteractionDialog, InteractionForm, InteractionFormPrimitive, InteractionInput, InteractionLabel, InteractionRoot, InteractionState, InteractionSubmit, InteractionSwitch, InteractionTrigger, InteractionUnavailableMessage, InteractionValidationMessage, MoreActions, NetworkGraph, Phase, PhaseIndicator, PhaseSwitch, PlayArea, PlayerRoster, PlayerRosterBadges, PlayerRosterEmpty, PlayerRosterList, PlayerRosterName, PlayerRosterRoot, PlayerRosterScore, PlayerRosterSwitchButton, PluginRuntime, PluginStateProvider, PrimaryActionButton, PrimaryButton, Prompt, PromptDialog, PromptInbox, PromptInboxEmpty, PromptInboxItems, PromptInboxRoot, PromptMessage, PromptOption, PromptOptions, PromptRoot, PromptTitle, ResourceCounter, ResourceCounterCount, ResourceCounterIcon, ResourceCounterItem, ResourceCounterLabel, ResourceCounterRoot, RuntimeContext, RuntimeProvider, SlotSystem, SquareGrid, ThemeProvider, ThemedButton, Toast, ToastActions, ToastProvider, TrackBoard, UI, UIRoot, Zone, ZoneCardAction, ZoneCardAt, ZoneItem, ZoneList, ZoneMap, ZonePileCards, ZonePileCount, ZonePileDescription, ZonePileLabel, ZonePileRoot, ZonePileTrigger, ZoneRoot, ZoneTopCard, arcadeTheme, buttonStyle, calculateViewBox, chipStyle, composeEventHandlers, createDreamboardUI, createHexBoardView, createResourceCounter, cssVar, cssVarOr, defaultFormInputs, deriveBoardTheme, getThemePreset, hasDefaultInteractionFormFields, hexColor, hexUtils, intentForVariant, isHexColor, mergeTheme, motionDuration, normalizeDiceState, normalizeHexBoardInput, normalizeSquareBoardInput, parseHexColor, playerColor, renderPrimitive, resolveTheme, studioTheme, surfaceStyle, tabletopTheme, themeToCssVars, toAlgebraic, toNumeric, toTrackBoardData, useBoardPrimitiveContext, useBoardTheme, useDicePrimitiveContext, useGameActionError, useHandLayout, useInteractionPrimitiveContext, useOptionalZonePrimitiveContext, usePanZoom, usePluginRuntime, useTheme, useThemeCssVars, useZoneCardContext, useZonePileContext, useZonePrimitiveContext };
+export type { ActionButtonProps, ActionGroupProps, ActionPanelProps, AnyHexBoardInput, AnySquareBoardInput, AuthoredHexBoardInput, AuthoredSquareBoardInput, BoardEdgeIdOf, BoardEdgeTargetProps, BoardHexGridInteractionFilter, BoardHexGridInteractions, BoardHexGridProps, BoardHexViewProps, BoardKindStates, BoardRef, BoardRootProps, BoardSelectionResult, BoardSpaceIdOf, BoardSpaceTargetProps, BoardStateProps, BoardStates, BoardTargetExtraInputs, BoardTargetKey, BoardTargetProps, BoardTheme, BoardVertexIdOf, BoardVertexTargetProps, BoundResourceCounterRootProps, ButtonSize$1 as ButtonSize, ButtonVariant$1 as ButtonVariant, CardCollection, CardKey, CardPositionProps, CardProps, CardSize, ClientParamSchema, ClientParamSchemaMap, ColorRamp, ComponentTokens, CostDisplayProps, DefaultChessPieceProps, DefaultEmptySlotProps, DefaultGridCellProps, DefaultGridPieceProps, DefaultHexEdgeProps, DefaultHexTileProps, DefaultHexVertexProps, DefaultNetworkEdgeProps, DefaultNetworkNodeProps, DefaultNetworkPieceProps, DefaultSlotItemProps, DefaultSlotOccupantProps, DefaultTrackConnectionProps, DefaultTrackJumpProps, DefaultTrackPieceProps, DefaultTrackSpaceProps, DefaultZonePieceProps, DefaultZonePiecesProps, DefaultZoneProps, DiceComponents, DiceRollerProps, DiceRootProps, DiceState, DiceStates, DiceValue, DiceValuesProps, DieState, DraftValidation, DreamboardUI, DreamboardUIRegister, EdgePosition, Elevation, ErrorBoundaryProps, FoundationColor, GameEndDisplayProps, GameMeState, GamePlayer, GamePlayerEntry, GamePlayersState, GameRenderState, GameRootProps, GameSkeletonProps, GameState, GameTurnState, GeneratedHexBoardInput, GeneratedHexSpaceStateLike, GeneratedSquareBoardInput, GeneratedSquareSpaceStateLike, GeneratedTiledEdgeStateLike, GeneratedTiledVertexStateLike, HandDockMode, HandDockPlacement, HandDockPresentation, HandDockProps, HandDockToggleContext, HandLayout, HandProps, HexBoardInput, HexBoardState, HexBoardView, HexBoardViewTile, HexColor, HexEdgeState, HexGridBoardProps, HexGridProps, HexOrientation, HexTileGeometry, HexTileState, HexVertexState, InputDomainDependencyCase, IntentColor, InteractionCardInputProps, InteractionContext, InteractionContextOption, InteractionDescriptor, InteractionDialogProps, InteractionDialogRenderState, InteractionDialogState, InteractionFieldPrimitiveProps, InteractionFormPrimitiveProps, InteractionFormProps, InteractionHandle, InteractionHandleStatus, InteractionInputKey, InteractionInputProps, InteractionKey, InteractionParamsShape, InteractionPartProps, InteractionRootProps, InteractionRouteMap, InteractionStateProps, InteractionStateSnapshot, InteractionSubmitProps, InteractionSwitchProps, InteractionSwitchRenderState, InteractionTriggerProps, InteractiveHexEdge, InteractiveHexVertex, InteractiveSquareEdge, InteractiveSquareVertex, InteractiveTargetLayer, InteractiveTargetRenderState, MoreActionsProps, Motion, NetworkBoardState, NetworkEdge, NetworkEdgeState, NetworkGraphProps, NetworkNode, NetworkNodeState, NetworkPiece, NetworkPieceState, NormalizedHexBoard, NormalizedHexEdgeOf, NormalizedHexTileOf, NormalizedHexVertexOf, NormalizedSquareBoard, NormalizedSquareCellOf, NormalizedSquareEdgeOf, NormalizedSquarePieceOf, NormalizedSquareVertexOf, PanZoomTransform, PerPlayer, PerPlayerBoardRef, PhaseFallback, PhaseIndicatorProps, PhaseKey, PhaseRouteMap, PhaseSwitchProps, PlayAreaProps, Player, PlayerColor, PlayerRosterBadge, PlayerRosterComponents, PlayerRosterEntry, PlayerRosterListProps, PlayerRosterPartProps, PlayerRosterRootProps, PlayerRosterSwitchButtonProps, PlayerScore, PluginRuntimeProps, PluginSessionState, PluginStateSnapshot, PrimaryActionAttention, PrimaryActionButtonProps, PrimaryButtonProps, PrimitiveCommonProps, PrimitiveDataAttributes, PromptDialogProps, PromptDialogRenderState, PromptDialogState, PromptInboxItemsProps, PromptKey, PromptOptionKey, PromptOptionProps, PromptOptionRenderItem, PromptOptionsProps, PromptRootProps, Radius, RegisteredUI, ResourceCounterComponents, ResourceCounterItemState, ResourceCounterPartProps, ResourceCounterProps, ResourceCounterRootProps, ResourceDefinition, ResourceDisplayConfig, ResourceIconProps, RuntimeAPI, SemanticColor, SharedBoardRef, SlotDefinition, SlotOccupant, SlotSystemProps, Space, SquareBoardInput, SquareBoardState, SquareCellState, SquareEdgePosition, SquareEdgeState, SquareGridBoardProps, SquareGridProps, SquarePieceState, SquareVertexPosition, SquareVertexState, SubmissionError, Theme, ThemeContextValue, ThemeMeta, ThemeOverride, ThemePresetId, ThemeProviderProps, ThemedButtonProps, ToastActionsProps, ToastActionsValue, ToastNotification, ToastType, TrackBoardProps, TrackBoardState, TrackPiece, TrackPieceState, TrackSpace, TrackSpaceState, TypedBoard, TypedGame, TypedInteraction, TypedPhase, TypedPlayerRoster, TypedPrompt, TypedPromptInbox, TypedZone, Typography, UIContract, UIContractBucket, UIRootProps, UseHandLayoutOptions, UseHandLayoutReturn, UsePanZoomOptions, UsePanZoomReturn, UsePluginRuntimeOptions, UsePluginRuntimeResult, ValidationResult, ViewCard, ViewSlotOccupant, ZoneCardActionExtraInputs, ZoneCardActionProps, ZoneCardActionResult, ZoneCardAtProps, ZoneCardRenderItem, ZoneDefinition, ZoneHighlightType, ZoneItemProps, ZoneKey, ZoneListProps, ZoneMapProps, ZonePiece, ZonePileCardsProps, ZonePileContextValue, ZonePileCountProps, ZonePileDescriptionProps, ZonePileLabelProps, ZonePileRootProps, ZonePileTriggerProps, ZoneRootProps, ZoneShape, ZoneTopCardProps };