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

package/dist/views-B0hlW6IT.d.ts

@@ -0,0 +1,3153 @@
+import { z } from 'zod';
+import { CardCollection, ViewCard, ViewSlotOccupant } from './types.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 RuntimeParams = RuntimeRecord;
+type SchemaLike<Output> = z.ZodType<Output>;
+type AnySchema = z.ZodTypeAny;
+type StringKeyOf<T> = Extract<keyof T, string>;
+type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
+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 RuntimeTiledSpaceState = RuntimeHexSpaceState | RuntimeSquareSpaceState;
+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>;
+};
+
+declare const FrameworkErrorCodes: {
+    readonly NOT_YOUR_TURN: "NOT_YOUR_TURN";
+    readonly WRONG_PHASE: "WRONG_PHASE";
+    readonly WRONG_STEP: "WRONG_STEP";
+    readonly INVALID_PARAMS: "INVALID_PARAMS";
+    readonly UNKNOWN_INTERACTION: "UNKNOWN_INTERACTION";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+};
+type FrameworkErrorCode = (typeof FrameworkErrorCodes)[keyof typeof FrameworkErrorCodes];
+
+type TableOfState<State> = State extends {
+    table: infer Table;
+} ? Table : never;
+type TableOfManifest<Manifest> = Manifest extends {
+    tableSchema: z.ZodType<infer Table extends RuntimeTableRecord>;
+} ? Table : Manifest extends 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>>;
+type ErrorCodeOfContract<Contract> = Contract extends {
+    errors: infer Errors extends Record<string, string>;
+} ? (keyof Errors & string) | FrameworkErrorCode : string;
+/**
+ * Manifest-declared resource id union for a runtime table.
+ *
+ * Derived from the shape of `table.resources`, which the generated
+ * manifest contract seeds as `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;
+type ResourceIdOfState<State> = ResourceIdOfTable<TableOfState<State>>;
+/**
+ * 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;
+type ResourceBalancesOfState<State> = ResourceBalancesOfTable<TableOfState<State>>;
+type ResourceIdOfManifest<Manifest> = Manifest extends {
+    literals: {
+        resourceIds: readonly (infer ResourceId)[];
+    };
+} ? Extract<ResourceId, string> : string;
+/**
+ * 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 PhaseStepOfState<State> = PhaseStateOfState<State> extends {
+    step?: infer Step;
+} ? Extract<NonNullable<Step>, string> : never;
+type PhaseMapOfState<State> = PhaseStateOfState<State>;
+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 HexEdgeStateOfTable<Table, BoardId extends HexBoardIdOfTable<Table>, EdgeId extends HexEdgeIdOfTable<Table, BoardId>> = HexBoardStateOfTable<Table, BoardId> extends {
+    edges: readonly (infer Edge)[];
+} ? Edge extends {
+    id: string;
+} ? Omit<Edge, "id"> & {
+    id: EdgeId;
+} : never : never;
+type SquareEdgeStateOfTable<Table, BoardId extends SquareBoardIdOfTable<Table>, EdgeId extends SquareEdgeIdOfTable<Table, BoardId>> = SquareBoardStateOfTable<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 HexVertexStateOfTable<Table, BoardId extends HexBoardIdOfTable<Table>, VertexId extends HexVertexIdOfTable<Table, BoardId>> = HexBoardStateOfTable<Table, BoardId> extends {
+    vertices: readonly (infer Vertex)[];
+} ? Vertex extends {
+    id: string;
+} ? Omit<Vertex, "id"> & {
+    id: VertexId;
+} : never : never;
+type SquareVertexStateOfTable<Table, BoardId extends SquareBoardIdOfTable<Table>, VertexId extends SquareVertexIdOfTable<Table, BoardId>> = SquareBoardStateOfTable<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 RuntimeSetupSelectionOverride<Manifest extends GeneratedManifestContractLike = GeneratedManifestContractLike> = SetupSelectionInputOfManifest<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 StaticBoardsJsonEnvelope<Table extends RuntimeTableRecord = RuntimeTableRecord> = {
+    formatVersion: 1;
+    generatedBy: "@dreamboard-games/sdk/codegen";
+    boards: StaticBoards<Table>;
+    initialTable: Table;
+};
+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 isManifestScopedSchema(schema: unknown): boolean;
+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 InitSetupSelectionInput<Manifest extends ReducerManifestContract<RuntimeTableRecord, string, string, string, string, string> = GeneratedManifestContractLike> = SetupSelectionInputOfManifest<Manifest>;
+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 PhasePayload<PhaseStates extends Record<string, object>, CurrentPhase extends keyof PhaseStates & string> = PhaseStates[CurrentPhase] & PhaseAccessor<PhaseStates, CurrentPhase>;
+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 ReducerSessionState<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Setup extends RuntimeSetupSelection = RuntimeSetupSelection> = {
+    domain: State;
+    runtime: ReducerRuntimeStateForState<State, Setup>;
+};
+type ReducerValidationResult = {
+    valid: true;
+} | {
+    valid: false;
+    errorCode: string;
+    message?: string;
+};
+type ReducerReject = {
+    type: "reject";
+    errorCode: string;
+    message?: string;
+};
+type TerminalOutcome<PlayerId extends string = string, Score extends number = number> = {
+    winnerPlayerId?: PlayerId;
+    finalScores?: Partial<Record<PlayerId, Score>>;
+    reason: string;
+};
+type ReducerAccept<State> = {
+    type: "accept";
+    state: State;
+    instructions?: RuntimeInstructionForState<State>[];
+    terminal?: TerminalOutcome<PlayerIdOfState<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>>, Errors extends Record<string, string> | undefined = undefined> = {
+    manifest: Manifest;
+    state: StateDefinition<PublicSchema, PrivateSchema, HiddenSchema>;
+    phases: Phases;
+    errors?: Errors;
+    /** Derived from `phases`; retained as an internal runtime convenience. */
+    phaseNames: readonly string[];
+};
+type ReducerStateForConfig<Table extends RuntimeTableRecord, PublicSchema extends SchemaLike<object>, PrivateSchema extends SchemaLike<object>, HiddenSchema extends SchemaLike<object>, PhaseName extends string> = ReducerGameState<Table, z.infer<PublicSchema>, z.infer<PrivateSchema>, z.infer<HiddenSchema>, RuntimePhaseState, PhaseName, Record<PhaseName, RuntimePhaseState>>;
+type ReducerSessionForConfig<Table extends RuntimeTableRecord, PublicSchema extends SchemaLike<object>, PrivateSchema extends SchemaLike<object>, HiddenSchema extends SchemaLike<object>, PhaseName extends string, Setup extends RuntimeSetupSelection = RuntimeSetupSelection> = ReducerSessionState<ReducerStateForConfig<Table, PublicSchema, PrivateSchema, HiddenSchema, PhaseName>, Setup>;
+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>>;
+type BaseGameSessionOfContract<Contract> = ReducerSessionState<BaseGameStateOfContract<Contract>, RuntimeSetupSelection<ManifestContractOf<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 AnyPhaseDefinitionForContract<Contract> = PhaseMapOf<Contract>[PhaseNameOfContract<Contract>];
+/**
+ * Helpers below accept heterogeneous phase maps (each phase binds its own
+ * `PhaseStateSchema` + per-phase registries). TypeScript requires the
+ * constraint to use a shape compatible with contract-bound state types in a
+ * contravariant `initialState` position, so we erase the registry-bound
+ * state/manifest generics with `any`. The only purpose of the constraint is
+ * to guarantee `Definitions[Name]` is a `PhaseDefinition` so the `extends`
+ * check below can infer `PhaseStateSchema`.
+ */
+type PhaseStateMapOfDefinitions<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>>>> = Partial<{
+    [Name in keyof Definitions & string]: Definitions[Name] extends PhaseDefinition<infer PhaseStateSchema, infer _State, infer _Manifest> ? z.infer<PhaseStateSchema> : never;
+}>;
+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 ResolvedGameSessionOf<Contract, Definitions extends PhaseMapOf<Contract>> = ReducerSessionState<ResolvedGameStateOf<Contract, Definitions>, RuntimeSetupSelection<ManifestContractOf<Contract>>>;
+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, 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 AnyReducerGameDefinition = ReducerGameDefinition<ReducerGameContractLike, PhaseMapOf<ReducerGameContractLike>, ViewMapOf<ReducerGameContractLike>>;
+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 ContinuationKind = ResumableEffectKind;
+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 extends string = string> = {
+    errorCode: ErrorCode;
+    message?: string;
+};
+type RuntimeHelpers<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, ErrorCode extends string = string> = {
+    accept(state: State, instructions?: RuntimeInstructionForState<State>[]): ReducerAccept<State>;
+    endGame(state: State, outcome: TerminalOutcome<PlayerIdOfState<State>>, instructions?: RuntimeInstructionForState<State>[]): ReducerAccept<State>;
+    reject: (errorCode: ErrorCode, 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 AnyContinuationCallable<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}> = {
+    (data: never): AnyContinuationToken;
+    id: string;
+    source: "effect";
+    dataSchema: AnySchema;
+    responseSchema: AnySchema;
+    effectKind?: ResumableEffectKind;
+    reduce: (args: unknown) => 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 EffectRegistryOfPhase<Phase> = Phase extends {
+    effects?: infer Effects extends Record<string, unknown>;
+} ? Effects : Record<string, never>;
+
+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>>, ErrorCode extends string = string> = ActionContext<State, Manifest> & RuntimeHelpers<State, ErrorCode> & {
+    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>>, ErrorCode extends string = string> = InteractionValidateArgs<Collectors, State, Manifest, ErrorCode> & 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<ErrorCode extends string = string> = boolean | string | ValidationIssue<ErrorCode> | null | undefined;
+type InteractionRule<Collectors extends Record<string, InputCollector> = Record<string, InputCollector>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+} = {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>> = ManifestContract<TableOfState<State>>, ErrorCode extends string = string> = {
+    /**
+     * Stable rule id for diagnostics and tests. Rule ids are author-owned and
+     * should be unique within one interaction.
+     */
+    id: string;
+    /**
+     * Error code used when the rule fails. The same code is used for descriptor
+     * availability and submit-time validation unless `validate` returns a
+     * specific ValidationIssue.
+     */
+    errorCode: ErrorCode;
+    message?: string;
+    /**
+     * Projection-time rule. Runs without submitted params, so UI descriptors can
+     * reflect action availability before the user clicks.
+     */
+    available?: BivariantCallback<InteractionAvailabilityArgs<State, Manifest>, boolean>;
+    /**
+     * Submit-time rule. Runs with parsed params and may return false, a concrete
+     * ValidationIssue, null, or undefined.
+     */
+    validate?: BivariantCallback<InteractionValidateArgs<Collectors, State, Manifest, ErrorCode>, InteractionRuleValidationResult<ErrorCode>>;
+};
+type InteractionCommitPolicy = {
+    mode: "manual";
+} | {
+    mode: "autoWhenReady";
+};
+type HasManyInputCollector<Collectors extends Record<string, InputCollector>> = Extract<Collectors[keyof Collectors], {
+    readonly selection: {
+        readonly mode: "many";
+    };
+}> extends never ? false : true;
+type InteractionCommitPolicyFor<Collectors extends Record<string, InputCollector>> = HasManyInputCollector<Collectors> extends true ? {
+    mode: "manual";
+} : InteractionCommitPolicy;
+/**
+ * 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>>, ErrorCode extends string = string> = {
+    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 ErrorCode[];
+    cost?: BivariantCallback<InteractionValidateArgs<Collectors, State, Manifest, ErrorCode>, Readonly<Record<string, number>>>;
+    rules?: readonly InteractionRule<NoInfer<Collectors>, State, Manifest, ErrorCode>[];
+    reduce: BivariantCallback<InteractionReduceArgs<Collectors, State, Manifest, ErrorCode>, 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>, ErrorCode extends string = string> = {
+    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 ErrorCode[];
+    cost?: BivariantCallback<InteractionValidateArgs<Collectors & {
+        cardId: InputCollector<SchemaLike<CardIdOfState<State>>>;
+    }, State, Manifest, ErrorCode>, Readonly<Record<string, number>>>;
+    rules?: readonly InteractionRule<NoInfer<Collectors & {
+        cardId: InputCollector<SchemaLike<CardIdOfState<State>>>;
+    }>, State, Manifest, ErrorCode>[];
+    reduce: BivariantCallback<InteractionReduceArgs<Collectors & {
+        cardId: InputCollector<SchemaLike<CardIdOfState<State>>>;
+    }, State, Manifest, ErrorCode>, ReducerResult<State>>;
+};
+type AnyInteractionRule = Omit<InteractionRule<any, any, any, any>, "available" | "validate"> & {
+    available?: BivariantCallback<any, boolean>;
+    validate?: BivariantCallback<any, InteractionRuleValidationResult<any>>;
+};
+type AnyCardActionSpec<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = Omit<CardActionSpec<any, State, Manifest, any, any>, "actor" | "cost" | "rules" | "reduce"> & {
+    actor?: BivariantCallback<any, any>;
+    cost?: BivariantCallback<any, Readonly<Record<string, number>>>;
+    rules?: readonly AnyInteractionRule[];
+    reduce: BivariantCallback<any, ReducerResult<any>>;
+};
+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
+ * intentionally erased with `any`: each authored interaction keeps a specific
+ * params shape, but phase registries need to store all of them together.
+ */
+type AnyInteractionSpec<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = Omit<InteractionSpec<any, State, Manifest, any>, "actor" | "cost" | "rules" | "reduce" | "to"> & {
+    actor?: BivariantCallback<any, any>;
+    cost?: BivariantCallback<any, Readonly<Record<string, number>>>;
+    rules?: readonly AnyInteractionRule[];
+    reduce: BivariantCallback<any, ReducerResult<any>>;
+    to?: BivariantCallback<any, any>;
+};
+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>[];
+
+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;
+};
+
+export { type ComponentDataOfTable as $, type ActionContext as A, type BaseGameSessionOfContract as B, type BoardTypeIdOfTable as C, type BoundedNumberDomainDescriptor as D, type Brand as E, type CardActionMap as F, type CardActionSpec as G, type CardIdOfDeck as H, type CardIdOfHand as I, type CardIdOfManifest as J, type CardIdOfState as K, type CardIdOfTable as L, type CardInputCollectorMeta as M, type CardInputZoneIdsOfDefinition as N, type CardInteractionKeyOfDefinition as O, type CardTargetDomainDescriptor as P, type CardTypeOfState as Q, type CardTypeOfTable as R, type ChoiceDomainDescriptor as S, type ChoiceListDomainDescriptor as T, type ChoiceOption as U, type ClientParamsOf as V, type ClientParamsOfInteractionOfDefinition as W, type CollectorState as X, type CompatibleCardIdForHandAndDeck as Y, type CompatibleCardIdForTwoPlayerZones as Z, type CompatibleHandIdForDeck as _, type ActorSelection as a, type InputDomainResolverDescriptor as a$, type ComponentIdOfTable as a0, type ComponentLocationByTypeOfTable as a1, type ComponentLocationOfTable as a2, type ContinuationCallable as a3, type ContinuationInput as a4, type ContinuationInputForSource as a5, type ContinuationKind as a6, type ContinuationReduceArgs as a7, type ContinuationResponseOf as a8, type ContinuationSourceKind as a9, type FrameworkErrorCode as aA, FrameworkErrorCodes as aB, type GameStateOf as aC, type GeneratedManifestContractLike as aD, type HandCardsOfTable as aE, type HandIdOfState as aF, type HandIdOfTable as aG, type HexBoardIdOfTable as aH, type HexBoardStateOfTable as aI, type HexEdgeIdOfTable as aJ, type HexEdgeStateOfTable as aK, type HexEdgeTypeIdOfTable as aL, type HexSpaceIdOfTable as aM, type HexSpaceTypeIdOfTable as aN, type HexVertexIdOfTable as aO, type HexVertexStateOfTable as aP, type HexVertexTypeIdOfTable as aQ, type HiddenSchemaOfContract as aR, type HiddenStateOfState as aS, type InitContext as aT, type InitSetupSelectionInput as aU, type InitialStateCallbacks as aV, type InputCollector as aW, type InputCollectorKind as aX, type InputCollectorMetaForKind as aY, type InputDomainDependencyCase as aZ, type InputDomainDescriptor as a_, type ContinuationToken as aa, type DeckCardsOfTable as ab, type DeckIdOfState as ac, type DeckIdOfTable as ad, type DefaultedClientParamKeysOfInteractionOfDefinition as ae, type DerivedDefinition as af, type DerivedResolver as ag, type DieIdOfManifest as ah, type EagerInputDomainDependencies as ai, type EdgeTypeIdOfManifest as aj, type EffectContinuationCallable as ak, type EffectContinuationInput as al, type EffectContinuationResponse as am, type EffectDefinition as an, type EffectIdsOfDefinition as ao, type EffectInvokeOptions as ap, type EffectMap as aq, type EffectRegistryOfPhase as ar, type EffectRollDieDefinition as as, type EffectShuffleDefinition as at, type EffectShufflePlayerZoneDefinition as au, type EffectSpecLike as av, type EffectTypeTag as aw, type ErrorCodeOfContract as ax, type ExactManifestContractOf as ay, type FlowState as az, type ActorSelector as b, type PlayerZoneIdOfTable as b$, type InputKeysWithCollectorKindOfDefinition as b0, type InputSelectionDescriptor as b1, type InteractionAvailabilityArgs as b2, type InteractionCommitPolicy as b3, type InteractionIdOfDefinition as b4, type InteractionIdOfDefinitionPhase as b5, type InteractionKind as b6, type InteractionMap as b7, type InteractionReduceArgs as b8, type InteractionReduceInput as b9, type PhaseDefinitionByName as bA, type PhaseEnterArgs as bB, type PhaseEnterContext as bC, type PhaseMapOf as bD, type PhaseMapOfState as bE, type PhaseNameOf as bF, type PhaseNameOfContract as bG, type PhaseNameOfManifest as bH, type PhaseNameOfState as bI, type PhaseNamesOfDefinition as bJ, type PhasePayload as bK, type PhaseSchemasOfContract as bL, type PhaseStateMapOfContract as bM, type PhaseStateMapOfDefinitions as bN, type PhaseStateOfDefinitions as bO, type PhaseStateOfState as bP, type PhaseStepOfState as bQ, type PhaseZoneList as bR, type PieceIdOfManifest as bS, type PlayableInteractionsOfZoneOfDefinition as bT, type PlayerId as bU, type PlayerIdOfManifest as bV, type PlayerIdOfState as bW, type PlayerIdOfTable as bX, type PlayerPhaseDefinition as bY, type PlayerZoneIdOfManifest as bZ, type PlayerZoneIdOfState as b_, type InteractionRule as ba, type InteractionRuleValidationResult as bb, type InteractionSpec as bc, type InteractionSpecByNameOfDefinitionPhase as bd, type InteractionToArgs as be, type InteractionValidateArgs as bf, type LazyBoardTargetDomainDescriptor as bg, type LazyCardTargetDomainDescriptor as bh, type LazyInputDomainDependencies as bi, type ManifestContract as bj, type ManifestContractOf as bk, type ManifestDefaults as bl, type ManifestIdSchema as bm, type ManifestIds as bn, type ManifestLiterals as bo, type ManifestOf as bp, type MutationRuntimeHelpers as bq, type NonEmptyReadonlyArray as br, type Op as bs, type ParamsOf as bt, type ParamsOfInteractionOfDefinition as bu, type PerPlayer as bv, type PerPlayerBoardRef as bw, type PerPlayerSchemaOptions as bx, type PhaseAccessor as by, type PhaseDefinition as bz, type ActorSelectorArgs as c, type RuntimeGenericBoardState as c$, type PrivateSchemaOfContract as c0, type PrivateStateOfState as c1, type PromptInputCollectorMeta as c2, type PromptInteractionKeyOfDefinition as c3, type PublicSchemaOfContract as c4, type PublicStateOfState as c5, type RandomHelpers as c6, type ReducerAccept as c7, type ReducerEdit as c8, type ReducerFx as c9, type ResolvedSpaceLocation as cA, type ResolvedVertexLocation as cB, type ResolvedZoneLocation as cC, type ResourceAmountsOfTable as cD, type ResourceBalancesOfState as cE, type ResourceBalancesOfTable as cF, type ResourceIdOfManifest as cG, type ResourceIdOfState as cH, type ResourceIdOfTable as cI, type ResourceMapDomainDescriptor as cJ, type ResumableEffectKind as cK, type RngInputCollectorMeta as cL, type RollDieContinuationResponse as cM, type RotatePlayerZoneArgs as cN, type RuntimeBoardBaseState as cO, type RuntimeBoardCollections as cP, type RuntimeBoardCompatibilityState as cQ, type RuntimeBoardContainerState as cR, type RuntimeBoardRelationState as cS, type RuntimeBoardSpaceState as cT, type RuntimeBoardState as cU, type RuntimeCardData as cV, type RuntimeCardVisibility as cW, type RuntimeComponentLocation as cX, type RuntimeComponentLocationMap as cY, type RuntimeDeckMap as cZ, type RuntimeDieData as c_, type ReducerGameContract as ca, type ReducerGameContractLike as cb, type ReducerGameDefinition as cc, type ReducerGameState as cd, type ReducerManifestContract as ce, type ReducerOps as cf, type ReducerReject as cg, type ReducerResult as ch, type ReducerRuntimeStateForState as ci, type ReducerSessionForConfig as cj, type ReducerSessionState as ck, type ReducerStateBase as cl, type ReducerStateForConfig as cm, type ReducerTransaction as cn, type ReducerValidationResult as co, type RelationTypeIdOfManifest as cp, type RelationTypeIdOfTable as cq, type ResolvedBoardTargetDomainDescriptor as cr, type ResolvedCardTargetDomainDescriptor as cs, type ResolvedContainerLocation as ct, type ResolvedDeckLocation as cu, type ResolvedEdgeLocation as cv, type ResolvedGameSessionOf as cw, type ResolvedGameStateOf as cx, type ResolvedHandLocation as cy, type ResolvedSlotLocation as cz, type AnyCardActionSpec as d, type SimultaneousPlayerPhaseDefinition as d$, type RuntimeHandMap as d0, type RuntimeHandVisibilityMode as d1, type RuntimeHelpers as d2, type RuntimeHexBoardState as d3, type RuntimeHexEdgeState as d4, type RuntimeHexOrientation as d5, type RuntimeHexSpaceState as d6, type RuntimeHexVertexState as d7, type RuntimeOwnerMap as d8, type RuntimeParams as d9, type RuntimeZoneMap as dA, type SchemaLike as dB, type ScopedPhaseState as dC, type SetupBootstrapContainerRef as dD, type SetupBootstrapDestinationRef as dE, type SetupBootstrapPerPlayerBoardContainerRef as dF, type SetupBootstrapPerPlayerBoardSpaceRef as dG, type SetupBootstrapPerPlayerContainerTemplateRef as dH, type SetupBootstrapPerPlayerZoneRef as dI, type SetupBootstrapSharedBoardContainerRef as dJ, type SetupBootstrapSharedBoardSpaceRef as dK, type SetupBootstrapSharedZoneRef as dL, type SetupBootstrapStep as dM, type SetupOptionChoiceMetadata as dN, type SetupOptionIdOfManifest as dO, type SetupOptionMetadata as dP, type SetupProfileDefinition as dQ, type SetupProfileIdOfManifest as dR, type SetupProfileMetadata as dS, type SetupSelectionInputOfManifest as dT, type SetupSelectionOfManifest as dU, type SharedBoardRef as dV, type SharedZoneIdOfManifest as dW, type SharedZoneIdOfState as dX, type SharedZoneIdOfTable as dY, type ShufflePlayerZoneContinuationResponse as dZ, type ShuffleSharedZoneContinuationResponse as d_, type RuntimePayload as da, type RuntimePhaseState as db, type RuntimePieceData as dc, type RuntimeRecord as dd, type RuntimeResourceMap as de, type RuntimeRngState as df, type RuntimeScalar as dg, type RuntimeSetupSelection as dh, type RuntimeSetupSelectionInput as di, type RuntimeSetupSelectionOverride as dj, type RuntimeSimultaneousState as dk, type RuntimeSimultaneousSubmission as dl, type RuntimeSlotHostRef as dm, type RuntimeSquareBoardState as dn, type RuntimeSquareEdgeState as dp, type RuntimeSquareSpaceState as dq, type RuntimeSquareVertexState as dr, type RuntimeState as ds, type RuntimeTableRecord as dt, type RuntimeTiledBoardBaseState as du, type RuntimeTiledBoardState as dv, type RuntimeTiledEdgeState as dw, type RuntimeTiledSpaceState as dx, type RuntimeTiledVertexState as dy, type RuntimeVisibilityMap as dz, type AnyContinuationCallable as e, createManifestStringLiteralSchema as e$, type SimultaneousResolveArgs as e0, type SimultaneousSubmission as e1, type SimultaneousSubmitSpec as e2, type SpaceIdOfManifest as e3, type SpaceIdOfTable as e4, type SpaceTypeIdOfManifest as e5, type SpaceTypeIdOfTable as e6, type SquareBoardIdOfTable as e7, type SquareBoardStateOfTable as e8, type SquareEdgeIdOfTable as e9, type TiledEdgeMap as eA, type TiledEdgeStateOfTable as eB, type TiledEdgeTypeIdOfTable as eC, type TiledSpaceIdOfTable as eD, type TiledSpaceMap as eE, type TiledVertexIdOfTable as eF, type TiledVertexMap as eG, type TiledVertexStateOfTable as eH, type TiledVertexTypeIdOfTable as eI, type ValidationIssue as eJ, type VertexTypeIdOfManifest as eK, type ViewDefinition as eL, type ViewDefinitionByName as eM, type ViewMapOf as eN, type ViewNamesOfDefinition as eO, type ViewOfDefinition as eP, type ViewsOfDefinition as eQ, type ZoneIdsOfDefinition as eR, asPlayerId as eS, assumeManifestSchema as eT, boardRef as eU, boardRefKey as eV, boardRefSchema as eW, cloneManifestDefault as eX, createDerivedResolver as eY, createManifestGameStateSchema as eZ, createManifestRuntimeSchema as e_, type SquareEdgeStateOfTable as ea, type SquareEdgeTypeIdOfTable as eb, type SquareSpaceIdOfTable as ec, type SquareSpaceTypeIdOfTable as ed, type SquareVertexIdOfTable as ee, type SquareVertexStateOfTable as ef, type SquareVertexTypeIdOfTable as eg, type StageMap as eh, type StageNamesOfDefinitionPhase as ei, type StageSpec as ej, type StateDefinition as ek, type StateDefinitionOfContract as el, type StaticBoards as em, type StaticBoardsJsonEnvelope as en, type StaticViewDefinition as eo, type StaticViewQueries as ep, type StringKeyOf as eq, type TableOfManifest as er, type TableOfState as es, type TableQueries as et, type TableQueriesOfState as eu, type TargetKind as ev, type TerminalOutcome as ew, type TiledBoardIdOfTable as ex, type TiledBoardStateOfTable as ey, type TiledEdgeIdOfTable as ez, type AnyContinuationToken as f, createReducerEdit as f0, createReducerOps as f1, createReducerTransaction as f2, defineDerived as f3, isManifestScopedSchema as f4, isPerPlayer as f5, isPerPlayerBoardRef as f6, isPlayerId as f7, isSharedBoardRef as f8, markManifestScopedSchema as f9, parseBoardRefKey as fa, perPlayer as fb, perPlayerBoardRef as fc, perPlayerEntries as fd, perPlayerGet as fe, perPlayerHas as ff, perPlayerKeys as fg, perPlayerMap as fh, perPlayerRequire as fi, perPlayerSchema as fj, perPlayerSet as fk, perPlayerSize as fl, perPlayerValues as fm, pipe as fn, resolveManifestPlayerIds as fo, sharedBoardRef as fp, type AnyInteractionSpec as g, type AnyPhaseDefinitionForContract as h, type AnyReducerGameDefinition as i, type AnySchema as j, type AutoPhaseDefinition as k, type BaseGameStateOfContract as l, type BoardBaseIdOfManifest as m, type BoardContainerIdOfManifest as n, type BoardContainerIdOfTable as o, type BoardIdOfManifest as p, type BoardIdOfTable as q, type BoardInputCollectorKind as r, type BoardInputCollectorMeta as s, type BoardInteractionKeyOfDefinition as t, type BoardLayoutOfManifest as u, type BoardMapOfTable as v, type BoardRef as w, type BoardStateOfTable as x, type BoardTargetDomainDescriptor as y, type BoardTypeIdOfManifest as z };