@dreamboard-games/sdk 0.4.0-alpha.5 → 0.4.0-alpha.7

package/dist/runtime-Dkfm1x2r.d.ts

@@ -0,0 +1,1670 @@
+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;
+}
+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, SchemaLike<object>, SchemaLike<object>> ? PublicSchema : never;
+type PrivateSchemaOfContract<Contract> = StateDefinitionOfContract<Contract> extends StateDefinition<SchemaLike<object>, infer PrivateSchema, SchemaLike<object>> ? PrivateSchema : never;
+type HiddenSchemaOfContract<Contract> = StateDefinitionOfContract<Contract> extends StateDefinition<SchemaLike<object>, SchemaLike<object>, infer HiddenSchema> ? HiddenSchema : never;
+type PhaseNameOfContract<Contract> = keyof PhaseSchemasOfContract<Contract> extends string ? keyof PhaseSchemasOfContract<Contract> & string : PhaseNameOfManifest<ManifestOf<Contract>>;
+type ManifestContractOf<Contract> = ManifestContract<TableOfManifest<ManifestOf<Contract>>>;
+type ExactManifestContractOf<Contract> = ManifestOf<Contract> & 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;
+    guidance?: {
+        summary?: string | null;
+        steps: readonly {
+            id: string;
+            label: string;
+            description?: string | null;
+        }[];
+    } | 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<unknown, 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 OutcomeResult = "win" | "draw" | "loss" | "eliminated";
+type OutcomeScoreComponent = {
+    id: string;
+    label: string;
+    value: number;
+};
+type OutcomeTieBreak = {
+    id: string;
+    label: string;
+    value: number | string;
+};
+type OutcomeStanding<PlayerId extends string = string> = {
+    playerId: PlayerId;
+    rank: number;
+    result: OutcomeResult;
+    score?: number;
+    scoreBreakdown?: readonly OutcomeScoreComponent[];
+    tieBreaks?: readonly OutcomeTieBreak[];
+};
+type GameOutcome<PlayerId extends string = string> = {
+    reason: {
+        code: string;
+        message?: string;
+    };
+    standings: readonly OutcomeStanding<PlayerId>[];
+};
+type GameEventDetail = {
+    label: string;
+    value: string | number | boolean;
+};
+type SystemActionEvent = {
+    kind: "systemAction";
+    procedureId: string;
+    title: string;
+    summary?: string;
+    details?: readonly GameEventDetail[];
+};
+type GameEvent = SystemActionEvent;
+type ReducerAcceptOptions<State> = {
+    instructions?: readonly RuntimeInstructionForState<State>[];
+    events?: readonly GameEvent[];
+};
+type ReducerAccept<State> = {
+    type: "accept";
+    state: State;
+    instructions?: readonly RuntimeInstructionForState<State>[];
+    events?: readonly GameEvent[];
+    terminal?: GameOutcome<PlayerIdOfState<State>>;
+};
+type ReducerResult<State> = ReducerAccept<State> | ReducerReject;
+
+export { type HexEdgeIdOfTable as $, type AnyContinuationToken as A, type BoardBaseIdOfManifest as B, type CardIdOfDeck as C, type ContinuationResponseOf as D, type ContinuationToken as E, type DeckCardsOfTable as F, type DeckIdOfState as G, type DeckIdOfTable as H, type DieIdOfManifest as I, type EdgeTypeIdOfManifest as J, type EffectInvokeOptions as K, type EffectSpecLike as L, type EffectTypeTag as M, type ErrorCodeOfContract as N, type ExactManifestContractOf as O, type FlowState as P, type FrameworkErrorCode as Q, FrameworkErrorCodes as R, type GameEvent as S, type GameEventDetail as T, type GameOutcome as U, type GeneratedManifestContractLike as V, type HandCardsOfTable as W, type HandIdOfState as X, type HandIdOfTable as Y, type HexBoardIdOfTable as Z, type HexBoardStateOfTable as _, type AnySchema as a, type ResolvedEdgeLocation as a$, type HexEdgeStateOfTable as a0, type HexEdgeTypeIdOfTable as a1, type HexSpaceIdOfTable as a2, type HexSpaceTypeIdOfTable as a3, type HexVertexIdOfTable as a4, type HexVertexStateOfTable as a5, type HexVertexTypeIdOfTable as a6, type HiddenSchemaOfContract as a7, type HiddenStateOfState as a8, type InitContext as a9, type PhaseStepOfState as aA, type PieceIdOfManifest as aB, type PlayerId as aC, type PlayerIdOfManifest as aD, type PlayerIdOfState as aE, type PlayerIdOfTable as aF, type PlayerZoneIdOfManifest as aG, type PlayerZoneIdOfState as aH, type PlayerZoneIdOfTable as aI, type PrivateSchemaOfContract as aJ, type PrivateStateOfState as aK, type PublicSchemaOfContract as aL, type PublicStateOfState as aM, type ReducerAccept as aN, type ReducerAcceptOptions as aO, type ReducerFx as aP, type ReducerGameState as aQ, type ReducerManifestContract as aR, type ReducerReject as aS, type ReducerResult as aT, type ReducerRuntimeStateForState as aU, type ReducerSessionState as aV, type ReducerValidationResult as aW, type RelationTypeIdOfManifest as aX, type RelationTypeIdOfTable as aY, type ResolvedContainerLocation as aZ, type ResolvedDeckLocation as a_, type InitSetupSelectionInput as aa, type ManifestContract as ab, type ManifestContractOf as ac, type ManifestDefaults as ad, type ManifestIdSchema as ae, type ManifestIds as af, type ManifestLiterals as ag, type ManifestOf as ah, type NonEmptyReadonlyArray as ai, type OutcomeResult as aj, type OutcomeScoreComponent as ak, type OutcomeStanding as al, type OutcomeTieBreak as am, type PerPlayer as an, type PerPlayerBoardRef as ao, type PerPlayerSchemaOptions as ap, type PhaseAccessor as aq, type PhaseMapOfState as ar, type PhaseNameOf as as, type PhaseNameOfContract as at, type PhaseNameOfManifest as au, type PhaseNameOfState as av, type PhasePayload as aw, type PhaseSchemasOfContract as ax, type PhaseStateMapOfContract as ay, type PhaseStateOfState as az, type BoardContainerIdOfManifest as b, type SetupBootstrapPerPlayerBoardContainerRef as b$, type ResolvedHandLocation as b0, type ResolvedSlotLocation as b1, type ResolvedSpaceLocation as b2, type ResolvedVertexLocation as b3, type ResolvedZoneLocation as b4, type ResourceAmountsOfTable as b5, type ResourceBalancesOfState as b6, type ResourceBalancesOfTable as b7, type ResourceIdOfManifest as b8, type ResourceIdOfState as b9, type RuntimePieceData as bA, type RuntimeRecord as bB, type RuntimeResourceMap as bC, type RuntimeRngState as bD, type RuntimeScalar as bE, type RuntimeSetupSelection as bF, type RuntimeSetupSelectionInput as bG, type RuntimeSetupSelectionOverride as bH, type RuntimeSimultaneousState as bI, type RuntimeSimultaneousSubmission as bJ, type RuntimeSlotHostRef as bK, type RuntimeSquareBoardState as bL, type RuntimeSquareEdgeState as bM, type RuntimeSquareSpaceState as bN, type RuntimeSquareVertexState as bO, type RuntimeState as bP, type RuntimeTableRecord as bQ, type RuntimeTiledBoardBaseState as bR, type RuntimeTiledBoardState as bS, type RuntimeTiledEdgeState as bT, type RuntimeTiledSpaceState as bU, type RuntimeTiledVertexState as bV, type RuntimeVisibilityMap as bW, type RuntimeZoneMap as bX, type SchemaLike as bY, type SetupBootstrapContainerRef as bZ, type SetupBootstrapDestinationRef as b_, type ResourceIdOfTable as ba, type RuntimeBoardBaseState as bb, type RuntimeBoardCollections as bc, type RuntimeBoardCompatibilityState as bd, type RuntimeBoardContainerState as be, type RuntimeBoardRelationState as bf, type RuntimeBoardSpaceState as bg, type RuntimeBoardState as bh, type RuntimeCardData as bi, type RuntimeCardVisibility as bj, type RuntimeComponentLocation as bk, type RuntimeComponentLocationMap as bl, type RuntimeDeckMap as bm, type RuntimeDieData as bn, type RuntimeGenericBoardState as bo, type RuntimeHandMap as bp, type RuntimeHandVisibilityMode as bq, type RuntimeHexBoardState as br, type RuntimeHexEdgeState as bs, type RuntimeHexOrientation as bt, type RuntimeHexSpaceState as bu, type RuntimeHexVertexState as bv, type RuntimeOwnerMap as bw, type RuntimeParams as bx, type RuntimePayload as by, type RuntimePhaseState as bz, type BoardContainerIdOfTable as c, createManifestRuntimeSchema as c$, type SetupBootstrapPerPlayerBoardSpaceRef as c0, type SetupBootstrapPerPlayerContainerTemplateRef as c1, type SetupBootstrapPerPlayerZoneRef as c2, type SetupBootstrapSharedBoardContainerRef as c3, type SetupBootstrapSharedBoardSpaceRef as c4, type SetupBootstrapSharedZoneRef as c5, type SetupBootstrapStep as c6, type SetupOptionChoiceMetadata as c7, type SetupOptionIdOfManifest as c8, type SetupOptionMetadata as c9, type StaticBoardsJsonEnvelope as cA, type StringKeyOf as cB, type SystemActionEvent as cC, type TableOfManifest as cD, type TableOfState as cE, type TableQueries as cF, type TableQueriesOfState as cG, type TiledBoardIdOfTable as cH, type TiledBoardStateOfTable as cI, type TiledEdgeIdOfTable as cJ, type TiledEdgeMap as cK, type TiledEdgeStateOfTable as cL, type TiledEdgeTypeIdOfTable as cM, type TiledSpaceIdOfTable as cN, type TiledSpaceMap as cO, type TiledVertexIdOfTable as cP, type TiledVertexMap as cQ, type TiledVertexStateOfTable as cR, type TiledVertexTypeIdOfTable as cS, type VertexTypeIdOfManifest as cT, asPlayerId as cU, assumeManifestSchema as cV, boardRef as cW, boardRefKey as cX, boardRefSchema as cY, cloneManifestDefault as cZ, createManifestGameStateSchema as c_, type SetupProfileDefinition as ca, type SetupProfileIdOfManifest as cb, type SetupProfileMetadata as cc, type SetupSelectionInputOfManifest as cd, type SetupSelectionOfManifest as ce, type SharedBoardRef as cf, type SharedZoneIdOfManifest as cg, type SharedZoneIdOfState as ch, type SharedZoneIdOfTable as ci, type SpaceIdOfManifest as cj, type SpaceIdOfTable as ck, type SpaceTypeIdOfManifest as cl, type SpaceTypeIdOfTable as cm, type SquareBoardIdOfTable as cn, type SquareBoardStateOfTable as co, type SquareEdgeIdOfTable as cp, type SquareEdgeStateOfTable as cq, type SquareEdgeTypeIdOfTable as cr, type SquareSpaceIdOfTable as cs, type SquareSpaceTypeIdOfTable as ct, type SquareVertexIdOfTable as cu, type SquareVertexStateOfTable as cv, type SquareVertexTypeIdOfTable as cw, type StateDefinition as cx, type StateDefinitionOfContract as cy, type StaticBoards as cz, type BoardIdOfManifest as d, createManifestStringLiteralSchema as d0, isManifestScopedSchema as d1, isPerPlayer as d2, isPerPlayerBoardRef as d3, isPlayerId as d4, isSharedBoardRef as d5, markManifestScopedSchema as d6, parseBoardRefKey as d7, perPlayer as d8, perPlayerBoardRef as d9, perPlayerEntries as da, perPlayerGet as db, perPlayerHas as dc, perPlayerKeys as dd, perPlayerMap as de, perPlayerRequire as df, perPlayerSchema as dg, perPlayerSet as dh, perPlayerSize as di, perPlayerValues as dj, resolveManifestPlayerIds as dk, sharedBoardRef as dl, type BoardIdOfTable as e, type BoardLayoutOfManifest as f, type BoardMapOfTable as g, type BoardRef as h, type BoardStateOfTable as i, type BoardTypeIdOfManifest as j, type BoardTypeIdOfTable as k, type Brand as l, type CardIdOfHand as m, type CardIdOfManifest as n, type CardIdOfState as o, type CardIdOfTable as p, type CardTypeOfState as q, type CardTypeOfTable as r, type ChoiceOption as s, type CompatibleCardIdForHandAndDeck as t, type CompatibleCardIdForTwoPlayerZones as u, type CompatibleHandIdForDeck as v, type ComponentDataOfTable as w, type ComponentIdOfTable as x, type ComponentLocationByTypeOfTable as y, type ComponentLocationOfTable as z };