@dreamboard-games/sdk 0.2.0

package/dist/reducer.d.ts

@@ -0,0 +1,3786 @@
+import { z } from 'zod';
+import { C as CardCollection, V as ViewCard } from './cards-Sl3b40Mv.js';
+import { V as ViewSlotOccupant } from './slots-1GPGihk8.js';
+import { R as ReducerBundleContract } from './bundle-TIZcw8LB.js';
+
+/**
+ * Opaque brand applied to a runtime player identifier.
+ *
+ * Generators produce a workspace-specific `PlayerId` alias (e.g.
+ * `Brand<string, "PlayerId">` in `shared/manifest-contract.ts`). Authors
+ * obtain `PlayerId` values only through:
+ *   - `q.player.order()` / `q.player.current()` (reducer queries),
+ *   - engine-injected callback arguments (actions, phases, prompts),
+ *   - `perPlayerKeys(...)` / entries iteration,
+ *   - `asPlayerId(raw)` as an explicit escape hatch (e.g. ingress parsing).
+ *
+ * The brand is a phantom type: at runtime a `PlayerId` is just a string.
+ * Do not JSON-serialize the brand marker; it exists purely at the type
+ * level to block accidental literal comparisons such as
+ * `playerId === "player-1"`.
+ */
+type PlayerId = Brand<string, "PlayerId">;
+/**
+ * Explicit conversion from a raw string to a branded `PlayerId`.
+ *
+ * Use at trust boundaries only (wire ingress, tests, fixtures). Inside
+ * reducer logic, obtain `PlayerId` values from the engine instead of
+ * constructing them yourself.
+ */
+declare function asPlayerId(raw: string): PlayerId;
+/**
+ * Type guard that narrows `unknown` to `PlayerId` when the value is a
+ * non-empty string. Does not validate against a specific player roster;
+ * use `perPlayerSchema`/ingress parsing for that.
+ */
+declare function isPlayerId(value: unknown): value is PlayerId;
+/**
+ * A runtime-accurate per-player map.
+ *
+ * `PerPlayer<Value>` is an opaque, ordered container whose entries are
+ * exactly the players that exist at runtime (the seats passed to
+ * `initialize`).
+ *
+ * The `__perPlayer` discriminator keeps the structural type nominal-ish
+ * without depending on a symbol (symbols do not round-trip through JSON,
+ * which this shape must).
+ *
+ * Construct with `perPlayer(ids, init)` and read with the accessors in
+ * this module; do not reach into `entries` directly unless you need
+ * ordered iteration.
+ */
+interface PerPlayer<Value, Id extends PlayerId = PlayerId> {
+    readonly __perPlayer: true;
+    readonly entries: ReadonlyArray<readonly [Id, Value]>;
+}
+/**
+ * Construct a `PerPlayer<Value>` with one entry per `id` in `ids`.
+ *
+ * `ids` is treated as the authoritative runtime seat list: the returned
+ * `PerPlayer` contains exactly `ids.length` entries, in the same order.
+ * Duplicate ids throw.
+ */
+declare function perPlayer<Value, Id extends PlayerId = PlayerId>(ids: readonly Id[], init: (id: Id, index: number) => Value): PerPlayer<Value, Id>;
+/** Ordered list of seat ids present in the `PerPlayer`. */
+declare function perPlayerKeys<Id extends PlayerId>(value: PerPlayer<unknown, Id>): Id[];
+/** Ordered list of values present in the `PerPlayer`. */
+declare function perPlayerValues<Value>(value: PerPlayer<Value, PlayerId>): Value[];
+/**
+ * Ordered `[id, value]` pairs. Returns the backing array as-is; callers
+ * must not mutate it.
+ */
+declare function perPlayerEntries<Value, Id extends PlayerId>(value: PerPlayer<Value, Id>): ReadonlyArray<readonly [Id, Value]>;
+/** Number of seats in the `PerPlayer`. */
+declare function perPlayerSize(value: PerPlayer<unknown, PlayerId>): number;
+/** Whether `id` has a value. */
+declare function perPlayerHas<Id extends PlayerId>(value: PerPlayer<unknown, Id>, id: Id): boolean;
+/** Lookup with no fallback; returns `undefined` for missing seats. */
+declare function perPlayerGet<Value, Id extends PlayerId>(value: PerPlayer<Value, Id>, id: Id): Value | undefined;
+/**
+ * Lookup that throws if `id` is not present.
+ *
+ * Use when the caller has already established (via `q.player.order()`,
+ * an action context, etc.) that `id` is an active runtime seat.
+ */
+declare function perPlayerRequire<Value, Id extends PlayerId>(value: PerPlayer<Value, Id>, id: Id): Value;
+/**
+ * Return a new `PerPlayer` with `id`'s value replaced (or added if the
+ * id is not present). Preserves entry order; new entries are appended.
+ */
+declare function perPlayerSet<Value, Id extends PlayerId>(value: PerPlayer<Value, Id>, id: Id, next: Value): PerPlayer<Value, Id>;
+/**
+ * Return a new `PerPlayer` where each value is replaced by `f(value, id)`.
+ * Seat order is preserved.
+ */
+declare function perPlayerMap<Value, Next, Id extends PlayerId>(value: PerPlayer<Value, Id>, f: (v: Value, id: Id, index: number) => Next): PerPlayer<Next, Id>;
+/**
+ * Structural check for a `PerPlayer` without a Zod schema. Useful in
+ * debug paths and as a fast pre-filter before schema validation.
+ */
+declare function isPerPlayer(value: unknown): value is PerPlayer<unknown>;
+/**
+ * Options accepted by `perPlayerSchema`.
+ *
+ * Setting `players` locks the schema to an exact seat list: parse fails
+ * if the input is missing any seat or has an unknown id. Leaving
+ * `players` unset yields a schema that accepts any non-empty string as
+ * a key, which is the right default for generic SDK types.
+ *
+ * `playerIdSchema` lets callers feed a manifest-scoped Zod id schema in
+ * so parse errors carry the same message as other branded ids.
+ */
+type PerPlayerSchemaOptions<Id extends PlayerId> = {
+    readonly playerIdSchema?: z.ZodType<Id>;
+    readonly players?: readonly Id[];
+};
+/**
+ * Build a Zod schema that validates a wire-shaped `PerPlayer<Value>`.
+ *
+ * When `options.players` is supplied the schema enforces that entries
+ * match that exact set (same cardinality, same ids, any order). This is
+ * the mechanism that catches the class of bug where a 3-player session
+ * produced a view shape the old `Record<PlayerId, T>` type claimed had
+ * a `player-4` key.
+ */
+declare function perPlayerSchema<Value, Id extends PlayerId = PlayerId>(valueSchema: z.ZodType<Value>, options?: PerPlayerSchemaOptions<Id>): z.ZodType<PerPlayer<Value, Id>>;
+/**
+ * Reference to a board by its authored `baseId`, plus an optional seat
+ * for per-player boards.
+ *
+ * Replaces the old generated `"ring:player-1" | "ring:player-2" | ...`
+ * flat unions whose keys pretended to be static but were actually
+ * derived from `maxPlayers` and therefore misaligned with the runtime
+ * seat list.
+ *
+ * The discriminant is the *presence* of `seat`, not a `scope` field, so
+ * authors can destructure and pass the ref directly without needing a
+ * discriminator check for shared boards.
+ */
+type BoardRef<BaseId extends string = string, Id extends PlayerId = PlayerId> = SharedBoardRef<BaseId> | PerPlayerBoardRef<BaseId, Id>;
+interface SharedBoardRef<BaseId extends string = string> {
+    readonly baseId: BaseId;
+    readonly seat?: undefined;
+}
+interface PerPlayerBoardRef<BaseId extends string = string, Id extends PlayerId = PlayerId> {
+    readonly baseId: BaseId;
+    readonly seat: Id;
+}
+/** Construct a shared board ref. */
+declare function sharedBoardRef<BaseId extends string>(baseId: BaseId): SharedBoardRef<BaseId>;
+/** Construct a per-player board ref. */
+declare function perPlayerBoardRef<BaseId extends string, Id extends PlayerId>(baseId: BaseId, seat: Id): PerPlayerBoardRef<BaseId, Id>;
+/**
+ * Construct a `BoardRef` without knowing the scope ahead of time. Pass
+ * `seat` for per-player boards; omit for shared boards.
+ */
+declare function boardRef<BaseId extends string, Id extends PlayerId>(baseId: BaseId, seat?: Id): BoardRef<BaseId, Id>;
+/** Stable string key for Maps/Records keyed by a `BoardRef`. */
+declare function boardRefKey(ref: BoardRef): string;
+/**
+ * Inverse of `boardRefKey`. Parses `"base"` as a shared ref and
+ * `"base:player-N"` as a per-player ref. Returns `null` for malformed
+ * input.
+ */
+declare function parseBoardRefKey(key: string): BoardRef | null;
+/**
+ * Zod schema for a `BoardRef` with free-form base and seat ids.
+ *
+ * Feed a manifest-scoped `baseIdSchema` and `playerIdSchema` to bind
+ * the ref to a specific workspace.
+ */
+declare function boardRefSchema<BaseId extends string = string, Id extends PlayerId = PlayerId>(options?: {
+    readonly baseIdSchema?: z.ZodType<BaseId>;
+    readonly playerIdSchema?: z.ZodType<Id>;
+}): z.ZodType<BoardRef<BaseId, Id>>;
+/** True when `ref` targets a shared board (no seat). */
+declare function isSharedBoardRef<BaseId extends string>(ref: BoardRef<BaseId, PlayerId>): ref is SharedBoardRef<BaseId>;
+/** True when `ref` targets a per-player board (has a seat). */
+declare function isPerPlayerBoardRef<BaseId extends string, Id extends PlayerId>(ref: BoardRef<BaseId, Id>): ref is PerPlayerBoardRef<BaseId, Id>;
+
+type RuntimeScalar = boolean | number | string | null;
+interface RuntimeRecord {
+    [key: string]: RuntimePayload | undefined;
+}
+type RuntimePayload = RuntimeScalar | RuntimePayload[] | RuntimeRecord;
+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, PerPlayer<string[]>>;
+type RuntimeZoneMap = {
+    shared: Record<string, string[]>;
+    perPlayer: Record<string, PerPlayer<string[]>>;
+    visibility: Record<string, RuntimeHandVisibilityMode>;
+    cardSetIdsByZoneId?: Record<string, readonly string[]>;
+};
+type RuntimeOwnerMap = Record<string, string | null>;
+type RuntimeResourceMap = PerPlayer<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;
+    templateId?: 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-top" | "flat-top";
+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>;
+};
+
+type TableOfState<State> = State extends {
+    table: infer Table;
+} ? Table : never;
+type TableOfManifest<Manifest> = Manifest extends GeneratedManifestContractLike<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 PlayerIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        playerIds: readonly (infer PlayerId)[];
+    };
+} ? Extract<PlayerId, string> : string;
+type PlayerIdOfState<State> = PlayerIdOfTable<TableOfState<State>>;
+/**
+ * Manifest-declared resource id union for a runtime table.
+ *
+ * Derived from the shape of `table.resources`, which the generated
+ * manifest contract seeds as `PerPlayer<Record<ResourceId, number>>`.
+ * The helper peeks inside the `PerPlayer` wrapper to surface the
+ * resource-id keys without forcing callers to remember the wrapper.
+ */
+type ResourceIdOfTable<Table> = Table extends {
+    resources: infer Resources;
+} ? ValueOfPerPlayer<Resources> extends infer PerPlayerValue ? PerPlayerValue extends Record<string, unknown> ? StringKeyOf<PerPlayerValue> : never : never : never;
+/**
+ * Per-player balance shape for a runtime table. Strips the `PerPlayer`
+ * wrapper around `table.resources` so callers receive the manifest-typed
+ * record directly (e.g. `Record<ResourceId, number>`).
+ */
+type ResourceBalancesOfTable<Table> = Table extends {
+    resources: infer Resources;
+} ? ValueOfPerPlayer<Resources> extends infer PerPlayerValue ? PerPlayerValue extends Record<string, unknown> ? PerPlayerValue : never : never : never;
+/**
+ * Per-player resource counts: a partial `Record<ResourceId, number>`.
+ *
+ * Used as the input shape for {@link ReducerOps.addResources},
+ * {@link ReducerOps.spendResources}, and {@link ReducerOps.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 CardTypeOfTable<Table> = Table extends {
+    cards: Record<string, {
+        cardType: infer CardType;
+    }>;
+} ? Extract<CardType, string> : string;
+type DeckIdOfState<State> = DeckIdOfTable<TableOfState<State>>;
+type HandIdOfState<State> = HandIdOfTable<TableOfState<State>>;
+type CardIdOfState<State> = CardIdOfTable<TableOfState<State>>;
+type CardTypeOfState<State> = CardTypeOfTable<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 BoardTypeIdOfTable<Table> = BoardStateOfTable<Table, BoardIdOfTable<Table>> extends {
+    typeId?: infer BoardTypeId | null;
+} ? Extract<BoardTypeId, string> : never;
+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 HexBoardIdOfTable<Table> = {
+    [BoardId in BoardIdOfTable<Table>]: BoardStateOfTable<Table, BoardId> extends {
+        layout: "hex";
+    } ? BoardId : never;
+}[BoardIdOfTable<Table>];
+type HexBoardStateOfTable<Table, BoardId extends HexBoardIdOfTable<Table>> = BoardStateOfTable<Table, BoardId> extends infer BoardState ? BoardState extends {
+    layout: "hex";
+    spaces: Record<string, unknown>;
+    edges: readonly {
+        id: string;
+    }[];
+    vertices: readonly {
+        id: string;
+    }[];
+} ? BoardState : never : never;
+type SquareBoardIdOfTable<Table> = {
+    [BoardId in BoardIdOfTable<Table>]: BoardStateOfTable<Table, BoardId> extends {
+        layout: "square";
+    } ? BoardId : never;
+}[BoardIdOfTable<Table>];
+type SquareBoardStateOfTable<Table, BoardId extends SquareBoardIdOfTable<Table>> = BoardStateOfTable<Table, BoardId> extends infer BoardState ? BoardState extends {
+    layout: "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 SpaceTypeIdOfTable<Table, BoardId extends BoardIdOfTable<Table>> = BoardStateOfTable<Table, BoardId> extends {
+    spaces: infer Spaces extends Record<string, unknown>;
+} ? Spaces[StringKeyOf<Spaces>] extends {
+    typeId?: infer SpaceTypeId | null;
+} ? Extract<SpaceTypeId, string> : never : never;
+type BoardContainerIdOfTable<Table, BoardId extends BoardIdOfTable<Table>> = BoardStateOfTable<Table, BoardId> extends {
+    containers: infer Containers;
+} ? StringKeyOf<Containers> : never;
+type RelationTypeIdOfTable<Table, BoardId extends BoardIdOfTable<Table>> = BoardStateOfTable<Table, BoardId> extends {
+    relations: readonly (infer Relation)[];
+} ? Relation extends {
+    typeId: infer RelationTypeId;
+} ? Extract<RelationTypeId, string> : never : never;
+type TiledSpaceIdOfTable<Table, BoardId extends TiledBoardIdOfTable<Table>> = TiledBoardStateOfTable<Table, BoardId> extends {
+    spaces: infer Spaces;
+} ? StringKeyOf<Spaces> : never;
+type HexSpaceIdOfTable<Table, BoardId extends HexBoardIdOfTable<Table>> = HexBoardStateOfTable<Table, BoardId> extends {
+    spaces: infer Spaces;
+} ? StringKeyOf<Spaces> : never;
+type SquareSpaceIdOfTable<Table, BoardId extends SquareBoardIdOfTable<Table>> = SquareBoardStateOfTable<Table, BoardId> extends {
+    spaces: infer Spaces;
+} ? StringKeyOf<Spaces> : never;
+type HexSpaceTypeIdOfTable<Table, BoardId extends HexBoardIdOfTable<Table>> = HexBoardStateOfTable<Table, BoardId> extends {
+    spaces: infer Spaces extends Record<string, unknown>;
+} ? Spaces[StringKeyOf<Spaces>] extends {
+    typeId?: infer SpaceTypeId | null;
+} ? Extract<SpaceTypeId, string> : never : never;
+type SquareSpaceTypeIdOfTable<Table, BoardId extends SquareBoardIdOfTable<Table>> = SquareBoardStateOfTable<Table, BoardId> extends {
+    spaces: infer Spaces extends Record<string, unknown>;
+} ? Spaces[StringKeyOf<Spaces>] extends {
+    typeId?: infer SpaceTypeId | null;
+} ? Extract<SpaceTypeId, string> : never : 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 HexEdgeIdOfTable<Table, BoardId extends HexBoardIdOfTable<Table>> = HexBoardStateOfTable<Table, BoardId> extends {
+    edges: readonly (infer Edge)[];
+} ? Edge extends {
+    id: infer EdgeId;
+} ? Extract<EdgeId, string> : never : never;
+type SquareEdgeIdOfTable<Table, BoardId extends SquareBoardIdOfTable<Table>> = SquareBoardStateOfTable<Table, BoardId> extends {
+    edges: readonly (infer Edge)[];
+} ? Edge extends {
+    id: infer EdgeId;
+} ? Extract<EdgeId, string> : never : never;
+/**
+ * Edge record on a tiled board narrowed to a specific `EdgeId` literal.
+ *
+ * The generated board state stores edges as a single array element type
+ * `{ id: <union-of-edge-ids>, spaceIds, typeId, fields, ... }`. Looking up an
+ * edge by id should return a record whose `id` is narrowed to the literal
+ * that was requested, not the entire edge-id union.
+ */
+type TiledEdgeStateOfTable<Table, BoardId extends TiledBoardIdOfTable<Table>, EdgeId extends TiledEdgeIdOfTable<Table, BoardId>> = TiledBoardStateOfTable<Table, BoardId> extends {
+    edges: readonly (infer Edge)[];
+} ? Edge extends {
+    id: string;
+} ? Omit<Edge, "id"> & {
+    id: EdgeId;
+} : never : never;
+type TiledEdgeTypeIdOfTable<Table, BoardId extends TiledBoardIdOfTable<Table>> = TiledBoardStateOfTable<Table, BoardId> extends {
+    edges: readonly (infer Edge)[];
+} ? Edge extends {
+    typeId?: infer EdgeTypeId | null;
+} ? Extract<EdgeTypeId, string> : never : never;
+type HexEdgeTypeIdOfTable<Table, BoardId extends HexBoardIdOfTable<Table>> = HexBoardStateOfTable<Table, BoardId> extends {
+    edges: readonly (infer Edge)[];
+} ? Edge extends {
+    typeId?: infer EdgeTypeId | null;
+} ? Extract<EdgeTypeId, string> : never : never;
+type SquareEdgeTypeIdOfTable<Table, BoardId extends SquareBoardIdOfTable<Table>> = SquareBoardStateOfTable<Table, BoardId> extends {
+    edges: readonly (infer Edge)[];
+} ? Edge extends {
+    typeId?: infer EdgeTypeId | null;
+} ? Extract<EdgeTypeId, 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 HexVertexIdOfTable<Table, BoardId extends HexBoardIdOfTable<Table>> = HexBoardStateOfTable<Table, BoardId> extends {
+    vertices: readonly (infer Vertex)[];
+} ? Vertex extends {
+    id: infer VertexId;
+} ? Extract<VertexId, string> : never : never;
+type SquareVertexIdOfTable<Table, BoardId extends SquareBoardIdOfTable<Table>> = SquareBoardStateOfTable<Table, BoardId> extends {
+    vertices: readonly (infer Vertex)[];
+} ? Vertex extends {
+    id: infer VertexId;
+} ? Extract<VertexId, string> : never : never;
+/**
+ * Vertex record on a tiled board narrowed to a specific `VertexId` literal.
+ * See {@link TiledEdgeStateOfTable} for rationale.
+ */
+type TiledVertexStateOfTable<Table, BoardId extends TiledBoardIdOfTable<Table>, VertexId extends TiledVertexIdOfTable<Table, BoardId>> = TiledBoardStateOfTable<Table, BoardId> extends {
+    vertices: readonly (infer Vertex)[];
+} ? Vertex extends {
+    id: string;
+} ? Omit<Vertex, "id"> & {
+    id: VertexId;
+} : never : never;
+type TiledVertexTypeIdOfTable<Table, BoardId extends TiledBoardIdOfTable<Table>> = TiledBoardStateOfTable<Table, BoardId> extends {
+    vertices: readonly (infer Vertex)[];
+} ? Vertex extends {
+    typeId?: infer VertexTypeId | null;
+} ? Extract<VertexTypeId, string> : never : never;
+type HexVertexTypeIdOfTable<Table, BoardId extends HexBoardIdOfTable<Table>> = HexBoardStateOfTable<Table, BoardId> extends {
+    vertices: readonly (infer Vertex)[];
+} ? Vertex extends {
+    typeId?: infer VertexTypeId | null;
+} ? Extract<VertexTypeId, string> : never : never;
+type SquareVertexTypeIdOfTable<Table, BoardId extends SquareBoardIdOfTable<Table>> = SquareBoardStateOfTable<Table, BoardId> extends {
+    vertices: readonly (infer Vertex)[];
+} ? Vertex extends {
+    typeId?: infer VertexTypeId | null;
+} ? Extract<VertexTypeId, string> : never : never;
+type TiledSpaceMap<Table, BoardId extends TiledBoardIdOfTable<Table>, Value> = Partial<Record<TiledSpaceIdOfTable<Table, BoardId>, Value>>;
+type TiledEdgeMap<Table, BoardId extends TiledBoardIdOfTable<Table>, Value> = Partial<Record<TiledEdgeIdOfTable<Table, BoardId>, Value>>;
+type TiledVertexMap<Table, BoardId extends TiledBoardIdOfTable<Table>, Value> = Partial<Record<TiledVertexIdOfTable<Table, BoardId>, Value>>;
+type ComponentIdOfTable<Table> = Table extends {
+    componentLocations: infer ComponentLocations;
+} ? StringKeyOf<ComponentLocations> : never;
+type SharedZoneIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        sharedZoneIds: readonly (infer ZoneId)[];
+    };
+} ? Extract<ZoneId, string> : string;
+type PlayerZoneIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        playerZoneIds: readonly (infer ZoneId)[];
+    };
+} ? Extract<ZoneId, string> : string;
+type SharedZoneIdOfState<State> = DeckIdOfState<State>;
+type PlayerZoneIdOfState<State> = HandIdOfState<State>;
+type BoardIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        boardIds: readonly (infer BoardId)[];
+    };
+} ? Extract<BoardId, string> : string;
+type BoardLayoutOfManifest<Manifest> = Manifest extends {
+    literals: {
+        boardLayouts: readonly (infer BoardLayout)[];
+    };
+} ? Extract<BoardLayout, string> : "generic" | "hex" | "square";
+type BoardTypeIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        boardTypeIds: readonly (infer BoardTypeId)[];
+    };
+} ? Extract<BoardTypeId, string> : string;
+type BoardBaseIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        boardBaseIds: readonly (infer BoardBaseId)[];
+    };
+} ? Extract<BoardBaseId, string> : string;
+type RelationTypeIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        relationTypeIds: readonly (infer RelationTypeId)[];
+    };
+} ? Extract<RelationTypeId, string> : string;
+type BoardContainerIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        boardContainerIds: readonly (infer ContainerId)[];
+    };
+} ? Extract<ContainerId, string> : string;
+type EdgeTypeIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        edgeTypeIds: readonly (infer EdgeTypeId)[];
+    };
+} ? Extract<EdgeTypeId, string> : string;
+type VertexTypeIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        vertexTypeIds: readonly (infer VertexTypeId)[];
+    };
+} ? Extract<VertexTypeId, string> : string;
+type SpaceIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        spaceIds: readonly (infer SpaceId)[];
+    };
+} ? Extract<SpaceId, string> : string;
+type SpaceTypeIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        spaceTypeIds: readonly (infer SpaceTypeId)[];
+    };
+} ? Extract<SpaceTypeId, string> : string;
+type PieceIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        pieceIds: readonly (infer PieceId)[];
+    };
+} ? Extract<PieceId, string> : string;
+type DieIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        dieIds: readonly (infer DieId)[];
+    };
+} ? Extract<DieId, string> : string;
+type ManifestOf<Source> = Source extends {
+    contract: infer Contract;
+} ? ManifestOf<Contract> : Source extends {
+    manifest: infer Manifest;
+} ? Manifest : never;
+type SetupOptionIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        setupOptionIds: readonly (infer SetupOptionId)[];
+    };
+} ? Extract<SetupOptionId, string> : string;
+type SetupProfileIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        setupProfileIds: readonly (infer SetupProfileId)[];
+    };
+} ? Extract<SetupProfileId, string> : string;
+type SetupSelectionInputOfManifest<Manifest> = {
+    profileId: SetupProfileIdOfManifest<Manifest>;
+    optionValues?: Partial<Record<SetupOptionIdOfManifest<Manifest>, string>>;
+};
+type SetupSelectionOfManifest<Manifest> = {
+    profileId: SetupProfileIdOfManifest<Manifest>;
+    optionValues: Record<SetupOptionIdOfManifest<Manifest>, string | null>;
+};
+type RuntimeSetupSelectionInput<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike> = SetupSelectionInputOfManifest<Manifest>;
+type RuntimeSetupSelection<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike> = SetupSelectionOfManifest<Manifest>;
+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, infer _PrivateSchema, infer _HiddenSchema> ? PublicSchema : never;
+type PrivateSchemaOfContract<Contract> = StateDefinitionOfContract<Contract> extends StateDefinition<infer _PublicSchema, infer PrivateSchema, infer _HiddenSchema> ? PrivateSchema : never;
+type HiddenSchemaOfContract<Contract> = StateDefinitionOfContract<Contract> extends StateDefinition<infer _PublicSchema, infer _PrivateSchema, 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> & GeneratedManifestContractLike<TableOfManifest<ManifestOf<Contract>>>;
+type PhaseNameOf<Source> = Source extends {
+    flow: {
+        currentPhase: infer PhaseName;
+    };
+} ? Extract<PhaseName, string> : PhaseNameOfContract<Source>;
+type DeckCardsOfTable<Table, DeckId extends DeckIdOfTable<Table>> = Table extends {
+    decks: infer Decks extends Record<string, readonly unknown[]>;
+} ? Decks[DeckId] : never;
+type ValueOfPerPlayer<T> = T extends {
+    readonly entries: ReadonlyArray<readonly [unknown, infer Value]>;
+} ? Value : never;
+type HandCardsOfTable<Table, HandId extends HandIdOfTable<Table>> = Table extends {
+    hands: infer Hands extends Record<string, unknown>;
+} ? HandId extends keyof Hands ? ValueOfPerPlayer<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 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: {
+        get: <BoardId extends BoardIdOfTable<Table>>(boardId: BoardId) => BoardRecord<Table, BoardId>;
+        hex: <BoardId extends HexBoardIdOfTable<Table>>(boardId: BoardId) => Extract<BoardRecord<Table, BoardId>, {
+            layout: "hex";
+        }>;
+        square: <BoardId extends SquareBoardIdOfTable<Table>>(boardId: BoardId) => Extract<BoardRecord<Table, BoardId>, {
+            layout: "square";
+        }>;
+        tiled: <BoardId extends TiledBoardIdOfTable<Table>>(boardId: BoardId) => TiledBoardRecord<Table, BoardId>;
+        space: <BoardId extends BoardIdOfTable<Table>, SpaceId extends SpaceIdOfTable<Table, BoardId>>(boardId: BoardId, spaceId: SpaceId) => Table["boards"]["byId"][BoardId]["spaces"][SpaceId];
+        hexSpace: <BoardId extends HexBoardIdOfTable<Table>, SpaceId extends HexSpaceIdOfTable<Table, BoardId>>(boardId: BoardId, spaceId: SpaceId) => Extract<Table["boards"]["byId"][BoardId], {
+            layout: "hex";
+        }>["spaces"][SpaceId];
+        squareSpace: <BoardId extends SquareBoardIdOfTable<Table>, SpaceId extends SquareSpaceIdOfTable<Table, BoardId>>(boardId: BoardId, spaceId: SpaceId) => Extract<Table["boards"]["byId"][BoardId], {
+            layout: "square";
+        }>["spaces"][SpaceId];
+        container: <BoardId extends BoardIdOfTable<Table>, ContainerId extends BoardContainerIdOfTable<Table, BoardId>>(boardId: BoardId, containerId: ContainerId) => Table["boards"]["byId"][BoardId]["containers"][ContainerId];
+        edge: <BoardId extends TiledBoardIdOfTable<Table>, EdgeId extends TiledEdgeIdOfTable<Table, BoardId>>(boardId: BoardId, edgeId: EdgeId) => TiledEdgeStateOfTable<Table, BoardId, EdgeId>;
+        vertex: <BoardId extends TiledBoardIdOfTable<Table>, VertexId extends TiledVertexIdOfTable<Table, BoardId>>(boardId: BoardId, vertexId: VertexId) => TiledVertexStateOfTable<Table, BoardId, VertexId>;
+        byType: <TypeId extends BoardTypeIdOfTable<Table>>(typeId: TypeId) => BoardIdOfTable<Table>[];
+        spacesByType: <BoardId extends BoardIdOfTable<Table>, TypeId extends SpaceTypeIdOfTable<Table, BoardId>>(boardId: BoardId, typeId: TypeId) => SpaceIdOfTable<Table, BoardId>[];
+        edgesByType: <BoardId extends TiledBoardIdOfTable<Table>, TypeId extends TiledEdgeTypeIdOfTable<Table, BoardId>>(boardId: BoardId, typeId: TypeId) => TiledEdgeIdOfTable<Table, BoardId>[];
+        verticesByType: <BoardId extends TiledBoardIdOfTable<Table>, TypeId extends TiledVertexTypeIdOfTable<Table, BoardId>>(boardId: BoardId, typeId: TypeId) => TiledVertexIdOfTable<Table, BoardId>[];
+        adjacentSpaces: <BoardId extends BoardIdOfTable<Table>, SpaceId extends SpaceIdOfTable<Table, BoardId>>(boardId: BoardId, spaceId: SpaceId) => SpaceIdOfTable<Table, BoardId>[];
+        relatedSpaces: <BoardId extends BoardIdOfTable<Table>, SpaceId extends SpaceIdOfTable<Table, BoardId>, TypeId extends RelationTypeIdOfTable<Table, BoardId>>(boardId: BoardId, spaceId: SpaceId, relationTypeId: TypeId) => SpaceIdOfTable<Table, BoardId>[];
+        incidentEdges: <BoardId extends TiledBoardIdOfTable<Table>, VertexId extends TiledVertexIdOfTable<Table, BoardId>>(boardId: BoardId, vertexId: VertexId) => TiledEdgeIdOfTable<Table, BoardId>[];
+        incidentVertices: <BoardId extends TiledBoardIdOfTable<Table>, EdgeId extends TiledEdgeIdOfTable<Table, BoardId>>(boardId: BoardId, edgeId: EdgeId) => TiledVertexIdOfTable<Table, BoardId>[];
+        spaceEdges: <BoardId extends TiledBoardIdOfTable<Table>>(boardId: BoardId, spaceId: SpaceIdOfTable<Table, BoardId>) => TiledEdgeIdOfTable<Table, BoardId>[];
+        spaceVertices: <BoardId extends TiledBoardIdOfTable<Table>>(boardId: BoardId, spaceId: SpaceIdOfTable<Table, BoardId>) => TiledVertexIdOfTable<Table, BoardId>[];
+        spaceDistance: <BoardId extends BoardIdOfTable<Table>, SpaceId extends SpaceIdOfTable<Table, BoardId>>(boardId: BoardId, fromSpaceId: SpaceId, toSpaceId: SpaceId) => number;
+        hexSpaceAt: <BoardId extends HexBoardIdOfTable<Table>>(boardId: BoardId, q: number, r: number) => Extract<Table["boards"]["byId"][BoardId], {
+            layout: "hex";
+        }>["spaces"][HexSpaceIdOfTable<Table, BoardId>] | undefined;
+        squareSpaceAt: <BoardId extends SquareBoardIdOfTable<Table>>(boardId: BoardId, row: number, col: number) => Extract<Table["boards"]["byId"][BoardId], {
+            layout: "square";
+        }>["spaces"][SquareSpaceIdOfTable<Table, BoardId>] | undefined;
+        squareNeighbors: <BoardId extends SquareBoardIdOfTable<Table>, SpaceId extends SquareSpaceIdOfTable<Table, BoardId>>(boardId: BoardId, spaceId: SpaceId, options?: {
+            mode?: "orthogonal" | "diagonal" | "all";
+        }) => SquareSpaceIdOfTable<Table, BoardId>[];
+        squareDistance: <BoardId extends SquareBoardIdOfTable<Table>, SpaceId extends SquareSpaceIdOfTable<Table, BoardId>>(boardId: BoardId, fromSpaceId: SpaceId, toSpaceId: SpaceId, options?: {
+            metric?: "manhattan" | "chebyshev";
+        }) => number;
+        spaceOccupants: <BoardId extends BoardIdOfTable<Table>, SpaceId extends SpaceIdOfTable<Table, BoardId>>(boardId: BoardId, spaceId: SpaceId) => ComponentIdOfTable<Table>[];
+        containerOccupants: <BoardId extends BoardIdOfTable<Table>, ContainerId extends BoardContainerIdOfTable<Table, BoardId>>(boardId: BoardId, containerId: ContainerId) => ComponentIdOfTable<Table>[];
+        edgeOccupants: <BoardId extends TiledBoardIdOfTable<Table>, EdgeId extends TiledEdgeIdOfTable<Table, BoardId>>(boardId: BoardId, edgeId: EdgeId) => ComponentIdOfTable<Table>[];
+        vertexOccupants: <BoardId extends TiledBoardIdOfTable<Table>, VertexId extends TiledVertexIdOfTable<Table, BoardId>>(boardId: BoardId, vertexId: VertexId) => 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 ManifestIdSchema<Output = unknown> = z.ZodType<Output> & {
+    readonly [manifestIdSchemaBrand]: true;
+};
+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")[];
+    setupOptionIds: readonly string[];
+    setupProfileIds: readonly string[];
+    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>;
+    setupChoiceIdsByOptionId: Record<string, readonly string[]>;
+    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;
+    setupOptionId: AnySchema;
+    setupProfileId: 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 StaticBoards<Table extends RuntimeTableRecord> = Pick<Table["boards"], "byId" | "hex" | "square">;
+type SetupOptionChoiceMetadata = {
+    id: string;
+    label: string;
+    description?: string | null;
+};
+type SetupOptionMetadata = {
+    id: string;
+    name: string;
+    description?: string | null;
+    choices: readonly SetupOptionChoiceMetadata[];
+};
+type SetupProfileMetadata = {
+    id: string;
+    name: string;
+    description?: string | null;
+    optionValues?: Record<string, string> | null;
+};
+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>;
+    staticBoards?: StaticBoards<Table>;
+    setupOptionsById: Record<string, SetupOptionMetadata>;
+    setupChoiceIdsByOptionId: Record<string, readonly string[]>;
+    setupProfilesById: Record<string, SetupProfileMetadata>;
+    tableSchema: z.ZodType<Table>;
+    runtimeSchema: AnySchema;
+    createGameStateSchema: (config: {
+        phaseNameSchema: AnySchema;
+        publicSchema: AnySchema;
+        privateSchema: AnySchema;
+        hiddenSchema: AnySchema;
+        phasesSchema: AnySchema;
+    }) => AnySchema;
+};
+type GeneratedManifestContractLike<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>>;
+declare function markManifestScopedSchema<Schema extends z.ZodTypeAny>(schema: Schema): Schema & ManifestIdSchema<z.infer<Schema>>;
+declare function createManifestStringLiteralSchema<Values extends readonly string[]>(values: Values): ManifestIdSchema<Values[number] extends never ? string : Values[number]>;
+declare function assumeManifestSchema<Output>(schema: z.ZodTypeAny): z.ZodType<Output>;
+declare function cloneManifestDefault<Value>(value: Value): Value;
+declare function resolveManifestPlayerIds<PlayerId extends string>(manifestPlayerIds: readonly PlayerId[], playerIds: readonly string[] | undefined): readonly PlayerId[];
+declare function createManifestRuntimeSchema<PhaseNameSchema extends z.ZodTypeAny, PlayerId extends string, SetupProfileId extends string>({ phaseNameSchema, playerIdSchema, setupProfileIdSchema, }: {
+    phaseNameSchema: PhaseNameSchema;
+    playerIdSchema: z.ZodType<PlayerId>;
+    setupProfileIdSchema: z.ZodType<SetupProfileId>;
+}): z.ZodObject<{
+    prompts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        promptId: z.ZodString;
+        to: z.ZodType<PlayerId, unknown, z.core.$ZodTypeInternals<PlayerId, unknown>>;
+        title: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>>>;
+        resume: z.ZodObject<{
+            id: z.ZodString;
+            data: z.ZodUnknown;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    rng: z.ZodDefault<z.ZodObject<{
+        seed: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        cursor: z.ZodDefault<z.ZodNumber>;
+        trace: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    setup: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        profileId: z.ZodType<SetupProfileId, unknown, z.core.$ZodTypeInternals<SetupProfileId, unknown>>;
+        optionValues: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+    }, z.core.$strip>>>;
+    simultaneous: z.ZodDefault<z.ZodObject<{
+        current: z.ZodNullable<z.ZodObject<{
+            phaseName: PhaseNameSchema;
+            actors: z.ZodArray<z.ZodType<PlayerId, unknown, z.core.$ZodTypeInternals<PlayerId, unknown>>>;
+            submissions: z.ZodRecord<z.ZodString, z.ZodObject<{
+                interactionId: z.ZodString;
+                params: z.ZodUnknown;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    lastTransition: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        from: PhaseNameSchema;
+        to: PhaseNameSchema;
+    }, z.core.$strip>>>;
+    nextInstanceId: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+declare function createManifestGameStateSchema<Table extends RuntimeTableRecord, PhaseNameSchema extends z.ZodTypeAny, PublicSchema extends z.ZodTypeAny, PrivateSchema extends z.ZodTypeAny, HiddenSchema extends z.ZodTypeAny, PhasesSchema extends z.ZodTypeAny, PlayerId extends string, SetupProfileId extends string>({ tableSchema, playerIdSchema, setupProfileIdSchema, phaseNameSchema, publicSchema, privateSchema, hiddenSchema, phasesSchema, }: {
+    tableSchema: z.ZodType<Table>;
+    playerIdSchema: z.ZodType<PlayerId>;
+    setupProfileIdSchema: z.ZodType<SetupProfileId>;
+    phaseNameSchema: PhaseNameSchema;
+    publicSchema: PublicSchema;
+    privateSchema: PrivateSchema;
+    hiddenSchema: HiddenSchema;
+    phasesSchema: PhasesSchema;
+}): z.ZodObject<{
+    table: z.ZodType<Table, unknown, z.core.$ZodTypeInternals<Table, unknown>>;
+    public: PublicSchema;
+    private: z.ZodRecord<z.ZodString, PrivateSchema>;
+    hidden: HiddenSchema;
+    flow: z.ZodObject<{
+        currentPhase: PhaseNameSchema;
+        turn: z.ZodNumber;
+        round: z.ZodNumber;
+        activePlayers: z.ZodArray<z.ZodType<PlayerId, unknown, z.core.$ZodTypeInternals<PlayerId, unknown>>>;
+    }, z.core.$strip>;
+    phase: PhasesSchema;
+    runtime: z.ZodObject<{
+        prompts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            promptId: z.ZodString;
+            to: z.ZodType<PlayerId, unknown, z.core.$ZodTypeInternals<PlayerId, unknown>>;
+            title: z.ZodOptional<z.ZodString>;
+            payload: z.ZodOptional<z.ZodUnknown>;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>>>;
+            resume: z.ZodObject<{
+                id: z.ZodString;
+                data: z.ZodUnknown;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>;
+        rng: z.ZodDefault<z.ZodObject<{
+            seed: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            cursor: z.ZodDefault<z.ZodNumber>;
+            trace: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        setup: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            profileId: z.ZodType<SetupProfileId, unknown, z.core.$ZodTypeInternals<SetupProfileId, unknown>>;
+            optionValues: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+        }, z.core.$strip>>>;
+        simultaneous: z.ZodDefault<z.ZodObject<{
+            current: z.ZodNullable<z.ZodObject<{
+                phaseName: PhaseNameSchema;
+                actors: z.ZodArray<z.ZodType<PlayerId, unknown, z.core.$ZodTypeInternals<PlayerId, unknown>>>;
+                submissions: z.ZodRecord<z.ZodString, z.ZodObject<{
+                    interactionId: z.ZodString;
+                    params: z.ZodUnknown;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        lastTransition: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            from: PhaseNameSchema;
+            to: PhaseNameSchema;
+        }, z.core.$strip>>>;
+        nextInstanceId: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+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>> = {
+    manifest: Manifest;
+    table: Table;
+    playerIds: PlayerIdOfTable<Table>[];
+    rngSeed?: number | null;
+    setup: SetupSelectionOfManifest<Manifest> | null;
+    q: TableQueriesOfState<{
+        table: Table;
+    }>;
+};
+type SetupBootstrapSharedZoneRef<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike> = {
+    type: "sharedZone";
+    zoneId: SharedZoneIdOfManifest<Manifest>;
+};
+type SetupBootstrapPerPlayerZoneRef<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike> = {
+    type: "playerZone";
+    zoneId: PlayerZoneIdOfManifest<Manifest>;
+    playerId: PlayerIdOfManifest<Manifest>;
+};
+type SetupBootstrapSharedBoardContainerRef<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike> = {
+    type: "sharedBoardContainer";
+    boardId: BoardBaseIdOfManifest<Manifest>;
+    containerId: BoardContainerIdOfManifest<Manifest>;
+};
+type SetupBootstrapPerPlayerBoardContainerRef<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike> = {
+    type: "playerBoardContainer";
+    boardId: BoardBaseIdOfManifest<Manifest>;
+    playerId: PlayerIdOfManifest<Manifest>;
+    containerId: BoardContainerIdOfManifest<Manifest>;
+};
+type SetupBootstrapSharedBoardSpaceRef<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike> = {
+    type: "sharedBoardSpace";
+    boardId: BoardBaseIdOfManifest<Manifest>;
+    spaceId: SpaceIdOfManifest<Manifest>;
+};
+type SetupBootstrapPerPlayerBoardSpaceRef<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike> = {
+    type: "playerBoardSpace";
+    boardId: BoardBaseIdOfManifest<Manifest>;
+    playerId: PlayerIdOfManifest<Manifest>;
+    spaceId: SpaceIdOfManifest<Manifest>;
+};
+type SetupBootstrapContainerRef<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike> = SetupBootstrapSharedZoneRef<Manifest> | SetupBootstrapPerPlayerZoneRef<Manifest> | SetupBootstrapSharedBoardContainerRef<Manifest> | SetupBootstrapPerPlayerBoardContainerRef<Manifest>;
+type SetupBootstrapDestinationRef<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike> = SetupBootstrapContainerRef<Manifest> | SetupBootstrapSharedBoardSpaceRef<Manifest> | SetupBootstrapPerPlayerBoardSpaceRef<Manifest>;
+type SetupBootstrapPerPlayerContainerTemplateRef<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike> = {
+    type: "playerZone";
+    zoneId: PlayerZoneIdOfManifest<Manifest>;
+} | {
+    type: "playerBoardContainer";
+    boardId: BoardBaseIdOfManifest<Manifest>;
+    containerId: BoardContainerIdOfManifest<Manifest>;
+};
+type SetupBootstrapStep<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike> = {
+    type: "shuffle";
+    container: SetupBootstrapContainerRef<Manifest>;
+} | {
+    type: "move";
+    from: SetupBootstrapContainerRef<Manifest>;
+    to: SetupBootstrapDestinationRef<Manifest>;
+    count?: number;
+    componentIds?: readonly (CardIdOfManifest<Manifest> | PieceIdOfManifest<Manifest> | DieIdOfManifest<Manifest>)[];
+} | {
+    type: "deal";
+    from: SetupBootstrapSharedZoneRef<Manifest> | SetupBootstrapSharedBoardContainerRef<Manifest>;
+    to: SetupBootstrapPerPlayerContainerTemplateRef<Manifest>;
+    count: number;
+    playerIds?: readonly PlayerIdOfManifest<Manifest>[];
+};
+type SetupProfileDefinition<PhaseName extends string = string, Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike> = {
+    initialPhase?: PhaseName;
+    bootstrap?: readonly SetupBootstrapStep<Manifest>[];
+};
+
+type FlowInstruction<PhaseName extends string> = {
+    kind: "flow.transition";
+    to: PhaseName;
+};
+type EngineRollDieInstruction = {
+    kind: "engine.rollDie";
+    dieId: string;
+    continuation?: AnyContinuationToken;
+};
+type EngineShuffleSharedZoneInstruction<DeckId extends string> = {
+    kind: "engine.shuffleSharedZone";
+    zoneId: DeckId;
+    continuation?: AnyContinuationToken;
+};
+type EngineShufflePlayerZoneInstruction<PlayerZoneId extends string, PlayerId extends string> = {
+    kind: "engine.shufflePlayerZone";
+    zoneId: PlayerZoneId;
+    playerId: PlayerId;
+    continuation?: AnyContinuationToken;
+};
+type EngineInstruction<DeckId extends string, PlayerZoneId extends string = string, PlayerId extends string = string> = EngineRollDieInstruction | EngineShuffleSharedZoneInstruction<DeckId> | EngineShufflePlayerZoneInstruction<PlayerZoneId, PlayerId>;
+type RuntimeInstruction<PhaseName extends string, DeckId extends string, PlayerZoneId extends string = string, PlayerId extends string = string> = FlowInstruction<PhaseName> | EngineInstruction<DeckId, PlayerZoneId, PlayerId>;
+type RuntimeInstructionForState<State> = RuntimeInstruction<PhaseNameOfState<State>, DeckIdOfState<State>, PlayerZoneIdOfState<State>, PlayerIdOfState<State>>;
+
+type ContinuationToken<Data = RuntimePayload, ContinuationId extends string = string, Response = RuntimePayload> = {
+    id: ContinuationId;
+    data: Data;
+    readonly __responseType?: Response;
+};
+type ContinuationResponseOf<Token> = Token extends ContinuationToken<any, string, infer Response> ? Response : never;
+type AnyContinuationToken = ContinuationToken<RuntimePayload, string, RuntimePayload>;
+/**
+ * Declarative choice option. Retained as the shape used by prompt-kind
+ * interactions' `options` field (see `InteractionSpec.options` in
+ * `model/spec.ts`). Independent of any specific prompt authoring API.
+ */
+type ChoiceOption<OptionId extends string = string> = {
+    id: OptionId;
+    label: string;
+};
+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[];
+};
+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;
+};
+/**
+ * Marker tag attached by `defineEffect` to every effect spec. `fx.effect`
+ * uses `type` to dispatch to the right wire-effect builder.
+ */
+type EffectTypeTag = "rollDie" | "shuffleSharedZone" | "shufflePlayerZone";
+/**
+ * Structural shape of the objects produced by `defineEffect`, as seen by
+ * the `fx.effect` dispatcher. The public, per-type effect definitions live
+ * in `model/spec.ts`.
+ */
+type EffectSpecLike<ContextSchema extends AnySchema = AnySchema> = {
+    type: EffectTypeTag;
+    id: string;
+    contextSchema?: ContextSchema;
+    /**
+     * Opaque authoring-time continuation callable. The runtime only needs its
+     * `id`; the heterogeneously-typed `(data) => ...` signature is erased
+     * here. The `data` parameter is typed as `never` so that this structural
+     * upper bound is assignable-from every concrete per-effect continuation
+     * (function parameters are contravariant — a specific `(data: T) => R`
+     * is assignable to `(data: X) => R` only when `X <: T`, and `never <: T`
+     * holds for every `T`).
+     */
+    __continuation?: ((data: never) => unknown) & {
+        id: string;
+    };
+};
+/**
+ * Options accepted by `fx.effect(effect, options)`, specialized by
+ * `effect.type`.
+ */
+type EffectContextValue<Effect extends EffectSpecLike> = NonNullable<Effect["contextSchema"]> extends AnySchema ? z.infer<NonNullable<Effect["contextSchema"]>> : undefined;
+type EffectInvokeOptions<Effect extends EffectSpecLike, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}> = Effect["type"] extends "rollDie" ? {
+    dieId: StringKeyOf<TableOfState<State>["dice"]>;
+    context?: EffectContextValue<Effect>;
+} : Effect["type"] extends "shuffleSharedZone" ? {
+    zoneId: DeckIdOfState<State>;
+    context?: EffectContextValue<Effect>;
+} : Effect["type"] extends "shufflePlayerZone" ? {
+    zoneId: PlayerZoneIdOfState<State>;
+    playerId: PlayerIdOfState<State>;
+    context?: EffectContextValue<Effect>;
+} : never;
+type EffectInstructionForState<Effect extends EffectSpecLike, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}> = Effect["type"] extends "rollDie" ? EngineRollDieInstruction : Effect["type"] extends "shuffleSharedZone" ? EngineShuffleSharedZoneInstruction<DeckIdOfState<State>> : Effect["type"] extends "shufflePlayerZone" ? EngineShufflePlayerZoneInstruction<PlayerZoneIdOfState<State>, PlayerIdOfState<State>> : never;
+type ReducerFx<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}> = {
+    transition: <To extends PhaseNameOfState<State>>(to: To) => FlowInstruction<To>;
+    /**
+     * Invoke an engine-side resumable effect authored via `defineEffect`.
+     * The returned runtime instruction is consumed by the engine; if the effect
+     * has a `reduce`, its continuation is delivered back as a typed input.
+     */
+    effect: <Effect extends EffectSpecLike>(effect: Effect, options: EffectInvokeOptions<Effect, State>) => EffectInstructionForState<Effect, State>;
+};
+type RuntimeState<PhaseName extends string, PlayerId extends string, Setup extends RuntimeSetupSelection = RuntimeSetupSelection> = {
+    rng: RuntimeRngState;
+    setup: Setup | null;
+    simultaneous: RuntimeSimultaneousState<PhaseName, PlayerId>;
+    lastTransition: {
+        from: PhaseName;
+        to: PhaseName;
+    } | null;
+};
+type ReducerRuntimeStateForState<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Setup extends RuntimeSetupSelection = RuntimeSetupSelection> = RuntimeState<PhaseNameOfState<State>, PlayerIdOfState<State>, Setup>;
+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;
+    instructions?: RuntimeInstructionForState<State>[];
+};
+type ReducerResult<State> = ReducerAccept<State> | ReducerReject;
+
+/**
+ * State composition primitives.
+ *
+ * `pipe` threads a seed state through a sequence of `State -> State`
+ * transformations, left to right. It is the preferred way to compose curried
+ * writers (the `ops.*` namespace) in reducers:
+ *
+ *     return accept(
+ *       pipe(state,
+ *         ops.spendPlayerResources({ playerId, resources: cost }),
+ *         ops.placePieceOnVertex({ boardId, vertexId, pieceId, ownerId: playerId }),
+ *       ),
+ *     );
+ */
+/**
+ * A state-preserving transformation.
+ *
+ * `Op<State>` is polymorphic in the exact input subtype — given a state `S`
+ * that extends `State`, it returns the same `S`. This lets curried writers
+ * from `ops.*` and author-written helpers thread through phase-scoped `pipe`
+ * calls without losing the narrowed phase state type.
+ */
+type Op<State> = <S extends State>(state: S) => S;
+declare function pipe<State>(state: State, ...ops: ReadonlyArray<Op<NoInfer<State>>>): State;
+
+/**
+ * Curried state writers for use with `pipe`.
+ *
+ * Each entry in the returned `ops` namespace is a curried transformation
+ * `(args) => (state) => state` that can be composed with `pipe`:
+ *
+ *     const ops = createReducerOps<GameState>();
+ *
+ *     return accept(
+ *       pipe(state,
+ *         ops.setActivePlayers([playerId]),
+ *         ops.moveCardFromPlayerZoneToSharedZone({
+ *           playerId,
+ *           fromZoneId: "things-hand",
+ *           toZoneId: "ring-1",
+ *           cardId: "a-dog",
+ *         }),
+ *       ),
+ *     );
+ *
+ * The factory binds all ops to a specific `State` type so that ID arguments
+ * (deck ids, card ids, etc.) are checked against the manifest-derived table
+ * shape of the game.
+ */
+
+/**
+ * Minimum shape required for any state targeted by reducer ops.
+ *
+ * All curried writers operate on a game state with a `table` field.
+ */
+type ReducerStateBase = {
+    table: RuntimeTableRecord;
+};
+type PipeTable<State extends ReducerStateBase> = TableOfState<State>;
+/**
+ * A shallow patch for a slice of state. Either a partial object to merge
+ * over the previous value, or a functional updater `(prev) => next`.
+ */
+type StatePatch<T> = Partial<T> | ((prev: T) => T);
+/**
+ * Curried writer namespace for a specific game state type.
+ *
+ * Created via {@link createReducerOps}.
+ */
+interface ReducerOps<State extends ReducerStateBase> {
+    /** Set the list of players whose turn is currently active. */
+    setActivePlayers(activePlayers: ReadonlyArray<PlayerIdOfState<State>>): Op<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(): Op<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>>): Op<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>>): Op<State>;
+    /**
+     * Update `state.hiddenState`.
+     *
+     * Accepts either a `Partial<HiddenState>` or a functional updater.
+     */
+    patchHiddenState(patch: StatePatch<HiddenStateOfState<State>>): Op<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>>;
+    }): Op<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<PipeTable<State>>>(args: {
+        deckId: DeckId;
+        cardId: DeckCardsOfTable<PipeTable<State>, DeckId>[number];
+        playedBy?: PlayerIdOfTable<PipeTable<State>> | null;
+        position?: "top" | "bottom";
+    }): Op<State>;
+    /** Remove a card from a shared zone (deck). */
+    removeCardFromSharedZone<DeckId extends DeckIdOfTable<PipeTable<State>>>(args: {
+        deckId: DeckId;
+        cardId: DeckCardsOfTable<PipeTable<State>, DeckId>[number];
+    }): Op<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<PipeTable<State>>, ToZoneId extends SharedZoneIdOfTable<PipeTable<State>>>(args: {
+        fromZoneId: FromZoneId;
+        toZoneId: ToZoneId;
+        cardId: DeckCardsOfTable<PipeTable<State>, FromZoneId>[number];
+        playedBy?: PlayerIdOfTable<PipeTable<State>> | null;
+        position?: "top" | "bottom";
+    }): Op<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 dealCardsToPlayerZone} for the perPlayer → perPlayer case. Stops
+     * silently if the source runs out before `count` is reached.
+     */
+    dealCardsBetweenPlayerZones<FromZoneId extends PlayerZoneIdOfTable<PipeTable<State>>, ToZoneId extends PlayerZoneIdOfTable<PipeTable<State>>, PlayerId extends PlayerIdOfTable<PipeTable<State>>>(args: {
+        playerId: PlayerId;
+        fromZoneId: FromZoneId;
+        toZoneId: ToZoneId;
+        count: number;
+    }): Op<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<PipeTable<State>>, ToZoneId extends PlayerZoneIdOfTable<PipeTable<State>>, PlayerId extends PlayerIdOfTable<PipeTable<State>>>(args: {
+        playerId: PlayerId;
+        fromZoneId: FromZoneId;
+        toZoneId: ToZoneId;
+        cardId: CompatibleCardIdForTwoPlayerZones<PipeTable<State>, FromZoneId, ToZoneId>;
+        position?: "top" | "bottom";
+    }): Op<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<PipeTable<State>>, ToZoneId extends SharedZoneIdOfTable<PipeTable<State>>, PlayerId extends PlayerIdOfTable<PipeTable<State>>>(args: {
+        playerId: PlayerId;
+        fromZoneId: FromZoneId;
+        toZoneId: ToZoneId;
+        cardId: CompatibleCardIdForHandAndDeck<PipeTable<State>, FromZoneId, ToZoneId>;
+        playedBy?: PlayerIdOfTable<PipeTable<State>> | null;
+        position?: "top" | "bottom";
+    }): Op<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 dealCardsToPlayerZone}, which draws unspecified top-N cards from a
+     * deck. Owner flips to the receiving player; visibility is recomputed.
+     */
+    moveCardFromSharedZoneToPlayerZone<FromZoneId extends SharedZoneIdOfTable<PipeTable<State>>, ToZoneId extends PlayerZoneIdOfTable<PipeTable<State>>, PlayerId extends PlayerIdOfTable<PipeTable<State>>>(args: {
+        playerId: PlayerId;
+        fromZoneId: FromZoneId;
+        toZoneId: ToZoneId;
+        cardId: CompatibleCardIdForHandAndDeck<PipeTable<State>, ToZoneId, FromZoneId>;
+        position?: "top" | "bottom";
+    }): Op<State>;
+    /**
+     * Deal the top `count` cards from a shared deck into a player's hand zone.
+     *
+     * This op does not consume RNG. If the deck needs to be random, shuffle it
+     * first with `fx.shuffleSharedZone(...)`, then deal from the shuffled deck
+     * inside the same reducer via this op.
+     */
+    dealCardsToPlayerZone<FromZoneId extends DeckIdOfTable<PipeTable<State>>, PlayerId extends PlayerIdOfTable<PipeTable<State>>, ToZoneId extends CompatibleHandIdForDeck<PipeTable<State>, FromZoneId> & HandIdOfTable<PipeTable<State>>>(args: {
+        fromZoneId: FromZoneId;
+        playerId: PlayerId;
+        toZoneId: ToZoneId;
+        count: number;
+    }): Op<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<PipeTable<State>>, PlayerId extends PlayerIdOfTable<PipeTable<State>>>(args: {
+        zoneId: ZoneId;
+        direction: "left" | "right";
+        players?: readonly PlayerId[];
+        cardIdsByPlayer?: Partial<Record<PlayerId, readonly CardIdOfTable<PipeTable<State>>[]>>;
+        position?: "top" | "bottom";
+    }): Op<State>;
+    /** Move a component onto a board space. */
+    moveComponentToSpace<BoardId extends BoardIdOfTable<PipeTable<State>>, SpaceId extends SpaceIdOfTable<PipeTable<State>, BoardId>, ComponentId extends ComponentIdOfTable<PipeTable<State>>>(args: {
+        componentId: ComponentId;
+        boardId: BoardId;
+        spaceId: SpaceId;
+    }): Op<State>;
+    /** Move a component into a board container. */
+    moveComponentToContainer<BoardId extends BoardIdOfTable<PipeTable<State>>, ContainerId extends BoardContainerIdOfTable<PipeTable<State>, BoardId>, ComponentId extends ComponentIdOfTable<PipeTable<State>>>(args: {
+        componentId: ComponentId;
+        boardId: BoardId;
+        containerId: ContainerId;
+    }): Op<State>;
+    /** Move a component onto a tiled board edge. */
+    moveComponentToEdge<BoardId extends TiledBoardIdOfTable<PipeTable<State>>, EdgeId extends TiledEdgeIdOfTable<PipeTable<State>, BoardId>, ComponentId extends ComponentIdOfTable<PipeTable<State>>>(args: {
+        componentId: ComponentId;
+        boardId: BoardId;
+        edgeId: EdgeId;
+    }): Op<State>;
+    /** Move a component onto a tiled board vertex. */
+    moveComponentToVertex<BoardId extends TiledBoardIdOfTable<PipeTable<State>>, VertexId extends TiledVertexIdOfTable<PipeTable<State>, BoardId>, ComponentId extends ComponentIdOfTable<PipeTable<State>>>(args: {
+        componentId: ComponentId;
+        boardId: BoardId;
+        vertexId: VertexId;
+    }): Op<State>;
+    /** Move a component back to the detached pool. */
+    moveComponentToDetached<ComponentId extends ComponentIdOfTable<PipeTable<State>>>(args: {
+        componentId: ComponentId;
+    }): Op<State>;
+    /**
+     * Credit the specified resources to a player.
+     *
+     * Amounts must be non-negative; use {@link spendResources} for deductions
+     * so that affordability is checked explicitly.
+     *
+     *     pipe(
+     *       state,
+     *       ops.addResources({ playerId, amounts: { wood: 1, brick: 1 } }),
+     *     )
+     */
+    addResources(args: {
+        playerId: PlayerIdOfTable<PipeTable<State>>;
+        amounts: ResourceAmountsOfTable<PipeTable<State>>;
+    }): Op<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.
+     *
+     *     pipe(
+     *       state,
+     *       ops.spendResources({ playerId, amounts: COST_DEV_CARD }),
+     *       ops.dealCardsToPlayerZone({ ... }),
+     *     )
+     */
+    spendResources(args: {
+        playerId: PlayerIdOfTable<PipeTable<State>>;
+        amounts: ResourceAmountsOfTable<PipeTable<State>>;
+    }): Op<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<PipeTable<State>>;
+        toPlayerId: PlayerIdOfTable<PipeTable<State>>;
+        amounts: ResourceAmountsOfTable<PipeTable<State>>;
+    }): Op<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<PipeTable<State>>;
+        resourceId: ResourceIdOfTable<PipeTable<State>>;
+        amount: number;
+    }): Op<State>;
+}
+/**
+ * Create the `ops.*` namespace specialised to a game state.
+ *
+ * Call this once (typically in a shared reducer-support module) and reuse the
+ * resulting object across phases:
+ *
+ *     export const ops = createReducerOps<GameState>();
+ */
+declare function createReducerOps<State extends ReducerStateBase>(): ReducerOps<State>;
+
+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";
+};
+type TransactionMethods<State extends {
+    table: RuntimeTableRecord;
+}> = {
+    [Key in Exclude<keyof ReducerOps<State>, "moveComponentToSpace">]: ReducerOps<State>[Key] extends (...args: infer Args) => Op<State> ? (...args: Args) => State : never;
+} & {
+    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;
+};
+type ReducerTransaction<State extends {
+    table: RuntimeTableRecord;
+}> = TransactionMethods<State> & {
+    readonly state: State;
+    readonly q: TableQueriesOfState<State>;
+    apply(op: Op<State>): State;
+    rotatePlayerZone<ZoneId extends PlayerZoneIdOfTable<TableOfState<State>>, PlayerId extends PlayerIdOfTable<TableOfState<State>>>(args: RotatePlayerZoneArgs<State, ZoneId, PlayerId>): State;
+};
+type ReducerEdit<State extends {
+    table: RuntimeTableRecord;
+}> = <DraftState extends State>(state: DraftState) => ReducerTransaction<DraftState>;
+declare function createReducerTransaction<State extends {
+    table: RuntimeTableRecord;
+}>(initialState: State, ops?: ReducerOps<State>): ReducerTransaction<State>;
+declare function createReducerEdit<State extends {
+    table: RuntimeTableRecord;
+}>(ops?: ReducerOps<State>): ReducerEdit<State>;
+
+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>>> = {
+    manifest: Manifest;
+    state: StateDefinition<PublicSchema, PrivateSchema, HiddenSchema>;
+    phases: Phases;
+    /** 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/
+ * Stages/Zones 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>, EffectMap<BaseGameStateOfContract<Contract>, ManifestContractOf<Contract>>, InteractionMap<BaseGameStateOfContract<Contract>, ManifestContractOf<Contract>>, StageMap<BaseGameStateOfContract<Contract>, ManifestContractOf<Contract>>, PhaseZoneList<ManifestContractOf<Contract>>, CardActionMap<BaseGameStateOfContract<Contract>, ManifestContractOf<Contract>>>;
+};
+type PhaseStateOfDefinitions<Definitions extends Record<string, PhaseDefinition<SchemaLike<object>, any, any, Record<string, InputCollector>, EffectMap<any, any>, InteractionMap<any, any>, StageMap<any, any>, PhaseZoneList<any>, CardActionMap<any, any>>>> = {
+    [Name in keyof Definitions & string]: Definitions[Name] extends PhaseDefinition<infer PhaseStateSchema, infer _State, infer _Manifest> ? 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 PhaseDefinition<infer PhaseStateSchema, infer _State, infer _Manifest> ? 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 ViewMapOf<Contract> = Record<string, ViewDefinition<BaseGameStateOfContract<Contract>, ManifestContractOf<Contract>, unknown>>;
+type PhasesOfDefinition<Definition> = Definition extends {
+    phases: infer Definitions extends Record<string, unknown>;
+} ? Definitions : never;
+type ViewsOfDefinition<Definition> = Definition extends {
+    views?: infer Views;
+} ? NonNullable<Views> : never;
+type NonNeverKeys<Registry> = {
+    [Key in keyof Registry]-?: [Registry[Key]] extends [never] ? never : Key;
+}[keyof Registry];
+type ViewNamesOfDefinition<Definition> = NonNeverKeys<ViewsOfDefinition<Definition>> & string;
+type ViewDefinitionByName<Definition, ViewName extends ViewNamesOfDefinition<Definition>> = ViewsOfDefinition<Definition>[ViewName];
+type ViewOfDefinition<Definition, ViewName extends ViewNamesOfDefinition<Definition>> = ViewDefinitionByName<Definition, ViewName> extends ViewDefinition<infer _State, infer _Manifest, 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 EffectsOfDefinition<Definition> = PhasesOfDefinition<Definition>[keyof PhasesOfDefinition<Definition> & string] extends {
+    effects?: infer Effects;
+} ? Effects extends Record<string, unknown> ? Effects[keyof Effects & string] : never : never;
+type EffectIdsOfDefinition<Definition> = EffectsOfDefinition<Definition> extends infer Effect ? Effect extends {
+    id: infer Id;
+} ? Extract<Id, string> : never : never;
+type GameStateOf<Source> = Source extends ReducerGameDefinition<infer Contract, infer Definitions, infer _Views> ? ResolvedGameStateOf<Contract, Definitions> : Source extends ReducerGameContract<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;
+    state: StateDefinition<SchemaLike<object>, SchemaLike<object>, SchemaLike<object>>;
+};
+type InitialStateContextOf<Contract extends ReducerGameContractLike> = InitContext<TableOfManifest<ManifestOf<Contract>>, ExactManifestContractOf<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>, Views extends ViewMapOf<Contract> = Record<string, never>> = {
+    contract: Contract;
+    initial?: InitialStateCallbacks<NoInfer<Contract>>;
+    initialPhase?: keyof Definitions & string;
+    setupProfiles?: Record<string, SetupProfileDefinition<keyof Definitions & string, ExactManifestContractOf<Contract>>>;
+    phases: Definitions;
+    views?: Views;
+    /**
+     * Optional session-scoped static projection. Authored via
+     * {@link StaticViewDefinition}; computed once per reducer session from the
+     * manifest + setup profile and cached by the host. The client merges the
+     * cached payload into every seat view, so the per-tick `projectSeatsDynamic`
+     * call no longer needs to re-serialize static board topology.
+     */
+    staticView?: StaticViewDefinition<ExactManifestContractOf<NoInfer<Contract>>, unknown>;
+};
+type InteractionRegistriesOfDefinition<Definition> = PhasesOfDefinition<Definition>[keyof PhasesOfDefinition<Definition> & string] extends {
+    interactions?: infer Interactions;
+} ? NonNullable<Interactions> : never;
+type SimultaneousSubmitRegistriesOfDefinition<Definition> = PhasesOfDefinition<Definition>[keyof PhasesOfDefinition<Definition> & string] extends {
+    submit?: infer Submit;
+} ? {
+    submit: NonNullable<Submit>;
+} : never;
+type CardActionRegistriesOfDefinition<Definition> = PhasesOfDefinition<Definition>[keyof PhasesOfDefinition<Definition> & string] extends {
+    cardActions?: infer CardActions;
+} ? NonNullable<CardActions> : never;
+type InteractionIdOfDefinition<Definition> = InteractionRegistriesOfDefinition<Definition> extends infer Interactions ? SimultaneousSubmitRegistriesOfDefinition<Definition> extends infer Submit ? CardActionRegistriesOfDefinition<Definition> extends infer CardActions ? Interactions extends Record<string, unknown> ? CardActions extends Record<string, unknown> ? Submit extends Record<string, unknown> ? (NonNeverKeys<Interactions> & string) | (NonNeverKeys<CardActions> & string) | (NonNeverKeys<Submit> & string) : (NonNeverKeys<Interactions> & string) | (NonNeverKeys<CardActions> & string) : Submit extends Record<string, unknown> ? (NonNeverKeys<Interactions> & string) | (NonNeverKeys<Submit> & string) : NonNeverKeys<Interactions> & string : CardActions extends Record<string, unknown> ? Submit extends Record<string, unknown> ? (NonNeverKeys<CardActions> & string) | (NonNeverKeys<Submit> & string) : NonNeverKeys<CardActions> & string : Submit extends Record<string, unknown> ? NonNeverKeys<Submit> & string : never : never : never : 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 CardActionRegistryOfDefinitionPhase<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>> = PhaseDefinitionByName<Definition, PhaseName> extends {
+    cardActions?: infer CardActions;
+} ? NonNullable<CardActions> : 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>> = InteractionRegistryOfDefinitionPhase<Definition, PhaseName> extends infer Interactions ? SimultaneousSubmitRegistryOfDefinitionPhase<Definition, PhaseName> extends infer Submit ? CardActionRegistryOfDefinitionPhase<Definition, PhaseName> extends infer CardActions ? Interactions extends Record<string, unknown> ? CardActions extends Record<string, unknown> ? Submit extends Record<string, unknown> ? (NonNeverKeys<Interactions> & string) | (NonNeverKeys<CardActions> & string) | (NonNeverKeys<Submit> & string) : (NonNeverKeys<Interactions> & string) | (NonNeverKeys<CardActions> & string) : Submit extends Record<string, unknown> ? (NonNeverKeys<Interactions> & string) | (NonNeverKeys<Submit> & string) : NonNeverKeys<Interactions> & string : CardActions extends Record<string, unknown> ? Submit extends Record<string, unknown> ? (NonNeverKeys<CardActions> & string) | (NonNeverKeys<Submit> & string) : NonNeverKeys<CardActions> & string : Submit extends Record<string, unknown> ? NonNeverKeys<Submit> & string : never : never : never : never;
+type InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>, InteractionId extends InteractionIdOfDefinitionPhase<Definition, PhaseName>> = InteractionRegistryOfDefinitionPhase<Definition, PhaseName> extends infer Interactions ? Interactions extends Record<string, unknown> ? NonNeverRegistryValue<Interactions, InteractionId> extends infer InteractionSpec ? [InteractionSpec] extends [never] ? CardActionRegistryOfDefinitionPhase<Definition, PhaseName> extends infer CardActions ? NonNeverRegistryValue<CardActions, InteractionId> extends infer CardActionSpec ? [CardActionSpec] extends [never] ? SimultaneousSubmitRegistryOfDefinitionPhase<Definition, PhaseName> extends infer Submit ? NonNeverRegistryValue<Submit, InteractionId> : never : CardActionSpec : never : never : InteractionSpec : never : never : never;
+type CollectorKindsOf<Collectors> = Collectors extends Record<string, InputCollector> ? Collectors[keyof Collectors] extends infer Collector ? Collector extends {
+    kind: infer Kind extends string;
+} ? Kind : never : never : never;
+type CollectorKeysWithKind<Collectors, Kind extends string> = Collectors extends Record<string, InputCollector> ? {
+    [K in keyof Collectors]: Collectors[K] extends {
+        kind: infer CollectorKind;
+    } ? Extract<CollectorKind, Kind> extends never ? never : K : never;
+}[keyof Collectors] : never;
+type CardCollectorZoneIds<Collector> = Collector extends {
+    kind: "card";
+    meta: infer Meta;
+} ? Meta extends {
+    readonly zoneIds: infer ZoneIds extends readonly string[];
+} ? ZoneIds[number] : Meta extends {
+    readonly zoneId: infer ZoneId extends string;
+} ? ZoneId : never : never;
+type CollectorCardZoneIds<Collectors, Input extends string> = Collectors extends Record<string, InputCollector> ? Input extends keyof Collectors ? CardCollectorZoneIds<Collectors[Input]> : never : never;
+type InteractionIdsWithCollectorKindOfDefinitionPhase<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>, Kind extends string> = {
+    [InteractionId in InteractionIdOfDefinitionPhase<Definition, PhaseName>]: InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends InteractionSpec<infer Collectors, infer _State, infer _Manifest> ? Extract<CollectorKindsOf<Collectors>, Kind> extends never ? never : InteractionId : InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends CardActionSpec<infer Collectors, infer _State, infer _Manifest> ? Extract<"card" | CollectorKindsOf<Collectors>, Kind> extends never ? never : InteractionId : InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends SimultaneousSubmitSpec<infer Collectors, infer _State, infer _Manifest> ? Extract<CollectorKindsOf<Collectors>, Kind> extends never ? never : InteractionId : never;
+}[InteractionIdOfDefinitionPhase<Definition, PhaseName>];
+type QualifiedInteractionIdsWithCollectorKindOfDefinitionPhase<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>, Kind extends string> = InteractionIdsWithCollectorKindOfDefinitionPhase<Definition, PhaseName, Kind> extends infer InteractionId extends string ? `${PhaseName}.${InteractionId}` : never;
+type PromptInteractionKeyOfDefinition<Definition> = {
+    [PhaseName in PhaseNamesOfDefinition<Definition>]: QualifiedInteractionIdsWithCollectorKindOfDefinitionPhase<Definition, PhaseName, "prompt">;
+}[PhaseNamesOfDefinition<Definition>];
+type BoardInteractionKeyOfDefinition<Definition> = {
+    [PhaseName in PhaseNamesOfDefinition<Definition>]: QualifiedInteractionIdsWithCollectorKindOfDefinitionPhase<Definition, PhaseName, "board-edge" | "board-space" | "board-tile" | "board-vertex">;
+}[PhaseNamesOfDefinition<Definition>];
+type CardInteractionKeyOfDefinition<Definition> = {
+    [PhaseName in PhaseNamesOfDefinition<Definition>]: QualifiedInteractionIdsWithCollectorKindOfDefinitionPhase<Definition, PhaseName, "card">;
+}[PhaseNamesOfDefinition<Definition>];
+type InputKeysWithCollectorKindOfDefinition<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>, InteractionId extends InteractionIdOfDefinitionPhase<Definition, PhaseName>, Kind extends string> = InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends InteractionSpec<infer Collectors, infer _State, infer _Manifest> ? CollectorKeysWithKind<Collectors, Kind> & string : InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends CardActionSpec<infer Collectors, infer _State, infer _Manifest> ? (Extract<"card", Kind> extends never ? never : "cardId") | (CollectorKeysWithKind<Collectors, Kind> & string) : InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends SimultaneousSubmitSpec<infer Collectors, infer _State, infer _Manifest> ? CollectorKeysWithKind<Collectors, Kind> & string : never;
+type CardInputZoneIdsOfDefinition<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>, InteractionId extends InteractionIdOfDefinitionPhase<Definition, PhaseName>, Input extends string> = InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends InteractionSpec<infer Collectors, infer _State, infer _Manifest> ? CollectorCardZoneIds<Collectors, Input> : InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends CardActionSpec<infer Collectors, infer _State, infer _Manifest> ? Input extends "cardId" ? InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends {
+    readonly playFrom: infer PlayFrom extends string;
+} ? PlayFrom : never : CollectorCardZoneIds<Collectors, Input> : InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends SimultaneousSubmitSpec<infer Collectors, infer _State, infer _Manifest> ? CollectorCardZoneIds<Collectors, Input> : never;
+type ParamsOfInteractionOfDefinition<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>, InteractionId extends InteractionIdOfDefinitionPhase<Definition, PhaseName>> = InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends InteractionSpec<infer Collectors, infer _State, infer _Manifest> ? Collectors extends Record<string, InputCollector> ? {
+    [K in keyof Collectors]: Collectors[K] extends InputCollector<infer S, infer _S2> ? S extends SchemaLike<infer V> ? V : never : never;
+} : never : InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends CardActionSpec<infer Collectors, infer _State, infer _Manifest> ? Collectors extends Record<string, InputCollector> ? {
+    cardId: string;
+} & {
+    [K in keyof Collectors]: Collectors[K] extends InputCollector<infer S, infer _S2> ? S extends SchemaLike<infer V> ? V : never : never;
+} : {
+    cardId: string;
+} : InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends SimultaneousSubmitSpec<infer Collectors, infer _State, infer _Manifest> ? Collectors extends Record<string, InputCollector> ? {
+    [K in keyof Collectors]: Collectors[K] extends InputCollector<infer S, infer _S2> ? S extends SchemaLike<infer V> ? V : never : 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
+ * in `shared/generated/ui-contract.ts`. The `reduce`-input counterpart is
+ * {@link ParamsOfInteractionOfDefinition}, which includes every field
+ * because the engine has already filled the sampled ones by then.
+ */
+type ClientParamsOfInteractionOfDefinition<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>, InteractionId extends InteractionIdOfDefinitionPhase<Definition, PhaseName>> = InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends InteractionSpec<infer Collectors, infer _State, infer _Manifest> ? Collectors extends Record<string, InputCollector> ? {
+    [K in keyof Collectors as Collectors[K] extends InputCollector<infer _S, infer _S2> & {
+        kind: "rng";
+    } ? never : K]: Collectors[K] extends InputCollector<infer S, infer _S2> ? S extends SchemaLike<infer V> ? V : never : never;
+} : never : InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends CardActionSpec<infer Collectors, infer _State, infer _Manifest> ? Collectors extends Record<string, InputCollector> ? {
+    cardId: string;
+} & {
+    [K in keyof Collectors as Collectors[K] extends InputCollector<infer _S, infer _S2> & {
+        kind: "rng";
+    } ? never : K]: Collectors[K] extends InputCollector<infer S, infer _S2> ? S extends SchemaLike<infer V> ? V : never : never;
+} : {
+    cardId: string;
+} : InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends SimultaneousSubmitSpec<infer Collectors, infer _State, infer _Manifest> ? Collectors extends Record<string, InputCollector> ? {
+    [K in keyof Collectors as Collectors[K] extends InputCollector<infer _S, infer _S2> & {
+        kind: "rng";
+    } ? never : K]: Collectors[K] extends InputCollector<infer S, infer _S2> ? S extends SchemaLike<infer V> ? V : never : never;
+} : never : never;
+type DefaultedClientCollectorKeys<Collectors extends Record<string, InputCollector>> = {
+    [K in keyof Collectors]: Collectors[K] extends InputCollector<infer _S, infer _S2> & {
+        kind: "rng";
+    } ? never : Collectors[K] extends {
+        readonly defaultValue: unknown;
+    } ? K : never;
+}[keyof Collectors];
+type DefaultedClientParamKeysOfInteractionOfDefinition<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>, InteractionId extends InteractionIdOfDefinitionPhase<Definition, PhaseName>> = InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends InteractionSpec<infer Collectors, infer _State, infer _Manifest> ? Collectors extends Record<string, InputCollector> ? DefaultedClientCollectorKeys<Collectors> & string : never : InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends CardActionSpec<infer Collectors, infer _State, infer _Manifest> ? Collectors extends Record<string, InputCollector> ? DefaultedClientCollectorKeys<Collectors> & string : never : InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends SimultaneousSubmitSpec<infer Collectors, infer _State, infer _Manifest> ? Collectors extends Record<string, InputCollector> ? DefaultedClientCollectorKeys<Collectors> & string : never : never;
+type StageRegistryOfDefinitionPhase<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>> = PhaseDefinitionByName<Definition, PhaseName> extends {
+    stages?: infer Stages;
+} ? NonNullable<Stages> : Record<string, never>;
+type StageNamesOfDefinitionPhase<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>> = StageRegistryOfDefinitionPhase<Definition, PhaseName> extends infer Stages ? Stages extends Record<string, unknown> ? NonNeverKeys<Stages> & string : never : never;
+type ZoneRegistriesOfDefinition<Definition> = PhasesOfDefinition<Definition>[keyof PhasesOfDefinition<Definition> & string] extends {
+    zones?: infer Zones;
+} ? NonNullable<Zones> : never;
+type ZoneIdsOfDefinition<Definition> = ZoneRegistriesOfDefinition<Definition> extends infer Zones ? Zones extends readonly (infer ZoneId)[] ? Extract<ZoneId, string> : never : never;
+type ZoneListOfDefinitionPhase<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>> = PhaseDefinitionByName<Definition, PhaseName> extends {
+    zones?: infer Zones;
+} ? NonNullable<Zones> : readonly [];
+type PlayableInteractionsOfZoneOfDefinition<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>, ZoneId extends string> = ZoneListOfDefinitionPhase<Definition, PhaseName> extends readonly (infer From)[] ? Extract<From, ZoneId> extends never ? never : CardActionRegistryOfDefinitionPhase<Definition, PhaseName> extends infer CardActions ? CardActions extends Record<string, unknown> ? {
+    [ActionId in keyof CardActions & string]: CardActions[ActionId] extends {
+        playFrom: infer PlayFrom extends string;
+    } ? Extract<PlayFrom, ZoneId> extends never ? never : ActionId : never;
+}[keyof CardActions & string] : never : never : never;
+
+/**
+ * A freestanding, memoized projection of immutable game state.
+ *
+ * Use `defineDerived` for values that are pure functions of component
+ * locations, zone contents, resources, or other state fields - and are
+ * consumed from multiple reducer or view call sites, or whose compute cost
+ * is non-trivial (graph walks, aggregate reductions).
+ *
+ * Do NOT cache derived values in `publicState`. State fields should be
+ * inputs to derivations, not mirrors of them.
+ */
+type DerivedDefinition<Contract, Value> = {
+    /** Optional label for debugging. Does not affect caching. */
+    readonly name?: string;
+    readonly compute: (ctx: {
+        readonly state: BaseGameStateOfContract<Contract>;
+        readonly q: TableQueriesOfState<BaseGameStateOfContract<Contract>>;
+        readonly derived: DerivedResolver;
+    }) => Value;
+};
+/**
+ * Resolves a `DerivedDefinition` to its value. Callers do not need to know
+ * about memoization - the resolver handles caching internally.
+ */
+type DerivedResolver = <Value>(def: DerivedDefinition<never, Value>) => Value;
+/**
+ * Author-facing factory for creating a derived value tied to a game
+ * contract. Usage:
+ *
+ * ```ts
+ * export const longestRoad = defineDerived<GameContract>()({
+ *   name: "longestRoad",
+ *   compute: ({ q, derived }) => computeLongestRoad(q),
+ * });
+ * ```
+ */
+declare function defineDerived<Contract>(): <Value>(def: {
+    name?: string;
+    compute: (ctx: {
+        state: BaseGameStateOfContract<Contract>;
+        q: TableQueriesOfState<BaseGameStateOfContract<Contract>>;
+        derived: DerivedResolver;
+    }) => Value;
+}) => DerivedDefinition<Contract, Value>;
+/**
+ * Creates a resolver scoped to a single state snapshot. Each engine tick
+ * and each view projection call creates its own resolver; cache lifetime
+ * ends with the call. Cache key is the `DerivedDefinition` identity (the
+ * object reference).
+ *
+ * Re-entry on an in-flight definition throws a readable error.
+ */
+declare function createDerivedResolver<State extends {
+    table: RuntimeTableRecord;
+}>(state: State, options?: {
+    q?: TableQueriesOfState<State>;
+}): DerivedResolver;
+
+type StaticBoardsOfManifest<Manifest> = Manifest extends {
+    staticBoards?: infer StaticBoards;
+} ? NonNullable<StaticBoards> : {
+    byId: Record<string, never>;
+    hex: Record<string, never>;
+    square: Record<string, never>;
+};
+type StaticBoardMapOfManifest<Manifest> = StaticBoardsOfManifest<Manifest> extends {
+    byId: infer Boards;
+} ? Boards : Record<string, never>;
+type StaticHexBoardMapOfManifest<Manifest> = StaticBoardsOfManifest<Manifest> extends {
+    hex: infer Boards;
+} ? Boards : Record<string, never>;
+type StaticSquareBoardMapOfManifest<Manifest> = StaticBoardsOfManifest<Manifest> extends {
+    square: infer Boards;
+} ? Boards : Record<string, never>;
+type StaticViewQueries<Manifest extends ManifestContract<RuntimeTableRecord>> = {
+    board: {
+        get: <BoardId extends StringKeyOf<StaticBoardMapOfManifest<Manifest>>>(boardId: BoardId) => StaticBoardMapOfManifest<Manifest>[BoardId];
+        hex: <BoardId extends StringKeyOf<StaticHexBoardMapOfManifest<Manifest>>>(boardId: BoardId) => StaticHexBoardMapOfManifest<Manifest>[BoardId];
+        square: <BoardId extends StringKeyOf<StaticSquareBoardMapOfManifest<Manifest>>>(boardId: BoardId) => StaticSquareBoardMapOfManifest<Manifest>[BoardId];
+    };
+};
+type ContinuationSourceKind = "effect";
+type ResumableEffectKind = "rollDie" | "shuffleSharedZone" | "shufflePlayerZone";
+type RollDieContinuationResponse = {
+    dieId: string;
+    value: number;
+};
+type ShuffleSharedZoneContinuationResponse = {
+    zoneId: string;
+    orderedCardIds: readonly string[];
+};
+type ShufflePlayerZoneContinuationResponse = {
+    zoneId: string;
+    playerId: string;
+    orderedCardIds: readonly string[];
+};
+type EffectContinuationResponse<Kind extends ResumableEffectKind> = Kind extends "rollDie" ? RollDieContinuationResponse : Kind extends "shuffleSharedZone" ? ShuffleSharedZoneContinuationResponse : Kind extends "shufflePlayerZone" ? ShufflePlayerZoneContinuationResponse : never;
+type EffectContinuationInput<DataSchema extends AnySchema, Kind extends ResumableEffectKind = ResumableEffectKind> = {
+    source: "effect";
+    effectKind: Kind;
+    data: z.infer<DataSchema>;
+    response: EffectContinuationResponse<Kind>;
+};
+type ContinuationInput<DataSchema extends AnySchema> = EffectContinuationInput<DataSchema, ResumableEffectKind>;
+type ContinuationInputForSource<DataSchema extends AnySchema, EffectType extends ResumableEffectKind = ResumableEffectKind> = EffectContinuationInput<DataSchema, EffectType>;
+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">;
+    setup: SetupSelectionOfManifest<Manifest> | null;
+};
+type ValidationIssue = {
+    errorCode: string;
+    message?: string;
+};
+type RuntimeHelpers<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}> = {
+    accept(state: State, instructions?: RuntimeInstructionForState<State>[]): ReducerAccept<State>;
+    reject: (errorCode: string, message?: string) => ReducerReject;
+    fx: ReducerFx<State>;
+    ops: ReducerOps<State>;
+    edit<DraftState extends State>(state: DraftState): ReducerTransaction<DraftState>;
+    q: TableQueriesOfState<State>;
+    derived: DerivedResolver;
+};
+type RandomHelpers = {
+    subset<const Values extends readonly unknown[]>(options: {
+        from: Values;
+        count: number;
+    }): readonly Values[number][];
+};
+type MutationRuntimeHelpers = {
+    random: RandomHelpers;
+};
+type PhaseEnterArgs<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = ActionContext<State, Manifest> & RuntimeHelpers<State> & MutationRuntimeHelpers & PhaseEnterContext & {
+    state: State;
+};
+type ActorSelectorArgs<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = ActionContext<State, Manifest> & RuntimeHelpers<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 ContinuationReduceArgs<DataSchema extends AnySchema, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>, EffectType extends ResumableEffectKind = ResumableEffectKind> = ActionContext<State, Manifest> & RuntimeHelpers<State> & MutationRuntimeHelpers & {
+    state: State;
+    input: ContinuationInputForSource<DataSchema, EffectType>;
+};
+type ScopedPhaseState<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+    phase: object;
+}, PhaseState extends object> = State & {
+    phase: PhaseState;
+};
+type ContinuationCallable<DataSchema extends AnySchema, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>, ContinuationId extends string = string, EffectType extends ResumableEffectKind = ResumableEffectKind> = ((data: z.infer<DataSchema>) => ContinuationToken<z.infer<DataSchema>, ContinuationId, EffectContinuationResponse<EffectType>>) & {
+    id: ContinuationId;
+    source: "effect";
+    dataSchema: DataSchema;
+    responseSchema: AnySchema;
+    effectKind?: EffectType;
+    reduce: BivariantCallback<ContinuationReduceArgs<DataSchema, State, Manifest, EffectType>, ReducerResult<State>>;
+};
+type EffectContinuationCallable<DataSchema extends AnySchema, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>, ContinuationId extends string = string, Kind extends ResumableEffectKind = ResumableEffectKind> = ContinuationCallable<DataSchema, State, Manifest, ContinuationId, Kind>;
+/**
+ * `rollDie` effect. Resolves a `rollDie` wire effect. `reduce` / `context`
+ * are both optional so authors can fire-and-forget a die roll without
+ * observing the result.
+ */
+type EffectRollDieDefinition<Id extends string, ContextSchema extends AnySchema, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = {
+    readonly type: "rollDie";
+    readonly id: Id;
+    readonly contextSchema?: ContextSchema;
+    readonly __continuation?: EffectContinuationCallable<ContextSchema, State, Manifest, Id, "rollDie">;
+};
+/**
+ * `shuffleSharedZone` effect. Resolves a `shuffleSharedZone` wire effect.
+ * `reduce` / `context` are both optional.
+ */
+type EffectShuffleDefinition<Id extends string, ContextSchema extends AnySchema, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = {
+    readonly type: "shuffleSharedZone";
+    readonly id: Id;
+    readonly contextSchema?: ContextSchema;
+    readonly __continuation?: EffectContinuationCallable<ContextSchema, State, Manifest, Id, "shuffleSharedZone">;
+};
+/**
+ * `shufflePlayerZone` effect. Resolves a `shufflePlayerZone` wire effect for
+ * a single player's perPlayer zone (e.g. deck-builder reshuffle of discard
+ * into deck). `reduce` / `context` are both optional.
+ */
+type EffectShufflePlayerZoneDefinition<Id extends string, ContextSchema extends AnySchema, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = {
+    readonly type: "shufflePlayerZone";
+    readonly id: Id;
+    readonly contextSchema?: ContextSchema;
+    readonly __continuation?: EffectContinuationCallable<ContextSchema, State, Manifest, Id, "shufflePlayerZone">;
+};
+/**
+ * Discriminated union of every `defineEffect` output.
+ */
+type EffectDefinition<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = EffectRollDieDefinition<string, AnySchema, State, Manifest> | EffectShuffleDefinition<string, AnySchema, State, Manifest> | EffectShufflePlayerZoneDefinition<string, AnySchema, State, Manifest>;
+type EffectMap<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = Record<string, EffectDefinition<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>>> = ActionContext<State, Manifest> & RuntimeHelpers<State> & MutationRuntimeHelpers & {
+    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>>> = {
+    name?: string;
+    state: PhaseStateSchema;
+    initialState?: (ctx: {
+        manifest: Manifest;
+        state: State;
+        playerIds: PlayerIdOfState<State>[];
+        setup: SetupSelectionOfManifest<Manifest> | null;
+    }) => z.infer<PhaseStateSchema>;
+    enter?: BivariantCallback<PhaseEnterArgs<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest>, 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>>> = PhaseDefinitionCommon<PhaseStateSchema, State, Manifest> & {
+    kind: "auto";
+    actor?: never;
+    actors?: never;
+    submit?: never;
+    canResubmit?: never;
+    resolve?: never;
+    effects?: never;
+    interactions?: never;
+    stages?: never;
+    zones?: never;
+    cardActions?: never;
+};
+type PlayerPhaseDefinition<PhaseStateSchema extends SchemaLike<object>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+    phase: object;
+}, Manifest extends ManifestContract<TableOfState<State>>, Effects extends EffectMap<State, Manifest> = Record<string, never>, Interactions extends InteractionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Stages extends StageMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Zones extends PhaseZoneList<Manifest> = readonly [], CardActions extends CardActionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>> = PhaseDefinitionCommon<PhaseStateSchema, State, Manifest> & {
+    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;
+    effects?: Effects;
+    interactions?: Interactions;
+    stages?: Stages;
+    zones?: Zones;
+    cardActions?: CardActions;
+};
+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>, Effects extends EffectMap<State, Manifest> = Record<string, never>, Interactions extends InteractionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Stages extends StageMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Zones extends PhaseZoneList<Manifest> = readonly [], CardActions extends CardActionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>> = PhaseDefinitionCommon<PhaseStateSchema, State, Manifest> & {
+    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>, ReducerResult<ScopedPhaseState<State, z.infer<PhaseStateSchema>>>>;
+    effects?: Effects;
+    interactions?: Interactions;
+    stages?: Stages;
+    zones?: Zones;
+    cardActions?: CardActions;
+};
+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>, Effects extends EffectMap<State, Manifest> = Record<string, never>, Interactions extends InteractionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Stages extends StageMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Zones extends PhaseZoneList<Manifest> = readonly [], CardActions extends CardActionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>> = AutoPhaseDefinition<PhaseStateSchema, State, Manifest> | PlayerPhaseDefinition<PhaseStateSchema, State, Manifest, Effects, Interactions, Stages, Zones, CardActions> | SimultaneousPlayerPhaseDefinition<PhaseStateSchema, State, Manifest, SubmitCollectors, Effects, Interactions, Stages, Zones, CardActions>;
+type ViewDefinition<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>, Projection = unknown> = {
+    project: (args: ActionContext<State, Manifest> & RuntimeHelpers<State> & {
+        state: State;
+        playerId: PlayerIdOfState<State>;
+        runtime: State extends {
+            runtime: infer RuntimeStateValue;
+        } ? RuntimeStateValue : never;
+    }) => Projection;
+};
+/**
+ * Session-scoped, once-per-init view. The `project` callback receives only
+ * the authored manifest — the mutable-state helpers (`state`, `playerId`,
+ * `runtime`, `fx`, `ops`, `accept`, `reject`, `q`) that `ViewDefinition.project`
+ * exposes are structurally absent, so an author cannot accidentally project
+ * per-tick state into the payload. The host calls this once per reducer
+ * session, caches the result, and merges it back into every seat view on
+ * the client. Moving static board topology here is what lets the adapter
+ * skip the ~87% of `projectSeatsDynamic` wall time that used to re-serialize
+ * manifest-sourced fields on every input.
+ */
+type StaticViewDefinition<Manifest extends ManifestContract<RuntimeTableRecord>, Projection = unknown> = {
+    project: (args: {
+        manifest: Manifest;
+        q: StaticViewQueries<Manifest>;
+    }) => Projection;
+};
+type InputCollectorKind = "form" | "board-vertex" | "board-edge" | "board-tile" | "board-space" | "card" | "prompt" | "rng";
+type TargetKind = "edge" | "vertex" | "space" | "tile" | "card";
+type BoardInputCollectorKind = Exclude<InputCollectorKind, "form" | "card" | "prompt" | "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 PromptInputCollectorMeta = {
+    readonly options: (state: unknown, playerId: unknown, q: unknown) => ReadonlyArray<{
+        id: unknown;
+        label?: string;
+    }>;
+    readonly eligibleOptions: (state: unknown, playerId: unknown, q: unknown) => ReadonlyArray<{
+        id: unknown;
+        label?: string;
+    }>;
+};
+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 "prompt" ? PromptInputCollectorMeta | undefined : Kind extends "rng" ? RngInputCollectorMeta : never;
+type InputSelectionDescriptor = {
+    readonly mode: "single";
+} | {
+    readonly mode: "many";
+    readonly min: number;
+    readonly max?: number;
+    readonly distinct?: boolean;
+};
+type InputDomainResolverDescriptor = {
+    readonly interactionKey?: string;
+    readonly inputKey: string;
+};
+type InputDomainDependencyCase<Domain extends InputDomainDescriptor = InputDomainDescriptor> = {
+    when: Record<string, string>;
+    domain: Domain;
+};
+type EagerInputDomainDependencies<Domain extends InputDomainDescriptor = InputDomainDescriptor> = {
+    readonly mode: "eager";
+    readonly dependentCases: readonly InputDomainDependencyCase<Domain>[];
+};
+type LazyInputDomainDependencies = {
+    readonly mode: "lazy";
+    readonly dependsOn: readonly string[];
+    readonly resolver: InputDomainResolverDescriptor;
+};
+type CardTargetDomainDescriptor = ResolvedCardTargetDomainDescriptor | LazyCardTargetDomainDescriptor;
+type ResolvedCardTargetDomainDescriptor = {
+    readonly type: "cardTarget";
+    readonly projection: "resolved";
+    readonly targetKind: "card";
+    readonly zoneIds: readonly string[];
+    readonly eligibleTargets: readonly string[];
+    readonly selection?: InputSelectionDescriptor;
+    readonly dependencies?: EagerInputDomainDependencies<ResolvedCardTargetDomainDescriptor>;
+};
+type LazyCardTargetDomainDescriptor = {
+    readonly type: "cardTarget";
+    readonly projection: "lazy";
+    readonly targetKind: "card";
+    readonly zoneIds: readonly string[];
+    readonly eligibleTargets?: never;
+    readonly selection?: InputSelectionDescriptor;
+    readonly dependencies: LazyInputDomainDependencies;
+};
+type BoardTargetDomainDescriptor = ResolvedBoardTargetDomainDescriptor | LazyBoardTargetDomainDescriptor;
+type ResolvedBoardTargetDomainDescriptor = {
+    readonly type: "boardTarget";
+    readonly projection: "resolved";
+    readonly targetKind: Exclude<TargetKind, "card">;
+    readonly boardId: string;
+    readonly valueKind?: "board-id" | "player-board-space";
+    readonly eligibleTargets: readonly string[];
+    readonly selection?: InputSelectionDescriptor;
+    readonly dependencies?: EagerInputDomainDependencies<ResolvedBoardTargetDomainDescriptor>;
+};
+type LazyBoardTargetDomainDescriptor = {
+    readonly type: "boardTarget";
+    readonly projection: "lazy";
+    readonly targetKind: Exclude<TargetKind, "card">;
+    readonly boardId: string;
+    readonly valueKind?: "board-id" | "player-board-space";
+    readonly eligibleTargets?: never;
+    readonly selection?: InputSelectionDescriptor;
+    readonly dependencies: LazyInputDomainDependencies;
+};
+type ResourceMapDomainDescriptor = {
+    type: "resourceMap";
+    resources: Array<{
+        resourceId: string;
+        label?: string;
+        icon?: string;
+        min: number;
+        max: number;
+    }>;
+    selection?: InputSelectionDescriptor;
+};
+type BoundedNumberDomainDescriptor = {
+    type: "boundedNumber";
+    min: number;
+    max: number;
+    step?: number;
+    selection?: InputSelectionDescriptor;
+};
+type ChoiceDomainDescriptor = {
+    type: "choice";
+    choices: Array<{
+        value: string | null;
+        label: string;
+        icon?: string;
+        badge?: string;
+        description?: string;
+        disabled?: boolean;
+        disabledReason?: string;
+    }>;
+    selection?: InputSelectionDescriptor;
+    dependencies?: EagerInputDomainDependencies<ChoiceDomainDescriptor>;
+};
+type ChoiceListDomainDescriptor = {
+    type: "choiceList";
+    choices: Array<{
+        value: string;
+        label: string;
+        icon?: string;
+        badge?: string;
+        description?: string;
+        disabled?: boolean;
+        disabledReason?: string;
+    }>;
+    min?: number;
+    max?: number;
+    selection?: InputSelectionDescriptor;
+    dependencies?: EagerInputDomainDependencies<ChoiceListDomainDescriptor>;
+};
+type InputDomainDescriptor = CardTargetDomainDescriptor | BoardTargetDomainDescriptor | ResourceMapDomainDescriptor | BoundedNumberDomainDescriptor | ChoiceDomainDescriptor | ChoiceListDomainDescriptor;
+type DomainProjector<Domain extends InputDomainDescriptor> = (state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, values?: Readonly<Record<string, 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 valid values. The hook receives
+ *     the same `q` table-queries helper that `validate` / `reduce` see, so
+ *     board/card/prompt 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, values?: Readonly<Record<string, unknown>>) => ReadonlyArray<unknown>;
+    readonly validateTarget?: (state: CollectorState, playerId: string, q: unknown, targetId: unknown, values?: Readonly<Record<string, unknown>>) => ValidationIssue | null | undefined;
+    readonly dependsOn?: readonly string[];
+    readonly resolveDefaultValue?: (state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, 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 ClientParamsOf<Collectors extends Record<string, InputCollector>> = {
+    [K in keyof Collectors as K extends EngineSampledCollectorKeys<Collectors> ? never : K]: Collectors[K] extends InputCollector<infer S> ? S extends SchemaLike<infer V> ? V : never : never;
+};
+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> & RuntimeHelpers<State> & {
+    state: State;
+    input: InteractionReduceInput<Collectors, State>;
+};
+type InteractionReduceArgs<Collectors extends Record<string, InputCollector>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = InteractionValidateArgs<Collectors, State, Manifest> & MutationRuntimeHelpers;
+type InteractionAvailabilityArgs<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = ActionContext<State, Manifest> & RuntimeHelpers<State> & {
+    state: State;
+    input: {
+        playerId: PlayerIdOfState<State>;
+    };
+};
+type InteractionRuleValidationResult = boolean | ValidationIssue | 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>>> = {
+    /**
+     * 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: string;
+    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>;
+};
+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;
+/**
+ * Projection-level interaction kind, derived by the trusted bundle from
+ * collector shape:
+ *
+ * - `"action"`: any interaction whose inputs are ordinary collectors
+ *   (`formInput`, `cardInput`).
+ * - `"prompt"`: any interaction whose inputs include a `promptInput`
+ *   collector. Prompt descriptors carry addressed-player context and options
+ *   so UI primitives can render response controls without reducer-owned
+ *   placement metadata.
+ *
+ * Authors never set this directly — the `promptInput(...)` collector is
+ * the single source of truth for prompt semantics. See {@link promptInput}
+ * and {@link InteractionDescriptor.kind}.
+ */
+type InteractionKind = "action" | "prompt";
+type InteractionToArgs<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = ActionContext<State, Manifest> & {
+    state: State;
+};
+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>>> = {
+    inputs: Collectors;
+    paramsSchema?: SchemaLike<ClientParamsOf<Collectors>>;
+    /** @internal Phase-local step gates are attached by `defineStepPhase`. */
+    __steps?: readonly string[];
+    /**
+     * 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>;
+    /**
+     * Addressed-player selector, used by prompt-kind interactions. When
+     * present, the trusted bundle only emits this descriptor for players in
+     * the returned set (or the single player, if a scalar is returned). Use
+     * to thread e.g. `state.publicState.knowerPlayerId` through without
+     * having to manage `activePlayers`. `undefined` / empty returns fall back
+     * to the standard `activePlayers` gating used by action-kind interactions.
+     */
+    to?: BivariantCallback<InteractionToArgs<State, Manifest>, PlayerIdOfState<State> | ReadonlyArray<PlayerIdOfState<State>> | null | undefined>;
+    /**
+     * Explicit actor selector. Overrides the phase-level actor for this
+     * interaction. Prefer this over `to` for new non-prompt interactions; `to`
+     * remains the prompt/addressee shorthand.
+     */
+    actor?: ActorSelector<State, Manifest>;
+    /**
+     * Descriptor visibility policy. `all` keeps non-actors visible but disabled;
+     * `actorsOnly` suppresses descriptors for seats that cannot act.
+     */
+    visibility?: "all" | "actorsOnly";
+    errorCodes?: readonly string[];
+    cost?: BivariantCallback<InteractionValidateArgs<Collectors, State, Manifest>, Readonly<Record<string, number>>>;
+    rules?: readonly InteractionRule<NoInfer<Collectors>, State, Manifest>[];
+    reduce: BivariantCallback<InteractionReduceArgs<Collectors, State, Manifest>, ReducerResult<State>>;
+};
+type CardActionSpec<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>>, PlayFrom extends PlayerZoneIdOfManifest<Manifest> = PlayerZoneIdOfManifest<Manifest>> = {
+    cardType: CardTypeOfState<State>;
+    playFrom: PlayFrom;
+    inputs?: Collectors;
+    paramsSchema?: SchemaLike<Record<string, unknown>>;
+    /** @internal Phase-local step gates are attached by `defineStepPhase`. */
+    __steps?: readonly string[];
+    /**
+     * Draft commit policy. Card clicks still mutate the draft first;
+     * `autoWhenReady` submits only once the full interaction draft validates.
+     * Multi-value collectors created with `many(...)` are always manual draft
+     * interactions and cannot opt into `autoWhenReady`.
+     */
+    commit?: InteractionCommitPolicyFor<Collectors>;
+    actor?: ActorSelector<State, Manifest>;
+    visibility?: "all" | "actorsOnly";
+    errorCodes?: readonly string[];
+    cost?: BivariantCallback<InteractionValidateArgs<Collectors & {
+        cardId: InputCollector<SchemaLike<CardIdOfState<State>>>;
+    }, State, Manifest>, Readonly<Record<string, number>>>;
+    rules?: readonly InteractionRule<NoInfer<Collectors & {
+        cardId: InputCollector<SchemaLike<CardIdOfState<State>>>;
+    }>, State, Manifest>[];
+    reduce: BivariantCallback<InteractionReduceArgs<Collectors & {
+        cardId: InputCollector<SchemaLike<CardIdOfState<State>>>;
+    }, State, Manifest>, ReducerResult<State>>;
+};
+type AnyCardActionSpec<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = CardActionSpec<Record<string, InputCollector>, State, Manifest>;
+type CardActionMap<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = Record<string, AnyCardActionSpec<State, Manifest>>;
+/**
+ * Type-safe erasure of {@link InteractionSpec} used by the runtime when it
+ * stores heterogeneous interactions in a single map. The collectors generic
+ * is erased to the structural upper bound (`Record<string, InputCollector>`)
+ * so that lookups and metadata helpers can iterate collectors without
+ * committing to a specific authoring-time shape.
+ */
+type AnyInteractionSpec<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = InteractionSpec<Record<string, InputCollector>, State, Manifest>;
+type InteractionMap<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = Record<string, AnyInteractionSpec<State, Manifest>>;
+type StageSpec<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = {
+    when?: BivariantCallback<ActionContext<State, Manifest> & {
+        state: State;
+    }, boolean>;
+    onEnter?: BivariantCallback<PhaseEnterArgs<State, Manifest>, ReducerResult<State> | void>;
+    onExit?: BivariantCallback<PhaseEnterArgs<State, Manifest>, ReducerResult<State> | void>;
+    allow: readonly string[];
+};
+type StageMap<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = Record<string, StageSpec<State, Manifest>>;
+type PhaseZoneList<Manifest extends ManifestContract<RuntimeTableRecord>> = readonly PlayerZoneIdOfManifest<Manifest>[];
+
+/**
+ * Structural upper bound for reducer game contracts accepted by the
+ * authoring-level `define*` factories. The `manifest` slot admits any
+ * contract-generated manifest shape (tables, players, decks, etc. vary per
+ * contract); `state` is pinned to the base {@link StateDefinition} so the
+ * authoring helpers can infer public/private/hidden schemas from it.
+ */
+type AnyReducerGameContract = {
+    manifest: ManifestContract<RuntimeTableRecord>;
+    state: StateDefinition<SchemaLike<object>, SchemaLike<object>, SchemaLike<object>>;
+};
+type PhaseStateInput = SchemaLike<object> | object;
+type InferPhaseState<Input extends PhaseStateInput> = Input extends SchemaLike<infer Output> ? Output extends object ? Output : object : Input extends object ? Input : object;
+type ContractState<Contract extends AnyReducerGameContract> = BaseGameStateOfContract<Contract>;
+type ContractManifest<Contract extends AnyReducerGameContract> = ManifestContractOf<Contract>;
+type ReducerPhaseDefinition<Contract extends AnyReducerGameContract, PhaseStateSchema extends SchemaLike<object>> = PhaseDefinition<PhaseStateSchema, ContractState<Contract>, ContractManifest<Contract>>;
+type ReducerViewDefinition<Contract extends AnyReducerGameContract, Projection = unknown> = ViewDefinition<ContractState<Contract>, ContractManifest<Contract>, Projection>;
+
+type ManifestIdSchemasOf<Ids extends Record<string, SchemaLike<unknown>>> = {
+    readonly [Key in keyof Ids]: Ids[Key] extends SchemaLike<infer Output> ? Ids[Key] & ManifestIdSchema<Output> : Ids[Key];
+};
+
+/**
+ * Narrows a manifest's `literals.phaseNames` and `ids.phaseName` to the
+ * author-supplied phase-name tuple. Lets `defineGameContract` override the
+ * codegen-emitted `phaseNames: readonly string[]` / `phaseName: z.string()`
+ * placeholders so `PhaseNameOfContract<Contract>` resolves to a literal
+ * union and flows through `fx.transition`, `PhaseMapOf`, and the flow
+ * state's `currentPhase`.
+ */
+type NarrowManifestPhaseNames<Manifest, PhaseNames extends readonly string[]> = Omit<Manifest, "literals" | "ids"> & {
+    literals: Manifest extends {
+        literals: infer L;
+    } ? Omit<L, "phaseNames"> & {
+        phaseNames: PhaseNames;
+    } : {
+        phaseNames: PhaseNames;
+    };
+    ids: Manifest extends {
+        ids: infer I;
+    } ? Omit<I, "phaseName"> & {
+        phaseName: z.ZodType<PhaseNames[number]>;
+    } : {
+        phaseName: z.ZodType<PhaseNames[number]>;
+    };
+};
+type ReducerGameContractInput<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>>> = {
+    manifest: Manifest;
+    state: StateDefinition<PublicSchema, PrivateSchema, HiddenSchema>;
+    phases: Phases;
+};
+declare function defineGameContract<Table extends RuntimeTableRecord, const Manifest extends ReducerManifestContract<Table, string, string, string, string, string>, PublicSchema extends SchemaLike<object>, PrivateSchema extends SchemaLike<object>, HiddenSchema extends SchemaLike<object>, const Phases extends Record<string, SchemaLike<object>>>(definition: ReducerGameContractInput<Table, Manifest, PublicSchema, PrivateSchema, HiddenSchema, Phases>): ReducerGameContract<Table, NarrowManifestPhaseNames<Manifest, readonly (keyof Phases & string)[]>, PublicSchema, PrivateSchema, HiddenSchema, Phases> & {
+    readonly phases: Phases;
+    readonly phaseNames: readonly (keyof Phases & string)[];
+    /**
+     * Ergonomic shortcut to the manifest-backed Zod id schemas. Equivalent to
+     * `definition.manifest.ids`. Prefer `gameContract.schemas.playerId` etc.
+     * over re-importing the generated `ids` namespace so that every authored
+     * schema is anchored to the same SDK-guided source.
+     */
+    readonly schemas: ManifestIdSchemasOf<NarrowManifestPhaseNames<Manifest, readonly (keyof Phases & string)[]>["ids"]>;
+};
+
+type EffectRollDieInput<Contract extends AnyReducerGameContract, Id extends string, ContextSchema extends AnySchema> = {
+    type: "rollDie";
+    id: Id;
+    context?: ContextSchema;
+    reduce?: ContinuationCallable<ContextSchema, ContractState<Contract>, ContractManifest<Contract>, Id, "rollDie">["reduce"];
+};
+type EffectShuffleInput<Contract extends AnyReducerGameContract, Id extends string, ContextSchema extends AnySchema> = {
+    type: "shuffleSharedZone";
+    id: Id;
+    context?: ContextSchema;
+    reduce?: ContinuationCallable<ContextSchema, ContractState<Contract>, ContractManifest<Contract>, Id, "shuffleSharedZone">["reduce"];
+};
+type EffectShufflePlayerZoneInput<Contract extends AnyReducerGameContract, Id extends string, ContextSchema extends AnySchema> = {
+    type: "shufflePlayerZone";
+    id: Id;
+    context?: ContextSchema;
+    reduce?: ContinuationCallable<ContextSchema, ContractState<Contract>, ContractManifest<Contract>, Id, "shufflePlayerZone">["reduce"];
+};
+declare function defineEffect<Contract extends AnyReducerGameContract>(): {
+    <Id extends string, ContextSchema extends AnySchema = z.ZodObject<Record<string, never>, z.core.$strip>>(definition: EffectRollDieInput<Contract, Id, ContextSchema>): EffectRollDieDefinition<Id, ContextSchema, ContractState<Contract>, ContractManifest<Contract>>;
+    <Id extends string, ContextSchema extends AnySchema = z.ZodObject<Record<string, never>, z.core.$strip>>(definition: EffectShuffleInput<Contract, Id, ContextSchema>): EffectShuffleDefinition<Id, ContextSchema, ContractState<Contract>, ContractManifest<Contract>>;
+    <Id extends string, ContextSchema extends AnySchema = z.ZodObject<Record<string, never>, z.core.$strip>>(definition: EffectShufflePlayerZoneInput<Contract, Id, ContextSchema>): EffectShufflePlayerZoneDefinition<Id, ContextSchema, ContractState<Contract>, ContractManifest<Contract>>;
+};
+
+declare function defineGame<const Contract extends AnyReducerGameContract, Definitions extends PhaseMapOf<Contract>, Views extends ViewMapOf<Contract> = Record<string, never>>(definition: {
+    contract: Contract;
+} & Omit<ReducerGameDefinition<NoInfer<Contract>, Definitions, Views>, "contract">): ReducerGameDefinition<Contract, Definitions, Views>;
+
+declare function defineInteraction<Contract extends AnyReducerGameContract, PhaseState extends PhaseStateInput = SchemaLike<object>>(): <Collectors extends Record<string, InputCollector>>(definition: InteractionSpec<Collectors, ScopedPhaseState<ContractState<Contract>, InferPhaseState<PhaseState>>, ContractManifest<Contract>>) => InteractionSpec<Collectors, ScopedPhaseState<ContractState<Contract>, InferPhaseState<PhaseState>>, ContractManifest<Contract>>;
+declare function defineInteractionRule<Contract extends AnyReducerGameContract, PhaseState extends PhaseStateInput = SchemaLike<object>>(): <Collectors extends Record<string, InputCollector> = Record<string, InputCollector>>(definition: InteractionRule<Collectors, ScopedPhaseState<ContractState<Contract>, InferPhaseState<PhaseState>>, ContractManifest<Contract>>) => InteractionRule<Collectors, ScopedPhaseState<ContractState<Contract>, InferPhaseState<PhaseState>>, ContractManifest<Contract>>;
+declare function defineCardAction<Contract extends AnyReducerGameContract, PhaseState extends PhaseStateInput>(): <Collectors extends Record<string, InputCollector> = Record<string, never>, const PlayFrom extends PlayerZoneIdOfManifest<ContractManifest<Contract>> = PlayerZoneIdOfManifest<ContractManifest<Contract>>>(definition: CardActionSpec<Collectors, ScopedPhaseState<ContractState<Contract>, InferPhaseState<PhaseState>>, ContractManifest<Contract>, PlayFrom>) => CardActionSpec<Collectors, ScopedPhaseState<ContractState<Contract>, InferPhaseState<PhaseState>>, ContractManifest<Contract>, PlayFrom>;
+
+type StepPhaseState<PhaseStateSchema extends SchemaLike<object>, Steps extends readonly string[]> = z.infer<PhaseStateSchema> & {
+    step: Steps[number];
+};
+type StepPhaseInteractionEntry<Step extends string, Interaction> = {
+    steps: readonly Step[];
+    interaction: Interaction;
+};
+type StepPhaseCardActionEntry<Step extends string, Action> = {
+    steps: readonly Step[];
+    action: Action;
+};
+type StepPhaseInteractionMap<Step extends string, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = Record<string, StepPhaseInteractionEntry<Step, AnyInteractionSpec<State, Manifest>>>;
+type StepPhaseCardActionMap<Step extends string, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = Record<string, StepPhaseCardActionEntry<Step, AnyCardActionSpec<State, Manifest>>>;
+type UnwrappedStepInteractions<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>, Interactions extends Record<string, StepPhaseInteractionEntry<string, AnyInteractionSpec<State, Manifest>>>> = {
+    [Key in keyof Interactions]: Interactions[Key]["interaction"];
+};
+type UnwrappedStepCardActions<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>, CardActions extends Record<string, StepPhaseCardActionEntry<string, AnyCardActionSpec<State, Manifest>>>> = {
+    [Key in keyof CardActions]: CardActions[Key]["action"];
+};
+declare function definePhase<Contract extends AnyReducerGameContract>(): <PhaseStateSchema extends SchemaLike<object>, SubmitCollectors extends Record<string, InputCollector> = Record<string, InputCollector>, Effects extends EffectMap<ContractState<Contract>, ContractManifest<Contract>> = Record<string, never>, Interactions extends Record<string, AnyInteractionSpec<ScopedPhaseState<ContractState<Contract>, z.infer<PhaseStateSchema>>, ContractManifest<Contract>>> = Record<string, never>, Stages extends StageMap<ScopedPhaseState<ContractState<Contract>, z.infer<PhaseStateSchema>>, ContractManifest<Contract>> = Record<string, never>, const Zones extends PhaseZoneList<ContractManifest<Contract>> = readonly [], CardActions extends CardActionMap<ScopedPhaseState<ContractState<Contract>, z.infer<PhaseStateSchema>>, ContractManifest<Contract>> = Record<string, never>>(definition: PhaseDefinition<PhaseStateSchema, ContractState<Contract>, ContractManifest<Contract>, SubmitCollectors, Effects, Interactions, Stages, Zones, CardActions>) => PhaseDefinition<PhaseStateSchema, ContractState<Contract>, ContractManifest<Contract>, SubmitCollectors, Effects, Interactions, Stages, Zones, CardActions>;
+declare function defineStepPhase<Contract extends AnyReducerGameContract>(): <const Steps extends readonly [string, ...string[]], PhaseStateSchema extends SchemaLike<object>, SubmitCollectors extends Record<string, InputCollector> = Record<string, InputCollector>, Effects extends EffectMap<ContractState<Contract>, ContractManifest<Contract>> = Record<string, never>, Interactions extends StepPhaseInteractionMap<Steps[number], ScopedPhaseState<ContractState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, ContractManifest<Contract>> = Record<string, never>, Stages extends StageMap<ScopedPhaseState<ContractState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, ContractManifest<Contract>> = Record<string, never>, const Zones extends PhaseZoneList<ContractManifest<Contract>> = readonly [], CardActions extends StepPhaseCardActionMap<Steps[number], ScopedPhaseState<ContractState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, ContractManifest<Contract>> = Record<string, never>>(definition: Omit<PhaseDefinition<PhaseStateSchema, ContractState<Contract>, ContractManifest<Contract>, SubmitCollectors, Effects, UnwrappedStepInteractions<ScopedPhaseState<ContractState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, ContractManifest<Contract>, Interactions>, Stages, Zones, UnwrappedStepCardActions<ScopedPhaseState<ContractState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, ContractManifest<Contract>, CardActions>>, "state" | "initialState" | "interactions" | "cardActions"> & {
+    steps: Steps;
+    state: PhaseStateSchema;
+    initialState?: (ctx: {
+        manifest: ContractManifest<Contract>;
+        state: ContractState<Contract>;
+        playerIds: PlayerIdOfState<ContractState<Contract>>[];
+        setup: SetupSelectionOfManifest<ContractManifest<Contract>> | null;
+    }) => z.infer<PhaseStateSchema>;
+    interactions?: Interactions;
+    cardActions?: CardActions;
+}) => PhaseDefinition<SchemaLike<StepPhaseState<PhaseStateSchema, Steps>>, ContractState<Contract>, ContractManifest<Contract>, SubmitCollectors, Effects, UnwrappedStepInteractions<ScopedPhaseState<ContractState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, ContractManifest<Contract>, Interactions>, Stages, Zones, UnwrappedStepCardActions<ScopedPhaseState<ContractState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, ContractManifest<Contract>, CardActions>>;
+
+declare function defineView<Contract extends AnyReducerGameContract>(): <Projection>(definition: ViewDefinition<ContractState<Contract>, ContractManifest<Contract>, Projection>) => ViewDefinition<ContractState<Contract>, ContractManifest<Contract>, Projection>;
+/**
+ * Factory for the session-scoped static view (see {@link StaticViewDefinition}).
+ * Kept separate from {@link defineView} because the argument shape is
+ * structurally different: it exposes only the manifest and generated static
+ * queries, with no `state`, `playerId`, `runtime`, `fx`, `ops`, or
+ * `accept/reject`. That shape is what prevents authors from accidentally
+ * projecting per-tick state into the once-per-session payload.
+ */
+declare function defineStaticView<Contract extends AnyReducerGameContract>(): <Projection>(definition: StaticViewDefinition<ExactManifestContractOf<Contract>, Projection>) => StaticViewDefinition<ExactManifestContractOf<Contract>, Projection>;
+declare function defineStage<Contract extends AnyReducerGameContract>(): (definition: StageSpec<ContractState<Contract>, ContractManifest<Contract>>) => StageSpec<ContractState<Contract>, ContractManifest<Contract>>;
+declare function definePhaseStage<Contract extends AnyReducerGameContract, PhaseStateSchema extends SchemaLike<object>>(): (definition: StageSpec<ScopedPhaseState<ContractState<Contract>, z.infer<PhaseStateSchema>>, ContractManifest<Contract>>) => StageSpec<ScopedPhaseState<ContractState<Contract>, z.infer<PhaseStateSchema>>, ContractManifest<Contract>>;
+
+type InputFieldRef<Key extends string = string, Value = unknown, Collector extends InputCollector = InputCollector> = {
+    readonly key: Key;
+    readonly collector: Collector;
+    readonly __value?: Value;
+};
+type RefValue<Ref> = Ref extends InputFieldRef<string, infer Value, InputCollector> ? Value : never;
+type CollectorOfRef<Ref> = Ref extends InputFieldRef<string, unknown, infer Collector> ? Collector : never;
+type CollectorValue<Collector> = Collector extends InputCollector<infer Schema> ? z.infer<Schema> : never;
+type DependencyValues<Dependencies extends readonly InputFieldRef<string, unknown, InputCollector>[]> = {
+    readonly [Ref in Dependencies[number] as Ref["key"]]: RefValue<Ref>;
+};
+type DefinedInputRefs = Record<string, InputFieldRef<string, unknown, InputCollector>>;
+type DefinedInputs<Refs extends DefinedInputRefs> = {
+    readonly [Key in keyof Refs]: CollectorOfRef<Refs[Key]>;
+};
+declare class InputBuilder {
+    add<const Key extends string, Collector extends InputCollector<SchemaLike<unknown>>>(key: Key, collector: Collector): InputFieldRef<Key, CollectorValue<Collector>, Collector>;
+}
+/**
+ * Define an interaction's inputs with typed field references. Field refs can be
+ * passed to dependent input domains, and the returned collector map preserves
+ * the original key/value types for interaction params.
+ */
+declare function defineInputs<const Refs extends DefinedInputRefs>(define: (input: InputBuilder) => Refs): DefinedInputs<Refs>;
+
+type DomainContext<State extends CollectorState, Values extends Readonly<Record<string, unknown>> = Record<string, never>> = {
+    state: State;
+    playerId: PlayerIdOfState<State>;
+    q: TableQueriesOfState<State>;
+    derived: DerivedResolver;
+    values: Values;
+};
+type ManifestFormInputSchema = ManifestIdSchema<unknown> | z.ZodOptional<ManifestIdSchema<unknown>> | z.ZodNullable<ManifestIdSchema<unknown>>;
+type DomainNumber<State extends CollectorState> = number | ((context: DomainContext<State>) => number);
+type ChoiceValue = string | null;
+type DomainChoice<Value extends ChoiceValue, State extends CollectorState> = {
+    value: Value;
+    label: string;
+    icon?: string;
+    badge?: string;
+    description?: string;
+    disabled?: boolean;
+    disabledReason?: string;
+};
+type DomainChoicePresentation = {
+    badge?: string;
+    description?: string;
+    disabled?: boolean;
+    disabledReason?: string;
+};
+type ResourceMapChoiceDecorator<State extends CollectorState> = (context: DomainContext<State> & {
+    resourceId: string;
+    label: string;
+    icon?: string;
+}) => DomainChoicePresentation | null | undefined;
+type ResourceMapChoiceSource<State extends CollectorState> = "resourceMap" | {
+    source: "resourceMap";
+    decorate?: ResourceMapChoiceDecorator<State>;
+};
+type DomainChoices<Value extends ChoiceValue, State extends CollectorState> = ReadonlyArray<DomainChoice<Value, State>> | ResourceMapChoiceSource<State> | ((context: DomainContext<State>) => ReadonlyArray<DomainChoice<Value, State>>);
+type DependentDomainChoices<Value extends ChoiceValue, State extends CollectorState, Dependencies extends readonly InputFieldRef<string, unknown>[]> = ReadonlyArray<DomainChoice<Value, State>> | ((context: DomainContext<State, DependencyValues<Dependencies>>) => ReadonlyArray<DomainChoice<Value, State>>);
+type ChoiceListDefaultValue<Value extends string, State extends CollectorState> = Value[] | "all" | ((context: DomainContext<State> & {
+    choices: ReadonlyArray<DomainChoice<Value, State>>;
+}) => Value[]);
+type ChoiceDefaultResolver<Value extends ChoiceValue, State extends CollectorState, Values extends Readonly<Record<string, unknown>> = Record<string, never>> = (context: DomainContext<State, Values> & {
+    choices: ReadonlyArray<DomainChoice<Value, State>>;
+}) => Value | undefined;
+declare function baseFormInput<Schema extends ManifestFormInputSchema & SchemaLike<unknown>, State extends CollectorState = CollectorState>(schema: Schema): InputCollector<Schema, State, "form">;
+declare function baseFormInput<Schema extends ManifestFormInputSchema & SchemaLike<unknown>, State extends CollectorState = CollectorState>(schema: Schema, options: {
+    defaultValue: z.infer<Schema>;
+}): InputCollector<Schema, State, "form"> & {
+    readonly defaultValue: z.infer<Schema>;
+};
+declare function resourceMapInput<State extends CollectorState = CollectorState>(options: {
+    resources: ReadonlyArray<{
+        resourceId: string;
+        label?: string;
+        icon?: string;
+        min?: DomainNumber<State>;
+        max: DomainNumber<State>;
+    }>;
+}): InputCollector<z.ZodRecord<z.ZodString, z.ZodNumber>, State, "form">;
+declare function resourceMapInput<State extends CollectorState = CollectorState>(options: {
+    resources: ReadonlyArray<{
+        resourceId: string;
+        label?: string;
+        icon?: string;
+        min?: DomainNumber<State>;
+        max: DomainNumber<State>;
+    }>;
+    defaultValue: Record<string, number>;
+}): InputCollector<z.ZodRecord<z.ZodString, z.ZodNumber>, State, "form"> & {
+    readonly defaultValue: Record<string, number>;
+};
+declare function numberInput<State extends CollectorState = CollectorState>(options: {
+    min: DomainNumber<State>;
+    max: DomainNumber<State>;
+    step?: DomainNumber<State>;
+}): InputCollector<z.ZodNumber, State, "form">;
+declare function numberInput<State extends CollectorState = CollectorState>(options: {
+    min: DomainNumber<State>;
+    max: DomainNumber<State>;
+    step?: DomainNumber<State>;
+    defaultValue: number;
+}): InputCollector<z.ZodNumber, State, "form"> & {
+    readonly defaultValue: number;
+};
+declare function choiceInput<const Dependencies extends readonly InputFieldRef<string, unknown>[], Value extends ChoiceValue = string, State extends CollectorState = CollectorState>(options: {
+    dependsOn: Dependencies;
+    choices: DependentDomainChoices<Value, State, Dependencies>;
+    defaultValue: Value;
+}): InputCollector<SchemaLike<Value>, State, "form"> & {
+    readonly defaultValue: Value;
+};
+declare function choiceInput<const Dependencies extends readonly InputFieldRef<string, unknown>[], Value extends ChoiceValue = string, State extends CollectorState = CollectorState>(options: {
+    dependsOn: Dependencies;
+    choices: DependentDomainChoices<Value, State, Dependencies>;
+    defaultValue: ChoiceDefaultResolver<Value, State, DependencyValues<Dependencies>>;
+}): InputCollector<SchemaLike<Value>, State, "form">;
+declare function choiceInput<Value extends ChoiceValue, State extends CollectorState = CollectorState>(options: {
+    choices: DomainChoices<Value, State>;
+    defaultValue: Value;
+}): InputCollector<SchemaLike<Value>, State, "form"> & {
+    readonly defaultValue: Value;
+};
+declare function choiceInput<Value extends ChoiceValue, State extends CollectorState = CollectorState>(options: {
+    choices: DomainChoices<Value, State>;
+    defaultValue: ChoiceDefaultResolver<Value, State>;
+}): InputCollector<SchemaLike<Value>, State, "form">;
+declare function choiceInput<Value extends ChoiceValue, State extends CollectorState = CollectorState, const Dependencies extends readonly InputFieldRef<string, unknown>[] = readonly InputFieldRef<string, unknown>[]>(options: {
+    dependsOn: Dependencies;
+    choices: DependentDomainChoices<Value, State, Dependencies>;
+    defaultValue: Value;
+}): InputCollector<SchemaLike<Value>, State, "form"> & {
+    readonly defaultValue: Value;
+};
+declare function choiceInput<Value extends ChoiceValue, State extends CollectorState = CollectorState, const Dependencies extends readonly InputFieldRef<string, unknown>[] = readonly InputFieldRef<string, unknown>[]>(options: {
+    dependsOn: Dependencies;
+    choices: DependentDomainChoices<Value, State, Dependencies>;
+    defaultValue: ChoiceDefaultResolver<Value, State, DependencyValues<Dependencies>>;
+}): InputCollector<SchemaLike<Value>, State, "form">;
+declare function choiceListInput<Value extends string, State extends CollectorState = CollectorState>(options: {
+    choices: DomainChoices<Value, State>;
+    min?: DomainNumber<State>;
+    max?: DomainNumber<State>;
+    defaultValue: Value[];
+}): InputCollector<SchemaLike<Value[]>, State, "form"> & {
+    readonly defaultValue: Value[];
+};
+declare function choiceListInput<Value extends string, State extends CollectorState = CollectorState>(options: {
+    choices: DomainChoices<Value, State>;
+    min?: DomainNumber<State>;
+    max?: DomainNumber<State>;
+    defaultValue?: ChoiceListDefaultValue<Value, State>;
+}): InputCollector<SchemaLike<Value[]>, State, "form">;
+type FormInputForState<State extends CollectorState> = {
+    <Schema extends ManifestFormInputSchema & SchemaLike<unknown>>(schema: Schema): InputCollector<Schema, State, "form">;
+    <Schema extends ManifestFormInputSchema & SchemaLike<unknown>>(schema: Schema, options: {
+        defaultValue: z.infer<Schema>;
+    }): InputCollector<Schema, State, "form"> & {
+        readonly defaultValue: z.infer<Schema>;
+    };
+    resourceMap(options: Parameters<typeof resourceMapInput<State>>[0]): ReturnType<typeof resourceMapInput<State>>;
+    resourceChoices(options?: {
+        decorate?: ResourceMapChoiceDecorator<State>;
+    }): ResourceMapChoiceSource<State>;
+    number(options: Parameters<typeof numberInput<State>>[0]): ReturnType<typeof numberInput<State>>;
+    choice<Value extends ChoiceValue>(options: {
+        choices: DomainChoices<Value, State>;
+        defaultValue: Value;
+    }): InputCollector<SchemaLike<Value>, State, "form"> & {
+        readonly defaultValue: Value;
+    };
+    choice<Value extends ChoiceValue>(options: {
+        choices: DomainChoices<Value, State>;
+        defaultValue: ChoiceDefaultResolver<Value, State>;
+    }): InputCollector<SchemaLike<Value>, State, "form">;
+    choiceList<Value extends string>(options: {
+        choices: DomainChoices<Value, State>;
+        min?: DomainNumber<State>;
+        max?: DomainNumber<State>;
+        defaultValue: Value[];
+    }): InputCollector<SchemaLike<Value[]>, State, "form"> & {
+        readonly defaultValue: Value[];
+    };
+    choiceList<Value extends string>(options: {
+        choices: DomainChoices<Value, State>;
+        min?: DomainNumber<State>;
+        max?: DomainNumber<State>;
+        defaultValue?: ChoiceListDefaultValue<Value, State>;
+    }): InputCollector<SchemaLike<Value[]>, State, "form">;
+};
+declare function formInputForState<State extends CollectorState>(): FormInputForState<State>;
+/**
+ * Manifest-backed id input. Free-form Zod schemas are intentionally explicit:
+ * if the runtime cannot disclose valid values or numeric bounds through a
+ * manifest id or domain helper, use a custom interaction surface with an
+ * explicit `paramsSchema` instead of the default form renderer.
+ */
+declare const formInput: typeof baseFormInput & {
+    resourceMap: typeof resourceMapInput;
+    resourceChoices: <State extends CollectorState = CollectorState>(options?: {
+        decorate?: ResourceMapChoiceDecorator<State>;
+    }) => ResourceMapChoiceSource<State>;
+    number: typeof numberInput;
+    choice: typeof choiceInput;
+    choiceList: typeof choiceListInput;
+    forState: typeof formInputForState;
+};
+
+type TargetContext<State extends CollectorState> = {
+    state: State;
+    playerId: PlayerIdOfState<State>;
+    q: TableQueriesOfState<State>;
+    values?: Readonly<Record<string, unknown>>;
+};
+type TargetPredicateArgs<State extends CollectorState, Target> = TargetContext<State> & {
+    targetId: Target;
+    target: Target;
+};
+type TargetPredicate<State extends CollectorState, Target> = {
+    id: string;
+    errorCode: string;
+    message?: string;
+    test: (args: TargetPredicateArgs<State, Target>) => boolean;
+};
+type BoundTargetRule<Target> = {
+    readonly eligible: () => readonly Target[];
+    readonly validate: (target: Target) => ValidationIssue | null;
+    readonly isEligible: (target: Target) => boolean;
+};
+type TargetRule<State extends CollectorState, Target> = {
+    readonly eligible: (ctx: TargetContext<State>) => readonly Target[];
+    readonly validate: (ctx: TargetContext<State>, target: Target) => ValidationIssue | null;
+    readonly isEligible: (ctx: TargetContext<State>, target: Target) => boolean;
+    readonly bind: (ctx: TargetContext<State>) => BoundTargetRule<Target>;
+};
+type TargetRuleBuilder<State extends CollectorState, Target, Rule extends TargetRule<State, Target>> = {
+    readonly where: (predicate: TargetPredicate<State, Target>) => TargetRuleBuilder<State, Target, Rule>;
+    readonly build: () => Rule;
+};
+
+type BoardTargetPredicate<State extends CollectorState, Target> = TargetPredicate<State, Target>;
+type BoardTargetRule<State extends CollectorState, Target> = TargetRule<State, Target> & {
+    readonly boardId: string;
+    readonly targetKind: TargetKind;
+    readonly valueKind: "board-id" | "player-board-space";
+};
+type BoardTargetBuilder<State extends CollectorState, Target> = TargetRuleBuilder<State, Target, BoardTargetRule<State, Target>>;
+type PlayerBoardSpaceTarget<BoardId extends string, SpaceId extends string, PlayerId extends string> = {
+    readonly boardId: BoardId;
+    readonly playerId: PlayerId;
+    readonly spaceId: SpaceId;
+};
+declare const boardTarget: {
+    edge: <State extends CollectorState, Id extends string>(boardId: string) => BoardTargetBuilder<State, Id>;
+    vertex: <State extends CollectorState, Id extends string>(boardId: string) => BoardTargetBuilder<State, Id>;
+    space: <State extends CollectorState, Id extends string>(boardId: string) => BoardTargetBuilder<State, Id>;
+    tile: <State extends CollectorState, Id extends string>(boardId: string) => BoardTargetBuilder<State, Id>;
+    playerSpace<State extends CollectorState, BoardId extends string, SpaceId extends string>(boardId: BoardId): BoardTargetBuilder<State, PlayerBoardSpaceTarget<BoardId, SpaceId, PlayerIdOfState<State>>>;
+};
+
+declare function playerSpaceInput<State extends CollectorState = CollectorState, BoardId extends string = string, SpaceId extends string = string, PlayerId extends string = string>(options: {
+    target: BoardTargetRule<State, PlayerBoardSpaceTarget<BoardId, SpaceId, PlayerId>>;
+    dependsOn?: readonly InputFieldRef<string, unknown>[];
+}): InputCollector<z.ZodType<PlayerBoardSpaceTarget<BoardId, SpaceId, PlayerId>>, State, "board-space">;
+declare const boardInput: {
+    vertex: <State extends CollectorState = CollectorState, Id extends string = string>(options: {
+        target: BoardTargetRule<State, Id>;
+        dependsOn?: readonly InputFieldRef<string, unknown>[];
+    }) => {
+        readonly kind: "board-vertex";
+        readonly schema: z.ZodType<Id, unknown, z.core.$ZodTypeInternals<Id, unknown>>;
+        readonly defaultValue?: Id | undefined;
+        readonly selection?: InputSelectionDescriptor;
+        readonly eligibleTargets?: (state: CollectorState, playerId: string, q: unknown, values?: Readonly<Record<string, unknown>>) => ReadonlyArray<unknown>;
+        readonly validateTarget?: (state: CollectorState, playerId: string, q: unknown, targetId: unknown, values?: Readonly<Record<string, unknown>>) => ValidationIssue | null | undefined;
+        readonly dependsOn?: readonly string[];
+        readonly resolveDefaultValue?: ((state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, domain: InputDomainDescriptor) => Id | undefined) | undefined;
+    } & {
+        readonly domain: (state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, values?: Readonly<Record<string, unknown>>) => BoardTargetDomainDescriptor;
+    } & {
+        readonly meta: BoardInputCollectorMeta;
+    };
+    edge: <State extends CollectorState = CollectorState, Id extends string = string>(options: {
+        target: BoardTargetRule<State, Id>;
+        dependsOn?: readonly InputFieldRef<string, unknown>[];
+    }) => {
+        readonly kind: "board-edge";
+        readonly schema: z.ZodType<Id, unknown, z.core.$ZodTypeInternals<Id, unknown>>;
+        readonly defaultValue?: Id | undefined;
+        readonly selection?: InputSelectionDescriptor;
+        readonly eligibleTargets?: (state: CollectorState, playerId: string, q: unknown, values?: Readonly<Record<string, unknown>>) => ReadonlyArray<unknown>;
+        readonly validateTarget?: (state: CollectorState, playerId: string, q: unknown, targetId: unknown, values?: Readonly<Record<string, unknown>>) => ValidationIssue | null | undefined;
+        readonly dependsOn?: readonly string[];
+        readonly resolveDefaultValue?: ((state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, domain: InputDomainDescriptor) => Id | undefined) | undefined;
+    } & {
+        readonly domain: (state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, values?: Readonly<Record<string, unknown>>) => BoardTargetDomainDescriptor;
+    } & {
+        readonly meta: BoardInputCollectorMeta;
+    };
+    tile: <State extends CollectorState = CollectorState, Id extends string = string>(options: {
+        target: BoardTargetRule<State, Id>;
+        dependsOn?: readonly InputFieldRef<string, unknown>[];
+    }) => {
+        readonly kind: "board-tile";
+        readonly schema: z.ZodType<Id, unknown, z.core.$ZodTypeInternals<Id, unknown>>;
+        readonly defaultValue?: Id | undefined;
+        readonly selection?: InputSelectionDescriptor;
+        readonly eligibleTargets?: (state: CollectorState, playerId: string, q: unknown, values?: Readonly<Record<string, unknown>>) => ReadonlyArray<unknown>;
+        readonly validateTarget?: (state: CollectorState, playerId: string, q: unknown, targetId: unknown, values?: Readonly<Record<string, unknown>>) => ValidationIssue | null | undefined;
+        readonly dependsOn?: readonly string[];
+        readonly resolveDefaultValue?: ((state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, domain: InputDomainDescriptor) => Id | undefined) | undefined;
+    } & {
+        readonly domain: (state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, values?: Readonly<Record<string, unknown>>) => BoardTargetDomainDescriptor;
+    } & {
+        readonly meta: BoardInputCollectorMeta;
+    };
+    space: <State extends CollectorState = CollectorState, Id extends string = string>(options: {
+        target: BoardTargetRule<State, Id>;
+        dependsOn?: readonly InputFieldRef<string, unknown>[];
+    }) => {
+        readonly kind: "board-space";
+        readonly schema: z.ZodType<Id, unknown, z.core.$ZodTypeInternals<Id, unknown>>;
+        readonly defaultValue?: Id | undefined;
+        readonly selection?: InputSelectionDescriptor;
+        readonly eligibleTargets?: (state: CollectorState, playerId: string, q: unknown, values?: Readonly<Record<string, unknown>>) => ReadonlyArray<unknown>;
+        readonly validateTarget?: (state: CollectorState, playerId: string, q: unknown, targetId: unknown, values?: Readonly<Record<string, unknown>>) => ValidationIssue | null | undefined;
+        readonly dependsOn?: readonly string[];
+        readonly resolveDefaultValue?: ((state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, domain: InputDomainDescriptor) => Id | undefined) | undefined;
+    } & {
+        readonly domain: (state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, values?: Readonly<Record<string, unknown>>) => BoardTargetDomainDescriptor;
+    } & {
+        readonly meta: BoardInputCollectorMeta;
+    };
+    playerSpace: typeof playerSpaceInput;
+};
+
+type CardTargetPredicate<State extends CollectorState, Id extends string> = TargetPredicate<State, Id>;
+type CardTargetRule<State extends CollectorState, Id extends string, ZoneIds extends readonly string[] = readonly string[]> = TargetRule<State, Id> & {
+    readonly zoneIds: ZoneIds;
+    readonly zoneId: ZoneIds[number];
+    readonly targetKind: "card";
+};
+type CardTargetBuilder<State extends CollectorState, Id extends string, ZoneIds extends readonly string[] = readonly string[]> = TargetRuleBuilder<State, Id, CardTargetRule<State, Id, ZoneIds>>;
+declare const cardTarget: {
+    zones<State extends CollectorState, Id extends string = CardIdOfState<State>, const ZoneIds extends readonly string[] = readonly string[]>(zoneIds: ZoneIds): CardTargetBuilder<State, Id, ZoneIds>;
+};
+
+type ChoiceTargetOption<Id extends string> = {
+    id: Id;
+    label?: string;
+};
+type ChoiceOptionsFactory<State extends CollectorState, Id extends string> = (state: State, playerId: PlayerIdOfState<State>, q: TableQueriesOfState<State>) => ReadonlyArray<ChoiceTargetOption<Id>>;
+type ChoiceTargetPredicate<State extends CollectorState, Id extends string> = TargetPredicate<State, Id>;
+type ChoiceTargetRule<State extends CollectorState, Id extends string> = TargetRule<State, Id> & {
+    readonly targetKind: "choice";
+    readonly options: (ctx: TargetContext<State>) => ReadonlyArray<ChoiceTargetOption<Id>>;
+    readonly eligibleOptions: (ctx: TargetContext<State>) => ReadonlyArray<ChoiceTargetOption<Id>>;
+};
+type ChoiceTargetBuilder<State extends CollectorState, Id extends string> = TargetRuleBuilder<State, Id, ChoiceTargetRule<State, Id>>;
+declare const choiceTarget: {
+    options<State extends CollectorState, Id extends string>(options: ReadonlyArray<ChoiceTargetOption<Id>> | ChoiceOptionsFactory<State, Id>): ChoiceTargetBuilder<State, Id>;
+};
+
+/**
+ * `cardInput` produces a collector backed by one built `cardTarget` rule.
+ * The submitted value is a manifest-branded card id.
+ *
+ * The target rule feeds server-authoritative eligible-card projection, submit
+ * validation, and tests through its `bind({ state, playerId, q })` helper.
+ */
+declare function cardInput<State extends CollectorState = CollectorState, Id extends string = CardIdOfState<State>, const ZoneIds extends readonly string[] = readonly string[]>(options: {
+    target: CardTargetRule<State, Id, ZoneIds>;
+    dependsOn?: readonly InputFieldRef<string, unknown>[];
+}): InputCollector<z.ZodType<Id>, State, "card"> & {
+    readonly meta: {
+        readonly zoneId: ZoneIds[number];
+        readonly zoneIds: ZoneIds;
+        readonly targetKind: "card";
+    };
+};
+
+type SchemaStringValue<Schema extends SchemaLike<unknown>> = Extract<Schema extends z.ZodType<infer V> ? V : never, string>;
+/**
+ * `promptInput` marks an interaction as a prompt delivered to a player's
+ * inbox. The submitted value is validated by the supplied Zod schema.
+ *
+ * Static or free-form prompts need only `schema`. Finite dynamic choices use
+ * a built `choiceTarget.options(...).build()` rule so projected options and
+ * submit validation share one source of truth.
+ */
+declare function promptInput<Schema extends SchemaLike<unknown>, State extends CollectorState = CollectorState>(options: {
+    schema: Schema;
+    target?: ChoiceTargetRule<State, SchemaStringValue<Schema>>;
+}): InputCollector<Schema, State, "prompt">;
+
+/**
+ * `rngInput.*` helpers produce collectors whose value is *sampled by the
+ * engine on submit* rather than supplied by the client. The schema pins
+ * the exact output shape so `ParamsOf<Collectors>` sees precisely typed
+ * results.
+ *
+ * Determinism:
+ *   Sampling happens inside `submitInteraction` only, never inside
+ *   `validateInteraction`. This lets clients dry-run a submission without
+ *   burning RNG state.
+ */
+type DieRoll = z.ZodObject<{
+    values: z.ZodArray<z.ZodNumber>;
+}>;
+type CoinFlip = z.ZodObject<{
+    value: z.ZodEnum<{
+        heads: "heads";
+        tails: "tails";
+    }>;
+}>;
+type RngCollector<Schema extends DieRoll | CoinFlip, State extends CollectorState> = InputCollector<Schema, State, "rng">;
+/**
+ * Roll `count` d6s. The submitted value is `{ values: number[] }` with
+ * `values.length === count` and each face `1..6`.
+ */
+declare function d6<State extends CollectorState = CollectorState>(count?: number): RngCollector<DieRoll, State>;
+/** Flip a coin. The submitted value is `{ value: "heads" | "tails" }`. */
+declare function coin<State extends CollectorState = CollectorState>(): RngCollector<CoinFlip, State>;
+declare const rngInput: {
+    d6: typeof d6;
+    coin: typeof coin;
+};
+
+type ManyOptions = {
+    count: number;
+    distinct?: boolean;
+} | {
+    min?: number;
+    max?: number;
+    distinct?: boolean;
+};
+type NonRngCollector = InputCollector<SchemaLike<unknown>, CollectorState> & {
+    readonly kind: Exclude<InputCollector["kind"], "rng">;
+};
+type CollectorSchema<Collector extends NonRngCollector> = [Collector] extends [
+    InputCollector<infer Schema, CollectorState>
+] ? Schema : never;
+type CollectorStateOf<Collector extends NonRngCollector> = [Collector] extends [
+    InputCollector<SchemaLike<unknown>, infer State>
+] ? State : never;
+type CollectorKindOf<Collector extends NonRngCollector> = [Collector] extends [
+    {
+        readonly kind: infer Kind extends Exclude<InputCollector["kind"], "rng">;
+    }
+] ? Kind : never;
+type ManyInputCollector<Schema extends SchemaLike<unknown> = SchemaLike<unknown>, State extends CollectorState = CollectorState, Kind extends Exclude<InputCollector["kind"], "rng"> = Exclude<InputCollector["kind"], "rng">> = InputCollector<z.ZodType<ReadonlyArray<z.infer<Schema>>>, State, Kind> & {
+    readonly selection: Extract<InputSelectionDescriptor, {
+        mode: "many";
+    }>;
+};
+declare function many<Collector extends NonRngCollector>(collector: Collector, options: ManyOptions): ManyInputCollector<CollectorSchema<Collector>, CollectorStateOf<Collector>, CollectorKindOf<Collector>> & Pick<Collector, "meta">;
+
+type SparseMap<Key extends string, Value> = Partial<Record<Key, Value>>;
+type SparseCounts<Key extends string> = SparseMap<Key, number>;
+declare function sparseMap<KeySchema extends z.ZodType<string>, ValueSchema extends z.ZodTypeAny>(keySchema: KeySchema, valueSchema: ValueSchema): z.ZodType<SparseMap<z.infer<KeySchema>, z.infer<ValueSchema>>>;
+declare function sparseCounts<KeySchema extends z.ZodType<string>>(keySchema: KeySchema): z.ZodType<SparseCounts<z.infer<KeySchema>>>;
+declare function normalizeCommandParams<Output>(schema: SchemaLike<Output>, input: unknown): Output;
+
+type ReducerBundle = ReducerBundleContract & {
+    createInProcessRuntime(): {
+        initialize(input: {
+            table: unknown;
+            playerIds: string[];
+            rngSeed?: number | null;
+            setup?: unknown;
+        }): Promise<void>;
+        hydrate(input: {
+            state: unknown;
+        }): void;
+        dispatch(input: {
+            input: unknown;
+        }): Promise<{
+            kind: "accept";
+        } | {
+            kind: "accept";
+            state: unknown;
+            trace: unknown[];
+        } | {
+            kind: "reject";
+            errorCode: string;
+            message?: string;
+        }>;
+        projectSeatViewDynamic(input: {
+            playerId: unknown;
+            viewId?: string;
+        }): unknown;
+        projectSeatsDynamic(input: {
+            playerIds: unknown[];
+            viewId?: string;
+            projectionMode?: "full" | "actionsOnly";
+        }): {
+            currentStage: string | null;
+            stageSeats: string[];
+            simultaneousPhase: {
+                phaseName: string;
+                interactionId: string;
+                actorIds: string[];
+                sealedPlayerIds: string[];
+                pendingPlayerIds: string[];
+            } | null;
+            seats: Record<string, {
+                view?: unknown;
+                availableInteractionRefs: unknown;
+                zones?: unknown;
+            }>;
+            interactionsByRef: Record<string, unknown>;
+        };
+        snapshot(): unknown;
+        unsafeState(): unknown;
+    };
+    projectSeatViewDynamic(input: {
+        state: unknown;
+        playerId: unknown;
+        viewId?: string;
+    }): unknown;
+};
+
+declare function createReducerBundle<Contract extends ReducerGameContractLike, Definitions extends PhaseMapOf<Contract>, Views extends ViewMapOf<Contract>>(definition: ReducerGameDefinition<Contract, Definitions, Views>): ReducerBundle;
+
+type ClientParamSchema = {
+    safeParse: (value: unknown) => {
+        success: true;
+        data: Record<string, unknown>;
+    } | {
+        success: false;
+        error: {
+            issues: Array<{
+                path: PropertyKey[];
+                message: string;
+            }>;
+        };
+    };
+};
+type ClientParamSchemasByPhase = Readonly<Record<string, Readonly<Record<string, ClientParamSchema>>>>;
+declare function createClientParamSchemasByPhase<Contract extends ReducerGameContractLike, Definitions extends PhaseMapOf<Contract>, Views extends ViewMapOf<Contract>>(definition: ReducerGameDefinition<Contract, Definitions, Views>): ClientParamSchemasByPhase;
+
+type StatefulBootstrapContext = {
+    table: RuntimeTableRecord;
+    runtime: {
+        rng: RuntimeRngState;
+    };
+};
+declare function applySetupBootstrap<State extends StatefulBootstrapContext>(state: State, steps: readonly SetupBootstrapStep[]): State;
+
+declare function shuffle<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike>(container: SetupBootstrapContainerRef<Manifest>): SetupBootstrapStep<Manifest>;
+declare function dealToPlayerZone<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike>({ from, zoneId, count, playerIds, }: {
+    from: Extract<SetupBootstrapContainerRef<Manifest>, {
+        type: "sharedZone" | "sharedBoardContainer";
+    }>;
+    zoneId: Extract<SetupBootstrapPerPlayerContainerTemplateRef<Manifest>, {
+        type: "playerZone";
+    }>["zoneId"];
+    count: number;
+    playerIds?: readonly PlayerIdOfManifest<Manifest>[];
+}): SetupBootstrapStep<Manifest>;
+declare function dealToPlayerBoardContainer<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike>({ from, boardId, containerId, count, playerIds, }: {
+    from: Extract<SetupBootstrapContainerRef<Manifest>, {
+        type: "sharedZone" | "sharedBoardContainer";
+    }>;
+    boardId: Extract<SetupBootstrapPerPlayerContainerTemplateRef<Manifest>, {
+        type: "playerBoardContainer";
+    }>["boardId"];
+    containerId: Extract<SetupBootstrapPerPlayerContainerTemplateRef<Manifest>, {
+        type: "playerBoardContainer";
+    }>["containerId"];
+    count: number;
+    playerIds?: readonly PlayerIdOfManifest<Manifest>[];
+}): SetupBootstrapStep<Manifest>;
+declare function seedSharedBoardContainer<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike>({ from, boardId, containerId, count, componentIds, }: {
+    from: SetupBootstrapContainerRef<Manifest>;
+    boardId: Extract<SetupBootstrapDestinationRef<Manifest>, {
+        type: "sharedBoardContainer";
+    }>["boardId"];
+    containerId: Extract<SetupBootstrapDestinationRef<Manifest>, {
+        type: "sharedBoardContainer";
+    }>["containerId"];
+    count?: number;
+    componentIds?: readonly (CardIdOfManifest<Manifest> | PieceIdOfManifest<Manifest> | DieIdOfManifest<Manifest>)[];
+}): SetupBootstrapStep<Manifest>;
+declare function seedSharedBoardSpace<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike>({ from, boardId, spaceId, count, componentIds, }: {
+    from: SetupBootstrapContainerRef<Manifest>;
+    boardId: Extract<SetupBootstrapDestinationRef<Manifest>, {
+        type: "sharedBoardSpace";
+    }>["boardId"];
+    spaceId: Extract<SetupBootstrapDestinationRef<Manifest>, {
+        type: "sharedBoardSpace";
+    }>["spaceId"];
+    count?: number;
+    componentIds?: readonly (CardIdOfManifest<Manifest> | PieceIdOfManifest<Manifest> | DieIdOfManifest<Manifest>)[];
+}): SetupBootstrapStep<Manifest>;
+
+declare function setActivePlayers<State extends {
+    flow: {
+        activePlayers: PlayerIdOfState<State>[];
+    };
+}>(state: State, activePlayers: PlayerIdOfState<State>[]): State;
+declare function assertCardAllowedInContainer<Table extends RuntimeTableRecord, BoardId extends BoardIdOfTable<NoInfer<Table>>, ContainerId extends BoardContainerIdOfTable<NoInfer<Table>, BoardId>>(table: Table, boardId: BoardId, containerId: ContainerId, componentId: string): void;
+
+declare function createTableQueries<Table extends RuntimeTableRecord>(table: Table): TableQueries<Table>;
+declare function createStateQueries<State extends {
+    table: RuntimeTableRecord;
+}>(state: State): TableQueriesOfState<State>;
+
+export { type ActionContext, type BoardBaseIdOfManifest, type BoardContainerIdOfManifest, type BoardContainerIdOfTable, type BoardIdOfManifest, type BoardIdOfTable, type BoardInteractionKeyOfDefinition, type BoardLayoutOfManifest, type BoardMapOfTable, type BoardRef, type BoardStateOfTable, type BoardTargetBuilder, type BoardTargetPredicate, type BoardTargetRule, type BoardTypeIdOfManifest, type BoardTypeIdOfTable, type BoundTargetRule, type CardIdOfDeck, type CardIdOfHand, type CardIdOfManifest, type CardIdOfState, type CardIdOfTable, type CardInputZoneIdsOfDefinition, type CardInteractionKeyOfDefinition, type CardTargetBuilder, type CardTargetPredicate, type CardTargetRule, type ChoiceOption, type ChoiceOptionsFactory, type ChoiceTargetBuilder, type ChoiceTargetOption, type ChoiceTargetPredicate, type ChoiceTargetRule, type ClientParamSchema, type ClientParamSchemasByPhase, type ClientParamsOf, type ClientParamsOfInteractionOfDefinition, type CompatibleCardIdForHandAndDeck, type CompatibleHandIdForDeck, type ComponentDataOfTable, type ComponentIdOfTable, type ComponentLocationByTypeOfTable, type ComponentLocationOfTable, type ContinuationCallable, type ContinuationInput, type ContinuationResponseOf, type ContinuationSourceKind, type ContinuationToken, type DeckCardsOfTable, type DeckIdOfState, type DeckIdOfTable, type DefaultedClientParamKeysOfInteractionOfDefinition, type DefinedInputs, type DependencyValues, type DerivedDefinition, type DerivedResolver, type DieIdOfManifest, type EdgeTypeIdOfManifest, type EffectContinuationCallable, type EffectContinuationInput, type EffectContinuationResponse, type EffectDefinition, type EffectIdsOfDefinition, type EffectMap, type EffectRollDieDefinition, type EffectShuffleDefinition, type GameStateOf, type HandCardsOfTable, type HandIdOfState, type HandIdOfTable, type HexBoardIdOfTable, type HexEdgeIdOfTable, type HexEdgeTypeIdOfTable, type HexSpaceIdOfTable, type HexSpaceTypeIdOfTable, type HexVertexIdOfTable, type HexVertexTypeIdOfTable, type InitContext, type InitialStateCallbacks, type InputCollector, type InputCollectorKind, type InputFieldRef, type InputKeysWithCollectorKindOfDefinition, type InteractionAvailabilityArgs, type InteractionIdOfDefinition, type InteractionIdOfDefinitionPhase, type InteractionKind, type InteractionMap, type InteractionRule, type InteractionSpec, type InteractionToArgs, type InteractionValidateArgs, type ManifestIdSchema, type ManifestOf, type ManyOptions, type Op, type ParamsOf, type ParamsOfInteractionOfDefinition, type PerPlayer, type PerPlayerBoardRef, type PerPlayerSchemaOptions, type PhaseDefinitionByName, type PhaseMapOf, type PhaseNameOf, type PhaseNamesOfDefinition, type PhaseZoneList, type PieceIdOfManifest, type PlayableInteractionsOfZoneOfDefinition, type PlayerBoardSpaceTarget, type PlayerId, type PlayerIdOfManifest, type PlayerIdOfState, type PlayerIdOfTable, type PlayerZoneIdOfManifest, type PlayerZoneIdOfState, type PlayerZoneIdOfTable, type PromptInteractionKeyOfDefinition, type ReducerAccept, type ReducerBundle, type ReducerEdit, type ReducerGameContract, type ReducerGameDefinition, type ReducerManifestContract, type ReducerOps, type ReducerPhaseDefinition, type ReducerReject, type ReducerResult, type ReducerStateBase, type ReducerTransaction, type ReducerValidationResult, type ReducerViewDefinition, type RelationTypeIdOfManifest, type RelationTypeIdOfTable, type ResolvedContainerLocation, type ResolvedDeckLocation, type ResolvedEdgeLocation, type ResolvedHandLocation, type ResolvedSlotLocation, type ResolvedSpaceLocation, type ResolvedVertexLocation, type ResolvedZoneLocation, type ResumableEffectKind, type RollDieContinuationResponse, type RotatePlayerZoneArgs, type RuntimeCardData, type RuntimeCardVisibility, type RuntimeComponentLocation, type RuntimeDieData, type RuntimeHandVisibilityMode, type RuntimePayload, type RuntimePieceData, type RuntimeRecord, type RuntimeSetupSelection, type RuntimeSetupSelectionInput, type RuntimeTableRecord, type RuntimeZoneMap, type SetupBootstrapContainerRef, type SetupBootstrapDestinationRef, type SetupBootstrapPerPlayerContainerTemplateRef, type SetupBootstrapStep, type SetupOptionChoiceMetadata, type SetupOptionIdOfManifest, type SetupOptionMetadata, type SetupProfileDefinition, type SetupProfileIdOfManifest, type SetupProfileMetadata, type SetupSelectionInputOfManifest, type SetupSelectionOfManifest, type SharedBoardRef, type SharedZoneIdOfManifest, type SharedZoneIdOfState, type SharedZoneIdOfTable, type ShuffleSharedZoneContinuationResponse, type SpaceIdOfManifest, type SpaceIdOfTable, type SpaceTypeIdOfManifest, type SpaceTypeIdOfTable, type SparseCounts, type SparseMap, type SquareBoardIdOfTable, type SquareEdgeIdOfTable, type SquareEdgeTypeIdOfTable, type SquareSpaceIdOfTable, type SquareSpaceTypeIdOfTable, type SquareVertexIdOfTable, type SquareVertexTypeIdOfTable, type StageMap, type StageNamesOfDefinitionPhase, type StageSpec, type StaticBoards, type StaticViewDefinition, type StaticViewQueries, type TableQueries, type TableQueriesOfState, type TargetContext, type TargetPredicate, type TargetPredicateArgs, type TargetRule, type TargetRuleBuilder, type TiledBoardIdOfTable, type TiledEdgeIdOfTable, type TiledEdgeMap, type TiledEdgeTypeIdOfTable, type TiledSpaceIdOfTable, type TiledSpaceMap, type TiledVertexIdOfTable, type TiledVertexMap, type TiledVertexTypeIdOfTable, type VertexTypeIdOfManifest, type ViewNamesOfDefinition, type ViewOfDefinition, type ZoneIdsOfDefinition, applySetupBootstrap, asPlayerId, assertCardAllowedInContainer, assumeManifestSchema, boardInput, boardRef, boardRefKey, boardRefSchema, boardTarget, cardInput, cardTarget, choiceTarget, cloneManifestDefault, createClientParamSchemasByPhase, createDerivedResolver, createManifestGameStateSchema, createManifestRuntimeSchema, createManifestStringLiteralSchema, createReducerBundle, createReducerEdit, createReducerOps, createReducerTransaction, createStateQueries, createTableQueries, dealToPlayerBoardContainer, dealToPlayerZone, defineCardAction, defineDerived, defineEffect, defineGame, defineGameContract, defineInputs, defineInteraction, defineInteractionRule, definePhase, definePhaseStage, defineStage, defineStaticView, defineStepPhase, defineView, formInput, isPerPlayer, isPerPlayerBoardRef, isPlayerId, isSharedBoardRef, many, markManifestScopedSchema, normalizeCommandParams, parseBoardRefKey, perPlayer, perPlayerBoardRef, perPlayerEntries, perPlayerGet, perPlayerHas, perPlayerKeys, perPlayerMap, perPlayerRequire, perPlayerSchema, perPlayerSet, perPlayerSize, perPlayerValues, pipe, promptInput, resolveManifestPlayerIds, rngInput, seedSharedBoardContainer, seedSharedBoardSpace, setActivePlayers, sharedBoardRef, shuffle, sparseCounts, sparseMap };