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

package/dist/shortcuts-B_RrufOM.d.ts

@@ -0,0 +1,822 @@
+import { Store } from '@tanstack/store';
+import { j as BoardSpaceTarget, bh as TopologyDefinitions, h as BoardIdOfTable, bb as TileSpaceId, aZ as SeatSpaceRef, b0 as SpaceIdOfTable, be as TiledBoardIdOfTable, bf as TiledEdgeIdOfTable, bg as TiledVertexIdOfTable, k as BoardStateOfTable, at as PositionTarget, a_ as SeatTileRef, aP as RuntimeJson, aX as SeatBoardTopology, a5 as InteractionInputDescriptor, U as InputDomain, aq as PhaseNamesOfDefinition, a4 as InteractionIdOfDefinitionPhase, s as ClientParamsOfInteractionOfDefinition, T as InputCollectorOfDefinition, bq as ViewOfDefinition, ay as ProjectedTile, aA as ReadonlyRuntimeData, l as BoardTopologyOf, P as HiddenCardId, bk as ViewCard, bl as ViewCardOfTable, I as GameEvent } from './extract-CwJWDrSD.js';
+import { g as SourceSnapshot, h as SourceState, i as SubmitResult, G as GameSource, I as InteractionDescriptor } from './types-BxXRINRF.js';
+import { z } from 'zod';
+
+type RuntimeBoardTarget = {
+    readonly valueKind: "board-id";
+    readonly kind: "space" | "edge" | "vertex";
+    readonly boardId: string;
+    readonly value: string;
+} | {
+    readonly valueKind: "board-space";
+    readonly kind: "space";
+    readonly value: BoardSpaceTarget;
+};
+type RuntimeSelectionTarget = RuntimeBoardTarget | {
+    readonly kind: "card";
+    readonly value: string;
+} | {
+    readonly kind: "tile";
+    readonly value: SeatTileRef;
+};
+type RuntimeTargetOptions = {
+    readonly interaction?: undefined;
+    readonly input?: never;
+} | {
+    readonly interaction: string;
+    readonly input?: string;
+};
+type RuntimeBoardDropTarget = RuntimeBoardTarget & {
+    readonly interactionKey: string;
+    readonly cardInputKey: string;
+    readonly inputKey: string;
+};
+interface RuntimeInteractionDropTarget {
+    readonly kind: "interaction";
+    readonly interactionKey: string;
+    readonly cardInputKey: string;
+    readonly params?: Readonly<Record<string, RuntimeJson>>;
+}
+/** An insertion point in a zone for an interaction with a position input. */
+interface RuntimePositionDropTarget {
+    readonly kind: "position";
+    readonly interactionKey: string;
+    readonly cardInputKey: string;
+    readonly inputKey: string;
+    readonly value: PositionTarget;
+}
+type RuntimeDropTarget = RuntimeBoardDropTarget | RuntimeInteractionDropTarget | RuntimePositionDropTarget;
+type SeatSpaceValue<Id> = Id extends TileSpaceId ? SeatSpaceRef : Id;
+type TargetOnBoard<Table, B extends BoardIdOfTable<Table>, Definitions extends TopologyDefinitions> = ({
+    readonly valueKind: "board-id";
+    readonly boardId: B;
+} & ({
+    readonly kind: "space";
+    readonly value: SeatSpaceValue<SpaceIdOfTable<Table, B, Definitions>>;
+} | (B extends TiledBoardIdOfTable<Table, Definitions> ? {
+    readonly kind: "edge";
+    readonly value: TiledEdgeIdOfTable<Table, B, Definitions>;
+} | {
+    readonly kind: "vertex";
+    readonly value: TiledVertexIdOfTable<Table, B, Definitions>;
+} : never))) | (BoardStateOfTable<Table, B, Definitions> extends {
+    scope: "perPlayer";
+    baseId: string;
+} ? {
+    readonly valueKind: "board-space";
+    readonly kind: "space";
+    readonly value: BoardSpaceTarget<B, SeatSpaceValue<SpaceIdOfTable<Table, B, Definitions>>>;
+} : never);
+/** One target identity; board-space targets already contain their board identity. */
+type BoardTarget<G> = [TableOfGame<G>] extends [never] ? RuntimeBoardTarget : G extends {
+    contract: {
+        manifest: infer Definitions extends TopologyDefinitions;
+    };
+} ? {
+    [B in BoardIdOfTable<TableOfGame<G>>]: TargetOnBoard<TableOfGame<G>, B, Definitions>;
+}[BoardIdOfTable<TableOfGame<G>>] : never;
+type SelectionTarget<G> = BoardTarget<G> | {
+    readonly kind: "card";
+    readonly value: SeatCardId<G>;
+} | {
+    readonly kind: "tile";
+    readonly value: SeatTileRef;
+};
+/** Input disambiguation belongs to a particular interaction. */
+type TargetOptions<G> = {
+    readonly interaction?: undefined;
+    readonly input?: never;
+} | {
+    [K in InteractionKey<G>]: {
+        readonly interaction: K;
+        readonly input?: InputKey<G, K>;
+    };
+}[InteractionKey<G>];
+type KeysOfKind<G, K extends InteractionKey<G>, Kind extends string> = unknown extends G ? string : {
+    [N in InputKey<G, K>]: InputKind<G, K, N> extends Kind ? N : never;
+}[InputKey<G, K>];
+/** A resolved atomic card/drop route retains both input identities. */
+type BoardDropTarget<G> = BoardTarget<G> & {
+    [K in InteractionKey<G>]: {
+        readonly interactionKey: K;
+        readonly cardInputKey: KeysOfKind<G, K, "card">;
+        readonly inputKey: KeysOfKind<G, K, "board-space" | "board-edge" | "board-vertex">;
+    };
+}[InteractionKey<G>];
+type DropAreaParams<G, K extends InteractionKey<G>> = Partial<InteractionParams<G, K>> & (unknown extends G ? Record<never, never> : {
+    readonly [N in KeysOfKind<G, K, "card">]?: never;
+});
+/** An area that runs an interaction without a board input on the dropped card. */
+type InteractionDropTarget<G> = {
+    [K in InteractionKey<G>]: [KeysOfKind<G, K, "card">] extends [never] ? never : {
+        readonly kind: "interaction";
+        readonly interactionKey: K;
+        readonly cardInputKey: KeysOfKind<G, K, "card">;
+        readonly params?: DropAreaParams<G, K>;
+    };
+}[InteractionKey<G>];
+type PositionValue<G, K extends InteractionKey<G>> = unknown extends G ? PositionTarget : {
+    [N in InputKey<G, K>]: InputKind<G, K, N> extends "position" ? InputTarget<G, K, N> : never;
+}[InputKey<G, K>];
+/** A dragged card's insertion point in a zone, as a position input takes it. */
+type PositionDropTarget<G> = {
+    [K in InteractionKey<G>]: [KeysOfKind<G, K, "position">] extends [never] ? never : {
+        readonly kind: "position";
+        readonly interactionKey: K;
+        readonly cardInputKey: KeysOfKind<G, K, "card">;
+        readonly inputKey: KeysOfKind<G, K, "position">;
+        readonly value: PositionValue<G, K>;
+    };
+}[InteractionKey<G>];
+type DropTarget<G> = BoardDropTarget<G> | InteractionDropTarget<G> | PositionDropTarget<G>;
+/**
+ * Bound inputs accompany the dropped card in one interaction draft. A
+ * `position` instead names the insertion point the area offers now.
+ */
+type DropAreaBinding<G> = {
+    [K in InteractionKey<G>]: {
+        readonly interaction: K;
+        readonly input?: KeysOfKind<G, K, "card">;
+        readonly params?: DropAreaParams<G, K>;
+        readonly position?: never;
+    } | ([KeysOfKind<G, K, "position">] extends [never] ? never : {
+        readonly interaction: K;
+        readonly input?: KeysOfKind<G, K, "card">;
+        readonly params?: never;
+        readonly position: PositionValue<G, K>;
+    });
+}[InteractionKey<G>];
+
+/** Internal operations over admitted projections; never a game facade widened to unknown. */
+declare const runtimeFeatures: unique symbol;
+interface RuntimeInput {
+    readonly key: string;
+    readonly kind: InteractionInputDescriptor["kind"];
+    getDomain(): InputDomain;
+    getIsEligible(value: RuntimeJson): boolean;
+    getIsSelected(value: RuntimeJson): boolean;
+    getTargetProps(value: RuntimeJson): ActionProps;
+}
+interface RuntimeInteraction {
+    readonly key: string;
+    getIsAvailable(params?: Readonly<Record<string, RuntimeJson>>): boolean;
+    getIsReady(params?: Readonly<Record<string, RuntimeJson>>): boolean;
+    getStatus(): "open" | "submitting" | "submitted";
+    submit(params?: Readonly<Record<string, RuntimeJson>>): Promise<SubmitResult>;
+    getInputs(): readonly RuntimeInput[];
+}
+interface RuntimeFeatureSnapshot {
+    readonly view: unknown;
+    readonly snapshot: SourceSnapshot | null;
+    readonly connection: SourceState["connection"];
+    readonly request: SourceState["request"];
+    readonly interactions: {
+        list(): readonly RuntimeInteraction[];
+    };
+    readonly zones: {
+        find(id: string, hostId: string): {
+            readonly count: number;
+        } | undefined;
+    };
+    readonly cards: {
+        find(id: string): {
+            readonly zone: string;
+            readonly hostId: string;
+            getInteractions(): readonly RuntimeInteraction[];
+        } | undefined;
+    };
+}
+interface RuntimeFeatureGame extends RuntimeFeatureSnapshot {
+    getSnapshot(): RuntimeFeatureSnapshot;
+    getOptions(): {
+        readonly source: GameSource;
+    };
+    subscribe(listener: () => void): () => void;
+}
+interface RuntimeBoard {
+    readonly id: string;
+    readonly data: SeatBoardTopology;
+    readonly game: RuntimeFeatureGame;
+}
+interface RuntimeFeatureContext {
+    readonly game: RuntimeFeatureGame;
+    getBoards(): Readonly<Record<string, SeatBoardTopology>>;
+    createBoard(data: SeatBoardTopology): RuntimeBoard;
+    routeTarget(target: RuntimeSelectionTarget, options?: RuntimeTargetOptions): void;
+    getCanDropCard(cardId: string, target: RuntimeDropTarget): boolean;
+    routeCardDrop(cardId: string, target: RuntimeDropTarget): void;
+    getCanDropCardGroup(cardIds: readonly string[], target: RuntimeDropTarget): boolean;
+    routeCardGroupDrop(cardIds: readonly string[], target: RuntimeDropTarget): void;
+    invalidate(): void;
+}
+
+type Domain<Type extends InputDomain["type"]> = Extract<InputDomain, {
+    type: Type;
+}>;
+type Editable<Value> = {
+    readonly value: Value;
+    readonly setValue: (value: Value) => void;
+};
+type Control<Type extends "boundedNumber" | "resourceMap", Value> = {
+    readonly type: Type;
+    readonly domain: Domain<Type>;
+} & (({
+    readonly mode: "single";
+} & Editable<Value | undefined>) | ({
+    readonly mode: "many";
+} & Editable<Value[]>));
+interface InputTargetOption<Value = RuntimeJson> {
+    readonly value: Value;
+    readonly label: string;
+    readonly selected: boolean;
+    readonly props: ActionProps;
+}
+/** A captured, descriptor-driven editor. Its handlers retain the input's lifetime. */
+type InputControl = {
+    readonly key: string;
+    readonly disabled: boolean;
+    readonly props: {
+        readonly disabled: boolean;
+        readonly [key: `data-${string}`]: string | number | boolean | undefined;
+    };
+} & (Control<"boundedNumber", number> | Control<"resourceMap", Record<string, number>> | {
+    readonly type: "targets";
+    readonly options: readonly InputTargetOption[];
+});
+
+type PhaseName<G> = [PhaseNamesOfDefinition<G>] extends [never] ? string : PhaseNamesOfDefinition<G>;
+type InteractionKey<G> = unknown extends G ? string : [PhaseNamesOfDefinition<G>] extends [never] ? string : {
+    [P in PhaseNamesOfDefinition<G>]: `${P}.${InteractionIdOfDefinitionPhase<G, P>}`;
+}[PhaseNamesOfDefinition<G>];
+type InteractionIdentity<G, K> = {
+    [P in PhaseNamesOfDefinition<G>]: {
+        [I in InteractionIdOfDefinitionPhase<G, P>]: `${P}.${I}` extends K ? {
+            phase: P;
+            id: I;
+        } : never;
+    }[InteractionIdOfDefinitionPhase<G, P>];
+}[PhaseNamesOfDefinition<G>];
+type RawInteractionParams<G, K extends InteractionKey<G>> = unknown extends G ? Record<string, RuntimeJson> : [PhaseNamesOfDefinition<G>] extends [never] ? Record<string, RuntimeJson> : InteractionIdentity<G, K> extends infer Identity ? Identity extends {
+    phase: infer P extends PhaseNamesOfDefinition<G>;
+    id: infer I;
+} ? I extends InteractionIdOfDefinitionPhase<G, P> ? ClientParamsOfInteractionOfDefinition<G, P, I> : never : never : never;
+type UnionKeys<T> = T extends unknown ? keyof T : never;
+type UnionValue<T, Key> = T extends unknown ? Key extends keyof T ? T[Key] : never : never;
+type InteractionParams<G, K extends InteractionKey<G>> = {
+    [N in UnionKeys<RawInteractionParams<G, K>>]: UnionValue<RawInteractionParams<G, K>, N>;
+};
+type CollectorOf<G, K, N extends string> = InteractionIdentity<G, K> extends infer Identity ? Identity extends {
+    phase: infer P extends PhaseNamesOfDefinition<G>;
+    id: infer I;
+} ? I extends InteractionIdOfDefinitionPhase<G, P> ? InputCollectorOfDefinition<G, P, I, N> : never : never : never;
+type InputKind<G, K extends InteractionKey<G>, N extends InputKey<G, K>> = [CollectorOf<G, K, N>] extends [never] ? InteractionInputDescriptor["kind"] : CollectorOf<G, K, N> extends {
+    readonly kind: infer Kind extends InteractionInputDescriptor["kind"];
+} ? Kind : InteractionInputDescriptor["kind"];
+type SelectionValue<Collector, Value> = Collector extends {
+    readonly selection: {
+        readonly mode: "many";
+    };
+} | {
+    readonly domain: (...args: never[]) => {
+        readonly type: "choiceList";
+    };
+} ? Value extends readonly (infer Item)[] ? Item : never : Value;
+type InputTarget<G, K extends InteractionKey<G>, N extends InputKey<G, K>> = [CollectorOf<G, K, N>] extends [never] ? Exclude<InteractionParams<G, K>[N], undefined> : SelectionValue<CollectorOf<G, K, N>, Exclude<InteractionParams<G, K>[N], undefined>>;
+type AnyInput<G, F extends Features, K extends InteractionKey<G>> = {
+    [N in InputKey<G, K>]: Input<G, F, K, N>;
+}[InputKey<G, K>];
+type AnyInteraction<G, F extends Features = Record<never, never>> = {
+    [K in InteractionKey<G>]: Interaction<G, F, K>;
+}[InteractionKey<G>];
+type InputKey<G, K extends InteractionKey<G>> = keyof InteractionParams<G, K> & string;
+type IdOf<G, K extends string> = G extends {
+    contract: {
+        manifest: {
+            ids: Record<K, infer Schema extends z.ZodType>;
+        };
+    };
+} ? z.output<Schema> & string : string;
+type ViewOf<G> = [ViewOfDefinition<G>] extends [never] ? unknown : ViewOfDefinition<G>;
+type Drafts<G> = Readonly<Partial<{
+    [K in InteractionKey<G>]: Readonly<Partial<InteractionParams<G, K>>>;
+}>>;
+interface LocalState<G> {
+    readonly drafts: Drafts<G>;
+    readonly activeInteraction: InteractionKey<G> | null;
+}
+interface Feature {
+    readonly root?: object;
+    readonly interaction?: object;
+    readonly input?: object;
+    readonly zone?: object;
+    readonly card?: object;
+    readonly board?: object;
+    readonly dispose?: () => void;
+}
+type Features = Readonly<Record<string, Feature>>;
+type Intersection<U> = (U extends unknown ? (value: U) => void : never) extends (value: infer I) => void ? I : never;
+type Hook<F extends Features, H extends keyof Feature> = keyof F extends never ? Record<never, never> : Intersection<{
+    [K in keyof F]: F[K] extends Record<H, infer A> ? A : Record<never, never>;
+}[keyof F]>;
+type TableOfGame<G> = G extends {
+    contract: {
+        manifest: {
+            tableSchema: infer Schema extends z.ZodType;
+        };
+    };
+} ? z.output<Schema> : never;
+/** Actual host identity admitted for one zone's attachment. */
+type ZoneHostId<G, K extends IdOf<G, "zoneId"> = IdOf<G, "zoneId">> = [
+    TableOfGame<G>
+] extends [never] ? string : TableOfGame<G> extends {
+    zones: infer Zones;
+} ? K extends keyof Zones ? Extract<keyof Zones[K], string> : never : never;
+type SeatCell<Cell> = Cell extends {
+    readonly id: string;
+    readonly tileId: string;
+} ? Omit<Cell, "id" | "tileId"> & {
+    readonly id: SeatSpaceRef;
+    readonly tileRef: SeatTileRef;
+} : Cell;
+type SeatRelation<Relation> = Relation extends {
+    readonly fromSpaceId: string;
+    readonly toSpaceId: string;
+} ? Omit<Relation, "fromSpaceId" | "toSpaceId"> & {
+    readonly fromSpaceId: SeatSpaceRef;
+    readonly toSpaceId: SeatSpaceRef;
+} : Relation;
+type SeatElement<Element> = Element extends {
+    readonly spaceIds: readonly string[];
+} ? Omit<Element, "spaceIds"> & {
+    readonly spaceIds: readonly SeatSpaceRef[];
+} : Element;
+type TileDefinitionsOf<G> = G extends {
+    contract: {
+        manifest: {
+            tileDefinitions: infer Definitions;
+        };
+    };
+} ? Definitions : never;
+type VisibleTileData<G, Runtime> = Runtime extends {
+    readonly tileTypeId: infer Type extends string;
+    readonly properties: infer Properties;
+} ? Type extends keyof TileDefinitionsOf<G> ? TileDefinitionsOf<G>[Type] extends {
+    readonly fields: infer Fields;
+} ? Omit<Extract<ProjectedTile, {
+    disclosure: "visible";
+}>, "tileTypeId" | "properties" | "fields"> & {
+    readonly tileTypeId: Type;
+    readonly properties: ReadonlyData<Properties>;
+    readonly fields: ReadonlyData<Fields>;
+} : never : never : never;
+/** The seat DTO is canonical; known games refine only disclosed authored face data. */
+type TileDataOf<G> = [TableOfGame<G>] extends [never] ? ProjectedTile : Extract<ProjectedTile, {
+    disclosure: "concealed";
+}> | (TableOfGame<G> extends {
+    readonly tiles: infer Tiles;
+} ? VisibleTileData<G, Tiles[keyof Tiles]> : never);
+type PlacedTileDataOf<G> = TileDataOf<G> & {
+    readonly placement: Extract<SeatBoardTopology, {
+        layout: "hex" | "square";
+    }>["tiles"][number]["placement"];
+};
+type SeatTopology<Topology, G> = Topology extends {
+    readonly layout: "hex" | "square";
+    readonly spaces: infer Spaces;
+    readonly relations: readonly (infer Relation)[];
+    readonly edges: readonly (infer Edge)[];
+    readonly vertices: readonly (infer Vertex)[];
+} ? Omit<Topology, "spaces" | "relations" | "edges" | "vertices"> & {
+    readonly spaces: Readonly<Record<SeatSpaceRef, SeatCell<Spaces[keyof Spaces]>>>;
+    readonly tiles: readonly PlacedTileDataOf<G>[];
+    readonly relations: readonly SeatRelation<Relation>[];
+    readonly edges: readonly SeatElement<Edge>[];
+    readonly vertices: readonly SeatElement<Vertex>[];
+} : Topology;
+type BoardDataOf<G, K extends string> = [TableOfGame<G>] extends [never] ? SeatBoardTopology : G extends {
+    contract: {
+        manifest: infer Definitions extends TopologyDefinitions;
+    };
+} ? TableOfGame<G> extends {
+    boards: infer Boards;
+} ? K extends Extract<keyof Boards, string> ? SeatTopology<BoardTopologyOf<TableOfGame<G>, Definitions, K>, G> : never : never : never;
+type BoardSpaceId<G, B extends IdOf<G, "boardId">> = B extends unknown ? BoardDataOf<G, B> extends {
+    readonly spaces: infer Spaces;
+} ? keyof Spaces & string : never : never;
+type BoardSpaceData<G, B extends IdOf<G, "boardId">, S extends BoardSpaceId<G, B>> = B extends unknown ? BoardDataOf<G, B> extends {
+    readonly spaces: infer Spaces;
+} ? S extends keyof Spaces ? Spaces[S] & {
+    readonly id: S;
+} : never : never : never;
+interface BoardSpace<G, F extends Features = Record<never, never>, B extends IdOf<G, "boardId"> = IdOf<G, "boardId">, S extends BoardSpaceId<G, B> = BoardSpaceId<G, B>> {
+    readonly id: S;
+    readonly data: BoardSpaceData<G, B, S>;
+    readonly board: Board<G, F, B>;
+    getIsEligible(): boolean;
+    getIsSelectable(): boolean;
+    getIsSelected(): boolean;
+    getSelectHandler(options?: TargetOptions<G>): () => void;
+    getTargetProps(options?: TargetOptions<G>): ActionProps;
+}
+interface BoardSpaceCollection<G, F extends Features = Record<never, never>, B extends IdOf<G, "boardId"> = IdOf<G, "boardId">> {
+    get<S extends BoardSpaceId<G, B>>(id: S): BoardSpace<G, F, B, S>;
+    find<S extends BoardSpaceId<G, B>>(id: S): BoardSpace<G, F, B, S> | undefined;
+    getAll(): readonly BoardSpace<G, F, B>[];
+}
+type BoardHooks<G, F extends Features, B extends IdOf<G, "boardId">> = {
+    [K in keyof Hook<F, "board">]: Hook<F, "board">[K] extends BoardSpaceCollection<G> ? BoardSpaceCollection<G, F, B> : Hook<F, "board">[K];
+};
+interface BoardBase<G, K extends IdOf<G, "boardId"> = IdOf<G, "boardId">> {
+    readonly id: K;
+    readonly game: CoreInstance<G>;
+    readonly data: BoardDataOf<G, K>;
+}
+type Board<G, F extends Features, K extends IdOf<G, "boardId"> = IdOf<G, "boardId">> = BoardBase<G, K> & BoardHooks<G, F, K> & {
+    readonly game: GameInstance<G, F>;
+};
+interface BoardCollection<G, F extends Features = Record<never, never>> {
+    get<K extends IdOf<G, "boardId">>(id: K): Board<G, F, K>;
+    find<K extends IdOf<G, "boardId">>(id: K): Board<G, F, K> | undefined;
+    getAll(): readonly Board<G, F>[];
+}
+type RootHooks<G, F extends Features> = {
+    [K in keyof Hook<F, "root">]: Hook<F, "root">[K] extends BoardCollection<G> ? BoardCollection<G, F> : Hook<F, "root">[K];
+};
+interface FeatureContext<G> {
+    readonly [runtimeFeatures]: RuntimeFeatureContext;
+    createBoard<K extends IdOf<G, "boardId">>(data: BoardDataOf<G, K> & {
+        readonly id: K;
+    }): BoardBase<G, K>;
+    routeTarget(target: SelectionTarget<G>, options?: TargetOptions<G>): void;
+    routeCardDrop(cardId: SeatCardId<G>, target: DropTarget<G>): void;
+    invalidate(): void;
+}
+interface NativeEvent {
+    preventDefault(): void;
+}
+type ActionProps = {
+    readonly onClick: (event?: NativeEvent) => void;
+    readonly disabled: boolean;
+    readonly type: "button";
+    readonly [key: `data-${string}`]: string | number | boolean | undefined;
+};
+interface Player<G, K extends IdOf<G, "playerId"> = IdOf<G, "playerId">> {
+    readonly id: K;
+    readonly index: number;
+    readonly name: string;
+    readonly color?: string;
+    readonly isMe: boolean;
+    readonly game: CoreInstance<G>;
+}
+interface Phase<G> {
+    readonly current: PhaseName<G> | null;
+    is(name: PhaseName<G>): boolean;
+    switch<R>(routes: {
+        [P in PhaseName<G>]: () => R;
+    }): R | null;
+}
+interface Turn<G> {
+    readonly activePlayerIds: readonly IdOf<G, "playerId">[];
+    readonly currentPlayerId: IdOf<G, "playerId"> | null;
+    readonly order: readonly IdOf<G, "playerId">[];
+    readonly isMine: boolean;
+}
+type DomainOfCollector<Collector> = Collector extends {
+    readonly domain: (...args: never[]) => infer Domain extends InputDomain;
+} ? Domain : InputDomain;
+type InputDomainOf<G, K extends InteractionKey<G>, N extends InputKey<G, K>> = [CollectorOf<G, K, N>] extends [never] ? InputDomain : DomainOfCollector<CollectorOf<G, K, N>>;
+type SelectionModeOfCollector<Collector> = Collector extends {
+    readonly selection: {
+        readonly mode: "many";
+    };
+} | {
+    readonly domain: (...args: never[]) => {
+        readonly type: "choiceList";
+    };
+} ? "many" : "single";
+type InputSelectionMode<G, K extends InteractionKey<G>, N extends InputKey<G, K>> = [CollectorOf<G, K, N>] extends [never] ? "single" | "many" : SelectionModeOfCollector<CollectorOf<G, K, N>>;
+interface InputBase<G, K extends InteractionKey<G>, N extends InputKey<G, K>> {
+    readonly key: N;
+    readonly kind: InputKind<G, K, N>;
+    readonly game: CoreInstance<G>;
+    readonly interaction: InteractionBase<G, K>;
+    readonly domainType: InputDomainOf<G, K, N>["type"];
+    readonly selectionMode: InputSelectionMode<G, K, N>;
+    getDomain(): InputDomainOf<G, K, N>;
+    getControl(): InputControl;
+    getTargetOptions(): readonly InputTargetOption<InputTarget<G, K, N>>[];
+    getValue(): InteractionParams<G, K>[N] | undefined;
+    readonly setValue: (value: Exclude<InteractionParams<G, K>[N], undefined>) => void;
+    clear(): void;
+    getIsReady(): boolean;
+    getEligibleTargets(): readonly InputTarget<G, K, N>[];
+    readonly getIsEligible: (value: InputTarget<G, K, N>) => boolean;
+    readonly getIsSelected: (value: InputTarget<G, K, N>) => boolean;
+    readonly getSelectHandler: (value: InputTarget<G, K, N>) => () => void;
+    readonly getTargetProps: (value: InputTarget<G, K, N>) => ActionProps;
+}
+type Input<G, F extends Features, K extends InteractionKey<G>, N extends InputKey<G, K>> = Omit<InputBase<G, K, N>, "interaction" | "game"> & Hook<F, "input"> & {
+    readonly game: GameInstance<G, F>;
+    readonly interaction: Interaction<G, F, K>;
+};
+interface InteractionBase<G, K extends InteractionKey<G>> {
+    readonly key: K;
+    readonly id: [InteractionIdentity<G, K>] extends [never] ? string : InteractionIdentity<G, K>["id"];
+    readonly phase: [InteractionIdentity<G, K>] extends [never] ? PhaseName<G> : InteractionIdentity<G, K>["phase"];
+    readonly label: string;
+    readonly help?: string;
+    readonly kind: "inputs" | "steps";
+    readonly game: CoreInstance<G>;
+    getAvailability(): InteractionDescriptor["availability"];
+    getIsAvailable(params?: InteractionParams<G, K>): boolean;
+    getUnavailableReason(): string | null;
+    getStep(): InteractionDescriptor["step"] | null;
+    getStepIndex(): number | null;
+    getIsReady(params?: InteractionParams<G, K>): boolean;
+    getMissingInputs(): readonly InputKey<G, K>[];
+    getStatus(): "open" | "submitting" | "submitted";
+    submit(params?: InteractionParams<G, K>): Promise<SubmitResult>;
+    cancel(): Promise<SubmitResult>;
+    reset(): void;
+    activate(): void;
+    getSubmitHandler(params?: InteractionParams<G, K>): (event?: NativeEvent) => void;
+    getSubmitProps(params?: InteractionParams<G, K>): ActionProps;
+}
+type Interaction<G, F extends Features, K extends InteractionKey<G>> = InteractionBase<G, K> & Hook<F, "interaction"> & {
+    readonly game: GameInstance<G, F>;
+    getInput<N extends InputKey<G, K>>(key: N): Input<G, F, K, N>;
+    findInput<N extends InputKey<G, K>>(key: N): Input<G, F, K, N> | undefined;
+    getInputs(): readonly AnyInput<G, F, K>[];
+};
+type ReadonlyData<T> = ReadonlyRuntimeData<T>;
+type CardDataOf<G, K extends string> = [TableOfGame<G>] extends [never] ? ReadonlyData<ViewCard<K>> : TableOfGame<G> extends {
+    cards: Record<string, {
+        cardType: string;
+        properties: Record<string, unknown>;
+    }>;
+} ? K extends keyof TableOfGame<G>["cards"] ? ReadonlyData<ViewCardOfTable<TableOfGame<G>, K>> : never : never;
+interface CardEntity<G> {
+    readonly zone: IdOf<G, "zoneId">;
+    readonly hostId: ZoneHostId<G>;
+    readonly index: number;
+    readonly game: CoreInstance<G>;
+    getInteractions(): readonly AnyInteraction<G>[];
+    getIsEligible(): boolean;
+    getIsSelected(): boolean;
+    getCanSelect(options?: TargetOptions<G>): boolean;
+    select(options?: TargetOptions<G>): void;
+    getSelectHandler(options?: TargetOptions<G>): () => void;
+    getProps(options?: TargetOptions<G>): ActionProps;
+}
+/** The id a seat knows a card by. */
+type SeatCardId<G> = IdOf<G, "cardId"> | HiddenCardId;
+type HiddenCard<K extends HiddenCardId> = {
+    readonly hidden: true;
+    readonly id: K;
+    readonly view: null;
+    /** The URL of the card's back image, when it has one. */
+    readonly backImage: string | null;
+};
+/** A hidden id is hidden; any other id is visible, or either when it is `string`. */
+type CardVisibility<G, K extends string> = K extends HiddenCardId ? HiddenCard<K> : (HiddenCardId extends K ? HiddenCard<HiddenCardId> : never) | {
+    readonly hidden: false;
+    readonly id: K;
+    readonly view: CardDataOf<G, K>;
+};
+type CardBase<G, K extends SeatCardId<G> = SeatCardId<G>> = CardEntity<G> & CardVisibility<G, K>;
+type Card<G, F extends Features, K extends SeatCardId<G> = SeatCardId<G>> = Omit<CardEntity<G>, "getInteractions" | "game"> & CardVisibility<G, K> & Hook<F, "card"> & {
+    readonly game: GameInstance<G, F>;
+    getInteractions(): readonly AnyInteraction<G, F>[];
+};
+/** One tile presentation admitted for this seat; its reference expires with its frame. */
+interface Tile<G, F extends Features = Record<never, never>> {
+    readonly ref: SeatTileRef;
+    readonly data: TileDataOf<G>;
+    readonly zone: IdOf<G, "zoneId">;
+    readonly hostId: ZoneHostId<G>;
+    readonly index: number;
+    readonly game: GameInstance<G, F>;
+    getInteractions(): readonly AnyInteraction<G, F>[];
+    getIsEligible(): boolean;
+    getIsSelected(): boolean;
+    getCanSelect(options?: TargetOptions<G>): boolean;
+    select(options?: TargetOptions<G>): void;
+    getSelectHandler(options?: TargetOptions<G>): () => void;
+    getTargetProps(options?: TargetOptions<G>): ActionProps;
+}
+interface ZoneBase<G, K extends IdOf<G, "zoneId"> = IdOf<G, "zoneId">> {
+    readonly id: K;
+    readonly hostId: ZoneHostId<G, K>;
+    /** Number of projected cards and tiles; omitted inventory contributes nothing. */
+    readonly count: number;
+    readonly game: CoreInstance<G>;
+    getIsEmpty(): boolean;
+}
+type Zone<G, F extends Features, K extends IdOf<G, "zoneId"> = IdOf<G, "zoneId">> = ZoneBase<G, K> & Hook<F, "zone"> & {
+    readonly game: GameInstance<G, F>;
+    getCards(options?: {
+        sort?: (a: Card<G, F>, b: Card<G, F>) => number;
+    }): readonly Card<G, F>[];
+    getTiles(): readonly Tile<G, F>[];
+    getTile(ref: SeatTileRef): Tile<G, F>;
+    findTile(ref: SeatTileRef): Tile<G, F> | undefined;
+    getCard<K extends SeatCardId<G>>(id: K): Card<G, F, K>;
+    findCard<K extends SeatCardId<G>>(id: K): Card<G, F, K> | undefined;
+};
+interface ReadModel<G, F extends Features = Record<never, never>> {
+    readonly snapshot: SourceSnapshot | null;
+    readonly view: ViewOf<G> | null;
+    readonly version: number | null;
+    readonly connection: SourceState["connection"];
+    readonly failure: SourceState["failure"];
+    readonly request: SourceState["request"];
+    readonly state: LocalState<G>;
+    readonly phase: Phase<G>;
+    readonly turn: Turn<G>;
+    readonly me: {
+        readonly id: IdOf<G, "playerId">;
+        readonly player: Player<G>;
+        getCanAct(): boolean;
+    } | null;
+    readonly players: {
+        get<K extends IdOf<G, "playerId">>(id: K): Player<G, K>;
+        find<K extends IdOf<G, "playerId">>(id: K): Player<G, K> | undefined;
+        getAll(): readonly Player<G>[];
+        next(id: IdOf<G, "playerId">): Player<G>;
+        readonly order: readonly IdOf<G, "playerId">[];
+    };
+    readonly interactions: {
+        get<K extends InteractionKey<G>>(key: K): Interaction<G, F, K>;
+        find<K extends InteractionKey<G>>(key: K): Interaction<G, F, K> | undefined;
+        list(): readonly AnyInteraction<G, F>[];
+        listAvailable(): readonly AnyInteraction<G, F>[];
+    };
+    readonly inputs: {
+        get<K extends InteractionKey<G>, N extends InputKey<G, K>>(interaction: K, input: N): Input<G, F, K, N>;
+        find<K extends InteractionKey<G>, N extends InputKey<G, K>>(interaction: K, input: N): Input<G, F, K, N> | undefined;
+    };
+    readonly zones: {
+        get<K extends IdOf<G, "zoneId">>(id: K, hostId: ZoneHostId<G, NoInfer<K>>): Zone<G, F, K>;
+        find<K extends IdOf<G, "zoneId">>(id: K, hostId: ZoneHostId<G, NoInfer<K>>): Zone<G, F, K> | undefined;
+        getAll(): readonly Zone<G, F>[];
+    };
+    readonly cards: {
+        get<K extends SeatCardId<G>>(id: K): Card<G, F, K>;
+        find<K extends SeatCardId<G>>(id: K): Card<G, F, K> | undefined;
+    };
+    readonly events: {
+        readonly recent: readonly GameEvent[];
+    };
+}
+interface InstanceOptions<G, S extends GameSource = GameSource> {
+    readonly source: S;
+    readonly initialState?: Partial<LocalState<G>>;
+    readonly state?: Partial<LocalState<G>>;
+    readonly onDraftsChange?: (drafts: Drafts<G>) => void;
+    readonly onActiveInteractionChange?: (key: InteractionKey<G> | null) => void;
+    readonly onError?: (error: unknown) => void;
+    readonly debug?: boolean;
+}
+type CoreInstance<G> = ReadModel<G> & {
+    readonly store: Pick<Store<ReadModel<G>>, "get" | "subscribe">;
+    getSnapshot(): ReadModel<G>;
+    getOptions(): InstanceOptions<G>;
+    setOptions(options: InstanceOptions<G>): void;
+    subscribe(listener: () => void): () => void;
+    dispose(): void;
+    assertCoverage(): void;
+};
+type GameSnapshot<G, F extends Features = Record<never, never>> = ReadModel<G, F> & RootHooks<G, F>;
+type GameInstance<G, F extends Features = Record<never, never>, S extends GameSource = GameSource> = Omit<CoreInstance<G>, keyof ReadModel<G> | "store" | "getSnapshot" | "getOptions" | "setOptions"> & ReadModel<G, F> & RootHooks<G, F> & {
+    readonly store: Pick<Store<GameSnapshot<G, F>>, "get" | "subscribe">;
+    getSnapshot(): GameSnapshot<G, F>;
+    getOptions(): InstanceOptions<G, S>;
+    setOptions(options: InstanceOptions<G, S>): void;
+} & (S extends {
+    apply(action: infer A): infer R;
+} ? {
+    apply(action: A): R;
+} : Record<never, never>) & (S extends {
+    explore(...args: infer A): infer R;
+} ? {
+    explore(...args: A): R;
+} : Record<never, never>);
+
+/** A zone control carries the actual admitted attachment, including its host. */
+type ShortcutZoneTarget<G> = {
+    [Z in IdOf<G, "zoneId">]: {
+        readonly kind: "zone";
+        readonly zoneId: Z;
+        readonly hostId: ZoneHostId<G, Z>;
+    };
+}[IdOf<G, "zoneId">];
+type ShortcutTarget<G> = SelectionTarget<G> | ShortcutZoneTarget<G>;
+type TargetKind = SelectionTarget<unknown>["kind"];
+type CollectorKind<Kind extends TargetKind> = Kind extends "space" ? "board-space" : Kind extends "edge" ? "board-edge" : Kind extends "vertex" ? "board-vertex" : Kind;
+type TargetFor<G, K extends InteractionKey<G>, N extends InputKey<G, K>, Kind extends TargetKind> = Extract<SelectionTarget<G>, {
+    readonly kind: Kind;
+}> & {
+    readonly value: InputTarget<G, K, N>;
+};
+type Binding<G, K extends InteractionKey<G>, Target, Filter> = Filter & {
+    /** Exact browser event.key values; modifiers and held repeats are ignored. */
+    readonly keys: readonly string[];
+    readonly label: string;
+    readonly kind: "interaction";
+    readonly interaction: K;
+    readonly inputs: (context: {
+        readonly key: string;
+        readonly target: Target;
+    }) => InteractionParams<G, K>;
+};
+type SelectionBinding<G, K extends InteractionKey<G>> = {
+    [N in InputKey<G, K>]: {
+        [Kind in TargetKind]: [
+            Extract<InputKind<G, K, N>, CollectorKind<Kind>>
+        ] extends [never] ? never : Binding<G, K, TargetFor<G, K, N, Kind>, {
+            readonly target: Kind;
+            readonly input: N;
+        }>;
+    }[TargetKind];
+}[InputKey<G, K>];
+/** Correlated by interaction, input kind, and the selected target's value. */
+type InteractionShortcutBinding<G> = {
+    [K in InteractionKey<G>]: SelectionBinding<G, K> | {
+        [Z in IdOf<G, "zoneId">]: Binding<G, K, Extract<ShortcutZoneTarget<G>, {
+            readonly zoneId: Z;
+        }>, {
+            readonly target: "zone";
+            readonly zoneId: Z;
+        }>;
+    }[IdOf<G, "zoneId">];
+}[InteractionKey<G>];
+/** Local presentation actions run only from control focus, independent of reducer turns. */
+type LocalShortcutBinding<G> = {
+    [Z in IdOf<G, "zoneId">]: {
+        readonly kind: "local";
+        readonly keys: readonly string[];
+        readonly label: string;
+        readonly target: "zone";
+        readonly zoneId: Z;
+        /** Pure applicability predicate, also evaluated for hints. */
+        readonly getIsAvailable?: (context: {
+            readonly key: string;
+            readonly target: Extract<ShortcutZoneTarget<G>, {
+                readonly zoneId: Z;
+            }>;
+        }) => boolean;
+        readonly run: (context: {
+            readonly key: string;
+            readonly target: Extract<ShortcutZoneTarget<G>, {
+                readonly zoneId: Z;
+            }>;
+        }) => void | Promise<void>;
+    };
+}[IdOf<G, "zoneId">];
+type ShortcutBinding<G> = InteractionShortcutBinding<G> | LocalShortcutBinding<G>;
+interface ShortcutOptions<G> {
+    readonly bindings: readonly ShortcutBinding<G>[];
+}
+type ShortcutHint<G = unknown> = {
+    readonly keys: readonly string[];
+    readonly label: string;
+} & ({
+    readonly kind: "interaction";
+    readonly interaction: InteractionKey<G>;
+} | {
+    readonly kind: "local";
+});
+type ShortcutResult = {
+    readonly kind: "interaction";
+    readonly result: SubmitResult;
+} | {
+    readonly kind: "local";
+};
+/** Mounted control activity; explicit-target interaction menus need no focus. */
+interface ShortcutActivity<G> {
+    readonly focusedTarget: ShortcutTarget<G> | null;
+    /** Card press, drag, or submitted drag overlay still settling. */
+    readonly pointerActive: boolean;
+}
+interface ShortcutsController<G> {
+    /** UI binding configuration has its own subscription, independent of reducer frames. */
+    readonly configuration: Pick<Store<ShortcutOptions<G> | null>, "get" | "subscribe">;
+    /** Registers one mounted adapter. Cleanup removes both behavior and hints. */
+    register(options: ShortcutOptions<G>): {
+        update(options: ShortcutOptions<G>): void;
+        dispose(): void;
+    };
+    /** null means unhandled; a handled key runs or submits exactly once. */
+    handle(key: string, target: ShortcutTarget<G> | null, activity?: ShortcutActivity<G>): Promise<ShortcutResult> | null;
+    getHints(target: ShortcutTarget<G> | null, activity?: ShortcutActivity<G>): readonly ShortcutHint<G>[];
+}
+/** Headless and opt-in: no names, bindings or browser listeners are installed by default. */
+declare function shortcutsFeature<G>(_game: CoreInstance<G>, context: FeatureContext<G>): {
+    root: {
+        shortcuts: ShortcutsController<G>;
+    };
+    dispose(): void;
+};
+
+export { type RuntimeBoardDropTarget as $, type ActionProps as A, type Board as B, type Card as C, type Drafts as D, type InputTargetOption as E, type Feature as F, type GameInstance as G, type Hook as H, type IdOf as I, type InstanceOptions as J, type Interaction as K, type InteractionBase as L, type InteractionDropTarget as M, type InteractionKey as N, type InteractionParams as O, type InteractionShortcutBinding as P, type LocalShortcutBinding as Q, type LocalState as R, type NativeEvent as S, type Phase as T, type PhaseName as U, type PlacedTileDataOf as V, type Player as W, type PositionDropTarget as X, type ReadModel as Y, type ReadonlyData as Z, type RuntimeBoard as _, type AnyInput as a, type RuntimeBoardTarget as a0, type RuntimeDropTarget as a1, type RuntimeInteractionDropTarget as a2, type RuntimePositionDropTarget as a3, type RuntimeSelectionTarget as a4, type RuntimeTargetOptions as a5, type SeatCardId as a6, type SelectionTarget as a7, type ShortcutActivity as a8, type ShortcutBinding as a9, type ShortcutHint as aa, type ShortcutOptions as ab, type ShortcutResult as ac, type ShortcutTarget as ad, type ShortcutZoneTarget as ae, type ShortcutsController as af, type TableOfGame as ag, type TargetOptions as ah, type Tile as ai, type TileDataOf as aj, type Turn as ak, type ViewOf as al, type Zone as am, type ZoneBase as an, type ZoneHostId as ao, shortcutsFeature as ap, type AnyInteraction as b, type BoardBase as c, type BoardCollection as d, type BoardDataOf as e, type BoardDropTarget as f, type BoardSpace as g, type BoardSpaceCollection as h, type BoardSpaceData as i, type BoardSpaceId as j, type BoardTarget as k, type CardBase as l, type CardDataOf as m, type CoreInstance as n, type DropAreaBinding as o, type DropTarget as p, type FeatureContext as q, type Features as r, type GameSnapshot as s, type Input as t, type InputBase as u, type InputControl as v, type InputDomainOf as w, type InputKey as x, type InputKind as y, type InputTarget as z };