@dreamboard-games/sdk 0.4.0-alpha.4 → 0.4.0-alpha.6

package/dist/views-32rSsfeU.d.ts

@@ -0,0 +1,1559 @@
+import { bQ as RuntimeTableRecord, aE as PlayerIdOfState, az as PhaseStateOfState, aM as PublicStateOfState, a8 as HiddenStateOfState, aK as PrivateStateOfState, ci as SharedZoneIdOfTable, cE as TableOfState, F as DeckCardsOfTable, aF as PlayerIdOfTable, H as DeckIdOfTable, aI as PlayerZoneIdOfTable, u as CompatibleCardIdForTwoPlayerZones, t as CompatibleCardIdForHandAndDeck, v as CompatibleHandIdForDeck, Y as HandIdOfTable, p as CardIdOfTable, e as BoardIdOfTable, ck as SpaceIdOfTable, x as ComponentIdOfTable, c as BoardContainerIdOfTable, cH as TiledBoardIdOfTable, cJ as TiledEdgeIdOfTable, cP as TiledVertexIdOfTable, b5 as ResourceAmountsOfTable, ba as ResourceIdOfTable, cG as TableQueriesOfState, aQ as ReducerGameState, cD as TableOfManifest, ac as ManifestContractOf, aL as PublicSchemaOfContract, aJ as PrivateSchemaOfContract, a7 as HiddenSchemaOfContract, ay as PhaseStateMapOfContract, at as PhaseNameOfContract, bY as SchemaLike, cx as StateDefinition, a9 as InitContext, ah as ManifestOf, O as ExactManifestContractOf, ca as SetupProfileDefinition, aR as ReducerManifestContract, aV as ReducerSessionState, bF as RuntimeSetupSelection, bz as RuntimePhaseState, a as AnySchema, ab as ManifestContract, E as ContinuationToken, av as PhaseNameOfState, aU as ReducerRuntimeStateForState, ce as SetupSelectionOfManifest, aO as ReducerAcceptOptions, aN as ReducerAccept, U as GameOutcome, aS as ReducerReject, aP as ReducerFx, aT as ReducerResult, cB as StringKeyOf, A as AnyContinuationToken, aG as PlayerZoneIdOfManifest, q as CardTypeOfState, o as CardIdOfState } from './runtime-Dkfm1x2r.js';
+import { z } from 'zod';
+
+/**
+ * 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 {
+        state: infer PhaseStateSchema extends SchemaLike<object>;
+    } ? 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 {
+        state: infer PhaseStateSchema extends SchemaLike<object>;
+    } ? z.infer<PhaseStateSchema> : never;
+}[keyof Definitions & string];
+type ResolvedGameStateOf<Contract, Definitions extends PhaseMapOf<Contract>> = {
+    [Name in keyof Definitions & string]: ReducerGameState<TableOfManifest<ManifestContractOf<Contract>>, z.infer<PublicSchemaOfContract<Contract>>, z.infer<PrivateSchemaOfContract<Contract>>, z.infer<HiddenSchemaOfContract<Contract>>, Definitions[Name] extends {
+        state: infer PhaseStateSchema extends SchemaLike<object>;
+    } ? z.infer<PhaseStateSchema> : never, PhaseNameOfContract<Contract>> & {
+        flow: ReducerGameState<TableOfManifest<ManifestContractOf<Contract>>, z.infer<PublicSchemaOfContract<Contract>>, z.infer<PrivateSchemaOfContract<Contract>>, z.infer<HiddenSchemaOfContract<Contract>>, PhaseStateOfDefinitions<Definitions>, PhaseNameOfContract<Contract>>["flow"] & {
+            currentPhase: Name;
+        };
+    };
+}[keyof Definitions & string];
+type 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 {
+    project: (...args: never[]) => infer Projection;
+} ? Projection : never;
+type PhaseNamesOfDefinition<Definition> = keyof PhasesOfDefinition<Definition> & string;
+type PhaseDefinitionByName<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>> = PhaseName extends keyof PhasesOfDefinition<Definition> & string ? PhasesOfDefinition<Definition>[PhaseName] : never;
+type 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 {
+    contract: infer Contract extends ReducerGameContractLike;
+    phases: infer Definitions;
+} ? Definitions extends PhaseMapOf<Contract> ? ResolvedGameStateOf<Contract, Definitions> : never : Source extends ReducerGameContract<any, any, any, any, any, any, any> ? 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 CollectorsOfInteractionDefinition<Spec> = Spec extends {
+    readonly inputs?: infer Collectors;
+} ? NonNullable<Collectors> extends Record<string, InputCollector> ? NonNullable<Collectors> : Record<string, never> : Record<string, never>;
+type CollectorKindsOfInteractionDefinition<Spec> = (Spec extends {
+    readonly cardType: unknown;
+    readonly playFrom: unknown;
+} ? "card" : never) | CollectorKindsOf<CollectorsOfInteractionDefinition<Spec>>;
+type InputKeysWithCollectorKindOfInteractionDefinition<Spec, Kind extends string> = (Spec extends {
+    readonly cardType: unknown;
+    readonly playFrom: unknown;
+} ? Extract<"card", Kind> extends never ? never : "cardId" : never) | (CollectorKeysWithKind<CollectorsOfInteractionDefinition<Spec>, Kind> & string);
+type CardInputZoneIdsOfInteractionDefinition<Spec, Input extends string> = Input extends "cardId" ? Spec extends {
+    readonly playFrom: infer PlayFrom extends string;
+} ? PlayFrom : CollectorCardZoneIds<CollectorsOfInteractionDefinition<Spec>, Input> : CollectorCardZoneIds<CollectorsOfInteractionDefinition<Spec>, Input>;
+type ParamsOfCollectors<Collectors> = Collectors extends Record<string, InputCollector> ? {
+    [K in keyof Collectors]: Collectors[K] extends InputCollector<infer S> ? S extends SchemaLike<infer V> ? V : never : never;
+} : never;
+type ClientParamsOfCollectors<Collectors> = Collectors extends Record<string, InputCollector> ? {
+    [K in keyof Collectors as Collectors[K] extends {
+        readonly kind: "rng";
+    } ? never : K]: Collectors[K] extends InputCollector<infer S> ? S extends SchemaLike<infer V> ? V : never : never;
+} : never;
+type InteractionIdsWithCollectorKindOfDefinitionPhase<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>, Kind extends string> = {
+    [InteractionId in InteractionIdOfDefinitionPhase<Definition, PhaseName>]: InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends infer Spec ? Extract<CollectorKindsOfInteractionDefinition<Spec>, 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 infer Spec ? InputKeysWithCollectorKindOfInteractionDefinition<Spec, Kind> : never;
+type CardInputZoneIdsOfDefinition<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>, InteractionId extends InteractionIdOfDefinitionPhase<Definition, PhaseName>, Input extends string> = InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends infer Spec ? CardInputZoneIdsOfInteractionDefinition<Spec, Input> : never;
+type ParamsOfInteractionOfDefinition<Definition, PhaseName extends PhaseNamesOfDefinition<Definition>, InteractionId extends InteractionIdOfDefinitionPhase<Definition, PhaseName>> = InteractionSpecByNameOfDefinitionPhase<Definition, PhaseName, InteractionId> extends infer Spec ? Spec extends {
+    readonly cardType: unknown;
+    readonly playFrom: unknown;
+} ? {
+    cardId: string;
+} & ParamsOfCollectors<CollectorsOfInteractionDefinition<Spec>> : ParamsOfCollectors<CollectorsOfInteractionDefinition<Spec>> : 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 infer Spec ? Spec extends {
+    readonly cardType: unknown;
+    readonly playFrom: unknown;
+} ? {
+    cardId: string;
+} & ClientParamsOfCollectors<CollectorsOfInteractionDefinition<Spec>> : ClientParamsOfCollectors<CollectorsOfInteractionDefinition<Spec>> : never;
+type DefaultedClientCollectorKeys<Collectors extends Record<string, InputCollector>> = {
+    [K in keyof Collectors]: Collectors[K] extends {
+        readonly 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 infer Spec ? DefaultedClientCollectorKeys<CollectorsOfInteractionDefinition<Spec>> & string : 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, options?: ReducerAcceptOptions<State>): ReducerAccept<State>;
+    endGame(state: State, outcome: GameOutcome<PlayerIdOfState<State>>, options?: ReducerAcceptOptions<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 InteractionPresentation = {
+    label: string;
+    help?: string;
+};
+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>>;
+    presentation?: InteractionPresentation;
+    /** @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>>;
+    presentation?: InteractionPresentation;
+    /** @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 PhaseGuidance = {
+    summary: string;
+    objective?: string;
+};
+type PhaseDefinitionCommon<PhaseStateSchema extends SchemaLike<object>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+    phase: object;
+}, Manifest extends ManifestContract<TableOfState<State>>> = {
+    name?: string;
+    guidance?: PhaseGuidance;
+    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 InputDomainDependencyCase as $, type ActionContext as A, type BaseGameSessionOfContract as B, type CardActionMap as C, type ContinuationInput as D, type ContinuationInputForSource as E, type ContinuationKind as F, type ContinuationReduceArgs as G, type ContinuationSourceKind as H, type DefaultedClientParamKeysOfInteractionOfDefinition as I, type DerivedDefinition as J, type DerivedResolver as K, type EagerInputDomainDependencies as L, type EffectContinuationCallable as M, type EffectContinuationInput as N, type EffectContinuationResponse as O, type EffectDefinition as P, type EffectIdsOfDefinition as Q, type EffectMap as R, type EffectRegistryOfPhase as S, type EffectRollDieDefinition as T, type EffectShuffleDefinition as U, type EffectShufflePlayerZoneDefinition as V, type GameStateOf as W, type InitialStateCallbacks as X, type InputCollector as Y, type InputCollectorKind as Z, type InputCollectorMetaForKind as _, type ActorSelection as a, type SimultaneousSubmission as a$, type InputDomainDescriptor as a0, type InputDomainResolverDescriptor as a1, type InputKeysWithCollectorKindOfDefinition as a2, type InputSelectionDescriptor as a3, type InteractionAvailabilityArgs as a4, type InteractionCommitPolicy as a5, type InteractionIdOfDefinition as a6, type InteractionIdOfDefinitionPhase as a7, type InteractionKind as a8, type InteractionMap as a9, type PromptInputCollectorMeta as aA, type PromptInteractionKeyOfDefinition as aB, type RandomHelpers as aC, type ReducerEdit as aD, type ReducerGameContract as aE, type ReducerGameContractLike as aF, type ReducerGameDefinition as aG, type ReducerOps as aH, type ReducerSessionForConfig as aI, type ReducerStateBase as aJ, type ReducerStateForConfig as aK, type ReducerTransaction as aL, type ResolvedBoardTargetDomainDescriptor as aM, type ResolvedCardTargetDomainDescriptor as aN, type ResolvedGameSessionOf as aO, type ResolvedGameStateOf as aP, type ResourceMapDomainDescriptor as aQ, type ResumableEffectKind as aR, type RngInputCollectorMeta as aS, type RollDieContinuationResponse as aT, type RotatePlayerZoneArgs as aU, type RuntimeHelpers as aV, type ScopedPhaseState as aW, type ShufflePlayerZoneContinuationResponse as aX, type ShuffleSharedZoneContinuationResponse as aY, type SimultaneousPlayerPhaseDefinition as aZ, type SimultaneousResolveArgs as a_, type InteractionReduceArgs as aa, type InteractionReduceInput as ab, type InteractionRule as ac, type InteractionRuleValidationResult as ad, type InteractionSpec as ae, type InteractionSpecByNameOfDefinitionPhase as af, type InteractionToArgs as ag, type InteractionValidateArgs as ah, type LazyBoardTargetDomainDescriptor as ai, type LazyCardTargetDomainDescriptor as aj, type LazyInputDomainDependencies as ak, type MutationRuntimeHelpers as al, type Op as am, type ParamsOf as an, type ParamsOfInteractionOfDefinition as ao, type PhaseDefinition as ap, type PhaseDefinitionByName as aq, type PhaseEnterArgs as ar, type PhaseEnterContext as as, type PhaseMapOf as at, type PhaseNamesOfDefinition as au, type PhaseStateMapOfDefinitions as av, type PhaseStateOfDefinitions as aw, type PhaseZoneList as ax, type PlayableInteractionsOfZoneOfDefinition as ay, type PlayerPhaseDefinition as az, type ActorSelector as b, type SimultaneousSubmitSpec as b0, type StageMap as b1, type StageNamesOfDefinitionPhase as b2, type StageSpec as b3, type StaticViewDefinition as b4, type StaticViewQueries as b5, type TargetKind as b6, type ValidationIssue as b7, type ViewDefinition as b8, type ViewDefinitionByName as b9, type ViewMapOf as ba, type ViewNamesOfDefinition as bb, type ViewOfDefinition as bc, type ViewsOfDefinition as bd, type ZoneIdsOfDefinition as be, createDerivedResolver as bf, createReducerEdit as bg, createReducerOps as bh, createReducerTransaction as bi, defineDerived as bj, pipe as bk, type ActorSelectorArgs as c, type AnyCardActionSpec as d, type AnyContinuationCallable as e, type AnyInteractionSpec as f, type AnyPhaseDefinitionForContract as g, type AnyReducerGameDefinition as h, type AutoPhaseDefinition as i, type BaseGameStateOfContract as j, type BoardInputCollectorKind as k, type BoardInputCollectorMeta as l, type BoardInteractionKeyOfDefinition as m, type BoardTargetDomainDescriptor as n, type BoundedNumberDomainDescriptor as o, type CardActionSpec as p, type CardInputCollectorMeta as q, type CardInputZoneIdsOfDefinition as r, type CardInteractionKeyOfDefinition as s, type CardTargetDomainDescriptor as t, type ChoiceDomainDescriptor as u, type ChoiceListDomainDescriptor as v, type ClientParamsOf as w, type ClientParamsOfInteractionOfDefinition as x, type CollectorState as y, type ContinuationCallable as z };