@dreamboard-games/sdk 0.5.0-alpha.2 → 0.5.0-alpha.3

package/dist/ui-contract-GTUPkf8z.d.ts

@@ -1,1168 +0,0 @@
-import * as react from 'react';
-import { ReactNode, ButtonHTMLAttributes, CSSProperties, HTMLAttributes, InputHTMLAttributes, ReactElement } from 'react';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { W as InteractiveTargetState$1, A as AnyHexBoardInput, d as BoardSpaceIdOf, K as HexGridBoardProps, z as HexBoardView, a as AnySquareBoardInput, ac as SquareGridBoardProps, ag as Theme, ai as ThemeOverride } from './hex-board-view-aKkblDp6.js';
-import { a as ThemePresetId } from './ThemeProvider-CElaL2ik.js';
-import { b as InteractionDescriptor, Z as ZoneHandlesSnapshot, d as PluginSessionState, P as PlayerId, I as InputDomain, c as InteractionInputDescriptor } from './runtime-api-Bz5pwNU_.js';
-import { ViewCard } from './types.js';
-import { P as PrimitiveCommonProps } from './primitive-props-BNHDkgd7.js';
-import { a as BrowserInteractionAttributeMap } from './attributes-DbvyMbXw.js';
-import { t as Player, j as HexColor } from './player-state-Cqpyeql0.js';
-
-type BoardTargetKind = "edge" | "vertex" | "space" | "tile";
-
-/**
- * Runtime extension of the ui target-layer types. The base shapes and the
- * render-state computation live in `src/ui/components/board/target-layer.ts`;
- * this module only widens the per-target state with the interaction metadata
- * the runtime layer attaches (interaction keys, conflict tracking, gameplay
- * browser attributes).
- */
-
-interface InteractiveTargetState extends InteractiveTargetState$1 {
-    kind?: BoardTargetKind;
-    interactionKey?: string;
-    interactionId?: string;
-    inputKey?: string;
-    conflictInteractionKeys?: readonly string[];
-    browserAttributes?: BrowserInteractionAttributeMap;
-}
-interface InteractiveTargetLayer {
-    enabled?: boolean;
-    eligible?: ReadonlySet<string>;
-    selectTargetId?: (targetId: string) => unknown | Promise<unknown>;
-    targetState?: (targetId: string) => Partial<InteractiveTargetState>;
-}
-
-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;
-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;
-}
-/**
- * Opinionated board-level dispatch context. Collapses the repeated
- * "collect every board handle, merge target domains across them,
- * route each click into the right interaction" pattern that advanced
- * board games (Catan-class) otherwise have to re-implement by hand.
- */
-interface BoardInteractionsContext<I extends string = string> {
-    /**
-     * All board-surface interactions projected onto the controlling seat
-     * — both available and unavailable. Rendered greyed-out states can
-     * key off this even when the interaction isn't dispatchable yet.
-     */
-    interactions: ReadonlyArray<InteractionDescriptor<I>>;
-    /**
-     * Per-target-kind eligibility sets merged across every currently-
-     * available board interaction. `eligible.vertex` answers "which
-     * vertex ids can be clicked right now?" without the caller manually
-     * unioning descriptor eligibility across handles or knowing the
-     * authored input key.
-     */
-    eligible: BoardEligibleTargets;
-    /**
-     * True when `targetId` is eligible for at least one available
-     * interaction. Pass `kind` to scope the check to a specific
-     * board target kind.
-     */
-    isEligible(targetId: string, kind?: BoardTargetKind): boolean;
-    /**
-     * Target-kind dispatch. Routes by board geometry (`edge`, `vertex`,
-     * `space`, `tile`) rather than authored input-key strings.
-     */
-    pendingInteraction: BoardPendingInteraction<I> | null;
-    select: {
-        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>>;
-    };
-    /**
-     * Reducer-aware target layers for board primitives. Pass these directly
-     * to grids so eligibility, dispatch, and submit error handling stay in
-     * one place instead of being re-wired per component.
-     */
-    targetLayers: {
-        edge: BoardTargetLayerFactory;
-        vertex: BoardTargetLayerFactory;
-        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>>;
-}
-
-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 BoardGridInteractionFilter<Key extends string = string> = "auto" | false | {
-    edge?: readonly Key[];
-    vertex?: readonly Key[];
-    space?: readonly Key[];
-};
-type BoardHexGridInteractionFilter = BoardGridInteractionFilter<string>;
-type BoardSquareGridInteractionFilter = BoardGridInteractionFilter<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 BoardSquareGridProps<TBoard extends AnySquareBoardInput> = Omit<SquareGridBoardProps<TBoard>, "interactiveEdges" | "interactiveVertices" | "interactiveSpaces"> & {
-    interactions?: BoardSquareGridInteractionFilter;
-};
-declare function BoardSquareGrid<const TBoard extends AnySquareBoardInput>({ board, interactions, ...props }: BoardSquareGridProps<TBoard>): 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;
-    value: Target;
-    interaction?: string;
-    input?: string;
-    extraInputs?: BoardTargetExtraInputs;
-    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;
-    SquareGrid: typeof BoardSquareGrid;
-    Target: typeof BoardTarget;
-    SpaceTarget: typeof BoardSpaceTarget;
-    EdgeTarget: typeof BoardEdgeTarget;
-    VertexTarget: typeof BoardVertexTarget;
-};
-
-interface UIRootProps {
-    /**
-     * Preset id, a full Theme, or omitted to defer to the host-mounted theme.
-     * When omitted, no provider is mounted and existing parent themes apply.
-     */
-    theme?: ThemePresetId | Theme;
-    /** Deep-partial overrides forwarded to the SDK ThemeProvider. */
-    themeOverride?: ThemeOverride;
-    /** Forwarded to the SDK ThemeProvider. */
-    reducedMotion?: "auto" | "force" | "ignore";
-    /** Forwarded to the SDK ThemeProvider wrapper. */
-    className?: string;
-    /** Forwarded to the SDK ThemeProvider wrapper style. */
-    style?: CSSProperties;
-    children: ReactNode;
-}
-/**
- * Root provider for generated UI contracts.
- *
- * Composes the SDK `ThemeProvider` so authors can write
- * `<UI.Root theme="tabletop">` and have presentation tokens applied without
- * importing `@dreamboard-games/sdk/ui` themselves. The runtime workspace contract
- * stacks plugin-state, toast and mobile-hand providers around this.
- */
-declare function UIRoot({ theme, themeOverride, reducedMotion, className, style, children, }: UIRootProps): react_jsx_runtime.JSX.Element;
-declare const UI: {
-    Root: typeof UIRoot;
-};
-
-interface ZoneContextValue {
-    zone: string;
-    snapshot: ZoneHandlesSnapshot | null;
-}
-interface ZoneCardContextValue {
-    zone: string;
-    cardId: string;
-}
-/**
- * An item rendered by a zone primitive. Discriminated by `hidden`:
- *
- * - `hidden: false` — fully hydrated from the zone projection. Carries the
- *   authored card type, properties, and reducer-projected interaction state.
- * - `hidden: true` — the zone snapshot exposes the card id but withholds its
- *   contents (e.g. opponent zones, or a zone that is projected count-only).
- *   The render contract is honest about not knowing the type; authors must
- *   narrow on `hidden` before reading `cardType` / `properties`.
- *
- * Replaces the previous silent fallback that widened `cardType` to the
- * untyped string `"unknown"` — see SDK Design Principles §2 (strong contracts
- * over comments).
- */
-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;
-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.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
-interface UseZoneCardsOptions {
-    sort?: (a: ZoneCardRenderItem, b: ZoneCardRenderItem) => number;
-}
-interface UseZoneCardsResult {
-    zone: string;
-    items: readonly ZoneCardRenderItem[];
-    count: number;
-    isEmpty: boolean;
-}
-declare function useZoneCards({ sort, }?: UseZoneCardsOptions): UseZoneCardsResult;
-interface ZoneItemProps extends PrimitiveCommonProps, HTMLAttributes<HTMLElement> {
-    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.ReactElement<unknown, string | react.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.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
-type ZonePileLabelProps = PrimitiveCommonProps & HTMLAttributes<HTMLElement>;
-declare function ZonePileLabel({ children, ...props }: ZonePileLabelProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
-type ZonePileCountProps = PrimitiveCommonProps & HTMLAttributes<HTMLElement>;
-declare function ZonePileCount({ children, ...props }: ZonePileCountProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
-type ZonePileDescriptionProps = PrimitiveCommonProps & HTMLAttributes<HTMLElement>;
-declare function ZonePileDescription({ children, ...props }: ZonePileDescriptionProps): react.ReactElement<unknown, string | react.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 function createZoneCardRenderItem(zone: string, snapshot: ZoneHandlesSnapshot | null, cardId: string, index: number): ZoneCardRenderItem;
-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;
-    useZoneCards: typeof useZoneCards;
-};
-
-/**
- * Hook to access plugin session metadata.
- * Returns session initialization status and IDs.
- *
- * @returns Plugin session state with status, sessionId, and controllingPlayerId
- *
- * @example
- * ```tsx
- * function MyPluginComponent() {
- *   const { status, sessionId, controllingPlayerId } = usePluginSession();
- *
- *   if (status === "loading") {
- *     return <div>Initializing...</div>;
- *   }
- *
- *   return (
- *     <div>
- *       <p>Session: {sessionId}</p>
- *       <p>Current perspective: {controllingPlayerId}</p>
- *     </div>
- *   );
- * }
- * ```
- */
-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;
-};
-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;
-    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 GamePendingInputState {
-    key: string;
-    kind: string;
-    domain: InputDomain;
-    title: string;
-}
-interface GameActiveActionState<Interaction extends string = string, Params extends Record<string, unknown> = Record<string, unknown>> {
-    interaction: Interaction;
-    interactionId: string;
-    descriptor: InteractionDescriptor<Interaction>;
-    title: string;
-    draft: Readonly<Partial<Params>>;
-    values: Partial<Params>;
-    missingInputs: readonly string[];
-    readyFrontier: readonly string[];
-    pendingInput: GamePendingInputState | null;
-}
-interface GameChromeState<ViewValue = unknown, PlayerIdValue extends string = PlayerId, PhaseValue extends string = string, Interaction extends string = string> extends GameRenderState<ViewValue, PlayerIdValue, PhaseValue> {
-    activePlayers: readonly PlayerIdValue[];
-    activeAction: GameActiveActionState<Interaction> | null;
-    cancel: (() => void) | null;
-}
-interface GameRootProps<ViewValue = unknown, PlayerIdValue extends string = PlayerId, PhaseValue extends string = string> {
-    onActionError?: (error: unknown) => void;
-    children: (state: GameRenderState<ViewValue, PlayerIdValue, PhaseValue>) => ReactNode;
-}
-interface GameChromeProps<ViewValue = unknown, PlayerIdValue extends string = PlayerId, PhaseValue extends string = string, Interaction extends string = string> {
-    children: (state: GameChromeState<ViewValue, PlayerIdValue, PhaseValue, Interaction>) => ReactNode;
-}
-interface GameViewportProps extends HTMLAttributes<HTMLDivElement> {
-    children?: 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 function GameChrome<ViewValue = unknown, PlayerIdValue extends string = PlayerId, PhaseValue extends string = string, Interaction extends string = string>({ children, }: GameChromeProps<ViewValue, PlayerIdValue, PhaseValue, Interaction>): react_jsx_runtime.JSX.Element;
-declare function GameViewport({ children, style, ...props }: GameViewportProps): react_jsx_runtime.JSX.Element;
-declare const Game: {
-    Root: typeof GameRoot;
-    Chrome: typeof GameChrome;
-    Viewport: typeof GameViewport;
-};
-
-/**
- * Anything that can be used as a submit params object. Subset of TS
- * objects so generic defaults and `keyof Params & string` hold.
- */
-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>;
-};
-/**
- * Bound handle around an {@link InteractionDescriptor}. Surfaces call into
- * this hook to submit an interaction, track draft input state for
- * multi-step prompts, and arm/disarm themselves on a surface.
- *
- * Availability flags are mirrored from the authoritative descriptor; UI
- * MUST NOT recompute eligibility locally.
- *
- * When the surrounding workspace knows the concrete params shape (e.g.
- * obtained from the generated `InteractionParamsOf<Id>` alias), parameterise
- * this handle on `Params` so `submit`, `draft`, and `setInput` are all
- * statically typed. The default `Record<string, unknown>` preserves the
- * loosely-typed fallback for generic infrastructure.
- */
-interface InteractionHandle<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never> {
-    descriptor: InteractionDescriptor;
-    /** Draft commit policy projected by the reducer. */
-    commit: InteractionDescriptor["commit"];
-    /**
-     * Submit the interaction. When `params` is omitted the current draft (as
-     * mutated by {@link InteractionHandle.setInput}) is used instead, which is
-     * the common case for multi-input prompts.
-     */
-    submit: (params?: Params) => Promise<void>;
-    /** Run local generated client-schema validation against the current draft. */
-    validateDraft: () => DraftValidation<Params>;
-    /**
-     * Validate the current draft locally, submit parsed params, then clear the
-     * draft only when submission succeeds.
-     */
-    submitDraft: () => Promise<void>;
-    /** Derived from `descriptor.availability`. */
-    available: boolean;
-    /** Derived from `descriptor.availability`. */
-    unavailableReason?: string;
-    /** Local/authoritative progress for this interaction. */
-    status: InteractionHandleStatus;
-    /** Live draft values for this interaction. Empty object when unset. */
-    draft: Readonly<Partial<Params>>;
-    /**
-     * Draft values with authored input defaults applied. Fields with declared
-     * defaults are typed as present; other draft fields remain partial.
-     */
-    values: Readonly<Partial<Params> & Pick<Params, DefaultedKeys>>;
-    /** Set a single input on the draft. */
-    setInput: <K extends keyof Params & string>(key: K, value: Params[K]) => void;
-    /** Clear a single input (or the whole draft when `key` is omitted). */
-    clearInput: (key?: keyof Params & string) => void;
-    /**
-     * True when every key declared on `descriptor.inputs` has a value in
-     * the draft. Falls back to `true` when the descriptor declares no inputs.
-     */
-    isReady: boolean;
-    /**
-     * True when this interaction is the currently armed one on its surface.
-     * Armed interactions are the ones that board primitives use
-     * to highlight eligible targets and route clicks.
-     */
-    isArmed: boolean;
-    /** Arm this interaction on its surface (disarms any previously armed). */
-    arm: () => void;
-    /** Disarm this interaction (if it was armed). */
-    disarm: () => void;
-}
-/**
- * Bind an {@link InteractionDescriptor} to submit/validate helpers plus
- * draft + arming state. Use this from any surface; draft state is shared
- * across components through {@link InteractionUiProvider}, which
- * `PluginRuntime` auto-mounts.
- *
- * Example:
- * ```tsx
- * const handle = useInteractionHandle(placeThing);
- * handle.setInput("cardId", card.id);
- * handle.setInput("ringId", ring.id);
- * if (handle.isReady) await handle.submit();
- * ```
- */
-declare function useInteractionHandle<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never>(descriptor: InteractionDescriptor): InteractionHandle<Params, DefaultedKeys>;
-
-interface InteractionContextValue {
-    interaction: string;
-    descriptor: InteractionDescriptor | null;
-    handle: ReturnType<typeof useInteractionHandle> | null;
-}
-declare function useInteractionPrimitiveContext(): InteractionContextValue;
-/**
- * Live draft value for the active interaction's card-target input, resolved
- * from the surrounding `<Interaction.Root>`. Returns the selected card-id array
- * for `selection: "many"` inputs and the single id for `selection: "one"`.
- * Returns `undefined` when there is no interaction context or no card-target
- * input (so it is safe to render outside a root). Reactive: `handle.values`
- * updates as the draft changes. Backs the card surface `slot.card.Value`.
- */
-declare function useResolvedCardTargetValue(): unknown;
-interface InteractionRootProps<Interaction extends string = InteractionKey> {
-    interaction: Interaction;
-    children: ReactNode;
-    unavailable?: "render" | "hide";
-}
-declare function InteractionRoot<Interaction extends string = InteractionKey>({ interaction, children, unavailable, }: InteractionRootProps<Interaction>): react_jsx_runtime.JSX.Element | null;
-
-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;
-
-interface InteractionSwitchRenderState<Interaction extends string = InteractionKey> {
-    interaction: Interaction;
-    descriptor: InteractionDescriptor<Interaction>;
-}
-type InteractionSwitchRouteMap<Interaction extends string = InteractionKey> = {
-    [Key in Interaction]?: (state: InteractionSwitchRenderState<Key>) => ReactNode;
-};
-interface InteractionRoute {
-    readonly collect: Record<string, unknown>;
-}
-type InteractionRoutesMap<Interaction extends string = InteractionKey> = {
-    [Key in Interaction]: InteractionRoute;
-};
-interface InteractionSwitchProps<Interaction extends string = InteractionKey> {
-    interaction?: Interaction;
-    routes: InteractionSwitchRouteMap<Interaction>;
-    fallback?: ReactNode;
-}
-declare function InteractionSwitch<Interaction extends string = InteractionKey>({ interaction, routes, fallback, }: InteractionSwitchProps<Interaction>): react_jsx_runtime.JSX.Element;
-interface InteractionRoutesProps<Interaction extends string = InteractionKey> {
-    routes: InteractionRoutesMap<Interaction>;
-    fallback?: ReactNode;
-    includeUnavailable?: boolean | null;
-}
-declare function InteractionRoutes<Interaction extends string = InteractionKey>({ routes, fallback, includeUnavailable, }: InteractionRoutesProps<Interaction>): react_jsx_runtime.JSX.Element | null;
-
-type DialogLifecycleState = "open" | "minimized" | "dismissed";
-
-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 InteractionSubmitCallbacks {
-    onSubmitSuccess?: () => void;
-    onSubmitError?: (error: unknown) => void;
-}
-
-type InteractionTriggerProps = PrimitiveCommonProps & ButtonHTMLAttributes<HTMLButtonElement>;
-declare function InteractionTrigger({ disabled, onClick, ...props }: InteractionTriggerProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
-type InteractionSubmitProps = PrimitiveCommonProps & ButtonHTMLAttributes<HTMLButtonElement> & {
-    params?: InteractionParamsShape | (() => InteractionParamsShape | null | undefined);
-    onSubmitSuccess?: InteractionSubmitCallbacks["onSubmitSuccess"];
-    onSubmitError?: InteractionSubmitCallbacks["onSubmitError"];
-};
-declare function InteractionSubmit({ disabled, onClick, params, onSubmitSuccess, onSubmitError, style, ...props }: InteractionSubmitProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
-type InteractionInputProps = PrimitiveCommonProps & Omit<InputHTMLAttributes<HTMLInputElement>, "name"> & {
-    name: string;
-    parse?: (value: string) => unknown;
-};
-declare function InteractionInput({ name, parse, onChange, disabled, ...props }: InteractionInputProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
-
-type InteractionPartProps = PrimitiveCommonProps & HTMLAttributes<HTMLElement>;
-declare function InteractionLabel({ children, ...props }: InteractionPartProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
-declare function InteractionDescription({ children, ...props }: InteractionPartProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | null;
-declare function InteractionUnavailableMessage({ children, ...props }: InteractionPartProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | null;
-declare function InteractionValidationMessage({ children, ...props }: InteractionPartProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | null;
-
-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];
-}
-
-/**
- * Headless input-slot factory for the interaction form: the slot prop types
- * and `createInteractionInputSlot`, which builds the
- * `Field`/`Default`/`Target`/`Card`/`Cards`/`Options`/`Value`/`Label`/`Message`
- * render surface (plus its shared `targetButton` helper) for a single input.
- *
- * Moved verbatim from `../InteractionForm.tsx`.
- */
-
-interface InteractionSlotComponentProps {
-    children?: ReactNode;
-}
-type InteractionButtonSlotProps = InteractionSlotComponentProps & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children" | "disabled" | "type" | "value">;
-interface InteractionTargetSlotProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children" | "disabled" | "aria-disabled" | "aria-pressed" | "onClick" | "type" | "value"> {
-    value: string;
-    children?: ReactNode;
-}
-interface InteractionOptionsSlotProps {
-    children: (option: {
-        value: string | null;
-        label: string;
-    }) => ReactNode;
-}
-interface InteractionCardsSlotProps {
-    children: (card: {
-        id: string;
-    }) => ReactNode;
-}
-interface InteractionValueSlotProps {
-    children: (value: unknown) => ReactNode;
-}
-interface InteractionInputSlot {
-    Field: (props: InteractionSlotComponentProps) => ReactNode;
-    Default: (props: InteractionSlotComponentProps) => ReactNode;
-    Target: (props: InteractionTargetSlotProps) => ReactNode;
-    Card: (props: InteractionTargetSlotProps) => ReactNode;
-    Cards: (props: InteractionCardsSlotProps) => ReactNode;
-    Options: (props: InteractionOptionsSlotProps) => ReactNode;
-    Value: (props: InteractionValueSlotProps) => ReactNode;
-    Label: (props: InteractionSlotComponentProps) => ReactNode;
-    Message: (props: InteractionSlotComponentProps) => ReactNode;
-}
-type InteractionInputRenderMap = Record<string, (slot: InteractionInputSlot) => ReactNode>;
-interface InteractionSubmitSlot {
-    Button: (props: InteractionButtonSlotProps) => ReactNode;
-}
-
-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>;
-    inputs?: InteractionInputRenderMap;
-    submit?: (slot: InteractionSubmitSlot, descriptor: InteractionDescriptor) => ReactNode;
-    title?: ReactNode;
-    description?: ReactNode;
-    submitLabel?: ReactNode;
-    cancelLabel?: ReactNode;
-    onCancel?: () => void;
-    onSubmitSuccess?: () => void;
-    disabled?: boolean;
-    accordion?: boolean;
-    defaultOpen?: boolean;
-    style?: CSSProperties;
-}
-
-type BoundInteractionFormProps<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never> = Omit<InteractionFormProps<Params, DefaultedKeys>, "descriptor" | "handle">;
-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 InteractionCardInputProps<Input extends string = InteractionInputKey> = PrimitiveCommonProps & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children"> & {
-    input: Input;
-    unsafeCardId?: string;
-    selected?: boolean;
-    onSelectedChange?: (selected: boolean) => void;
-    children?: ReactNode | ((state: InteractionCardInputRenderState) => ReactNode);
-};
-interface InteractionCardInputRenderState {
-    cardId: string | undefined;
-    zone: string | undefined;
-    selected: boolean;
-    disabled: boolean;
-    eligible: boolean;
-    targetValid: boolean;
-    selectable: boolean;
-    cardAvailable: boolean;
-    invalid: boolean;
-}
-declare function InteractionCardInput<Input extends string = InteractionInputKey>({ input, unsafeCardId, selected, onSelectedChange, onClick, disabled, children, ...props }: InteractionCardInputProps<Input>): react.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
-
-declare const Interaction: {
-    Root: typeof InteractionRoot;
-    State: typeof InteractionState;
-    Switch: typeof InteractionSwitch;
-    Routes: typeof InteractionRoutes;
-    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;
-};
-
-type PhaseRouteMap<Phase extends string = PhaseKey> = {
-    readonly [Key in Phase]: () => ReactNode;
-};
-type PhaseFallback = ReactNode | ((phase: string | null) => ReactNode);
-interface PhaseSwitchProps<Phase extends string = PhaseKey> {
-    routes: PhaseRouteMap<Phase>;
-    fallback?: PhaseFallback;
-}
-declare function PhaseSwitch<Phase extends string = PhaseKey>({ routes, fallback, }: PhaseSwitchProps<Phase>): ReactElement | null;
-declare const Phase: {
-    Switch: typeof PhaseSwitch;
-};
-
-interface PlayerRosterBadge {
-    key: string;
-    label?: ReactNode;
-    icon?: ReactNode;
-    tooltip?: string;
-}
-interface PlayerRosterEntry {
-    playerId: PlayerId;
-    name: string;
-    color?: HexColor;
-    index: number;
-    isActive: boolean;
-    isCurrentPlayer: boolean;
-    score?: number;
-    scoreLabel?: string;
-    badges: readonly PlayerRosterBadge[];
-    metadata?: Record<string, unknown>;
-}
-interface PlayerRosterRootProps {
-    children: ReactNode;
-    order?: "turn" | "self-first";
-    include?: "all" | "self" | "opponents";
-    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"> & {
-    children?: (player: PlayerRosterEntry) => ReactNode;
-};
-declare function PlayerRosterList({ children, ...props }: PlayerRosterListProps): ReactElement<unknown, string | react.JSXElementConstructor<any>>;
-declare function PlayerRosterEmpty({ children }: {
-    children?: ReactNode;
-}): react_jsx_runtime.JSX.Element | null;
-type PlayerRosterPartProps = PrimitiveCommonProps & HTMLAttributes<HTMLElement> & {
-    player: PlayerRosterEntry;
-};
-interface PlayerRosterComponents {
-    Root(props: PlayerRosterRootProps): ReactElement | null;
-    List(props: PlayerRosterListProps): ReactElement;
-    Empty(props: {
-        children?: ReactNode;
-    }): ReactElement | null;
-    Name(props: PlayerRosterPartProps): ReactElement;
-    Score(props: PlayerRosterPartProps): ReactElement | null;
-    Badges(props: PlayerRosterPartProps): ReactElement | null;
-}
-declare function PlayerRosterName({ player, children, ...props }: PlayerRosterPartProps): ReactElement<unknown, string | react.JSXElementConstructor<any>>;
-declare function PlayerRosterScore({ player, children, ...props }: PlayerRosterPartProps): ReactElement<unknown, string | react.JSXElementConstructor<any>> | null;
-declare function PlayerRosterBadges({ player, children, ...props }: PlayerRosterPartProps): ReactElement<unknown, string | react.JSXElementConstructor<any>> | null;
-declare const PlayerRoster: PlayerRosterComponents;
-
-type PromptRootProps<Prompt extends string = PromptKey> = InteractionRootProps<Prompt>;
-declare function PromptRoot<Prompt extends string = PromptKey>(props: PromptRootProps<Prompt>): react_jsx_runtime.JSX.Element;
-declare function PromptTitle(props: InteractionPartProps): react_jsx_runtime.JSX.Element;
-declare function PromptMessage(props: InteractionPartProps): react_jsx_runtime.JSX.Element | null;
-type PromptOptionProps<Option extends string = PromptOptionKey> = PrimitiveCommonProps & ButtonHTMLAttributes<HTMLButtonElement> & {
-    value: Option;
-    disableWhenUnavailable?: boolean;
-    onSubmitError?: InteractionSubmitCallbacks["onSubmitError"];
-    onSubmitSuccess?: InteractionSubmitCallbacks["onSubmitSuccess"];
-};
-declare function PromptOption<Option extends string = PromptOptionKey>({ value, disabled, disableWhenUnavailable, onClick, onSubmitError, onSubmitSuccess, children, ...props }: PromptOptionProps<Option>): react.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
-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;
-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;
-    Empty: typeof PromptInboxEmpty;
-    Items: typeof PromptInboxItems;
-};
-
-type DiceValue = number | null | undefined;
-interface DiceState {
-    values: ReadonlyArray<number | undefined> | undefined;
-    /** Undefined if any die has not been rolled yet. */
-    sum: number | undefined;
-    diceCount: number;
-    allRolled: boolean;
-}
-interface DiceRootProps {
-    values?: readonly DiceValue[] | null;
-    /** Used when values are not provided. */
-    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;
-
-/**
- * Workspace-aware UI typing extension point.
- *
- * Generated workspaces will augment this interface with their concrete UI
- * contract. The unregistered SDK keeps all public keys string-compatible so
- * package-local tests and generic consumers can still import ui-sdk directly.
- */
-interface DreamboardUIRegister {
-    readonly __dreamboardUIRegister?: never;
-}
-type UIContractBucket = Record<string, unknown>;
-interface UIContract {
-    interactions?: UIContractBucket;
-    inputs?: UIContractBucket;
-    prompts?: UIContractBucket;
-    promptOptions?: UIContractBucket;
-    players?: UIContractBucket;
-    zones?: UIContractBucket;
-    cards?: UIContractBucket;
-    phases?: UIContractBucket;
-    boardTargets?: UIContractBucket;
-}
-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 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 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: InteractionSwitchRouteMap<InteractionKey<Contract>>;
-    }): ReactElement;
-    Routes(props: Omit<InteractionRoutesProps<InteractionKey<Contract>>, "routes"> & {
-        routes: InteractionRoutesMap<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 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 TypedPromptInbox<Contract extends UIContract> = Omit<typeof PromptInbox, "Items"> & {
-    Items(props: Omit<PromptInboxItemsProps, "children"> & {
-        children: (prompt: Omit<InteractionDescriptor, "interactionKey"> & {
-            interactionKey: PromptKey<Contract>;
-        }) => ReactNode;
-    }): ReactElement;
-};
-type TypedPlayerRosterEntry<Player extends string> = Omit<PlayerRosterEntry, "playerId"> & {
-    playerId: Player;
-};
-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 TypedPlayerRoster<Contract extends UIContract> = Omit<PlayerRosterComponents, "Root" | "List" | "Name" | "Score" | "Badges"> & {
-    Root(props: TypedPlayerRosterRootProps<PlayerKey<Contract>>): ReactElement | null;
-    List(props: TypedPlayerRosterListProps<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" | "SquareGrid"> & {
-    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;
-    SquareGrid<TBoard extends AnySquareBoardInput>(props: Omit<BoardSquareGridProps<TBoard>, "interactions"> & {
-        interactions?: Exclude<BoardSquareGridInteractionFilter, 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;
-    Chrome(props: GameChromeProps<View, Player, Phase, InteractionKey<_Contract>>): 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>;
-}
-
-export { InteractionDescription as $, type DiceState as A, Board as B, type DiceValue as C, Dice as D, DiceValues as E, type DiceValuesProps as F, type DreamboardUI as G, Game as H, type GameActiveActionState as I, GameChrome as J, type GameChromeProps as K, type GameChromeState as L, type GameMeState as M, type GamePendingInputState as N, type GamePlayer as O, type GamePlayerEntry as P, type GamePlayersState as Q, type GameRenderState as R, GameRoot as S, type GameRootProps as T, type GameTurnState as U, GameViewport as V, type GameViewportProps as W, Interaction as X, InteractionCardInput as Y, type InteractionCardInputProps as Z, type InteractionCardInputRenderState as _, BoardEdgeTarget as a, type PromptOptionsProps as a$, InteractionDialog as a0, type InteractionDialogProps as a1, type InteractionDialogRenderState as a2, type InteractionDialogState as a3, type InteractionFieldPrimitiveProps as a4, InteractionFormPrimitive as a5, type InteractionFormPrimitiveProps as a6, InteractionInput as a7, type InteractionInputProps as a8, InteractionLabel as a9, type PlayerRosterBadge as aA, PlayerRosterBadges as aB, type PlayerRosterComponents as aC, PlayerRosterEmpty as aD, type PlayerRosterEntry as aE, PlayerRosterList as aF, type PlayerRosterListProps as aG, PlayerRosterName as aH, type PlayerRosterPartProps as aI, PlayerRosterRoot as aJ, type PlayerRosterRootProps as aK, PlayerRosterScore as aL, Prompt as aM, PromptDialog as aN, type PromptDialogProps as aO, type PromptDialogRenderState as aP, type PromptDialogState as aQ, PromptInbox as aR, PromptInboxEmpty as aS, PromptInboxItems as aT, type PromptInboxItemsProps as aU, PromptInboxRoot as aV, PromptMessage as aW, PromptOption as aX, type PromptOptionProps as aY, type PromptOptionRenderItem as aZ, PromptOptions as a_, type InteractionPartProps as aa, InteractionRoot as ab, type InteractionRootProps as ac, type InteractionRoute as ad, InteractionRoutes as ae, type InteractionRoutesMap as af, type InteractionRoutesProps as ag, InteractionState as ah, type InteractionStateProps as ai, type InteractionStateSnapshot as aj, InteractionSubmit as ak, type InteractionSubmitProps as al, InteractionSwitch as am, type InteractionSwitchProps as an, type InteractionSwitchRenderState as ao, type InteractionSwitchRouteMap as ap, InteractionTrigger as aq, type InteractionTriggerProps as ar, InteractionUnavailableMessage as as, InteractionValidationMessage as at, Phase as au, type PhaseFallback as av, type PhaseRouteMap as aw, PhaseSwitch as ax, type PhaseSwitchProps as ay, PlayerRoster as az, type BoardEdgeTargetProps as b, PromptRoot as b0, type PromptRootProps as b1, PromptTitle as b2, type TypedGame as b3, UI as b4, type UIContract as b5, UIRoot as b6, type UIRootProps as b7, type UseZoneCardsOptions as b8, type UseZoneCardsResult as b9, type ZoneRootProps as bA, ZoneTopCard as bB, type ZoneTopCardProps as bC, createZoneCardRenderItem as bD, normalizeDiceState as bE, useBoardPrimitiveContext as bF, useDicePrimitiveContext as bG, useGameActionError as bH, useInteractionPrimitiveContext as bI, useOptionalZonePrimitiveContext as bJ, useResolvedCardTargetValue as bK, useZoneCardContext as bL, useZoneCards as bM, useZonePileContext as bN, useZonePrimitiveContext as bO, Zone as ba, ZoneCardAction as bb, type ZoneCardActionExtraInputs as bc, type ZoneCardActionProps as bd, type ZoneCardActionResult as be, ZoneCardAt as bf, type ZoneCardAtProps as bg, type ZoneCardRenderItem as bh, ZoneItem as bi, type ZoneItemProps as bj, ZoneList as bk, type ZoneListProps as bl, ZonePileCards as bm, type ZonePileCardsProps as bn, type ZonePileContextValue as bo, ZonePileCount as bp, type ZonePileCountProps as bq, ZonePileDescription as br, type ZonePileDescriptionProps as bs, ZonePileLabel as bt, type ZonePileLabelProps as bu, ZonePileRoot as bv, type ZonePileRootProps as bw, ZonePileTrigger as bx, type ZonePileTriggerProps as by, ZoneRoot as bz, type BoardGridInteractionFilter as c, BoardHexGrid as d, type BoardHexGridInteractionFilter as e, type BoardHexGridInteractions as f, type BoardHexGridProps as g, BoardHexView as h, type BoardHexViewProps as i, BoardRoot as j, type BoardRootProps as k, BoardSpaceTarget as l, type BoardSpaceTargetProps as m, BoardSquareGrid as n, type BoardSquareGridInteractionFilter as o, type BoardSquareGridProps as p, BoardState as q, type BoardStateProps as r, BoardTarget as s, type BoardTargetExtraInputs as t, type BoardTargetProps as u, BoardVertexTarget as v, type BoardVertexTargetProps as w, type DiceComponents as x, DiceRoot as y, type DiceRootProps as z };