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

package/dist/hex-board-view-aKkblDp6.d.ts

@@ -1,1228 +0,0 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ReactNode } from 'react';
-import { a as BoardId, l as HexTileState, k as HexEdgeState, E as EdgeTypeId, u as PlayerId, m as HexVertexState, V as VertexTypeId, w as SpaceTypeId, y as SquareCellState, z as SquareEdgeState, F as SquareVertexState, A as SquarePieceState, H as HexBoardState, x as SquareBoardState } from './player-state-Cqpyeql0.js';
-
-/**
- * Token contract for `@dreamboard-games/sdk/ui`.
- *
- * The {@link Theme} object is the only thing components consume for
- * visual styling. Every preset (tabletop, arcade, studio) is just a
- * different fully-resolved {@link Theme}; every author override is a
- * deep partial of it. Components never inline hex codes, font stacks,
- * or shadow strings — they read from `useTheme()` (or, when written in
- * Tailwind, from CSS variables that the {@link ThemeProvider} writes
- * onto its wrapper element).
- *
- * Architectural rules:
- *
- * 1. **Foundation → Semantic → Component.** Foundation palette ramps
- *    (`color.neutral`, `color.brand`, …) are never read directly by
- *    components. Components read `semantic.*` (e.g. `surface.card`,
- *    `intent.primary`) which the preset maps from foundation tokens.
- * 2. **No optional deep keys.** Presets must supply every leaf so
- *    components don't need fallbacks. Author-supplied overrides are
- *    `DeepPartial<Theme>` and merged before the provider mounts.
- * 3. **Scalar leaves only.** Every leaf is a string (CSS-ready) so the
- *    serializer can emit a CSS variable for it without per-token
- *    formatting logic.
- */
-/** Identity-only metadata. */
-interface ThemeMeta {
-    /** Stable id used by `data-dreamboard-theme` and CSS-var scoping. */
-    readonly id: string;
-    /** Human-readable name for dev tools. */
-    readonly name: string;
-    /**
-     * Render mode hint for components that need to choose between light
-     * and dark sub-tokens. Presets pick one; authors don't toggle this.
-     */
-    readonly mode: "light" | "dark";
-}
-/** Foundation color ramp. Six stops keeps presets compact. */
-interface ColorRamp {
-    readonly 50: string;
-    readonly 100: string;
-    readonly 200: string;
-    readonly 400: string;
-    readonly 600: string;
-    readonly 800: string;
-    readonly 950: string;
-}
-/**
- * Per-player color tokens. The {@link Theme.player} array is indexed by
- * 0-based seat slot (`player[0]` = first seat). Each entry carries a
- * `solid` brand color, a `soft` tint usable as a background, and `on`
- * — the recommended foreground when text sits on `solid`.
- */
-interface PlayerColor {
-    readonly solid: string;
-    readonly soft: string;
-    readonly on: string;
-}
-/**
- * Foundation palette. Components never read this directly; presets map
- * these into {@link SemanticTokens}. Exposed so authors who write a
- * full theme can compose without inventing their own palette type.
- */
-interface FoundationColor {
-    readonly neutral: ColorRamp;
-    readonly brand: ColorRamp;
-    readonly accent: ColorRamp;
-    readonly success: ColorRamp;
-    readonly warning: ColorRamp;
-    readonly danger: ColorRamp;
-    readonly info: ColorRamp;
-}
-/**
- * Semantic colors consumed by every component. These are the *only*
- * color tokens components should reference. Names describe role
- * ("the surface a player card sits on"), not appearance ("light grey").
- */
-interface SemanticColor {
-    readonly surface: {
-        /** Outermost shell background. */
-        readonly app: string;
-        /** Board canvas background (behind tiles). */
-        readonly board: string;
-        /** HUD chrome panels (top bar, action bar, side rails). */
-        readonly hud: string;
-        /** Standalone cards (player cards, action cards, hand cards). */
-        readonly card: string;
-        /** Modal/sheet body. */
-        readonly sheet: string;
-        /** Scrim behind a blocker overlay. */
-        readonly overlay: string;
-        /** Subtle inset (resource pills, count badges, …). */
-        readonly inset: string;
-    };
-    readonly text: {
-        /** Default body and headline text on light surfaces. */
-        readonly primary: string;
-        /** De-emphasised metadata, hint copy, captions. */
-        readonly muted: string;
-        /** Text used on `intent.primary` solid backgrounds. */
-        readonly onIntent: string;
-        /** Brand-tinted text for emphasis (links, key numbers). */
-        readonly accent: string;
-        /** Disabled text (button labels in disabled state). */
-        readonly disabled: string;
-    };
-    readonly border: {
-        /** Hairline divider between sibling rows. */
-        readonly subtle: string;
-        /** Standard card / panel border. */
-        readonly default: string;
-        /** Outlined emphasis (hovered tiles, selected card). */
-        readonly strong: string;
-        /** Focus ring (keyboard nav). */
-        readonly focus: string;
-    };
-    /**
-     * Intent colours map to action emphasis. Components pick a slot
-     * (`primary` for "do the main thing now", `danger` for destructive
-     * confirms, etc.) and read both the surface and on-color from it.
-     */
-    readonly intent: {
-        readonly primary: IntentColor;
-        readonly secondary: IntentColor;
-        readonly success: IntentColor;
-        readonly danger: IntentColor;
-        readonly warning: IntentColor;
-        readonly info: IntentColor;
-    };
-}
-/** A semantic intent (button background + matching foreground + soft tint). */
-interface IntentColor {
-    /** Solid fill (button bg, badge bg). */
-    readonly solid: string;
-    /** Recommended text/icon color sitting on `solid`. */
-    readonly on: string;
-    /** Subtle tint (e.g. badge bg with `text` for foreground). */
-    readonly soft: string;
-    /** Suitable foreground when sitting on `soft`. */
-    readonly onSoft: string;
-    /** Border tint matched to this intent (e.g. focus ring on intent). */
-    readonly border: string;
-}
-/** Border-radius ramp. */
-interface Radius {
-    readonly none: string;
-    readonly sm: string;
-    readonly md: string;
-    readonly lg: string;
-    /** HUD chrome (top bar pieces, action-bar bar). */
-    readonly hud: string;
-    /** Fully-round badges/pills. */
-    readonly pill: string;
-}
-/** Spacing ramp (rem-based by default). */
-interface Space {
-    readonly 0: string;
-    readonly 0.5: string;
-    readonly 1: string;
-    readonly 1.5: string;
-    readonly 2: string;
-    readonly 3: string;
-    readonly 4: string;
-    readonly 6: string;
-    readonly 8: string;
-    readonly 12: string;
-}
-/** Typography tokens. */
-interface Typography {
-    readonly fontFamily: {
-        /** Hero text — phase name, scoreboard headline, winner banner. */
-        readonly display: string;
-        /** Default UI body text. */
-        readonly body: string;
-        /** Numeric runs (scores, counters, tabular data). Tabular figures preferred. */
-        readonly tabular: string;
-        /** Source/code/raw-id rendering. */
-        readonly mono: string;
-    };
-    readonly fontSize: {
-        readonly xs: string;
-        readonly sm: string;
-        readonly md: string;
-        readonly lg: string;
-        readonly xl: string;
-        readonly "2xl": string;
-        readonly "3xl": string;
-    };
-    readonly fontWeight: {
-        readonly regular: string;
-        readonly medium: string;
-        readonly bold: string;
-    };
-    readonly lineHeight: {
-        readonly tight: string;
-        readonly normal: string;
-        readonly relaxed: string;
-    };
-    readonly letterSpacing: {
-        readonly tight: string;
-        readonly normal: string;
-        readonly wide: string;
-        /** All-caps labels ("YOUR TURN"). */
-        readonly caps: string;
-    };
-}
-/** Drop-shadow elevation ramp. */
-interface Elevation {
-    /** Resting state (cards, panels). */
-    readonly rest: string;
-    /** Hover-lift (interactive cards). */
-    readonly hover: string;
-    /** Selected / dragged element. */
-    readonly lifted: string;
-    /** Modal / overlay stack. */
-    readonly overlay: string;
-    /** Inner shadow (board canvas inset, resource pill well). */
-    readonly inset: string;
-}
-/**
- * Motion tokens. Components import durations and easings from here so a
- * single `prefers-reduced-motion` switch zeroes everything out at the
- * provider, not per-component.
- */
-interface Motion {
-    readonly duration: {
-        /** Hover, focus, micro-press (~80ms). */
-        readonly fast: string;
-        /** Default — most state changes (~160ms). */
-        readonly normal: string;
-        /** Layout shifts, drawer open/close (~280ms). */
-        readonly slow: string;
-        /**
-         * Looping ambient pulses — active-player breath, dice glow.
-         * Components should respect `motion.reducedMotion` before kicking
-         * off looping animations.
-         */
-        readonly ambient: string;
-    };
-    readonly easing: {
-        /** Default for entering / settling. */
-        readonly out: string;
-        /** Default for exiting. */
-        readonly in: string;
-        /** Symmetric. */
-        readonly inOut: string;
-        /** Springy — selected card lift, active-player wobble. */
-        readonly spring: string;
-    };
-    /**
-     * `"true"` when the active client requests reduced motion. Components
-     * should branch on this rather than forcing animations off via CSS,
-     * because some animations (e.g. dice roll, shuffle) are critical for
-     * conveying state and need a static fallback.
-     */
-    readonly reducedMotion: "true" | "false";
-}
-/**
- * Component-level token slots derived from semantic + foundation tokens.
- * Kept intentionally tiny — a slot is added here only when a component
- * needs to deviate from the semantic mapping in a way that authors
- * should be able to customise without re-skinning the whole intent
- * scale.
- */
-interface ComponentTokens {
-    readonly board: {
-        /** Outer ring around the board canvas. */
-        readonly frameBorder: string;
-        /** Inner board surface tint (overlays the canvas tile renderer). */
-        readonly frameBackground: string;
-        /** Highlight ring drawn on hovered interactive targets. */
-        readonly hoverRing: string;
-        /** Idle hint colour for eligible-but-unhovered targets. */
-        readonly eligibleHint: string;
-    };
-    readonly card: {
-        /** Border drawn around face-up cards. */
-        readonly border: string;
-        /** Border drawn around face-down cards. */
-        readonly backBorder: string;
-        /** Card-back fill colour. */
-        readonly backBackground: string;
-        /** Selected outline. */
-        readonly selectedRing: string;
-    };
-    readonly playerCard: {
-        /** Background of the active-player card. */
-        readonly activeBackground: string;
-        /** Border of the active-player card. */
-        readonly activeBorder: string;
-        /** Glow colour radiated by the active-player card. */
-        readonly activeGlow: string;
-        /** Background of the "you" badge. */
-        readonly youBadgeBackground: string;
-        /** Foreground of the "you" badge. */
-        readonly youBadgeForeground: string;
-    };
-    readonly toast: {
-        readonly successBackground: string;
-        readonly errorBackground: string;
-        readonly infoBackground: string;
-        readonly foreground: string;
-    };
-}
-/**
- * The complete theme contract. Every leaf is a CSS-ready string so the
- * provider can emit a CSS variable for each path without per-leaf
- * formatting. {@link DeepPartial} is exported for author overrides.
- */
-interface Theme {
-    readonly meta: ThemeMeta;
-    readonly color: FoundationColor;
-    readonly semantic: SemanticColor;
-    readonly radius: Radius;
-    readonly space: Space;
-    readonly typography: Typography;
-    readonly elevation: Elevation;
-    readonly motion: Motion;
-    readonly player: readonly [
-        PlayerColor,
-        PlayerColor,
-        PlayerColor,
-        PlayerColor,
-        PlayerColor,
-        PlayerColor
-    ];
-    readonly component: ComponentTokens;
-}
-/**
- * Recursive partial for theme overrides. Authors pass this to
- * `<ThemeProvider override={...}/>` (or to a preset's `extend`
- * helper) to tweak individual tokens without re-declaring the whole
- * tree.
- */
-type ThemeOverride = DeepPartial<Theme>;
-type DeepPartial<T> = T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends object ? {
-    readonly [K in keyof T]?: DeepPartial<T[K]>;
-} : T;
-/**
- * Deep merge for {@link Theme} overrides. Arrays (notably
- * {@link Theme.player}) are *replaced* rather than merged so callers
- * can't accidentally end up with mixed-preset palettes.
- */
-declare function mergeTheme(base: Theme, override?: ThemeOverride): Theme;
-
-type RuntimeFields = Record<string, unknown>;
-interface GeneratedTiledEdgeStateLike<SpaceIdValue extends string = string, EdgeIdValue extends string = string, Fields = RuntimeFields> {
-    id: EdgeIdValue;
-    spaceIds: readonly SpaceIdValue[];
-    typeId?: EdgeTypeId | null;
-    label?: string | null;
-    ownerId?: PlayerId | null;
-    fields?: Fields;
-}
-interface GeneratedTiledVertexStateLike<SpaceIdValue extends string = string, VertexIdValue extends string = string, Fields = RuntimeFields> {
-    id: VertexIdValue;
-    spaceIds: readonly SpaceIdValue[];
-    typeId?: VertexTypeId | null;
-    label?: string | null;
-    ownerId?: PlayerId | null;
-    fields?: Fields;
-}
-interface GeneratedHexSpaceStateLike<SpaceIdValue extends string = string, Fields = RuntimeFields> {
-    id: SpaceIdValue;
-    q: number;
-    r: number;
-    typeId?: SpaceTypeId | null;
-    label?: string | null;
-    ownerId?: PlayerId | null;
-    fields?: Fields;
-}
-interface GeneratedSquareSpaceStateLike<SpaceIdValue extends string = string, Fields = RuntimeFields> {
-    id: SpaceIdValue;
-    row: number;
-    col: number;
-    typeId?: SpaceTypeId | null;
-    label?: string | null;
-    ownerId?: PlayerId | null;
-    fields?: Fields;
-}
-interface GeneratedHexBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields> {
-    id: BoardIdValue;
-    layout?: "hex";
-    orientation?: "pointy-top" | "flat-top";
-    spaces: Readonly<Record<SpaceIdValue, GeneratedHexSpaceStateLike<SpaceIdValue, SpaceFields>>>;
-    edges: ReadonlyArray<HexEdgeState<BoardIdValue, SpaceIdValue, EdgeIdValue, EdgeFields> | GeneratedTiledEdgeStateLike<SpaceIdValue, EdgeIdValue, EdgeFields>>;
-    vertices: ReadonlyArray<HexVertexState<BoardIdValue, SpaceIdValue, VertexIdValue, VertexFields> | GeneratedTiledVertexStateLike<SpaceIdValue, VertexIdValue, VertexFields>>;
-}
-interface AuthoredHexBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields, SpaceView = unknown> {
-    id: BoardIdValue;
-    layout?: "hex";
-    orientation?: "pointy-top" | "flat-top";
-    tiles: ReadonlyArray<HexTileState<BoardIdValue, SpaceIdValue, SpaceFields, SpaceView>>;
-    edges: ReadonlyArray<HexEdgeState<BoardIdValue, SpaceIdValue, EdgeIdValue, EdgeFields> | GeneratedTiledEdgeStateLike<SpaceIdValue, EdgeIdValue, EdgeFields>>;
-    vertices: ReadonlyArray<HexVertexState<BoardIdValue, SpaceIdValue, VertexIdValue, VertexFields> | GeneratedTiledVertexStateLike<SpaceIdValue, VertexIdValue, VertexFields>>;
-}
-type HexBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields> = AuthoredHexBoardInput<BoardIdValue, SpaceIdValue, EdgeIdValue, VertexIdValue, SpaceFields, EdgeFields, VertexFields> | GeneratedHexBoardInput<BoardIdValue, SpaceIdValue, EdgeIdValue, VertexIdValue, SpaceFields, EdgeFields, VertexFields>;
-interface GeneratedSquareBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, PieceIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields, PieceFields = RuntimeFields> {
-    id: BoardIdValue;
-    layout?: "square";
-    spaces: Readonly<Record<SpaceIdValue, GeneratedSquareSpaceStateLike<SpaceIdValue, SpaceFields>>>;
-    edges: ReadonlyArray<SquareEdgeState<SpaceIdValue, EdgeIdValue, EdgeFields> | GeneratedTiledEdgeStateLike<SpaceIdValue, EdgeIdValue, EdgeFields>>;
-    vertices: ReadonlyArray<SquareVertexState<SpaceIdValue, VertexIdValue, VertexFields> | GeneratedTiledVertexStateLike<SpaceIdValue, VertexIdValue, VertexFields>>;
-    pieces?: ReadonlyArray<SquarePieceState<PieceIdValue, PieceFields>>;
-}
-interface AuthoredSquareBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, PieceIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields, PieceFields = RuntimeFields> {
-    id: BoardIdValue;
-    layout?: "square";
-    rows: number;
-    cols: number;
-    cells: ReadonlyArray<SquareCellState<SpaceIdValue, SpaceFields>>;
-    edges: ReadonlyArray<SquareEdgeState<SpaceIdValue, EdgeIdValue, EdgeFields> | GeneratedTiledEdgeStateLike<SpaceIdValue, EdgeIdValue, EdgeFields>>;
-    vertices: ReadonlyArray<SquareVertexState<SpaceIdValue, VertexIdValue, VertexFields> | GeneratedTiledVertexStateLike<SpaceIdValue, VertexIdValue, VertexFields>>;
-    pieces: ReadonlyArray<SquarePieceState<PieceIdValue, PieceFields>>;
-}
-type SquareBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, PieceIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields, PieceFields = RuntimeFields> = AuthoredSquareBoardInput<BoardIdValue, SpaceIdValue, EdgeIdValue, VertexIdValue, PieceIdValue, SpaceFields, EdgeFields, VertexFields, PieceFields> | GeneratedSquareBoardInput<BoardIdValue, SpaceIdValue, EdgeIdValue, VertexIdValue, PieceIdValue, SpaceFields, EdgeFields, VertexFields, PieceFields>;
-type AnyHexBoardInput = HexBoardInput<string, string, string, string, RuntimeFields, RuntimeFields, RuntimeFields>;
-type AnySquareBoardInput = SquareBoardInput<string, string, string, string, string, RuntimeFields, RuntimeFields, RuntimeFields, RuntimeFields>;
-type BoardIdOf<TBoard> = TBoard extends {
-    id: infer Id extends string;
-} ? Id : string;
-type SpaceRecordValueOf<TBoard> = TBoard extends {
-    spaces: Readonly<Record<string, infer Space>>;
-} ? Space : never;
-type TileValueOf<TBoard> = TBoard extends {
-    tiles: ReadonlyArray<infer Tile>;
-} ? Tile : never;
-type CellValueOf<TBoard> = TBoard extends {
-    cells: ReadonlyArray<infer Cell>;
-} ? Cell : never;
-type EdgeValueOf<TBoard> = TBoard extends {
-    edges: ReadonlyArray<infer Edge>;
-} ? Edge : never;
-type VertexValueOf<TBoard> = TBoard extends {
-    vertices: ReadonlyArray<infer Vertex>;
-} ? Vertex : never;
-type PieceValueOf<TBoard> = TBoard extends {
-    pieces?: ReadonlyArray<infer Piece>;
-} ? Piece : never;
-type BoardSpaceIdOf<TBoard> = SpaceRecordValueOf<TBoard> extends {
-    id: infer Id extends string;
-} ? Id : TileValueOf<TBoard> extends {
-    id: infer Id extends string;
-} ? Id : CellValueOf<TBoard> extends {
-    id: infer Id extends string;
-} ? Id : never;
-type BoardEdgeIdOf<TBoard> = EdgeValueOf<TBoard> extends {
-    id: infer Id extends string;
-} ? Id : never;
-type BoardVertexIdOf<TBoard> = VertexValueOf<TBoard> extends {
-    id: infer Id extends string;
-} ? Id : never;
-type HexTilePropertiesOf<TBoard> = SpaceRecordValueOf<TBoard> extends {
-    fields?: infer Fields;
-} ? Fields : TileValueOf<TBoard> extends {
-    properties?: infer Properties;
-} ? Properties : RuntimeFields;
-type HexTileViewOf<TBoard> = TileValueOf<TBoard> extends {
-    view: infer View;
-} ? View : TileValueOf<TBoard> extends {
-    view?: infer View;
-} ? View | undefined : unknown;
-type HexEdgePropertiesOf<TBoard> = EdgeValueOf<TBoard> extends {
-    fields?: infer Fields;
-} ? Fields : EdgeValueOf<TBoard> extends {
-    properties?: infer Properties;
-} ? Properties : RuntimeFields;
-type HexVertexPropertiesOf<TBoard> = VertexValueOf<TBoard> extends {
-    fields?: infer Fields;
-} ? Fields : VertexValueOf<TBoard> extends {
-    properties?: infer Properties;
-} ? Properties : RuntimeFields;
-type SquareCellPropertiesOf<TBoard> = SpaceRecordValueOf<TBoard> extends {
-    fields?: infer Fields;
-} ? Fields : CellValueOf<TBoard> extends {
-    properties?: infer Properties;
-} ? Properties : RuntimeFields;
-type SquareEdgePropertiesOf<TBoard> = EdgeValueOf<TBoard> extends {
-    fields?: infer Fields;
-} ? Fields : EdgeValueOf<TBoard> extends {
-    properties?: infer Properties;
-} ? Properties : RuntimeFields;
-type SquareVertexPropertiesOf<TBoard> = VertexValueOf<TBoard> extends {
-    fields?: infer Fields;
-} ? Fields : VertexValueOf<TBoard> extends {
-    properties?: infer Properties;
-} ? Properties : RuntimeFields;
-type SquarePiecePropertiesOf<TBoard> = PieceValueOf<TBoard> extends {
-    properties?: infer Properties;
-} ? Properties : RuntimeFields;
-/**
- * Normalized hex tile shape for a given board input.
- *
- * `view` is always present (required) on the result so consumers can
- * read overlay fields without a null-check. For boards that do not
- * statically declare a `view` shape (the generic case), `view` falls
- * back to `unknown`, which still admits any value.
- *
- * The runtime normalizer injects `view: undefined` for inputs that
- * do not author a `view` field, keeping the runtime contract aligned
- * with this static shape.
- */
-type NormalizedHexTileOf<TBoard extends AnyHexBoardInput> = Omit<HexTileState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, HexTilePropertiesOf<TBoard>, HexTileViewOf<TBoard>>, "view"> & {
-    view: HexTileViewOf<TBoard>;
-};
-type NormalizedHexEdgeOf<TBoard extends AnyHexBoardInput> = HexEdgeState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, BoardEdgeIdOf<TBoard>, HexEdgePropertiesOf<TBoard>>;
-type NormalizedHexVertexOf<TBoard extends AnyHexBoardInput> = HexVertexState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, BoardVertexIdOf<TBoard>, HexVertexPropertiesOf<TBoard>>;
-type NormalizedSquareCellOf<TBoard extends AnySquareBoardInput> = SquareCellState<BoardSpaceIdOf<TBoard>, SquareCellPropertiesOf<TBoard>>;
-type NormalizedSquareEdgeOf<TBoard extends AnySquareBoardInput> = SquareEdgeState<BoardSpaceIdOf<TBoard>, BoardEdgeIdOf<TBoard>, SquareEdgePropertiesOf<TBoard>>;
-type NormalizedSquareVertexOf<TBoard extends AnySquareBoardInput> = SquareVertexState<BoardSpaceIdOf<TBoard>, BoardVertexIdOf<TBoard>, SquareVertexPropertiesOf<TBoard>>;
-type NormalizedSquarePieceOf<TBoard extends AnySquareBoardInput> = SquarePieceState<PieceValueOf<TBoard> extends {
-    id: infer PieceIdValue extends string;
-} ? PieceIdValue : string, SquarePiecePropertiesOf<TBoard>>;
-type NormalizedHexBoard<TBoard extends AnyHexBoardInput> = Omit<Pick<HexBoardState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, BoardEdgeIdOf<TBoard>, BoardVertexIdOf<TBoard>, HexTilePropertiesOf<TBoard>, HexEdgePropertiesOf<TBoard>, HexVertexPropertiesOf<TBoard>>, "id" | "tiles" | "edges" | "vertices">, "tiles"> & {
-    tiles: ReadonlyArray<NormalizedHexTileOf<TBoard>>;
-    orientation?: "pointy-top" | "flat-top";
-};
-type NormalizedSquareBoard<TBoard extends AnySquareBoardInput> = Pick<SquareBoardState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, BoardEdgeIdOf<TBoard>, BoardVertexIdOf<TBoard>, PieceValueOf<TBoard> extends {
-    id: infer PieceIdValue extends string;
-} ? PieceIdValue : string, SquareCellPropertiesOf<TBoard>, SquareEdgePropertiesOf<TBoard>, SquareVertexPropertiesOf<TBoard>, SquarePiecePropertiesOf<TBoard>>, "id" | "rows" | "cols" | "cells" | "edges" | "vertices" | "pieces">;
-declare function normalizeHexBoardInput<TBoard extends AnyHexBoardInput>(board: TBoard): NormalizedHexBoard<TBoard>;
-declare function normalizeSquareBoardInput<TBoard extends AnySquareBoardInput>(board: TBoard): NormalizedSquareBoard<TBoard>;
-
-/**
- * Controlled visual state contract for `@dreamboard-games/sdk/ui` components.
- *
- * The SDK is Dreamboard-interaction unaware: components consume `display data`
- * and `controlled semantic states`. Runtime adapters compute these states from
- * descriptors/drafts and pass them in as plain props.
- */
-/**
- * Generic semantic state attached to a presentational component.
- *
- * Every flag is optional and renders as a stable `data-*` attribute on the
- * underlying element so that selectors, snapshot diffs and accessibility
- * announcements can react to state without inspecting class strings.
- */
-interface InteractionVisualState {
-    /** Caller may activate this surface right now. */
-    eligible?: boolean;
-    /**
-     * Eligible *and* a meaningful subset — i.e. at least one peer surface is not
-     * eligible. Use this (rather than `eligible`) to drive a "highlight the
-     * playable cards" affordance: when every card in a hand is a legal target
-     * (e.g. a pass where any card may be chosen, or a turn where you may play
-     * anything) the highlight carries no information, so `distinctlyEligible` is
-     * `false` for all of them and the ring naturally disappears. `eligible`
-     * keeps its literal meaning ("is a legal target") for dimming/logic.
-     */
-    distinctlyEligible?: boolean;
-    /** Currently chosen as part of a draft selection or focus state. */
-    selected?: boolean;
-    /** Surface is non-interactive and visually muted. */
-    disabled?: boolean;
-    /** Caller's draft is invalid — render an error tint without removing the surface. */
-    invalid?: boolean;
-    /** Action has been submitted; render a settled/locked feedback state. */
-    submitted?: boolean;
-    /** Surface is being previewed (long-press, hover hold) without commitment. */
-    previewing?: boolean;
-    /**
-     * Optional 0..1 progress reading for an in-flight UI intent (swipe, hold,
-     * etc.). Components may render this as a fill, scale or halo without owning
-     * the gesture pipeline themselves.
-     */
-    intentProgress?: number;
-}
-/**
- * Generic UI intent emitted by SDK components.
- *
- * Components do not know what `activate`/`drop` mean in Dreamboard terms —
- * that mapping belongs to a runtime adapter. They only emit when a generic
- * pointer/keyboard gesture completes.
- *
- * - `activate` is a single-target commit produced by a desktop click or a
- *   keyboard activation in `direct-activate` mode.
- * - `drop` is a card→target commit produced by mobile drag or keyboard drop
- *   in `drag-to-target` mode. The opaque `targetId` is registered by a
- *   `CardDropTargetView` and resolved against pointer geometry inside the
- *   `CardDragSurface`.
- * - `previewStart`/`previewEnd` bracket a long-press inspection that does
- *   not commit.
- */
-type CardIntent<CardId extends string = string, TargetId extends string = string> = {
-    type: "activate";
-    cardId: CardId;
-    source: "tap" | "keyboard";
-} | {
-    type: "previewStart";
-    cardId: CardId;
-} | {
-    type: "previewEnd";
-    cardId: CardId;
-} | {
-    type: "drop";
-    cardId: CardId;
-    targetId: TargetId;
-    source: "pointer" | "keyboard";
-};
-/**
- * Generic UI intent emitted for a board target (space/edge/vertex).
- */
-type TargetIntent<TargetId extends string = string> = {
-    type: "activate";
-    targetId: TargetId;
-    source: "tap" | "keyboard";
-} | {
-    type: "previewStart";
-    targetId: TargetId;
-} | {
-    type: "previewEnd";
-    targetId: TargetId;
-};
-/**
- * Controlled visual state for a card drop target rendered through
- * `CardDropTargetView`.
- *
- * `active` is `true` when any card is currently being dragged anywhere on
- * the surface (eligible target should advertise itself). `over` is `true`
- * only for the target that the lifted pointer would currently drop on.
- */
-interface CardDropTargetVisualState extends InteractionVisualState {
-    active?: boolean;
-    over?: boolean;
-}
-/**
- * Build the `data-*` attribute bag for an {@link InteractionVisualState} so
- * that components apply a single consistent attribute surface.
- *
- * `undefined` values are emitted (rather than `false`) so that CSS
- * `[data-…="true"]` selectors do not match by mistake.
- */
-declare function visualStateDataAttributes(state: InteractionVisualState | undefined): Readonly<Record<string, string | undefined>>;
-/**
- * Build the `data-*` attribute bag for a {@link CardDropTargetVisualState}.
- */
-declare function dropTargetVisualStateDataAttributes(state: CardDropTargetVisualState | undefined): Readonly<Record<string, string | undefined>>;
-
-type BoardTargetKind = "edge" | "vertex" | "space" | "tile";
-interface InteractiveTargetState {
-    kind?: BoardTargetKind;
-    id: string;
-    eligible: boolean;
-    selectable: boolean;
-    hovered: boolean;
-    pending: boolean;
-    conflict: boolean;
-    unavailableReason?: string;
-    browserAttributes?: Record<string, string | boolean>;
-    select?: () => unknown | Promise<unknown>;
-}
-interface InteractiveTargetLayer {
-    enabled?: boolean;
-    eligible?: ReadonlySet<string>;
-    selectTargetId?: (targetId: string) => unknown | Promise<unknown>;
-    targetState?: (targetId: string) => Partial<InteractiveTargetState>;
-}
-interface InteractiveTargetRenderState extends InteractiveTargetState {
-    isEnabled: boolean;
-    isEligible: boolean;
-    isHovered: boolean;
-}
-
-interface SquareEdgePosition {
-    x1: number;
-    y1: number;
-    x2: number;
-    y2: number;
-    midX: number;
-    midY: number;
-    angle: number;
-}
-interface SquareVertexPosition {
-    x: number;
-    y: number;
-}
-interface InteractiveSquareEdge<TBoard extends AnySquareBoardInput = AnySquareBoardInput> extends NormalizedSquareEdgeOf<TBoard> {
-    position: SquareEdgePosition;
-}
-interface InteractiveSquareVertex<TBoard extends AnySquareBoardInput = AnySquareBoardInput> extends NormalizedSquareVertexOf<TBoard> {
-    position: SquareVertexPosition;
-}
-type InteractiveSquareSpace<TBoard extends AnySquareBoardInput = AnySquareBoardInput> = NormalizedSquareCellOf<TBoard>;
-interface SquareGeneratedGridInputProps {
-    id?: string;
-    layout?: "square";
-    spaces: Extract<AnySquareBoardInput, {
-        spaces: unknown;
-    }>["spaces"];
-    pieces?: AnySquareBoardInput["pieces"];
-    edges?: AnySquareBoardInput["edges"];
-    vertices?: AnySquareBoardInput["vertices"];
-}
-interface SquareAuthoredGridInputProps {
-    id?: string;
-    layout?: "square";
-    rows?: number;
-    cols?: number;
-    cells: Extract<AnySquareBoardInput, {
-        cells: unknown;
-    }>["cells"];
-    pieces?: readonly SquarePieceState[];
-    edges?: AnySquareBoardInput["edges"];
-    vertices?: AnySquareBoardInput["vertices"];
-}
-type SquareGridInputProps = SquareGeneratedGridInputProps | SquareAuthoredGridInputProps;
-type ResolvedSquareArrayProp<Value> = Exclude<Value, undefined> extends readonly unknown[] ? Exclude<Value, undefined> : readonly [];
-type SquareBoardLikeOfProps<TProps extends SquareGridInputProps> = TProps extends {
-    id?: infer Id;
-    layout?: infer Layout;
-    spaces: infer Spaces;
-    pieces?: infer Pieces;
-    edges?: infer Edges;
-    vertices?: infer Vertices;
-} ? {
-    id: Extract<Id, string> extends never ? string : Extract<Id, string>;
-    layout?: Extract<Layout, "square">;
-    spaces: Spaces;
-    pieces: ResolvedSquareArrayProp<Pieces>;
-    edges: ResolvedSquareArrayProp<Edges>;
-    vertices: ResolvedSquareArrayProp<Vertices>;
-} & GeneratedSquareBoardInput : TProps extends {
-    id?: infer Id;
-    layout?: infer Layout;
-    rows?: infer Rows;
-    cols?: infer Cols;
-    cells: infer Cells;
-    pieces?: infer Pieces;
-    edges?: infer Edges;
-    vertices?: infer Vertices;
-} ? {
-    id: Extract<Id, string> extends never ? string : Extract<Id, string>;
-    layout?: Extract<Layout, "square">;
-    rows: Extract<Rows, number> extends never ? number : Extract<Rows, number>;
-    cols: Extract<Cols, number> extends never ? number : Extract<Cols, number>;
-    cells: Cells;
-    pieces: ResolvedSquareArrayProp<Pieces>;
-    edges: ResolvedSquareArrayProp<Edges>;
-    vertices: ResolvedSquareArrayProp<Vertices>;
-} & AuthoredSquareBoardInput : never;
-type SquareGridProps<TProps extends SquareGridInputProps = SquareGridInputProps> = TProps & {
-    cellSize?: number;
-    /** Receives row/col with transform centered at cell position */
-    renderCell: (row: number, col: number) => ReactNode;
-    /** Receives piece with transform centered at cell center */
-    renderPiece: (piece: NormalizedSquarePieceOf<NoInfer<SquareBoardLikeOfProps<TProps>>>) => ReactNode;
-    renderEdge?: (edge: NormalizedSquareEdgeOf<NoInfer<SquareBoardLikeOfProps<TProps>>>, position: SquareEdgePosition) => ReactNode;
-    renderVertex?: (vertex: NormalizedSquareVertexOf<NoInfer<SquareBoardLikeOfProps<TProps>>>, position: SquareVertexPosition) => ReactNode;
-    showCoordinates?: boolean;
-    coordinateStyle?: "algebraic" | "numeric" | "none";
-    width?: number | string;
-    height?: number | string;
-    enablePanZoom?: boolean;
-    initialZoom?: number;
-    minZoom?: number;
-    maxZoom?: number;
-    className?: string;
-    interactiveSpaces?: InteractiveTargetLayer;
-    interactiveEdges?: InteractiveTargetLayer;
-    interactiveVertices?: InteractiveTargetLayer;
-    renderInteractiveSpace?: (space: InteractiveSquareSpace<NoInfer<SquareBoardLikeOfProps<TProps>>>, state: InteractiveTargetRenderState) => ReactNode;
-    renderInteractiveEdge?: (edge: InteractiveSquareEdge<NoInfer<SquareBoardLikeOfProps<TProps>>>, position: SquareEdgePosition, state: InteractiveTargetRenderState) => ReactNode;
-    renderInteractiveVertex?: (vertex: InteractiveSquareVertex<NoInfer<SquareBoardLikeOfProps<TProps>>>, position: SquareVertexPosition, state: InteractiveTargetRenderState) => ReactNode;
-};
-interface SquareGridBoardProps<TBoard extends AnySquareBoardInput = AnySquareBoardInput> {
-    board: TBoard;
-    cellSize?: number;
-    renderCell: (row: number, col: number) => ReactNode;
-    renderPiece: (piece: NormalizedSquarePieceOf<NoInfer<TBoard>>) => ReactNode;
-    renderEdge?: (edge: NormalizedSquareEdgeOf<NoInfer<TBoard>>, position: SquareEdgePosition) => ReactNode;
-    renderVertex?: (vertex: NormalizedSquareVertexOf<NoInfer<TBoard>>, position: SquareVertexPosition) => ReactNode;
-    showCoordinates?: boolean;
-    coordinateStyle?: "algebraic" | "numeric" | "none";
-    width?: number | string;
-    height?: number | string;
-    enablePanZoom?: boolean;
-    initialZoom?: number;
-    minZoom?: number;
-    maxZoom?: number;
-    className?: string;
-    interactiveSpaces?: InteractiveTargetLayer;
-    interactiveEdges?: InteractiveTargetLayer;
-    interactiveVertices?: InteractiveTargetLayer;
-    renderInteractiveSpace?: (space: InteractiveSquareSpace<NoInfer<TBoard>>, state: InteractiveTargetRenderState) => ReactNode;
-    renderInteractiveEdge?: (edge: InteractiveSquareEdge<NoInfer<TBoard>>, position: SquareEdgePosition, state: InteractiveTargetRenderState) => ReactNode;
-    renderInteractiveVertex?: (vertex: InteractiveSquareVertex<NoInfer<TBoard>>, position: SquareVertexPosition, state: InteractiveTargetRenderState) => ReactNode;
-}
-interface DefaultGridCellProps {
-    size: number;
-    isLight?: boolean;
-    lightColor?: string;
-    darkColor?: string;
-    isHighlighted?: boolean;
-    highlightColor?: string;
-    isSelected?: boolean;
-    selectedColor?: string;
-    isValidMove?: boolean;
-    isCapture?: boolean;
-    onClick?: () => void;
-    onPointerEnter?: () => void;
-    onPointerLeave?: () => void;
-    className?: string;
-}
-/** Pre-built grid cell component for use in `renderCell`. */
-declare function DefaultGridCell({ size, isLight, lightColor, darkColor, isHighlighted, highlightColor, isSelected, selectedColor, isValidMove, isCapture, onClick, onPointerEnter, onPointerLeave, className, }: DefaultGridCellProps): react_jsx_runtime.JSX.Element;
-interface DefaultGridPieceProps {
-    size: number;
-    color?: string;
-    strokeColor?: string;
-    label?: string;
-    isDragging?: boolean;
-    onClick?: () => void;
-    onPointerDown?: (e: React.PointerEvent) => void;
-    className?: string;
-}
-/** Pre-built grid piece component for use in `renderPiece`. */
-declare function DefaultGridPiece({ size, color, strokeColor, label, isDragging, onClick, onPointerDown, className, }: DefaultGridPieceProps): react_jsx_runtime.JSX.Element;
-interface DefaultChessPieceProps {
-    size: number;
-    type: string;
-    owner: "white" | "black";
-    onClick?: () => void;
-    onPointerDown?: (e: React.PointerEvent) => void;
-    className?: string;
-}
-/** Pre-built chess piece component using Unicode symbols. */
-declare function DefaultChessPiece({ size, type, owner, onClick, onPointerDown, className, }: DefaultChessPieceProps): react_jsx_runtime.JSX.Element;
-/**
- * Convert row/col to algebraic notation (a1, b2, etc.)
- */
-declare function toAlgebraic(row: number, col: number, totalRows: number): string;
-/**
- * Convert row/col to numeric notation (1,1, 2,3, etc.)
- */
-declare function toNumeric(row: number, col: number): string;
-interface SquareGridComponent {
-    <const TBoard extends AnySquareBoardInput>(props: SquareGridBoardProps<TBoard>): ReactNode;
-    <const TProps extends SquareGeneratedGridInputProps>(props: SquareGridProps<TProps>): ReactNode;
-    <const TProps extends SquareAuthoredGridInputProps>(props: SquareGridProps<TProps>): ReactNode;
-}
-declare const SquareGrid: SquareGridComponent;
-
-type HexOrientation = "pointy-top" | "flat-top";
-/**
- * Geometry context passed to `renderTile`.
- *
- * `corners`, `points`, and `bounds` are expressed in tile-local
- * coordinates because each tile is rendered inside a `<g>` translated
- * to its center. Use `position` if you need the resolved center in the
- * board's absolute SVG coordinates.
- *
- * The `inset` option shrinks the polygon toward the center by that many
- * pixels, which is useful for layered effects such as borders, frames,
- * or inner highlights without re-deriving the hex math yourself.
- */
-interface HexTileGeometry {
-    size: number;
-    orientation: HexOrientation;
-    center: {
-        x: 0;
-        y: 0;
-    };
-    position: {
-        x: number;
-        y: number;
-    };
-    corners: (options?: {
-        inset?: number;
-    }) => Array<{
-        x: number;
-        y: number;
-    }>;
-    points: (options?: {
-        inset?: number;
-    }) => string;
-    bounds: {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-        width: number;
-        height: number;
-    };
-}
-interface EdgePosition {
-    /** Absolute SVG start point of the visible edge line. */
-    x1: number;
-    y1: number;
-    /** Absolute SVG end point of the visible edge line. */
-    x2: number;
-    y2: number;
-    /** Absolute SVG midpoint of the edge. */
-    midX: number;
-    midY: number;
-    /**
-     * Angle in degrees from hex1 center to hex2 center.
-     * This is perpendicular to the visible edge line.
-     */
-    centerAngle: number;
-    /** Angle in degrees of the visible edge line itself. */
-    edgeAngle: number;
-}
-interface InteractiveHexVertex<TBoard extends AnyHexBoardInput = AnyHexBoardInput> extends NormalizedHexVertexOf<TBoard> {
-    position: {
-        x: number;
-        y: number;
-    };
-    spaceIds: ReadonlyArray<BoardSpaceIdOf<TBoard>>;
-}
-interface InteractiveHexEdge<TBoard extends AnyHexBoardInput = AnyHexBoardInput> extends NormalizedHexEdgeOf<TBoard> {
-    position: EdgePosition;
-    spaceIds: ReadonlyArray<BoardSpaceIdOf<TBoard>>;
-}
-type InteractiveHexSpace<TBoard extends AnyHexBoardInput = AnyHexBoardInput> = NormalizedHexTileOf<TBoard>;
-interface HexGeneratedGridInputProps {
-    id?: string;
-    layout?: "hex";
-    orientation?: HexOrientation;
-    spaces: Extract<AnyHexBoardInput, {
-        spaces: unknown;
-    }>["spaces"];
-    edges?: AnyHexBoardInput["edges"];
-    vertices?: AnyHexBoardInput["vertices"];
-}
-interface HexAuthoredGridInputProps {
-    id?: string;
-    layout?: "hex";
-    orientation?: HexOrientation;
-    tiles: Extract<AnyHexBoardInput, {
-        tiles: unknown;
-    }>["tiles"];
-    edges?: AnyHexBoardInput["edges"];
-    vertices?: AnyHexBoardInput["vertices"];
-}
-type HexGridInputProps = HexGeneratedGridInputProps | HexAuthoredGridInputProps;
-type ResolvedArrayProp<Value> = Exclude<Value, undefined> extends readonly unknown[] ? Exclude<Value, undefined> : readonly [];
-type HexBoardLikeOfProps<TProps extends HexGridInputProps> = TProps extends {
-    id?: infer Id;
-    layout?: infer Layout;
-    orientation?: infer Orientation;
-    spaces: infer Spaces;
-    edges?: infer Edges;
-    vertices?: infer Vertices;
-} ? {
-    id: Extract<Id, string> extends never ? string : Extract<Id, string>;
-    layout?: Extract<Layout, "hex">;
-    orientation?: Extract<Orientation, HexOrientation>;
-    spaces: Spaces;
-    edges: ResolvedArrayProp<Edges>;
-    vertices: ResolvedArrayProp<Vertices>;
-} & GeneratedHexBoardInput : TProps extends {
-    id?: infer Id;
-    layout?: infer Layout;
-    orientation?: infer Orientation;
-    tiles: infer Tiles;
-    edges?: infer Edges;
-    vertices?: infer Vertices;
-} ? {
-    id: Extract<Id, string> extends never ? string : Extract<Id, string>;
-    layout?: Extract<Layout, "hex">;
-    orientation?: Extract<Orientation, HexOrientation>;
-    tiles: Tiles;
-    edges: ResolvedArrayProp<Edges>;
-    vertices: ResolvedArrayProp<Vertices>;
-} & AuthoredHexBoardInput : never;
-type HexGridProps<TProps extends HexGridInputProps = HexGridInputProps> = TProps & {
-    orientation?: HexOrientation;
-    /** Hex radius in pixels */
-    hexSize?: number;
-    /**
-     * Receives tile data centered at (0,0) plus a `HexTileGeometry`
-     * helper. Use `geometry.points({ inset })` to draw custom polygons
-     * without duplicating `hexSize` / orientation in the consumer.
-     */
-    renderTile: (tile: NormalizedHexTileOf<NoInfer<HexBoardLikeOfProps<TProps>>>, geometry: HexTileGeometry) => ReactNode;
-    /**
-     * Receives edge geometry in absolute SVG coordinates.
-     * Use `position.edgeAngle` to align artwork with the visible edge.
-     */
-    renderEdge: (edge: NormalizedHexEdgeOf<NoInfer<HexBoardLikeOfProps<TProps>>>, position: EdgePosition) => ReactNode;
-    renderVertex: (vertex: NormalizedHexVertexOf<NoInfer<HexBoardLikeOfProps<TProps>>>, position: {
-        x: number;
-        y: number;
-    }) => ReactNode;
-    width?: number | string;
-    height?: number | string;
-    enablePanZoom?: boolean;
-    initialZoom?: number;
-    minZoom?: number;
-    maxZoom?: number;
-    className?: string;
-    /** Reducer-aware space target layer from `board.targetLayers.space(...)`. */
-    interactiveSpaces?: InteractiveTargetLayer;
-    /** Reducer-aware vertex target layer from `board.targetLayers.vertex(...)`. */
-    interactiveVertices?: InteractiveTargetLayer;
-    /** Reducer-aware edge target layer from `board.targetLayers.edge(...)`. */
-    interactiveEdges?: InteractiveTargetLayer;
-    /** Receives space geometry centered at (0,0). */
-    renderInteractiveSpace?: (space: InteractiveHexSpace<NoInfer<HexBoardLikeOfProps<TProps>>>, state: InteractiveTargetRenderState) => ReactNode;
-    /**
-     * Receives vertex geometry in absolute SVG coordinates.
-     */
-    renderInteractiveVertex?: (vertex: InteractiveHexVertex<NoInfer<HexBoardLikeOfProps<TProps>>>, position: {
-        x: number;
-        y: number;
-    }, state: InteractiveTargetRenderState) => ReactNode;
-    /**
-     * Receives edge geometry in the same absolute SVG coordinates as `renderEdge`.
-     */
-    renderInteractiveEdge?: (edge: InteractiveHexEdge<NoInfer<HexBoardLikeOfProps<TProps>>>, position: EdgePosition, state: InteractiveTargetRenderState) => ReactNode;
-    interactiveVertexSize?: number;
-    interactiveEdgeSize?: number;
-};
-interface HexGridBoardProps<TBoard extends AnyHexBoardInput = AnyHexBoardInput> {
-    board: TBoard;
-    orientation?: HexOrientation;
-    hexSize?: number;
-    /**
-     * Receives tile data centered at (0,0) plus a `HexTileGeometry`
-     * helper. Use `geometry.points({ inset })` to draw custom polygons
-     * without duplicating `hexSize` / orientation in the consumer.
-     */
-    renderTile: (tile: NormalizedHexTileOf<NoInfer<TBoard>>, geometry: HexTileGeometry) => ReactNode;
-    /**
-     * Receives edge geometry in absolute SVG coordinates.
-     * Use `position.edgeAngle` to align artwork with the visible edge.
-     */
-    renderEdge: (edge: NormalizedHexEdgeOf<NoInfer<TBoard>>, position: EdgePosition) => ReactNode;
-    renderVertex: (vertex: NormalizedHexVertexOf<NoInfer<TBoard>>, position: {
-        x: number;
-        y: number;
-    }) => ReactNode;
-    width?: number | string;
-    height?: number | string;
-    enablePanZoom?: boolean;
-    initialZoom?: number;
-    minZoom?: number;
-    maxZoom?: number;
-    className?: string;
-    interactiveSpaces?: InteractiveTargetLayer;
-    interactiveVertices?: InteractiveTargetLayer;
-    interactiveEdges?: InteractiveTargetLayer;
-    /** Receives space geometry centered at (0,0). */
-    renderInteractiveSpace?: (space: InteractiveHexSpace<NoInfer<TBoard>>, state: InteractiveTargetRenderState) => ReactNode;
-    /**
-     * Receives vertex geometry in absolute SVG coordinates.
-     */
-    renderInteractiveVertex?: (vertex: InteractiveHexVertex<NoInfer<TBoard>>, position: {
-        x: number;
-        y: number;
-    }, state: InteractiveTargetRenderState) => ReactNode;
-    /**
-     * Receives edge geometry in the same absolute SVG coordinates as `renderEdge`.
-     */
-    renderInteractiveEdge?: (edge: InteractiveHexEdge<NoInfer<TBoard>>, position: EdgePosition, state: InteractiveTargetRenderState) => ReactNode;
-    interactiveVertexSize?: number;
-    interactiveEdgeSize?: number;
-}
-interface DefaultHexTileProps {
-    /** Should match hexSize from HexGrid */
-    size: number;
-    fill: string;
-    stroke?: string;
-    strokeWidth?: number;
-    isSelected?: boolean;
-    isHighlighted?: boolean;
-    label?: string;
-    showCoordinates?: boolean;
-    coordinates?: {
-        q: number;
-        r: number;
-    };
-    orientation?: HexOrientation;
-    onClick?: () => void;
-    onPointerEnter?: () => void;
-    onPointerLeave?: () => void;
-    className?: string;
-}
-/** Pre-built hexagon tile for use in `renderTile`. */
-declare function DefaultHexTile({ size, fill, stroke, strokeWidth, isSelected, isHighlighted, label, showCoordinates, coordinates, orientation, onClick, onPointerEnter, onPointerLeave, className, }: DefaultHexTileProps): react_jsx_runtime.JSX.Element;
-interface DefaultHexEdgeProps {
-    position: EdgePosition;
-    color: string;
-    hasOwner?: boolean;
-    strokeWidth?: number;
-    touchTargetSize?: number;
-    onClick?: () => void;
-    className?: string;
-}
-/** Pre-built edge/road component for use in `renderEdge`. */
-declare function DefaultHexEdge({ position, color, hasOwner, strokeWidth, touchTargetSize, onClick, className, }: DefaultHexEdgeProps): react_jsx_runtime.JSX.Element;
-interface DefaultHexVertexProps {
-    position: {
-        x: number;
-        y: number;
-    };
-    color: string;
-    stroke?: string;
-    strokeWidth?: number;
-    hasOwner?: boolean;
-    isSelected?: boolean;
-    isHighlighted?: boolean;
-    size?: number;
-    touchTargetSize?: number;
-    shape?: "circle" | "square";
-    onClick?: () => void;
-    onPointerEnter?: () => void;
-    onPointerLeave?: () => void;
-    className?: string;
-}
-/** Pre-built vertex/settlement component for use in `renderVertex`. */
-declare function DefaultHexVertex({ position, color, stroke, strokeWidth, hasOwner, isSelected, isHighlighted, size, touchTargetSize, shape, onClick, onPointerEnter, onPointerLeave, className, }: DefaultHexVertexProps): react_jsx_runtime.JSX.Element;
-declare const hexUtils: {
-    /** Convert axial coordinates to pixel position. */
-    axialToPixel(q: number, r: number, size: number, orientation: HexOrientation): {
-        x: number;
-        y: number;
-    };
-    getNeighbors(q: number, r: number): Array<{
-        q: number;
-        r: number;
-    }>;
-    getDistance(q1: number, r1: number, q2: number, r2: number): number;
-    getHexCorners(centerX: number, centerY: number, size: number, orientation: HexOrientation): Array<{
-        x: number;
-        y: number;
-    }>;
-    getHexPoints(centerX: number, centerY: number, size: number, orientation: HexOrientation): string;
-    getEdgePosition(hex1Pos: {
-        x: number;
-        y: number;
-    }, hex2Pos: {
-        x: number;
-        y: number;
-    }, size: number): EdgePosition;
-    getVertexPosition(hex1Pos: {
-        x: number;
-        y: number;
-    }, hex2Pos: {
-        x: number;
-        y: number;
-    }, hex3Pos: {
-        x: number;
-        y: number;
-    }): {
-        x: number;
-        y: number;
-    };
-};
-interface HexGridComponent {
-    <const TBoard extends AnyHexBoardInput>(props: HexGridBoardProps<TBoard>): ReactNode;
-    <const TProps extends HexGeneratedGridInputProps>(props: HexGridProps<TProps>): ReactNode;
-    <const TProps extends HexAuthoredGridInputProps>(props: HexGridProps<TProps>): ReactNode;
-}
-declare const HexGrid: HexGridComponent;
-
-/**
- * Typed adapter for joining static hex-board topology with a dynamic
- * per-space view overlay. Use this to feed `HexGrid` a single board
- * value whose tiles carry both static geometry (`q`, `r`, `id`) and
- * the projected view fields the UI cares about (e.g. `terrain`,
- * `numberToken`).
- *
- * The runtime is intentionally strict: every static space must have
- * exactly one overlay, duplicates throw, and overlays for ids that
- * are not on the board throw. There is no relaxed fallback in v1 —
- * silent merge bugs are far more expensive than a loud throw at
- * dev/CI time.
- */
-
-/**
- * Per-tile result produced by {@link createHexBoardView}. Each tile
- * carries the static topology (`id`, `q`, `r`) plus the matched
- * overlay row in `view`.
- *
- * Static board fields/properties are preserved from `TBoard`.
- * Consumers should use `tile.properties` for authored static space
- * fields and `tile.view` for dynamic per-space projection data.
- */
-type HexBoardViewTile<TBoard extends AnyHexBoardInput, TSpaceView extends {
-    id: BoardSpaceIdOf<TBoard>;
-}> = Omit<NormalizedHexTileOf<TBoard>, "view"> & {
-    view: TSpaceView;
-};
-/**
- * Result of {@link createHexBoardView}. Shaped like an authored hex
- * board so it can be passed straight to `<HexGrid board={...} />`
- * without any further adapter work.
- *
- * The type-level board id and space id are preserved from `TBoard`,
- * so `tile.id` stays narrow inside `renderTile`. `tile.view` is the
- * authored overlay row, fully typed.
- */
-interface HexBoardView<TBoard extends AnyHexBoardInput, TSpaceView extends {
-    id: BoardSpaceIdOf<TBoard>;
-}> {
-    id: BoardIdOf<TBoard>;
-    layout?: "hex";
-    orientation?: "pointy-top" | "flat-top";
-    tiles: ReadonlyArray<HexBoardViewTile<TBoard, TSpaceView>>;
-    edges: TBoard["edges"];
-    vertices: TBoard["vertices"];
-}
-interface CreateHexBoardViewOptions<TSpaceView> {
-    spaces: readonly TSpaceView[];
-}
-/**
- * Join a static hex board topology with a dynamic per-space overlay.
- *
- * The result is suitable for direct use as the `board` prop on
- * `<HexGrid>`. Every overlay is enforced 1-to-1 against the board's
- * spaces:
- *
- *  - missing overlay for a board space → throws
- *  - duplicate overlay (same `id` twice) → throws
- *  - overlay `id` not present on the board → throws
- *
- * Each tile in the result carries a `view` field with the matched
- * overlay row.
- */
-declare function createHexBoardView<const TBoard extends AnyHexBoardInput, const TSpaceView extends {
-    id: BoardSpaceIdOf<TBoard>;
-}>(board: TBoard, options: CreateHexBoardViewOptions<TSpaceView>): HexBoardView<TBoard, TSpaceView>;
-
-export { type NormalizedHexVertexOf as $, type AnyHexBoardInput as A, type BoardEdgeIdOf as B, type CardDropTargetVisualState as C, DefaultChessPiece as D, type EdgePosition as E, type FoundationColor as F, type GeneratedHexBoardInput as G, type HexBoardInput as H, type HexBoardViewTile as I, HexGrid as J, type HexGridBoardProps as K, type HexGridProps as L, type HexOrientation as M, type HexTileGeometry as N, type IntentColor as O, type InteractionVisualState as P, type InteractiveHexEdge as Q, type InteractiveHexVertex as R, type InteractiveSquareEdge as S, type InteractiveSquareVertex as T, type InteractiveTargetLayer as U, type InteractiveTargetRenderState as V, type InteractiveTargetState as W, type Motion as X, type NormalizedHexBoard as Y, type NormalizedHexEdgeOf as Z, type NormalizedHexTileOf as _, type AnySquareBoardInput as a, type NormalizedSquareBoard as a0, type NormalizedSquareCellOf as a1, type NormalizedSquareEdgeOf as a2, type NormalizedSquarePieceOf as a3, type NormalizedSquareVertexOf as a4, type PlayerColor as a5, type Radius as a6, type SemanticColor as a7, type Space as a8, type SquareBoardInput as a9, type SquareEdgePosition as aa, SquareGrid as ab, type SquareGridBoardProps as ac, type SquareGridProps as ad, type SquareVertexPosition as ae, type TargetIntent as af, type Theme as ag, type ThemeMeta as ah, type ThemeOverride as ai, type Typography as aj, createHexBoardView as ak, dropTargetVisualStateDataAttributes as al, hexUtils as am, mergeTheme as an, normalizeHexBoardInput as ao, normalizeSquareBoardInput as ap, toAlgebraic as aq, toNumeric as ar, visualStateDataAttributes as as, type AuthoredHexBoardInput as b, type AuthoredSquareBoardInput as c, type BoardSpaceIdOf as d, type BoardVertexIdOf as e, type CardIntent as f, type ColorRamp as g, type ComponentTokens as h, type DefaultChessPieceProps as i, DefaultGridCell as j, type DefaultGridCellProps as k, DefaultGridPiece as l, type DefaultGridPieceProps as m, DefaultHexEdge as n, type DefaultHexEdgeProps as o, DefaultHexTile as p, type DefaultHexTileProps as q, DefaultHexVertex as r, type DefaultHexVertexProps as s, type Elevation as t, type GeneratedHexSpaceStateLike as u, type GeneratedSquareBoardInput as v, type GeneratedSquareSpaceStateLike as w, type GeneratedTiledEdgeStateLike as x, type GeneratedTiledVertexStateLike as y, type HexBoardView as z };