@dreamboard-games/sdk 0.4.0-alpha.0 → 0.4.0-alpha.2

package/dist/player-state-Cqpyeql0.d.ts

@@ -0,0 +1,371 @@
+import { ViewCard } from './types.js';
+
+type HexColor = string & {
+    readonly __brand: "HexColor";
+};
+declare function isHexColor(value: unknown): value is HexColor;
+declare function parseHexColor(value: unknown): HexColor | undefined;
+declare function hexColor(value: string): HexColor;
+
+type PlayerId = string;
+type CardId = string;
+type DeckId = string;
+type BoardBaseId = string;
+type BoardId = string;
+type PieceId = string;
+type SpaceId = string;
+type DieId = string;
+type EdgeTypeId = string;
+type VertexTypeId = string;
+type PieceTypeId = string;
+type SpaceTypeId = string;
+type CardProperties = Record<string, unknown>;
+type CardIdsByDeckId = Record<DeckId, readonly CardId[]>;
+interface PerPlayer<Value> {
+    readonly __perPlayer: true;
+    readonly entries: ReadonlyArray<readonly [PlayerId, Value]>;
+}
+interface SharedBoardRef<BaseId extends string = BoardBaseId> {
+    readonly baseId: BaseId;
+    readonly seat?: undefined;
+}
+interface PerPlayerBoardRef<BaseId extends string = BoardBaseId, Id extends string = PlayerId> {
+    readonly baseId: BaseId;
+    readonly seat: Id;
+}
+type BoardRef<BaseId extends string = BoardBaseId, Id extends string = PlayerId> = SharedBoardRef<BaseId> | PerPlayerBoardRef<BaseId, Id>;
+/**
+ * Hands are keyed by the authored hand id and split per seat. The per-seat
+ * entries are populated from the runtime seat list, not the static manifest
+ * upper bound, so views always match what the backend actually computed.
+ */
+type CardIdsByHandId = Record<string, PerPlayer<CardId[]>>;
+type StateName = string;
+type TilePropertiesByBoardId = Record<BoardId, Record<string, unknown>>;
+type EdgePropertiesByBoardId = Record<BoardId, Record<string, unknown>>;
+type VertexPropertiesByBoardId = Record<BoardId, Record<string, unknown>>;
+interface Player {
+    /** Player ID */
+    playerId: PlayerId;
+    /** Player display name */
+    name: string;
+    /** Whether this player is the host */
+    isHost?: boolean;
+    /** Player's assigned color */
+    color?: HexColor;
+}
+interface HexTileState<B extends string = BoardId, SpaceIdValue extends string = SpaceId, Properties = B extends keyof TilePropertiesByBoardId ? TilePropertiesByBoardId[B] : undefined, View = unknown> {
+    /** Unique tile identifier */
+    id: SpaceIdValue;
+    /** Axial coordinate Q */
+    q: number;
+    /** Axial coordinate R */
+    r: number;
+    /** Tile type identifier for rendering */
+    typeId?: SpaceTypeId;
+    /** Display label on the tile */
+    label?: string;
+    /** Player ID who owns this tile */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: Properties;
+    /**
+     * Optional view-projection overlay merged onto the static topology by
+     * component-first board helpers such as `Board.HexView`. Authored boards can
+     * also supply this directly when building tiles by hand.
+     */
+    view?: View;
+}
+/** State of an edge on a reducer-projected hex board. */
+interface HexEdgeState<B extends string = BoardId, SpaceIdValue extends string = SpaceId, EdgeIdValue extends string = string, Properties = B extends keyof EdgePropertiesByBoardId ? EdgePropertiesByBoardId[B] : undefined> {
+    /** Unique edge identifier (serialized string, e.g., "tile1-tile2") */
+    id: EdgeIdValue;
+    /** First hex tile ID this edge borders */
+    hex1: SpaceIdValue;
+    /** Second hex tile ID this edge borders */
+    hex2: SpaceIdValue;
+    /** Edge type identifier for rendering */
+    typeId?: EdgeTypeId;
+    /** Display label for setup or rendering */
+    label?: string;
+    /** Player ID who owns this edge */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: Properties;
+}
+/** State of a vertex on a reducer-projected hex board. */
+interface HexVertexState<B extends string = BoardId, SpaceIdValue extends string = SpaceId, VertexIdValue extends string = string, Properties = B extends keyof VertexPropertiesByBoardId ? VertexPropertiesByBoardId[B] : undefined> {
+    /** Unique vertex identifier (serialized string, e.g., "tile1-tile2-tile3") */
+    id: VertexIdValue;
+    /** The hex tile IDs this vertex touches */
+    hexes: readonly SpaceIdValue[];
+    /** Vertex type identifier for rendering */
+    typeId?: VertexTypeId;
+    /** Display label for setup or rendering */
+    label?: string;
+    /** Player ID who owns this vertex */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: Properties;
+}
+/** Complete state of a reducer-projected hex board. */
+interface HexBoardState<B extends string = BoardId, SpaceIdValue extends string = SpaceId, EdgeIdValue extends string = string, VertexIdValue extends string = string, TileProperties = B extends keyof TilePropertiesByBoardId ? TilePropertiesByBoardId[B] : undefined, EdgeProperties = B extends keyof EdgePropertiesByBoardId ? EdgePropertiesByBoardId[B] : undefined, VertexProperties = B extends keyof VertexPropertiesByBoardId ? VertexPropertiesByBoardId[B] : undefined> {
+    /** Unique board identifier */
+    id: B;
+    /** All tiles on the board */
+    tiles: ReadonlyArray<HexTileState<B, SpaceIdValue, TileProperties>>;
+    /** All edges on the board */
+    edges: ReadonlyArray<HexEdgeState<B, SpaceIdValue, EdgeIdValue, EdgeProperties>>;
+    /** All vertices on the board */
+    vertices: ReadonlyArray<HexVertexState<B, SpaceIdValue, VertexIdValue, VertexProperties>>;
+}
+/** State of a node in a reducer-projected network board. */
+interface NetworkNodeState {
+    /** Unique node identifier */
+    id: SpaceId;
+    /** X coordinate position */
+    x: number;
+    /** Y coordinate position */
+    y: number;
+    /** Node type identifier for rendering */
+    typeId?: SpaceTypeId;
+    /** Display label on the node */
+    label?: string;
+    /** Player ID who owns this node */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: string;
+}
+/** State of an edge connecting two nodes in a reducer-projected network board. */
+interface NetworkEdgeState {
+    /** Unique edge identifier */
+    id: string;
+    /** Source node ID */
+    from: SpaceId;
+    /** Target node ID */
+    to: SpaceId;
+    /** Edge type identifier for rendering */
+    typeId?: string;
+    /** Display label on the edge */
+    label?: string;
+    /** Player ID who owns this edge */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: string;
+}
+/** State of a piece placed on a reducer-projected network node. */
+interface NetworkPieceState {
+    /** Unique piece identifier */
+    id: PieceId;
+    /** Node ID where this piece is placed */
+    nodeId: SpaceId;
+    /** Piece type identifier for rendering */
+    typeId?: PieceTypeId;
+    /** Player ID who owns this piece */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: string;
+}
+/** Complete state of a reducer-projected network board. */
+interface NetworkBoardState {
+    /** Unique board identifier */
+    id: BoardId;
+    /** All nodes on the board */
+    nodes: NetworkNodeState[];
+    /** All edges on the board */
+    edges: NetworkEdgeState[];
+    /** All pieces on the board */
+    pieces: NetworkPieceState[];
+}
+/** State of a cell on a reducer-projected square grid board. */
+interface SquareCellState<SpaceIdValue extends string = SpaceId, Properties = Record<string, unknown>> {
+    /** Unique cell identifier */
+    id: SpaceIdValue;
+    /** Row index (0-based) */
+    row: number;
+    /** Column index (0-based) */
+    col: number;
+    /** Cell type identifier for rendering */
+    typeId?: SpaceTypeId;
+    /** Display label on the cell */
+    label?: string;
+    /** Player ID who owns this cell */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: Properties;
+}
+/** State of an edge on a reducer-projected square grid board. */
+interface SquareEdgeState<SpaceIdValue extends string = SpaceId, EdgeIdValue extends string = string, Properties = Record<string, unknown>> {
+    /** Unique edge identifier */
+    id: EdgeIdValue;
+    /** The cell IDs this edge borders */
+    spaceIds: readonly SpaceIdValue[];
+    /** Edge type identifier for rendering */
+    typeId?: EdgeTypeId;
+    /** Display label for setup or rendering */
+    label?: string;
+    /** Player ID who owns this edge */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: Properties;
+}
+/** State of a vertex on a reducer-projected square grid board. */
+interface SquareVertexState<SpaceIdValue extends string = SpaceId, VertexIdValue extends string = string, Properties = Record<string, unknown>> {
+    /** Unique vertex identifier */
+    id: VertexIdValue;
+    /** The cell IDs that touch this corner */
+    spaceIds: readonly SpaceIdValue[];
+    /** Vertex type identifier for rendering */
+    typeId?: VertexTypeId;
+    /** Display label for setup or rendering */
+    label?: string;
+    /** Player ID who owns this vertex */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: Properties;
+}
+/** State of a piece placed on a reducer-projected square grid cell. */
+interface SquarePieceState<PieceIdValue extends string = PieceId, Properties = Record<string, unknown>> {
+    /** Unique piece identifier */
+    id: PieceIdValue;
+    /** Row index where piece is located */
+    row: number;
+    /** Column index where piece is located */
+    col: number;
+    /** Piece type identifier for rendering */
+    typeId: PieceTypeId;
+    /** Player ID who owns this piece */
+    owner?: PlayerId;
+    /** JSON-serialized custom properties */
+    properties?: Properties;
+}
+/** Complete state of a reducer-projected square grid board. */
+interface SquareBoardState<B extends string = BoardId, SpaceIdValue extends string = SpaceId, EdgeIdValue extends string = string, VertexIdValue extends string = string, PieceIdValue extends string = PieceId, CellProperties = Record<string, unknown>, EdgeProperties = Record<string, unknown>, VertexProperties = Record<string, unknown>, PieceProperties = Record<string, unknown>> {
+    /** Unique board identifier */
+    id: B;
+    /** Number of rows in the grid */
+    rows: number;
+    /** Number of columns in the grid */
+    cols: number;
+    /** All authored cells on the board */
+    cells: ReadonlyArray<SquareCellState<SpaceIdValue, CellProperties>>;
+    /** All edges on the board */
+    edges: ReadonlyArray<SquareEdgeState<SpaceIdValue, EdgeIdValue, EdgeProperties>>;
+    /** All vertices on the board */
+    vertices: ReadonlyArray<SquareVertexState<SpaceIdValue, VertexIdValue, VertexProperties>>;
+    /** All pieces on the board */
+    pieces: ReadonlyArray<SquarePieceState<PieceIdValue, PieceProperties>>;
+}
+/** State of a space on a reducer-projected track board. */
+interface TrackSpaceState {
+    /** Unique space identifier */
+    id: SpaceId;
+    /** Position index in the track sequence */
+    index: number;
+    /** X coordinate for rendering */
+    x: number;
+    /** Y coordinate for rendering */
+    y: number;
+    /** Display name of the space */
+    name?: string;
+    /** Space type identifier for rendering */
+    typeId?: SpaceTypeId;
+    /** Player ID who owns this space */
+    owner?: PlayerId;
+    /** IDs of spaces that can be reached from here (for branching tracks) */
+    nextSpaces?: SpaceId[];
+    /** JSON-serialized custom properties */
+    properties?: string;
+}
+/** State of a piece on a reducer-projected track board. */
+interface TrackPieceState {
+    /** Unique piece identifier */
+    id: PieceId;
+    /** ID of the space this piece occupies */
+    spaceId: SpaceId;
+    /** Player ID who owns this piece */
+    owner: PlayerId;
+    /** Piece type identifier for rendering */
+    typeId?: PieceTypeId;
+    /** JSON-serialized custom properties */
+    properties?: string;
+}
+/** Complete state of a reducer-projected track board. */
+interface TrackBoardState {
+    /** Unique board identifier */
+    id: BoardId;
+    /** All spaces on the track */
+    spaces: TrackSpaceState[];
+    /** All pieces on the track */
+    pieces: TrackPieceState[];
+}
+/** State of a reducer-projected die component. */
+interface DieState {
+    /** Unique die identifier */
+    id: DieId;
+    /** Number of sides on the die (e.g., 6 for standard die) */
+    sides: number;
+    /** Current face value (1 to sides, undefined if not rolled) */
+    currentValue?: number;
+    /** Optional color for visual identification */
+    color?: string;
+}
+/**
+ * Collection of boards of a particular kind, split into shared boards
+ * (indexed by base id, e.g. `"market-board"`) and per-player boards
+ * (indexed by base id, then by the runtime seat list via `PerPlayer<T>`).
+ *
+ * Splitting by the `BoardRef` discriminator keeps the UI types honest about
+ * what the runtime actually produced: per-player board state only exists
+ * for the seats that are currently playing, never for a static `maxPlayers`
+ * upper bound.
+ */
+interface BoardKindStates<State> {
+    /** Shared boards keyed by base id. */
+    shared: Record<BoardBaseId, State>;
+    /** Per-player boards keyed by base id, then by seat via `PerPlayer<T>`. */
+    perPlayer: Record<BoardBaseId, PerPlayer<State>>;
+}
+/**
+ * Container for all board states organized by kind.
+ * This is the strongly-typed board payload authored UIs consume from reducer views.
+ */
+interface BoardStates {
+    /** Hex boards split into shared vs per-player collections. */
+    hex: BoardKindStates<HexBoardState>;
+    /** Network boards split into shared vs per-player collections. */
+    network: BoardKindStates<NetworkBoardState>;
+    /** Square grid boards split into shared vs per-player collections. */
+    square: BoardKindStates<SquareBoardState>;
+    /** Track boards split into shared vs per-player collections. */
+    track: BoardKindStates<TrackBoardState>;
+}
+/**
+ * Container for all dice states.
+ * Maps die IDs to their die state.
+ */
+type DiceStates = Record<DieId, DieState>;
+interface GameState {
+    /** All currently active players (supports MULTIPLE_ACTIVE_PLAYER states) */
+    currentPlayerIds: PlayerId[];
+    decks: CardIdsByDeckId;
+    /**
+     * Player-scoped hands keyed by the authored hand id. The inner
+     * `PerPlayer<CardId[]>` is keyed by the runtime seat list and only
+     * contains entries for players who actually hold the hand.
+     */
+    hands: CardIdsByHandId;
+    /** Map of card IDs to their card info including type and properties */
+    cards: Record<CardId, ViewCard<CardId, string, CardProperties>>;
+    /**
+     * Per-player resource totals keyed by the runtime seat list. The inner
+     * record maps resource id → amount for that seat.
+     */
+    playerResources: PerPlayer<Record<string, number>>;
+    currentState: StateName;
+    isMyTurn: boolean;
+    boards: BoardStates;
+    dice: DiceStates;
+}
+
+export { type SquarePieceState as A, type BoardBaseId as B, type CardId as C, type DeckId as D, type EdgeTypeId as E, type SquareVertexState as F, type GameState as G, type HexBoardState as H, type TrackPieceState as I, type TrackSpaceState as J, hexColor as K, isHexColor as L, parseHexColor as M, type NetworkBoardState as N, type PerPlayer as P, type SharedBoardRef as S, type TrackBoardState as T, type VertexTypeId as V, type BoardId as a, type BoardKindStates as b, type BoardRef as c, type BoardStates as d, type CardIdsByDeckId as e, type CardProperties as f, type DiceStates as g, type DieId as h, type DieState as i, type HexColor as j, type HexEdgeState as k, type HexTileState as l, type HexVertexState as m, type NetworkEdgeState as n, type NetworkNodeState as o, type NetworkPieceState as p, type PerPlayerBoardRef as q, type PieceId as r, type PieceTypeId as s, type Player as t, type PlayerId as u, type SpaceId as v, type SpaceTypeId as w, type SquareBoardState as x, type SquareCellState as y, type SquareEdgeState as z };

package/dist/protocol-BP193lva.d.ts

@@ -0,0 +1,267 @@
+type RuntimeJson = null | boolean | number | string | RuntimeJson[] | {
+    [key: string]: RuntimeJson;
+};
+type CanonicalJson = null | boolean | number | string | CanonicalJson[] | {
+    [key: string]: CanonicalJson;
+};
+declare function canonicalizePluginRuntimeJson(value: unknown): CanonicalJson;
+declare function encodeCanonicalPluginRuntimeJson(value: unknown): string;
+declare function digestPluginRuntimeJson(value: unknown): string;
+
+type PlayerId = string;
+interface PluginPlayerSummary {
+    readonly playerId: PlayerId;
+    readonly displayName: string;
+    readonly color?: string;
+}
+interface PluginSessionDescriptor {
+    readonly sessionId: string;
+    /** Turn order is the order of this array. */
+    readonly players: readonly PluginPlayerSummary[];
+}
+interface InteractionCommitPolicy {
+    readonly mode: "manual" | "autoWhenReady";
+}
+type InputSelection = {
+    readonly mode: "single";
+} | {
+    readonly mode: "many";
+    readonly min: number;
+    readonly max?: number;
+    readonly distinct?: boolean;
+};
+interface InputDomainDependencyCase {
+    readonly when: Readonly<Record<string, string>>;
+    readonly domain: InputDomain;
+}
+type InputDomainDependencies = {
+    readonly mode: "eager";
+    readonly dependentCases: readonly InputDomainDependencyCase[];
+} | {
+    readonly mode: "lazy";
+    readonly dependsOn: readonly string[];
+    readonly resolver: {
+        readonly interactionKey?: string;
+        readonly inputKey: string;
+    };
+};
+interface InputDomain {
+    readonly type: string;
+    readonly selection?: InputSelection;
+    readonly dependencies?: InputDomainDependencies;
+    readonly [key: string]: RuntimeJson | InputSelection | InputDomainDependencies | undefined;
+}
+interface InteractionChoiceOption {
+    readonly value: string | null;
+    readonly label: string;
+    readonly icon?: string;
+    readonly badge?: string;
+    readonly description?: string;
+    readonly disabled?: boolean;
+    readonly disabledReason?: string;
+}
+interface InteractionInputDescriptor {
+    readonly key: string;
+    readonly kind: string;
+    readonly domain: InputDomain;
+    readonly defaultValue?: RuntimeJson;
+}
+type InteractionAvailability = {
+    readonly status: "available";
+} | {
+    readonly status: "notYourTurn";
+    readonly reason: string;
+} | {
+    readonly status: "insufficientResources";
+    readonly reason: string;
+    readonly missingResources: Readonly<Record<string, number>>;
+} | {
+    readonly status: "blocked";
+    readonly reason: string;
+    readonly code?: string;
+};
+interface InteractionDiagnosticReason {
+    readonly ruleId: string;
+    readonly errorCode: string;
+}
+interface InteractionDescriptorBase<Interaction extends string = string> {
+    readonly phaseName: string;
+    readonly interactionKey: Interaction;
+    readonly interactionId: string;
+    readonly zoneId?: string;
+    readonly zoneIds?: readonly string[];
+    readonly commit: InteractionCommitPolicy;
+    readonly descriptorDigest?: string;
+    readonly actorSeat?: number;
+    readonly draftDigest?: string;
+    readonly inputs: readonly InteractionInputDescriptor[];
+    readonly cost?: Readonly<Record<string, RuntimeJson>>;
+    readonly currentResources?: Readonly<Record<string, RuntimeJson>>;
+    readonly availability: InteractionAvailability;
+    readonly reasons?: readonly InteractionDiagnosticReason[];
+}
+type ActionInteractionDescriptor<Interaction extends string = string> = InteractionDescriptorBase<Interaction> & {
+    readonly kind: "action";
+};
+interface InteractionContextOption {
+    readonly id: string;
+    readonly label?: string;
+}
+interface InteractionContext {
+    readonly to: string;
+    readonly title?: string;
+    readonly payload?: Readonly<Record<string, RuntimeJson>>;
+    readonly options?: readonly InteractionContextOption[];
+}
+type PromptInteractionDescriptor<Interaction extends string = string> = InteractionDescriptorBase<Interaction> & {
+    readonly kind: "prompt";
+    readonly context: InteractionContext;
+};
+type InteractionDescriptor<Interaction extends string = string> = ActionInteractionDescriptor<Interaction> | PromptInteractionDescriptor<Interaction>;
+interface ZoneHandlesSnapshot<Interaction extends string = string> {
+    readonly cardIds: readonly string[];
+    readonly cardViewsById: Readonly<Record<string, string>>;
+    readonly playableByCardId: Readonly<Record<string, readonly InteractionDescriptor<Interaction>[]>>;
+}
+interface SimultaneousPhaseSnapshot {
+    readonly phaseName: string;
+    readonly interactionId: string;
+    readonly actorIds: readonly PlayerId[];
+    readonly sealedPlayerIds: readonly PlayerId[];
+    readonly pendingPlayerIds: readonly PlayerId[];
+}
+interface PluginGameplayFrame<View = unknown, Phase extends string = string, Stage extends string = string, Interaction extends string = string> {
+    readonly gameVersion: number;
+    readonly actionSetVersion: string;
+    readonly perspectivePlayerId: PlayerId | null;
+    readonly view: View | null;
+    readonly flow: {
+        readonly currentPhase: Phase | null;
+        readonly currentStage: Stage | null;
+        readonly activePlayers: readonly PlayerId[];
+        readonly simultaneousPhase: SimultaneousPhaseSnapshot | null;
+    };
+    readonly availableInteractions: ReadonlyArray<InteractionDescriptor<Interaction>>;
+    readonly zones: Readonly<Record<string, ZoneHandlesSnapshot<Interaction>>>;
+}
+interface ReducerSeatProjectionBundle {
+    readonly currentStage?: string | null;
+    readonly stageSeats?: readonly string[];
+    readonly simultaneousPhase?: SimultaneousPhaseSnapshot | null;
+    readonly interactionsByRef?: unknown;
+    readonly seats: Readonly<Record<string, {
+        readonly view?: unknown;
+        readonly availableInteractionRefs?: unknown;
+        readonly zones?: unknown;
+    }>>;
+}
+interface ReducerBoardStaticProjection {
+    readonly view: RuntimeJson;
+    readonly hash?: string;
+    readonly manifestVersion?: string;
+}
+
+declare const DREAMBOARD_PLUGIN_PROTOCOL: "dreamboard-plugin";
+declare const DREAMBOARD_PLUGIN_PROTOCOL_VERSION: 3;
+interface ValidationResult {
+    readonly valid: boolean;
+    readonly errorCode?: string;
+    readonly message?: string;
+}
+type SubmissionResult = {
+    readonly accepted: true;
+} | {
+    readonly accepted: false;
+    readonly errorCode: string;
+    readonly message?: string;
+};
+interface PluginInteractionBasis {
+    readonly gameVersion: number;
+    readonly actionSetVersion: string;
+    readonly perspectivePlayerId: PlayerId | null;
+}
+interface ValidateInteractionCommand {
+    readonly type: "interaction.validate";
+    readonly requestId: string;
+    readonly basis: PluginInteractionBasis;
+    readonly interactionId: string;
+    readonly params: RuntimeJson;
+}
+interface SubmitInteractionCommand {
+    readonly type: "interaction.submit";
+    readonly requestId: string;
+    readonly basis: PluginInteractionBasis;
+    readonly interactionId: string;
+    readonly params: RuntimeJson;
+}
+type HostToPluginPayload = {
+    readonly type: "runtime.init";
+    readonly session: PluginSessionDescriptor;
+} | {
+    readonly type: "gameplay.frame";
+    readonly frame: PluginGameplayFrame;
+} | {
+    readonly type: "interaction.validation-result";
+    readonly requestId: string;
+    readonly result: ValidationResult;
+} | {
+    readonly type: "interaction.submit-result";
+    readonly requestId: string;
+    readonly result: SubmissionResult;
+};
+type PluginToHostPayload = {
+    readonly type: "runtime.ready";
+} | {
+    readonly type: "runtime.ack";
+    /** Echoes the host envelope sequence. It is delivery order only. */
+    readonly sequence: number;
+    readonly clientReceivedAtMs?: number;
+    readonly clientRenderedAtMs?: number;
+} | ValidateInteractionCommand | SubmitInteractionCommand | {
+    readonly type: "runtime.error";
+    readonly message: string;
+    readonly code?: string;
+};
+interface PluginProtocolEnvelope<Payload> {
+    readonly protocol: typeof DREAMBOARD_PLUGIN_PROTOCOL;
+    readonly version: typeof DREAMBOARD_PLUGIN_PROTOCOL_VERSION;
+    readonly channelId: string;
+    /** Delivery order only. It is not a game revision. */
+    readonly sequence: number;
+    readonly payload: Payload;
+}
+type HostToPluginEnvelope = PluginProtocolEnvelope<HostToPluginPayload>;
+type PluginToHostEnvelope = PluginProtocolEnvelope<PluginToHostPayload>;
+interface PluginProtocolFrame {
+    readonly id: string;
+    readonly frame: PluginGameplayFrame;
+    readonly projectionDigest: string;
+}
+interface PluginProtocolTape {
+    readonly session: PluginSessionDescriptor;
+    readonly frames: readonly PluginProtocolFrame[];
+    readonly steps: readonly PluginProtocolStep[];
+}
+type PluginProtocolStep = {
+    readonly id: string;
+    readonly kind: "host.frame";
+    readonly frameId: string;
+} | {
+    readonly id: string;
+    readonly kind: "client.validate";
+    readonly fromFrameId: string;
+    readonly requestDigest: string;
+    readonly response: ValidationResult;
+} | {
+    readonly id: string;
+    readonly kind: "client.submit";
+    readonly fromFrameId: string;
+    readonly requestDigest: string;
+    readonly response: SubmissionResult;
+};
+type ActionSetVersionInput = {
+    readonly gameVersion: number;
+    readonly availableInteractions: readonly InteractionDescriptor[];
+};
+
+export { type ActionInteractionDescriptor as A, type RuntimeJson as B, type CanonicalJson as C, DREAMBOARD_PLUGIN_PROTOCOL as D, type SubmissionResult as E, type SubmitInteractionCommand as F, type ValidationResult as G, type HostToPluginEnvelope as H, type InputDomain as I, canonicalizePluginRuntimeJson as J, digestPluginRuntimeJson as K, encodeCanonicalPluginRuntimeJson as L, type PlayerId as P, type ReducerBoardStaticProjection as R, type SimultaneousPhaseSnapshot as S, type ValidateInteractionCommand as V, type ZoneHandlesSnapshot as Z, type ActionSetVersionInput as a, DREAMBOARD_PLUGIN_PROTOCOL_VERSION as b, type HostToPluginPayload as c, type InputDomainDependencies as d, type InputDomainDependencyCase as e, type InputSelection as f, type InteractionAvailability as g, type InteractionChoiceOption as h, type InteractionCommitPolicy as i, type InteractionContext as j, type InteractionContextOption as k, type InteractionDescriptor as l, type InteractionDiagnosticReason as m, type InteractionInputDescriptor as n, type PluginGameplayFrame as o, type PluginInteractionBasis as p, type PluginPlayerSummary as q, type PluginProtocolEnvelope as r, type PluginProtocolFrame as s, type PluginProtocolStep as t, type PluginProtocolTape as u, type PluginSessionDescriptor as v, type PluginToHostEnvelope as w, type PluginToHostPayload as x, type PromptInteractionDescriptor as y, type ReducerSeatProjectionBundle as z };