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

package/dist/{components-B7hFaEn_.d.ts → components-BTwSIjXj.d.ts}

@@ -1,16 +1,18 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ViewCard, ViewSlotOccupant } from './types.js';
-import { a3 as Theme, I as IntentColor, Z as PlayerColor, J as InteractionVisualState, f as CardIntent, C as CardDropTargetVisualState, a as AnySquareBoardInput, W as NormalizedSquareEdgeOf, Y as NormalizedSquareVertexOf, X as NormalizedSquarePieceOf, M as InteractiveTargetLayer, V as NormalizedSquareCellOf, N as InteractiveTargetRenderState, p as GeneratedSquareBoardInput, c as AuthoredSquareBoardInput } from './hex-board-view-BFlWDb9k.js';
+import { ag as Theme, O as IntentColor, a5 as PlayerColor, P as InteractionVisualState, f as CardIntent, C as CardDropTargetVisualState } from './hex-board-view-aKkblDp6.js';
 import * as react from 'react';
 import { ReactNode, CSSProperties, RefObject, Component, ErrorInfo, ComponentType, ButtonHTMLAttributes, ElementType, ComponentProps, HTMLAttributes } from 'react';
-import './HandView-x8MhbhFl.js';
+import './HandView-Bi2lxzQP.js';
 import { Transition } from 'framer-motion';
 import './ResourceCounter-BFxJknqp.js';
 import { Drawer as Drawer$1 } from 'vaul';
 import * as DialogPrimitive from '@radix-ui/react-dialog';
 import * as LabelPrimitive from '@radix-ui/react-label';
 import * as SelectPrimitive from '@radix-ui/react-select';
-import { A as SquarePieceState } from './player-state-Cqpyeql0.js';
+import { U as GameOutcome, al as OutcomeStanding } from './runtime-Dkfm1x2r.js';
+import { P as ProjectedGameEvent, S as SystemActionEvent } from './plugin-state-BRH3UiUp.js';
+import './player-state-Cqpyeql0.js';
 
 interface TrackSpace<SpaceIdValue extends string = string, Data = unknown> {
     id: SpaceIdValue;
@@ -975,32 +977,80 @@ interface PhaseIndicatorProps {
 }
 declare function PhaseIndicator({ currentPhase, phaseLabels, isMyTurn, activePlayerNames, variant, className, }: PhaseIndicatorProps): react_jsx_runtime.JSX.Element;
 
-/**
- * End-of-game winner display and scoreboard overlay.
- *
- * Visual styling derives entirely from the active {@link useTheme}
- * (semantic + intent + elevation tokens). The win moment is the
- * Peak-end anchor of the session, so the surface intentionally pushes
- * the loudest theme signals (display typeface, primary intent,
- * elevation.overlay) without inventing one-off colours.
- */
-interface PlayerScore {
-    playerId: string;
-    name: string;
-    score: number;
-    isWinner?: boolean;
-    details?: Record<string, number>;
-}
-interface GameEndDisplayProps {
-    isGameOver: boolean;
-    /** Sorted by rank */
-    scores: PlayerScore[];
-    winnerMessage?: string;
-    showDetails?: boolean;
+interface GuidancePhase {
+    id: string;
+    label: string;
+    summary?: ReactNode;
+    objective?: ReactNode;
+}
+interface GuidanceSetupStep {
+    id: string;
+    label: ReactNode;
+    description?: ReactNode;
+}
+interface SetupGuidance {
+    profileId: string;
+    name: ReactNode;
+    summary?: ReactNode;
+    steps: readonly GuidanceSetupStep[];
+}
+interface GuidanceAction {
+    label: ReactNode;
+    help?: ReactNode;
+    unavailableReason?: ReactNode;
+}
+interface GuidancePanelProps {
+    phase: GuidancePhase;
+    actions?: readonly GuidanceAction[];
+    className?: string;
+    style?: CSSProperties;
+}
+interface SetupChecklistProps {
+    guidance?: SetupGuidance | null;
+    completedStepIds?: readonly string[];
+    className?: string;
+    style?: CSSProperties;
+}
+interface ActionHelpProps {
+    label: ReactNode;
+    help?: ReactNode;
+    unavailableReason?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+declare function GuidancePanel({ phase, actions, className, style, }: GuidancePanelProps): react_jsx_runtime.JSX.Element;
+declare function SetupChecklist({ guidance, completedStepIds, className, style, }: SetupChecklistProps): react_jsx_runtime.JSX.Element | null;
+declare function ActionHelp({ label, help, unavailableReason, className, style, }: ActionHelpProps): react_jsx_runtime.JSX.Element;
+
+interface StandingsTableProps<PlayerId extends string = string> {
+    rows: readonly OutcomeStanding<PlayerId>[];
+    playerName: (playerId: PlayerId) => ReactNode;
+    provisional?: boolean;
+    className?: string;
+}
+interface OutcomeDialogProps<PlayerId extends string = string> {
+    outcome?: GameOutcome<PlayerId> | null;
+    playerName: (playerId: PlayerId) => ReactNode;
     onReturnToLobby?: () => void;
     className?: string;
 }
-declare function GameEndDisplay({ isGameOver, scores, winnerMessage, showDetails, onReturnToLobby, className, }: GameEndDisplayProps): react_jsx_runtime.JSX.Element | null;
+declare function StandingsTable<PlayerId extends string = string>({ rows, playerName, provisional, className, }: StandingsTableProps<PlayerId>): react_jsx_runtime.JSX.Element;
+declare function OutcomeDialog<PlayerId extends string = string>({ outcome, playerName, onReturnToLobby, className, }: OutcomeDialogProps<PlayerId>): react_jsx_runtime.JSX.Element | null;
+
+interface SystemActionSummaryProps {
+    event: SystemActionEvent;
+    className?: string;
+    style?: CSSProperties;
+}
+interface GameEventLogProps {
+    events: readonly ProjectedGameEvent[];
+    empty?: ReactNode;
+    maxVisible?: number;
+    className?: string;
+    style?: CSSProperties;
+}
+declare function SystemActionSummary({ event, className, style, }: SystemActionSummaryProps): react_jsx_runtime.JSX.Element;
+declare function GameEventLog({ events, empty, maxVisible, className, style, }: GameEventLogProps): react_jsx_runtime.JSX.Element;
 
 interface NetworkNode {
     id: string;
@@ -1247,183 +1297,4 @@ interface DefaultEmptySlotProps {
 declare function DefaultEmptySlot({ size, className, }: DefaultEmptySlotProps): react_jsx_runtime.JSX.Element;
 declare function SlotSystem({ slots, occupants, renderSlot, layout, width, height, minSlotWidth, className, }: SlotSystemProps): react_jsx_runtime.JSX.Element;
 
-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;
-
-export { Dialog as $, ActionButton as A, type ButtonSize$1 as B, CardDragSurface as C, DefaultChessPiece as D, type DefaultNetworkEdgeProps as E, DefaultNetworkNode as F, type DefaultNetworkNodeProps as G, DefaultNetworkPiece as H, type DefaultNetworkPieceProps as I, DefaultSlotItem as J, type DefaultSlotItemProps as K, DefaultSlotOccupant as L, type DefaultSlotOccupantProps as M, DefaultTrackConnection as N, type DefaultTrackConnectionProps as O, DefaultTrackJump as P, type DefaultTrackJumpProps as Q, DefaultTrackPiece as R, type DefaultTrackPieceProps as S, DefaultTrackSpace as T, type DefaultTrackSpaceProps as U, DefaultZone as V, DefaultZonePiece as W, type DefaultZonePieceProps as X, DefaultZonePieces as Y, type DefaultZonePiecesProps as Z, type DefaultZoneProps as _, type ActionButtonProps as a, type PlayAreaProps as a$, DialogClose as a0, DialogContent as a1, DialogDescription as a2, DialogFooter as a3, DialogHeader as a4, DialogOverlay as a5, DialogPortal as a6, DialogTitle as a7, DialogTrigger as a8, DiceRoller as a9, type HandProps as aA, Input as aB, type InteractiveSquareEdge as aC, type InteractiveSquareVertex as aD, Label as aE, MoreActions as aF, type MoreActionsProps as aG, type NetworkEdge as aH, NetworkGraph as aI, type NetworkGraphProps as aJ, type NetworkNode as aK, type NetworkPiece as aL, Panel as aM, PanelActions as aN, PanelBody as aO, PanelDescription as aP, type PanelDescriptionProps as aQ, PanelHeader as aR, type PanelPartProps as aS, PanelRoot as aT, type PanelRootProps as aU, PanelTitle as aV, type PanelTitleProps as aW, type PanelTone as aX, PhaseIndicator as aY, type PhaseIndicatorProps as aZ, PlayArea as a_, type DiceRollerProps as aa, type DragPhase as ab, Drawer as ac, DrawerClose as ad, DrawerContent as ae, DrawerDescription as af, DrawerFooter as ag, DrawerHeader as ah, DrawerOverlay as ai, DrawerPortal as aj, DrawerTitle as ak, DrawerTrigger as al, ErrorBoundary as am, type ErrorBoundaryProps as an, GameEndDisplay as ao, type GameEndDisplayProps as ap, GameSkeleton as aq, type GameSkeletonProps as ar, Hand as as, HandDock as at, type HandDockMode as au, type HandDockPlacement as av, type HandDockPresentation as aw, type HandDockProps as ax, type HandDockToggleContext as ay, type HandLayout as az, ActionGroup as b, type PlayerScore as b0, type PrimaryActionAttention as b1, PrimaryActionButton as b2, type PrimaryActionButtonProps as b3, PrimaryButton as b4, type PrimaryButtonProps as b5, type ResourceDefinition as b6, Select as b7, SelectContent as b8, SelectItem as b9, type UseHandLayoutReturn as bA, type ZoneDefinition as bB, type ZoneHighlightType as bC, ZoneMap as bD, type ZoneMapProps as bE, type ZonePiece as bF, type ZoneShape as bG, buttonStyle as bH, chipStyle as bI, intentForVariant as bJ, motionDuration as bK, playerColor as bL, surfaceStyle as bM, toAlgebraic as bN, toNumeric as bO, useCardDragSurface as bP, useChromeSuppression as bQ, SelectTrigger as ba, type SlotDefinition as bb, type SlotOccupant as bc, SlotSystem as bd, type SlotSystemProps as be, type SquareEdgePosition as bf, SquareGrid as bg, type SquareGridBoardProps as bh, type SquareGridProps as bi, type SquareVertexPosition as bj, StagingZone as bk, type StagingZoneProps as bl, ThemedButton as bm, type ThemedButtonProps as bn, Toast as bo, ToastActions as bp, type ToastActionsProps as bq, type ToastActionsValue as br, type ToastNotification as bs, ToastProvider as bt, type ToastType as bu, TrackBoard as bv, type TrackBoardProps as bw, type TrackPiece as bx, type TrackSpace as by, type UseHandLayoutOptions as bz, type ActionGroupProps as c, ActionPanel as d, type ActionPanelProps as e, type ButtonVariant$1 as f, type CardDragSurfaceContextValue as g, type CardDragSurfaceController as h, type CardDragSurfaceProps as i, CardDropTargetView as j, type CardDropTargetViewProps as k, CardFace as l, type CardFaceProps as m, type CardPositionProps as n, type CardSize as o, ChromeSuppressionProvider as p, CostDisplay as q, type CostDisplayProps as r, type DefaultChessPieceProps as s, DefaultEmptySlot as t, type DefaultEmptySlotProps as u, DefaultGridCell as v, type DefaultGridCellProps as w, DefaultGridPiece as x, type DefaultGridPieceProps as y, DefaultNetworkEdge as z };
+export { DialogFooter as $, ActionButton as A, type ButtonSize$1 as B, CardDragSurface as C, DefaultEmptySlot as D, type DefaultNetworkPieceProps as E, DefaultSlotItem as F, type DefaultSlotItemProps as G, DefaultSlotOccupant as H, type DefaultSlotOccupantProps as I, DefaultTrackConnection as J, type DefaultTrackConnectionProps as K, DefaultTrackJump as L, type DefaultTrackJumpProps as M, DefaultTrackPiece as N, type DefaultTrackPieceProps as O, DefaultTrackSpace as P, type DefaultTrackSpaceProps as Q, DefaultZone as R, DefaultZonePiece as S, type DefaultZonePieceProps as T, DefaultZonePieces as U, type DefaultZonePiecesProps as V, type DefaultZoneProps as W, Dialog as X, DialogClose as Y, DialogContent as Z, DialogDescription as _, type ActionButtonProps as a, PlayArea as a$, DialogHeader as a0, DialogOverlay as a1, DialogPortal as a2, DialogTitle as a3, DialogTrigger as a4, DiceRoller as a5, type DiceRollerProps as a6, type DragPhase as a7, Drawer as a8, DrawerClose as a9, type HandLayout as aA, type HandProps as aB, Input as aC, Label as aD, MoreActions as aE, type MoreActionsProps as aF, type NetworkEdge as aG, NetworkGraph as aH, type NetworkGraphProps as aI, type NetworkNode as aJ, type NetworkPiece as aK, OutcomeDialog as aL, type OutcomeDialogProps as aM, Panel as aN, PanelActions as aO, PanelBody as aP, PanelDescription as aQ, type PanelDescriptionProps as aR, PanelHeader as aS, type PanelPartProps as aT, PanelRoot as aU, type PanelRootProps as aV, PanelTitle as aW, type PanelTitleProps as aX, type PanelTone as aY, PhaseIndicator as aZ, type PhaseIndicatorProps as a_, DrawerContent as aa, DrawerDescription as ab, DrawerFooter as ac, DrawerHeader as ad, DrawerOverlay as ae, DrawerPortal as af, DrawerTitle as ag, DrawerTrigger as ah, ErrorBoundary as ai, type ErrorBoundaryProps as aj, GameEventLog as ak, type GameEventLogProps as al, GameSkeleton as am, type GameSkeletonProps as an, type GuidanceAction as ao, GuidancePanel as ap, type GuidancePanelProps as aq, type GuidancePhase as ar, type GuidanceSetupStep as as, Hand as at, HandDock as au, type HandDockMode as av, type HandDockPlacement as aw, type HandDockPresentation as ax, type HandDockProps as ay, type HandDockToggleContext as az, ActionGroup as b, type PlayAreaProps as b0, type PrimaryActionAttention as b1, PrimaryActionButton as b2, type PrimaryActionButtonProps as b3, PrimaryButton as b4, type PrimaryButtonProps as b5, type ResourceDefinition as b6, Select as b7, SelectContent as b8, SelectItem as b9, type TrackSpace as bA, type UseHandLayoutOptions as bB, type UseHandLayoutReturn as bC, type ZoneDefinition as bD, type ZoneHighlightType as bE, ZoneMap as bF, type ZoneMapProps as bG, type ZonePiece as bH, type ZoneShape as bI, buttonStyle as bJ, chipStyle as bK, intentForVariant as bL, motionDuration as bM, playerColor as bN, surfaceStyle as bO, useCardDragSurface as bP, useChromeSuppression as bQ, SelectTrigger as ba, SetupChecklist as bb, type SetupChecklistProps as bc, type SetupGuidance as bd, type SlotDefinition as be, type SlotOccupant as bf, SlotSystem as bg, type SlotSystemProps as bh, StagingZone as bi, type StagingZoneProps as bj, StandingsTable as bk, type StandingsTableProps as bl, SystemActionSummary as bm, type SystemActionSummaryProps as bn, ThemedButton as bo, type ThemedButtonProps as bp, Toast as bq, ToastActions as br, type ToastActionsProps as bs, type ToastActionsValue as bt, type ToastNotification as bu, ToastProvider as bv, type ToastType as bw, TrackBoard as bx, type TrackBoardProps as by, type TrackPiece as bz, type ActionGroupProps as c, ActionHelp as d, type ActionHelpProps as e, ActionPanel as f, type ActionPanelProps as g, type ButtonVariant$1 as h, type CardDragSurfaceContextValue as i, type CardDragSurfaceController as j, type CardDragSurfaceProps as k, CardDropTargetView as l, type CardDropTargetViewProps as m, CardFace as n, type CardFaceProps as o, type CardPositionProps as p, type CardSize as q, ChromeSuppressionProvider as r, CostDisplay as s, type CostDisplayProps as t, type DefaultEmptySlotProps as u, DefaultNetworkEdge as v, type DefaultNetworkEdgeProps as w, DefaultNetworkNode as x, type DefaultNetworkNodeProps as y, DefaultNetworkPiece as z };

package/dist/{hex-board-view-BFlWDb9k.d.ts → hex-board-view-aKkblDp6.d.ts}

@@ -664,6 +664,185 @@ interface InteractiveTargetRenderState extends InteractiveTargetState {
     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`.
@@ -1046,4 +1225,4 @@ declare function createHexBoardView<const TBoard extends AnyHexBoardInput, const
     id: BoardSpaceIdOf<TBoard>;
 }>(board: TBoard, options: CreateHexBoardViewOptions<TSpaceView>): HexBoardView<TBoard, TSpaceView>;
 
-export { type SemanticColor as $, type AnyHexBoardInput as A, type BoardEdgeIdOf as B, type CardDropTargetVisualState as C, DefaultHexEdge as D, type EdgePosition as E, type FoundationColor as F, type GeneratedHexBoardInput as G, type HexBoardInput as H, type IntentColor as I, type InteractionVisualState as J, type InteractiveHexEdge as K, type InteractiveHexVertex as L, type InteractiveTargetLayer as M, type InteractiveTargetRenderState as N, type InteractiveTargetState as O, type Motion as P, type NormalizedHexBoard as Q, type NormalizedHexEdgeOf as R, type NormalizedHexTileOf as S, type NormalizedHexVertexOf as T, type NormalizedSquareBoard as U, type NormalizedSquareCellOf as V, type NormalizedSquareEdgeOf as W, type NormalizedSquarePieceOf as X, type NormalizedSquareVertexOf as Y, type PlayerColor as Z, type Radius as _, type AnySquareBoardInput as a, type Space as a0, type SquareBoardInput as a1, type TargetIntent as a2, type Theme as a3, type ThemeMeta as a4, type ThemeOverride as a5, type Typography as a6, createHexBoardView as a7, dropTargetVisualStateDataAttributes as a8, hexUtils as a9, mergeTheme as aa, normalizeHexBoardInput as ab, normalizeSquareBoardInput as ac, visualStateDataAttributes as ad, 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 DefaultHexEdgeProps as i, DefaultHexTile as j, type DefaultHexTileProps as k, DefaultHexVertex as l, type DefaultHexVertexProps as m, type Elevation as n, type GeneratedHexSpaceStateLike as o, type GeneratedSquareBoardInput as p, type GeneratedSquareSpaceStateLike as q, type GeneratedTiledEdgeStateLike as r, type GeneratedTiledVertexStateLike as s, type HexBoardView as t, type HexBoardViewTile as u, HexGrid as v, type HexGridBoardProps as w, type HexGridProps as x, type HexOrientation as y, type HexTileGeometry as z };
+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 };

package/dist/{index-gjxQichK.d.ts → index-CFTjJIXd.d.ts}

@@ -1,6 +1,6 @@
 import { ReactNode, ReactElement, ButtonHTMLAttributes } from 'react';
-import { l as BoardSpaceTargetProps, bh as ZoneListProps, b1 as UIContract } from './ui-contract-B4NjRlvC.js';
-import { J as InteractionVisualState } from './hex-board-view-BFlWDb9k.js';
+import { m as BoardSpaceTargetProps, bl as ZoneListProps, b5 as UIContract } from './ui-contract-Ue6SywvO.js';
+import { P as InteractionVisualState } from './hex-board-view-aKkblDp6.js';
 import { H as HandRole } from './ResourceCounter-BFxJknqp.js';
 
 interface ClientParamSchema {
@@ -154,7 +154,7 @@ type WorkspaceSurfaceDescriptor = WorkspaceBoardSurfaceDescriptor | WorkspaceHan
 interface WorkspaceSurfaceSpec {
     readonly [key: string]: WorkspaceSurfaceDescriptor | WorkspaceSurfaceSpec;
 }
-interface WorkspaceContractOptions<Contract extends UIContract, Resource extends string, Card, HexBoards extends Record<string, unknown>> {
+interface WorkspaceContractOptions<Contract extends UIContract, Resource extends string, Card, HexBoards extends Record<string, unknown>, SquareBoards extends Record<string, unknown> = Record<string, unknown>> {
     readonly uiContract: Contract;
     readonly clientParamSchemasByPhase?: ClientParamSchemaMap;
     readonly formInputKeysForInteraction: (interaction: string) => ReadonlySet<string>;
@@ -164,6 +164,7 @@ interface WorkspaceContractOptions<Contract extends UIContract, Resource extends
         icon?: string;
     }>>;
     readonly hexStaticBoards: HexBoards;
+    readonly squareStaticBoards?: SquareBoards;
     readonly cardIdFromZoneCard: (card: Card) => string;
     readonly zoneIdFromZoneCard: (card: Card) => string;
 }
@@ -187,6 +188,6 @@ interface DefineGameUIConfig<GameState, Surfaces> {
     fallback?: ReactNode | ((phase: string | null) => ReactNode);
     includeUnavailableInteractions?: boolean | null;
 }
-declare function createWorkspaceUIContract<WorkspaceUI, Contract extends UIContract, Resource extends string, Card, HexBoards extends Record<string, unknown>>(options: WorkspaceContractOptions<Contract, Resource, Card, HexBoards>): WorkspaceUI;
+declare function createWorkspaceUIContract<WorkspaceUI, Contract extends UIContract, Resource extends string, Card, HexBoards extends Record<string, unknown>, SquareBoards extends Record<string, unknown> = Record<string, unknown>>(options: WorkspaceContractOptions<Contract, Resource, Card, HexBoards, SquareBoards>): WorkspaceUI;
 
 export { type ClientParamSchemaMap as C, type DefineGameUIConfig as D, type WorkspaceBoardSurface as W, type WorkspaceBoardSurfaceDescriptor as a, type WorkspaceBoardTargetInputSlot as b, type WorkspaceCardCollectionSurface as c, type WorkspaceCardCollectionSurfaceDescriptor as d, type WorkspaceCardInputSlot as e, type WorkspaceFormInputSlot as f, type WorkspaceHandSurface as g, type WorkspaceHandSurfaceDescriptor as h, type WorkspaceInteractionFormDescriptor as i, type WorkspaceInteractionFormsDescriptor as j, type WorkspaceInteractionSlotComponent as k, type WorkspacePileSurface as l, type WorkspacePileSurfaceDescriptor as m, type WorkspacePilesSurfaceDescriptor as n, type WorkspaceSurfaceSpec as o, createWorkspaceUIContract as p };