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

package/dist/definition-BaHNPZol.d.ts

@@ -0,0 +1,4639 @@
+import { z } from 'zod';
+import { Point } from 'honeycomb-grid';
+
+/** JSON values shared by protocol and game-owned runtime state. */
+declare const RuntimeJsonSchema: z.ZodJSONSchema;
+type RuntimeJson = z.infer<typeof RuntimeJsonSchema>;
+
+type RuntimeRecord = Record<string, RuntimeJson>;
+type RuntimePayload = RuntimeJson;
+type SchemaLike<Output> = z.ZodType<Output>;
+type AnySchema = z.ZodTypeAny;
+type StringKeyOf<T> = Extract<keyof T, string>;
+type Brand<Value, Name extends string> = Value & {
+    readonly __brand: Name;
+};
+type RuntimeHandVisibilityMode = "all" | "ownerOnly" | "public" | "hidden";
+type RuntimeDeckMap = Record<string, string[]>;
+type RuntimeHandMap = Record<string, Record<string, string[]>>;
+type RuntimeZoneMap = {
+    shared: Record<string, string[]>;
+    perPlayer: Record<string, Record<string, string[]>>;
+    visibility: Record<string, RuntimeHandVisibilityMode>;
+    cardSetIdsByZoneId?: Record<string, readonly string[]>;
+};
+type RuntimeOwnerMap = Record<string, string | null>;
+type RuntimeResourceMap = Record<string, RuntimeRecord>;
+type RuntimeBoardSpaceState = {
+    id: string;
+    name?: string | null;
+    typeId?: string | null;
+    fields: RuntimeRecord;
+    zoneId?: string | null;
+};
+type RuntimeBoardRelationState = {
+    id?: string | null;
+    typeId: string;
+    fromSpaceId: string;
+    toSpaceId: string;
+    directed: boolean;
+    fields: RuntimeRecord;
+};
+type RuntimeBoardContainerState = {
+    id: string;
+    name: string;
+    host: {
+        type: "board";
+    } | {
+        type: "space";
+        spaceId: string;
+    };
+    allowedCardSetIds?: readonly string[];
+    zoneId: string;
+    fields: RuntimeRecord;
+};
+type RuntimeBoardCompatibilityState = {
+    spaces: Record<string, RuntimeBoardSpaceState>;
+    relations: RuntimeBoardRelationState[];
+    containers: Record<string, RuntimeBoardContainerState>;
+};
+type RuntimeBoardBaseState = {
+    id: string;
+    baseId?: string;
+    layout: "generic" | "hex" | "square";
+    typeId?: string | null;
+    scope: "shared" | "perPlayer";
+    playerId?: string | null;
+    fields: RuntimeRecord;
+};
+type RuntimeGenericBoardState = RuntimeBoardBaseState & {
+    layout: "generic";
+} & RuntimeBoardCompatibilityState;
+type RuntimeHexSpaceState = RuntimeBoardSpaceState & {
+    q: number;
+    r: number;
+};
+type RuntimeSquareSpaceState = RuntimeBoardSpaceState & {
+    row: number;
+    col: number;
+};
+type RuntimeTiledEdgeState = {
+    id: string;
+    spaceIds: readonly string[];
+    typeId?: string | null;
+    label?: string | null;
+    ownerId?: string | null;
+    fields: RuntimeRecord;
+};
+type RuntimeTiledVertexState = {
+    id: string;
+    spaceIds: readonly string[];
+    typeId?: string | null;
+    label?: string | null;
+    ownerId?: string | null;
+    fields: RuntimeRecord;
+};
+type RuntimeHexEdgeState = RuntimeTiledEdgeState;
+type RuntimeHexVertexState = RuntimeTiledVertexState;
+type RuntimeSquareEdgeState = RuntimeTiledEdgeState;
+type RuntimeSquareVertexState = RuntimeTiledVertexState;
+type RuntimeHexOrientation = "pointy" | "flat";
+type RuntimeTiledBoardBaseState = RuntimeBoardBaseState & {
+    layout: "hex" | "square";
+    relations: RuntimeBoardRelationState[];
+    containers: Record<string, RuntimeBoardContainerState>;
+    edges: RuntimeTiledEdgeState[];
+    vertices: RuntimeTiledVertexState[];
+};
+type RuntimeHexBoardState = RuntimeTiledBoardBaseState & {
+    layout: "hex";
+    spaces: Record<string, RuntimeHexSpaceState>;
+    orientation: RuntimeHexOrientation;
+    edges: RuntimeHexEdgeState[];
+    vertices: RuntimeHexVertexState[];
+};
+type RuntimeSquareBoardState = RuntimeTiledBoardBaseState & {
+    layout: "square";
+    spaces: Record<string, RuntimeSquareSpaceState>;
+    edges: RuntimeSquareEdgeState[];
+    vertices: RuntimeSquareVertexState[];
+};
+type RuntimeTiledBoardState = RuntimeHexBoardState | RuntimeSquareBoardState;
+type RuntimeBoardState = RuntimeGenericBoardState | RuntimeTiledBoardState;
+type RuntimeBoardCollections = {
+    byId: Record<string, RuntimeBoardState>;
+    hex: Record<string, RuntimeHexBoardState>;
+    square: Record<string, RuntimeSquareBoardState>;
+    /** Structured board buckets used by manifest table schemas (empty when unused). */
+    network: Record<string, RuntimeRecord>;
+    track: Record<string, RuntimeRecord>;
+};
+type RuntimeCardVisibility = {
+    faceUp: boolean;
+    visibleTo?: string[] | null;
+};
+type RuntimeCardData = {
+    componentType?: string;
+    id: string;
+    cardSetId: string;
+    cardType: string;
+    name?: string;
+    text?: string;
+    properties: RuntimeRecord;
+};
+type RuntimePieceData = {
+    componentType?: string;
+    id: string;
+    pieceTypeId: string;
+    pieceName?: string | null;
+    ownerId?: string | null;
+    properties: RuntimeRecord;
+};
+type RuntimeDieData = {
+    componentType?: string;
+    id: string;
+    dieTypeId: string;
+    dieName?: string | null;
+    ownerId?: string | null;
+    sides: number;
+    value?: number | null;
+    properties: RuntimeRecord;
+};
+type RuntimeSlotHostRef = {
+    kind: "piece";
+    id: string;
+} | {
+    kind: "die";
+    id: string;
+};
+type RuntimeComponentLocation = {
+    type: "Detached";
+} | {
+    type: "InDeck";
+    deckId: string;
+    playedBy: string | null;
+    position?: number | null;
+} | {
+    type: "InHand";
+    handId: string;
+    playerId: string;
+    position?: number | null;
+} | {
+    type: "InZone";
+    zoneId: string;
+    playedBy?: string | null;
+    position?: number | null;
+} | {
+    type: "OnSpace";
+    boardId: string;
+    spaceId: string;
+    position?: number | null;
+} | {
+    type: "InContainer";
+    boardId: string;
+    containerId: string;
+    position?: number | null;
+} | {
+    type: "OnEdge";
+    boardId: string;
+    edgeId: string;
+    position?: number | null;
+} | {
+    type: "OnVertex";
+    boardId: string;
+    vertexId: string;
+    position?: number | null;
+} | {
+    type: "InSlot";
+    host: RuntimeSlotHostRef;
+    slotId: string;
+    position?: number | null;
+};
+type RuntimeComponentLocationMap = Record<string, RuntimeComponentLocation>;
+type RuntimeVisibilityMap = Record<string, RuntimeCardVisibility>;
+type RuntimeTableRecord = {
+    playerOrder: string[];
+    zones: RuntimeZoneMap;
+    decks: RuntimeDeckMap;
+    hands: RuntimeHandMap;
+    handVisibility: Record<string, RuntimeHandVisibilityMode>;
+    cards: Record<string, RuntimeCardData>;
+    pieces: Record<string, RuntimePieceData>;
+    componentLocations: RuntimeComponentLocationMap;
+    ownerOfCard: RuntimeOwnerMap;
+    visibility: RuntimeVisibilityMap;
+    resources: RuntimeResourceMap;
+    boards: RuntimeBoardCollections;
+    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<{
+    mode: z.ZodLiteral<"autoWhenReady">;
+}, z.core.$strict>], "mode">;
+declare const InputSelectionSchema: 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">;
+declare const InteractionChoiceOptionSchema: z.ZodObject<{
+    value: z.ZodNullable<z.ZodString>;
+    label: z.ZodString;
+    icon: z.ZodOptional<z.ZodString>;
+    badge: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    disabledReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const InputDomainSchema: z.ZodDiscriminatedUnion<[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<"cardTarget">;
+    projection: z.ZodLiteral<"resolved">;
+    targetKind: z.ZodLiteral<"card">;
+    zoneIds: z.ZodArray<z.ZodString>;
+    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.ZodEnum<{
+        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";
+    }>>;
+    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<"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<{
+    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<"boundedNumber">;
+    min: z.ZodNumber;
+    max: z.ZodNumber;
+    step: z.ZodOptional<z.ZodNumber>;
+}, 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<"choice">;
+    choices: z.ZodArray<z.ZodObject<{
+        value: z.ZodNullable<z.ZodString>;
+        label: z.ZodString;
+        icon: z.ZodOptional<z.ZodString>;
+        badge: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+        disabledReason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, 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<"choiceList">;
+    choices: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        icon: z.ZodOptional<z.ZodString>;
+        badge: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+        disabledReason: z.ZodOptional<z.ZodString>;
+        value: z.ZodString;
+    }, z.core.$strict>>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>], "type">;
+declare const InteractionInputDescriptorSchema: z.ZodObject<{
+    key: z.ZodString;
+    kind: z.ZodEnum<{
+        card: "card";
+        form: "form";
+        "board-vertex": "board-vertex";
+        "board-edge": "board-edge";
+        "board-tile": "board-tile";
+        "board-space": "board-space";
+        rng: "rng";
+    }>;
+    domain: z.ZodDiscriminatedUnion<[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<"cardTarget">;
+        projection: z.ZodLiteral<"resolved">;
+        targetKind: z.ZodLiteral<"card">;
+        zoneIds: z.ZodArray<z.ZodString>;
+        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.ZodEnum<{
+            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";
+        }>>;
+        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<"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<{
+        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<"boundedNumber">;
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+        step: z.ZodOptional<z.ZodNumber>;
+    }, 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<"choice">;
+        choices: z.ZodArray<z.ZodObject<{
+            value: z.ZodNullable<z.ZodString>;
+            label: z.ZodString;
+            icon: z.ZodOptional<z.ZodString>;
+            badge: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            disabled: z.ZodOptional<z.ZodBoolean>;
+            disabledReason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, 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<"choiceList">;
+        choices: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            icon: z.ZodOptional<z.ZodString>;
+            badge: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            disabled: z.ZodOptional<z.ZodBoolean>;
+            disabledReason: z.ZodOptional<z.ZodString>;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>], "type">;
+    defaultValue: z.ZodOptional<z.ZodJSONSchema>;
+}, z.core.$strict>;
+declare const InteractionAvailabilitySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"available">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"notYourTurn">;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"blocked">;
+    reason: z.ZodString;
+    code: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "status">;
+declare const InteractionDescriptorSchema: z.ZodObject<{
+    phaseName: z.ZodString;
+    interactionKey: z.ZodString;
+    interactionId: z.ZodString;
+    label: z.ZodString;
+    help: z.ZodOptional<z.ZodString>;
+    zoneId: z.ZodOptional<z.ZodString>;
+    zoneIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    commit: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"manual">;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"autoWhenReady">;
+    }, z.core.$strict>], "mode">;
+    descriptorDigest: z.ZodOptional<z.ZodString>;
+    actorSeat: z.ZodOptional<z.ZodNumber>;
+    draftDigest: z.ZodOptional<z.ZodString>;
+    inputs: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        kind: z.ZodEnum<{
+            card: "card";
+            form: "form";
+            "board-vertex": "board-vertex";
+            "board-edge": "board-edge";
+            "board-tile": "board-tile";
+            "board-space": "board-space";
+            rng: "rng";
+        }>;
+        domain: z.ZodDiscriminatedUnion<[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<"cardTarget">;
+            projection: z.ZodLiteral<"resolved">;
+            targetKind: z.ZodLiteral<"card">;
+            zoneIds: z.ZodArray<z.ZodString>;
+            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.ZodEnum<{
+                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";
+            }>>;
+            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<"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<{
+            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<"boundedNumber">;
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+            step: z.ZodOptional<z.ZodNumber>;
+        }, 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<"choice">;
+            choices: z.ZodArray<z.ZodObject<{
+                value: z.ZodNullable<z.ZodString>;
+                label: z.ZodString;
+                icon: z.ZodOptional<z.ZodString>;
+                badge: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                disabled: z.ZodOptional<z.ZodBoolean>;
+                disabledReason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, 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<"choiceList">;
+            choices: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                icon: z.ZodOptional<z.ZodString>;
+                badge: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                disabled: z.ZodOptional<z.ZodBoolean>;
+                disabledReason: z.ZodOptional<z.ZodString>;
+                value: z.ZodString;
+            }, z.core.$strict>>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>], "type">;
+        defaultValue: z.ZodOptional<z.ZodJSONSchema>;
+    }, z.core.$strict>>;
+    step: z.ZodOptional<z.ZodObject<{
+        index: z.ZodNumber;
+        total: z.ZodNumber;
+        selected: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        canCancel: z.ZodBoolean;
+    }, z.core.$strict>>;
+    availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"notYourTurn">;
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"blocked">;
+        reason: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>], "status">;
+    reasons: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ruleId: z.ZodString;
+        errorCode: z.ZodString;
+    }, z.core.$strict>>>;
+    kind: z.ZodLiteral<"action">;
+}, z.core.$strict>;
+type DeepReadonly<T> = T extends readonly (infer Item)[] ? readonly DeepReadonly<Item>[] : T extends object ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T;
+type InputDomain = DeepReadonly<z.infer<typeof InputDomainSchema>>;
+type InputSelection = DeepReadonly<z.infer<typeof InputSelectionSchema>>;
+type InteractionCommitPolicy$1 = z.infer<typeof InteractionCommitPolicySchema>;
+type InteractionChoiceOption = DeepReadonly<z.infer<typeof InteractionChoiceOptionSchema>>;
+type InteractionInputDescriptor = Readonly<Omit<z.infer<typeof InteractionInputDescriptorSchema>, "domain">> & {
+    readonly domain: InputDomain;
+};
+type InteractionAvailability = DeepReadonly<z.infer<typeof InteractionAvailabilitySchema>>;
+type DescriptorData = z.infer<typeof InteractionDescriptorSchema>;
+type InteractionDescriptor = Readonly<Omit<DescriptorData, "inputs" | "step" | "zoneIds" | "reasons">> & {
+    readonly inputs: readonly InteractionInputDescriptor[];
+    readonly zoneIds?: readonly string[];
+    readonly reasons?: readonly Readonly<NonNullable<DescriptorData["reasons"]>[number]>[];
+    readonly step?: Readonly<Omit<NonNullable<DescriptorData["step"]>, "selected">> & {
+        readonly selected: Readonly<NonNullable<DescriptorData["step"]>["selected"]>;
+    };
+};
+type InteractionDiagnosticReason = NonNullable<InteractionDescriptor["reasons"]>[number];
+
+/**
+ * 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";
+    /**
+     * Default initial home for cards materialized from the preset.
+     */
+    defaultHome: ComponentHomeSpec;
+};
+/**
+ * Arbitrary authored JSON value.
+ */
+type JsonValue = RuntimeJson;
+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 per-card initial home. Omitted cards use their manual card set's
+     * defaultHome. Compatibility declarations such as allowedCardSetIds never
+     * imply placement. Player-scoped distribution belongs in reducer setup.
+     */
+    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;
+    /**
+     * Default initial home for cards that do not declare a per-card home.
+     */
+    defaultHome: ComponentHomeSpec;
+    /**
+     * 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;
+    };
+};
+/**
+ * Visual orientation for authored hex coordinates
+ */
+type HexOrientation = "pointy" | "flat";
+type HexCoordinate = {
+    q: number;
+    r: number;
+};
+type HexShape = {
+    kind: "hexagon" | "spiral";
+    radius: number;
+    center?: HexCoordinate;
+} | {
+    kind: "ring";
+    radius: number;
+    center?: HexCoordinate;
+} | {
+    kind: "rectangle";
+    width: number;
+    height: number;
+    start?: HexCoordinate;
+} | {
+    kind: "coordinates";
+    coordinates: readonly HexCoordinate[];
+};
+type HexSpaceOverride = Omit<HexSpaceSpec, "id" | "q" | "r"> & {
+    id?: string;
+};
+/**
+ * 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];
+} | {
+    space: string;
+    side: 0 | 1 | 2 | 3 | 4 | 5;
+};
+/**
+ * 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];
+} | {
+    space: string;
+    corner: 0 | 1 | 2 | 3 | 4 | 5;
+};
+/**
+ * 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;
+    };
+};
+/**
+ * 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;
+    };
+};
+/**
+ * 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;
+    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;
+    /**
+     * Shape used to generate spaces before exclusions and coordinate overrides
+     */
+    shape: HexShape;
+    exclude?: Array<HexCoordinate>;
+    orientation?: HexOrientation;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    edgeFieldsSchema?: ObjectSchema;
+    vertexFieldsSchema?: ObjectSchema;
+    /**
+     * Typed authored board fields validated against boardFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+    spaces?: {
+        [coordinate: `${number},${number}`]: HexSpaceOverride;
+    };
+    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;
+    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 = {
+    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
+ */
+/**
+ * Authoritative topology manifest for reducer-native games
+ */
+type GameTopologyManifest = {
+    players: PlayersDefinition;
+    /**
+     * Authored card catalogs and schemas
+     */
+    cardSets: Array<CardSetDefinition>;
+    /**
+     * Shared and per-player authored containers
+     */
+    zones?: Array<ZoneSpec>;
+    /**
+     * Shared and per-player authored board shells
+     */
+    boards?: Array<BoardSpec>;
+    pieceTypes?: Array<PieceTypeSpec>;
+    pieceSeeds?: Array<PieceSeedSpec>;
+    dieTypes?: Array<DieTypeSpec>;
+    dieSeeds?: Array<DieSeedSpec>;
+    resources?: Array<ResourceDefinition>;
+};
+
+declare const boardIdentity: unique symbol;
+type HexEdgeId<BoardId extends string = string> = `${BoardId}:edge:${string}` & {
+    readonly [boardIdentity]: "edge";
+};
+type HexVertexId<BoardId extends string = string> = `${BoardId}:vertex:${string}` & {
+    readonly [boardIdentity]: "vertex";
+};
+/** Shape membership is checked at runtime; explicit coordinates retain literals. */
+type HexSpaceId<Board> = Board extends {
+    shape: infer Shape;
+} ? Shape extends {
+    coordinates: readonly (infer Coordinate)[];
+} ? Coordinate extends {
+    q: infer Q extends number;
+    r: infer R extends number;
+} ? HexCoordinateId<Board, `${Q},${R}`> : never : HexOverrideIds<Board> | `${number},${number}` : never;
+type HexOverrideIds<Board> = Board extends {
+    spaces: infer Spaces;
+} ? {
+    [Key in keyof Spaces]: Spaces[Key] extends {
+        id: infer Id extends string;
+    } ? Id : Extract<Key, string>;
+}[keyof Spaces] : never;
+type HexCoordinateId<Board, Key extends string> = Board extends {
+    spaces: infer Spaces;
+} ? Key extends keyof Spaces ? Spaces[Key] extends {
+    id: infer Id extends string;
+} ? Id : Key : Key : Key;
+
+type AxialCoordinate = Readonly<HexCoordinate>;
+declare const hexagon: (options: Omit<Extract<HexShape, {
+    kind: "hexagon" | "spiral";
+}>, "kind">) => {
+    radius: number;
+    center?: HexCoordinate | undefined;
+    kind: "hexagon";
+};
+declare const spiral: (options: Omit<Extract<HexShape, {
+    kind: "hexagon" | "spiral";
+}>, "kind">) => {
+    radius: number;
+    center?: HexCoordinate | undefined;
+    kind: "spiral";
+};
+declare const ring: (options: Omit<Extract<HexShape, {
+    kind: "ring";
+}>, "kind">) => {
+    radius: number;
+    center?: HexCoordinate | undefined;
+    kind: "ring";
+};
+declare const rectangle: (options: Omit<Extract<HexShape, {
+    kind: "rectangle";
+}>, "kind">) => {
+    width: number;
+    height: number;
+    start?: HexCoordinate | undefined;
+    kind: "rectangle";
+};
+declare const fromCoordinates: <const Coordinates extends readonly AxialCoordinate[]>(coordinates: Coordinates) => {
+    kind: "coordinates";
+    coordinates: Coordinates;
+};
+type HexBoardOrientation = HexOrientation;
+type HexBoardSpace<Id extends string = string> = AxialCoordinate & {
+    id: Id;
+};
+type HexTopologyEdge<BoardId extends string> = {
+    id: HexEdgeId<BoardId>;
+    spaceIds: string[];
+    vertexIds: [HexVertexId<BoardId>, HexVertexId<BoardId>];
+};
+type HexTopologyVertex<BoardId extends string> = {
+    id: HexVertexId<BoardId>;
+    spaceIds: string[];
+    edgeIds: HexEdgeId<BoardId>[];
+};
+/** One immutable topology for materialization, rules, layout, and hit testing. */
+declare function createHexBoardGeometry<const BoardId extends string, SpaceId extends string>(board: {
+    id: BoardId;
+    orientation?: HexBoardOrientation;
+    spaces: readonly HexBoardSpace<SpaceId>[];
+}): {
+    edges: HexTopologyEdge<BoardId>[];
+    vertices: HexTopologyVertex<BoardId>[];
+    neighbors(id: SpaceId): SpaceId[];
+    distance(from: SpaceId, to: SpaceId): number;
+    ring(id: SpaceId, radius: number): SpaceId[];
+    line(from: SpaceId, to: SpaceId): SpaceId[];
+    edgesOf(id: SpaceId): HexEdgeId<BoardId>[];
+    verticesOf(id: SpaceId): HexVertexId<BoardId>[];
+    edgeAt(id: SpaceId, side: 0 | 1 | 2 | 3 | 4 | 5): HexEdgeId<BoardId>;
+    vertexAt(id: SpaceId, corner: 0 | 1 | 2 | 3 | 4 | 5): HexVertexId<BoardId>;
+    edge(a: SpaceId, b: SpaceId): HexEdgeId<BoardId>;
+    vertex(a: SpaceId, b: SpaceId, c: SpaceId): HexVertexId<BoardId>;
+    incidentEdges(vertexId: HexVertexId<BoardId>): HexEdgeId<BoardId>[];
+    incidentVertices(edgeId: HexEdgeId<BoardId>): [HexVertexId<BoardId>, HexVertexId<BoardId>];
+    spacesAt(vertexId: HexVertexId<BoardId>): SpaceId[];
+    spacesAlong(edgeId: HexEdgeId<BoardId>): SpaceId[];
+    getLayout({ hexSize, origin, }: {
+        hexSize: number;
+        origin?: Point;
+    }): {
+        viewBox: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        spaces: {
+            id: SpaceId;
+            center: {
+                x: number;
+                y: number;
+            };
+            corners: {
+                x: number;
+                y: number;
+            }[];
+        }[];
+        edges: {
+            id: HexEdgeId<BoardId>;
+            from: {
+                x: number;
+                y: number;
+            };
+            to: {
+                x: number;
+                y: number;
+            };
+        }[];
+        vertices: {
+            id: HexVertexId<BoardId>;
+            center: {
+                x: number;
+                y: number;
+            };
+        }[];
+        pointToSpace(point: Point): SpaceId | undefined;
+    };
+};
+
+declare const ReducerContractVersionSchema: z.ZodString;
+declare const RngOperationParameterSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+declare const RngOperationSchema: z.ZodObject<{
+    kind: z.ZodString;
+    parameters: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+}, z.core.$strict>;
+declare const RngDrawSchema: z.ZodObject<{
+    index: z.ZodNumber;
+    cursorBefore: z.ZodNumber;
+    cursorAfter: z.ZodNumber;
+    operation: z.ZodObject<{
+        kind: z.ZodString;
+        parameters: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+declare const RngStateSchema: z.ZodObject<{
+    seed: z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>;
+    cursor: z.ZodNumber;
+    trace: z.ZodArray<z.ZodString>;
+    draws: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        cursorBefore: z.ZodNumber;
+        cursorAfter: z.ZodNumber;
+        operation: z.ZodObject<{
+            kind: z.ZodString;
+            parameters: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+declare const ReducerFlowStateSchema: z.ZodObject<{
+    currentPhase: z.ZodString;
+    turn: z.ZodNumber;
+    round: z.ZodNumber;
+    activePlayers: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+declare const RuntimeSimultaneousSubmissionSchema: z.ZodObject<{
+    interactionId: z.ZodString;
+    params: z.ZodJSONSchema;
+}, z.core.$strict>;
+declare const RuntimeSimultaneousCurrentSchema: z.ZodObject<{
+    phaseName: z.ZodString;
+    actors: z.ZodArray<z.ZodString>;
+    submissions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        interactionId: z.ZodString;
+        params: z.ZodJSONSchema;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const RuntimeSimultaneousStateSchema: z.ZodObject<{
+    current: z.ZodUnion<readonly [z.ZodObject<{
+        phaseName: z.ZodString;
+        actors: z.ZodArray<z.ZodString>;
+        submissions: z.ZodRecord<z.ZodString, z.ZodObject<{
+            interactionId: z.ZodString;
+            params: z.ZodJSONSchema;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodNull]>;
+}, z.core.$strict>;
+declare const TransitionRecordSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+}, z.core.$strict>;
+declare const RuntimePendingInteractionSchema: z.ZodObject<{
+    phaseName: z.ZodString;
+    interactionId: z.ZodString;
+    values: z.ZodArray<z.ZodJSONSchema>;
+}, z.core.$strict>;
+declare const GameEventDetailSchema: z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+}, z.core.$strict>;
+declare const SystemActionEventSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"systemAction">;
+    procedureId: z.ZodString;
+    title: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+declare const GameEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"systemAction">;
+    procedureId: z.ZodString;
+    title: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>], "kind">;
+declare const ReducerRuntimeStateSchema: z.ZodObject<{
+    events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"systemAction">;
+        procedureId: z.ZodString;
+        title: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>], "kind">>;
+    rng: z.ZodObject<{
+        seed: z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>;
+        cursor: z.ZodNumber;
+        trace: z.ZodArray<z.ZodString>;
+        draws: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            index: z.ZodNumber;
+            cursorBefore: z.ZodNumber;
+            cursorAfter: z.ZodNumber;
+            operation: z.ZodObject<{
+                kind: z.ZodString;
+                parameters: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    pending: z.ZodRecord<z.ZodString, z.ZodObject<{
+        phaseName: z.ZodString;
+        interactionId: z.ZodString;
+        values: z.ZodArray<z.ZodJSONSchema>;
+    }, z.core.$strict>>;
+    simultaneous: z.ZodObject<{
+        current: z.ZodUnion<readonly [z.ZodObject<{
+            phaseName: z.ZodString;
+            actors: z.ZodArray<z.ZodString>;
+            submissions: z.ZodRecord<z.ZodString, z.ZodObject<{
+                interactionId: z.ZodString;
+                params: z.ZodJSONSchema;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodNull]>;
+    }, z.core.$strict>;
+    lastTransition: z.ZodUnion<readonly [z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strict>, z.ZodNull]>;
+    options: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+}, z.core.$strict>;
+declare const ReducerDomainStateSchema: z.ZodObject<{
+    table: z.ZodJSONSchema;
+    publicState: z.ZodJSONSchema;
+    privateState: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    hiddenState: z.ZodJSONSchema;
+    flow: z.ZodObject<{
+        currentPhase: z.ZodString;
+        turn: z.ZodNumber;
+        round: z.ZodNumber;
+        activePlayers: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    phase: z.ZodJSONSchema;
+}, z.core.$strict>;
+declare const ReducerSessionStateSchema: z.ZodObject<{
+    domain: z.ZodObject<{
+        table: z.ZodJSONSchema;
+        publicState: z.ZodJSONSchema;
+        privateState: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        hiddenState: z.ZodJSONSchema;
+        flow: z.ZodObject<{
+            currentPhase: z.ZodString;
+            turn: z.ZodNumber;
+            round: z.ZodNumber;
+            activePlayers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        phase: z.ZodJSONSchema;
+    }, z.core.$strict>;
+    runtime: z.ZodObject<{
+        events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"systemAction">;
+            procedureId: z.ZodString;
+            title: z.ZodString;
+            summary: z.ZodOptional<z.ZodString>;
+            details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>], "kind">>;
+        rng: z.ZodObject<{
+            seed: z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>;
+            cursor: z.ZodNumber;
+            trace: z.ZodArray<z.ZodString>;
+            draws: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                index: z.ZodNumber;
+                cursorBefore: z.ZodNumber;
+                cursorAfter: z.ZodNumber;
+                operation: z.ZodObject<{
+                    kind: z.ZodString;
+                    parameters: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        pending: z.ZodRecord<z.ZodString, z.ZodObject<{
+            phaseName: z.ZodString;
+            interactionId: z.ZodString;
+            values: z.ZodArray<z.ZodJSONSchema>;
+        }, z.core.$strict>>;
+        simultaneous: z.ZodObject<{
+            current: z.ZodUnion<readonly [z.ZodObject<{
+                phaseName: z.ZodString;
+                actors: z.ZodArray<z.ZodString>;
+                submissions: z.ZodRecord<z.ZodString, z.ZodObject<{
+                    interactionId: z.ZodString;
+                    params: z.ZodJSONSchema;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodNull]>;
+        }, z.core.$strict>;
+        lastTransition: z.ZodUnion<readonly [z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+        }, z.core.$strict>, z.ZodNull]>;
+        options: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+declare const GameInputInteractionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interaction">;
+    playerId: z.ZodString;
+    interactionId: z.ZodString;
+    params: z.ZodJSONSchema;
+}, z.core.$strict>;
+declare const GameInputCancelSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interaction.cancel">;
+    playerId: z.ZodString;
+    interactionId: z.ZodString;
+}, z.core.$strict>;
+declare const GameInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"interaction">;
+    playerId: z.ZodString;
+    interactionId: z.ZodString;
+    params: z.ZodJSONSchema;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"interaction.cancel">;
+    playerId: z.ZodString;
+    interactionId: z.ZodString;
+}, z.core.$strict>], "kind">;
+declare const GameOutcomeReasonSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const OutcomeResultSchema: z.ZodEnum<{
+    win: "win";
+    draw: "draw";
+    loss: "loss";
+    eliminated: "eliminated";
+}>;
+declare const OutcomeScoreComponentSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    value: z.ZodNumber;
+}, z.core.$strict>;
+declare const OutcomeTieBreakSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+}, z.core.$strict>;
+declare const OutcomeStandingSchema: z.ZodObject<{
+    playerId: z.ZodString;
+    rank: z.ZodNumber;
+    result: z.ZodEnum<{
+        win: "win";
+        draw: "draw";
+        loss: "loss";
+        eliminated: "eliminated";
+    }>;
+    score: z.ZodOptional<z.ZodNumber>;
+    scoreBreakdown: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodNumber;
+    }, z.core.$strict>>>;
+    tieBreaks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+declare const GameOutcomeSchema: z.ZodObject<{
+    reason: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    standings: z.ZodArray<z.ZodObject<{
+        playerId: z.ZodString;
+        rank: z.ZodNumber;
+        result: z.ZodEnum<{
+            win: "win";
+            draw: "draw";
+            loss: "loss";
+            eliminated: "eliminated";
+        }>;
+        score: z.ZodOptional<z.ZodNumber>;
+        scoreBreakdown: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            value: z.ZodNumber;
+        }, z.core.$strict>>>;
+        tieBreaks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const InitializeResultSchema: z.ZodObject<{
+    state: z.ZodObject<{
+        domain: z.ZodObject<{
+            table: z.ZodJSONSchema;
+            publicState: z.ZodJSONSchema;
+            privateState: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            hiddenState: z.ZodJSONSchema;
+            flow: z.ZodObject<{
+                currentPhase: z.ZodString;
+                turn: z.ZodNumber;
+                round: z.ZodNumber;
+                activePlayers: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            phase: z.ZodJSONSchema;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"systemAction">;
+                procedureId: z.ZodString;
+                title: z.ZodString;
+                summary: z.ZodOptional<z.ZodString>;
+                details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>], "kind">>;
+            rng: z.ZodObject<{
+                seed: z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>;
+                cursor: z.ZodNumber;
+                trace: z.ZodArray<z.ZodString>;
+                draws: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    index: z.ZodNumber;
+                    cursorBefore: z.ZodNumber;
+                    cursorAfter: z.ZodNumber;
+                    operation: z.ZodObject<{
+                        kind: z.ZodString;
+                        parameters: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+            pending: z.ZodRecord<z.ZodString, z.ZodObject<{
+                phaseName: z.ZodString;
+                interactionId: z.ZodString;
+                values: z.ZodArray<z.ZodJSONSchema>;
+            }, z.core.$strict>>;
+            simultaneous: z.ZodObject<{
+                current: z.ZodUnion<readonly [z.ZodObject<{
+                    phaseName: z.ZodString;
+                    actors: z.ZodArray<z.ZodString>;
+                    submissions: z.ZodRecord<z.ZodString, z.ZodObject<{
+                        interactionId: z.ZodString;
+                        params: z.ZodJSONSchema;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>, z.ZodNull]>;
+            }, z.core.$strict>;
+            lastTransition: z.ZodUnion<readonly [z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strict>, z.ZodNull]>;
+            options: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    terminal: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        standings: z.ZodArray<z.ZodObject<{
+            playerId: z.ZodString;
+            rank: z.ZodNumber;
+            result: z.ZodEnum<{
+                win: "win";
+                draw: "draw";
+                loss: "loss";
+                eliminated: "eliminated";
+            }>;
+            score: z.ZodOptional<z.ZodNumber>;
+            scoreBreakdown: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                value: z.ZodNumber;
+            }, z.core.$strict>>>;
+            tieBreaks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    events: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"systemAction">;
+        procedureId: z.ZodString;
+        title: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>], "kind">>>;
+}, z.core.$strict>;
+declare const InitializeRequestSchema: z.ZodObject<{
+    table: z.ZodJSONSchema;
+    playerIds: z.ZodArray<z.ZodString>;
+    rngSeed: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strict>;
+declare const DispatchRequestSchema: z.ZodObject<{
+    state: z.ZodObject<{
+        domain: z.ZodObject<{
+            table: z.ZodJSONSchema;
+            publicState: z.ZodJSONSchema;
+            privateState: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            hiddenState: z.ZodJSONSchema;
+            flow: z.ZodObject<{
+                currentPhase: z.ZodString;
+                turn: z.ZodNumber;
+                round: z.ZodNumber;
+                activePlayers: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            phase: z.ZodJSONSchema;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"systemAction">;
+                procedureId: z.ZodString;
+                title: z.ZodString;
+                summary: z.ZodOptional<z.ZodString>;
+                details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>], "kind">>;
+            rng: z.ZodObject<{
+                seed: z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>;
+                cursor: z.ZodNumber;
+                trace: z.ZodArray<z.ZodString>;
+                draws: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    index: z.ZodNumber;
+                    cursorBefore: z.ZodNumber;
+                    cursorAfter: z.ZodNumber;
+                    operation: z.ZodObject<{
+                        kind: z.ZodString;
+                        parameters: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+            pending: z.ZodRecord<z.ZodString, z.ZodObject<{
+                phaseName: z.ZodString;
+                interactionId: z.ZodString;
+                values: z.ZodArray<z.ZodJSONSchema>;
+            }, z.core.$strict>>;
+            simultaneous: z.ZodObject<{
+                current: z.ZodUnion<readonly [z.ZodObject<{
+                    phaseName: z.ZodString;
+                    actors: z.ZodArray<z.ZodString>;
+                    submissions: z.ZodRecord<z.ZodString, z.ZodObject<{
+                        interactionId: z.ZodString;
+                        params: z.ZodJSONSchema;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>, z.ZodNull]>;
+            }, z.core.$strict>;
+            lastTransition: z.ZodUnion<readonly [z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strict>, z.ZodNull]>;
+            options: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"interaction">;
+        playerId: z.ZodString;
+        interactionId: z.ZodString;
+        params: z.ZodJSONSchema;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"interaction.cancel">;
+        playerId: z.ZodString;
+        interactionId: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+declare const DispatchTraceAcceptedClientInputSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"acceptedClientInput">;
+    input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"interaction">;
+        playerId: z.ZodString;
+        interactionId: z.ZodString;
+        params: z.ZodJSONSchema;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"interaction.cancel">;
+        playerId: z.ZodString;
+        interactionId: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+declare const DispatchTracePhaseEnteredSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"phaseEntered">;
+    from: z.ZodString;
+    to: z.ZodString;
+}, z.core.$strict>;
+declare const DispatchTraceRngConsumptionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"rngConsumption">;
+    version: z.ZodLiteral<2>;
+    operation: z.ZodString;
+    drawIndex: z.ZodNumber;
+    traceEntry: z.ZodString;
+}, z.core.$strict>;
+declare const DispatchTraceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"acceptedClientInput">;
+    input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"interaction">;
+        playerId: z.ZodString;
+        interactionId: z.ZodString;
+        params: z.ZodJSONSchema;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"interaction.cancel">;
+        playerId: z.ZodString;
+        interactionId: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"phaseEntered">;
+    from: z.ZodString;
+    to: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"rngConsumption">;
+    version: z.ZodLiteral<2>;
+    operation: z.ZodString;
+    drawIndex: z.ZodNumber;
+    traceEntry: z.ZodString;
+}, z.core.$strict>], "kind">;
+declare const DispatchResultRejectSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"reject">;
+    errorCode: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const DispatchResultAcceptSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"accept">;
+    state: z.ZodObject<{
+        domain: z.ZodObject<{
+            table: z.ZodJSONSchema;
+            publicState: z.ZodJSONSchema;
+            privateState: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            hiddenState: z.ZodJSONSchema;
+            flow: z.ZodObject<{
+                currentPhase: z.ZodString;
+                turn: z.ZodNumber;
+                round: z.ZodNumber;
+                activePlayers: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            phase: z.ZodJSONSchema;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"systemAction">;
+                procedureId: z.ZodString;
+                title: z.ZodString;
+                summary: z.ZodOptional<z.ZodString>;
+                details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>], "kind">>;
+            rng: z.ZodObject<{
+                seed: z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>;
+                cursor: z.ZodNumber;
+                trace: z.ZodArray<z.ZodString>;
+                draws: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    index: z.ZodNumber;
+                    cursorBefore: z.ZodNumber;
+                    cursorAfter: z.ZodNumber;
+                    operation: z.ZodObject<{
+                        kind: z.ZodString;
+                        parameters: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+            pending: z.ZodRecord<z.ZodString, z.ZodObject<{
+                phaseName: z.ZodString;
+                interactionId: z.ZodString;
+                values: z.ZodArray<z.ZodJSONSchema>;
+            }, z.core.$strict>>;
+            simultaneous: z.ZodObject<{
+                current: z.ZodUnion<readonly [z.ZodObject<{
+                    phaseName: z.ZodString;
+                    actors: z.ZodArray<z.ZodString>;
+                    submissions: z.ZodRecord<z.ZodString, z.ZodObject<{
+                        interactionId: z.ZodString;
+                        params: z.ZodJSONSchema;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>, z.ZodNull]>;
+            }, z.core.$strict>;
+            lastTransition: z.ZodUnion<readonly [z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strict>, z.ZodNull]>;
+            options: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    terminal: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        standings: z.ZodArray<z.ZodObject<{
+            playerId: z.ZodString;
+            rank: z.ZodNumber;
+            result: z.ZodEnum<{
+                win: "win";
+                draw: "draw";
+                loss: "loss";
+                eliminated: "eliminated";
+            }>;
+            score: z.ZodOptional<z.ZodNumber>;
+            scoreBreakdown: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                value: z.ZodNumber;
+            }, z.core.$strict>>>;
+            tieBreaks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    trace: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"acceptedClientInput">;
+        input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"interaction">;
+            playerId: z.ZodString;
+            interactionId: z.ZodString;
+            params: z.ZodJSONSchema;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"interaction.cancel">;
+            playerId: z.ZodString;
+            interactionId: z.ZodString;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"phaseEntered">;
+        from: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"rngConsumption">;
+        version: z.ZodLiteral<2>;
+        operation: z.ZodString;
+        drawIndex: z.ZodNumber;
+        traceEntry: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"systemAction">;
+        procedureId: z.ZodString;
+        title: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+declare const DispatchResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"reject">;
+    errorCode: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"accept">;
+    state: z.ZodObject<{
+        domain: z.ZodObject<{
+            table: z.ZodJSONSchema;
+            publicState: z.ZodJSONSchema;
+            privateState: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            hiddenState: z.ZodJSONSchema;
+            flow: z.ZodObject<{
+                currentPhase: z.ZodString;
+                turn: z.ZodNumber;
+                round: z.ZodNumber;
+                activePlayers: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            phase: z.ZodJSONSchema;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"systemAction">;
+                procedureId: z.ZodString;
+                title: z.ZodString;
+                summary: z.ZodOptional<z.ZodString>;
+                details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>], "kind">>;
+            rng: z.ZodObject<{
+                seed: z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>;
+                cursor: z.ZodNumber;
+                trace: z.ZodArray<z.ZodString>;
+                draws: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    index: z.ZodNumber;
+                    cursorBefore: z.ZodNumber;
+                    cursorAfter: z.ZodNumber;
+                    operation: z.ZodObject<{
+                        kind: z.ZodString;
+                        parameters: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+            pending: z.ZodRecord<z.ZodString, z.ZodObject<{
+                phaseName: z.ZodString;
+                interactionId: z.ZodString;
+                values: z.ZodArray<z.ZodJSONSchema>;
+            }, z.core.$strict>>;
+            simultaneous: z.ZodObject<{
+                current: z.ZodUnion<readonly [z.ZodObject<{
+                    phaseName: z.ZodString;
+                    actors: z.ZodArray<z.ZodString>;
+                    submissions: z.ZodRecord<z.ZodString, z.ZodObject<{
+                        interactionId: z.ZodString;
+                        params: z.ZodJSONSchema;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>, z.ZodNull]>;
+            }, z.core.$strict>;
+            lastTransition: z.ZodUnion<readonly [z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strict>, z.ZodNull]>;
+            options: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    terminal: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        standings: z.ZodArray<z.ZodObject<{
+            playerId: z.ZodString;
+            rank: z.ZodNumber;
+            result: z.ZodEnum<{
+                win: "win";
+                draw: "draw";
+                loss: "loss";
+                eliminated: "eliminated";
+            }>;
+            score: z.ZodOptional<z.ZodNumber>;
+            scoreBreakdown: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                value: z.ZodNumber;
+            }, z.core.$strict>>>;
+            tieBreaks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    trace: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"acceptedClientInput">;
+        input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"interaction">;
+            playerId: z.ZodString;
+            interactionId: z.ZodString;
+            params: z.ZodJSONSchema;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"interaction.cancel">;
+            playerId: z.ZodString;
+            interactionId: z.ZodString;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"phaseEntered">;
+        from: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"rngConsumption">;
+        version: z.ZodLiteral<2>;
+        operation: z.ZodString;
+        drawIndex: z.ZodNumber;
+        traceEntry: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"systemAction">;
+        procedureId: z.ZodString;
+        title: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>], "kind">;
+declare const ReducerRuntimeLogEntryAcceptedClientInputSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"acceptedClientInput">;
+    version: z.ZodNumber;
+    input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"interaction">;
+        playerId: z.ZodString;
+        interactionId: z.ZodString;
+        params: z.ZodJSONSchema;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"interaction.cancel">;
+        playerId: z.ZodString;
+        interactionId: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+declare const ReducerRuntimeLogEntryPhaseEnteredSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"phaseEntered">;
+    from: z.ZodString;
+    to: z.ZodString;
+    version: z.ZodNumber;
+}, z.core.$strict>;
+declare const ReducerRuntimeLogEntryRngConsumptionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"rngConsumption">;
+    version: z.ZodNumber;
+    operation: z.ZodString;
+    drawIndex: z.ZodOptional<z.ZodNumber>;
+    traceEntry: z.ZodString;
+}, z.core.$strict>;
+declare const ReducerRuntimeLogEntryStateCommitSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"stateCommit">;
+    version: z.ZodNumber;
+    state: z.ZodObject<{
+        domain: z.ZodObject<{
+            table: z.ZodJSONSchema;
+            publicState: z.ZodJSONSchema;
+            privateState: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            hiddenState: z.ZodJSONSchema;
+            flow: z.ZodObject<{
+                currentPhase: z.ZodString;
+                turn: z.ZodNumber;
+                round: z.ZodNumber;
+                activePlayers: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            phase: z.ZodJSONSchema;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"systemAction">;
+                procedureId: z.ZodString;
+                title: z.ZodString;
+                summary: z.ZodOptional<z.ZodString>;
+                details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>], "kind">>;
+            rng: z.ZodObject<{
+                seed: z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>;
+                cursor: z.ZodNumber;
+                trace: z.ZodArray<z.ZodString>;
+                draws: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    index: z.ZodNumber;
+                    cursorBefore: z.ZodNumber;
+                    cursorAfter: z.ZodNumber;
+                    operation: z.ZodObject<{
+                        kind: z.ZodString;
+                        parameters: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+            pending: z.ZodRecord<z.ZodString, z.ZodObject<{
+                phaseName: z.ZodString;
+                interactionId: z.ZodString;
+                values: z.ZodArray<z.ZodJSONSchema>;
+            }, z.core.$strict>>;
+            simultaneous: z.ZodObject<{
+                current: z.ZodUnion<readonly [z.ZodObject<{
+                    phaseName: z.ZodString;
+                    actors: z.ZodArray<z.ZodString>;
+                    submissions: z.ZodRecord<z.ZodString, z.ZodObject<{
+                        interactionId: z.ZodString;
+                        params: z.ZodJSONSchema;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>, z.ZodNull]>;
+            }, z.core.$strict>;
+            lastTransition: z.ZodUnion<readonly [z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strict>, z.ZodNull]>;
+            options: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+declare const ReducerRuntimeLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"acceptedClientInput">;
+    version: z.ZodNumber;
+    input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"interaction">;
+        playerId: z.ZodString;
+        interactionId: z.ZodString;
+        params: z.ZodJSONSchema;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"interaction.cancel">;
+        playerId: z.ZodString;
+        interactionId: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"phaseEntered">;
+    from: z.ZodString;
+    to: z.ZodString;
+    version: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"rngConsumption">;
+    version: z.ZodNumber;
+    operation: z.ZodString;
+    drawIndex: z.ZodOptional<z.ZodNumber>;
+    traceEntry: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"stateCommit">;
+    version: z.ZodNumber;
+    state: z.ZodObject<{
+        domain: z.ZodObject<{
+            table: z.ZodJSONSchema;
+            publicState: z.ZodJSONSchema;
+            privateState: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            hiddenState: z.ZodJSONSchema;
+            flow: z.ZodObject<{
+                currentPhase: z.ZodString;
+                turn: z.ZodNumber;
+                round: z.ZodNumber;
+                activePlayers: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            phase: z.ZodJSONSchema;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"systemAction">;
+                procedureId: z.ZodString;
+                title: z.ZodString;
+                summary: z.ZodOptional<z.ZodString>;
+                details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>], "kind">>;
+            rng: z.ZodObject<{
+                seed: z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>;
+                cursor: z.ZodNumber;
+                trace: z.ZodArray<z.ZodString>;
+                draws: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    index: z.ZodNumber;
+                    cursorBefore: z.ZodNumber;
+                    cursorAfter: z.ZodNumber;
+                    operation: z.ZodObject<{
+                        kind: z.ZodString;
+                        parameters: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+            pending: z.ZodRecord<z.ZodString, z.ZodObject<{
+                phaseName: z.ZodString;
+                interactionId: z.ZodString;
+                values: z.ZodArray<z.ZodJSONSchema>;
+            }, z.core.$strict>>;
+            simultaneous: z.ZodObject<{
+                current: z.ZodUnion<readonly [z.ZodObject<{
+                    phaseName: z.ZodString;
+                    actors: z.ZodArray<z.ZodString>;
+                    submissions: z.ZodRecord<z.ZodString, z.ZodObject<{
+                        interactionId: z.ZodString;
+                        params: z.ZodJSONSchema;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>, z.ZodNull]>;
+            }, z.core.$strict>;
+            lastTransition: z.ZodUnion<readonly [z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strict>, z.ZodNull]>;
+            options: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "kind">;
+/** Authored views are records; boards is reserved for manifest geometry. */
+declare const AuthoredViewSchema: z.ZodObject<{
+    boards: z.ZodOptional<z.ZodNever>;
+}, z.core.$catchall<z.ZodJSONSchema>>;
+declare const SeatProjectionSchema: z.ZodObject<{
+    view: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        boards: z.ZodOptional<z.ZodNever>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>>;
+    availableInteractionRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    zones: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        cardIds: z.ZodArray<z.ZodString>;
+        cardViewsById: z.ZodRecord<z.ZodString, z.ZodString>;
+        playableByCardId: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+declare const SimultaneousPhaseProjectionSchema: z.ZodObject<{
+    phaseName: z.ZodString;
+    interactionId: z.ZodString;
+    actorIds: z.ZodArray<z.ZodString>;
+    sealedPlayerIds: z.ZodArray<z.ZodString>;
+    pendingPlayerIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+declare const SchedulerContinuationDependencySchema: z.ZodObject<{
+    waiterPlayerId: z.ZodString;
+    blockerPlayerIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+declare const SchedulerFlowAuthorityProjectionSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    activePlayerIds: z.ZodArray<z.ZodString>;
+    pendingPlayerIds: z.ZodArray<z.ZodString>;
+    continuationDependencies: z.ZodArray<z.ZodObject<{
+        waiterPlayerId: z.ZodString;
+        blockerPlayerIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const ProjectionTimingMetadataSchema: z.ZodObject<{
+    resolveAvailableInteractionsMs: z.ZodNumber;
+    resolveViewMs: z.ZodNumber;
+    resolveZoneHandlesMs: z.ZodNumber;
+    descriptorHashMs: z.ZodNumber;
+}, z.core.$strict>;
+declare const SeatProjectionBundleSchema: z.ZodObject<{
+    events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"systemAction">;
+        procedureId: z.ZodString;
+        title: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>], "kind">>;
+    simultaneousPhase: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        phaseName: z.ZodString;
+        interactionId: z.ZodString;
+        actorIds: z.ZodArray<z.ZodString>;
+        sealedPlayerIds: z.ZodArray<z.ZodString>;
+        pendingPlayerIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodNull]>>;
+    schedulerFlow: z.ZodOptional<z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        activePlayerIds: z.ZodArray<z.ZodString>;
+        pendingPlayerIds: z.ZodArray<z.ZodString>;
+        continuationDependencies: z.ZodArray<z.ZodObject<{
+            waiterPlayerId: z.ZodString;
+            blockerPlayerIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    interactionsByRef: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        phaseName: z.ZodString;
+        interactionKey: z.ZodString;
+        interactionId: z.ZodString;
+        label: z.ZodString;
+        help: z.ZodOptional<z.ZodString>;
+        zoneId: z.ZodOptional<z.ZodString>;
+        zoneIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        commit: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"manual">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"autoWhenReady">;
+        }, z.core.$strict>], "mode">;
+        descriptorDigest: z.ZodOptional<z.ZodString>;
+        actorSeat: z.ZodOptional<z.ZodNumber>;
+        draftDigest: z.ZodOptional<z.ZodString>;
+        inputs: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodEnum<{
+                card: "card";
+                form: "form";
+                "board-vertex": "board-vertex";
+                "board-edge": "board-edge";
+                "board-tile": "board-tile";
+                "board-space": "board-space";
+                rng: "rng";
+            }>;
+            domain: z.ZodDiscriminatedUnion<[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<"cardTarget">;
+                projection: z.ZodLiteral<"resolved">;
+                targetKind: z.ZodLiteral<"card">;
+                zoneIds: z.ZodArray<z.ZodString>;
+                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.ZodEnum<{
+                    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";
+                }>>;
+                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<"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<{
+                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<"boundedNumber">;
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+                step: z.ZodOptional<z.ZodNumber>;
+            }, 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<"choice">;
+                choices: z.ZodArray<z.ZodObject<{
+                    value: z.ZodNullable<z.ZodString>;
+                    label: z.ZodString;
+                    icon: z.ZodOptional<z.ZodString>;
+                    badge: z.ZodOptional<z.ZodString>;
+                    description: z.ZodOptional<z.ZodString>;
+                    disabled: z.ZodOptional<z.ZodBoolean>;
+                    disabledReason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, 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<"choiceList">;
+                choices: z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    icon: z.ZodOptional<z.ZodString>;
+                    badge: z.ZodOptional<z.ZodString>;
+                    description: z.ZodOptional<z.ZodString>;
+                    disabled: z.ZodOptional<z.ZodBoolean>;
+                    disabledReason: z.ZodOptional<z.ZodString>;
+                    value: z.ZodString;
+                }, z.core.$strict>>;
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>], "type">;
+            defaultValue: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strict>>;
+        step: z.ZodOptional<z.ZodObject<{
+            index: z.ZodNumber;
+            total: z.ZodNumber;
+            selected: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            canCancel: z.ZodBoolean;
+        }, z.core.$strict>>;
+        availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"notYourTurn">;
+            reason: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"blocked">;
+            reason: z.ZodString;
+            code: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        reasons: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            ruleId: z.ZodString;
+            errorCode: z.ZodString;
+        }, z.core.$strict>>>;
+        kind: z.ZodLiteral<"action">;
+    }, z.core.$strict>>>;
+    seats: z.ZodRecord<z.ZodString, z.ZodObject<{
+        view: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            boards: z.ZodOptional<z.ZodNever>;
+        }, z.core.$catchall<z.ZodJSONSchema>>>>;
+        availableInteractionRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        zones: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            cardIds: z.ZodArray<z.ZodString>;
+            cardViewsById: z.ZodRecord<z.ZodString, z.ZodString>;
+            playableByCardId: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    timing: z.ZodOptional<z.ZodObject<{
+        resolveAvailableInteractionsMs: z.ZodNumber;
+        resolveViewMs: z.ZodNumber;
+        resolveZoneHandlesMs: z.ZodNumber;
+        descriptorHashMs: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const ProjectRequestSchema: z.ZodObject<{
+    state: z.ZodObject<{
+        domain: z.ZodObject<{
+            table: z.ZodJSONSchema;
+            publicState: z.ZodJSONSchema;
+            privateState: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            hiddenState: z.ZodJSONSchema;
+            flow: z.ZodObject<{
+                currentPhase: z.ZodString;
+                turn: z.ZodNumber;
+                round: z.ZodNumber;
+                activePlayers: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            phase: z.ZodJSONSchema;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"systemAction">;
+                procedureId: z.ZodString;
+                title: z.ZodString;
+                summary: z.ZodOptional<z.ZodString>;
+                details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>], "kind">>;
+            rng: z.ZodObject<{
+                seed: z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>;
+                cursor: z.ZodNumber;
+                trace: z.ZodArray<z.ZodString>;
+                draws: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    index: z.ZodNumber;
+                    cursorBefore: z.ZodNumber;
+                    cursorAfter: z.ZodNumber;
+                    operation: z.ZodObject<{
+                        kind: z.ZodString;
+                        parameters: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+            pending: z.ZodRecord<z.ZodString, z.ZodObject<{
+                phaseName: z.ZodString;
+                interactionId: z.ZodString;
+                values: z.ZodArray<z.ZodJSONSchema>;
+            }, z.core.$strict>>;
+            simultaneous: z.ZodObject<{
+                current: z.ZodUnion<readonly [z.ZodObject<{
+                    phaseName: z.ZodString;
+                    actors: z.ZodArray<z.ZodString>;
+                    submissions: z.ZodRecord<z.ZodString, z.ZodObject<{
+                        interactionId: z.ZodString;
+                        params: z.ZodJSONSchema;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>, z.ZodNull]>;
+            }, z.core.$strict>;
+            lastTransition: z.ZodUnion<readonly [z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strict>, z.ZodNull]>;
+            options: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    playerIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+declare const BoardStaticProjectionSchema: z.ZodObject<{
+    view: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    hash: z.ZodString;
+    manifestVersion: z.ZodString;
+}, z.core.$strict>;
+
+declare const runtimeSchema_AuthoredViewSchema: typeof AuthoredViewSchema;
+declare const runtimeSchema_BoardStaticProjectionSchema: typeof BoardStaticProjectionSchema;
+declare const runtimeSchema_DispatchRequestSchema: typeof DispatchRequestSchema;
+declare const runtimeSchema_DispatchResultAcceptSchema: typeof DispatchResultAcceptSchema;
+declare const runtimeSchema_DispatchResultRejectSchema: typeof DispatchResultRejectSchema;
+declare const runtimeSchema_DispatchResultSchema: typeof DispatchResultSchema;
+declare const runtimeSchema_DispatchTraceAcceptedClientInputSchema: typeof DispatchTraceAcceptedClientInputSchema;
+declare const runtimeSchema_DispatchTracePhaseEnteredSchema: typeof DispatchTracePhaseEnteredSchema;
+declare const runtimeSchema_DispatchTraceRngConsumptionSchema: typeof DispatchTraceRngConsumptionSchema;
+declare const runtimeSchema_DispatchTraceSchema: typeof DispatchTraceSchema;
+declare const runtimeSchema_GameEventDetailSchema: typeof GameEventDetailSchema;
+declare const runtimeSchema_GameEventSchema: typeof GameEventSchema;
+declare const runtimeSchema_GameInputCancelSchema: typeof GameInputCancelSchema;
+declare const runtimeSchema_GameInputInteractionSchema: typeof GameInputInteractionSchema;
+declare const runtimeSchema_GameInputSchema: typeof GameInputSchema;
+declare const runtimeSchema_GameOutcomeReasonSchema: typeof GameOutcomeReasonSchema;
+declare const runtimeSchema_GameOutcomeSchema: typeof GameOutcomeSchema;
+declare const runtimeSchema_InitializeRequestSchema: typeof InitializeRequestSchema;
+declare const runtimeSchema_InitializeResultSchema: typeof InitializeResultSchema;
+declare const runtimeSchema_OutcomeResultSchema: typeof OutcomeResultSchema;
+declare const runtimeSchema_OutcomeScoreComponentSchema: typeof OutcomeScoreComponentSchema;
+declare const runtimeSchema_OutcomeStandingSchema: typeof OutcomeStandingSchema;
+declare const runtimeSchema_OutcomeTieBreakSchema: typeof OutcomeTieBreakSchema;
+declare const runtimeSchema_ProjectRequestSchema: typeof ProjectRequestSchema;
+declare const runtimeSchema_ProjectionTimingMetadataSchema: typeof ProjectionTimingMetadataSchema;
+declare const runtimeSchema_ReducerContractVersionSchema: typeof ReducerContractVersionSchema;
+declare const runtimeSchema_ReducerDomainStateSchema: typeof ReducerDomainStateSchema;
+declare const runtimeSchema_ReducerFlowStateSchema: typeof ReducerFlowStateSchema;
+declare const runtimeSchema_ReducerRuntimeLogEntryAcceptedClientInputSchema: typeof ReducerRuntimeLogEntryAcceptedClientInputSchema;
+declare const runtimeSchema_ReducerRuntimeLogEntryPhaseEnteredSchema: typeof ReducerRuntimeLogEntryPhaseEnteredSchema;
+declare const runtimeSchema_ReducerRuntimeLogEntryRngConsumptionSchema: typeof ReducerRuntimeLogEntryRngConsumptionSchema;
+declare const runtimeSchema_ReducerRuntimeLogEntrySchema: typeof ReducerRuntimeLogEntrySchema;
+declare const runtimeSchema_ReducerRuntimeLogEntryStateCommitSchema: typeof ReducerRuntimeLogEntryStateCommitSchema;
+declare const runtimeSchema_ReducerRuntimeStateSchema: typeof ReducerRuntimeStateSchema;
+declare const runtimeSchema_ReducerSessionStateSchema: typeof ReducerSessionStateSchema;
+declare const runtimeSchema_RngDrawSchema: typeof RngDrawSchema;
+declare const runtimeSchema_RngOperationParameterSchema: typeof RngOperationParameterSchema;
+declare const runtimeSchema_RngOperationSchema: typeof RngOperationSchema;
+declare const runtimeSchema_RngStateSchema: typeof RngStateSchema;
+declare const runtimeSchema_RuntimePendingInteractionSchema: typeof RuntimePendingInteractionSchema;
+declare const runtimeSchema_RuntimeSimultaneousCurrentSchema: typeof RuntimeSimultaneousCurrentSchema;
+declare const runtimeSchema_RuntimeSimultaneousStateSchema: typeof RuntimeSimultaneousStateSchema;
+declare const runtimeSchema_RuntimeSimultaneousSubmissionSchema: typeof RuntimeSimultaneousSubmissionSchema;
+declare const runtimeSchema_SchedulerContinuationDependencySchema: typeof SchedulerContinuationDependencySchema;
+declare const runtimeSchema_SchedulerFlowAuthorityProjectionSchema: typeof SchedulerFlowAuthorityProjectionSchema;
+declare const runtimeSchema_SeatProjectionBundleSchema: typeof SeatProjectionBundleSchema;
+declare const runtimeSchema_SeatProjectionSchema: typeof SeatProjectionSchema;
+declare const runtimeSchema_SimultaneousPhaseProjectionSchema: typeof SimultaneousPhaseProjectionSchema;
+declare const runtimeSchema_SystemActionEventSchema: typeof SystemActionEventSchema;
+declare const runtimeSchema_TransitionRecordSchema: typeof TransitionRecordSchema;
+declare namespace runtimeSchema {
+  export { runtimeSchema_AuthoredViewSchema as AuthoredViewSchema, runtimeSchema_BoardStaticProjectionSchema as BoardStaticProjectionSchema, runtimeSchema_DispatchRequestSchema as DispatchRequestSchema, runtimeSchema_DispatchResultAcceptSchema as DispatchResultAcceptSchema, runtimeSchema_DispatchResultRejectSchema as DispatchResultRejectSchema, runtimeSchema_DispatchResultSchema as DispatchResultSchema, runtimeSchema_DispatchTraceAcceptedClientInputSchema as DispatchTraceAcceptedClientInputSchema, runtimeSchema_DispatchTracePhaseEnteredSchema as DispatchTracePhaseEnteredSchema, runtimeSchema_DispatchTraceRngConsumptionSchema as DispatchTraceRngConsumptionSchema, runtimeSchema_DispatchTraceSchema as DispatchTraceSchema, runtimeSchema_GameEventDetailSchema as GameEventDetailSchema, runtimeSchema_GameEventSchema as GameEventSchema, runtimeSchema_GameInputCancelSchema as GameInputCancelSchema, runtimeSchema_GameInputInteractionSchema as GameInputInteractionSchema, runtimeSchema_GameInputSchema as GameInputSchema, runtimeSchema_GameOutcomeReasonSchema as GameOutcomeReasonSchema, runtimeSchema_GameOutcomeSchema as GameOutcomeSchema, runtimeSchema_InitializeRequestSchema as InitializeRequestSchema, runtimeSchema_InitializeResultSchema as InitializeResultSchema, runtimeSchema_OutcomeResultSchema as OutcomeResultSchema, runtimeSchema_OutcomeScoreComponentSchema as OutcomeScoreComponentSchema, runtimeSchema_OutcomeStandingSchema as OutcomeStandingSchema, runtimeSchema_OutcomeTieBreakSchema as OutcomeTieBreakSchema, runtimeSchema_ProjectRequestSchema as ProjectRequestSchema, runtimeSchema_ProjectionTimingMetadataSchema as ProjectionTimingMetadataSchema, runtimeSchema_ReducerContractVersionSchema as ReducerContractVersionSchema, runtimeSchema_ReducerDomainStateSchema as ReducerDomainStateSchema, runtimeSchema_ReducerFlowStateSchema as ReducerFlowStateSchema, runtimeSchema_ReducerRuntimeLogEntryAcceptedClientInputSchema as ReducerRuntimeLogEntryAcceptedClientInputSchema, runtimeSchema_ReducerRuntimeLogEntryPhaseEnteredSchema as ReducerRuntimeLogEntryPhaseEnteredSchema, runtimeSchema_ReducerRuntimeLogEntryRngConsumptionSchema as ReducerRuntimeLogEntryRngConsumptionSchema, runtimeSchema_ReducerRuntimeLogEntrySchema as ReducerRuntimeLogEntrySchema, runtimeSchema_ReducerRuntimeLogEntryStateCommitSchema as ReducerRuntimeLogEntryStateCommitSchema, runtimeSchema_ReducerRuntimeStateSchema as ReducerRuntimeStateSchema, runtimeSchema_ReducerSessionStateSchema as ReducerSessionStateSchema, runtimeSchema_RngDrawSchema as RngDrawSchema, runtimeSchema_RngOperationParameterSchema as RngOperationParameterSchema, runtimeSchema_RngOperationSchema as RngOperationSchema, runtimeSchema_RngStateSchema as RngStateSchema, runtimeSchema_RuntimePendingInteractionSchema as RuntimePendingInteractionSchema, runtimeSchema_RuntimeSimultaneousCurrentSchema as RuntimeSimultaneousCurrentSchema, runtimeSchema_RuntimeSimultaneousStateSchema as RuntimeSimultaneousStateSchema, runtimeSchema_RuntimeSimultaneousSubmissionSchema as RuntimeSimultaneousSubmissionSchema, runtimeSchema_SchedulerContinuationDependencySchema as SchedulerContinuationDependencySchema, runtimeSchema_SchedulerFlowAuthorityProjectionSchema as SchedulerFlowAuthorityProjectionSchema, runtimeSchema_SeatProjectionBundleSchema as SeatProjectionBundleSchema, runtimeSchema_SeatProjectionSchema as SeatProjectionSchema, runtimeSchema_SimultaneousPhaseProjectionSchema as SimultaneousPhaseProjectionSchema, runtimeSchema_SystemActionEventSchema as SystemActionEventSchema, runtimeSchema_TransitionRecordSchema as TransitionRecordSchema };
+}
+
+type ReducerContractVersion = z.infer<typeof ReducerContractVersionSchema>;
+type RngOperationParameter = z.infer<typeof RngOperationParameterSchema>;
+type RngOperation = z.infer<typeof RngOperationSchema>;
+type RngDraw = z.infer<typeof RngDrawSchema>;
+type RngState = z.infer<typeof RngStateSchema>;
+type ReducerFlowState = z.infer<typeof ReducerFlowStateSchema>;
+type RuntimeSimultaneousSubmission$1 = z.infer<typeof RuntimeSimultaneousSubmissionSchema>;
+type RuntimeSimultaneousCurrent = z.infer<typeof RuntimeSimultaneousCurrentSchema>;
+type RuntimeSimultaneousState$1 = z.infer<typeof RuntimeSimultaneousStateSchema>;
+type TransitionRecord = z.infer<typeof TransitionRecordSchema>;
+type ReducerRuntimeState = z.infer<typeof ReducerRuntimeStateSchema>;
+type ReducerDomainState = z.infer<typeof ReducerDomainStateSchema>;
+type ReducerSessionState = z.infer<typeof ReducerSessionStateSchema>;
+type GameInputInteraction = z.infer<typeof GameInputInteractionSchema>;
+type GameInput = z.infer<typeof GameInputSchema>;
+type GameOutcomeReason = z.infer<typeof GameOutcomeReasonSchema>;
+type OutcomeResult$1 = z.infer<typeof OutcomeResultSchema>;
+type OutcomeScoreComponent$1 = z.infer<typeof OutcomeScoreComponentSchema>;
+type OutcomeTieBreak$1 = z.infer<typeof OutcomeTieBreakSchema>;
+type OutcomeStanding$1 = z.infer<typeof OutcomeStandingSchema>;
+type GameOutcome$1 = z.infer<typeof GameOutcomeSchema>;
+type GameEventDetail$1 = z.infer<typeof GameEventDetailSchema>;
+type SystemActionEvent$1 = z.infer<typeof SystemActionEventSchema>;
+type GameEvent$1 = z.infer<typeof GameEventSchema>;
+type InitializeResult = z.infer<typeof InitializeResultSchema>;
+type InitializeRequest = z.infer<typeof InitializeRequestSchema>;
+type DispatchRequest = z.infer<typeof DispatchRequestSchema>;
+type DispatchTraceAcceptedClientInput = z.infer<typeof DispatchTraceAcceptedClientInputSchema>;
+type DispatchTracePhaseEntered = z.infer<typeof DispatchTracePhaseEnteredSchema>;
+type DispatchTraceRngConsumption = z.infer<typeof DispatchTraceRngConsumptionSchema>;
+type DispatchTrace = z.infer<typeof DispatchTraceSchema>;
+type DispatchResultReject = z.infer<typeof DispatchResultRejectSchema>;
+type DispatchResultAccept = z.infer<typeof DispatchResultAcceptSchema>;
+type DispatchResult = z.infer<typeof DispatchResultSchema>;
+type ReducerRuntimeLogEntryAcceptedClientInput = z.infer<typeof ReducerRuntimeLogEntryAcceptedClientInputSchema>;
+type ReducerRuntimeLogEntryPhaseEntered = z.infer<typeof ReducerRuntimeLogEntryPhaseEnteredSchema>;
+type ReducerRuntimeLogEntryRngConsumption = z.infer<typeof ReducerRuntimeLogEntryRngConsumptionSchema>;
+type ReducerRuntimeLogEntryStateCommit = z.infer<typeof ReducerRuntimeLogEntryStateCommitSchema>;
+type ReducerRuntimeLogEntry = z.infer<typeof ReducerRuntimeLogEntrySchema>;
+type SeatProjection = z.infer<typeof SeatProjectionSchema>;
+type SimultaneousPhaseProjection = z.infer<typeof SimultaneousPhaseProjectionSchema>;
+type SchedulerContinuationDependency = z.infer<typeof SchedulerContinuationDependencySchema>;
+type SchedulerFlowAuthorityProjection = z.infer<typeof SchedulerFlowAuthorityProjectionSchema>;
+type ProjectionTimingMetadata = z.infer<typeof ProjectionTimingMetadataSchema>;
+type SeatProjectionBundle = z.infer<typeof SeatProjectionBundleSchema>;
+type ProjectRequest = z.infer<typeof ProjectRequestSchema>;
+type BoardStaticProjection = z.infer<typeof BoardStaticProjectionSchema>;
+type RuntimePendingInteraction = z.infer<typeof RuntimePendingInteractionSchema>;
+type GameInputCancel = z.infer<typeof GameInputCancelSchema>;
+type AuthoredView = z.infer<typeof AuthoredViewSchema>;
+
+type runtimeTypes_AuthoredView = AuthoredView;
+type runtimeTypes_BoardStaticProjection = BoardStaticProjection;
+type runtimeTypes_DispatchRequest = DispatchRequest;
+type runtimeTypes_DispatchResult = DispatchResult;
+type runtimeTypes_DispatchResultAccept = DispatchResultAccept;
+type runtimeTypes_DispatchResultReject = DispatchResultReject;
+type runtimeTypes_DispatchTrace = DispatchTrace;
+type runtimeTypes_DispatchTraceAcceptedClientInput = DispatchTraceAcceptedClientInput;
+type runtimeTypes_DispatchTracePhaseEntered = DispatchTracePhaseEntered;
+type runtimeTypes_DispatchTraceRngConsumption = DispatchTraceRngConsumption;
+type runtimeTypes_GameInput = GameInput;
+type runtimeTypes_GameInputCancel = GameInputCancel;
+type runtimeTypes_GameInputInteraction = GameInputInteraction;
+type runtimeTypes_GameOutcomeReason = GameOutcomeReason;
+type runtimeTypes_InitializeRequest = InitializeRequest;
+type runtimeTypes_InitializeResult = InitializeResult;
+type runtimeTypes_ProjectRequest = ProjectRequest;
+type runtimeTypes_ProjectionTimingMetadata = ProjectionTimingMetadata;
+type runtimeTypes_ReducerContractVersion = ReducerContractVersion;
+type runtimeTypes_ReducerDomainState = ReducerDomainState;
+type runtimeTypes_ReducerFlowState = ReducerFlowState;
+type runtimeTypes_ReducerRuntimeLogEntry = ReducerRuntimeLogEntry;
+type runtimeTypes_ReducerRuntimeLogEntryAcceptedClientInput = ReducerRuntimeLogEntryAcceptedClientInput;
+type runtimeTypes_ReducerRuntimeLogEntryPhaseEntered = ReducerRuntimeLogEntryPhaseEntered;
+type runtimeTypes_ReducerRuntimeLogEntryRngConsumption = ReducerRuntimeLogEntryRngConsumption;
+type runtimeTypes_ReducerRuntimeLogEntryStateCommit = ReducerRuntimeLogEntryStateCommit;
+type runtimeTypes_ReducerRuntimeState = ReducerRuntimeState;
+type runtimeTypes_ReducerSessionState = ReducerSessionState;
+type runtimeTypes_RngDraw = RngDraw;
+type runtimeTypes_RngOperation = RngOperation;
+type runtimeTypes_RngOperationParameter = RngOperationParameter;
+type runtimeTypes_RngState = RngState;
+type runtimeTypes_RuntimePendingInteraction = RuntimePendingInteraction;
+type runtimeTypes_RuntimeSimultaneousCurrent = RuntimeSimultaneousCurrent;
+type runtimeTypes_SchedulerContinuationDependency = SchedulerContinuationDependency;
+type runtimeTypes_SchedulerFlowAuthorityProjection = SchedulerFlowAuthorityProjection;
+type runtimeTypes_SeatProjection = SeatProjection;
+type runtimeTypes_SeatProjectionBundle = SeatProjectionBundle;
+type runtimeTypes_SimultaneousPhaseProjection = SimultaneousPhaseProjection;
+type runtimeTypes_TransitionRecord = TransitionRecord;
+declare namespace runtimeTypes {
+  export type { runtimeTypes_AuthoredView as AuthoredView, runtimeTypes_BoardStaticProjection as BoardStaticProjection, runtimeTypes_DispatchRequest as DispatchRequest, runtimeTypes_DispatchResult as DispatchResult, runtimeTypes_DispatchResultAccept as DispatchResultAccept, runtimeTypes_DispatchResultReject as DispatchResultReject, runtimeTypes_DispatchTrace as DispatchTrace, runtimeTypes_DispatchTraceAcceptedClientInput as DispatchTraceAcceptedClientInput, runtimeTypes_DispatchTracePhaseEntered as DispatchTracePhaseEntered, runtimeTypes_DispatchTraceRngConsumption as DispatchTraceRngConsumption, GameEvent$1 as GameEvent, GameEventDetail$1 as GameEventDetail, runtimeTypes_GameInput as GameInput, runtimeTypes_GameInputCancel as GameInputCancel, runtimeTypes_GameInputInteraction as GameInputInteraction, GameOutcome$1 as GameOutcome, runtimeTypes_GameOutcomeReason as GameOutcomeReason, runtimeTypes_InitializeRequest as InitializeRequest, runtimeTypes_InitializeResult as InitializeResult, OutcomeResult$1 as OutcomeResult, OutcomeScoreComponent$1 as OutcomeScoreComponent, OutcomeStanding$1 as OutcomeStanding, OutcomeTieBreak$1 as OutcomeTieBreak, runtimeTypes_ProjectRequest as ProjectRequest, runtimeTypes_ProjectionTimingMetadata as ProjectionTimingMetadata, runtimeTypes_ReducerContractVersion as ReducerContractVersion, runtimeTypes_ReducerDomainState as ReducerDomainState, runtimeTypes_ReducerFlowState as ReducerFlowState, runtimeTypes_ReducerRuntimeLogEntry as ReducerRuntimeLogEntry, runtimeTypes_ReducerRuntimeLogEntryAcceptedClientInput as ReducerRuntimeLogEntryAcceptedClientInput, runtimeTypes_ReducerRuntimeLogEntryPhaseEntered as ReducerRuntimeLogEntryPhaseEntered, runtimeTypes_ReducerRuntimeLogEntryRngConsumption as ReducerRuntimeLogEntryRngConsumption, runtimeTypes_ReducerRuntimeLogEntryStateCommit as ReducerRuntimeLogEntryStateCommit, runtimeTypes_ReducerRuntimeState as ReducerRuntimeState, runtimeTypes_ReducerSessionState as ReducerSessionState, runtimeTypes_RngDraw as RngDraw, runtimeTypes_RngOperation as RngOperation, runtimeTypes_RngOperationParameter as RngOperationParameter, runtimeTypes_RngState as RngState, runtimeTypes_RuntimePendingInteraction as RuntimePendingInteraction, runtimeTypes_RuntimeSimultaneousCurrent as RuntimeSimultaneousCurrent, RuntimeSimultaneousState$1 as RuntimeSimultaneousState, RuntimeSimultaneousSubmission$1 as RuntimeSimultaneousSubmission, runtimeTypes_SchedulerContinuationDependency as SchedulerContinuationDependency, runtimeTypes_SchedulerFlowAuthorityProjection as SchedulerFlowAuthorityProjection, runtimeTypes_SeatProjection as SeatProjection, runtimeTypes_SeatProjectionBundle as SeatProjectionBundle, runtimeTypes_SimultaneousPhaseProjection as SimultaneousPhaseProjection, SystemActionEvent$1 as SystemActionEvent, runtimeTypes_TransitionRecord as TransitionRecord };
+}
+
+type GameEventDetail = Readonly<GameEventDetail$1>;
+type SystemActionEvent = Readonly<Omit<SystemActionEvent$1, "details">> & {
+    readonly details?: readonly GameEventDetail[];
+};
+/** Public display information only. Never include hidden cards, resources, or private state. */
+type GameEvent = SystemActionEvent;
+type OutcomeResult = OutcomeResult$1;
+type OutcomeScoreComponent = Readonly<OutcomeScoreComponent$1>;
+type OutcomeTieBreak = Readonly<OutcomeTieBreak$1>;
+type OutcomeStanding<Player extends string = string> = Readonly<Omit<OutcomeStanding$1, "playerId" | "scoreBreakdown" | "tieBreaks">> & {
+    readonly playerId: Player;
+    readonly scoreBreakdown?: readonly OutcomeScoreComponent[];
+    readonly tieBreaks?: readonly OutcomeTieBreak[];
+};
+type GameOutcome<Player extends string = string> = {
+    readonly reason: Readonly<GameOutcome$1["reason"]>;
+    readonly standings: readonly OutcomeStanding<Player>[];
+};
+
+type RuntimePhaseState = object;
+type PhaseAccessor<PhaseStates extends Record<string, object>, CurrentPhase extends keyof PhaseStates & string = keyof PhaseStates & string> = {
+    get<PhaseName extends keyof PhaseStates & string>(phaseName: PhaseName): CurrentPhase extends PhaseName ? PhaseStates[PhaseName] : PhaseStates[PhaseName] | null;
+};
+type FlowState<PhaseName extends string, PlayerId extends string> = {
+    currentPhase: PhaseName;
+    turn: number;
+    round: number;
+    activePlayers: PlayerId[];
+};
+type RuntimeRngState = {
+    seed?: number | null;
+    cursor: number;
+    trace: string[];
+    draws: RuntimeRngDraw[];
+};
+type RuntimeRngOperationParameter = string | number | boolean;
+type RuntimeRngOperation = {
+    kind: string;
+    parameters: Record<string, RuntimeRngOperationParameter>;
+};
+/**
+ * Public, persisted identity for one deterministic RNG cursor advance.
+ *
+ * Sampled values deliberately remain absent. Their consequences are exposed
+ * only through the normal public/player projections.
+ */
+type RuntimeRngDraw = {
+    index: number;
+    cursorBefore: number;
+    cursorAfter: number;
+    operation: RuntimeRngOperation;
+};
+type RuntimeSimultaneousSubmission = {
+    interactionId: string;
+    params: RuntimePayload;
+};
+type RuntimeSimultaneousState<PhaseName extends string, PlayerId extends string> = {
+    current: {
+        phaseName: PhaseName;
+        actors: PlayerId[];
+        submissions: Partial<Record<PlayerId, RuntimeSimultaneousSubmission>>;
+    } | null;
+};
+type RuntimeState<PhaseName extends string, PlayerId extends string, Options extends RuntimeRecord = RuntimeRecord> = {
+    /** Latest accepted public display-event batch; snapshot data, not history. */
+    events: readonly GameEvent[];
+    rng: RuntimeRngState;
+    options: Options;
+    simultaneous: RuntimeSimultaneousState<PhaseName, PlayerId>;
+    pending: Partial<Record<PlayerId, {
+        phaseName: PhaseName;
+        interactionId: string;
+        values: RuntimePayload[];
+    }>>;
+    lastTransition: {
+        from: PhaseName;
+        to: PhaseName;
+    } | null;
+};
+type ReducerRuntimeStateForState<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Options extends RuntimeRecord = RuntimeRecord> = RuntimeState<PhaseNameOfState<State>, PlayerIdOfState<State>, Options>;
+type ReducerGameState<Table extends RuntimeTableRecord, PublicState extends object, PrivateState extends object, HiddenState extends object, PhaseState extends RuntimePhaseState, PhaseName extends string, PhaseStates extends Record<PhaseName, object> = Record<PhaseName, PhaseState>> = {
+    table: Table;
+    publicState: PublicState;
+    privateState: Record<PlayerIdOfTable<Table>, PrivateState>;
+    hiddenState: HiddenState;
+    flow: FlowState<PhaseName, PlayerIdOfTable<Table>>;
+    phase: PhaseState & PhaseAccessor<PhaseStates>;
+};
+type ReducerValidationResult = {
+    valid: true;
+} | {
+    valid: false;
+    errorCode: string;
+    message?: string;
+};
+type ReducerReject = {
+    type: "reject";
+    errorCode: string;
+    message?: string;
+};
+
+type ReducerAccept<State> = {
+    type: "accept";
+    state: State;
+    transition?: PhaseNameOfState<State>;
+    events?: readonly GameEvent[];
+    terminal?: GameOutcome<PlayerIdOfState<State>>;
+};
+type ReducerResult<State> = ReducerAccept<State> | ReducerReject;
+
+type RotatePlayerZoneArgs<State extends {
+    table: RuntimeTableRecord;
+}, ZoneId extends PlayerZoneIdOfTable<TableOfState<State>> = PlayerZoneIdOfTable<TableOfState<State>>, PlayerId extends PlayerIdOfTable<TableOfState<State>> = PlayerIdOfTable<TableOfState<State>>> = {
+    zoneId: ZoneId;
+    direction: "left" | "right";
+    players?: readonly PlayerId[];
+    cardIdsByPlayer?: Partial<Record<PlayerId, readonly CardIdOfTable<TableOfState<State>>[]>>;
+    position?: "top" | "bottom";
+};
+/**
+ * Shallow patch or functional updater for one state slice. The updater is a
+ * method-style callable so a transaction over a phase-scoped state stays
+ * assignable to one over the base game state; a plain function type would be
+ * invariant in `T` under `strictFunctionTypes`.
+ */
+type StatePatch<T> = Partial<T> | {
+    update(prev: T): T;
+}["update"];
+/**
+ * Mutations available on a transaction-owned draft.
+ */
+interface TransactionMutations<State extends {
+    table: RuntimeTableRecord;
+}> {
+    /** Set the list of players whose turn is currently active. */
+    setActivePlayers(activePlayers: ReadonlyArray<PlayerIdOfState<State>>): State;
+    /**
+     * Advance `flow.activePlayers` to the single next seat in `playerOrder`.
+     *
+     * Uses `state.flow.activePlayers[0]` as the current seat (or the first
+     * seat in `playerOrder` when `activePlayers` is empty) and sets
+     * `activePlayers` to `[q.player.nextInOrder(current)]`. No-op when the
+     * player order is empty.
+     */
+    advanceActivePlayer(): State;
+    /**
+     * Update the current phase's local state.
+     *
+     * Accepts either a `Partial<PhaseState>` which is shallow-merged into the
+     * previous value, or a functional updater `(prev) => next` which must
+     * return a complete `PhaseState`.
+     */
+    patchPhaseState(patch: StatePatch<PhaseStateOfState<State>>): State;
+    /**
+     * Update `state.publicState`.
+     *
+     * Accepts either a `Partial<PublicState>` which is shallow-merged into the
+     * previous value, or a functional updater `(prev) => next` which must
+     * return a complete `PublicState`.
+     */
+    patchPublicState(patch: StatePatch<PublicStateOfState<State>>): State;
+    /**
+     * Update `state.hiddenState`.
+     *
+     * Accepts either a `Partial<HiddenState>` or a functional updater.
+     */
+    patchHiddenState(patch: StatePatch<HiddenStateOfState<State>>): State;
+    /**
+     * Update a single player's entry in `state.privateState`.
+     *
+     * Accepts either a `Partial<PrivateState>` or a functional updater.
+     */
+    patchPlayerPrivateState(args: {
+        playerId: PlayerIdOfState<State>;
+        patch: StatePatch<PrivateStateOfState<State>>;
+    }): State;
+    /**
+     * Append a card to a shared zone (deck). Defaults to placing the card at the
+     * bottom; pass `position: "top"` for top-of-deck placement (e.g. Bureaucrat-style).
+     */
+    addCardToSharedZone<DeckId extends SharedZoneIdOfTable<TableOfState<State>>>(args: {
+        deckId: DeckId;
+        cardId: DeckCardsOfTable<TableOfState<State>, DeckId>[number];
+        playedBy?: PlayerIdOfTable<TableOfState<State>> | null;
+        position?: "top" | "bottom";
+    }): State;
+    /** Remove a card from a shared zone (deck). */
+    removeCardFromSharedZone<DeckId extends DeckIdOfTable<TableOfState<State>>>(args: {
+        deckId: DeckId;
+        cardId: DeckCardsOfTable<TableOfState<State>, DeckId>[number];
+    }): State;
+    /**
+     * Move a card between two shared zones (decks). Defaults to placing the card
+     * at the bottom of the destination; pass `position: "top"` for top placement.
+     */
+    moveCardBetweenSharedZones<FromZoneId extends SharedZoneIdOfTable<TableOfState<State>>, ToZoneId extends SharedZoneIdOfTable<TableOfState<State>>>(args: {
+        fromZoneId: FromZoneId;
+        toZoneId: ToZoneId;
+        cardId: DeckCardsOfTable<TableOfState<State>, FromZoneId>[number];
+        playedBy?: PlayerIdOfTable<TableOfState<State>> | null;
+        position?: "top" | "bottom";
+    }): State;
+    /**
+     * Draw the top `count` cards from one perPlayer zone into another for the
+     * same player (e.g. deck → hand at the start of a turn). Companion to
+     * {@link deal} for the perPlayer → perPlayer case. Stops
+     * silently if the source runs out before `count` is reached.
+     */
+    dealCardsBetweenPlayerZones<FromZoneId extends PlayerZoneIdOfTable<TableOfState<State>>, ToZoneId extends PlayerZoneIdOfTable<TableOfState<State>>, PlayerId extends PlayerIdOfTable<TableOfState<State>>>(args: {
+        playerId: PlayerId;
+        fromZoneId: FromZoneId;
+        toZoneId: ToZoneId;
+        count: number;
+    }): State;
+    /**
+     * Move a card between two perPlayer zones owned by the same player (e.g.
+     * hand → in-play → discard). Owner is preserved; visibility is recomputed
+     * from the destination zone.
+     */
+    moveCardBetweenPlayerZones<FromZoneId extends PlayerZoneIdOfTable<TableOfState<State>>, ToZoneId extends PlayerZoneIdOfTable<TableOfState<State>>, PlayerId extends PlayerIdOfTable<TableOfState<State>>>(args: {
+        playerId: PlayerId;
+        fromZoneId: FromZoneId;
+        toZoneId: ToZoneId;
+        cardId: CompatibleCardIdForTwoPlayerZones<TableOfState<State>, FromZoneId, ToZoneId>;
+        position?: "top" | "bottom";
+    }): State;
+    /**
+     * Move a card from a player zone (hand) to a shared zone (deck). Defaults to
+     * placing the card at the bottom; pass `position: "top"` to topdeck.
+     */
+    moveCardFromPlayerZoneToSharedZone<FromZoneId extends PlayerZoneIdOfTable<TableOfState<State>>, ToZoneId extends SharedZoneIdOfTable<TableOfState<State>>, PlayerId extends PlayerIdOfTable<TableOfState<State>>>(args: {
+        playerId: PlayerId;
+        fromZoneId: FromZoneId;
+        toZoneId: ToZoneId;
+        cardId: CompatibleCardIdForHandAndDeck<TableOfState<State>, FromZoneId, ToZoneId>;
+        playedBy?: PlayerIdOfTable<TableOfState<State>> | null;
+        position?: "top" | "bottom";
+    }): State;
+    /**
+     * Move a named card from a shared zone (supply pile, deck) to a perPlayer
+     * zone (e.g. discard). The "gain" verb in deck-builders. Distinct from
+     * {@link deal}, which draws unspecified top-N cards from a
+     * deck. Owner flips to the receiving player; visibility is recomputed.
+     */
+    moveCardFromSharedZoneToPlayerZone<FromZoneId extends SharedZoneIdOfTable<TableOfState<State>>, ToZoneId extends PlayerZoneIdOfTable<TableOfState<State>>, PlayerId extends PlayerIdOfTable<TableOfState<State>>>(args: {
+        playerId: PlayerId;
+        fromZoneId: FromZoneId;
+        toZoneId: ToZoneId;
+        cardId: CompatibleCardIdForHandAndDeck<TableOfState<State>, ToZoneId, FromZoneId>;
+        position?: "top" | "bottom";
+    }): State;
+    /**
+     * Deal the top `count` cards from a shared deck into a player's hand zone.
+     *
+     * Dealing does not consume RNG. Shuffle first with `tx.shuffle({ zoneId })`
+     * when the deck needs a random order, then call `tx.deal(...)`.
+     */
+    deal<FromZoneId extends DeckIdOfTable<TableOfState<State>>, PlayerId extends PlayerIdOfTable<TableOfState<State>>, ToZoneId extends CompatibleHandIdForDeck<TableOfState<State>, FromZoneId> & HandIdOfTable<TableOfState<State>>>(args: {
+        fromZoneId: FromZoneId;
+        playerId: PlayerId;
+        toZoneId: ToZoneId;
+        count: number;
+    }): State;
+    /**
+     * Atomically rotate cards in a per-player zone around the table.
+     *
+     * Defaults to rotating every card currently in `zoneId` for every player in
+     * turn order. Pass `players` to use a smaller explicit order, or
+     * `cardIdsByPlayer` to rotate only selected cards such as Hearts passes.
+     */
+    rotatePlayerZone<ZoneId extends PlayerZoneIdOfTable<TableOfState<State>>, PlayerId extends PlayerIdOfTable<TableOfState<State>>>(args: RotatePlayerZoneArgs<State, ZoneId, PlayerId>): State;
+    /** Move a component onto a board space. */
+    moveComponentToSpace<BoardId extends BoardIdOfTable<TableOfState<State>>, SpaceId extends SpaceIdOfTable<TableOfState<State>, BoardId>, ComponentId extends ComponentIdOfTable<TableOfState<State>>>(args: {
+        componentId: ComponentId;
+        boardId: BoardId;
+        spaceId: SpaceId;
+    }): State;
+    /** Move a component into a board container. */
+    moveComponentToContainer<BoardId extends BoardIdOfTable<TableOfState<State>>, ContainerId extends BoardContainerIdOfTable<TableOfState<State>, BoardId>, ComponentId extends ComponentIdOfTable<TableOfState<State>>>(args: {
+        componentId: ComponentId;
+        boardId: BoardId;
+        containerId: ContainerId;
+    }): State;
+    /** Move a component onto a tiled board edge. */
+    moveComponentToEdge<BoardId extends TiledBoardIdOfTable<TableOfState<State>>, EdgeId extends TiledEdgeIdOfTable<TableOfState<State>, BoardId>, ComponentId extends ComponentIdOfTable<TableOfState<State>>>(args: {
+        componentId: ComponentId;
+        boardId: BoardId;
+        edgeId: EdgeId;
+    }): State;
+    /** Move a component onto a tiled board vertex. */
+    moveComponentToVertex<BoardId extends TiledBoardIdOfTable<TableOfState<State>>, VertexId extends TiledVertexIdOfTable<TableOfState<State>, BoardId>, ComponentId extends ComponentIdOfTable<TableOfState<State>>>(args: {
+        componentId: ComponentId;
+        boardId: BoardId;
+        vertexId: VertexId;
+    }): State;
+    /** Move a component back to the detached pool. */
+    moveComponentToDetached<ComponentId extends ComponentIdOfTable<TableOfState<State>>>(args: {
+        componentId: ComponentId;
+    }): State;
+    /**
+     * Credit the specified resources to a player.
+     *
+     * Amounts must be non-negative; use {@link spendResources} for deductions
+     * so that affordability is checked explicitly.
+     *
+     *     tx.addResources({ playerId, amounts: { wood: 1, brick: 1 } });
+     */
+    addResources(args: {
+        playerId: PlayerIdOfTable<TableOfState<State>>;
+        amounts: ResourceAmountsOfTable<TableOfState<State>>;
+    }): State;
+    /**
+     * Debit the specified resources from a player.
+     *
+     * Throws when the player cannot afford the full cost — gate with
+     * `q.player.canAfford(...)` in your `validate` step before invoking.
+     *
+     *     tx.spendResources({ playerId, amounts: COST_DEV_CARD });
+     *     tx.deal({ ... });
+     */
+    spendResources(args: {
+        playerId: PlayerIdOfTable<TableOfState<State>>;
+        amounts: ResourceAmountsOfTable<TableOfState<State>>;
+    }): State;
+    /**
+     * Transfer the specified resources from one player to another.
+     *
+     * Throws when the source cannot afford the full amount. On success the
+     * destination gains exactly what the source loses.
+     */
+    transferResources(args: {
+        fromPlayerId: PlayerIdOfTable<TableOfState<State>>;
+        toPlayerId: PlayerIdOfTable<TableOfState<State>>;
+        amounts: ResourceAmountsOfTable<TableOfState<State>>;
+    }): State;
+    /**
+     * Overwrite a single resource balance for a player. Prefer
+     * {@link addResources} / {@link spendResources} — use this only when the
+     * new balance is an absolute (e.g. scripted setup).
+     */
+    setResource(args: {
+        playerId: PlayerIdOfTable<TableOfState<State>>;
+        resourceId: ResourceIdOfTable<TableOfState<State>>;
+        amount: number;
+    }): State;
+}
+
+type IsAny<Value> = 0 extends 1 & Value ? true : false;
+/** Phase names a transaction may transition to; `string` when state is erased. */
+type TransitionTarget<State> = IsAny<State> extends true ? string : PhaseNameOfState<State>;
+
+/**
+ * Result builders on the transaction. A mutation callback ends with one of
+ * these or with a bare `return` (accept the transaction as it stands).
+ */
+type ReducerTransactionOutcome<State extends {
+    table: RuntimeTableRecord;
+}, ErrorCode extends string = string> = {
+    /** Emit public display events for every seat. Private details belong in the authored seat view. */
+    emit(...events: GameEvent[]): void;
+    /** Accept with the current transaction state. Same as a bare `return`. */
+    accept(): ReducerAccept<State>;
+    /** Accept and move the flow to another declared phase. */
+    transition<To extends TransitionTarget<State>>(to: To): ReducerAccept<State>;
+    /**
+     * Accept and end the game with a terminal outcome. Pass `transition` to
+     * also move the flow to a terminal phase in the same result.
+     */
+    endGame(outcome: GameOutcome<PlayerIdOfState<State>>, options?: {
+        transition?: TransitionTarget<State>;
+    }): ReducerAccept<State>;
+    /** Reject with a declared error code. The transaction is discarded. */
+    reject(errorCode: ErrorCode, message?: string): ReducerReject;
+};
+type ReducerTransaction<State extends {
+    table: RuntimeTableRecord;
+}, ErrorCode extends string = string> = TransactionMutations<State> & ReducerTransactionOutcome<State, ErrorCode> & {
+    readonly state: State;
+    readonly q: TableQueriesOfState<State>;
+    roll(dieId: StringKeyOf<TableOfState<State>["dice"]>): number;
+    shuffle(args: {
+        zoneId: DeckIdOfState<State>;
+    } | {
+        zoneId: PlayerZoneIdOfState<State>;
+        playerId: PlayerIdOfTable<TableOfState<State>>;
+    }): void;
+};
+
+type PhaseEnterContext = {
+    event: "initialize" | "transition";
+};
+type BivariantCallback<Args, Result> = {
+    bivarianceHack(args: Args): Result;
+}["bivarianceHack"];
+type ActionContext<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = {
+    currentPhase: PhaseNameOfState<State>;
+    manifest: Manifest;
+    playerOrder: PlayerIdOfState<State>[];
+    activePlayers: PlayerIdOfState<State>[];
+    runtime: Omit<ReducerRuntimeStateForState<State>, "rng">;
+};
+type ValidationIssue<ErrorCode extends string = string> = {
+    errorCode: ErrorCode;
+    message?: string;
+};
+/**
+ * Read-only helpers available to every callback, including views, actor
+ * selectors, and interaction rules.
+ */
+type ReadHelpers<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}> = {
+    q: TableQueriesOfState<State>;
+};
+type RandomHelpers = {
+    integer(options: {
+        minInclusive: number;
+        maxInclusive: number;
+    }): number;
+    subset<const Values extends readonly unknown[]>(options: {
+        from: Values;
+        count: number;
+    }): readonly Values[number][];
+};
+/**
+ * Helpers available only to mutation callbacks (`enter`, `reduce`, `resolve`). `tx` is the open transaction: mutate through it and end the
+ * callback with a bare `return`, `tx.transition(...)`, `tx.endGame(...)`, or
+ * `tx.reject(...)`.
+ */
+type MutationHelpers<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, ErrorCode extends string = string> = {
+    tx: ReducerTransaction<State, ErrorCode>;
+    random: RandomHelpers;
+};
+type PhaseEnterArgs<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>, ErrorCode extends string = string> = ActionContext<State, Manifest> & ReadHelpers<State> & MutationHelpers<State, ErrorCode> & PhaseEnterContext & {
+    state: State;
+};
+type ActorSelectorArgs<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = ActionContext<State, Manifest> & ReadHelpers<State> & {
+    state: State;
+};
+type ActorSelection<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}> = PlayerIdOfState<State> | readonly PlayerIdOfState<State>[] | null | undefined;
+type ActorSelector<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = BivariantCallback<ActorSelectorArgs<State, Manifest>, ActorSelection<State>>;
+type ScopedPhaseState<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+    phase: object;
+}, PhaseState extends object> = State & {
+    phase: PhaseState;
+};
+
+type InputCollectorKind = InteractionInputDescriptor["kind"];
+type TargetKind = Extract<InputDomain, {
+    type: "cardTarget" | "boardTarget";
+}>["targetKind"];
+type BoardInputCollectorKind = Exclude<InputCollectorKind, "form" | "card" | "rng">;
+type CardInputCollectorMeta = {
+    readonly zoneId: string;
+    readonly zoneIds?: readonly string[];
+    readonly targetKind: "card";
+};
+type BoardInputCollectorMeta = {
+    readonly targetKind: TargetKind;
+    readonly boardId: string;
+    readonly valueKind?: "board-id" | "player-board-space";
+};
+type RngInputCollectorMeta = {
+    readonly rng: "d6";
+    readonly count: number;
+} | {
+    readonly rng: "coin";
+};
+type InputCollectorMetaForKind<Kind extends InputCollectorKind> = Kind extends "card" ? CardInputCollectorMeta : Kind extends BoardInputCollectorKind ? BoardInputCollectorMeta : Kind extends "rng" ? RngInputCollectorMeta : never;
+type InputSelectionDescriptor = InputSelection;
+type InputDomainDescriptor = InputDomain;
+type CardTargetDomainDescriptor = Extract<InputDomain, {
+    type: "cardTarget";
+}>;
+type BoardTargetDomainDescriptor = Extract<InputDomain, {
+    type: "boardTarget";
+}>;
+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>;
+/**
+ * Base state shape every collector is generic over. Collectors that need
+ * narrowed ids (card / player) use `PlayerIdOfState<State>` etc. to thread
+ * the manifest's branded types.
+ */
+type CollectorState = {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+};
+/**
+ * An input collector declares:
+ *   - a Zod schema for the parameter value the interaction expects. The
+ *     schema's `z.infer` feeds `ParamsOf<Collectors>`, so downstream
+ *     `reduce({ input: { params } })` sees branded ids from `cardInput` /
+ *     `boardInput` without a second declaration.
+ *   - an optional `eligibleTargets(state, playerId, q)` hook that the runtime
+ *     calls to enumerate server-authoritative, submit-ready values accepted by
+ *     the collector schema. The hook receives
+ *     the same `q` table-queries helper that `validate` / `reduce` see, so
+ *     board/card/form collectors can reuse whatever board-graph or zone
+ *     lookups they already use for validation without rebuilding them from
+ *     raw state. Each collector helper narrows the return type to its own
+ *     branded id (`CardIdOfState<State>` for `cardInput`, the caller-supplied
+ *     `Id extends string` for `boardInput.*`, etc.). At the generic interface
+ *     level we keep inputs weak (`CollectorState`, `string`, `unknown`) and
+ *     the return `ReadonlyArray<unknown>` so the runtime can treat all
+ *     collectors uniformly; per-helper signatures provide the author-facing
+ *     strong typing.
+ *   - optional `meta` for collector-kind-specific routing (e.g. `cardInput`
+ *     stores the `zoneId` the card must come from).
+ *
+ * Collectors without meaningful eligibility (`form`, `rng`) leave
+ * `eligibleTargets` undefined.
+ */
+type InputCollectorMetaSlot<Kind extends InputCollectorKind> = [
+    InputCollectorMetaForKind<Kind>
+] extends [never] ? {
+    readonly meta?: never;
+} : undefined extends InputCollectorMetaForKind<Kind> ? {
+    readonly meta?: Exclude<InputCollectorMetaForKind<Kind>, undefined>;
+} : {
+    readonly meta: InputCollectorMetaForKind<Kind>;
+};
+type InputCollectorBase<Schema extends SchemaLike<unknown> = SchemaLike<unknown>, State extends CollectorState = CollectorState, Kind extends InputCollectorKind = InputCollectorKind> = {
+    readonly kind: Kind;
+    readonly schema: Schema;
+    readonly defaultValue?: z.infer<Schema>;
+    readonly selection?: InputSelectionDescriptor;
+    readonly eligibleTargets?: (state: CollectorState, playerId: string, q: unknown) => ReadonlyArray<unknown>;
+    readonly validateTarget?: (state: CollectorState, playerId: string, q: unknown, targetId: unknown) => ValidationIssue | null | undefined;
+    readonly resolveDefaultValue?: (state: CollectorState, playerId: string, q: unknown, domain: InputDomainDescriptor) => z.infer<Schema> | undefined;
+} & (Kind extends "rng" ? {
+    readonly domain?: never;
+} : Kind extends "card" | BoardInputCollectorKind ? {
+    readonly domain: DomainProjector<InputDomainForCollectorKind<Kind>>;
+} : {
+    readonly domain?: DomainProjector<InputDomainForCollectorKind<Kind>>;
+}) & InputCollectorMetaSlot<Kind>;
+type InputCollector<Schema extends SchemaLike<unknown> = SchemaLike<unknown>, State extends CollectorState = CollectorState, Kind extends InputCollectorKind = InputCollectorKind> = Kind extends InputCollectorKind ? InputCollectorBase<Schema, State, Kind> : never;
+type ParamsOf<Collectors extends Record<string, InputCollector>> = {
+    [K in keyof Collectors]: Collectors[K] extends InputCollector<infer S> ? S extends SchemaLike<infer V> ? V : never : never;
+};
+type EngineSampledCollectorKeys<Collectors extends Record<string, InputCollector>> = {
+    [K in keyof Collectors]: Collectors[K] extends InputCollector & {
+        kind: "rng";
+    } ? K : never;
+}[keyof Collectors];
+type ClientCollectorValue<Collector> = Collector extends InputCollector<infer S> ? S extends SchemaLike<infer V> ? V : never : never;
+type ClientCollectorKeys<Collectors extends Record<string, InputCollector>> = Exclude<keyof Collectors, EngineSampledCollectorKeys<Collectors>>;
+type OptionalClientCollectorKeys<Collectors extends Record<string, InputCollector>> = {
+    [K in ClientCollectorKeys<Collectors>]: undefined extends ClientCollectorValue<Collectors[K]> ? K : never;
+}[ClientCollectorKeys<Collectors>];
+type ClientParamsOf<Collectors extends Record<string, InputCollector>> = {
+    [K in Exclude<ClientCollectorKeys<Collectors>, OptionalClientCollectorKeys<Collectors>>]: ClientCollectorValue<Collectors[K]>;
+} & {
+    [K in OptionalClientCollectorKeys<Collectors>]?: Exclude<ClientCollectorValue<Collectors[K]>, undefined>;
+};
+
+type StepCollector = Exclude<InputCollector, {
+    readonly kind: "rng";
+}>;
+type StepFactoryArgs<State extends CollectorState, Collectors extends Record<string, InputCollector>> = {
+    readonly state: State;
+    readonly playerId: PlayerIdOfState<State>;
+    readonly q: TableQueriesOfState<State>;
+    readonly selected: Readonly<ParamsOf<Collectors>>;
+};
+type InputStep<State extends CollectorState> = {
+    readonly key: string;
+    readonly resolve: {
+        invoke(args: StepFactoryArgs<State, Record<string, InputCollector>>): InputCollector;
+    }["invoke"];
+};
+type StepDefinition<Collectors extends Record<string, InputCollector>> = {
+    readonly collectors: Collectors;
+    readonly entries: readonly InputStep<CollectorState>[];
+};
+/** Ordered authoring definition. Only the committed values are persisted. */
+declare class InteractionSteps<State extends CollectorState, Collectors extends Record<string, InputCollector> = Record<never, never>> {
+    readonly entries: readonly InputStep<State>[];
+    readonly collectors: Collectors;
+    constructor(entries?: readonly InputStep<State>[]);
+    input<const Key extends string, Collector extends StepCollector>(key: Key extends keyof Collectors ? never : Key, collector: Collector | ((args: StepFactoryArgs<State, Collectors>) => Collector)): InteractionSteps<State, Collectors & Record<Key, Collector>>;
+}
+
+type InteractionReduceInput<Collectors extends Record<string, InputCollector>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}> = {
+    playerId: PlayerIdOfState<State>;
+    params: ParamsOf<Collectors>;
+};
+type InteractionValidateArgs<Collectors extends Record<string, InputCollector>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = ActionContext<State, Manifest> & ReadHelpers<State> & {
+    state: State;
+    input: {
+        playerId: PlayerIdOfState<State>;
+        params: ClientParamsOf<Collectors>;
+    };
+};
+type InteractionReduceArgs<Collectors extends Record<string, InputCollector>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>, ErrorCode extends string = string> = Omit<InteractionValidateArgs<Collectors, State, Manifest>, "input"> & {
+    input: InteractionReduceInput<Collectors, State>;
+} & MutationHelpers<State, ErrorCode>;
+type InteractionAvailabilityArgs<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = ActionContext<State, Manifest> & ReadHelpers<State> & {
+    state: State;
+    input: {
+        playerId: PlayerIdOfState<State>;
+    };
+};
+type InteractionRuleValidationResult<ErrorCode extends string = string> = boolean | string | ValidationIssue<ErrorCode> | null | undefined;
+type InteractionRule<Collectors extends Record<string, InputCollector> = Record<string, InputCollector>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+} = {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>> = ManifestContract<TableOfState<State>>, ErrorCode extends string = string> = {
+    /**
+     * Stable rule id for diagnostics and tests. Rule ids are author-owned and
+     * should be unique within one interaction.
+     */
+    id: string;
+    /**
+     * Error code used when the rule fails. The same code is used for descriptor
+     * availability and submit-time validation unless `validate` returns a
+     * specific ValidationIssue.
+     */
+    errorCode: ErrorCode;
+    message?: string;
+    /**
+     * Projection-time rule. Runs without submitted params, so UI descriptors can
+     * reflect action availability before the user clicks.
+     */
+    available?: BivariantCallback<InteractionAvailabilityArgs<State, Manifest>, boolean>;
+    /**
+     * Submit-time rule. Runs with parsed params and may return false, a concrete
+     * ValidationIssue, null, or undefined.
+     */
+    validate?: BivariantCallback<InteractionValidateArgs<Collectors, State, Manifest>, InteractionRuleValidationResult<ErrorCode>>;
+};
+type InteractionCommitPolicy = {
+    mode: "manual";
+} | {
+    mode: "autoWhenReady";
+};
+type HasManyInputCollector<Collectors extends Record<string, InputCollector>> = Extract<Collectors[keyof Collectors], {
+    readonly selection: {
+        readonly mode: "many";
+    };
+}> extends never ? false : true;
+type InteractionCommitPolicyFor<Collectors extends Record<string, InputCollector>> = HasManyInputCollector<Collectors> extends true ? {
+    mode: "manual";
+} : InteractionCommitPolicy;
+type InteractionPresentation = {
+    label: string;
+    help?: string;
+};
+type InteractionSpec<Collectors extends Record<string, InputCollector> = Record<string, InputCollector>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+} = {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>> = ManifestContract<TableOfState<State>>, ErrorCode extends string = string> = ({
+    inputs: Collectors;
+    steps?: never;
+} | {
+    inputs?: never;
+    steps: StepDefinition<Collectors>;
+}) & {
+    paramsSchema?: SchemaLike<ClientParamsOf<Collectors>>;
+    presentation?: InteractionPresentation;
+    /**
+     * Draft commit policy. The input collectors still own value shape and
+     * validation; this only controls whether a ready draft may be submitted
+     * automatically by SDK controls.
+     *
+     * Multi-value collectors created with `many(...)` are always manual draft
+     * interactions. They represent a selection set that should be committed by
+     * explicit player intent, so `autoWhenReady` is intentionally not accepted.
+     */
+    commit?: InteractionCommitPolicyFor<Collectors>;
+    /** Overrides the phase actor and limits input domains to the selected seats. */
+    actor?: ActorSelector<State, Manifest>;
+    errorCodes?: readonly ErrorCode[];
+    rules?: readonly InteractionRule<NoInfer<Collectors>, State, Manifest, ErrorCode>[];
+    reduce: BivariantCallback<InteractionReduceArgs<Collectors, State, Manifest, ErrorCode>, ReducerResult<State> | void>;
+};
+type AnyInteractionRule = Omit<InteractionRule<any, any, any, any>, "available" | "validate"> & {
+    available?: BivariantCallback<any, boolean>;
+    validate?: BivariantCallback<any, InteractionRuleValidationResult<any>>;
+};
+/**
+ * Type-safe erasure of {@link InteractionSpec} used by the runtime when it
+ * stores heterogeneous interactions in a single map. The collectors generic is
+ * intentionally erased with `any`: each authored interaction keeps a specific
+ * params shape, but phase registries need to store all of them together.
+ */
+type AnyInteractionSpec<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = Omit<InteractionSpec<any, State, Manifest, any>, "actor" | "rules" | "reduce"> & {
+    actor?: BivariantCallback<any, any>;
+    rules?: readonly AnyInteractionRule[];
+    reduce: BivariantCallback<any, ReducerResult<any> | void>;
+};
+type InteractionMap<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = Record<string, AnyInteractionSpec<State, Manifest>>;
+
+type SimultaneousSubmission<Collectors extends Record<string, InputCollector>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}> = {
+    playerId: PlayerIdOfState<State>;
+    params: ParamsOf<Collectors>;
+};
+type SimultaneousResolveArgs<Collectors extends Record<string, InputCollector>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>, ErrorCode extends string = string> = ActionContext<State, Manifest> & ReadHelpers<State> & MutationHelpers<State, ErrorCode> & {
+    state: State;
+    submissions: Record<PlayerIdOfState<State>, SimultaneousSubmission<Collectors, State>>;
+    submittedPlayerIds: PlayerIdOfState<State>[];
+    waitingPlayerIds: PlayerIdOfState<State>[];
+};
+type SimultaneousSubmitSpec<Collectors extends Record<string, InputCollector> = Record<string, InputCollector>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+} = {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>> = ManifestContract<TableOfState<State>>> = Omit<InteractionSpec<Collectors, State, Manifest>, "reduce"> & {
+    /**
+     * Optional compatibility slot for callers that reuse `defineInteraction`.
+     * The simultaneous phase barrier stores submissions and invokes the
+     * phase-level `resolve`; this per-submission reducer is intentionally
+     * ignored when present.
+     */
+    reduce?: InteractionSpec<Collectors, State, Manifest>["reduce"];
+};
+
+type PhaseDefinitionCommon<PhaseStateSchema extends SchemaLike<object>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+    phase: object;
+}, Manifest extends ManifestContract<TableOfState<State>>, ErrorCode extends string = string, Options extends RuntimeRecord = RuntimeRecord> = {
+    name?: string;
+    state: PhaseStateSchema;
+    initialState?: (ctx: {
+        manifest: Manifest;
+        state: State;
+        playerIds: PlayerIdOfState<State>[];
+        options: Options;
+    }) => z.infer<PhaseStateSchema>;
+    enter?: BivariantCallback<PhaseEnterArgs<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest, ErrorCode>, ReducerResult<ScopedPhaseState<State, z.infer<PhaseStateSchema>>> | void>;
+};
+type AutoPhaseDefinition<PhaseStateSchema extends SchemaLike<object>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+    phase: object;
+}, Manifest extends ManifestContract<TableOfState<State>>, ErrorCode extends string = string, Options extends RuntimeRecord = RuntimeRecord> = PhaseDefinitionCommon<PhaseStateSchema, State, Manifest, ErrorCode, Options> & {
+    kind: "auto";
+    actor?: never;
+    actors?: never;
+    submit?: never;
+    canResubmit?: never;
+    resolve?: never;
+    interactions?: never;
+};
+type PlayerPhaseDefinition<PhaseStateSchema extends SchemaLike<object>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+    phase: object;
+}, Manifest extends ManifestContract<TableOfState<State>>, Interactions extends InteractionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Options extends RuntimeRecord = RuntimeRecord, ErrorCode extends string = string> = PhaseDefinitionCommon<PhaseStateSchema, State, Manifest, ErrorCode, Options> & {
+    kind: "player";
+    /**
+     * Default actor selector for interactions in this phase. When omitted the
+     * runtime falls back to `flow.activePlayers`, preserving the existing turn
+     * ownership model. Returning multiple players models simultaneous actors.
+     */
+    actor?: ActorSelector<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest>;
+    actors?: never;
+    submit?: never;
+    canResubmit?: never;
+    resolve?: never;
+    interactions?: Interactions;
+};
+type SimultaneousPlayerPhaseDefinition<PhaseStateSchema extends SchemaLike<object>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+    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> = PhaseDefinitionCommon<PhaseStateSchema, State, Manifest, ErrorCode, Options> & {
+    kind: "simultaneousPlayer";
+    actor?: never;
+    /**
+     * Actor selector for `kind: "simultaneousPlayer"` phases. This is an alias
+     * of `actor` with wording that matches simultaneous submission semantics.
+     */
+    actors: ActorSelector<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest>;
+    /**
+     * Canonical sealed submission interaction for simultaneous phases. It is
+     * projected like a normal interaction, but the trusted runtime stores the
+     * parsed params until every actor has submitted, then calls `resolve`.
+     */
+    submit: SimultaneousSubmitSpec<SubmitCollectors, ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest>;
+    /**
+     * When false or omitted, each actor can submit once per simultaneous
+     * barrier. Set true to allow replacing the sealed submission before every
+     * required actor has submitted.
+     */
+    canResubmit?: boolean;
+    /**
+     * Batch resolver invoked once all simultaneous actors have submitted. The
+     * submitted params are passed together so game state mutates from one
+     * deterministic base state instead of one player at a time.
+     */
+    resolve: BivariantCallback<SimultaneousResolveArgs<SubmitCollectors, ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest, ErrorCode>, ReducerResult<ScopedPhaseState<State, z.infer<PhaseStateSchema>>> | void>;
+    interactions?: Interactions;
+};
+type PhaseDefinition<PhaseStateSchema extends SchemaLike<object>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+    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>;
+
+type SpaceId<Board extends RuntimeBoardState> = keyof Board["spaces"] & string;
+type CommonBoardQueries<Board extends RuntimeBoardState, ComponentId extends string> = {
+    state: Board;
+    space<Id extends SpaceId<Board>>(id: Id): Board["spaces"][Id];
+    container<Id extends keyof Board["containers"] & string>(id: Id): Board["containers"][Id];
+    spacesByType(id: Extract<Board["spaces"][keyof Board["spaces"]]["typeId"], string>): SpaceId<Board>[];
+    relatedSpaces(id: SpaceId<Board>, typeId: Board["relations"][number]["typeId"]): SpaceId<Board>[];
+    neighbors(id: SpaceId<Board>): SpaceId<Board>[];
+    distance(from: SpaceId<Board>, to: SpaceId<Board>): number;
+    spaceOccupants(id: SpaceId<Board>): ComponentId[];
+    containerOccupants(id: keyof Board["containers"] & string): ComponentId[];
+};
+type HexQueries<Board extends RuntimeBoardState> = ReturnType<typeof createHexBoardGeometry<Extract<Board["baseId"], string>, SpaceId<Board>>>;
+type BoundBoardQueries<Board extends RuntimeBoardState, ComponentId extends string> = CommonBoardQueries<Board, ComponentId> & (Board extends {
+    layout: "hex";
+} ? Omit<HexQueries<Board>, "edgesOf" | "verticesOf" | "incidentEdges" | "incidentVertices"> & {
+    spaceEdges: HexQueries<Board>["edgesOf"];
+    spaceVertices: HexQueries<Board>["verticesOf"];
+    edgesOf: HexQueries<Board>["incidentEdges"];
+    verticesOf: HexQueries<Board>["incidentVertices"];
+} : Board extends {
+    layout: "square";
+    edges: readonly {
+        id: infer EdgeId extends string;
+    }[];
+    vertices: readonly {
+        id: infer VertexId extends string;
+    }[];
+} ? {
+    edgesOf(id: VertexId): EdgeId[];
+    verticesOf(id: EdgeId): VertexId[];
+    spaceEdges(id: SpaceId<Board>): EdgeId[];
+    spaceVertices(id: SpaceId<Board>): VertexId[];
+    spacesAt(id: VertexId): SpaceId<Board>[];
+    spacesAlong(id: EdgeId): SpaceId<Board>[];
+    neighbors(id: SpaceId<Board>, options?: {
+        mode?: "orthogonal" | "diagonal" | "all";
+    }): SpaceId<Board>[];
+    distance(from: SpaceId<Board>, to: SpaceId<Board>, options?: {
+        metric?: "manhattan" | "chebyshev";
+    }): number;
+} : unknown);
+
+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>>;
+}
+
+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 BoardRecord<Table extends RuntimeTableRecord, BoardId extends BoardIdOfTable<Table>> = Table["boards"]["byId"][BoardId];
+type TiledBoardRecord<Table extends RuntimeTableRecord, BoardId extends TiledBoardIdOfTable<Table>> = Extract<BoardRecord<Table, BoardId>, {
+    layout: "hex" | "square";
+}>;
+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;
+}>;
+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;
+type CardCollectionOfTable<Table extends RuntimeTableRecord> = CardCollection<CardIdOfTable<Table> & string, ViewCardOfTable<Table, CardIdOfTable<Table>>>;
+type SlotOccupantOfTable<Table extends RuntimeTableRecord> = ViewSlotOccupant<ComponentIdOfTable<Table> & string, PlayerIdOfTable<Table> & string, string, Record<string, unknown>>;
+type SlotOccupantsOfTable<Table extends RuntimeTableRecord> = ReadonlyArray<SlotOccupantOfTable<Table>>;
+type SlotOccupantsBySlotIdOfTable<Table extends RuntimeTableRecord> = Readonly<Record<string, SlotOccupantsOfTable<Table>>>;
+type ComponentLocationOfTable<Table, ComponentId extends ComponentIdOfTable<Table>> = Table extends {
+    componentLocations: infer ComponentLocations extends Record<string, unknown>;
+} ? ComponentLocations[ComponentId] : never;
+type ComponentDataOfTable<Table, ComponentId extends ComponentIdOfTable<Table>> = Table extends {
+    cards: infer Cards extends Record<string, unknown>;
+    pieces: infer Pieces extends Record<string, unknown>;
+    dice: infer Dice extends Record<string, unknown>;
+} ? ComponentId extends keyof Cards ? Cards[ComponentId] : ComponentId extends keyof Pieces ? Pieces[ComponentId] : ComponentId extends keyof Dice ? Dice[ComponentId] : never : never;
+type ComponentLocationByTypeOfTable<Table, ComponentId extends ComponentIdOfTable<Table>, Type extends RuntimeComponentLocation["type"]> = Extract<ComponentLocationOfTable<Table, ComponentId>, {
+    type: Type;
+}>;
+type ResolvedDeckLocation<Table extends RuntimeTableRecord, ComponentId extends ComponentIdOfTable<Table>> = {
+    [DeckId in DeckIdOfTable<Table>]: {
+        componentId: ComponentId;
+        deckId: DeckId;
+        cards: DeckCardsOfTable<Table, DeckId>;
+        location: ComponentLocationByTypeOfTable<Table, ComponentId, "InDeck"> & {
+            deckId: DeckId;
+        };
+    };
+}[DeckIdOfTable<Table>];
+type ResolvedHandLocation<Table extends RuntimeTableRecord, ComponentId extends ComponentIdOfTable<Table>> = {
+    [HandId in HandIdOfTable<Table>]: {
+        [PlayerId in PlayerIdOfTable<Table>]: {
+            componentId: ComponentId;
+            handId: HandId;
+            playerId: PlayerId;
+            cards: HandCardsOfTable<Table, HandId>;
+            location: ComponentLocationByTypeOfTable<Table, ComponentId, "InHand"> & {
+                handId: HandId;
+                playerId: PlayerId;
+            };
+        };
+    }[PlayerIdOfTable<Table>];
+}[HandIdOfTable<Table>];
+type ResolvedZoneLocation<Table extends RuntimeTableRecord, ComponentId extends ComponentIdOfTable<Table>> = ComponentLocationByTypeOfTable<Table, ComponentId, "InZone"> extends infer Location ? Location extends {
+    type: "InZone";
+    zoneId: infer ZoneId extends string;
+} ? {
+    componentId: ComponentId;
+    zoneId: ZoneId;
+    location: Location;
+} : never : never;
+type ResolvedSpaceLocation<Table extends RuntimeTableRecord, ComponentId extends ComponentIdOfTable<Table>> = {
+    [BoardId in BoardIdOfTable<Table>]: {
+        [SpaceId in SpaceIdOfTable<Table, BoardId>]: {
+            componentId: ComponentId;
+            boardId: BoardId;
+            board: BoardRecord<Table, BoardId>;
+            spaceId: SpaceId;
+            space: Table["boards"]["byId"][BoardId]["spaces"][SpaceId];
+            location: ComponentLocationByTypeOfTable<Table, ComponentId, "OnSpace"> & {
+                boardId: BoardId;
+                spaceId: SpaceId;
+            };
+        };
+    }[SpaceIdOfTable<Table, BoardId>];
+}[BoardIdOfTable<Table>];
+type ResolvedContainerLocation<Table extends RuntimeTableRecord, ComponentId extends ComponentIdOfTable<Table>> = {
+    [BoardId in BoardIdOfTable<Table>]: {
+        [ContainerId in BoardContainerIdOfTable<Table, BoardId>]: {
+            componentId: ComponentId;
+            boardId: BoardId;
+            board: BoardRecord<Table, BoardId>;
+            containerId: ContainerId;
+            container: Table["boards"]["byId"][BoardId]["containers"][ContainerId];
+            location: ComponentLocationByTypeOfTable<Table, ComponentId, "InContainer"> & {
+                boardId: BoardId;
+                containerId: ContainerId;
+            };
+        };
+    }[BoardContainerIdOfTable<Table, BoardId>];
+}[BoardIdOfTable<Table>];
+type ResolvedEdgeLocation<Table extends RuntimeTableRecord, ComponentId extends ComponentIdOfTable<Table>> = {
+    [BoardId in TiledBoardIdOfTable<Table>]: {
+        [EdgeId in TiledEdgeIdOfTable<Table, BoardId>]: {
+            componentId: ComponentId;
+            boardId: BoardId;
+            board: TiledBoardRecord<Table, BoardId>;
+            edgeId: EdgeId;
+            edge: Extract<Table["boards"]["byId"][BoardId], {
+                layout: "hex" | "square";
+            }>["edges"][number];
+            location: ComponentLocationByTypeOfTable<Table, ComponentId, "OnEdge"> & {
+                boardId: BoardId;
+                edgeId: EdgeId;
+            };
+        };
+    }[TiledEdgeIdOfTable<Table, BoardId>];
+}[TiledBoardIdOfTable<Table>];
+type ResolvedVertexLocation<Table extends RuntimeTableRecord, ComponentId extends ComponentIdOfTable<Table>> = {
+    [BoardId in TiledBoardIdOfTable<Table>]: {
+        [VertexId in TiledVertexIdOfTable<Table, BoardId>]: {
+            componentId: ComponentId;
+            boardId: BoardId;
+            board: TiledBoardRecord<Table, BoardId>;
+            vertexId: VertexId;
+            vertex: Extract<Table["boards"]["byId"][BoardId], {
+                layout: "hex" | "square";
+            }>["vertices"][number];
+            location: ComponentLocationByTypeOfTable<Table, ComponentId, "OnVertex"> & {
+                boardId: BoardId;
+                vertexId: VertexId;
+            };
+        };
+    }[TiledVertexIdOfTable<Table, BoardId>];
+}[TiledBoardIdOfTable<Table>];
+type ResolvedSlotLocation<Table extends RuntimeTableRecord, ComponentId extends ComponentIdOfTable<Table>> = ComponentLocationByTypeOfTable<Table, ComponentId, "InSlot"> extends infer Location ? Location extends {
+    type: "InSlot";
+    host: infer Host extends RuntimeSlotHostRef;
+    slotId: infer SlotId extends string;
+} ? {
+    componentId: ComponentId;
+    host: Host;
+    slotId: SlotId;
+    location: Location;
+} : never : never;
+type TableQueries<Table extends RuntimeTableRecord> = {
+    board<BoardId extends BoardIdOfTable<Table>>(boardId: BoardId): BoundBoardQueries<Table["boards"]["byId"][BoardId], ComponentIdOfTable<Table>>;
+    zone: {
+        sharedCards: <ZoneId extends DeckIdOfTable<Table>>(zoneId: ZoneId) => DeckCardsForZone<Table, ZoneId>;
+        sharedCardCollection: <ZoneId extends DeckIdOfTable<Table>>(zoneId: ZoneId) => CardCollectionOfTable<Table>;
+        allSharedCards: () => {
+            readonly [Z in DeckIdOfTable<Table>]: DeckCardsOfTable<Table, Z>;
+        };
+        playerCards: <PlayerId extends PlayerIdOfTable<Table>, ZoneId extends HandIdOfTable<Table>>(playerId: PlayerId, zoneId: ZoneId) => HandCardsForZone<Table, ZoneId>;
+        playerCardCollection: <PlayerId extends PlayerIdOfTable<Table>, ZoneId extends HandIdOfTable<Table>>(playerId: PlayerId, zoneId: ZoneId) => CardCollectionOfTable<Table>;
+        allPlayerCards: <ZoneId extends HandIdOfTable<Table>>(zoneId: ZoneId) => {
+            readonly [P in PlayerIdOfTable<Table>]: HandCardsOfTable<Table, ZoneId>;
+        };
+    };
+    card: {
+        get: <CardId extends CardIdOfTable<Table>>(cardId: CardId) => ViewCardOfTable<Table, CardId>;
+        byIds: <CardIds extends readonly CardIdOfTable<Table>[]>(cardIds: CardIds) => CardsByIdOfTable<Table, CardIds>;
+        owner: <CardId extends CardIdOfTable<Table>>(cardId: CardId) => Table["ownerOfCard"][CardId];
+        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>;
+    };
+    player: {
+        /** Seating order from the manifest / setup profile. */
+        order: () => Table["playerOrder"];
+        /**
+         * Next player id in seating order after `playerId`, wrapping around to
+         * the first seat. Returns `null` when `playerId` is unknown or the
+         * order is empty. Convenient for "whose turn is next" logic.
+         */
+        nextInOrder: (playerId: PlayerIdOfTable<Table>) => PlayerIdOfTable<Table> | null;
+        /** All resource balances for a player, as the manifest-typed record. */
+        resources: <PlayerId extends PlayerIdOfTable<Table>>(playerId: PlayerId) => ResourceBalancesOfTable<Table>;
+        /** Balance of a single resource; returns `0` when unset. */
+        resource: (playerId: PlayerIdOfTable<Table>, resourceId: ResourceIdOfTable<Table>) => number;
+        /**
+         * Sum of every resource amount held by a player (e.g. "total cards in
+         * hand" checks). Returns `0` for unknown players or empty balances.
+         */
+        resourceTotal: (playerId: PlayerIdOfTable<Table>) => number;
+        /** `true` when the player can pay every non-zero amount in `amounts`. */
+        canAfford: (playerId: PlayerIdOfTable<Table>, amounts: ResourceAmountsOfTable<Table>) => boolean;
+        /** Shortfall per resource when the player cannot afford `amounts`. */
+        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;
+        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;
+        space: <ComponentId extends ComponentIdOfTable<Table>>(componentId: ComponentId) => ResolvedSpaceLocation<Table, ComponentId> | null;
+        container: <ComponentId extends ComponentIdOfTable<Table>>(componentId: ComponentId) => ResolvedContainerLocation<Table, ComponentId> | null;
+        edge: <ComponentId extends ComponentIdOfTable<Table>>(componentId: ComponentId) => ResolvedEdgeLocation<Table, ComponentId> | null;
+        vertex: <ComponentId extends ComponentIdOfTable<Table>>(componentId: ComponentId) => ResolvedVertexLocation<Table, ComponentId> | null;
+        slot: <ComponentId extends ComponentIdOfTable<Table>>(componentId: ComponentId) => ResolvedSlotLocation<Table, ComponentId> | null;
+    };
+};
+type TableQueriesOfState<State extends {
+    table: RuntimeTableRecord;
+}> = TableQueries<TableOfState<State>>;
+
+declare const manifestIdSchemaBrand: unique symbol;
+type ManifestIdFamily = keyof ManifestIds<string, string, string, string, string>;
+type ManifestIdSchema<Output = unknown, Family extends ManifestIdFamily | undefined = ManifestIdFamily | undefined> = z.ZodType<Output> & {
+    readonly [manifestIdSchemaBrand]: Family;
+};
+type ManifestLiterals<PlayerId extends string, DeckId extends string, HandId extends string, CardId extends string, PhaseName extends string = string> = {
+    playerIds: readonly PlayerId[];
+    phaseNames: readonly PhaseName[];
+    boardLayouts: readonly ("generic" | "hex" | "square")[];
+    cardSetIds: readonly string[];
+    cardTypes: readonly string[];
+    deckIds: readonly DeckId[];
+    handIds: readonly HandId[];
+    sharedZoneIds: readonly DeckId[];
+    playerZoneIds: readonly HandId[];
+    zoneIds: readonly (DeckId | HandId)[];
+    cardIds: readonly CardId[];
+    resourceIds: readonly string[];
+    resourcePresentationById?: Record<string, {
+        label: string;
+        icon?: string | null;
+    }>;
+    pieceTypeIds: readonly string[];
+    pieceIds: readonly string[];
+    dieTypeIds: readonly string[];
+    dieIds: readonly string[];
+    boardTemplateIds: readonly string[];
+    boardTypeIds: readonly string[];
+    boardBaseIds: readonly string[];
+    boardIds: readonly string[];
+    boardContainerIds: readonly string[];
+    relationTypeIds: readonly string[];
+    edgeIds: readonly string[];
+    edgeTypeIds: readonly string[];
+    vertexIds: readonly string[];
+    vertexTypeIds: readonly string[];
+    spaceIds: readonly string[];
+    spaceTypeIds: readonly string[];
+    handVisibilityById: Record<HandId, RuntimeHandVisibilityMode>;
+    zoneVisibilityById: Record<DeckId | HandId, RuntimeHandVisibilityMode>;
+    cardSetIdByCardId: Record<CardId, string>;
+    cardTypeByCardId: Record<CardId, string>;
+    cardSetIdsBySharedZoneId: Record<DeckId, readonly string[]>;
+    cardSetIdsByPlayerZoneId: Record<HandId, readonly string[]>;
+};
+type ManifestIds<PlayerId extends string, DeckId extends string, HandId extends string, CardId extends string, PhaseName extends string = string> = {
+    playerId: z.ZodType<PlayerId>;
+    phaseName: z.ZodType<PhaseName>;
+    boardLayout: AnySchema;
+    cardSetId: AnySchema;
+    cardType: AnySchema;
+    cardId: z.ZodType<CardId>;
+    deckId: z.ZodType<DeckId>;
+    handId: z.ZodType<HandId>;
+    sharedZoneId: AnySchema;
+    playerZoneId: AnySchema;
+    zoneId: AnySchema;
+    resourceId: AnySchema;
+    pieceTypeId: AnySchema;
+    pieceId: AnySchema;
+    dieId: AnySchema;
+    dieTypeId: AnySchema;
+    boardTypeId: AnySchema;
+    boardId: AnySchema;
+    boardBaseId: AnySchema;
+    boardContainerId: AnySchema;
+    relationTypeId: AnySchema;
+    edgeId: AnySchema;
+    edgeTypeId: AnySchema;
+    vertexId: AnySchema;
+    vertexTypeId: AnySchema;
+    spaceId: AnySchema;
+    spaceTypeId: AnySchema;
+};
+type ManifestDefaults<Table extends RuntimeTableRecord> = {
+    zones: (playerIds?: readonly string[]) => Table["zones"];
+    decks: (playerIds?: readonly string[]) => Table["decks"];
+    hands: (playerIds?: readonly string[]) => Table["hands"];
+    handVisibility: (playerIds?: readonly string[]) => Table["handVisibility"];
+    ownerOfCard: (playerIds?: readonly string[]) => Table["ownerOfCard"];
+    visibility: (playerIds?: readonly string[]) => Table["visibility"];
+    resources: (playerIds?: readonly string[]) => Table["resources"];
+};
+type ManifestNormalSetup<Table extends RuntimeTableRecord> = {
+    readonly minPlayers: number;
+    readonly maxPlayers: number;
+    readonly createInitialTable: (options: {
+        readonly playerIds: readonly string[];
+    }) => Table;
+};
+type StaticBoards<Table extends RuntimeTableRecord> = Pick<Table["boards"], "byId" | "hex" | "square">;
+type ReducerManifestContract<Table extends RuntimeTableRecord, PhaseName extends string, PlayerId extends string, DeckId extends string, HandId extends string, CardId extends string> = {
+    literals: ManifestLiterals<PlayerId, DeckId, HandId, CardId, PhaseName>;
+    ids: ManifestIds<PlayerId, DeckId, HandId, CardId, PhaseName>;
+    defaults: ManifestDefaults<Table>;
+    /**
+     * Normal-session setup capability supplied by the manifest compiler.
+     *
+     * This remains optional on the structural contract so small handwritten
+     * manifests can model focused reducer tests without recreating generated
+     * topology metadata. Compiled manifests always provide it.
+     */
+    normalSetup?: ManifestNormalSetup<Table>;
+    staticBoards?: StaticBoards<Table>;
+    tableSchema: z.ZodType<Table>;
+    runtimeSchema: AnySchema;
+    createGameStateSchema: (config: {
+        phaseNameSchema: AnySchema;
+        publicSchema: AnySchema;
+        privateSchema: AnySchema;
+        hiddenSchema: AnySchema;
+        phasesSchema: AnySchema;
+    }) => AnySchema;
+};
+type ReducerManifestContractLike<Table extends RuntimeTableRecord = RuntimeTableRecord, PhaseName extends string = string, PlayerId extends string = string, DeckId extends string = string, HandId extends string = string, CardId extends string = string> = ReducerManifestContract<Table, PhaseName, PlayerId, DeckId, HandId, CardId>;
+type ManifestContract<Table extends RuntimeTableRecord> = ReducerManifestContract<Table, string, PlayerIdOfTable<Table>, DeckIdOfTable<Table>, HandIdOfTable<Table>, CardIdOfTable<Table>>;
+type StateDefinition<PublicSchema extends SchemaLike<object>, PrivateSchema extends SchemaLike<object>, HiddenSchema extends SchemaLike<object>> = {
+    public: PublicSchema;
+    private: PrivateSchema;
+    hidden: HiddenSchema;
+};
+type InitContext<Table extends RuntimeTableRecord, Manifest extends ReducerManifestContract<Table, string, string, string, string, string> = ManifestContract<Table>, Options extends RuntimeRecord = RuntimeRecord> = {
+    manifest: Manifest;
+    table: Table;
+    playerIds: PlayerIdOfTable<Table>[];
+    rngSeed?: number | null;
+    options: Options;
+    q: TableQueriesOfState<{
+        table: Table;
+    }>;
+};
+
+/** 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>>;
+};
+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;
+/**
+ * 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;
+
+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 };