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

package/dist/{definition-BaHNPZol.d.ts → extract-gVKcB8Og.d.ts}

@@ -139,6 +139,8 @@ type RuntimeCardData = {
     cardType: string;
     name?: string;
     text?: string;
+    frontImage?: string;
+    backImage?: string;
     properties: RuntimeRecord;
 };
 type RuntimePieceData = {
@@ -227,179 +229,6 @@ type RuntimeTableRecord = {
     dice: Record<string, RuntimeDieData>;
 };
 
-declare const FrameworkErrorCodes: {
-    readonly NOT_YOUR_TURN: "NOT_YOUR_TURN";
-    readonly WRONG_PHASE: "WRONG_PHASE";
-    readonly WRONG_STEP: "WRONG_STEP";
-    readonly NO_LEGAL_INPUT: "NO_LEGAL_INPUT";
-    readonly INVALID_PARAMS: "INVALID_PARAMS";
-    readonly UNKNOWN_INTERACTION: "UNKNOWN_INTERACTION";
-    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
-};
-type FrameworkErrorCode = (typeof FrameworkErrorCodes)[keyof typeof FrameworkErrorCodes];
-
-type TableOfState<State> = State extends {
-    table: infer Table;
-} ? Table : never;
-type TableOfManifest<Manifest> = Manifest extends {
-    tableSchema: z.ZodType<infer Table extends RuntimeTableRecord>;
-} ? Table : Manifest extends ReducerManifestContractLike<infer Table> ? Table : never;
-type PhaseNameOfState<State> = State extends {
-    flow: {
-        currentPhase: infer PhaseName;
-    };
-} ? Extract<PhaseName, string> : never;
-type PhaseNameOfManifest<Manifest> = Manifest extends {
-    literals: {
-        phaseNames: readonly (infer PhaseName)[];
-    };
-} ? Extract<PhaseName, string> : never;
-type PlayerIdOfTable<Table> = Table extends {
-    playerOrder: readonly (infer PlayerId)[];
-} ? Extract<PlayerId, string> : never;
-type PlayerIdOfState<State> = PlayerIdOfTable<TableOfState<State>>;
-type ErrorCodeOfContract<Contract> = Contract extends {
-    errors: infer Errors extends Record<string, string>;
-} ? (keyof Errors & string) | FrameworkErrorCode : string;
-/**
- * Manifest-declared resource id union for a runtime table.
- *
- * Derived from the shape of `table.resources`, which the generated
- * manifest contract seeds as `Record<PlayerId, Record<ResourceId, number>>`.
- * Resource identifiers come from the player balance record.
- */
-type ResourceIdOfTable<Table> = Table extends {
-    resources: infer Resources;
-} ? PlayerRecordValue<Resources> extends infer PlayerValue ? PlayerValue extends Record<string, unknown> ? StringKeyOf<PlayerValue> : never : never : never;
-/**
- * Per-player balance shape for a runtime table. Extracts the
- * value of `table.resources` so callers receive the manifest-typed
- * record directly (e.g. `Record<ResourceId, number>`).
- */
-type ResourceBalancesOfTable<Table> = Table extends {
-    resources: infer Resources;
-} ? PlayerRecordValue<Resources> extends infer PlayerValue ? PlayerValue extends Record<string, unknown> ? PlayerValue : never : never : never;
-/**
- * Per-player resource counts: a partial `Record<ResourceId, number>`.
- *
- * Used as the input shape for {@link ReducerTransaction.addResources},
- * {@link ReducerTransaction.spendResources}, and {@link ReducerTransaction.transferResources}.
- */
-type ResourceAmountsOfTable<Table> = Partial<Record<ResourceIdOfTable<Table>, number>>;
-type PhaseStateOfState<State> = State extends {
-    phase: infer PhaseState;
-} ? PhaseState : never;
-type PublicStateOfState<State> = State extends {
-    publicState: infer PublicState;
-} ? PublicState : never;
-type HiddenStateOfState<State> = State extends {
-    hiddenState: infer HiddenState;
-} ? HiddenState : never;
-type PrivateStateOfState<State> = State extends {
-    privateState: Record<string, infer PrivateState>;
-} ? PrivateState : never;
-type DeckIdOfTable<Table> = Table extends {
-    decks: infer Decks;
-} ? StringKeyOf<Decks> : never;
-type HandIdOfTable<Table> = Table extends {
-    hands: infer Hands;
-} ? StringKeyOf<Hands> : never;
-type CardIdOfTable<Table> = Table extends {
-    cards: infer Cards;
-} ? StringKeyOf<Cards> : never;
-type DeckIdOfState<State> = DeckIdOfTable<TableOfState<State>>;
-type HandIdOfState<State> = HandIdOfTable<TableOfState<State>>;
-type CardIdOfManifest<Manifest> = Manifest extends {
-    literals: {
-        cardIds: readonly (infer CardId)[];
-    };
-} ? Extract<CardId, string> : string;
-type SharedZoneIdOfTable<Table> = DeckIdOfTable<Table>;
-type PlayerZoneIdOfTable<Table> = HandIdOfTable<Table>;
-type BoardMapOfTable<Table> = Table extends {
-    boards: {
-        byId: infer Boards;
-    };
-} ? Boards : never;
-type BoardIdOfTable<Table> = StringKeyOf<BoardMapOfTable<Table>>;
-type BoardStateOfTable<Table, BoardId extends BoardIdOfTable<Table>> = BoardMapOfTable<Table>[BoardId];
-type TiledBoardIdOfTable<Table> = {
-    [BoardId in BoardIdOfTable<Table>]: BoardStateOfTable<Table, BoardId> extends {
-        layout: "hex" | "square";
-    } ? BoardId : never;
-}[BoardIdOfTable<Table>];
-type TiledBoardStateOfTable<Table, BoardId extends TiledBoardIdOfTable<Table>> = BoardStateOfTable<Table, BoardId> extends infer BoardState ? BoardState extends {
-    layout: "hex" | "square";
-    spaces: Record<string, unknown>;
-    edges: readonly {
-        id: string;
-    }[];
-    vertices: readonly {
-        id: string;
-    }[];
-} ? BoardState : never : never;
-type SpaceIdOfTable<Table, BoardId extends BoardIdOfTable<Table>> = BoardStateOfTable<Table, BoardId> extends {
-    spaces: infer Spaces;
-} ? StringKeyOf<Spaces> : never;
-type BoardContainerIdOfTable<Table, BoardId extends BoardIdOfTable<Table>> = BoardStateOfTable<Table, BoardId> extends {
-    containers: infer Containers;
-} ? StringKeyOf<Containers> : never;
-type TiledSpaceIdOfTable<Table, BoardId extends TiledBoardIdOfTable<Table>> = TiledBoardStateOfTable<Table, BoardId> extends {
-    spaces: infer Spaces;
-} ? StringKeyOf<Spaces> : never;
-type TiledEdgeIdOfTable<Table, BoardId extends TiledBoardIdOfTable<Table>> = TiledBoardStateOfTable<Table, BoardId> extends {
-    edges: readonly (infer Edge)[];
-} ? Edge extends {
-    id: infer EdgeId;
-} ? Extract<EdgeId, string> : never : never;
-type TiledVertexIdOfTable<Table, BoardId extends TiledBoardIdOfTable<Table>> = TiledBoardStateOfTable<Table, BoardId> extends {
-    vertices: readonly (infer Vertex)[];
-} ? Vertex extends {
-    id: infer VertexId;
-} ? Extract<VertexId, string> : never : never;
-type ComponentIdOfTable<Table> = Table extends {
-    componentLocations: infer ComponentLocations;
-} ? StringKeyOf<ComponentLocations> : never;
-type PlayerZoneIdOfState<State> = HandIdOfState<State>;
-type ManifestOf<Source> = Source extends {
-    contract: infer Contract;
-} ? ManifestOf<Contract> : Source extends {
-    manifest: infer Manifest;
-} ? Manifest : never;
-type StateDefinitionOfContract<Contract> = Contract extends {
-    state: infer StateDefinitionValue;
-} ? StateDefinitionValue : never;
-type PhaseSchemasOfContract<Contract> = Contract extends {
-    phases: infer Phases extends Record<string, SchemaLike<object>>;
-} ? Phases : Record<PhaseNameOfManifest<ManifestOf<Contract>>, SchemaLike<object>>;
-type PhaseStateMapOfContract<Contract> = {
-    [Name in keyof PhaseSchemasOfContract<Contract> & string]: z.infer<PhaseSchemasOfContract<Contract>[Name]>;
-};
-type PublicSchemaOfContract<Contract> = StateDefinitionOfContract<Contract> extends StateDefinition<infer PublicSchema, SchemaLike<object>, SchemaLike<object>> ? PublicSchema : never;
-type PrivateSchemaOfContract<Contract> = StateDefinitionOfContract<Contract> extends StateDefinition<SchemaLike<object>, infer PrivateSchema, SchemaLike<object>> ? PrivateSchema : never;
-type HiddenSchemaOfContract<Contract> = StateDefinitionOfContract<Contract> extends StateDefinition<SchemaLike<object>, SchemaLike<object>, infer HiddenSchema> ? HiddenSchema : never;
-type PhaseNameOfContract<Contract> = keyof PhaseSchemasOfContract<Contract> extends string ? keyof PhaseSchemasOfContract<Contract> & string : PhaseNameOfManifest<ManifestOf<Contract>>;
-type ManifestContractOf<Contract> = ManifestContract<TableOfManifest<ManifestOf<Contract>>>;
-type ExactManifestContractOf<Contract> = ManifestOf<Contract> & ReducerManifestContractLike<TableOfManifest<ManifestOf<Contract>>>;
-type DeckCardsOfTable<Table, DeckId extends DeckIdOfTable<Table>> = Table extends {
-    decks: infer Decks extends Record<string, readonly unknown[]>;
-} ? Decks[DeckId] : never;
-type PlayerRecordValue<T> = T extends Record<string, infer Value> ? Value : never;
-type HandCardsOfTable<Table, HandId extends HandIdOfTable<Table>> = Table extends {
-    hands: infer Hands extends Record<string, unknown>;
-} ? HandId extends keyof Hands ? PlayerRecordValue<Hands[HandId]> extends infer Value ? Value extends readonly unknown[] ? Value : never : never : never : never;
-type CardIdOfDeck<Table, DeckId extends DeckIdOfTable<Table>> = DeckCardsOfTable<Table, DeckId>[number];
-type CardIdOfHand<Table, HandId extends HandIdOfTable<Table>> = HandCardsOfTable<Table, HandId>[number];
-type CompatibleHandIdForDeck<Table, DeckId extends DeckIdOfTable<Table>> = {
-    [CandidateHandId in HandIdOfTable<Table>]: Extract<CardIdOfDeck<Table, DeckId>, CardIdOfHand<Table, CandidateHandId>> extends never ? never : CandidateHandId;
-}[HandIdOfTable<Table>];
-type CompatibleCardIdForHandAndDeck<Table, HandId extends HandIdOfTable<Table>, DeckId extends DeckIdOfTable<Table>> = Extract<CardIdOfHand<Table, HandId>, CardIdOfDeck<Table, DeckId>>;
-type CompatibleCardIdForTwoPlayerZones<Table, FromZoneId extends HandIdOfTable<Table>, ToZoneId extends HandIdOfTable<Table>> = Extract<CardIdOfHand<Table, FromZoneId>, CardIdOfHand<Table, ToZoneId>>;
-type OptionsSchemaOfContract<Contract> = Contract extends {
-    options: infer Schema extends SchemaLike<RuntimeRecord>;
-} ? Schema : SchemaLike<Record<string, never>>;
-type OptionsOfContract<Contract> = z.infer<OptionsSchemaOfContract<Contract>>;
-
 declare const InteractionCommitPolicySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     mode: z.ZodLiteral<"manual">;
 }, z.core.$strict>, z.ZodObject<{
@@ -436,7 +265,7 @@ declare const InputDomainSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     targetKind: z.ZodLiteral<"card">;
     zoneIds: z.ZodArray<z.ZodString>;
     eligibleTargets: z.ZodArray<z.ZodString>;
-}, z.core.$strict>, z.ZodObject<{
+}, z.core.$strict>, z.ZodDiscriminatedUnion<[z.ZodObject<{
     selection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         mode: z.ZodLiteral<"single">;
     }, z.core.$strict>, z.ZodObject<{
@@ -448,18 +277,34 @@ declare const InputDomainSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"boardTarget">;
     projection: z.ZodLiteral<"resolved">;
     targetKind: z.ZodEnum<{
+        space: "space";
         edge: "edge";
         vertex: "vertex";
-        space: "space";
         tile: "tile";
     }>;
     boardId: z.ZodString;
-    valueKind: z.ZodOptional<z.ZodEnum<{
-        "board-id": "board-id";
-        "player-board-space": "player-board-space";
-    }>>;
+    valueKind: z.ZodLiteral<"board-id">;
     eligibleTargets: z.ZodArray<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
+    selection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"single">;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"many">;
+        min: z.ZodNumber;
+        max: z.ZodOptional<z.ZodNumber>;
+        distinct: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>], "mode">>;
+    type: z.ZodLiteral<"boardTarget">;
+    projection: z.ZodLiteral<"resolved">;
+    targetKind: z.ZodLiteral<"space">;
+    boardId: z.ZodString;
+    valueKind: z.ZodLiteral<"player-board-space">;
+    eligibleTargets: z.ZodArray<z.ZodObject<{
+        boardId: z.ZodString;
+        playerId: z.ZodString;
+        spaceId: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "valueKind">, z.ZodObject<{
     selection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         mode: z.ZodLiteral<"single">;
     }, z.core.$strict>, z.ZodObject<{
@@ -555,7 +400,7 @@ declare const InteractionInputDescriptorSchema: z.ZodObject<{
         targetKind: z.ZodLiteral<"card">;
         zoneIds: z.ZodArray<z.ZodString>;
         eligibleTargets: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodDiscriminatedUnion<[z.ZodObject<{
         selection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
             mode: z.ZodLiteral<"single">;
         }, z.core.$strict>, z.ZodObject<{
@@ -567,18 +412,34 @@ declare const InteractionInputDescriptorSchema: z.ZodObject<{
         type: z.ZodLiteral<"boardTarget">;
         projection: z.ZodLiteral<"resolved">;
         targetKind: z.ZodEnum<{
+            space: "space";
             edge: "edge";
             vertex: "vertex";
-            space: "space";
             tile: "tile";
         }>;
         boardId: z.ZodString;
-        valueKind: z.ZodOptional<z.ZodEnum<{
-            "board-id": "board-id";
-            "player-board-space": "player-board-space";
-        }>>;
+        valueKind: z.ZodLiteral<"board-id">;
         eligibleTargets: z.ZodArray<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
+        selection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"single">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"many">;
+            min: z.ZodNumber;
+            max: z.ZodOptional<z.ZodNumber>;
+            distinct: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>], "mode">>;
+        type: z.ZodLiteral<"boardTarget">;
+        projection: z.ZodLiteral<"resolved">;
+        targetKind: z.ZodLiteral<"space">;
+        boardId: z.ZodString;
+        valueKind: z.ZodLiteral<"player-board-space">;
+        eligibleTargets: z.ZodArray<z.ZodObject<{
+            boardId: z.ZodString;
+            playerId: z.ZodString;
+            spaceId: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "valueKind">, z.ZodObject<{
         selection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
             mode: z.ZodLiteral<"single">;
         }, z.core.$strict>, z.ZodObject<{
@@ -702,7 +563,7 @@ declare const InteractionDescriptorSchema: z.ZodObject<{
             targetKind: z.ZodLiteral<"card">;
             zoneIds: z.ZodArray<z.ZodString>;
             eligibleTargets: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>, z.ZodObject<{
+        }, z.core.$strict>, z.ZodDiscriminatedUnion<[z.ZodObject<{
             selection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 mode: z.ZodLiteral<"single">;
             }, z.core.$strict>, z.ZodObject<{
@@ -714,18 +575,34 @@ declare const InteractionDescriptorSchema: z.ZodObject<{
             type: z.ZodLiteral<"boardTarget">;
             projection: z.ZodLiteral<"resolved">;
             targetKind: z.ZodEnum<{
+                space: "space";
                 edge: "edge";
                 vertex: "vertex";
-                space: "space";
                 tile: "tile";
             }>;
             boardId: z.ZodString;
-            valueKind: z.ZodOptional<z.ZodEnum<{
-                "board-id": "board-id";
-                "player-board-space": "player-board-space";
-            }>>;
+            valueKind: z.ZodLiteral<"board-id">;
             eligibleTargets: z.ZodArray<z.ZodString>;
         }, z.core.$strict>, z.ZodObject<{
+            selection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"single">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"many">;
+                min: z.ZodNumber;
+                max: z.ZodOptional<z.ZodNumber>;
+                distinct: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>], "mode">>;
+            type: z.ZodLiteral<"boardTarget">;
+            projection: z.ZodLiteral<"resolved">;
+            targetKind: z.ZodLiteral<"space">;
+            boardId: z.ZodString;
+            valueKind: z.ZodLiteral<"player-board-space">;
+            eligibleTargets: z.ZodArray<z.ZodObject<{
+                boardId: z.ZodString;
+                playerId: z.ZodString;
+                spaceId: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "valueKind">, z.ZodObject<{
             selection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 mode: z.ZodLiteral<"single">;
             }, z.core.$strict>, z.ZodObject<{
@@ -850,28 +727,6 @@ type PlayersDefinition = {
     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";
-    /**
-     * Default initial home for cards materialized from the preset.
-     */
-    defaultHome: ComponentHomeSpec;
-};
 /**
  * Arbitrary authored JSON value.
  */
@@ -935,7 +790,7 @@ type CardPropertySchemaVariants = {
         [key: string]: PropertySchema;
     };
     /**
-     * Property schema for each card type in this manual card set.
+     * Property schema for each card type in this card set.
      */
     variants: {
         [key: string]: ObjectSchema;
@@ -1026,17 +881,22 @@ type ComponentVisibilitySpec = {
 };
 type BoardCard = {
     /**
-     * Card type identifier used to generate runtime CardIds. When count > 1, runtime IDs are generated as '{type}-1', '{type}-2', etc.
+     * Card definition identifier used to generate runtime CardIds. When count > 1, runtime IDs are generated as '{id}-1', '{id}-2', etc.
      */
-    type: string;
+    id: string;
     /**
      * Display name of the card
      */
     name: string;
     /**
-     * URL to the card's image
+     * Front face image: a repository path under `assets/`, such as
+     * `assets/cards/queen-of-fire.webp`. Game UIs receive it as a loadable URL.
      */
-    imageUrl?: string;
+    frontImage?: string;
+    /**
+     * Back face image, in the same form as `frontImage`.
+     */
+    backImage?: string;
     /**
      * Text content on the card
      */
@@ -1046,11 +906,11 @@ type BoardCard = {
      */
     count: number;
     /**
-     * Optional authored card category or subtype identifier
+     * Authored card category or subtype identifier
      */
-    cardType?: string;
+    cardType: string;
     /**
-     * Optional per-card initial home. Omitted cards use their manual card set's
+     * Optional per-card initial home. Omitted cards use their card set's
      * defaultHome. Compatibility declarations such as allowedCardSetIds never
      * imply placement. Player-scoped distribution belongs in reducer setup.
      */
@@ -1066,7 +926,7 @@ type BoardCard = {
         [key: string]: JsonValue;
     };
 };
-type ManualCardSetDefinition = {
+type CardSetDefinition = {
     /**
      * Unique identifier for the card set
      */
@@ -1075,10 +935,6 @@ type ManualCardSetDefinition = {
      * 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
      */
@@ -1092,11 +948,6 @@ type ManualCardSetDefinition = {
      */
     cards: Array<BoardCard>;
 };
-type CardSetDefinition = ({
-    type: "preset";
-} & PresetCardSetDefinition) | ({
-    type: "manual";
-} & ManualCardSetDefinition);
 /**
  * Whether authored topology exists once for the table or once per player
  */
@@ -1584,6 +1435,11 @@ type ResourceDefinition = {
      * Optional compact icon or emoji rendered by generic UI resource controls.
      */
     icon?: string;
+    /**
+     * Who sees each player's balance in seat projections. Defaults to
+     * `"public"`; `"owner"` balances reach only the player who holds them.
+     */
+    visibility?: "public" | "owner";
 };
 /**
  * One authored setup option choice
@@ -2732,6 +2588,7 @@ declare const SeatProjectionSchema: z.ZodObject<{
         cardViewsById: z.ZodRecord<z.ZodString, z.ZodString>;
         playableByCardId: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>>;
+    resources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>>;
 }, z.core.$strict>;
 declare const SimultaneousPhaseProjectionSchema: z.ZodObject<{
     phaseName: z.ZodString;
@@ -2827,7 +2684,7 @@ declare const SeatProjectionBundleSchema: z.ZodObject<{
                 targetKind: z.ZodLiteral<"card">;
                 zoneIds: z.ZodArray<z.ZodString>;
                 eligibleTargets: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>, z.ZodObject<{
+            }, z.core.$strict>, z.ZodDiscriminatedUnion<[z.ZodObject<{
                 selection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
                     mode: z.ZodLiteral<"single">;
                 }, z.core.$strict>, z.ZodObject<{
@@ -2839,16 +2696,13 @@ declare const SeatProjectionBundleSchema: z.ZodObject<{
                 type: z.ZodLiteral<"boardTarget">;
                 projection: z.ZodLiteral<"resolved">;
                 targetKind: z.ZodEnum<{
+                    space: "space";
                     edge: "edge";
                     vertex: "vertex";
-                    space: "space";
                     tile: "tile";
                 }>;
                 boardId: z.ZodString;
-                valueKind: z.ZodOptional<z.ZodEnum<{
-                    "board-id": "board-id";
-                    "player-board-space": "player-board-space";
-                }>>;
+                valueKind: z.ZodLiteral<"board-id">;
                 eligibleTargets: z.ZodArray<z.ZodString>;
             }, z.core.$strict>, z.ZodObject<{
                 selection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -2859,12 +2713,31 @@ declare const SeatProjectionBundleSchema: z.ZodObject<{
                     max: z.ZodOptional<z.ZodNumber>;
                     distinct: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strict>], "mode">>;
-                type: z.ZodLiteral<"resourceMap">;
-                resources: z.ZodArray<z.ZodObject<{
-                    resourceId: z.ZodString;
-                    label: z.ZodOptional<z.ZodString>;
-                    icon: z.ZodOptional<z.ZodString>;
-                    min: z.ZodNumber;
+                type: z.ZodLiteral<"boardTarget">;
+                projection: z.ZodLiteral<"resolved">;
+                targetKind: z.ZodLiteral<"space">;
+                boardId: z.ZodString;
+                valueKind: z.ZodLiteral<"player-board-space">;
+                eligibleTargets: z.ZodArray<z.ZodObject<{
+                    boardId: z.ZodString;
+                    playerId: z.ZodString;
+                    spaceId: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>], "valueKind">, z.ZodObject<{
+                selection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    mode: z.ZodLiteral<"single">;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"many">;
+                    min: z.ZodNumber;
+                    max: z.ZodOptional<z.ZodNumber>;
+                    distinct: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>], "mode">>;
+                type: z.ZodLiteral<"resourceMap">;
+                resources: z.ZodArray<z.ZodObject<{
+                    resourceId: z.ZodString;
+                    label: z.ZodOptional<z.ZodString>;
+                    icon: z.ZodOptional<z.ZodString>;
+                    min: z.ZodNumber;
                     max: z.ZodNumber;
                 }, z.core.$strict>>;
             }, z.core.$strict>, z.ZodObject<{
@@ -2955,6 +2828,7 @@ declare const SeatProjectionBundleSchema: z.ZodObject<{
             cardViewsById: z.ZodRecord<z.ZodString, z.ZodString>;
             playableByCardId: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
         }, z.core.$strict>>>;
+        resources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>>;
     }, z.core.$strict>>;
     timing: z.ZodOptional<z.ZodObject<{
         resolveAvailableInteractionsMs: z.ZodNumber;
@@ -3671,6 +3545,17 @@ type ScopedPhaseState<State extends {
     phase: PhaseState;
 };
 
+declare const FrameworkErrorCodes: {
+    readonly NOT_YOUR_TURN: "NOT_YOUR_TURN";
+    readonly WRONG_PHASE: "WRONG_PHASE";
+    readonly WRONG_STEP: "WRONG_STEP";
+    readonly NO_LEGAL_INPUT: "NO_LEGAL_INPUT";
+    readonly INVALID_PARAMS: "INVALID_PARAMS";
+    readonly UNKNOWN_INTERACTION: "UNKNOWN_INTERACTION";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+};
+type FrameworkErrorCode = (typeof FrameworkErrorCodes)[keyof typeof FrameworkErrorCodes];
+
 type InputCollectorKind = InteractionInputDescriptor["kind"];
 type TargetKind = Extract<InputDomain, {
     type: "cardTarget" | "boardTarget";
@@ -3701,6 +3586,9 @@ type CardTargetDomainDescriptor = Extract<InputDomain, {
 type BoardTargetDomainDescriptor = Extract<InputDomain, {
     type: "boardTarget";
 }>;
+type ChoiceListDomainDescriptor = Extract<InputDomain, {
+    type: "choiceList";
+}>;
 type DomainProjector<Domain extends InputDomainDescriptor> = (state: CollectorState, playerId: string, q: unknown) => Domain;
 type InputDomainForCollectorKind<Kind extends InputCollectorKind> = Kind extends "card" ? CardTargetDomainDescriptor : Kind extends BoardInputCollectorKind ? BoardTargetDomainDescriptor : Exclude<InputDomainDescriptor, CardTargetDomainDescriptor | BoardTargetDomainDescriptor>;
 /**
@@ -4098,6 +3986,168 @@ type PhaseDefinition<PhaseStateSchema extends SchemaLike<object>, State extends
     phase: object;
 }, Manifest extends ManifestContract<TableOfState<State>>, SubmitCollectors extends Record<string, InputCollector> = Record<string, InputCollector>, Interactions extends InteractionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Options extends RuntimeRecord = RuntimeRecord, ErrorCode extends string = string> = AutoPhaseDefinition<PhaseStateSchema, State, Manifest, ErrorCode, Options> | PlayerPhaseDefinition<PhaseStateSchema, State, Manifest, Interactions, Options, ErrorCode> | SimultaneousPlayerPhaseDefinition<PhaseStateSchema, State, Manifest, SubmitCollectors, Interactions, Options, ErrorCode>;
 
+/** Authored fields retain their domain types; wire admission validates JSON. */
+type ViewData = Record<string, unknown> & {
+    readonly boards?: never;
+};
+/** A JSON record for exactly one seat. `boards` is reserved for manifest geometry. */
+type ViewDefinition<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>, Projection extends ViewData = ViewData> = (args: ActionContext<State, Manifest> & ReadHelpers<State> & {
+    state: State;
+    playerId: PlayerIdOfState<State>;
+}) => Projection;
+
+type ReducerGameContract<Table extends RuntimeTableRecord, Manifest extends ReducerManifestContract<Table, string, string, string, string, string>, PublicSchema extends SchemaLike<object>, PrivateSchema extends SchemaLike<object>, HiddenSchema extends SchemaLike<object>, Phases extends Record<string, SchemaLike<object>>, Errors extends Record<string, string> | undefined = undefined, OptionsSchema extends SchemaLike<RuntimeRecord> = SchemaLike<Record<string, never>>> = {
+    manifest: Manifest;
+    state: StateDefinition<PublicSchema, PrivateSchema, HiddenSchema>;
+    phases: Phases;
+    errors?: Errors;
+    options: OptionsSchema;
+    /** Derived from `phases`; retained as an internal runtime convenience. */
+    phaseNames: readonly string[];
+};
+type BaseGameStateOfContract<Contract> = ReducerGameState<TableOfManifest<ManifestContractOf<Contract>>, z.infer<PublicSchemaOfContract<Contract>>, z.infer<PrivateSchemaOfContract<Contract>>, z.infer<HiddenSchemaOfContract<Contract>>, PhaseStateMapOfContract<Contract>[PhaseNameOfContract<Contract>], PhaseNameOfContract<Contract>, PhaseStateMapOfContract<Contract>>;
+/**
+ * Heterogeneous phase map for a contract. Each phase carries its own local
+ * `PhaseStateSchema` plus authoring-time Actions/Flows/Interactions/
+ * interaction and zone maps. The registries are bound to the contract's base state +
+ * manifest so the runtime can iterate them through a single index type
+ * without reaching for `any`.
+ */
+type PhaseMapOf<Contract> = {
+    [Name in PhaseNameOfContract<Contract>]: PhaseDefinition<SchemaLike<object>, BaseGameStateOfContract<Contract>, ManifestContractOf<Contract>, Record<string, InputCollector>, InteractionMap<BaseGameStateOfContract<Contract>, ManifestContractOf<Contract>>, OptionsOfContract<Contract>>;
+};
+type PhaseStateOfDefinitions<Definitions extends Record<string, PhaseDefinition<SchemaLike<object>, any, any, Record<string, InputCollector>, InteractionMap<any, any>, any>>> = {
+    [Name in keyof Definitions & string]: Definitions[Name] extends {
+        state: infer PhaseStateSchema extends SchemaLike<object>;
+    } ? z.infer<PhaseStateSchema> : never;
+}[keyof Definitions & string];
+type ResolvedGameStateOf<Contract, Definitions extends PhaseMapOf<Contract>> = {
+    [Name in keyof Definitions & string]: ReducerGameState<TableOfManifest<ManifestContractOf<Contract>>, z.infer<PublicSchemaOfContract<Contract>>, z.infer<PrivateSchemaOfContract<Contract>>, z.infer<HiddenSchemaOfContract<Contract>>, Definitions[Name] extends {
+        state: infer PhaseStateSchema extends SchemaLike<object>;
+    } ? z.infer<PhaseStateSchema> : never, PhaseNameOfContract<Contract>> & {
+        flow: ReducerGameState<TableOfManifest<ManifestContractOf<Contract>>, z.infer<PublicSchemaOfContract<Contract>>, z.infer<PrivateSchemaOfContract<Contract>>, z.infer<HiddenSchemaOfContract<Contract>>, PhaseStateOfDefinitions<Definitions>, PhaseNameOfContract<Contract>>["flow"] & {
+            currentPhase: Name;
+        };
+    };
+}[keyof Definitions & string];
+type ViewOfContract<Contract, Projection extends ViewData = ViewData> = ViewDefinition<BaseGameStateOfContract<Contract>, ManifestContractOf<Contract>, Projection>;
+type PhasesOfDefinition<Definition> = Definition extends {
+    phases: infer Definitions extends Record<string, unknown>;
+} ? Definitions : never;
+type NonNeverKeys<Registry> = {
+    [Key in keyof Registry]-?: [Registry[Key]] extends [never] ? never : Key;
+}[keyof Registry];
+type ViewOfDefinition<Definition> = Definition extends {
+    view: (...args: never[]) => infer Projection;
+} ? Projection : never;
+type PhaseNamesOfDefinition<Definition> = keyof PhasesOfDefinition<Definition> & string;
+type PhaseDefinitionByName<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>> = PhaseName extends keyof PhasesOfDefinition<Definition> & string ? PhasesOfDefinition<Definition>[PhaseName] : never;
+type GameStateOf<Source> = Source extends {
+    contract: infer Contract extends ReducerGameContractLike;
+    phases: infer Definitions;
+} ? Definitions extends PhaseMapOf<Contract> ? ResolvedGameStateOf<Contract, Definitions> : never : Source extends ReducerGameContract<any, any, any, any, any, any, any, any> ? BaseGameStateOfContract<Source> : never;
+/**
+ * Public structural upper bound for a reducer game contract.
+ *
+ * The `manifest` slot is intentionally erased with `any` because concrete
+ * manifests bind per-contract branded literals (e.g. `PlayerId` unions with
+ * specific string literals). Using a ground `ManifestContract<...>` type
+ * here would prevent assignability from contract-bound manifests in a
+ * contravariant position.
+ */
+type ReducerGameContractLike = {
+    manifest: any;
+    options: SchemaLike<RuntimeRecord>;
+    state: StateDefinition<SchemaLike<object>, SchemaLike<object>, SchemaLike<object>>;
+};
+type InitialStateContextOf<Contract extends ReducerGameContractLike> = InitContext<TableOfManifest<ManifestOf<Contract>>, ExactManifestContractOf<Contract>, OptionsOfContract<Contract>>;
+type InitialStateCallbacks<Contract extends ReducerGameContractLike> = {
+    public?: (ctx: InitialStateContextOf<Contract>) => z.infer<PublicSchemaOfContract<Contract>>;
+    private?: (ctx: InitialStateContextOf<Contract> & {
+        playerId: PlayerIdOfTable<TableOfManifest<ManifestOf<Contract>>>;
+    }) => z.infer<PrivateSchemaOfContract<Contract>>;
+    hidden?: (ctx: InitialStateContextOf<Contract>) => z.infer<HiddenSchemaOfContract<Contract>>;
+};
+declare const validatedReducerDefinition: unique symbol;
+/** Authored input to game.assemble; no runtime contract or validation marker. */
+type ReducerGameDefinitionInput<Contract extends ReducerGameContractLike, Definitions extends PhaseMapOf<Contract>, View extends ViewOfContract<Contract>> = {
+    initial?: InitialStateCallbacks<Contract>;
+    initialPhase?: PhaseNameOfContract<Contract>;
+    phases: Definitions & Record<Exclude<keyof Definitions, PhaseNameOfContract<Contract>>, never>;
+    view: View;
+};
+/** Assembled definition accepted by reducer runtime consumers. */
+type ReducerGameDefinition<Contract extends ReducerGameContractLike, Definitions extends PhaseMapOf<Contract>, View extends ViewOfContract<Contract>> = {
+    readonly [validatedReducerDefinition]: true;
+    contract: Contract;
+    initial?: InitialStateCallbacks<Contract>;
+    initialPhase?: PhaseNameOfContract<Contract>;
+    phases: Definitions;
+    view: View;
+};
+type RegistryKeys<Registry> = Registry extends Record<string, unknown> ? NonNeverKeys<Registry> & string : never;
+type InteractionRegistryOfDefinitionPhase<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>> = PhaseDefinitionByName<Definition, PhaseName> extends {
+    interactions?: infer Interactions;
+} ? NonNullable<Interactions> : Record<string, never>;
+type SimultaneousSubmitRegistryOfDefinitionPhase<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>> = PhaseDefinitionByName<Definition, PhaseName> extends {
+    submit?: infer Submit;
+} ? {
+    submit: NonNullable<Submit>;
+} : Record<string, never>;
+type NonNeverRegistryValue<Registry, Key extends string> = Registry extends Record<string, unknown> ? Key extends keyof Registry ? [Registry[Key]] extends [never] ? never : Registry[Key] : never : never;
+type InteractionIdOfDefinitionPhase<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>> = PhaseDefinitionByName<Definition, PhaseName> extends {
+    kind: "auto";
+} ? never : InteractionRegistryOfDefinitionPhase<Definition, PhaseName> extends infer Interactions ? SimultaneousSubmitRegistryOfDefinitionPhase<Definition, PhaseName> extends infer Submit ? RegistryKeys<Interactions> | RegistryKeys<Submit> : never : never;
+type InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>, InteractionId extends InteractionIdOfDefinitionPhase<Definition, PhaseName>> = NonNeverRegistryValue<InteractionRegistryOfDefinitionPhase<Definition, PhaseName>, InteractionId> | NonNeverRegistryValue<SimultaneousSubmitRegistryOfDefinitionPhase<Definition, PhaseName>, InteractionId>;
+type CollectorsOfInteractionDefinition<Spec> = Spec extends {
+    readonly steps: {
+        readonly collectors: infer Collectors extends Record<string, InputCollector>;
+    };
+} ? Collectors : Spec extends {
+    readonly inputs?: infer Collectors;
+} ? NonNullable<Collectors> extends Record<string, InputCollector> ? NonNullable<Collectors> : Record<string, never> : Record<string, never>;
+/** The canonical collector for a named interaction input, including step inputs. */
+type InputCollectorOfDefinition<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>, InteractionId extends InteractionIdOfDefinitionPhase<Definition, PhaseName>, Input extends string> = InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends infer Spec ? Input extends keyof CollectorsOfInteractionDefinition<Spec> ? CollectorsOfInteractionDefinition<Spec>[Input] : Input extends "cardId" ? Spec extends {
+    readonly cardType: unknown;
+    readonly playFrom: unknown;
+} ? {
+    readonly kind: "card";
+} : never : never : never;
+type ClientParamsOfCollectors<Collectors> = Collectors extends Record<string, InputCollector> ? {
+    [K in keyof Collectors as Collectors[K] extends {
+        readonly kind: "rng";
+    } ? never : K]: Collectors[K] extends InputCollector<infer S> ? S extends SchemaLike<infer V> ? V : never : never;
+} : never;
+/**
+ * Client-facing params shape for an interaction. Omits engine-sampled
+ * collectors (`rngInput.*`) — clients never supply those fields; the
+ * trusted reducer bundle fills them during `submitInteraction`.
+ *
+ * This is the type that drives `submit(playerId, id, params)`,
+ * `handle.submit(params)`, and the generated `InteractionParams` surface
+ * through `createGameUi(game)`. The `reduce`-input counterpart is
+ * {@link ParamsOfInteractionOfDefinition}, which includes every field
+ * because the engine has already filled the sampled ones by then.
+ */
+type CurrentStepParams<Collectors extends Record<string, InputCollector>> = {
+    [Key in keyof Collectors]: Pick<ClientParamsOfCollectors<Collectors>, Key & keyof ClientParamsOfCollectors<Collectors>> & {
+        [Other in Exclude<keyof Collectors, Key>]?: never;
+    };
+}[keyof Collectors];
+type ClientParamsOfInteractionOfDefinition<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>, InteractionId extends InteractionIdOfDefinitionPhase<Definition, PhaseName>> = InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends infer Spec ? Spec extends {
+    readonly steps: unknown;
+} ? CurrentStepParams<CollectorsOfInteractionDefinition<Spec>> : Spec extends {
+    readonly cardType: unknown;
+    readonly playFrom: unknown;
+} ? {
+    cardId: string;
+} & ClientParamsOfCollectors<CollectorsOfInteractionDefinition<Spec>> : ClientParamsOfCollectors<CollectorsOfInteractionDefinition<Spec>> : never;
+
 type SpaceId<Board extends RuntimeBoardState> = keyof Board["spaces"] & string;
 type CommonBoardQueries<Board extends RuntimeBoardState, ComponentId extends string> = {
     state: Board;
@@ -4146,6 +4196,10 @@ interface ViewCard<CardIdValue extends string = string, CardTypeValue extends st
     cardType: CardTypeValue;
     name?: string;
     text?: string;
+    /** Manifest asset path; game UIs receive a loadable URL. */
+    frontImage?: string;
+    /** Manifest asset path; game UIs receive a loadable URL. */
+    backImage?: string;
     properties: Properties;
 }
 interface CardCollection<CardIdValue extends string = string, Card extends ViewCard<CardIdValue> = ViewCard<CardIdValue>> {
@@ -4166,7 +4220,7 @@ type TiledBoardRecord<Table extends RuntimeTableRecord, BoardId extends TiledBoa
 }>;
 type ViewCardOfTable<Table extends RuntimeTableRecord, CardId extends CardIdOfTable<Table>> = CardId extends CardIdOfTable<Table> ? ViewCard<CardId & string, Table["cards"][CardId]["cardType"] & string, Extract<Table["cards"][CardId]["properties"], Record<string, unknown>>> : never;
 type CardsByIdOfTable<Table extends RuntimeTableRecord, CardIds extends readonly CardIdOfTable<Table>[]> = Readonly<{
-    [Id in CardIds[number]]: ViewCardOfTable<Table, Id> | undefined;
+    [Id in CardIds[number]]: ViewCardOfTable<Table, Id>;
 }>;
 type DeckCardsForZone<Table extends RuntimeTableRecord, ZoneId extends DeckIdOfTable<Table>> = ZoneId extends infer Each extends DeckIdOfTable<Table> ? DeckCardsOfTable<Table, Each> : never;
 type HandCardsForZone<Table extends RuntimeTableRecord, ZoneId extends HandIdOfTable<Table>> = ZoneId extends infer Each extends HandIdOfTable<Table> ? HandCardsOfTable<Table, Each> : never;
@@ -4312,12 +4366,18 @@ type TableQueries<Table extends RuntimeTableRecord> = {
         visibility: <CardId extends CardIdOfTable<Table>>(cardId: CardId) => Table["visibility"][CardId];
     };
     slot: {
-        occupants: (host: RuntimeSlotHostRef, slotId: string) => SlotOccupantsOfTable<Table>;
-        occupantsByHost: (host: RuntimeSlotHostRef) => SlotOccupantsBySlotIdOfTable<Table>;
-        pieceOccupants: (hostId: string, slotId: string) => SlotOccupantsOfTable<Table>;
-        pieceOccupantsByHost: (hostId: string) => SlotOccupantsBySlotIdOfTable<Table>;
-        dieOccupants: (hostId: string, slotId: string) => SlotOccupantsOfTable<Table>;
-        dieOccupantsByHost: (hostId: string) => SlotOccupantsBySlotIdOfTable<Table>;
+        occupants: <Host extends SlotHostOfTable<Table>>(host: Host, slotId: SlotIdOfTable<Table, NoInfer<Host>>) => SlotOccupantsOfTable<Table>;
+        occupantsByHost: (host: SlotHostOfTable<Table>) => SlotOccupantsBySlotIdOfTable<Table>;
+        pieceOccupants: <Id extends keyof Table["pieces"] & string>(hostId: Id, slotId: SlotIdOfTable<Table, {
+            kind: "piece";
+            id: NoInfer<Id>;
+        }>) => SlotOccupantsOfTable<Table>;
+        pieceOccupantsByHost: (hostId: keyof Table["pieces"] & string) => SlotOccupantsBySlotIdOfTable<Table>;
+        dieOccupants: <Id extends keyof Table["dice"] & string>(hostId: Id, slotId: SlotIdOfTable<Table, {
+            kind: "die";
+            id: NoInfer<Id>;
+        }>) => SlotOccupantsOfTable<Table>;
+        dieOccupantsByHost: (hostId: keyof Table["dice"] & string) => SlotOccupantsBySlotIdOfTable<Table>;
     };
     player: {
         /** Seating order from the manifest / setup profile. */
@@ -4343,8 +4403,8 @@ type TableQueries<Table extends RuntimeTableRecord> = {
         missingResources: (playerId: PlayerIdOfTable<Table>, amounts: ResourceAmountsOfTable<Table>) => Partial<Record<ResourceIdOfTable<Table>, number>>;
     };
     component: {
-        data: <ComponentId extends ComponentIdOfTable<Table>>(componentId: ComponentId) => ComponentDataOfTable<Table, ComponentId> | undefined;
-        location: <ComponentId extends ComponentIdOfTable<Table>>(componentId: ComponentId) => ComponentLocationOfTable<Table, ComponentId> | undefined;
+        data: <ComponentId extends ComponentIdOfTable<Table>>(componentId: ComponentId) => ComponentDataOfTable<Table, ComponentId>;
+        location: <ComponentId extends ComponentIdOfTable<Table>>(componentId: ComponentId) => ComponentLocationOfTable<Table, ComponentId>;
         deck: <ComponentId extends ComponentIdOfTable<Table>>(componentId: ComponentId) => ResolvedDeckLocation<Table, ComponentId> | null;
         hand: <ComponentId extends ComponentIdOfTable<Table>>(componentId: ComponentId) => ResolvedHandLocation<Table, ComponentId> | null;
         zone: <ComponentId extends ComponentIdOfTable<Table>>(componentId: ComponentId) => ResolvedZoneLocation<Table, ComponentId> | null;
@@ -4381,6 +4441,8 @@ type ManifestLiterals<PlayerId extends string, DeckId extends string, HandId ext
         label: string;
         icon?: string | null;
     }>;
+    /** Resources whose balances are projected only to their holder. */
+    ownerResourceIds?: readonly string[];
     pieceTypeIds: readonly string[];
     pieceIds: readonly string[];
     dieTypeIds: readonly string[];
@@ -4491,149 +4553,184 @@ type InitContext<Table extends RuntimeTableRecord, Manifest extends ReducerManif
     }>;
 };
 
-/** Authored fields retain their domain types; wire admission validates JSON. */
-type ViewData = Record<string, unknown> & {
-    readonly boards?: never;
-};
-/** A JSON record for exactly one seat. `boards` is reserved for manifest geometry. */
-type ViewDefinition<State extends {
-    table: RuntimeTableRecord;
+type TableOfState<State> = State extends {
+    table: infer Table;
+} ? Table : never;
+type TableOfManifest<Manifest> = Manifest extends {
+    tableSchema: z.ZodType<infer Table extends RuntimeTableRecord>;
+} ? Table : Manifest extends ReducerManifestContractLike<infer Table> ? Table : never;
+type PhaseNameOfState<State> = State extends {
     flow: {
-        currentPhase: string;
+        currentPhase: infer PhaseName;
     };
-}, Manifest extends ManifestContract<TableOfState<State>>, Projection extends ViewData = ViewData> = (args: ActionContext<State, Manifest> & ReadHelpers<State> & {
-    state: State;
-    playerId: PlayerIdOfState<State>;
-}) => Projection;
-
-type ReducerGameContract<Table extends RuntimeTableRecord, Manifest extends ReducerManifestContract<Table, string, string, string, string, string>, PublicSchema extends SchemaLike<object>, PrivateSchema extends SchemaLike<object>, HiddenSchema extends SchemaLike<object>, Phases extends Record<string, SchemaLike<object>>, Errors extends Record<string, string> | undefined = undefined, OptionsSchema extends SchemaLike<RuntimeRecord> = SchemaLike<Record<string, never>>> = {
-    manifest: Manifest;
-    state: StateDefinition<PublicSchema, PrivateSchema, HiddenSchema>;
-    phases: Phases;
-    errors?: Errors;
-    options: OptionsSchema;
-    /** Derived from `phases`; retained as an internal runtime convenience. */
-    phaseNames: readonly string[];
-};
-type BaseGameStateOfContract<Contract> = ReducerGameState<TableOfManifest<ManifestContractOf<Contract>>, z.infer<PublicSchemaOfContract<Contract>>, z.infer<PrivateSchemaOfContract<Contract>>, z.infer<HiddenSchemaOfContract<Contract>>, PhaseStateMapOfContract<Contract>[PhaseNameOfContract<Contract>], PhaseNameOfContract<Contract>, PhaseStateMapOfContract<Contract>>;
-/**
- * Heterogeneous phase map for a contract. Each phase carries its own local
- * `PhaseStateSchema` plus authoring-time Actions/Flows/Interactions/
- * interaction and zone maps. The registries are bound to the contract's base state +
- * manifest so the runtime can iterate them through a single index type
- * without reaching for `any`.
- */
-type PhaseMapOf<Contract> = {
-    [Name in PhaseNameOfContract<Contract>]: PhaseDefinition<SchemaLike<object>, BaseGameStateOfContract<Contract>, ManifestContractOf<Contract>, Record<string, InputCollector>, InteractionMap<BaseGameStateOfContract<Contract>, ManifestContractOf<Contract>>, OptionsOfContract<Contract>>;
-};
-type PhaseStateOfDefinitions<Definitions extends Record<string, PhaseDefinition<SchemaLike<object>, any, any, Record<string, InputCollector>, InteractionMap<any, any>, any>>> = {
-    [Name in keyof Definitions & string]: Definitions[Name] extends {
-        state: infer PhaseStateSchema extends SchemaLike<object>;
-    } ? z.infer<PhaseStateSchema> : never;
-}[keyof Definitions & string];
-type ResolvedGameStateOf<Contract, Definitions extends PhaseMapOf<Contract>> = {
-    [Name in keyof Definitions & string]: ReducerGameState<TableOfManifest<ManifestContractOf<Contract>>, z.infer<PublicSchemaOfContract<Contract>>, z.infer<PrivateSchemaOfContract<Contract>>, z.infer<HiddenSchemaOfContract<Contract>>, Definitions[Name] extends {
-        state: infer PhaseStateSchema extends SchemaLike<object>;
-    } ? z.infer<PhaseStateSchema> : never, PhaseNameOfContract<Contract>> & {
-        flow: ReducerGameState<TableOfManifest<ManifestContractOf<Contract>>, z.infer<PublicSchemaOfContract<Contract>>, z.infer<PrivateSchemaOfContract<Contract>>, z.infer<HiddenSchemaOfContract<Contract>>, PhaseStateOfDefinitions<Definitions>, PhaseNameOfContract<Contract>>["flow"] & {
-            currentPhase: Name;
-        };
+} ? Extract<PhaseName, string> : never;
+type PhaseNameOfManifest<Manifest> = Manifest extends {
+    literals: {
+        phaseNames: readonly (infer PhaseName)[];
     };
-}[keyof Definitions & string];
-type ViewOfContract<Contract, Projection extends ViewData = ViewData> = ViewDefinition<BaseGameStateOfContract<Contract>, ManifestContractOf<Contract>, Projection>;
-type PhasesOfDefinition<Definition> = Definition extends {
-    phases: infer Definitions extends Record<string, unknown>;
-} ? Definitions : never;
-type NonNeverKeys<Registry> = {
-    [Key in keyof Registry]-?: [Registry[Key]] extends [never] ? never : Key;
-}[keyof Registry];
-type ViewOfDefinition<Definition> = Definition extends {
-    view: (...args: never[]) => infer Projection;
-} ? Projection : never;
-type PhaseNamesOfDefinition<Definition> = keyof PhasesOfDefinition<Definition> & string;
-type PhaseDefinitionByName<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>> = PhaseName extends keyof PhasesOfDefinition<Definition> & string ? PhasesOfDefinition<Definition>[PhaseName] : never;
-type GameStateOf<Source> = Source extends {
-    contract: infer Contract extends ReducerGameContractLike;
-    phases: infer Definitions;
-} ? Definitions extends PhaseMapOf<Contract> ? ResolvedGameStateOf<Contract, Definitions> : never : Source extends ReducerGameContract<any, any, any, any, any, any, any, any> ? BaseGameStateOfContract<Source> : never;
+} ? Extract<PhaseName, string> : never;
+type PlayerIdOfTable<Table> = Table extends {
+    playerOrder: readonly (infer PlayerId)[];
+} ? Extract<PlayerId, string> : never;
+type PlayerIdOfState<State> = PlayerIdOfTable<TableOfState<State>>;
+type ErrorCodeOfContract<Contract> = Contract extends {
+    errors: infer Errors extends Record<string, string>;
+} ? (keyof Errors & string) | FrameworkErrorCode : string;
 /**
- * Public structural upper bound for a reducer game contract.
+ * Manifest-declared resource id union for a runtime table.
  *
- * The `manifest` slot is intentionally erased with `any` because concrete
- * manifests bind per-contract branded literals (e.g. `PlayerId` unions with
- * specific string literals). Using a ground `ManifestContract<...>` type
- * here would prevent assignability from contract-bound manifests in a
- * contravariant position.
+ * Derived from the shape of `table.resources`, which the generated
+ * manifest contract seeds as `Record<PlayerId, Record<ResourceId, number>>`.
+ * Resource identifiers come from the player balance record.
  */
-type ReducerGameContractLike = {
-    manifest: any;
-    options: SchemaLike<RuntimeRecord>;
-    state: StateDefinition<SchemaLike<object>, SchemaLike<object>, SchemaLike<object>>;
-};
-type InitialStateContextOf<Contract extends ReducerGameContractLike> = InitContext<TableOfManifest<ManifestOf<Contract>>, ExactManifestContractOf<Contract>, OptionsOfContract<Contract>>;
-type InitialStateCallbacks<Contract extends ReducerGameContractLike> = {
-    public?: (ctx: InitialStateContextOf<Contract>) => z.infer<PublicSchemaOfContract<Contract>>;
-    private?: (ctx: InitialStateContextOf<Contract> & {
-        playerId: PlayerIdOfTable<TableOfManifest<ManifestOf<Contract>>>;
-    }) => z.infer<PrivateSchemaOfContract<Contract>>;
-    hidden?: (ctx: InitialStateContextOf<Contract>) => z.infer<HiddenSchemaOfContract<Contract>>;
-};
-type ReducerGameDefinition<Contract extends ReducerGameContractLike, Definitions extends PhaseMapOf<Contract>, View extends ViewOfContract<Contract>> = {
-    contract: Contract;
-    initial?: InitialStateCallbacks<NoInfer<Contract>>;
-    initialPhase?: keyof Definitions & string;
-    phases: Definitions;
-    view: View;
-};
-type RegistryKeys<Registry> = Registry extends Record<string, unknown> ? NonNeverKeys<Registry> & string : never;
-type InteractionRegistryOfDefinitionPhase<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>> = PhaseDefinitionByName<Definition, PhaseName> extends {
-    interactions?: infer Interactions;
-} ? NonNullable<Interactions> : Record<string, never>;
-type SimultaneousSubmitRegistryOfDefinitionPhase<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>> = PhaseDefinitionByName<Definition, PhaseName> extends {
-    submit?: infer Submit;
-} ? {
-    submit: NonNullable<Submit>;
-} : Record<string, never>;
-type NonNeverRegistryValue<Registry, Key extends string> = Registry extends Record<string, unknown> ? Key extends keyof Registry ? [Registry[Key]] extends [never] ? never : Registry[Key] : never : never;
-type InteractionIdOfDefinitionPhase<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>> = PhaseDefinitionByName<Definition, PhaseName> extends {
-    kind: "auto";
-} ? never : InteractionRegistryOfDefinitionPhase<Definition, PhaseName> extends infer Interactions ? SimultaneousSubmitRegistryOfDefinitionPhase<Definition, PhaseName> extends infer Submit ? RegistryKeys<Interactions> | RegistryKeys<Submit> : never : never;
-type InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>, InteractionId extends InteractionIdOfDefinitionPhase<Definition, PhaseName>> = NonNeverRegistryValue<InteractionRegistryOfDefinitionPhase<Definition, PhaseName>, InteractionId> | NonNeverRegistryValue<SimultaneousSubmitRegistryOfDefinitionPhase<Definition, PhaseName>, InteractionId>;
-type CollectorsOfInteractionDefinition<Spec> = Spec extends {
-    readonly steps: {
-        readonly collectors: infer Collectors extends Record<string, InputCollector>;
-    };
-} ? Collectors : Spec extends {
-    readonly inputs?: infer Collectors;
-} ? NonNullable<Collectors> extends Record<string, InputCollector> ? NonNullable<Collectors> : Record<string, never> : Record<string, never>;
-type ClientParamsOfCollectors<Collectors> = Collectors extends Record<string, InputCollector> ? {
-    [K in keyof Collectors as Collectors[K] extends {
-        readonly kind: "rng";
-    } ? never : K]: Collectors[K] extends InputCollector<infer S> ? S extends SchemaLike<infer V> ? V : never : never;
-} : never;
+type ResourceIdOfTable<Table> = Table extends {
+    resources: infer Resources;
+} ? PlayerRecordValue<Resources> extends infer PlayerValue ? PlayerValue extends Record<string, unknown> ? StringKeyOf<PlayerValue> : never : never : never;
 /**
- * Client-facing params shape for an interaction. Omits engine-sampled
- * collectors (`rngInput.*`) — clients never supply those fields; the
- * trusted reducer bundle fills them during `submitInteraction`.
+ * Per-player balance shape for a runtime table. Extracts the
+ * value of `table.resources` so callers receive the manifest-typed
+ * record directly (e.g. `Record<ResourceId, number>`).
+ */
+type ResourceBalancesOfTable<Table> = Table extends {
+    resources: infer Resources;
+} ? PlayerRecordValue<Resources> extends infer PlayerValue ? PlayerValue extends Record<string, unknown> ? PlayerValue : never : never : never;
+/**
+ * Per-player resource counts: a partial `Record<ResourceId, number>`.
  *
- * This is the type that drives `submit(playerId, id, params)`,
- * `handle.submit(params)`, and the generated `InteractionParams` surface
- * through `createGameUi(game)`. The `reduce`-input counterpart is
- * {@link ParamsOfInteractionOfDefinition}, which includes every field
- * because the engine has already filled the sampled ones by then.
+ * Used as the input shape for {@link ReducerTransaction.addResources},
+ * {@link ReducerTransaction.spendResources}, and {@link ReducerTransaction.transferResources}.
  */
-type CurrentStepParams<Collectors extends Record<string, InputCollector>> = {
-    [Key in keyof Collectors]: Pick<ClientParamsOfCollectors<Collectors>, Key & keyof ClientParamsOfCollectors<Collectors>> & {
-        [Other in Exclude<keyof Collectors, Key>]?: never;
+type ResourceAmountsOfTable<Table> = Partial<Record<ResourceIdOfTable<Table>, number>>;
+type PhaseStateOfState<State> = State extends {
+    phase: infer PhaseState;
+} ? PhaseState : never;
+type PublicStateOfState<State> = State extends {
+    publicState: infer PublicState;
+} ? PublicState : never;
+type HiddenStateOfState<State> = State extends {
+    hiddenState: infer HiddenState;
+} ? HiddenState : never;
+type PrivateStateOfState<State> = State extends {
+    privateState: Record<string, infer PrivateState>;
+} ? PrivateState : never;
+type DeckIdOfTable<Table> = Table extends {
+    decks: infer Decks;
+} ? StringKeyOf<Decks> : never;
+type HandIdOfTable<Table> = Table extends {
+    hands: infer Hands;
+} ? StringKeyOf<Hands> : never;
+type CardIdOfTable<Table> = Table extends {
+    cards: infer Cards;
+} ? StringKeyOf<Cards> : never;
+type DeckIdOfState<State> = DeckIdOfTable<TableOfState<State>>;
+type HandIdOfState<State> = HandIdOfTable<TableOfState<State>>;
+type CardIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        cardIds: readonly (infer CardId)[];
     };
-}[keyof Collectors];
-type ClientParamsOfInteractionOfDefinition<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>, InteractionId extends InteractionIdOfDefinitionPhase<Definition, PhaseName>> = InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends infer Spec ? Spec extends {
-    readonly steps: unknown;
-} ? CurrentStepParams<CollectorsOfInteractionDefinition<Spec>> : Spec extends {
-    readonly cardType: unknown;
-    readonly playFrom: unknown;
-} ? {
-    cardId: string;
-} & ClientParamsOfCollectors<CollectorsOfInteractionDefinition<Spec>> : ClientParamsOfCollectors<CollectorsOfInteractionDefinition<Spec>> : never;
+} ? Extract<CardId, string> : string;
+type SharedZoneIdOfTable<Table> = DeckIdOfTable<Table>;
+type PlayerZoneIdOfTable<Table> = HandIdOfTable<Table>;
+type BoardMapOfTable<Table> = Table extends {
+    boards: {
+        byId: infer Boards;
+    };
+} ? Boards : never;
+type BoardIdOfTable<Table> = StringKeyOf<BoardMapOfTable<Table>>;
+type BoardStateOfTable<Table, BoardId extends BoardIdOfTable<Table>> = BoardMapOfTable<Table>[BoardId];
+type TiledBoardIdOfTable<Table> = {
+    [BoardId in BoardIdOfTable<Table>]: BoardStateOfTable<Table, BoardId> extends {
+        layout: "hex" | "square";
+    } ? BoardId : never;
+}[BoardIdOfTable<Table>];
+type TiledBoardStateOfTable<Table, BoardId extends TiledBoardIdOfTable<Table>> = BoardStateOfTable<Table, BoardId> extends infer BoardState ? BoardState extends {
+    layout: "hex" | "square";
+    spaces: Record<string, unknown>;
+    edges: readonly {
+        id: string;
+    }[];
+    vertices: readonly {
+        id: string;
+    }[];
+} ? BoardState : never : never;
+type SpaceIdOfTable<Table, BoardId extends BoardIdOfTable<Table>> = BoardStateOfTable<Table, BoardId> extends {
+    spaces: infer Spaces;
+} ? StringKeyOf<Spaces> : never;
+type BoardContainerIdOfTable<Table, BoardId extends BoardIdOfTable<Table>> = BoardStateOfTable<Table, BoardId> extends {
+    containers: infer Containers;
+} ? StringKeyOf<Containers> : never;
+type TiledSpaceIdOfTable<Table, BoardId extends TiledBoardIdOfTable<Table>> = TiledBoardStateOfTable<Table, BoardId> extends {
+    spaces: infer Spaces;
+} ? StringKeyOf<Spaces> : never;
+type TiledEdgeIdOfTable<Table, BoardId extends TiledBoardIdOfTable<Table>> = TiledBoardStateOfTable<Table, BoardId> extends {
+    edges: readonly (infer Edge)[];
+} ? Edge extends {
+    id: infer EdgeId;
+} ? Extract<EdgeId, string> : never : never;
+type TiledVertexIdOfTable<Table, BoardId extends TiledBoardIdOfTable<Table>> = TiledBoardStateOfTable<Table, BoardId> extends {
+    vertices: readonly (infer Vertex)[];
+} ? Vertex extends {
+    id: infer VertexId;
+} ? Extract<VertexId, string> : never : never;
+type ComponentIdOfTable<Table> = Table extends {
+    componentLocations: infer ComponentLocations;
+} ? StringKeyOf<ComponentLocations> : never;
+type PlayerZoneIdOfState<State> = HandIdOfState<State>;
+type ManifestOf<Source> = Source extends {
+    contract: infer Contract;
+} ? ManifestOf<Contract> : Source extends {
+    manifest: infer Manifest;
+} ? Manifest : never;
+type StateDefinitionOfContract<Contract> = Contract extends {
+    state: infer StateDefinitionValue;
+} ? StateDefinitionValue : never;
+type PhaseSchemasOfContract<Contract> = Contract extends {
+    phases: infer Phases extends Record<string, SchemaLike<object>>;
+} ? Phases : Record<PhaseNameOfManifest<ManifestOf<Contract>>, SchemaLike<object>>;
+type PhaseStateMapOfContract<Contract> = {
+    [Name in keyof PhaseSchemasOfContract<Contract> & string]: z.infer<PhaseSchemasOfContract<Contract>[Name]>;
+};
+type PublicSchemaOfContract<Contract> = StateDefinitionOfContract<Contract> extends StateDefinition<infer PublicSchema, SchemaLike<object>, SchemaLike<object>> ? PublicSchema : never;
+type PrivateSchemaOfContract<Contract> = StateDefinitionOfContract<Contract> extends StateDefinition<SchemaLike<object>, infer PrivateSchema, SchemaLike<object>> ? PrivateSchema : never;
+type HiddenSchemaOfContract<Contract> = StateDefinitionOfContract<Contract> extends StateDefinition<SchemaLike<object>, SchemaLike<object>, infer HiddenSchema> ? HiddenSchema : never;
+type PhaseNameOfContract<Contract> = keyof PhaseSchemasOfContract<Contract> extends string ? keyof PhaseSchemasOfContract<Contract> & string : PhaseNameOfManifest<ManifestOf<Contract>>;
+type ManifestContractOf<Contract> = ManifestContract<TableOfManifest<ManifestOf<Contract>>>;
+type ExactManifestContractOf<Contract> = ManifestOf<Contract> & ReducerManifestContractLike<TableOfManifest<ManifestOf<Contract>>>;
+type DeckCardsOfTable<Table, DeckId extends DeckIdOfTable<Table>> = Table extends {
+    decks: infer Decks extends Record<string, readonly unknown[]>;
+} ? Decks[DeckId] : never;
+type PlayerRecordValue<T> = T extends Record<string, infer Value> ? Value : never;
+type HandCardsOfTable<Table, HandId extends HandIdOfTable<Table>> = Table extends {
+    hands: infer Hands extends Record<string, unknown>;
+} ? HandId extends keyof Hands ? PlayerRecordValue<Hands[HandId]> extends infer Value ? Value extends readonly unknown[] ? Value : never : never : never : never;
+type CardIdOfDeck<Table, DeckId extends DeckIdOfTable<Table>> = DeckCardsOfTable<Table, DeckId>[number];
+type CardIdOfHand<Table, HandId extends HandIdOfTable<Table>> = HandCardsOfTable<Table, HandId>[number];
+type CompatibleHandIdForDeck<Table, DeckId extends DeckIdOfTable<Table>> = {
+    [CandidateHandId in HandIdOfTable<Table>]: Extract<CardIdOfDeck<Table, DeckId>, CardIdOfHand<Table, CandidateHandId>> extends never ? never : CandidateHandId;
+}[HandIdOfTable<Table>];
+type CompatibleCardIdForHandAndDeck<Table, HandId extends HandIdOfTable<Table>, DeckId extends DeckIdOfTable<Table>> = Extract<CardIdOfHand<Table, HandId>, CardIdOfDeck<Table, DeckId>>;
+type CompatibleCardIdForTwoPlayerZones<Table, FromZoneId extends HandIdOfTable<Table>, ToZoneId extends HandIdOfTable<Table>> = Extract<CardIdOfHand<Table, FromZoneId>, CardIdOfHand<Table, ToZoneId>>;
+type OptionsSchemaOfContract<Contract> = Contract extends {
+    options: infer Schema extends SchemaLike<RuntimeRecord>;
+} ? Schema : SchemaLike<Record<string, never>>;
+type OptionsOfContract<Contract> = z.infer<OptionsSchemaOfContract<Contract>>;
+/** Slot hosts share the canonical piece and die inventories. */
+type SlotHostOfTable<Table extends RuntimeTableRecord> = {
+    kind: "piece";
+    id: keyof Table["pieces"] & string;
+} | {
+    kind: "die";
+    id: keyof Table["dice"] & string;
+};
+type SlotLocationOfTable<Table> = Table extends {
+    componentLocations: infer Locations;
+} ? Extract<Locations[keyof Locations], {
+    type: "InSlot";
+}> : never;
+type SlotIdForHost<Location, Host> = Location extends {
+    host: infer Candidate;
+    slotId: infer Id;
+} ? Host extends Candidate ? Extract<Id, string> : never : never;
+type SlotIdOfTable<Table, Host> = SlotIdForHost<SlotLocationOfTable<Table>, Host>;
 
-export { type OutcomeResult as $, type InteractionChoiceOption as A, type BaseGameStateOfContract as B, type CardIdOfManifest as C, type DieTypeSpec as D, type ErrorCodeOfContract as E, FrameworkErrorCodes as F, type GameEvent as G, type HexEdgeId as H, type InitializeRequest as I, type InteractionCommitPolicy$1 as J, InteractionCommitPolicySchema as K, type InteractionDescriptor as L, InteractionDescriptorSchema as M, type InteractionDiagnosticReason as N, type InteractionIdOfDefinitionPhase as O, type InteractionInputDescriptor as P, InteractionInputDescriptorSchema as Q, type InteractionMap as R, type InteractionRule as S, type InteractionSpec as T, type InteractionSpecByNameOfDefinitionPhase as U, InteractionSteps as V, type JsonValue as W, type ManifestContractOf as X, type ManifestIdSchema as Y, type ObjectSchema as Z, type OptionsOfContract as _, type BoardContainerIdOfTable as a, rectangle as a$, type OutcomeScoreComponent as a0, type OutcomeStanding as a1, type OutcomeTieBreak as a2, type PhaseDefinition as a3, type PhaseMapOf as a4, type PhaseNameOfContract as a5, type PhaseNamesOfDefinition as a6, type PhaseSchemasOfContract as a7, type PlayerIdOfState as a8, type ProjectRequest as a9, type RuntimeSquareBoardState as aA, type RuntimeSquareSpaceState as aB, type RuntimeTableRecord as aC, type RuntimeTiledEdgeState as aD, type RuntimeTiledVertexState as aE, type SchemaLike as aF, type ScopedPhaseState as aG, type SeatProjectionBundle as aH, type SimultaneousPhaseProjection as aI, type SquareBoardSpec as aJ, type StateDefinition as aK, type SystemActionEvent as aL, type TableOfManifest as aM, type TableQueries as aN, type TableQueriesOfState as aO, type TiledBoardIdOfTable as aP, type TiledEdgeIdOfTable as aQ, type TiledSpaceIdOfTable as aR, type TiledVertexIdOfTable as aS, type ValidationIssue as aT, type ViewCard as aU, type ViewData as aV, type ViewDefinition as aW, type ViewOfContract as aX, type ViewOfDefinition as aY, fromCoordinates as aZ, hexagon as a_, type PropertySchema as aa, type ReducerAccept as ab, type ReducerContractVersion as ac, type ReducerGameContract as ad, type ReducerGameContractLike as ae, type ReducerGameDefinition as af, type ReducerManifestContract as ag, type ReducerManifestContractLike as ah, type ReducerReject as ai, type ReducerResult as aj, type ReducerSessionState as ak, type ReducerTransaction as al, type ReducerTransactionOutcome as am, type ReducerValidationResult as an, type RotatePlayerZoneArgs as ao, type RuntimeBoardState as ap, type RuntimeCardData as aq, type RuntimeDieData as ar, type RuntimeGenericBoardState as as, type RuntimeHexBoardState as at, type RuntimeHexSpaceState as au, type RuntimeJson as av, RuntimeJsonSchema as aw, type RuntimePayload as ax, type RuntimePieceData as ay, type RuntimeRecord as az, type BoardEdgeRef as b, ring as b0, runtimeSchema as b1, runtimeTypes as b2, spiral as b3, type BoardIdOfTable as c, type BoardStaticProjection as d, type BoardVertexRef as e, type Brand as f, type ClientParamsOfInteractionOfDefinition as g, type CollectorState as h, type DispatchRequest as i, type DispatchResult as j, type GameEventDetail as k, type GameInput as l, type GameOutcome as m, type GameOutcome$1 as n, type GameStateOf as o, type GameTopologyManifest as p, type HexSpaceId as q, type HexVertexId as r, type InitializeResult as s, type InputCollector as t, type InputDomain as u, InputDomainSchema as v, type InputSelection as w, type InputSelectionDescriptor as x, type InteractionAvailability as y, InteractionAvailabilitySchema as z };
+export { type JsonValue as $, InputDomainSchema as A, type BaseGameStateOfContract as B, type CardIdOfManifest as C, type DeckIdOfTable as D, type ErrorCodeOfContract as E, FrameworkErrorCodes as F, type GameEvent as G, type HandIdOfTable as H, type InitializeRequest as I, type InputSelection as J, type InputSelectionDescriptor as K, type InteractionAvailability as L, InteractionAvailabilitySchema as M, type InteractionChoiceOption as N, type InteractionCommitPolicy$1 as O, InteractionCommitPolicySchema as P, type InteractionDescriptor as Q, InteractionDescriptorSchema as R, type InteractionDiagnosticReason as S, type InteractionIdOfDefinitionPhase as T, type InteractionInputDescriptor as U, InteractionInputDescriptorSchema as V, type InteractionMap as W, type InteractionRule as X, type InteractionSpec as Y, type InteractionSpecByNameOfDefinitionPhase as Z, InteractionSteps as _, type BoardContainerIdOfTable as a, type ViewCard as a$, type ManifestContractOf as a0, type ManifestIdSchema as a1, type ObjectSchema as a2, type OptionsOfContract as a3, type OutcomeResult as a4, type OutcomeScoreComponent as a5, type OutcomeStanding as a6, type OutcomeTieBreak as a7, type PhaseDefinition as a8, type PhaseMapOf as a9, type RuntimeGenericBoardState as aA, type RuntimeHexBoardState as aB, type RuntimeJson as aC, RuntimeJsonSchema as aD, type RuntimePayload as aE, type RuntimePieceData as aF, type RuntimeRecord as aG, type RuntimeSquareBoardState as aH, type RuntimeTableRecord as aI, type RuntimeTiledEdgeState as aJ, type RuntimeTiledVertexState as aK, type SchemaLike as aL, type ScopedPhaseState as aM, type SeatProjectionBundle as aN, type SimultaneousPhaseProjection as aO, type SpaceIdOfTable as aP, type SquareBoardSpec as aQ, type StateDefinition as aR, type SystemActionEvent as aS, type TableOfManifest as aT, type TableQueries as aU, type TableQueriesOfState as aV, type TiledBoardIdOfTable as aW, type TiledEdgeIdOfTable as aX, type TiledSpaceIdOfTable as aY, type TiledVertexIdOfTable as aZ, type ValidationIssue as a_, type PhaseNameOfContract as aa, type PhaseNamesOfDefinition as ab, type PhaseSchemasOfContract as ac, type PlayerIdOfState as ad, type PlayerIdOfTable as ae, type ProjectRequest as af, type PropertySchema as ag, type ReducerAccept as ah, type ReducerContractVersion as ai, type ReducerGameContract as aj, type ReducerGameContractLike as ak, type ReducerGameDefinition as al, type ReducerGameDefinitionInput as am, type ReducerManifestContract as an, type ReducerManifestContractLike as ao, type ReducerReject as ap, type ReducerResult as aq, type ReducerSessionState as ar, type ReducerTransaction as as, type ReducerTransactionOutcome as at, type ReducerValidationResult as au, type RotatePlayerZoneArgs as av, type RuntimeBoardState as aw, type RuntimeCardData as ax, type RuntimeComponentLocation as ay, type RuntimeDieData as az, type BoardEdgeRef as b, type ViewData as b0, type ViewDefinition as b1, type ViewOfContract as b2, type ViewOfDefinition as b3, fromCoordinates as b4, hexagon as b5, rectangle as b6, ring as b7, runtimeSchema as b8, runtimeTypes as b9, spiral as ba, type BoardIdOfTable as c, type BoardStateOfTable as d, type BoardStaticProjection as e, type BoardVertexRef as f, type Brand as g, type ChoiceListDomainDescriptor as h, type ClientParamsOfInteractionOfDefinition as i, type CollectorState as j, type DieTypeSpec as k, type DispatchRequest as l, type DispatchResult as m, type GameEventDetail as n, type GameInput as o, type GameOutcome as p, type GameOutcome$1 as q, type GameStateOf as r, type GameTopologyManifest as s, type HexEdgeId as t, type HexSpaceId as u, type HexVertexId as v, type InitializeResult as w, type InputCollector as x, type InputCollectorOfDefinition as y, type InputDomain as z };