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

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

@@ -1,392 +0,0 @@
-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-CcT9Q7N7.js';
-export { a as ClientParamSchemaMap, d as WorkspaceCardCollectionSurface, f as WorkspaceCardInputSlot, h as WorkspaceHandSurface, m as WorkspacePileSurface, q as createWorkspaceUIContract } from '../index-CcT9Q7N7.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-GTUPkf8z.js';
-export { c as BoardGridInteractionFilter, m as BoardSpaceTargetProps, o as BoardSquareGridInteractionFilter } from '../ui-contract-GTUPkf8z.js';
-import { ReactNode, ButtonHTMLAttributes, ReactElement } from 'react';
-import { b as InteractionDescriptor } from '../runtime-api-Bz5pwNU_.js';
-import { av as PhaseNamesOfDefinition, a8 as InteractionIdOfDefinitionPhase, x as ClientParamsOfInteractionOfDefinition, a3 as InputKeysWithCollectorKindOfDefinition, I as DefaultedClientParamKeysOfInteractionOfDefinition, bd as ViewNamesOfDefinition, be as ViewOfDefinition, aH as ReducerGameContractLike } from '../views-BpuWcOyN.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 { z } from 'zod';
-import { bk as RuntimeCardData } from '../runtime-RJ5orDJU.js';
-import 'react/jsx-runtime';
-import '../ThemeProvider-CElaL2ik.js';
-import '../types.js';
-import '../primitive-props-BNHDkgd7.js';
-import '../attributes-DbvyMbXw.js';
-import '../types-DJj5MJkl.js';
-import '../player-state-Cqpyeql0.js';
-import './protocol-dYgafTYY.js';
-
-interface WorkspaceInteractionFormDialogProps extends Omit<InteractionDialogProps, "children"> {
-    title: ReactNode;
-    description?: ReactNode;
-    trigger?: ReactNode;
-    children: ReactNode;
-    contentClassName?: string;
-    overlayClassName?: string;
-    showCloseButton?: boolean;
-}
-
-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 GameUiInteractionRoute<Game, Key extends GameUiInteractionKey<Game>> = {
-    readonly collect: {
-        [Input in GameUiInteractionInputKeys<Game, Key>]: GameUiCollectorSlot<Game, Key, Input>;
-    };
-};
-type GameUiSimultaneousSubmitKey<Game> = Extract<GameUiInteractionKey<Game>, `${string}.submit`>;
-type GameUiNamedInteractionKey<Game> = Exclude<GameUiInteractionKey<Game>, GameUiSimultaneousSubmitKey<Game>>;
-type GameUiInteractionRoutes<Game> = {
-    [Key in GameUiNamedInteractionKey<Game>]: GameUiInteractionRoute<Game, Key>;
-} & {
-    [Key in GameUiSimultaneousSubmitKey<Game>]?: GameUiInteractionRoute<Game, Key>;
-};
-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>;
-
-type GameWithManifest = {
-    contract: ReducerGameContractLike;
-};
-type ManifestOf<G extends GameWithManifest> = G["contract"]["manifest"];
-type Id<G extends GameWithManifest, K extends keyof ManifestOf<G>["ids"]> = z.output<ManifestOf<G>["ids"][K]> & string;
-type Table<G extends GameWithManifest> = z.output<ManifestOf<G>["tableSchema"]>;
-type GameUiManifestOf<G extends GameWithManifest> = {
-    PlayerId: Id<G, "playerId">;
-    ResourceId: Id<G, "resourceId">;
-    ZoneId: Id<G, "zoneId">;
-    CardId: Id<G, "cardId">;
-    CardType: Id<G, "cardType">;
-    CardProperties: Table<G>["cards"][keyof Table<G>["cards"]] extends RuntimeCardData ? Table<G>["cards"][keyof Table<G>["cards"]]["properties"] : Record<string, unknown>;
-    BoardBaseId: Id<G, "boardBaseId">;
-    SpaceId: Id<G, "spaceId">;
-    EdgeId: Id<G, "edgeId">;
-    VertexId: Id<G, "vertexId">;
-    PlayerCardZoneId: Id<G, "playerZoneId">;
-    CardZoneId: Id<G, "zoneId">;
-};
-type GameUiRootStateOf<G extends GameWithManifest> = GameUiGameRootState<G, GameUiManifestOf<G>>;
-type GameUiHandSurfaceOf<G extends GameWithManifest> = GameUiHandSurface<GameUiManifestOf<G>>;
-/** Bind UI primitives directly to an authored game's inferred contract. */
-declare function createGameUi<const G extends GameWithManifest>(game: G): {
-    uiContract: GameUiContract<G, GameUiManifestOf<G>>;
-    UI: GameWorkspaceUI<G, GameUiManifestOf<G>, GameUiContract<G, GameUiManifestOf<G>>, NonNullable<ManifestOf<G>["staticBoards"]>["hex"], NonNullable<ManifestOf<G>["staticBoards"]>["square"]>;
-    clientParamSchemasByPhase: Readonly<Record<string, Readonly<Record<string, ClientParamSchema>>>>;
-};
-
-export { BoardHexGridProps, BoardHexViewProps, BoardSquareGridProps, DefineGameUIConfig, DreamboardUI, GameMeState, GamePlayersState, GameRenderState, GameTurnState, type GameUiBoardSurface, type GameUiCardCollectionSurface, type GameUiContract, type GameUiGameRootState, type GameUiHandSurface, type GameUiHandSurfaceOf, type GameUiInteractionDescriptor, type GameUiInteractionFormSurface, type GameUiInteractionKey, type GameUiInteractionParamsOf, type GameUiInteractionRoutes, type GameUiManifestOf, type GameUiManifestTypes, type GameUiMe, type GameUiPhaseName, type GameUiPileSurface, type GameUiPlayers, type GameUiRootStateOf, 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, createGameUi, createGameUiContract };

package/dist/runtime/workspace-contract.js

@@ -1,28 +0,0 @@
-import {
-  createGameUi,
-  createGameUiContract,
-  createWorkspaceUIContract
-} from "../chunk-EVCLTY4Q.js";
-import "../chunk-ANRB4XKA.js";
-import "../chunk-PN5O6GG2.js";
-import "../chunk-LR3ZTWQF.js";
-import "../chunk-T3ZKNUZ7.js";
-import "../chunk-GDPKTBUR.js";
-import "../chunk-3SKDNDPG.js";
-import "../chunk-32PFKDV7.js";
-import "../chunk-VDXOF4FW.js";
-import "../chunk-WHR5UW3F.js";
-import "../chunk-VCDWP5VL.js";
-import "../chunk-ZZGN2ATS.js";
-import "../chunk-H6VDGFL5.js";
-import "../chunk-5YV2WHJ4.js";
-import "../chunk-PF7L4BMG.js";
-import "../chunk-Z7QCREWI.js";
-import "../chunk-UGH54WZ2.js";
-import "../chunk-PZ5AY32C.js";
-export {
-  createGameUi,
-  createGameUiContract,
-  createWorkspaceUIContract
-};
-//# sourceMappingURL=workspace-contract.js.map

package/dist/runtime/workspace-contract.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}