@dreamboard-games/sdk 0.4.0-alpha.11 → 0.4.0-alpha.13

package/dist/runtime/workspace-contract.d.ts

@@ -1,18 +1,23 @@
-export { C as ClientParamSchemaMap, D as DefineGameUIConfig, W as WorkspaceBoardSurface, a as WorkspaceBoardSurfaceDescriptor, b as WorkspaceBoardTargetInputSlot, c as WorkspaceCardCollectionSurface, d as WorkspaceCardCollectionSurfaceDescriptor, e as WorkspaceCardInputSlot, f as WorkspaceFormInputSlot, g as WorkspaceHandSurface, h as WorkspaceHandSurfaceDescriptor, i as WorkspaceInteractionFormDescriptor, j as WorkspaceInteractionFormsDescriptor, k as WorkspaceInteractionSlotComponent, l as WorkspacePileSurface, m as WorkspacePileSurfaceDescriptor, n as WorkspacePilesSurfaceDescriptor, o as WorkspaceSurfaceSpec, p as createWorkspaceUIContract } from '../index-CRfZ21dM.js';
-import { a1 as InteractionDialogProps } from '../ui-contract-BC4JpysE.js';
-export { c as BoardGridInteractionFilter, g as BoardHexGridProps, i as BoardHexViewProps, m as BoardSpaceTargetProps, o as BoardSquareGridInteractionFilter, p as BoardSquareGridProps, G as DreamboardUI, M as GameMeState, Q as GamePlayersState, R as GameRenderState, U as GameTurnState, b3 as TypedGame, b5 as UIContract, b7 as UIRootProps, bh as ZoneCardRenderItem, bl as ZoneListProps } from '../ui-contract-BC4JpysE.js';
-export { b as ResourceCounterComponents } from '../ResourceCounter-BFxJknqp.js';
-import { ReactNode } from 'react';
-import '../hex-board-view-aKkblDp6.js';
+import { W as WorkspaceBoardSurface, l as WorkspaceInteractionSlotComponent, c as WorkspaceBoardTargetInputSlot, g as WorkspaceFormInputSlot, p as WorkspaceSurfaceSpec, b as WorkspaceBoardSurfaceDescriptor, i as WorkspaceHandSurfaceDescriptor, n as WorkspacePileSurfaceDescriptor, o as WorkspacePilesSurfaceDescriptor, e as WorkspaceCardCollectionSurfaceDescriptor, j as WorkspaceInteractionFormDescriptor, k as WorkspaceInteractionFormsDescriptor, D as DefineGameUIConfig, C as ClientParamSchema } from '../index-CR69MyWr.js';
+export { a as ClientParamSchemaMap, d as WorkspaceCardCollectionSurface, f as WorkspaceCardInputSlot, h as WorkspaceHandSurface, m as WorkspacePileSurface, q as createWorkspaceUIContract } from '../index-CR69MyWr.js';
+import { a1 as InteractionDialogProps, bl as ZoneListProps, bh as ZoneCardRenderItem, R as GameRenderState, b5 as UIContract, G as DreamboardUI, M as GameMeState, Q as GamePlayersState, U as GameTurnState, b7 as UIRootProps, b3 as TypedGame, i as BoardHexViewProps, g as BoardHexGridProps, p as BoardSquareGridProps } from '../ui-contract-BC4JpysE.js';
+export { c as BoardGridInteractionFilter, m as BoardSpaceTargetProps, o as BoardSquareGridInteractionFilter } from '../ui-contract-BC4JpysE.js';
+import { ReactNode, ButtonHTMLAttributes, ReactElement } from 'react';
+import { b as InteractionDescriptor } from '../plugin-state-BRH3UiUp.js';
+import { av as PhaseNamesOfDefinition, a8 as InteractionIdOfDefinitionPhase, x as ClientParamsOfInteractionOfDefinition, a3 as InputKeysWithCollectorKindOfDefinition, I as DefaultedClientParamKeysOfInteractionOfDefinition, bd as ViewNamesOfDefinition, be as ViewOfDefinition } from '../views-BbCGDuCs.js';
+import { P as InteractionVisualState, d as BoardSpaceIdOf, A as AnyHexBoardInput, a as AnySquareBoardInput } from '../hex-board-view-aKkblDp6.js';
+import { b as ResourceCounterComponents } from '../ResourceCounter-BFxJknqp.js';
 import 'react/jsx-runtime';
-import '../player-state-Cqpyeql0.js';
-import '../types.js';
 import '../ThemeProvider-CElaL2ik.js';
-import '../plugin-state-BRH3UiUp.js';
+import '../types.js';
 import '../primitive-props-BNHDkgd7.js';
 import '../attributes-DbvyMbXw.js';
 import '../types-DJj5MJkl.js';
 import '../runtime-api-CgPuEVeF.js';
+import '../player-state-Cqpyeql0.js';
+import '../runtime-BhuaOkIL.js';
+import 'zod';
+import './protocol-Bcas2Xa8.js';
 
 interface WorkspaceInteractionFormDialogProps extends Omit<InteractionDialogProps, "children"> {
     title: ReactNode;
@@ -24,4 +29,331 @@ interface WorkspaceInteractionFormDialogProps extends Omit<InteractionDialogProp
     showCloseButton?: boolean;
 }
 
-export type { WorkspaceInteractionFormDialogProps };
+interface GameUiManifestTypes {
+    readonly PlayerId: string;
+    readonly ResourceId: string;
+    readonly ZoneId: string;
+    readonly CardId: string;
+    readonly CardType: string;
+    readonly CardProperties: Record<string, unknown>;
+    readonly BoardBaseId: string;
+    readonly SpaceId: string;
+    readonly EdgeId: string;
+    readonly VertexId: string;
+    readonly PlayerCardZoneId: string;
+    readonly CardZoneId: string;
+}
+type GameUiPhaseName<Game> = PhaseNamesOfDefinition<Game>;
+type GameUiViewName<Game> = ViewNamesOfDefinition<Game>;
+type GameUiView<Game> = Extract<"player", GameUiViewName<Game>> extends never ? never : ViewOfDefinition<Game, Extract<"player", GameUiViewName<Game>>>;
+type GameUiInteractionIdForPhase<Game, Phase extends GameUiPhaseName<Game>> = InteractionIdOfDefinitionPhase<Game, Phase>;
+type GameUiInteractionKey<Game> = {
+    [Phase in GameUiPhaseName<Game>]: `${Phase}.${GameUiInteractionIdForPhase<Game, Phase>}`;
+}[GameUiPhaseName<Game>];
+type PhaseOfInteractionKey<Game, Key extends GameUiInteractionKey<Game>> = Key extends `${infer Phase}.${string}` ? Extract<Phase, GameUiPhaseName<Game>> : never;
+type IdOfInteractionKey<Game, Key extends GameUiInteractionKey<Game>> = Key extends `${infer Phase}.${infer Id}` ? Phase extends GameUiPhaseName<Game> ? Extract<Id, GameUiInteractionIdForPhase<Game, Phase>> : never : never;
+type GameUiInteractionParamsOf<Game, Key extends GameUiInteractionKey<Game>> = ClientParamsOfInteractionOfDefinition<Game, PhaseOfInteractionKey<Game, Key>, IdOfInteractionKey<Game, Key>>;
+type CollectorKind = "form" | "board-vertex" | "board-edge" | "board-tile" | "board-space" | "card" | "prompt";
+type AuthoredInputKeys<Game, Key extends GameUiInteractionKey<Game>> = InputKeysWithCollectorKindOfDefinition<Game, PhaseOfInteractionKey<Game, Key>, IdOfInteractionKey<Game, Key>, CollectorKind> extends infer Input ? string extends Input ? never : Input & string : never;
+type GameUiInteractionInputKeys<Game, Key extends GameUiInteractionKey<Game>> = (string extends keyof GameUiInteractionParamsOf<Game, Key> ? never : keyof GameUiInteractionParamsOf<Game, Key> & string) | AuthoredInputKeys<Game, Key> | (DefaultedClientParamKeysOfInteractionOfDefinition<Game, PhaseOfInteractionKey<Game, Key>, IdOfInteractionKey<Game, Key>> & string);
+type GameUiInteractionSlot = {
+    readonly Field: WorkspaceInteractionSlotComponent;
+    readonly Options: WorkspaceInteractionSlotComponent<{
+        children: (option: {
+            value: unknown;
+            label: string;
+        }) => ReactNode;
+    }>;
+    readonly Value: WorkspaceInteractionSlotComponent<{
+        children: (value: unknown | undefined) => ReactNode;
+    }>;
+    readonly Default: WorkspaceInteractionSlotComponent;
+    readonly Card: WorkspaceInteractionSlotComponent<{
+        value: string;
+    }>;
+    readonly Cards: WorkspaceInteractionSlotComponent<{
+        children: (card: {
+            id: string;
+        }) => ReactNode;
+    }>;
+    readonly Target: WorkspaceInteractionSlotComponent<{
+        value: string;
+    }>;
+};
+type GameUiCollectorSlot<Game, Key extends GameUiInteractionKey<Game>, Input extends GameUiInteractionInputKeys<Game, Key>> = Input extends InputKeysWithCollectorKindOfDefinition<Game, PhaseOfInteractionKey<Game, Key>, IdOfInteractionKey<Game, Key>, "board-space"> ? WorkspaceBoardTargetInputSlot<"space", never> : Input extends InputKeysWithCollectorKindOfDefinition<Game, PhaseOfInteractionKey<Game, Key>, IdOfInteractionKey<Game, Key>, "board-edge"> ? WorkspaceBoardTargetInputSlot<"edge", never> : Input extends InputKeysWithCollectorKindOfDefinition<Game, PhaseOfInteractionKey<Game, Key>, IdOfInteractionKey<Game, Key>, "board-vertex"> ? WorkspaceBoardTargetInputSlot<"vertex", never> : Input extends InputKeysWithCollectorKindOfDefinition<Game, PhaseOfInteractionKey<Game, Key>, IdOfInteractionKey<Game, Key>, "board-tile"> ? WorkspaceBoardTargetInputSlot<"tile", never> : Input extends InputKeysWithCollectorKindOfDefinition<Game, PhaseOfInteractionKey<Game, Key>, IdOfInteractionKey<Game, Key>, "card"> ? GameUiInteractionSlot : WorkspaceFormInputSlot<Input>;
+type GameUiInteractionFormSurface<Game, Contract extends UIContract, Key extends GameUiInteractionKey<Game>> = {
+    readonly Root: WorkspaceInteractionSlotComponent;
+    readonly Form: DreamboardUI<Contract>["Interaction"]["Form"];
+    readonly Dialog: (props: WorkspaceInteractionFormDialogProps) => ReactElement | null;
+    readonly State: DreamboardUI<Contract>["Interaction"]["State"];
+    readonly Arm: DreamboardUI<Contract>["Interaction"]["Trigger"];
+    readonly Submit: DreamboardUI<Contract>["Interaction"]["Submit"];
+    readonly Field: <Input extends GameUiInteractionInputKeys<Game, Key>>(props: {
+        input: Input;
+        children?: ReactNode;
+    }) => ReactElement | null;
+    readonly slot: {
+        readonly [Input in GameUiInteractionInputKeys<Game, Key>]: GameUiCollectorSlot<Game, Key, Input>;
+    };
+};
+type GameUiInteractionRoutes<Game> = Partial<{
+    [Key in GameUiInteractionKey<Game>]: {
+        readonly collect: {
+            [Input in GameUiInteractionInputKeys<Game, Key>]: GameUiCollectorSlot<Game, Key, Input>;
+        };
+    };
+}>;
+type GameUiZoneCard<Manifest extends GameUiManifestTypes> = ZoneCardRenderItem<Manifest["CardId"], Manifest["CardType"], Manifest["CardProperties"]> extends infer Item ? Item extends {
+    zone: string;
+} ? Omit<Item, "zone"> & {
+    zone: Manifest["ZoneId"];
+} : never : never;
+type GameUiBoardSurface<Manifest extends GameUiManifestTypes, _Board extends Manifest["BoardBaseId"] = Manifest["BoardBaseId"]> = WorkspaceBoardSurface<Manifest["SpaceId"], Manifest["EdgeId"], Manifest["VertexId"], Manifest["SpaceId"]> & {
+    readonly __board?: _Board;
+};
+type ZoneCardsComponent<Manifest extends GameUiManifestTypes> = WorkspaceInteractionSlotComponent<Omit<ZoneListProps, "children" | "empty"> & {
+    empty?: ReactNode;
+    children: (card: GameUiZoneCard<Manifest>) => ReactNode;
+}>;
+type ZoneCardComponent<Manifest extends GameUiManifestTypes> = WorkspaceInteractionSlotComponent<Omit<ButtonHTMLAttributes<HTMLButtonElement>, "type" | "value"> & {
+    card: GameUiZoneCard<Manifest>;
+}>;
+type GameUiHandCardIntent<Card extends string, Target extends string> = {
+    type: "activate";
+    cardId: Card;
+    source: "tap" | "keyboard";
+} | {
+    type: "previewStart";
+    cardId: Card;
+} | {
+    type: "previewEnd";
+    cardId: Card;
+} | {
+    type: "drop";
+    cardId: Card;
+    targetId: Target;
+    source: "pointer" | "keyboard";
+};
+type GameUiHandSelectionSummary<Card extends string> = {
+    readonly selectedCount: number;
+    readonly selectedIds: readonly Card[];
+    readonly hasInvalidSelection: boolean;
+};
+type GameUiHandProps<Manifest extends GameUiManifestTypes> = Omit<ZoneListProps, "children" | "empty"> & {
+    empty?: ReactNode;
+    children: (card: GameUiZoneCard<Manifest>, state: InteractionVisualState) => ReactNode;
+    layout?: "fan" | "compressed-fan" | "tray" | "strip" | "stack" | {
+        desktop?: "fan" | "compressed-fan" | "tray" | "strip" | "stack";
+        mobile?: "fan" | "compressed-fan" | "tray" | "strip" | "stack";
+    };
+    mobileInteraction?: "direct-activate" | "drag-to-target";
+    cardSize?: "sm" | "md" | "lg";
+    ariaLabel?: string;
+    dropTargets?: ReadonlyArray<{
+        target: {
+            readonly kind: "card";
+            readonly card: Manifest["CardId"];
+        } | {
+            readonly kind: "space" | "tile";
+            readonly target: Manifest["SpaceId"];
+        } | {
+            readonly kind: "edge";
+            readonly target: Manifest["EdgeId"];
+        } | {
+            readonly kind: "vertex";
+            readonly target: Manifest["VertexId"];
+        };
+        label: string;
+        render: (state: unknown) => ReactNode;
+        className?: string;
+        role?: string;
+        order?: number;
+    }>;
+    renderDropTargets?: (children: ReactNode) => ReactNode;
+    onCardIntent?: (intent: GameUiHandCardIntent<Manifest["CardId"], Manifest["CardId"] | Manifest["SpaceId"] | Manifest["EdgeId"] | Manifest["VertexId"]>) => void;
+    onSelectionSummary?: (summary: GameUiHandSelectionSummary<Manifest["CardId"]>) => void;
+};
+type GameUiHandSurface<Manifest extends GameUiManifestTypes, Zones extends readonly Manifest["ZoneId"][] = readonly Manifest["ZoneId"][]> = {
+    readonly Hand: WorkspaceInteractionSlotComponent<Omit<GameUiHandProps<Manifest>, "children"> & {
+        children: ReactNode;
+    }>;
+    readonly Cards: WorkspaceInteractionSlotComponent<{
+        children: (card: GameUiZoneCard<Manifest>, state: InteractionVisualState) => ReactNode;
+    }>;
+    readonly Summary: (props: {
+        children?: ReactNode | ((summary: GameUiHandSelectionSummary<Manifest["CardId"]>) => ReactNode);
+    }) => ReactElement | null;
+    readonly Actions: (props: {
+        children?: ReactNode | ((summary: GameUiHandSelectionSummary<Manifest["CardId"]>) => ReactNode);
+    }) => ReactElement | null;
+    readonly Card: ZoneCardComponent<Manifest>;
+    readonly Staging: WorkspaceInteractionSlotComponent<{
+        children: (card: Extract<GameUiZoneCard<Manifest>, {
+            hidden: false;
+        }>) => ReactNode;
+        label?: ReactNode;
+        renderEmptySlot?: (index: number) => ReactNode;
+        cardSize?: "sm" | "md" | "lg";
+        ariaLabel?: string;
+        className?: string;
+    }>;
+    readonly slot: {
+        readonly card: GameUiInteractionSlot & {
+            readonly __zones?: Zones;
+        };
+    };
+};
+type GameUiPileSurface<Manifest extends GameUiManifestTypes> = {
+    readonly Pile: ZoneCardsComponent<Manifest>;
+    readonly Card: ZoneCardComponent<Manifest>;
+};
+type GameUiCardCollectionSurface<Manifest extends GameUiManifestTypes, Zones extends readonly Manifest["ZoneId"][] = readonly Manifest["ZoneId"][]> = {
+    readonly Collection: ZoneCardsComponent<Manifest>;
+    readonly Card: ZoneCardComponent<Manifest>;
+    readonly slot: {
+        readonly card: GameUiInteractionSlot & {
+            readonly __zones?: Zones;
+        };
+    };
+};
+type UiRegistry<Game, Manifest extends GameUiManifestTypes> = {
+    interactions: {
+        [Key in GameUiInteractionKey<Game>]: {
+            interaction: Key;
+            phase: PhaseOfInteractionKey<Game, Key>;
+            id: IdOfInteractionKey<Game, Key>;
+        };
+    };
+    inputs: {
+        [Key in GameUiInteractionInputKeys<Game, GameUiInteractionKey<Game>>]: {
+            input: Key;
+        };
+    };
+    prompts: {
+        [Key in GameUiInteractionKey<Game>]: {
+            interaction: Key;
+        };
+    };
+    promptOptions: Record<string, {
+        value: string;
+    }>;
+    players: {
+        [Key in Manifest["PlayerId"]]: {
+            player: Key;
+        };
+    };
+    zones: {
+        [Key in Manifest["ZoneId"]]: {
+            zone: Key;
+        };
+    };
+    cards: {
+        [Key in Manifest["CardId"]]: {
+            card: Key;
+        };
+    };
+    phases: {
+        [Key in GameUiPhaseName<Game>]: {
+            phase: Key;
+        };
+    };
+    boardTargets: {
+        [Key in Manifest["SpaceId"] | Manifest["EdgeId"] | Manifest["VertexId"]]: {
+            target: Key;
+        };
+    };
+};
+type GameUiContract<Game, Manifest extends GameUiManifestTypes> = UiRegistry<Game, Manifest>;
+type SurfaceValue<Game, Manifest extends GameUiManifestTypes, Contract extends UIContract, Spec> = Spec extends WorkspaceBoardSurfaceDescriptor<infer Board extends Manifest["BoardBaseId"]> ? GameUiBoardSurface<Manifest, Board> : Spec extends WorkspaceHandSurfaceDescriptor<infer Zone extends Manifest["PlayerCardZoneId"]> ? GameUiHandSurface<Manifest, readonly [Zone]> : Spec extends WorkspacePileSurfaceDescriptor<infer Zone extends Manifest["CardZoneId"]> ? GameUiPileSurface<Manifest> & {
+    readonly __zone?: Zone;
+} : Spec extends WorkspacePilesSurfaceDescriptor<infer Zones extends readonly Manifest["CardZoneId"][]> ? {
+    readonly [Zone in Zones[number]]: GameUiPileSurface<Manifest>;
+} : Spec extends WorkspaceCardCollectionSurfaceDescriptor<infer Zones extends readonly Manifest["CardZoneId"][]> ? GameUiCardCollectionSurface<Manifest, Zones> : Spec extends WorkspaceInteractionFormDescriptor<infer Interaction extends GameUiInteractionKey<Game>> ? GameUiInteractionFormSurface<Game, Contract, Interaction> : Spec extends WorkspaceInteractionFormsDescriptor<infer Forms extends Readonly<Record<string, GameUiInteractionKey<Game>>>> ? {
+    readonly [Key in keyof Forms]: GameUiInteractionFormSurface<Game, Contract, Forms[Key]>;
+} : Spec extends WorkspaceSurfaceSpec ? {
+    readonly [Key in keyof Spec]: SurfaceValue<Game, Manifest, Contract, Spec[Key]>;
+} : never;
+type GameUiHexBoardId<HexBoards> = keyof HexBoards & string;
+type GameUiSquareBoardId<SquareBoards> = keyof SquareBoards & string;
+type GameUiHexBoardTopology<HexBoards, Id extends GameUiHexBoardId<HexBoards>> = Extract<HexBoards[Id], AnyHexBoardInput>;
+type GameUiSquareBoardTopology<SquareBoards, Id extends GameUiSquareBoardId<SquareBoards>> = Extract<SquareBoards[Id], AnySquareBoardInput>;
+type GameUiHexBoardSpaceId<HexBoards, Id extends GameUiHexBoardId<HexBoards>> = BoardSpaceIdOf<GameUiHexBoardTopology<HexBoards, Id>>;
+type GameUiBoardNamespace<Manifest extends GameUiManifestTypes, Contract extends UIContract, HexBoards, SquareBoards> = Omit<DreamboardUI<Contract>["Board"], "HexView" | "HexGrid" | "SquareGrid"> & {
+    surface<const Board extends Manifest["BoardBaseId"]>(board: Board): WorkspaceBoardSurfaceDescriptor<Board>;
+    useSurface<const Board extends Manifest["BoardBaseId"]>(name: string, options?: {
+        board: Board;
+    }): GameUiBoardSurface<Manifest, Board>;
+    HexView<const Id extends GameUiHexBoardId<HexBoards>, const SpaceView extends {
+        id: GameUiHexBoardSpaceId<HexBoards, Id>;
+    }>(props: Omit<BoardHexViewProps<GameUiHexBoardTopology<HexBoards, Id>, SpaceView>, "board"> & {
+        board: Id;
+    }): ReactElement;
+    HexGrid<const Id extends GameUiHexBoardId<HexBoards>, const SpaceView extends {
+        id: GameUiHexBoardSpaceId<HexBoards, Id>;
+    }>(props: Omit<BoardHexGridProps<GameUiHexBoardTopology<HexBoards, Id>, SpaceView>, "board" | "interactions"> & {
+        board: Id;
+    }): ReactElement;
+    SquareGrid<const Id extends GameUiSquareBoardId<SquareBoards>>(props: Omit<BoardSquareGridProps<GameUiSquareBoardTopology<SquareBoards, Id>>, "board" | "interactions"> & {
+        board: Id;
+    }): ReactElement;
+};
+type GameWorkspaceUI<Game, Manifest extends GameUiManifestTypes, Contract extends GameUiContract<Game, Manifest>, HexBoards, SquareBoards> = Omit<DreamboardUI<Contract>, "Root" | "Game" | "Interaction" | "Board" | "Zone" | "Prompt" | "PromptInbox"> & {
+    Root(props: UIRootProps): ReactElement;
+    defineSurfaces<const Spec extends WorkspaceSurfaceSpec>(spec: Spec): () => SurfaceValue<Game, Manifest, Contract, Spec>;
+    defineGameUI<Surfaces>(config: DefineGameUIConfig<GameRenderState<GameUiView<Game>, Manifest["PlayerId"], GameUiPhaseName<Game>>, Surfaces> & {
+        useSurfaces: () => Surfaces;
+        interactionRoutes?: () => GameUiInteractionRoutes<Game>;
+        phases: {
+            readonly [Phase in GameUiPhaseName<Game>]: (context: {
+                game: GameRenderState<GameUiView<Game>, Manifest["PlayerId"], GameUiPhaseName<Game>>;
+                surfaces: Surfaces;
+            }) => ReactNode;
+        };
+    }): (props: Omit<UIRootProps, "children">) => ReactElement;
+    readonly Game: TypedGame<Contract, GameUiView<Game>, Manifest["PlayerId"], GameUiPhaseName<Game>>;
+    readonly Interaction: Pick<DreamboardUI<Contract>["Interaction"], "State" | "Dialog"> & {
+        useForm<Key extends GameUiInteractionKey<Game>>(interaction: Key): GameUiInteractionFormSurface<Game, Contract, Key>;
+        form<const Interaction extends GameUiInteractionKey<Game>>(interaction: Interaction): WorkspaceInteractionFormDescriptor<Interaction>;
+        forms<const Interactions extends Readonly<Record<string, GameUiInteractionKey<Game>>>>(interactions: Interactions): WorkspaceInteractionFormsDescriptor<Interactions>;
+        Routes(props: {
+            routes: GameUiInteractionRoutes<Game>;
+            fallback?: ReactNode;
+            includeUnavailable?: boolean | null;
+        }): ReactElement;
+    };
+    readonly Board: GameUiBoardNamespace<Manifest, Contract, HexBoards, SquareBoards>;
+    readonly Zone: {
+        hand<const Zone extends Manifest["PlayerCardZoneId"]>(zone: Zone, options: {
+            role: "primary" | "auxiliary" | "task";
+            label: string;
+            order?: number;
+        }): WorkspaceHandSurfaceDescriptor<Zone>;
+        pile<const Zone extends Manifest["CardZoneId"]>(zone: Zone): WorkspacePileSurfaceDescriptor<Zone>;
+        collection<const Zones extends readonly Manifest["CardZoneId"][]>(zones: Zones, options?: {
+            mode?: "all" | "top-card";
+        }): WorkspaceCardCollectionSurfaceDescriptor<Zones>;
+    } & DreamboardUI<Contract>["Zone"];
+    readonly ResourceCounter: ResourceCounterComponents<Manifest["ResourceId"]>;
+};
+interface CreateGameUiContractOptions<Game, Manifest extends GameUiManifestTypes, HexBoards extends Record<string, unknown>, SquareBoards extends Record<string, unknown>> {
+    readonly game: Game;
+    readonly resourceIds: readonly Manifest["ResourceId"][];
+    readonly resourcePresentationById?: Partial<Record<string, {
+        label?: string;
+        icon?: string;
+    }>>;
+    readonly hexStaticBoards: HexBoards;
+    readonly squareStaticBoards: SquareBoards;
+}
+declare function createGameUiContract<Game, Manifest extends GameUiManifestTypes, HexBoards extends Record<string, unknown>, SquareBoards extends Record<string, unknown>>(options: CreateGameUiContractOptions<Game, Manifest, HexBoards, SquareBoards>): {
+    uiContract: GameUiContract<Game, Manifest>;
+    UI: GameWorkspaceUI<Game, Manifest, GameUiContract<Game, Manifest>, HexBoards, SquareBoards>;
+    clientParamSchemasByPhase: Readonly<Record<string, Readonly<Record<string, ClientParamSchema>>>>;
+};
+type GameUiGameRootState<Game, Manifest extends GameUiManifestTypes> = GameRenderState<GameUiView<Game>, Manifest["PlayerId"], GameUiPhaseName<Game>>;
+type GameUiPlayers<Manifest extends GameUiManifestTypes> = GamePlayersState<Manifest["PlayerId"]>;
+type GameUiMe<Manifest extends GameUiManifestTypes> = GameMeState<Manifest["PlayerId"]>;
+type GameUiTurn<Game, Manifest extends GameUiManifestTypes> = GameTurnState<Manifest["PlayerId"], GameUiPhaseName<Game>>;
+type GameUiInteractionDescriptor<Game, Key extends GameUiInteractionKey<Game>> = InteractionDescriptor<Key>;
+
+export { BoardHexGridProps, BoardHexViewProps, BoardSquareGridProps, DefineGameUIConfig, DreamboardUI, GameMeState, GamePlayersState, GameRenderState, GameTurnState, type GameUiBoardSurface, type GameUiCardCollectionSurface, type GameUiContract, type GameUiGameRootState, type GameUiHandSurface, type GameUiInteractionDescriptor, type GameUiInteractionFormSurface, type GameUiInteractionKey, type GameUiInteractionParamsOf, type GameUiInteractionRoutes, type GameUiManifestTypes, type GameUiMe, type GameUiPhaseName, type GameUiPileSurface, type GameUiPlayers, type GameUiTurn, type GameUiView, type GameUiViewName, type GameWorkspaceUI, ResourceCounterComponents, TypedGame, UIContract, UIRootProps, WorkspaceBoardSurface, WorkspaceBoardSurfaceDescriptor, WorkspaceBoardTargetInputSlot, WorkspaceCardCollectionSurfaceDescriptor, WorkspaceFormInputSlot, WorkspaceHandSurfaceDescriptor, WorkspaceInteractionFormDescriptor, type WorkspaceInteractionFormDialogProps, WorkspaceInteractionFormsDescriptor, WorkspaceInteractionSlotComponent, WorkspacePileSurfaceDescriptor, WorkspacePilesSurfaceDescriptor, WorkspaceSurfaceSpec, ZoneCardRenderItem, ZoneListProps, createGameUiContract };

package/dist/runtime/workspace-contract.js

@@ -1,17 +1,23 @@
 import {
+  createGameUiContract,
   createWorkspaceUIContract
-} from "../chunk-RP6QDQGI.js";
+} from "../chunk-7JBPOJOF.js";
+import "../chunk-VWTKGIYF.js";
 import "../chunk-WAQUD4IG.js";
 import "../chunk-MPVC2SU6.js";
 import "../chunk-T3ZKNUZ7.js";
 import "../chunk-YOLIZMXR.js";
 import "../chunk-VDXOF4FW.js";
 import "../chunk-B33RRZ4O.js";
+import "../chunk-5XTAQ4EQ.js";
+import "../chunk-YNW3KBDE.js";
 import "../chunk-WHR5UW3F.js";
 import "../chunk-PF7L4BMG.js";
 import "../chunk-FBQNCOPQ.js";
+import "../chunk-3PFDHTR7.js";
 import "../chunk-PZ5AY32C.js";
 export {
+  createGameUiContract,
   createWorkspaceUIContract
 };
 //# sourceMappingURL=workspace-contract.js.map

package/dist/runtime.d.ts

@@ -1,6 +1,6 @@
 import { b5 as UIContract$1, G as DreamboardUI$1, b3 as TypedGame$1 } from './ui-contract-BC4JpysE.js';
 export { c as BoardGridInteractionFilter, g as BoardHexGridProps, i as BoardHexViewProps, m as BoardSpaceTargetProps, o as BoardSquareGridInteractionFilter, p as BoardSquareGridProps, M as GameMeState, Q as GamePlayersState, R as GameRenderState, U as GameTurnState, b7 as UIRootProps, bh as ZoneCardRenderItem, bl as ZoneListProps } from './ui-contract-BC4JpysE.js';
-export { C as ClientParamSchemaMap, W as WorkspaceBoardSurface, a as WorkspaceBoardSurfaceDescriptor, b as WorkspaceBoardTargetInputSlot, c as WorkspaceCardCollectionSurface, d as WorkspaceCardCollectionSurfaceDescriptor, e as WorkspaceCardInputSlot, f as WorkspaceFormInputSlot, g as WorkspaceHandSurface, h as WorkspaceHandSurfaceDescriptor, i as WorkspaceInteractionFormDescriptor, j as WorkspaceInteractionFormsDescriptor, k as WorkspaceInteractionSlotComponent, l as WorkspacePileSurface, m as WorkspacePileSurfaceDescriptor, n as WorkspacePilesSurfaceDescriptor, o as WorkspaceSurfaceSpec, p as createWorkspaceUIContract } from './index-CRfZ21dM.js';
+export { a as ClientParamSchemaMap, W as WorkspaceBoardSurface, b as WorkspaceBoardSurfaceDescriptor, c as WorkspaceBoardTargetInputSlot, d as WorkspaceCardCollectionSurface, e as WorkspaceCardCollectionSurfaceDescriptor, f as WorkspaceCardInputSlot, g as WorkspaceFormInputSlot, h as WorkspaceHandSurface, i as WorkspaceHandSurfaceDescriptor, j as WorkspaceInteractionFormDescriptor, k as WorkspaceInteractionFormsDescriptor, l as WorkspaceInteractionSlotComponent, m as WorkspacePileSurface, n as WorkspacePileSurfaceDescriptor, o as WorkspacePilesSurfaceDescriptor, p as WorkspaceSurfaceSpec, q as createWorkspaceUIContract } from './index-CR69MyWr.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import react__default from 'react';
 import { c as RuntimeDiagnosticHandler } from './runtime-api-CgPuEVeF.js';

package/dist/runtime.js

@@ -1,6 +1,7 @@
 import {
   createWorkspaceUIContract
-} from "./chunk-RP6QDQGI.js";
+} from "./chunk-7JBPOJOF.js";
+import "./chunk-VWTKGIYF.js";
 import "./chunk-WAQUD4IG.js";
 import "./chunk-MPVC2SU6.js";
 import "./chunk-T3ZKNUZ7.js";
@@ -13,17 +14,20 @@ import {
   createPluginRuntimeClient
 } from "./chunk-NQTXQWUP.js";
 import "./chunk-B33RRZ4O.js";
+import "./chunk-5XTAQ4EQ.js";
+import "./chunk-YNW3KBDE.js";
 import "./chunk-WHR5UW3F.js";
 import "./chunk-PF7L4BMG.js";
 import {
   DREAMBOARD_SDK_VERSION
-} from "./chunk-HRWI2DIJ.js";
-import "./chunk-CP3BF3B2.js";
+} from "./chunk-MLFHVYF7.js";
+import "./chunk-THWT4V3Z.js";
 import {
   DREAMBOARD_PLUGIN_PROTOCOL,
   DREAMBOARD_PLUGIN_PROTOCOL_VERSION,
   HostToPluginEnvelopeSchema
 } from "./chunk-FBQNCOPQ.js";
+import "./chunk-3PFDHTR7.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/runtime/hooks/usePluginRuntime.ts

package/dist/runtime.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/runtime/hooks/usePluginRuntime.ts","../src/runtime/browser/post-message-transport.ts","../src/runtime/components/PluginRuntime.tsx"],"sourcesContent":["import { useState, useEffect, useRef } from \"react\";\nimport { DREAMBOARD_SDK_VERSION } from \"../../package-set.js\";\nimport { createPostMessagePluginTransport } from \"../browser/post-message-transport.js\";\nimport { createPluginRuntimeClient } from \"../core/create-plugin-runtime-client.js\";\nimport type { PluginRuntimeClient } from \"../core/types.js\";\nimport type { RuntimeDiagnosticHandler } from \"../types/runtime-api.js\";\n\nconst BUNDLED_SDK_VERSION = DREAMBOARD_SDK_VERSION;\n\nexport interface UsePluginRuntimeOptions {\n  /**\n   * Timeout in milliseconds to wait for the first gameplay frame.\n   * @default 10000 (10 seconds)\n   */\n  timeout?: number;\n  onDiagnostic?: RuntimeDiagnosticHandler;\n}\n\nexport interface UsePluginRuntimeResult {\n  /** The transport-agnostic plugin runtime client. */\n  runtime: PluginRuntimeClient;\n  /** Whether the initial reducer-native snapshot is available and ready */\n  isReady: boolean;\n  /**\n   * True when the plugin was ready before but the current snapshot has no\n   * projected view — e.g. you've acted and are waiting on the rest of the\n   * table in a simultaneous phase. Lets the loading affordance read as a\n   * mid-game wait rather than a cold \"still loading\" stall.\n   */\n  waiting: boolean;\n  /** Error message if initialization failed */\n  error: string | null;\n}\n\nfunction hasProjectedView(runtime: PluginRuntimeClient): boolean {\n  const frame = runtime.getFrame();\n  return (\n    frame !== null && frame.view !== null && typeof frame.view !== \"undefined\"\n  );\n}\n\n/**\n * Hook that creates and manages a PluginRuntimeClient instance.\n *\n * This hook handles:\n * 1. Creating the runtime client\n * 2. Waiting for the first gameplay frame before setting isReady\n *\n * In the new architecture, the host only renders the plugin when a reducer-native\n * snapshot is available, so isReady should become true quickly after init.\n *\n * @example\n * ```tsx\n * function PluginRuntime({ children }: { children: React.ReactNode }) {\n *   const { runtime, isReady, error } = usePluginRuntime();\n *\n *   if (error) {\n *     return <div>Error: {error}</div>;\n *   }\n *\n *   if (!isReady) {\n *     return <GameSkeleton message=\"Waiting for game state...\" />;\n *   }\n *\n *   return <RuntimeProvider runtime={runtime}>{children}</RuntimeProvider>;\n * }\n * ```\n */\nexport function usePluginRuntime(\n  options: UsePluginRuntimeOptions = {},\n): UsePluginRuntimeResult {\n  const { timeout = 10000, onDiagnostic } = options;\n  const [error, setError] = useState<string | null>(null);\n\n  // Create runtime once and keep stable reference\n  const [runtime] = useState<PluginRuntimeClient>(() =>\n    createPluginRuntimeClient({\n      transport: createPostMessagePluginTransport({\n        bundledSdkVersion: BUNDLED_SDK_VERSION,\n        onInvalidMessage: (reason, value) => {\n          const message =\n            `Plugin runtime rejected a host message (${reason}). ` +\n            `Bundled @dreamboard-games/sdk version: ${BUNDLED_SDK_VERSION}. ` +\n            \"The host and plugin bundle may have incompatible SDK/runtime contract versions.\";\n          setError(message);\n          onDiagnostic?.({\n            type: \"runtimeLog\",\n            level: \"warn\",\n            message,\n            details: [value],\n          });\n        },\n      }),\n    }),\n  );\n  const [isReady, setIsReady] = useState(() => hasProjectedView(runtime));\n  // Latches once we've shown a view, so a later view-less snapshot reads as a\n  // mid-game wait rather than a fresh load. (A ref, so it never re-triggers a\n  // render on its own.)\n  const hasBeenReadyRef = useRef(false);\n  if (isReady) hasBeenReadyRef.current = true;\n\n  useEffect(() => {\n    void onDiagnostic;\n  }, [onDiagnostic]);\n\n  // Subscribe to gameplay frames and set isReady when the first projected view arrives.\n  useEffect(() => {\n    const markReadyFromFrame = () => {\n      if (!hasProjectedView(runtime)) {\n        return false;\n      }\n      setError(null);\n      setIsReady(true);\n      return true;\n    };\n\n    if (markReadyFromFrame()) {\n      return;\n    }\n\n    // Set up timeout\n    const timeoutId = setTimeout(() => {\n      if (!markReadyFromFrame()) {\n        setError(\n          `Timed out waiting for the initial projected view after ${timeout}ms. ` +\n            \"Ensure the host sends a gameplay frame with a seat view.\",\n        );\n      }\n    }, timeout);\n\n    // Fallback poll for dev/HMR flows where the runtime frame may already\n    // exist but the first subscribe callback is missed.\n    const pollId = setInterval(() => {\n      if (markReadyFromFrame()) {\n        clearInterval(pollId);\n        clearTimeout(timeoutId);\n      }\n    }, 100);\n\n    const unsubscribe = runtime.subscribeFrame(() => {\n      if (!hasProjectedView(runtime)) {\n        setIsReady(false);\n        return;\n      }\n      clearInterval(pollId);\n      clearTimeout(timeoutId);\n      setError(null);\n      setIsReady(true);\n    });\n\n    return () => {\n      clearInterval(pollId);\n      clearTimeout(timeoutId);\n      unsubscribe?.();\n    };\n  }, [runtime, timeout]);\n\n  return {\n    runtime,\n    isReady,\n    waiting: hasBeenReadyRef.current && !isReady,\n    error,\n  };\n}\n","import {\n  DREAMBOARD_PLUGIN_PROTOCOL,\n  DREAMBOARD_PLUGIN_PROTOCOL_VERSION,\n  HostToPluginEnvelopeSchema,\n  type HostToPluginEnvelope,\n  type PluginToHostPayload,\n} from \"@dreamboard-games/plugin-runtime-contract\";\nimport type { PluginTransport } from \"../core/types.js\";\n\nexport interface PostMessagePluginTransportOptions {\n  readonly targetWindow?: Window;\n  readonly parentWindow?: Window;\n  readonly bundledSdkVersion?: string;\n  readonly onInvalidMessage?: (reason: string, value: unknown) => void;\n}\n\nexport function createPostMessagePluginTransport(\n  options: PostMessagePluginTransportOptions = {},\n): PluginTransport {\n  const targetWindow = options.targetWindow ?? window;\n  const parentWindow = options.parentWindow ?? targetWindow.parent;\n  const bundledSdkVersion = options.bundledSdkVersion?.trim() || \"unknown\";\n  let channel: {\n    readonly channelId: string;\n    readonly hostOrigin: string;\n    readonly hostWindow: Window;\n  } | null = null;\n  let outboundSequence = 0;\n  let invalidEnvelopeReported = false;\n\n  const reportInvalidEnvelope = (reason: string, value: unknown) => {\n    options.onInvalidMessage?.(reason, value);\n\n    if (!channel || invalidEnvelopeReported) {\n      return;\n    }\n\n    invalidEnvelopeReported = true;\n    channel.hostWindow.postMessage(\n      {\n        protocol: DREAMBOARD_PLUGIN_PROTOCOL,\n        version: DREAMBOARD_PLUGIN_PROTOCOL_VERSION,\n        channelId: channel.channelId,\n        sequence: ++outboundSequence,\n        payload: {\n          type: \"runtime.error\",\n          code: \"host-runtime-protocol-mismatch\",\n          message:\n            `Plugin runtime rejected a host message (${reason}). ` +\n            `Bundled @dreamboard-games/sdk version: ${bundledSdkVersion}. ` +\n            \"The host and plugin bundle may have incompatible SDK/runtime contract versions.\",\n        },\n      },\n      channel.hostOrigin,\n    );\n  };\n\n  return {\n    start(onMessage) {\n      const handleMessage = (event: MessageEvent) => {\n        if (event.source !== parentWindow) {\n          return;\n        }\n        const parseResult = HostToPluginEnvelopeSchema.safeParse(event.data);\n        if (!parseResult.success) {\n          reportInvalidEnvelope(\"invalid-envelope\", event.data);\n          return;\n        }\n        const envelope = parseResult.data;\n        if (!channel) {\n          if (envelope.payload.type !== \"runtime.init\") {\n            return;\n          }\n          channel = {\n            channelId: envelope.channelId,\n            hostOrigin: event.origin,\n            hostWindow: event.source as Window,\n          };\n        }\n        if (\n          envelope.channelId !== channel.channelId ||\n          event.origin !== channel.hostOrigin ||\n          event.source !== channel.hostWindow\n        ) {\n          reportInvalidEnvelope(\"channel-mismatch\", event.data);\n          return;\n        }\n        onMessage(envelope as HostToPluginEnvelope);\n      };\n\n      targetWindow.addEventListener(\"message\", handleMessage);\n      return () => {\n        targetWindow.removeEventListener(\"message\", handleMessage);\n        channel = null;\n      };\n    },\n    send(payload: PluginToHostPayload) {\n      if (!channel) {\n        throw new Error(\"Plugin transport is not initialized.\");\n      }\n      channel.hostWindow.postMessage(\n        {\n          protocol: DREAMBOARD_PLUGIN_PROTOCOL,\n          version: DREAMBOARD_PLUGIN_PROTOCOL_VERSION,\n          channelId: channel.channelId,\n          sequence: ++outboundSequence,\n          payload,\n        },\n        channel.hostOrigin,\n      );\n    },\n  };\n}\n","import React from \"react\";\nimport { usePluginRuntime } from \"../hooks/usePluginRuntime.js\";\nimport { GameSkeleton } from \"../../ui.js\";\nimport type { RuntimeDiagnosticHandler } from \"../types/runtime-api.js\";\nimport { PluginRuntimeBoundary } from \"./PluginRuntimeBoundary.js\";\n\nexport interface PluginRuntimeProps {\n  /** Child components to render after gameplay frame has started */\n  children: React.ReactNode;\n  /**\n   * Timeout in milliseconds to wait for the first gameplay-frame snapshot.\n   * @default 10000 (10 seconds)\n   */\n  timeout?: number;\n  /** Custom loading component to show while waiting for gameplay frame */\n  loadingComponent?: React.ReactNode;\n  /** Custom error component to show when initialization fails */\n  errorComponent?: (error: string) => React.ReactNode;\n  onDiagnostic?: RuntimeDiagnosticHandler;\n}\n\n/**\n * PluginRuntime provides the RuntimeContext for plugin components.\n *\n * This component:\n * - Creates a transport-backed runtime client\n * - Waits for the first projected gameplay frame before rendering children\n * - Provides runtime commands plus session/frame state to all child components\n *\n * @example\n * ```tsx\n * // In your plugin's index.tsx\n * import { PluginRuntime } from \"./components/dreamboard\";\n * import App from './App';\n *\n * ReactDOM.createRoot(document.getElementById('root')!).render(\n *   <PluginRuntime>\n *     <App />\n *   </PluginRuntime>\n * );\n * ```\n */\nexport function PluginRuntime({\n  children,\n  timeout = 10000,\n  loadingComponent,\n  errorComponent,\n  onDiagnostic,\n}: PluginRuntimeProps) {\n  const { runtime, isReady, waiting, error } = usePluginRuntime({\n    timeout,\n    onDiagnostic,\n  });\n\n  if (error) {\n    if (errorComponent) {\n      return <>{errorComponent(error)}</>;\n    }\n    return (\n      <div className=\"flex h-full w-full items-center justify-center bg-gray-50\">\n        <div className=\"text-center p-6\">\n          <p className=\"text-red-600 font-medium mb-2\">Failed to load game</p>\n          <p className=\"text-gray-600 text-sm\">{error}</p>\n        </div>\n      </div>\n    );\n  }\n\n  if (!isReady) {\n    if (loadingComponent) {\n      return <>{loadingComponent}</>;\n    }\n    // Once the game has rendered, a view-less snapshot is a mid-game wait (you\n    // acted and are waiting on the table), not a cold load — say so rather than\n    // reading as a stalled \"Waiting for game state\".\n    return (\n      <GameSkeleton\n        message={\n          waiting\n            ? \"Waiting for the other players…\"\n            : \"Waiting for game state...\"\n        }\n      />\n    );\n  }\n\n  return (\n    <PluginRuntimeBoundary runtime={runtime}>{children}</PluginRuntimeBoundary>\n  );\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/runtime/hooks/usePluginRuntime.ts","../src/runtime/browser/post-message-transport.ts","../src/runtime/components/PluginRuntime.tsx"],"sourcesContent":["import { useState, useEffect, useRef } from \"react\";\nimport { DREAMBOARD_SDK_VERSION } from \"../../package-set.js\";\nimport { createPostMessagePluginTransport } from \"../browser/post-message-transport.js\";\nimport { createPluginRuntimeClient } from \"../core/create-plugin-runtime-client.js\";\nimport type { PluginRuntimeClient } from \"../core/types.js\";\nimport type { RuntimeDiagnosticHandler } from \"../types/runtime-api.js\";\n\nconst BUNDLED_SDK_VERSION = DREAMBOARD_SDK_VERSION;\n\nexport interface UsePluginRuntimeOptions {\n  /**\n   * Timeout in milliseconds to wait for the first gameplay frame.\n   * @default 10000 (10 seconds)\n   */\n  timeout?: number;\n  onDiagnostic?: RuntimeDiagnosticHandler;\n}\n\nexport interface UsePluginRuntimeResult {\n  /** The transport-agnostic plugin runtime client. */\n  runtime: PluginRuntimeClient;\n  /** Whether the initial reducer-native snapshot is available and ready */\n  isReady: boolean;\n  /**\n   * True when the plugin was ready before but the current snapshot has no\n   * projected view — e.g. you've acted and are waiting on the rest of the\n   * table in a simultaneous phase. Lets the loading affordance read as a\n   * mid-game wait rather than a cold \"still loading\" stall.\n   */\n  waiting: boolean;\n  /** Error message if initialization failed */\n  error: string | null;\n}\n\nfunction hasProjectedView(runtime: PluginRuntimeClient): boolean {\n  const frame = runtime.getFrame();\n  return (\n    frame !== null && frame.view !== null && typeof frame.view !== \"undefined\"\n  );\n}\n\n/**\n * Hook that creates and manages a PluginRuntimeClient instance.\n *\n * This hook handles:\n * 1. Creating the runtime client\n * 2. Waiting for the first gameplay frame before setting isReady\n *\n * In the new architecture, the host only renders the plugin when a reducer-native\n * snapshot is available, so isReady should become true quickly after init.\n *\n * @example\n * ```tsx\n * function PluginRuntime({ children }: { children: React.ReactNode }) {\n *   const { runtime, isReady, error } = usePluginRuntime();\n *\n *   if (error) {\n *     return <div>Error: {error}</div>;\n *   }\n *\n *   if (!isReady) {\n *     return <GameSkeleton message=\"Waiting for game state...\" />;\n *   }\n *\n *   return <RuntimeProvider runtime={runtime}>{children}</RuntimeProvider>;\n * }\n * ```\n */\nexport function usePluginRuntime(\n  options: UsePluginRuntimeOptions = {},\n): UsePluginRuntimeResult {\n  const { timeout = 10000, onDiagnostic } = options;\n  const [error, setError] = useState<string | null>(null);\n\n  // Create runtime once and keep stable reference\n  const [runtime] = useState<PluginRuntimeClient>(() =>\n    createPluginRuntimeClient({\n      transport: createPostMessagePluginTransport({\n        bundledSdkVersion: BUNDLED_SDK_VERSION,\n        onInvalidMessage: (reason, value) => {\n          const message =\n            `Plugin runtime rejected a host message (${reason}). ` +\n            `Bundled @dreamboard-games/sdk version: ${BUNDLED_SDK_VERSION}. ` +\n            \"The host and plugin bundle may have incompatible SDK/runtime contract versions.\";\n          setError(message);\n          onDiagnostic?.({\n            type: \"runtimeLog\",\n            level: \"warn\",\n            message,\n            details: [value],\n          });\n        },\n      }),\n    }),\n  );\n  const [isReady, setIsReady] = useState(() => hasProjectedView(runtime));\n  // Latches once we've shown a view, so a later view-less snapshot reads as a\n  // mid-game wait rather than a fresh load. (A ref, so it never re-triggers a\n  // render on its own.)\n  const hasBeenReadyRef = useRef(false);\n  if (isReady) hasBeenReadyRef.current = true;\n\n  useEffect(() => {\n    void onDiagnostic;\n  }, [onDiagnostic]);\n\n  // Subscribe to gameplay frames and set isReady when the first projected view arrives.\n  useEffect(() => {\n    const markReadyFromFrame = () => {\n      if (!hasProjectedView(runtime)) {\n        return false;\n      }\n      setError(null);\n      setIsReady(true);\n      return true;\n    };\n\n    if (markReadyFromFrame()) {\n      return;\n    }\n\n    // Set up timeout\n    const timeoutId = setTimeout(() => {\n      if (!markReadyFromFrame()) {\n        setError(\n          `Timed out waiting for the initial projected view after ${timeout}ms. ` +\n            \"Ensure the host sends a gameplay frame with a seat view.\",\n        );\n      }\n    }, timeout);\n\n    // Fallback poll for dev/HMR flows where the runtime frame may already\n    // exist but the first subscribe callback is missed.\n    const pollId = setInterval(() => {\n      if (markReadyFromFrame()) {\n        clearInterval(pollId);\n        clearTimeout(timeoutId);\n      }\n    }, 100);\n\n    const unsubscribe = runtime.subscribeFrame(() => {\n      if (!hasProjectedView(runtime)) {\n        setIsReady(false);\n        return;\n      }\n      clearInterval(pollId);\n      clearTimeout(timeoutId);\n      setError(null);\n      setIsReady(true);\n    });\n\n    return () => {\n      clearInterval(pollId);\n      clearTimeout(timeoutId);\n      unsubscribe?.();\n    };\n  }, [runtime, timeout]);\n\n  return {\n    runtime,\n    isReady,\n    waiting: hasBeenReadyRef.current && !isReady,\n    error,\n  };\n}\n","import {\n  DREAMBOARD_PLUGIN_PROTOCOL,\n  DREAMBOARD_PLUGIN_PROTOCOL_VERSION,\n  HostToPluginEnvelopeSchema,\n  type HostToPluginEnvelope,\n  type PluginToHostPayload,\n} from \"@dreamboard-games/plugin-runtime-contract\";\nimport type { PluginTransport } from \"../core/types.js\";\n\nexport interface PostMessagePluginTransportOptions {\n  readonly targetWindow?: Window;\n  readonly parentWindow?: Window;\n  readonly bundledSdkVersion?: string;\n  readonly onInvalidMessage?: (reason: string, value: unknown) => void;\n}\n\nexport function createPostMessagePluginTransport(\n  options: PostMessagePluginTransportOptions = {},\n): PluginTransport {\n  const targetWindow = options.targetWindow ?? window;\n  const parentWindow = options.parentWindow ?? targetWindow.parent;\n  const bundledSdkVersion = options.bundledSdkVersion?.trim() || \"unknown\";\n  let channel: {\n    readonly channelId: string;\n    readonly hostOrigin: string;\n    readonly hostWindow: Window;\n  } | null = null;\n  let outboundSequence = 0;\n  let invalidEnvelopeReported = false;\n\n  const reportInvalidEnvelope = (reason: string, value: unknown) => {\n    options.onInvalidMessage?.(reason, value);\n\n    if (!channel || invalidEnvelopeReported) {\n      return;\n    }\n\n    invalidEnvelopeReported = true;\n    channel.hostWindow.postMessage(\n      {\n        protocol: DREAMBOARD_PLUGIN_PROTOCOL,\n        version: DREAMBOARD_PLUGIN_PROTOCOL_VERSION,\n        channelId: channel.channelId,\n        sequence: ++outboundSequence,\n        payload: {\n          type: \"runtime.error\",\n          code: \"host-runtime-protocol-mismatch\",\n          message:\n            `Plugin runtime rejected a host message (${reason}). ` +\n            `Bundled @dreamboard-games/sdk version: ${bundledSdkVersion}. ` +\n            \"The host and plugin bundle may have incompatible SDK/runtime contract versions.\",\n        },\n      },\n      channel.hostOrigin,\n    );\n  };\n\n  return {\n    start(onMessage) {\n      const handleMessage = (event: MessageEvent) => {\n        if (event.source !== parentWindow) {\n          return;\n        }\n        const parseResult = HostToPluginEnvelopeSchema.safeParse(event.data);\n        if (!parseResult.success) {\n          reportInvalidEnvelope(\"invalid-envelope\", event.data);\n          return;\n        }\n        const envelope = parseResult.data;\n        if (!channel) {\n          if (envelope.payload.type !== \"runtime.init\") {\n            return;\n          }\n          channel = {\n            channelId: envelope.channelId,\n            hostOrigin: event.origin,\n            hostWindow: event.source as Window,\n          };\n        }\n        if (\n          envelope.channelId !== channel.channelId ||\n          event.origin !== channel.hostOrigin ||\n          event.source !== channel.hostWindow\n        ) {\n          reportInvalidEnvelope(\"channel-mismatch\", event.data);\n          return;\n        }\n        onMessage(envelope as HostToPluginEnvelope);\n      };\n\n      targetWindow.addEventListener(\"message\", handleMessage);\n      return () => {\n        targetWindow.removeEventListener(\"message\", handleMessage);\n        channel = null;\n      };\n    },\n    send(payload: PluginToHostPayload) {\n      if (!channel) {\n        throw new Error(\"Plugin transport is not initialized.\");\n      }\n      channel.hostWindow.postMessage(\n        {\n          protocol: DREAMBOARD_PLUGIN_PROTOCOL,\n          version: DREAMBOARD_PLUGIN_PROTOCOL_VERSION,\n          channelId: channel.channelId,\n          sequence: ++outboundSequence,\n          payload,\n        },\n        channel.hostOrigin,\n      );\n    },\n  };\n}\n","import React from \"react\";\nimport { usePluginRuntime } from \"../hooks/usePluginRuntime.js\";\nimport { GameSkeleton } from \"../../ui.js\";\nimport type { RuntimeDiagnosticHandler } from \"../types/runtime-api.js\";\nimport { PluginRuntimeBoundary } from \"./PluginRuntimeBoundary.js\";\n\nexport interface PluginRuntimeProps {\n  /** Child components to render after gameplay frame has started */\n  children: React.ReactNode;\n  /**\n   * Timeout in milliseconds to wait for the first gameplay-frame snapshot.\n   * @default 10000 (10 seconds)\n   */\n  timeout?: number;\n  /** Custom loading component to show while waiting for gameplay frame */\n  loadingComponent?: React.ReactNode;\n  /** Custom error component to show when initialization fails */\n  errorComponent?: (error: string) => React.ReactNode;\n  onDiagnostic?: RuntimeDiagnosticHandler;\n}\n\n/**\n * PluginRuntime provides the RuntimeContext for plugin components.\n *\n * This component:\n * - Creates a transport-backed runtime client\n * - Waits for the first projected gameplay frame before rendering children\n * - Provides runtime commands plus session/frame state to all child components\n *\n * @example\n * ```tsx\n * // In your plugin's index.tsx\n * import { PluginRuntime } from \"./components/dreamboard\";\n * import App from './App';\n *\n * ReactDOM.createRoot(document.getElementById('root')!).render(\n *   <PluginRuntime>\n *     <App />\n *   </PluginRuntime>\n * );\n * ```\n */\nexport function PluginRuntime({\n  children,\n  timeout = 10000,\n  loadingComponent,\n  errorComponent,\n  onDiagnostic,\n}: PluginRuntimeProps) {\n  const { runtime, isReady, waiting, error } = usePluginRuntime({\n    timeout,\n    onDiagnostic,\n  });\n\n  if (error) {\n    if (errorComponent) {\n      return <>{errorComponent(error)}</>;\n    }\n    return (\n      <div className=\"flex h-full w-full items-center justify-center bg-gray-50\">\n        <div className=\"text-center p-6\">\n          <p className=\"text-red-600 font-medium mb-2\">Failed to load game</p>\n          <p className=\"text-gray-600 text-sm\">{error}</p>\n        </div>\n      </div>\n    );\n  }\n\n  if (!isReady) {\n    if (loadingComponent) {\n      return <>{loadingComponent}</>;\n    }\n    // Once the game has rendered, a view-less snapshot is a mid-game wait (you\n    // acted and are waiting on the table), not a cold load — say so rather than\n    // reading as a stalled \"Waiting for game state\".\n    return (\n      <GameSkeleton\n        message={\n          waiting\n            ? \"Waiting for the other players…\"\n            : \"Waiting for game state...\"\n        }\n      />\n    );\n  }\n\n  return (\n    <PluginRuntimeBoundary runtime={runtime}>{children}</PluginRuntimeBoundary>\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/testing-runtime.js

@@ -5,11 +5,11 @@ import {
   materializeScenarioRuntimeCheckpoint,
   replayScenario,
   resolveScenarioCommandParams
-} from "./chunk-RU3Z5J6V.js";
-import "./chunk-5XTAQ4EQ.js";
+} from "./chunk-KZFHTUI5.js";
 import {
   interactionDomainEligibleCount
 } from "./chunk-XDGRC6OR.js";
+import "./chunk-5XTAQ4EQ.js";
 import "./chunk-YNW3KBDE.js";
 import "./chunk-PF7L4BMG.js";
 import "./chunk-FBQNCOPQ.js";