@dreamboard-games/sdk 0.2.1-alpha.0 → 0.3.0-alpha.1

package/dist/types.d.ts

@@ -1,16 +1,1455 @@
-import { M as GameTopologyManifest$1, H as DieTypeSpec$1, g as BoardEdgeRef, o as BoardVertexRef, al as JsonValue } from './index-BwqPQtBu.js';
-export { A as ActionDefinition, a as ActionInteractionDescriptor, b as ActionParameterDefinition, c as AvailableInteractionAvailability, B as BlockedInteractionAvailability, d as BoardCard, e as BoardContainerHostSpec, f as BoardContainerSpec, h as BoardHostSpec, i as BoardLayout, j as BoardRelationSpec, k as BoardSpaceSpec, l as BoardSpec, m as BoardTargetDomain, n as BoardTemplateSpec, p as BoundedNumberDomain, C as CardPropertySchema, q as CardPropertySchemaVariants, r as CardSetDefinition, s as CardSetSourceType, t as CardTargetDomain, u as ChoiceDomain, v as ChoiceDomainOption, w as ChoiceListDomain, x as ComponentHomeSpec, y as ComponentSlotSpec, z as ComponentVisibilitySpec, D as ContainerHomeSpec, E as DetachedHomeSpec, F as DieSeedSpec, G as DieSlotHostRef, I as DieTypeSpec, J as EagerInputDomainDependencies, K as EdgeHomeSpec, L as GameTopologyManifest, N as GenericBoardSpec, O as GenericBoardTemplateSpec, P as HexBoardSpec, Q as HexBoardTemplateSpec, R as HexEdgeRef, S as HexEdgeSpec, T as HexOrientation, U as HexSpaceSpec, V as HexVertexRef, W as HexVertexSpec, X as HistoryEntrySummary, Y as HostActionSubmitResponse, Z as HostEndedSessionSnapshot, _ as HostGameplaySeatView, $ as HostGameplaySessionSnapshot, a0 as HostGameplaySharedView, a1 as HostLobbySessionSnapshot, a2 as HostLobbyView, a3 as HostPlayerGameplayView, a4 as HostSessionContext, a5 as HostSessionEventCausation, a6 as HostSessionGameplayUpdatedEvent, a7 as HostSessionSnapshot, a8 as HostSessionStatus, a9 as InputDomain, aa as InputDomainDependencyCase, ab as InputDomainResolver, ac as InputSelection, ad as InsufficientResourcesInteractionAvailability, ae as InteractionAvailability, af as InteractionCommitPolicy, ag as InteractionContext, ah as InteractionContextOption, ai as InteractionDescriptor, aj as InteractionDescriptorBase, ak as InteractionInputDescriptor, am as LazyBoardTargetDomain, an as LazyCardTargetDomain, ao as LazyInputDomainDependencies, ap as ManualCardSetDefinition, aq as ManyInputSelection, ar as NotYourTurnInteractionAvailability, as as ObjectSchema, at as ParameterType, au as PieceSeedSpec, av as PieceSlotHostRef, aw as PieceTypeSpec, ax as PlayerId, ay as PlayersDefinition, az as PresetCardSetDefinition, aA as PromptInteractionDescriptor, aB as PropertySchema, aC as ResolvedBoardTargetDomain, aD as ResolvedCardTargetDomain, aE as ResourceDefinition, aF as ResourceMapDomain, aG as ResourceMapDomainEntry, aH as SeatAssignment, aI as SessionActor, aJ as SessionActorAuthUser, aK as SessionActorDemoGuest, aL as SessionGameSource, aM as SessionGameSourceDemoRevision, aN as SessionGameSourceUserCompiled, aO as SessionSnapshotHistory, aP as SessionSnapshotPhase, aQ as SetupOptionChoiceSpec, aR as SetupOptionSpec, aS as SetupProfileSpec, aT as SimultaneousPhaseSnapshot, aU as SingleInputSelection, aV as SlotHomeSpec, aW as SlotHostRef, aX as SpaceHomeSpec, aY as SpaceHostSpec, aZ as SquareBoardSpec, a_ as SquareBoardTemplateSpec, a$ as SquareEdgeSpec, b0 as SquareSpaceSpec, b1 as SquareVertexSpec, b2 as TopologyScope, b3 as VertexHomeSpec, b4 as ZoneHandles, b5 as ZoneHomeSpec, b6 as ZoneSpec, b7 as ZoneVisibility } from './index-BwqPQtBu.js';
-export { C as CardCollection, V as ViewCard } from './cards-Sl3b40Mv.js';
-export { V as ViewSlotOccupant } from './slots-1GPGihk8.js';
+/**
+ * Supported player-count metadata for the game
+ */
+type PlayersDefinition = {
+    minPlayers: number;
+    maxPlayers: number;
+    optimalPlayers?: number;
+};
+type PresetCardSetDefinition = {
+    /**
+     * Unique local identifier for the authored card set
+     */
+    id: string;
+    /**
+     * Built-in preset card-set selector
+     */
+    presetId: string;
+    /**
+     * Display name of the card set
+     */
+    name: string;
+    /**
+     * Type of card set source
+     */
+    type: 'preset';
+};
+/**
+ * Arbitrary authored JSON value.
+ */
+type JsonValue = string | number | boolean | null | Array<JsonValue> | {
+    [key: string]: JsonValue;
+};
+type PropertySchema = {
+    /**
+     * The data type of the property.
+     */
+    type: 'string' | 'integer' | 'number' | 'boolean' | 'zoneId' | 'cardId' | 'playerId' | 'boardId' | 'edgeId' | 'vertexId' | 'spaceId' | 'pieceId' | 'dieId' | 'resourceId' | 'array' | 'object' | 'record' | 'enum';
+    /**
+     * Optional description of the property's purpose and usage.
+     */
+    description?: string;
+    /**
+     * Whether an object property may be omitted.
+     */
+    optional?: boolean;
+    /**
+     * Whether the value may be null.
+     */
+    nullable?: boolean;
+    /**
+     * Optional authored default value for this property. When present, omitted
+     * seed values materialize to the default and generated TypeScript treats
+     * the property as present even if `optional: true` is also set.
+     *
+     */
+    default?: JsonValue;
+    /**
+     * For array types, the schema of the array items. Required if type is 'array'.
+     */
+    items?: PropertySchema;
+    /**
+     * For object types, the schema of the object's properties. Required if type is 'object'.
+     */
+    properties?: {
+        [key: string]: PropertySchema;
+    };
+    /**
+     * For enum types, the list of allowed string values. Required if type is 'enum'.
+     */
+    enums?: Array<string>;
+    /**
+     * For record types, the schema of the record's values. Required if type is 'record'.
+     */
+    values?: PropertySchema;
+};
+type ObjectSchema = {
+    /**
+     * Map of property names to their schemas. Type is always 'object' and all properties are required.
+     */
+    properties: {
+        [key: string]: PropertySchema;
+    };
+};
+type CardPropertySchemaVariants = {
+    /**
+     * Property schemas present on every card-type variant.
+     */
+    shared?: {
+        [key: string]: PropertySchema;
+    };
+    /**
+     * Property schema for each card type in this manual card set.
+     */
+    variants: {
+        [key: string]: ObjectSchema;
+    };
+};
+type CardPropertySchema = ObjectSchema | CardPropertySchemaVariants;
+type DetachedHomeSpec = {
+    type: 'detached';
+};
+type ZoneHomeSpec = {
+    type: 'zone';
+    zoneId: string;
+};
+type SpaceHomeSpec = {
+    type: 'space';
+    boardId: string;
+    spaceId: string;
+};
+type ContainerHomeSpec = {
+    type: 'container';
+    boardId: string;
+    containerId: string;
+};
+/**
+ * Tiled board edge identified by the spaces that border it
+ */
+type BoardEdgeRef = {
+    spaces: Array<string>;
+};
+type EdgeHomeSpec = {
+    type: 'edge';
+    boardId: string;
+    ref: BoardEdgeRef;
+};
+/**
+ * Tiled board vertex identified by the spaces that touch it
+ */
+type BoardVertexRef = {
+    spaces: Array<string>;
+};
+type VertexHomeSpec = {
+    type: 'vertex';
+    boardId: string;
+    ref: BoardVertexRef;
+};
+type PieceSlotHostRef = {
+    kind: 'piece';
+    id: string;
+};
+type DieSlotHostRef = {
+    kind: 'die';
+    id: string;
+};
+type SlotHostRef = ({
+    kind: 'piece';
+} & PieceSlotHostRef) | ({
+    kind: 'die';
+} & DieSlotHostRef);
+type SlotHomeSpec = {
+    type: 'slot';
+    host: SlotHostRef;
+    slotId: string;
+};
+type ComponentHomeSpec = ({
+    type: 'detached';
+} & DetachedHomeSpec) | ({
+    type: 'zone';
+} & ZoneHomeSpec) | ({
+    type: 'space';
+} & SpaceHomeSpec) | ({
+    type: 'container';
+} & ContainerHomeSpec) | ({
+    type: 'edge';
+} & EdgeHomeSpec) | ({
+    type: 'vertex';
+} & VertexHomeSpec) | ({
+    type: 'slot';
+} & SlotHomeSpec);
+/**
+ * Default authored visibility for a component instance
+ */
+type ComponentVisibilitySpec = {
+    faceUp?: boolean;
+    /**
+     * When omitted, visible to all players
+     */
+    visibleTo?: Array<string>;
+};
+type BoardCard = {
+    /**
+     * Card type identifier used to generate runtime CardIds. When count > 1, runtime IDs are generated as '{type}-1', '{type}-2', etc.
+     */
+    type: string;
+    /**
+     * Display name of the card
+     */
+    name: string;
+    /**
+     * URL to the card's image
+     */
+    imageUrl?: string;
+    /**
+     * Text content on the card
+     */
+    text?: string;
+    /**
+     * Number of copies of this card
+     */
+    count: number;
+    /**
+     * Optional authored card category or subtype identifier
+     */
+    cardType?: string;
+    /**
+     * Optional authored home for this card inventory. When omitted, cards start detached until reducer setup places them.
+     */
+    home?: ComponentHomeSpec;
+    /**
+     * Default authored visibility for the card inventory
+     */
+    visibility?: ComponentVisibilitySpec;
+    /**
+     * Actual property values for this specific card instance. Keys must match the properties defined in the referenced cardSchema.
+     */
+    properties: {
+        [key: string]: JsonValue;
+    };
+};
+type ManualCardSetDefinition = {
+    /**
+     * Unique identifier for the card set
+     */
+    id: string;
+    /**
+     * Display name of the card set
+     */
+    name: string;
+    /**
+     * Type of card set source
+     */
+    type: 'manual';
+    /**
+     * Schema definition for authored card properties in this card set
+     */
+    cardSchema: CardPropertySchema;
+    /**
+     * List of authored cards in this card set
+     */
+    cards: Array<BoardCard>;
+};
+type CardSetDefinition = ({
+    type: 'preset';
+} & PresetCardSetDefinition) | ({
+    type: 'manual';
+} & ManualCardSetDefinition);
+/**
+ * Whether authored topology exists once for the table or once per player
+ */
+type TopologyScope = 'shared' | 'perPlayer';
+/**
+ * Default topology visibility for a zone or slot
+ */
+type ZoneVisibility = 'ownerOnly' | 'public' | 'hidden';
+/**
+ * Generic authored container that can hold cards, pieces, or dice
+ */
+type ZoneSpec = {
+    /**
+     * Stable zone identifier
+     */
+    id: string;
+    /**
+     * Display name for the zone
+     */
+    name: string;
+    scope: TopologyScope;
+    /**
+     * Optional card-set restriction for this zone
+     */
+    allowedCardSetIds?: Array<string>;
+    visibility?: ZoneVisibility;
+};
+/**
+ * Stable authored board space or slot anchor
+ */
+type BoardSpaceSpec = {
+    /**
+     * Stable space identifier local to the board
+     */
+    id: string;
+    /**
+     * Human-readable space name
+     */
+    name?: string;
+    /**
+     * Optional authored space type identifier
+     */
+    typeId?: string;
+    /**
+     * Typed authored fields validated against the board's spaceFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Named relation between two authored spaces
+ */
+type BoardRelationSpec = {
+    /**
+     * Optional stable relation identifier
+     */
+    id?: string;
+    /**
+     * Relation type identifier such as adjacent, covers, blocks, or linked
+     */
+    typeId: string;
+    fromSpaceId: string;
+    toSpaceId: string;
+    directed?: boolean;
+    /**
+     * Typed authored relation fields validated against relationFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+type BoardHostSpec = {
+    type: 'board';
+};
+type SpaceHostSpec = {
+    type: 'space';
+    spaceId: string;
+};
+type BoardContainerHostSpec = ({
+    type: 'board';
+} & BoardHostSpec) | ({
+    type: 'space';
+} & SpaceHostSpec);
+/**
+ * Authored board-attached or space-attached container/slot
+ */
+type BoardContainerSpec = {
+    /**
+     * Stable container identifier local to the board
+     */
+    id: string;
+    /**
+     * Display name for the container
+     */
+    name: string;
+    host: BoardContainerHostSpec;
+    allowedCardSetIds?: Array<string>;
+    /**
+     * Typed authored container fields validated against containerFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Reusable authored board topology template
+ */
+type GenericBoardTemplateSpec = {
+    /**
+     * Stable template identifier
+     */
+    id: string;
+    name: string;
+    layout: 'generic';
+    /**
+     * Optional authored board type identifier such as track, map, tableau, or grid
+     */
+    typeId?: string;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    relationFieldsSchema?: ObjectSchema;
+    containerFieldsSchema?: ObjectSchema;
+    spaces?: Array<BoardSpaceSpec>;
+    relations?: Array<BoardRelationSpec>;
+    containers?: Array<BoardContainerSpec>;
+};
+/**
+ * Visual orientation for authored hex coordinates
+ */
+type HexOrientation = 'pointy-top' | 'flat-top';
+/**
+ * One authored hex space in axial coordinates
+ */
+type HexSpaceSpec = {
+    /**
+     * Stable space identifier local to the board
+     */
+    id: string;
+    /**
+     * Axial q coordinate
+     */
+    q: number;
+    /**
+     * Axial r coordinate
+     */
+    r: number;
+    /**
+     * Optional authored space type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional hex-space label for setup or rendering
+     */
+    label?: string;
+    /**
+     * Typed authored fields validated against the board's spaceFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Hex edge identified by two adjacent hex spaces
+ */
+type HexEdgeRef = {
+    spaces: [
+        string,
+        string
+    ];
+};
+/**
+ * Authored metadata attached to one derived hex edge
+ */
+type HexEdgeSpec = {
+    ref: HexEdgeRef;
+    /**
+     * Optional authored edge type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional edge label for setup or rendering
+     */
+    label?: string;
+    tags?: Array<string>;
+    /**
+     * Typed authored edge fields validated against edgeFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Hex vertex identified by three touching hex spaces
+ */
+type HexVertexRef = {
+    spaces: [
+        string,
+        string,
+        string
+    ];
+};
+/**
+ * Authored metadata attached to one derived hex vertex
+ */
+type HexVertexSpec = {
+    ref: HexVertexRef;
+    /**
+     * Optional authored vertex type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional vertex label for setup or rendering
+     */
+    label?: string;
+    tags?: Array<string>;
+    /**
+     * Typed authored vertex fields validated against vertexFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Reusable authored hex board topology template
+ */
+type HexBoardTemplateSpec = {
+    /**
+     * Stable template identifier
+     */
+    id: string;
+    name: string;
+    layout: 'hex';
+    /**
+     * Optional authored board type identifier
+     */
+    typeId?: string;
+    orientation?: HexOrientation;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    edgeFieldsSchema?: ObjectSchema;
+    vertexFieldsSchema?: ObjectSchema;
+    spaces?: Array<HexSpaceSpec>;
+    edges?: Array<HexEdgeSpec>;
+    vertices?: Array<HexVertexSpec>;
+};
+/**
+ * One authored square space in row/column coordinates
+ */
+type SquareSpaceSpec = {
+    /**
+     * Stable space identifier local to the board
+     */
+    id: string;
+    /**
+     * Zero-based row coordinate
+     */
+    row: number;
+    /**
+     * Zero-based column coordinate
+     */
+    col: number;
+    /**
+     * Optional authored space type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional square-space label for setup or rendering
+     */
+    label?: string;
+    /**
+     * Typed authored fields validated against the board's spaceFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Authored metadata attached to one derived square edge
+ */
+type SquareEdgeSpec = {
+    ref: BoardEdgeRef;
+    /**
+     * Optional authored edge type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional edge label for setup or rendering
+     */
+    label?: string;
+    tags?: Array<string>;
+    /**
+     * Typed authored edge fields validated against edgeFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Authored metadata attached to one derived square vertex
+ */
+type SquareVertexSpec = {
+    ref: BoardVertexRef;
+    /**
+     * Optional authored vertex type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional vertex label for setup or rendering
+     */
+    label?: string;
+    tags?: Array<string>;
+    /**
+     * Typed authored vertex fields validated against vertexFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Reusable authored square board topology template
+ */
+type SquareBoardTemplateSpec = {
+    /**
+     * Stable template identifier
+     */
+    id: string;
+    name: string;
+    layout: 'square';
+    /**
+     * Optional authored board type identifier
+     */
+    typeId?: string;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    relationFieldsSchema?: ObjectSchema;
+    containerFieldsSchema?: ObjectSchema;
+    edgeFieldsSchema?: ObjectSchema;
+    vertexFieldsSchema?: ObjectSchema;
+    spaces?: Array<SquareSpaceSpec>;
+    relations?: Array<BoardRelationSpec>;
+    containers?: Array<BoardContainerSpec>;
+    edges?: Array<SquareEdgeSpec>;
+    vertices?: Array<SquareVertexSpec>;
+};
+type BoardTemplateSpec = ({
+    layout: 'generic';
+} & GenericBoardTemplateSpec) | ({
+    layout: 'hex';
+} & HexBoardTemplateSpec) | ({
+    layout: 'square';
+} & SquareBoardTemplateSpec);
+/**
+ * Shared or per-player authored board instance shell
+ */
+type GenericBoardSpec = {
+    /**
+     * Stable board identifier
+     */
+    id: string;
+    name: string;
+    layout: 'generic';
+    /**
+     * Optional authored board type identifier such as track, map, tableau, or grid
+     */
+    typeId?: string;
+    scope: TopologyScope;
+    /**
+     * Optional board template to clone before applying inline authored additions
+     */
+    templateId?: string;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    relationFieldsSchema?: ObjectSchema;
+    containerFieldsSchema?: ObjectSchema;
+    /**
+     * Typed authored board fields validated against boardFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+    spaces?: Array<BoardSpaceSpec>;
+    relations?: Array<BoardRelationSpec>;
+    containers?: Array<BoardContainerSpec>;
+};
+/**
+ * Shared or per-player authored hex board instance shell
+ */
+type HexBoardSpec = {
+    /**
+     * Stable board identifier
+     */
+    id: string;
+    name: string;
+    layout: 'hex';
+    /**
+     * Optional authored board type identifier
+     */
+    typeId?: string;
+    scope: TopologyScope;
+    /**
+     * Optional hex board template to clone before applying inline authored additions
+     */
+    templateId?: string;
+    orientation?: HexOrientation;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    edgeFieldsSchema?: ObjectSchema;
+    vertexFieldsSchema?: ObjectSchema;
+    /**
+     * Typed authored board fields validated against boardFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+    spaces?: Array<HexSpaceSpec>;
+    edges?: Array<HexEdgeSpec>;
+    vertices?: Array<HexVertexSpec>;
+};
+/**
+ * Shared or per-player authored square board instance shell
+ */
+type SquareBoardSpec = {
+    /**
+     * Stable board identifier
+     */
+    id: string;
+    name: string;
+    layout: 'square';
+    /**
+     * Optional authored board type identifier
+     */
+    typeId?: string;
+    scope: TopologyScope;
+    /**
+     * Optional square board template to clone before applying inline authored additions
+     */
+    templateId?: string;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    relationFieldsSchema?: ObjectSchema;
+    containerFieldsSchema?: ObjectSchema;
+    edgeFieldsSchema?: ObjectSchema;
+    vertexFieldsSchema?: ObjectSchema;
+    /**
+     * Typed authored board fields validated against boardFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+    spaces?: Array<SquareSpaceSpec>;
+    relations?: Array<BoardRelationSpec>;
+    containers?: Array<BoardContainerSpec>;
+    edges?: Array<SquareEdgeSpec>;
+    vertices?: Array<SquareVertexSpec>;
+};
+type BoardSpec = ({
+    layout: 'generic';
+} & GenericBoardSpec) | ({
+    layout: 'hex';
+} & HexBoardSpec) | ({
+    layout: 'square';
+} & SquareBoardSpec);
+/**
+ * Named authored slot exposed by a piece or die type
+ */
+type ComponentSlotSpec = {
+    id: string;
+    name?: string;
+};
+/**
+ * Reusable authored piece type
+ */
+type PieceTypeSpec = {
+    id: string;
+    name: string;
+    fieldsSchema?: ObjectSchema;
+    slots?: Array<ComponentSlotSpec>;
+};
+/**
+ * Authored seeded piece inventory or supply definition
+ */
+type PieceSeedSpec = {
+    /**
+     * Stable piece id seed. When count > 1, runtime ids are generated as '{id}-1', '{id}-2', etc.
+     */
+    id?: string;
+    name?: string;
+    typeId: string;
+    count?: number;
+    ownerId?: string;
+    home?: ComponentHomeSpec;
+    visibility?: ComponentVisibilitySpec;
+    /**
+     * Typed authored piece fields validated against the piece type schema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Reusable authored die type
+ */
+type DieTypeSpec$2 = {
+    id: string;
+    name: string;
+    sides?: number;
+    fieldsSchema?: ObjectSchema;
+    slots?: Array<ComponentSlotSpec>;
+};
+/**
+ * Authored seeded die inventory or supply definition
+ */
+type DieSeedSpec = {
+    /**
+     * Stable die id seed. When count > 1, runtime ids are generated as '{id}-1', '{id}-2', etc.
+     */
+    id?: string;
+    name?: string;
+    typeId: string;
+    count?: number;
+    ownerId?: string;
+    home?: ComponentHomeSpec;
+    visibility?: ComponentVisibilitySpec;
+    /**
+     * Typed authored die fields validated against the die type schema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Definition of a game resource type
+ */
+type ResourceDefinition = {
+    /**
+     * Unique identifier for the resource. Used as a typed ResourceId.
+     */
+    id: string;
+    /**
+     * Human-readable display name for the resource
+     */
+    name: string;
+    /**
+     * Optional compact icon or emoji rendered by generic UI resource controls.
+     */
+    icon?: string;
+};
+/**
+ * One authored setup option choice
+ */
+type SetupOptionChoiceSpec = {
+    id: string;
+    label: string;
+    description?: string;
+};
+/**
+ * Authored setup module/variant axis metadata
+ */
+type SetupOptionSpec = {
+    id: string;
+    name: string;
+    description?: string;
+    choices?: Array<SetupOptionChoiceSpec>;
+};
+/**
+ * Reducer-consumed authored setup profile, recipe, or loadout metadata
+ */
+type SetupProfileSpec = {
+    id: string;
+    name: string;
+    description?: string;
+    /**
+     * Selected setup-option values for this profile
+     */
+    optionValues?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Authoritative topology manifest for reducer-native games
+ */
+type GameTopologyManifest$2 = {
+    players: PlayersDefinition;
+    /**
+     * Authored card catalogs and schemas
+     */
+    cardSets: Array<CardSetDefinition>;
+    /**
+     * Shared and per-player authored containers
+     */
+    zones?: Array<ZoneSpec>;
+    /**
+     * Reusable board topology templates
+     */
+    boardTemplates?: Array<BoardTemplateSpec>;
+    /**
+     * Shared and per-player authored board shells
+     */
+    boards?: Array<BoardSpec>;
+    pieceTypes?: Array<PieceTypeSpec>;
+    pieceSeeds?: Array<PieceSeedSpec>;
+    dieTypes?: Array<DieTypeSpec$2>;
+    dieSeeds?: Array<DieSeedSpec>;
+    resources?: Array<ResourceDefinition>;
+    /**
+     * Authored setup-option metadata consumed by reducer-owned setup flows
+     */
+    setupOptions?: Array<SetupOptionSpec>;
+    /**
+     * Authored setup recipes, loadouts, or module profiles consumed by reducer setup code
+     */
+    setupProfiles?: Array<SetupProfileSpec>;
+};
+/**
+ * Authenticated user acting in a session.
+ */
+type SessionActorAuthUser = {
+    kind: 'AUTH_USER';
+    /**
+     * Internal user id
+     */
+    id: string;
+};
+/**
+ * Anonymous demo principal for one demo_sessions row (shared across tabs).
+ */
+type SessionActorDemoGuest = {
+    kind: 'DEMO_GUEST';
+    /**
+     * demo_sessions.id
+     */
+    demoActorSessionId: string;
+};
+type SessionActor = ({
+    kind: 'AUTH_USER';
+} & SessionActorAuthUser) | ({
+    kind: 'DEMO_GUEST';
+} & SessionActorDemoGuest);
+type SessionGameSourceUserCompiled = {
+    kind: 'USER_COMPILED';
+    ownerUserId: string;
+    gameId: string;
+    compiledResultId: string;
+};
+type SessionGameSourceDemoRevision = {
+    kind: 'DEMO_REVISION';
+    slug: string;
+    revisionId: string;
+};
+type SessionGameSource = ({
+    kind: 'USER_COMPILED';
+} & SessionGameSourceUserCompiled) | ({
+    kind: 'DEMO_REVISION';
+} & SessionGameSourceDemoRevision);
+type SessionSnapshotPhase = 'lobby' | 'gameplay' | 'ended';
+type HostSessionStatus = 'active' | 'ended';
+/**
+ * Summary of a game state history entry.
+ */
+type HistoryEntrySummary = {
+    id: string;
+    generation: number;
+    version: number;
+    timestamp: string;
+    description: string;
+    playerId?: string;
+    actionType?: string;
+    isCurrent: boolean;
+};
+type SessionSnapshotHistory = {
+    entries: Array<HistoryEntrySummary>;
+    currentIndex: number;
+    canGoBack: boolean;
+    canGoForward: boolean;
+};
+type HostSessionContext = {
+    /**
+     * Unique identifier for the session.
+     */
+    sessionId: string;
+    /**
+     * Memorable short code for sharing.
+     */
+    shortCode: string;
+    phase: SessionSnapshotPhase;
+    status: HostSessionStatus;
+    hostActor: SessionActor;
+    gameSource: SessionGameSource;
+    /**
+     * Selected authored setup profile for this session.
+     */
+    setupProfileId?: string;
+    /**
+     * Player IDs the authenticated session actor may select.
+     */
+    switchablePlayerIds: Array<string>;
+    history?: SessionSnapshotHistory;
+};
+type SeatAssignment = {
+    /**
+     * Player identifier (e.g., 'player-1')
+     */
+    playerId: string;
+    /**
+     * Session actor controlling this seat (null if empty)
+     */
+    controllerActor?: SessionActor;
+    /**
+     * Display name for this seat/player
+     */
+    displayName: string;
+    /**
+     * Hex color code for the player (e.g., '#FF5733')
+     */
+    playerColor?: string;
+    /**
+     * Whether this seat is the host
+     */
+    isHost?: boolean;
+};
+type HostLobbyView = {
+    /**
+     * Current public seat assignments for the session.
+     */
+    seats: Array<SeatAssignment>;
+    /**
+     * Whether the lobby can currently be started.
+     */
+    canStart: boolean;
+    /**
+     * Session actor that hosts this session.
+     */
+    hostActor: SessionActor;
+    /**
+     * Selected authored setup profile for this session.
+     */
+    setupProfileId?: string;
+};
+type HostLobbySessionSnapshot = {
+    type: 'lobby';
+    context: HostSessionContext;
+    lobby: HostLobbyView;
+};
+type SimultaneousPhaseSnapshot = {
+    phaseName: string;
+    interactionId: string;
+    actorIds: Array<string>;
+    sealedPlayerIds: Array<string>;
+    pendingPlayerIds: Array<string>;
+};
+type HostGameplaySharedView = {
+    /**
+     * Player IDs currently active in the game state.
+     */
+    activePlayers: Array<string>;
+    /**
+     * Current reducer-native gameplay phase.
+     */
+    currentPhase: string;
+    /**
+     * Current stage within the phase. Null when the phase has no active stage.
+     */
+    currentStage: string | null;
+    /**
+     * Player IDs this stage currently admits.
+     */
+    stageSeats: Array<string>;
+    /**
+     * Visibility-safe progress metadata for an active simultaneous-player phase.
+     */
+    simultaneousPhase?: SimultaneousPhaseSnapshot | null;
+    /**
+     * JSON-serialized session-scoped static view. Populated on gameplay bootstrap payloads only.
+     */
+    boardStatic?: string | null;
+    /**
+     * Content hash of the session-scoped static view held on the host.
+     */
+    boardStaticHash?: string | null;
+};
+/**
+ * Draft commit policy consumed by default UI surfaces.
+ */
+type InteractionCommitPolicy = {
+    mode: 'manual' | 'autoWhenReady';
+};
+/**
+ * Single-value input selection.
+ */
+type SingleInputSelection = {
+    mode: 'single';
+};
+/**
+ * Multi-value input selection.
+ */
+type ManyInputSelection = {
+    mode: 'many';
+    min: number;
+    max?: number;
+    distinct?: boolean;
+};
+type InputSelection = ({
+    mode: 'single';
+} & SingleInputSelection) | ({
+    mode: 'many';
+} & ManyInputSelection);
+type InputDomain = ({
+    type: 'cardTarget';
+} & CardTargetDomain) | ({
+    type: 'boardTarget';
+} & BoardTargetDomain) | ({
+    type: 'resourceMap';
+} & ResourceMapDomain) | ({
+    type: 'boundedNumber';
+} & BoundedNumberDomain) | ({
+    type: 'choice';
+} & ChoiceDomain) | ({
+    type: 'choiceList';
+} & ChoiceListDomain);
+type InputDomainDependencyCase = {
+    when: {
+        [key: string]: string;
+    };
+    domain: InputDomain;
+};
+type EagerInputDomainDependencies = {
+    mode: 'eager';
+    dependentCases: Array<InputDomainDependencyCase>;
+};
+type ResolvedCardTargetDomain = {
+    type: 'cardTarget';
+    projection: 'resolved';
+    targetKind: 'card';
+    zoneIds: Array<string>;
+    eligibleTargets: Array<string>;
+    selection?: InputSelection;
+    dependencies?: EagerInputDomainDependencies;
+};
+type InputDomainResolver = {
+    interactionKey?: string;
+    inputKey: string;
+};
+type LazyInputDomainDependencies = {
+    mode: 'lazy';
+    dependsOn: Array<string>;
+    resolver: InputDomainResolver;
+};
+type LazyCardTargetDomain = {
+    type: 'cardTarget';
+    projection: 'lazy';
+    targetKind: 'card';
+    zoneIds: Array<string>;
+    selection?: InputSelection;
+    dependencies: LazyInputDomainDependencies;
+};
+type CardTargetDomain = ({
+    projection: 'resolved';
+} & ResolvedCardTargetDomain) | ({
+    projection: 'lazy';
+} & LazyCardTargetDomain);
+type ResolvedBoardTargetDomain = {
+    type: 'boardTarget';
+    projection: 'resolved';
+    targetKind: 'edge' | 'vertex' | 'space' | 'tile';
+    boardId: string;
+    valueKind?: 'board-id' | 'player-board-space';
+    eligibleTargets: Array<string>;
+    selection?: InputSelection;
+    dependencies?: EagerInputDomainDependencies;
+};
+type LazyBoardTargetDomain = {
+    type: 'boardTarget';
+    projection: 'lazy';
+    targetKind: 'edge' | 'vertex' | 'space' | 'tile';
+    boardId: string;
+    valueKind?: 'board-id' | 'player-board-space';
+    selection?: InputSelection;
+    dependencies: LazyInputDomainDependencies;
+};
+type BoardTargetDomain = ({
+    projection: 'resolved';
+} & ResolvedBoardTargetDomain) | ({
+    projection: 'lazy';
+} & LazyBoardTargetDomain);
+type ResourceMapDomainEntry = {
+    resourceId: string;
+    label?: string;
+    icon?: string;
+    min: number;
+    max: number;
+};
+type ResourceMapDomain = {
+    type: 'resourceMap';
+    resources: Array<ResourceMapDomainEntry>;
+    selection?: InputSelection;
+};
+type BoundedNumberDomain = {
+    type: 'boundedNumber';
+    min: number;
+    max: number;
+    step?: number;
+    selection?: InputSelection;
+};
+type ChoiceDomainOption = {
+    value: string | null;
+    label: string;
+    icon?: string;
+    badge?: string;
+    description?: string;
+    disabled?: boolean;
+    disabledReason?: string;
+};
+type ChoiceDomain = {
+    type: 'choice';
+    choices: Array<ChoiceDomainOption>;
+    selection?: InputSelection;
+    dependencies?: EagerInputDomainDependencies;
+};
+type ChoiceListDomain = {
+    type: 'choiceList';
+    choices: Array<ChoiceDomainOption>;
+    min?: number;
+    max?: number;
+    selection?: InputSelection;
+    dependencies?: EagerInputDomainDependencies;
+};
+/**
+ * Canonical descriptor for one interaction input collector.
+ */
+type InteractionInputDescriptor = {
+    key: string;
+    kind: string;
+    domain: InputDomain;
+    /**
+     * Optional default value applied to this input when the player has not
+     * yet drafted a value. Mirrors the input collector's `defaultValue`
+     * from the authored interaction, so plugins can render a sensible
+     * starting state (e.g. a pre-selected resource for a bank trade).
+     *
+     */
+    defaultValue?: JsonValue;
+};
+type AvailableInteractionAvailability = {
+    status: 'available';
+};
+type NotYourTurnInteractionAvailability = {
+    status: 'notYourTurn';
+    reason: string;
+};
+type InsufficientResourcesInteractionAvailability = {
+    status: 'insufficientResources';
+    reason: string;
+    /**
+     * Resource shortfall by resource id when a costed interaction is not currently affordable.
+     */
+    missingResources: {
+        [key: string]: number;
+    };
+};
+type BlockedInteractionAvailability = {
+    status: 'blocked';
+    reason: string;
+    code?: string;
+};
+type InteractionAvailability = ({
+    status: 'available';
+} & AvailableInteractionAvailability) | ({
+    status: 'notYourTurn';
+} & NotYourTurnInteractionAvailability) | ({
+    status: 'insufficientResources';
+} & InsufficientResourcesInteractionAvailability) | ({
+    status: 'blocked';
+} & BlockedInteractionAvailability);
+/**
+ * Authoritative interaction descriptor resolved by the trusted bundle.
+ */
+type InteractionDescriptorBase = {
+    phaseName: string;
+    interactionKey: string;
+    interactionId: string;
+    zoneId?: string;
+    /**
+     * Draft commit policy materialized by the trusted reducer bundle. Omitted authoring specs default to manual before this descriptor crosses the runtime boundary.
+     */
+    commit: InteractionCommitPolicy;
+    /**
+     * Ordered input descriptors. Each entry is the canonical source for its collector key, collector kind, and valid-value domain.
+     */
+    inputs: Array<InteractionInputDescriptor>;
+    cost?: {
+        [key: string]: JsonValue;
+    };
+    currentResources?: {
+        [key: string]: JsonValue;
+    };
+    availability: InteractionAvailability;
+};
+type ActionInteractionDescriptor = InteractionDescriptorBase & {
+    kind: 'action';
+};
+type InteractionContextOption = {
+    id: string;
+    label: string;
+};
+type InteractionContext = {
+    to: string;
+    title?: string;
+    payload?: {
+        [key: string]: JsonValue;
+    };
+    options?: Array<InteractionContextOption>;
+};
+type PromptInteractionDescriptor = InteractionDescriptorBase & {
+    kind: 'prompt';
+    context: InteractionContext;
+};
+type InteractionDescriptor = ({
+    kind: 'action';
+} & ActionInteractionDescriptor) | ({
+    kind: 'prompt';
+} & PromptInteractionDescriptor);
+type ZoneHandles = {
+    cardIds: Array<string>;
+    cardViewsById: {
+        [key: string]: string;
+    };
+    playableByCardId: {
+        [key: string]: Array<string>;
+    };
+};
+type HostGameplaySeatView = {
+    /**
+     * Opaque revision token for this seat's available descriptors and input domains.
+     */
+    actionSetVersion: string;
+    /**
+     * JSON-serialized reducer-projected UI view for this player.
+     */
+    view: string | null;
+    /**
+     * Descriptor refs for interactions available to this player.
+     */
+    availableInteractionRefs: Array<string>;
+    /**
+     * Zone handles for this player, keyed by zone id.
+     */
+    zones: {
+        [key: string]: ZoneHandles;
+    };
+};
+type HostPlayerGameplayView = {
+    /**
+     * Monotonic gameplay version for stale-client detection.
+     */
+    version: number;
+    /**
+     * Opaque revision token for the returned descriptors and input domains.
+     */
+    actionSetVersion: string;
+    /**
+     * Player ID currently selected for rendering and input.
+     */
+    perspectivePlayerId: string;
+    /**
+     * Player IDs included in this normalized projection envelope.
+     */
+    controllablePlayerIds: Array<string>;
+    shared: HostGameplaySharedView;
+    /**
+     * Deduplicated interaction descriptor registry keyed by stable descriptor ref.
+     */
+    interactionsByRef: {
+        [key: string]: InteractionDescriptor;
+    };
+    /**
+     * Player-scoped projections keyed by authorized player id.
+     */
+    seats: {
+        [key: string]: HostGameplaySeatView;
+    };
+};
+type HostGameplaySessionSnapshot = {
+    type: 'gameplay';
+    context: HostSessionContext;
+    lobby: HostLobbyView;
+    gameplay: HostPlayerGameplayView;
+};
+type HostEndedSessionSnapshot = {
+    type: 'ended';
+    context: HostSessionContext;
+    lobby: HostLobbyView;
+};
+type HostSessionSnapshot = ({
+    type: 'lobby';
+} & HostLobbySessionSnapshot) | ({
+    type: 'gameplay';
+} & HostGameplaySessionSnapshot) | ({
+    type: 'ended';
+} & HostEndedSessionSnapshot);
+type HostSessionEventCausation = {
+    clientActionId?: string;
+};
+type HostSessionGameplayUpdatedEvent = {
+    type: 'session.gameplayUpdated';
+    context: HostSessionContext;
+    gameplay: HostPlayerGameplayView;
+    causation?: HostSessionEventCausation;
+};
+type HostActionSubmitResponse = {
+    success: boolean;
+    version: number;
+    actionSetVersion: string;
+    accepted?: boolean;
+    durabilityStatus?: 'COMMITTED';
+    errorCode?: string;
+    message?: string;
+    clientActionId?: string;
+    update?: HostSessionGameplayUpdatedEvent;
+};
+/**
+ * Type of parameter accepted by a runtime action
+ */
+type ParameterType = 'cardId' | 'cardType' | 'playerId' | 'string' | 'number' | 'boolean' | 'zoneId' | 'pieceId' | 'dieId' | 'boardId' | 'edgeId' | 'vertexId' | 'spaceId' | 'resourceId';
+/**
+ * Defines a parameter for an action
+ */
+type ActionParameterDefinition = {
+    name: string;
+    type: ParameterType;
+    required?: boolean;
+    array?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    /**
+     * Optional card set ID to specify which card set a CARD_ID parameter refers to
+     */
+    cardSetId?: string;
+    description?: string;
+};
+/**
+ * Defines an available player action with metadata and parameter definitions
+ */
+type ActionDefinition = {
+    /**
+     * Unique action identifier
+     */
+    actionType: string;
+    /**
+     * UI display name for this action
+     */
+    displayName: string;
+    /**
+     * Optional help text describing the action
+     */
+    description?: string;
+    /**
+     * List of parameters this action accepts
+     */
+    parameters: Array<ActionParameterDefinition>;
+    /**
+     * List of possible validation error codes
+     */
+    errorCodes?: Array<string>;
+};
+/**
+ * Type of source for the card set
+ */
+type CardSetSourceType = 'preset' | 'csv' | 'manual';
+/**
+ * Engine-level structural board layout discriminator
+ */
+type BoardLayout = 'generic' | 'hex' | 'square';
+/**
+ * Unique identifier for the player (e.g., 'player-1')
+ */
+type PlayerId$1 = string;
+
+interface ViewCard<CardIdValue extends string = string, CardTypeValue extends string = string, Properties extends Record<string, unknown> = Record<string, unknown>> {
+    id: CardIdValue;
+    cardType: CardTypeValue;
+    name?: string;
+    text?: string;
+    properties: Properties;
+}
+interface CardCollection<CardIdValue extends string = string, Card extends ViewCard<CardIdValue> = ViewCard<CardIdValue>> {
+    cardIds: readonly CardIdValue[];
+    cardsById: Readonly<Record<CardIdValue, Card | undefined>>;
+}
 
-type DieTypeSpec = Omit<DieTypeSpec$1, "sides"> & {
-    sides?: DieTypeSpec$1["sides"];
+interface ViewSlotOccupant<PieceIdValue extends string = string, PlayerIdValue extends string = string, SlotIdValue extends string = string, Data extends Record<string, unknown> = Record<string, unknown>> {
+    pieceId: PieceIdValue;
+    playerId: PlayerIdValue | null;
+    slotId: SlotIdValue;
+    data?: Data;
+}
+
+type DieTypeSpec$1 = Omit<DieTypeSpec$2, "sides"> & {
+    sides?: DieTypeSpec$2["sides"];
 };
 type DeepReadonly<T> = T extends (...args: readonly unknown[]) => unknown ? T : T extends readonly (infer Item)[] ? ReadonlyArray<DeepReadonly<Item>> : T extends object ? {
     readonly [Key in keyof T]: DeepReadonly<T[Key]>;
 } : T;
-type GameTopologyManifest = DeepReadonly<Omit<GameTopologyManifest$1, "dieTypes"> & {
-    dieTypes?: readonly DieTypeSpec[];
+type GameTopologyManifest$1 = DeepReadonly<Omit<GameTopologyManifest$2, "dieTypes"> & {
+    dieTypes?: readonly DieTypeSpec$1[];
 }>;
 type ArrayItem<T> = T extends readonly (infer Item)[] ? Item : never;
 type EntryId<T> = T extends {
@@ -18,36 +1457,36 @@ type EntryId<T> = T extends {
 } ? Id : never;
 type IdsOf<T> = EntryId<ArrayItem<NonNullable<T>>>;
 type RuntimeRecord = Record<string, JsonValue>;
-type CardSetId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["cardSets"]>;
-type ZoneId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["zones"]>;
-type BoardId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["boards"]>;
-type PerPlayerZoneId<Manifest extends GameTopologyManifest> = EntryId<Extract<ArrayItem<NonNullable<Manifest["zones"]>>, {
+type CardSetId<Manifest extends GameTopologyManifest$1> = IdsOf<Manifest["cardSets"]>;
+type ZoneId<Manifest extends GameTopologyManifest$1> = IdsOf<Manifest["zones"]>;
+type BoardId<Manifest extends GameTopologyManifest$1> = IdsOf<Manifest["boards"]>;
+type PerPlayerZoneId<Manifest extends GameTopologyManifest$1> = EntryId<Extract<ArrayItem<NonNullable<Manifest["zones"]>>, {
     scope: "perPlayer";
 }>>;
-type SharedZoneId<Manifest extends GameTopologyManifest> = Exclude<ZoneId<Manifest>, PerPlayerZoneId<Manifest>>;
-type PerPlayerBoardId<Manifest extends GameTopologyManifest> = EntryId<Extract<ArrayItem<NonNullable<Manifest["boards"]>>, {
+type SharedZoneId<Manifest extends GameTopologyManifest$1> = Exclude<ZoneId<Manifest>, PerPlayerZoneId<Manifest>>;
+type PerPlayerBoardId<Manifest extends GameTopologyManifest$1> = EntryId<Extract<ArrayItem<NonNullable<Manifest["boards"]>>, {
     scope: "perPlayer";
 }>>;
-type SharedBoardId<Manifest extends GameTopologyManifest> = Exclude<BoardId<Manifest>, PerPlayerBoardId<Manifest>>;
-type ResourceId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["resources"]>;
-type PieceTypeId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["pieceTypes"]>;
-type DieTypeId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["dieTypes"]>;
-type PieceSeedOf<Manifest extends GameTopologyManifest> = ArrayItem<NonNullable<Manifest["pieceSeeds"]>>;
-type DieSeedOf<Manifest extends GameTopologyManifest> = ArrayItem<NonNullable<Manifest["dieSeeds"]>>;
-type SetupOptionId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["setupOptions"]>;
-type ManualCardSetOf<Manifest extends GameTopologyManifest> = Extract<ArrayItem<NonNullable<Manifest["cardSets"]>>, {
+type SharedBoardId<Manifest extends GameTopologyManifest$1> = Exclude<BoardId<Manifest>, PerPlayerBoardId<Manifest>>;
+type ResourceId<Manifest extends GameTopologyManifest$1> = IdsOf<Manifest["resources"]>;
+type PieceTypeId<Manifest extends GameTopologyManifest$1> = IdsOf<Manifest["pieceTypes"]>;
+type DieTypeId<Manifest extends GameTopologyManifest$1> = IdsOf<Manifest["dieTypes"]>;
+type PieceSeedOf<Manifest extends GameTopologyManifest$1> = ArrayItem<NonNullable<Manifest["pieceSeeds"]>>;
+type DieSeedOf<Manifest extends GameTopologyManifest$1> = ArrayItem<NonNullable<Manifest["dieSeeds"]>>;
+type SetupOptionId<Manifest extends GameTopologyManifest$1> = IdsOf<Manifest["setupOptions"]>;
+type ManualCardSetOf<Manifest extends GameTopologyManifest$1> = Extract<ArrayItem<NonNullable<Manifest["cardSets"]>>, {
     type: "manual";
 }>;
-type CardOf<Manifest extends GameTopologyManifest> = ManualCardSetOf<Manifest> extends infer CardSet ? CardSet extends {
+type CardOf<Manifest extends GameTopologyManifest$1> = ManualCardSetOf<Manifest> extends infer CardSet ? CardSet extends {
     cards: infer Cards extends readonly unknown[];
 } ? ArrayItem<Cards> : never : never;
-type BoardOf<Manifest extends GameTopologyManifest, CurrentBoardId extends BoardId<Manifest>> = Extract<ArrayItem<NonNullable<Manifest["boards"]>>, {
+type BoardOf<Manifest extends GameTopologyManifest$1, CurrentBoardId extends BoardId<Manifest>> = Extract<ArrayItem<NonNullable<Manifest["boards"]>>, {
     id: CurrentBoardId;
 }>;
-type BoardTemplateOf<Manifest extends GameTopologyManifest, CurrentTemplateId extends string> = Extract<ArrayItem<NonNullable<Manifest["boardTemplates"]>>, {
+type BoardTemplateOf<Manifest extends GameTopologyManifest$1, CurrentTemplateId extends string> = Extract<ArrayItem<NonNullable<Manifest["boardTemplates"]>>, {
     id: CurrentTemplateId;
 }>;
-type ResolvedBoardLikeOf<Manifest extends GameTopologyManifest, CurrentBoardId extends BoardId<Manifest>> = BoardOf<Manifest, CurrentBoardId> | (BoardOf<Manifest, CurrentBoardId> extends {
+type ResolvedBoardLikeOf<Manifest extends GameTopologyManifest$1, CurrentBoardId extends BoardId<Manifest>> = BoardOf<Manifest, CurrentBoardId> | (BoardOf<Manifest, CurrentBoardId> extends {
     templateId: infer CurrentTemplateId extends string;
 } ? BoardTemplateOf<Manifest, CurrentTemplateId> : never);
 type SpaceIdOf<BoardLike> = IdsOf<BoardLike extends {
@@ -67,18 +1506,18 @@ type HexSpaceOf<BoardLike> = Extract<SpaceOf<BoardLike>, {
     q: number;
     r: number;
 }>;
-type BoardEntryOf<Manifest extends GameTopologyManifest> = ArrayItem<NonNullable<Manifest["boards"]>>;
-type TemplateForBoardEntry<Manifest extends GameTopologyManifest, Entry> = Entry extends {
+type BoardEntryOf<Manifest extends GameTopologyManifest$1> = ArrayItem<NonNullable<Manifest["boards"]>>;
+type TemplateForBoardEntry<Manifest extends GameTopologyManifest$1, Entry> = Entry extends {
     templateId: infer TemplateId extends string;
     layout: infer Layout;
 } ? Extract<BoardTemplateOf<Manifest, TemplateId>, {
     layout: Layout;
 }> : never;
-type BoardLikeForEntry<Manifest extends GameTopologyManifest, Entry> = Entry extends BoardEntryOf<Manifest> ? Entry extends {
+type BoardLikeForEntry<Manifest extends GameTopologyManifest$1, Entry> = Entry extends BoardEntryOf<Manifest> ? Entry extends {
     id: infer CurrentBoardId extends BoardId<Manifest>;
 } ? ResolvedBoardLikeOf<Manifest, CurrentBoardId> : Entry : Entry;
-type SpaceIdForBoard<Manifest extends GameTopologyManifest, CurrentBoardId extends BoardId<Manifest>> = SpaceIdOf<ResolvedBoardLikeOf<Manifest, CurrentBoardId>>;
-type ContainerIdForBoard<Manifest extends GameTopologyManifest, CurrentBoardId extends BoardId<Manifest>> = ContainerIdOf<ResolvedBoardLikeOf<Manifest, CurrentBoardId>>;
+type SpaceIdForBoard<Manifest extends GameTopologyManifest$1, CurrentBoardId extends BoardId<Manifest>> = SpaceIdOf<ResolvedBoardLikeOf<Manifest, CurrentBoardId>>;
+type ContainerIdForBoard<Manifest extends GameTopologyManifest$1, CurrentBoardId extends BoardId<Manifest>> = ContainerIdOf<ResolvedBoardLikeOf<Manifest, CurrentBoardId>>;
 type RuntimeIdsFromCount<BaseId extends string, Count> = Count extends number ? number extends Count ? BaseId | `${BaseId}-${number}` : Count extends 1 ? BaseId : `${BaseId}-${OneTo<Count>}` : BaseId;
 type CardRuntimeId<Card> = Card extends {
     type: infer TypeId extends string;
@@ -92,32 +1531,32 @@ type SeedRuntimeId<Seed> = Seed extends {
 } ? Id : TypeId, Seed extends {
     count: infer Count extends number;
 } ? Count : never> : never;
-type CardId<Manifest extends GameTopologyManifest> = CardRuntimeId<CardOf<Manifest>>;
-type PieceId<Manifest extends GameTopologyManifest> = SeedRuntimeId<PieceSeedOf<Manifest>>;
-type DieId<Manifest extends GameTopologyManifest> = SeedRuntimeId<DieSeedOf<Manifest>>;
-type PieceTypeOf<Manifest extends GameTopologyManifest, CurrentTypeId extends PieceTypeId<Manifest>> = Extract<ArrayItem<NonNullable<Manifest["pieceTypes"]>>, {
+type CardId<Manifest extends GameTopologyManifest$1> = CardRuntimeId<CardOf<Manifest>>;
+type PieceId<Manifest extends GameTopologyManifest$1> = SeedRuntimeId<PieceSeedOf<Manifest>>;
+type DieId<Manifest extends GameTopologyManifest$1> = SeedRuntimeId<DieSeedOf<Manifest>>;
+type PieceTypeOf<Manifest extends GameTopologyManifest$1, CurrentTypeId extends PieceTypeId<Manifest>> = Extract<ArrayItem<NonNullable<Manifest["pieceTypes"]>>, {
     id: CurrentTypeId;
 }>;
-type DieTypeOf<Manifest extends GameTopologyManifest, CurrentTypeId extends DieTypeId<Manifest>> = Extract<ArrayItem<NonNullable<Manifest["dieTypes"]>>, {
+type DieTypeOf<Manifest extends GameTopologyManifest$1, CurrentTypeId extends DieTypeId<Manifest>> = Extract<ArrayItem<NonNullable<Manifest["dieTypes"]>>, {
     id: CurrentTypeId;
 }>;
 type SlotIdOf<TypeSpec> = IdsOf<TypeSpec extends {
     slots?: infer Slots;
 } ? Slots : never>;
-type SlotIdForPieceType<Manifest extends GameTopologyManifest, CurrentTypeId extends PieceTypeId<Manifest>> = SlotIdOf<PieceTypeOf<Manifest, CurrentTypeId>>;
-type SlotIdForDieType<Manifest extends GameTopologyManifest, CurrentTypeId extends DieTypeId<Manifest>> = SlotIdOf<DieTypeOf<Manifest, CurrentTypeId>>;
+type SlotIdForPieceType<Manifest extends GameTopologyManifest$1, CurrentTypeId extends PieceTypeId<Manifest>> = SlotIdOf<PieceTypeOf<Manifest, CurrentTypeId>>;
+type SlotIdForDieType<Manifest extends GameTopologyManifest$1, CurrentTypeId extends DieTypeId<Manifest>> = SlotIdOf<DieTypeOf<Manifest, CurrentTypeId>>;
 type SingletonExplicitSeed<Seed> = Seed extends {
     id: infer _Id extends string;
 } ? Seed extends {
     count: infer Count extends number;
 } ? Count extends 1 ? Seed : never : Seed : never;
-type TypedPieceSlotHostSeed<Manifest extends GameTopologyManifest> = SingletonExplicitSeed<PieceSeedOf<Manifest>> extends infer Seed ? Seed extends {
+type TypedPieceSlotHostSeed<Manifest extends GameTopologyManifest$1> = SingletonExplicitSeed<PieceSeedOf<Manifest>> extends infer Seed ? Seed extends {
     typeId: infer CurrentTypeId extends PieceTypeId<Manifest>;
 } ? [SlotIdForPieceType<Manifest, CurrentTypeId>] extends [never] ? never : Seed : never : never;
-type TypedDieSlotHostSeed<Manifest extends GameTopologyManifest> = SingletonExplicitSeed<DieSeedOf<Manifest>> extends infer Seed ? Seed extends {
+type TypedDieSlotHostSeed<Manifest extends GameTopologyManifest$1> = SingletonExplicitSeed<DieSeedOf<Manifest>> extends infer Seed ? Seed extends {
     typeId: infer CurrentTypeId extends DieTypeId<Manifest>;
 } ? [SlotIdForDieType<Manifest, CurrentTypeId>] extends [never] ? never : Seed : never : never;
-type TypedPieceSlotHomeSpec<Manifest extends GameTopologyManifest> = TypedPieceSlotHostSeed<Manifest> extends infer Seed ? Seed extends {
+type TypedPieceSlotHomeSpec<Manifest extends GameTopologyManifest$1> = TypedPieceSlotHostSeed<Manifest> extends infer Seed ? Seed extends {
     id: infer HostId extends string;
     typeId: infer CurrentTypeId extends PieceTypeId<Manifest>;
 } ? {
@@ -128,7 +1567,7 @@ type TypedPieceSlotHomeSpec<Manifest extends GameTopologyManifest> = TypedPieceS
     };
     slotId: SlotIdForPieceType<Manifest, CurrentTypeId>;
 } : never : never;
-type TypedDieSlotHomeSpec<Manifest extends GameTopologyManifest> = TypedDieSlotHostSeed<Manifest> extends infer Seed ? Seed extends {
+type TypedDieSlotHomeSpec<Manifest extends GameTopologyManifest$1> = TypedDieSlotHostSeed<Manifest> extends infer Seed ? Seed extends {
     id: infer HostId extends string;
     typeId: infer CurrentTypeId extends DieTypeId<Manifest>;
 } ? {
@@ -153,12 +1592,12 @@ type OptionalSchemaKeys<Properties extends Readonly<Record<string, unknown>>> =
         default: unknown;
     } ? Key : never;
 }[keyof Properties];
-type SchemaValueFromObjectProperties<Properties extends Readonly<Record<string, unknown>>, Manifest extends GameTopologyManifest, BoardLike = never> = keyof Properties extends never ? RuntimeRecord : {
+type SchemaValueFromObjectProperties<Properties extends Readonly<Record<string, unknown>>, Manifest extends GameTopologyManifest$1, BoardLike = never> = keyof Properties extends never ? RuntimeRecord : {
     [Key in RequiredSchemaKeys<Properties>]: SchemaValueForProperty<Properties[Key], Manifest, BoardLike>;
 } & {
     [Key in OptionalSchemaKeys<Properties>]?: SchemaValueForProperty<Properties[Key], Manifest, BoardLike>;
 };
-type SchemaValueForObjectSchema<Schema, Manifest extends GameTopologyManifest, BoardLike = never> = Schema extends {
+type SchemaValueForObjectSchema<Schema, Manifest extends GameTopologyManifest$1, BoardLike = never> = Schema extends {
     properties: infer Properties extends Readonly<Record<string, unknown>>;
 } ? SchemaValueFromObjectProperties<Properties, Manifest, BoardLike> : RuntimeRecord;
 type MergeSharedProperties<Variant, Shared> = Variant extends {
@@ -166,7 +1605,7 @@ type MergeSharedProperties<Variant, Shared> = Variant extends {
 } ? {
     properties: Shared extends Readonly<Record<string, unknown>> ? Omit<Shared, keyof VariantProperties> & VariantProperties : VariantProperties;
 } : Variant;
-type BaseSchemaValueForProperty<Schema, Manifest extends GameTopologyManifest, BoardLike = never> = Schema extends {
+type BaseSchemaValueForProperty<Schema, Manifest extends GameTopologyManifest$1, BoardLike = never> = Schema extends {
     type: "string";
 } ? string : Schema extends {
     type: "integer" | "number";
@@ -211,14 +1650,14 @@ type BaseSchemaValueForProperty<Schema, Manifest extends GameTopologyManifest, B
 } ? Record<string, SchemaValueForProperty<Schema extends {
     values?: infer Values;
 } ? Values : undefined, Manifest, BoardLike>> : RuntimeRecord;
-type SchemaValueForProperty<Schema, Manifest extends GameTopologyManifest, BoardLike = never> = Schema extends {
+type SchemaValueForProperty<Schema, Manifest extends GameTopologyManifest$1, BoardLike = never> = Schema extends {
     nullable: true;
 } ? BaseSchemaValueForProperty<Schema, Manifest, BoardLike> | null : BaseSchemaValueForProperty<Schema, Manifest, BoardLike>;
 type BuildTuple<Length extends number, Accumulator extends unknown[] = []> = Accumulator["length"] extends Length ? Accumulator : BuildTuple<Length, [...Accumulator, unknown]>;
 type EnumerateInternal<Length extends number, Accumulator extends number[] = []> = Accumulator["length"] extends Length ? Accumulator[number] : EnumerateInternal<Length, [...Accumulator, Accumulator["length"]]>;
 type AddOne<Count extends number> = [...BuildTuple<Count>, unknown]["length"] & number;
 type OneTo<Count extends number> = Exclude<EnumerateInternal<AddOne<Count>>, 0>;
-type PlayerId<Manifest extends GameTopologyManifest> = Manifest["players"]["maxPlayers"] extends infer MaxPlayers extends number ? `player-${OneTo<MaxPlayers>}` : `player-${number}`;
+type PlayerId<Manifest extends GameTopologyManifest$1> = Manifest["players"]["maxPlayers"] extends infer MaxPlayers extends number ? `player-${OneTo<MaxPlayers>}` : `player-${number}`;
 type ToNumber<Input extends string> = Input extends `${infer Value extends number}` ? Value : never;
 type AbsoluteNumber<Count extends number> = `${Count}` extends `-${infer Value extends number}` ? Value : Count;
 type IsNegative<Count extends number> = `${Count}` extends `-${string}` ? true : false;
@@ -277,80 +1716,80 @@ type DerivedVertexIdOf<BoardLike> = BoardLike extends {
 type SetupOptionChoiceId<Option> = IdsOf<Option extends {
     choices?: infer Choices;
 } ? Choices : never>;
-type SetupOptionOf<Manifest extends GameTopologyManifest> = ArrayItem<NonNullable<Manifest["setupOptions"]>>;
-type SetupOptionChoiceIdFor<Manifest extends GameTopologyManifest, OptionId extends SetupOptionId<Manifest>> = SetupOptionChoiceId<Extract<SetupOptionOf<Manifest>, {
+type SetupOptionOf<Manifest extends GameTopologyManifest$1> = ArrayItem<NonNullable<Manifest["setupOptions"]>>;
+type SetupOptionChoiceIdFor<Manifest extends GameTopologyManifest$1, OptionId extends SetupOptionId<Manifest>> = SetupOptionChoiceId<Extract<SetupOptionOf<Manifest>, {
     id: OptionId;
 }>>;
-type TypedSharedSpaceHomeSpec<Manifest extends GameTopologyManifest> = {
+type TypedSharedSpaceHomeSpec<Manifest extends GameTopologyManifest$1> = {
     [CurrentBoardId in SharedBoardId<Manifest>]: {
         type: "space";
         boardId: CurrentBoardId;
         spaceId: SpaceIdForBoard<Manifest, CurrentBoardId>;
     };
 }[SharedBoardId<Manifest>];
-type TypedPerPlayerSpaceHomeSpec<Manifest extends GameTopologyManifest> = {
+type TypedPerPlayerSpaceHomeSpec<Manifest extends GameTopologyManifest$1> = {
     [CurrentBoardId in PerPlayerBoardId<Manifest>]: {
         type: "space";
         boardId: CurrentBoardId;
         spaceId: SpaceIdForBoard<Manifest, CurrentBoardId>;
     };
 }[PerPlayerBoardId<Manifest>];
-type TypedSharedContainerHomeSpec<Manifest extends GameTopologyManifest> = {
+type TypedSharedContainerHomeSpec<Manifest extends GameTopologyManifest$1> = {
     [CurrentBoardId in SharedBoardId<Manifest>]: {
         type: "container";
         boardId: CurrentBoardId;
         containerId: ContainerIdForBoard<Manifest, CurrentBoardId>;
     };
 }[SharedBoardId<Manifest>];
-type TypedPerPlayerContainerHomeSpec<Manifest extends GameTopologyManifest> = {
+type TypedPerPlayerContainerHomeSpec<Manifest extends GameTopologyManifest$1> = {
     [CurrentBoardId in PerPlayerBoardId<Manifest>]: {
         type: "container";
         boardId: CurrentBoardId;
         containerId: ContainerIdForBoard<Manifest, CurrentBoardId>;
     };
 }[PerPlayerBoardId<Manifest>];
-type TypedSharedEdgeHomeSpec<Manifest extends GameTopologyManifest> = {
+type TypedSharedEdgeHomeSpec<Manifest extends GameTopologyManifest$1> = {
     [CurrentBoardId in SharedBoardId<Manifest>]: {
         type: "edge";
         boardId: CurrentBoardId;
         ref: BoardEdgeRef;
     };
 }[SharedBoardId<Manifest>];
-type TypedPerPlayerEdgeHomeSpec<Manifest extends GameTopologyManifest> = {
+type TypedPerPlayerEdgeHomeSpec<Manifest extends GameTopologyManifest$1> = {
     [CurrentBoardId in PerPlayerBoardId<Manifest>]: {
         type: "edge";
         boardId: CurrentBoardId;
         ref: BoardEdgeRef;
     };
 }[PerPlayerBoardId<Manifest>];
-type TypedSharedVertexHomeSpec<Manifest extends GameTopologyManifest> = {
+type TypedSharedVertexHomeSpec<Manifest extends GameTopologyManifest$1> = {
     [CurrentBoardId in SharedBoardId<Manifest>]: {
         type: "vertex";
         boardId: CurrentBoardId;
         ref: BoardVertexRef;
     };
 }[SharedBoardId<Manifest>];
-type TypedPerPlayerVertexHomeSpec<Manifest extends GameTopologyManifest> = {
+type TypedPerPlayerVertexHomeSpec<Manifest extends GameTopologyManifest$1> = {
     [CurrentBoardId in PerPlayerBoardId<Manifest>]: {
         type: "vertex";
         boardId: CurrentBoardId;
         ref: BoardVertexRef;
     };
 }[PerPlayerBoardId<Manifest>];
-type TypedSharedZoneHomeSpec<Manifest extends GameTopologyManifest> = {
+type TypedSharedZoneHomeSpec<Manifest extends GameTopologyManifest$1> = {
     type: "zone";
     zoneId: SharedZoneId<Manifest>;
 };
-type TypedPerPlayerZoneHomeSpec<Manifest extends GameTopologyManifest> = {
+type TypedPerPlayerZoneHomeSpec<Manifest extends GameTopologyManifest$1> = {
     type: "zone";
     zoneId: PerPlayerZoneId<Manifest>;
 };
-type TypedPlayerScopedComponentHomeSpec<Manifest extends GameTopologyManifest> = TypedPerPlayerZoneHomeSpec<Manifest> | TypedPerPlayerSpaceHomeSpec<Manifest> | TypedPerPlayerContainerHomeSpec<Manifest> | TypedPerPlayerEdgeHomeSpec<Manifest> | TypedPerPlayerVertexHomeSpec<Manifest>;
-type TypedSharedComponentHomeSpec<Manifest extends GameTopologyManifest> = {
+type TypedPlayerScopedComponentHomeSpec<Manifest extends GameTopologyManifest$1> = TypedPerPlayerZoneHomeSpec<Manifest> | TypedPerPlayerSpaceHomeSpec<Manifest> | TypedPerPlayerContainerHomeSpec<Manifest> | TypedPerPlayerEdgeHomeSpec<Manifest> | TypedPerPlayerVertexHomeSpec<Manifest>;
+type TypedSharedComponentHomeSpec<Manifest extends GameTopologyManifest$1> = {
     type: "detached";
 } | TypedSharedZoneHomeSpec<Manifest> | TypedSharedSpaceHomeSpec<Manifest> | TypedSharedContainerHomeSpec<Manifest> | TypedSharedEdgeHomeSpec<Manifest> | TypedSharedVertexHomeSpec<Manifest> | TypedPieceSlotHomeSpec<Manifest> | TypedDieSlotHomeSpec<Manifest>;
-type TypedComponentHomeSpec<Manifest extends GameTopologyManifest> = TypedSharedComponentHomeSpec<Manifest> | TypedPlayerScopedComponentHomeSpec<Manifest>;
-type TypedSeedLocationSpec<Seed, Manifest extends GameTopologyManifest> = Seed extends {
+type TypedComponentHomeSpec<Manifest extends GameTopologyManifest$1> = TypedSharedComponentHomeSpec<Manifest> | TypedPlayerScopedComponentHomeSpec<Manifest>;
+type TypedSeedLocationSpec<Seed, Manifest extends GameTopologyManifest$1> = Seed extends {
     home: infer Home;
 } ? Home extends TypedPlayerScopedComponentHomeSpec<Manifest> ? Omit<Seed, "ownerId" | "home"> & {
     ownerId: PlayerId<Manifest>;
@@ -362,16 +1801,16 @@ type TypedSeedLocationSpec<Seed, Manifest extends GameTopologyManifest> = Seed e
     ownerId?: PlayerId<Manifest>;
     home?: TypedComponentHomeSpec<Manifest>;
 };
-type TypedVisibilitySpec<Manifest extends GameTopologyManifest> = {
+type TypedVisibilitySpec<Manifest extends GameTopologyManifest$1> = {
     faceUp?: boolean;
     visibleTo?: readonly PlayerId<Manifest>[];
 };
-type TypedVisibility<T, Manifest extends GameTopologyManifest> = T extends {
+type TypedVisibility<T, Manifest extends GameTopologyManifest$1> = T extends {
     visibility?: unknown;
 } ? Omit<T, "visibility"> & {
     visibility?: TypedVisibilitySpec<Manifest>;
 } : T;
-type TypedFields<T, Schema, Manifest extends GameTopologyManifest, BoardLike = never> = T extends {
+type TypedFields<T, Schema, Manifest extends GameTopologyManifest$1, BoardLike = never> = T extends {
     fields?: unknown;
 } ? Omit<T, "fields"> & {
     fields?: SchemaValueForObjectSchema<Schema, Manifest, BoardLike>;
@@ -382,12 +1821,12 @@ type TypedBoardContainerHost<Host, BoardLike> = Host extends {
 } ? Omit<Host, "spaceId"> & {
     spaceId: SpaceIdOf<BoardLike>;
 } : Host;
-type TypedBoardContainer<Container, Manifest extends GameTopologyManifest, BoardLike, ContainerSchema> = Container extends {
+type TypedBoardContainer<Container, Manifest extends GameTopologyManifest$1, BoardLike, ContainerSchema> = Container extends {
     host: infer Host;
 } ? Omit<TypedFields<TypedAllowedCardSetIds<Container, Manifest>, ContainerSchema, Manifest, BoardLike>, "host"> & {
     host: TypedBoardContainerHost<Host, BoardLike>;
 } : TypedFields<TypedAllowedCardSetIds<Container, Manifest>, ContainerSchema, Manifest, BoardLike>;
-type TypedBoardRelation<Relation, Manifest extends GameTopologyManifest, BoardLike, RelationSchema> = Relation extends object ? Omit<TypedFields<Relation, RelationSchema, Manifest, BoardLike>, "fromSpaceId" | "toSpaceId"> & {
+type TypedBoardRelation<Relation, Manifest extends GameTopologyManifest$1, BoardLike, RelationSchema> = Relation extends object ? Omit<TypedFields<Relation, RelationSchema, Manifest, BoardLike>, "fromSpaceId" | "toSpaceId"> & {
     fromSpaceId: SpaceIdOf<BoardLike>;
     toSpaceId: SpaceIdOf<BoardLike>;
 } : Relation;
@@ -396,22 +1835,22 @@ type TypedOptionalArray<Base, Source, Key extends string, Item> = Source extends
 } ? Base & {
     [Property in Key]?: ReadonlyArray<Item>;
 } : Base;
-type EffectiveSchemaForEntry<Manifest extends GameTopologyManifest, Entry, Key extends string> = Key extends keyof Entry ? Entry[Key] : TemplateForBoardEntry<Manifest, Entry> extends infer Template ? Key extends keyof Template ? Template[Key] : undefined : undefined;
-type TypedGenericBoardLike<Entry, Manifest extends GameTopologyManifest, BoardLike> = TypedOptionalArray<TypedOptionalArray<TypedOptionalArray<TypedFields<Omit<Entry, "spaces" | "relations" | "containers">, EffectiveSchemaForEntry<Manifest, Entry, "boardFieldsSchema">, Manifest, BoardLike>, Entry, "spaces", TypedFields<ArrayItem<NonNullable<Entry extends {
+type EffectiveSchemaForEntry<Manifest extends GameTopologyManifest$1, Entry, Key extends string> = Key extends keyof Entry ? Entry[Key] : TemplateForBoardEntry<Manifest, Entry> extends infer Template ? Key extends keyof Template ? Template[Key] : undefined : undefined;
+type TypedGenericBoardLike<Entry, Manifest extends GameTopologyManifest$1, BoardLike> = TypedOptionalArray<TypedOptionalArray<TypedOptionalArray<TypedFields<Omit<Entry, "spaces" | "relations" | "containers">, EffectiveSchemaForEntry<Manifest, Entry, "boardFieldsSchema">, Manifest, BoardLike>, Entry, "spaces", TypedFields<ArrayItem<NonNullable<Entry extends {
     spaces?: infer Spaces;
 } ? Spaces : never>>, EffectiveSchemaForEntry<Manifest, Entry, "spaceFieldsSchema">, Manifest, BoardLike>>, Entry, "relations", TypedBoardRelation<ArrayItem<NonNullable<Entry extends {
     relations?: infer Relations;
 } ? Relations : never>>, Manifest, BoardLike, EffectiveSchemaForEntry<Manifest, Entry, "relationFieldsSchema">>>, Entry, "containers", TypedBoardContainer<ArrayItem<NonNullable<Entry extends {
     containers?: infer Containers;
 } ? Containers : never>>, Manifest, BoardLike, EffectiveSchemaForEntry<Manifest, Entry, "containerFieldsSchema">>>;
-type TypedHexBoardLike<Entry, Manifest extends GameTopologyManifest, BoardLike> = TypedOptionalArray<TypedOptionalArray<TypedOptionalArray<TypedFields<Omit<Entry, "spaces" | "edges" | "vertices">, EffectiveSchemaForEntry<Manifest, Entry, "boardFieldsSchema">, Manifest, BoardLike>, Entry, "spaces", TypedFields<ArrayItem<NonNullable<Entry extends {
+type TypedHexBoardLike<Entry, Manifest extends GameTopologyManifest$1, BoardLike> = TypedOptionalArray<TypedOptionalArray<TypedOptionalArray<TypedFields<Omit<Entry, "spaces" | "edges" | "vertices">, EffectiveSchemaForEntry<Manifest, Entry, "boardFieldsSchema">, Manifest, BoardLike>, Entry, "spaces", TypedFields<ArrayItem<NonNullable<Entry extends {
     spaces?: infer Spaces;
 } ? Spaces : never>>, EffectiveSchemaForEntry<Manifest, Entry, "spaceFieldsSchema">, Manifest, BoardLike>>, Entry, "edges", TypedFields<ArrayItem<NonNullable<Entry extends {
     edges?: infer Edges;
 } ? Edges : never>>, EffectiveSchemaForEntry<Manifest, Entry, "edgeFieldsSchema">, Manifest, BoardLike>>, Entry, "vertices", TypedFields<ArrayItem<NonNullable<Entry extends {
     vertices?: infer Vertices;
 } ? Vertices : never>>, EffectiveSchemaForEntry<Manifest, Entry, "vertexFieldsSchema">, Manifest, BoardLike>>;
-type TypedSquareBoardLike<Entry, Manifest extends GameTopologyManifest, BoardLike> = TypedOptionalArray<TypedOptionalArray<TypedOptionalArray<TypedOptionalArray<TypedOptionalArray<TypedFields<Omit<Entry, "spaces" | "relations" | "containers" | "edges" | "vertices">, EffectiveSchemaForEntry<Manifest, Entry, "boardFieldsSchema">, Manifest, BoardLike>, Entry, "spaces", TypedFields<ArrayItem<NonNullable<Entry extends {
+type TypedSquareBoardLike<Entry, Manifest extends GameTopologyManifest$1, BoardLike> = TypedOptionalArray<TypedOptionalArray<TypedOptionalArray<TypedOptionalArray<TypedOptionalArray<TypedFields<Omit<Entry, "spaces" | "relations" | "containers" | "edges" | "vertices">, EffectiveSchemaForEntry<Manifest, Entry, "boardFieldsSchema">, Manifest, BoardLike>, Entry, "spaces", TypedFields<ArrayItem<NonNullable<Entry extends {
     spaces?: infer Spaces;
 } ? Spaces : never>>, EffectiveSchemaForEntry<Manifest, Entry, "spaceFieldsSchema">, Manifest, BoardLike>>, Entry, "relations", TypedBoardRelation<ArrayItem<NonNullable<Entry extends {
     relations?: infer Relations;
@@ -422,14 +1861,14 @@ type TypedSquareBoardLike<Entry, Manifest extends GameTopologyManifest, BoardLik
 } ? Edges : never>>, EffectiveSchemaForEntry<Manifest, Entry, "edgeFieldsSchema">, Manifest, BoardLike>>, Entry, "vertices", TypedFields<ArrayItem<NonNullable<Entry extends {
     vertices?: infer Vertices;
 } ? Vertices : never>>, EffectiveSchemaForEntry<Manifest, Entry, "vertexFieldsSchema">, Manifest, BoardLike>>;
-type TypedBoardLikeEntry<Entry, Manifest extends GameTopologyManifest> = Entry extends {
+type TypedBoardLikeEntry<Entry, Manifest extends GameTopologyManifest$1> = Entry extends {
     layout: "generic";
 } ? TypedGenericBoardLike<Entry, Manifest, BoardLikeForEntry<Manifest, Entry>> : Entry extends {
     layout: "hex";
 } ? TypedHexBoardLike<Entry, Manifest, BoardLikeForEntry<Manifest, Entry>> : Entry extends {
     layout: "square";
 } ? TypedSquareBoardLike<Entry, Manifest, BoardLikeForEntry<Manifest, Entry>> : Entry;
-type TypedCard<Card, Manifest extends GameTopologyManifest, CardSchema> = Card extends {
+type TypedCard<Card, Manifest extends GameTopologyManifest$1, CardSchema> = Card extends {
     type: infer CardType extends string;
 } ? Omit<TypedVisibility<Card, Manifest>, "home" | "properties"> & {
     home?: TypedComponentHomeSpec<Manifest>;
@@ -438,18 +1877,18 @@ type TypedCard<Card, Manifest extends GameTopologyManifest, CardSchema> = Card e
         shared?: infer Shared;
     } ? CardType extends keyof Variants ? SchemaValueForObjectSchema<MergeSharedProperties<Variants[CardType], Shared>, Manifest> : never : SchemaValueForObjectSchema<CardSchema, Manifest>;
 } : Card;
-type TypedCardSet<CardSet, Manifest extends GameTopologyManifest> = CardSet extends {
+type TypedCardSet<CardSet, Manifest extends GameTopologyManifest$1> = CardSet extends {
     type: "manual";
     cardSchema: infer CardSchema;
     cards: infer Cards extends readonly unknown[];
 } ? Omit<CardSet, "cards"> & {
     cards: ReadonlyArray<TypedCard<ArrayItem<Cards>, Manifest, CardSchema>>;
 } : CardSet;
-type TypedAllowedCardSetIds<T, Manifest extends GameTopologyManifest> = T extends object ? Omit<T, "allowedCardSetIds"> & {
+type TypedAllowedCardSetIds<T, Manifest extends GameTopologyManifest$1> = T extends object ? Omit<T, "allowedCardSetIds"> & {
     allowedCardSetIds?: readonly CardSetId<Manifest>[];
 } : T;
-type TypedZone<Zone, Manifest extends GameTopologyManifest> = TypedAllowedCardSetIds<Zone, Manifest>;
-type TypedPieceSeed<Seed, Manifest extends GameTopologyManifest> = Seed extends {
+type TypedZone<Zone, Manifest extends GameTopologyManifest$1> = TypedAllowedCardSetIds<Zone, Manifest>;
+type TypedPieceSeed<Seed, Manifest extends GameTopologyManifest$1> = Seed extends {
     typeId: infer CurrentTypeId;
 } ? CurrentTypeId extends PieceTypeId<Manifest> ? Omit<TypedSeedLocationSpec<TypedVisibility<Seed, Manifest>, Manifest>, "typeId" | "ownerId" | "home" | "fields"> & {
     typeId: CurrentTypeId;
@@ -459,7 +1898,7 @@ type TypedPieceSeed<Seed, Manifest extends GameTopologyManifest> = Seed extends
 } & Pick<TypedSeedLocationSpec<TypedVisibility<Seed, Manifest>, Manifest>, "ownerId" | "home"> : Omit<Seed, "typeId"> & {
     typeId: PieceTypeId<Manifest>;
 } : never;
-type TypedDieSeed<Seed, Manifest extends GameTopologyManifest> = Seed extends {
+type TypedDieSeed<Seed, Manifest extends GameTopologyManifest$1> = Seed extends {
     typeId: infer CurrentTypeId;
 } ? CurrentTypeId extends DieTypeId<Manifest> ? Omit<TypedSeedLocationSpec<TypedVisibility<Seed, Manifest>, Manifest>, "typeId" | "ownerId" | "home" | "fields"> & {
     typeId: CurrentTypeId;
@@ -469,13 +1908,13 @@ type TypedDieSeed<Seed, Manifest extends GameTopologyManifest> = Seed extends {
 } & Pick<TypedSeedLocationSpec<TypedVisibility<Seed, Manifest>, Manifest>, "ownerId" | "home"> : Omit<Seed, "typeId"> & {
     typeId: DieTypeId<Manifest>;
 } : never;
-type TypedSetupOptionValues<Manifest extends GameTopologyManifest> = Partial<{
+type TypedSetupOptionValues<Manifest extends GameTopologyManifest$1> = Partial<{
     [OptionId in SetupOptionId<Manifest>]: SetupOptionChoiceIdFor<Manifest, OptionId>;
 }>;
-type TypedSetupProfile<Profile, Manifest extends GameTopologyManifest> = Profile extends object ? Omit<Profile, "optionValues"> & {
+type TypedSetupProfile<Profile, Manifest extends GameTopologyManifest$1> = Profile extends object ? Omit<Profile, "optionValues"> & {
     optionValues?: TypedSetupOptionValues<Manifest>;
 } : Profile;
-type TypedTopologyManifest<Manifest extends GameTopologyManifest> = Omit<Manifest, "cardSets" | "zones" | "boardTemplates" | "boards" | "pieceSeeds" | "dieSeeds" | "setupProfiles"> & {
+type TypedTopologyManifest<Manifest extends GameTopologyManifest$1> = Omit<Manifest, "cardSets" | "zones" | "boardTemplates" | "boards" | "pieceSeeds" | "dieSeeds" | "setupProfiles"> & {
     cardSets: ReadonlyArray<TypedCardSet<ArrayItem<Manifest["cardSets"]>, Manifest>>;
     zones?: Manifest["zones"] extends readonly unknown[] ? ReadonlyArray<TypedZone<ArrayItem<Manifest["zones"]>, Manifest>> : Manifest["zones"];
     boardTemplates?: Manifest["boardTemplates"] extends readonly unknown[] ? ReadonlyArray<TypedBoardLikeEntry<ArrayItem<Manifest["boardTemplates"]>, Manifest>> : Manifest["boardTemplates"];
@@ -484,8 +1923,8 @@ type TypedTopologyManifest<Manifest extends GameTopologyManifest> = Omit<Manifes
     dieSeeds?: Manifest["dieSeeds"] extends readonly unknown[] ? ReadonlyArray<TypedDieSeed<ArrayItem<Manifest["dieSeeds"]>, Manifest>> : Manifest["dieSeeds"];
     setupProfiles?: Manifest["setupProfiles"] extends readonly unknown[] ? ReadonlyArray<TypedSetupProfile<ArrayItem<Manifest["setupProfiles"]>, Manifest>> : Manifest["setupProfiles"];
 };
-type TopologyManifestValidation<Manifest> = Manifest extends GameTopologyManifest ? TypedTopologyManifest<Manifest> : GameTopologyManifest;
-type DefinedTopologyManifest<Manifest> = Manifest extends GameTopologyManifest ? Manifest : GameTopologyManifest;
+type TopologyManifestValidation<Manifest> = Manifest extends GameTopologyManifest$1 ? TypedTopologyManifest<Manifest> : GameTopologyManifest$1;
+type DefinedTopologyManifest<Manifest> = Manifest extends GameTopologyManifest$1 ? Manifest : GameTopologyManifest$1;
 declare function defineTopologyManifest<const Manifest>(manifest: Manifest & TopologyManifestValidation<NoInfer<Manifest>>): DefinedTopologyManifest<Manifest>;
 
 type RecordInitializer<Id extends string, Value> = Value | ((id: Id) => Value);
@@ -493,4 +1932,11 @@ declare function buildTypedRecord<Id extends string, Value>(ids: readonly Id[],
 declare function isTypedId<Id extends string>(ids: readonly Id[], value: string): value is Id;
 declare function expectTypedId<Id extends string>(ids: readonly Id[], value: string, description: string): Id;
 
-export { BoardEdgeRef, BoardVertexRef, JsonValue, type TypedTopologyManifest, buildTypedRecord, defineTopologyManifest, expectTypedId, isTypedId };
+type DieTypeSpec = Omit<DieTypeSpec$2, "sides"> & {
+    sides?: DieTypeSpec$2["sides"];
+};
+type GameTopologyManifest = Omit<GameTopologyManifest$2, "dieTypes"> & {
+    dieTypes?: Array<DieTypeSpec>;
+};
+
+export { type ActionDefinition, type ActionInteractionDescriptor, type ActionParameterDefinition, type AvailableInteractionAvailability, type BlockedInteractionAvailability, type BoardCard, type BoardContainerHostSpec, type BoardContainerSpec, type BoardEdgeRef, type BoardHostSpec, type BoardLayout, type BoardRelationSpec, type BoardSpaceSpec, type BoardSpec, type BoardTargetDomain, type BoardTemplateSpec, type BoardVertexRef, type BoundedNumberDomain, type CardCollection, type CardPropertySchema, type CardPropertySchemaVariants, type CardSetDefinition, type CardSetSourceType, type CardTargetDomain, type ChoiceDomain, type ChoiceDomainOption, type ChoiceListDomain, type ComponentHomeSpec, type ComponentSlotSpec, type ComponentVisibilitySpec, type ContainerHomeSpec, type DetachedHomeSpec, type DieSeedSpec, type DieSlotHostRef, type DieTypeSpec, type EagerInputDomainDependencies, type EdgeHomeSpec, type GameTopologyManifest, type GenericBoardSpec, type GenericBoardTemplateSpec, type HexBoardSpec, type HexBoardTemplateSpec, type HexEdgeRef, type HexEdgeSpec, type HexOrientation, type HexSpaceSpec, type HexVertexRef, type HexVertexSpec, type HistoryEntrySummary, type HostActionSubmitResponse, type HostEndedSessionSnapshot, type HostGameplaySeatView, type HostGameplaySessionSnapshot, type HostGameplaySharedView, type HostLobbySessionSnapshot, type HostLobbyView, type HostPlayerGameplayView, type HostSessionContext, type HostSessionEventCausation, type HostSessionGameplayUpdatedEvent, type HostSessionSnapshot, type HostSessionStatus, type InputDomain, type InputDomainDependencyCase, type InputDomainResolver, type InputSelection, type InsufficientResourcesInteractionAvailability, type InteractionAvailability, type InteractionCommitPolicy, type InteractionContext, type InteractionContextOption, type InteractionDescriptor, type InteractionDescriptorBase, type InteractionInputDescriptor, type JsonValue, type LazyBoardTargetDomain, type LazyCardTargetDomain, type LazyInputDomainDependencies, type ManualCardSetDefinition, type ManyInputSelection, type NotYourTurnInteractionAvailability, type ObjectSchema, type ParameterType, type PieceSeedSpec, type PieceSlotHostRef, type PieceTypeSpec, type PlayerId$1 as PlayerId, type PlayersDefinition, type PresetCardSetDefinition, type PromptInteractionDescriptor, type PropertySchema, type ResolvedBoardTargetDomain, type ResolvedCardTargetDomain, type ResourceDefinition, type ResourceMapDomain, type ResourceMapDomainEntry, type SeatAssignment, type SessionActor, type SessionActorAuthUser, type SessionActorDemoGuest, type SessionGameSource, type SessionGameSourceDemoRevision, type SessionGameSourceUserCompiled, type SessionSnapshotHistory, type SessionSnapshotPhase, type SetupOptionChoiceSpec, type SetupOptionSpec, type SetupProfileSpec, type SimultaneousPhaseSnapshot, type SingleInputSelection, type SlotHomeSpec, type SlotHostRef, type SpaceHomeSpec, type SpaceHostSpec, type SquareBoardSpec, type SquareBoardTemplateSpec, type SquareEdgeSpec, type SquareSpaceSpec, type SquareVertexSpec, type TopologyScope, type TypedTopologyManifest, type VertexHomeSpec, type ViewCard, type ViewSlotOccupant, type ZoneHandles, type ZoneHomeSpec, type ZoneSpec, type ZoneVisibility, buildTypedRecord, defineTopologyManifest, expectTypedId, isTypedId };