@almadar/ui 5.105.0 → 5.108.0

package/dist/components/{game/2d → core}/atoms/GameIcon.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import type { Asset } from '@almadar/core';
-import { type IconInput } from '../../../core/atoms/Icon';
+import { type IconInput } from './Icon';
 export interface GameIconProps {
     /** Asset — when url is present, renders an img (Asset-primary). */
     assetUrl?: Asset;

package/dist/components/core/atoms/index.d.ts

@@ -8,6 +8,7 @@ export { Checkbox, type CheckboxProps } from "./Checkbox";
 export { Card, CardHeader, CardTitle, CardContent, CardBody, CardFooter, type CardProps, } from "./Card";
 export { Badge, type BadgeProps, type BadgeVariant } from "./Badge";
 export { AtlasImage, AtlasPanel, useAtlasSliceDataUrl, type AtlasImageProps, type AtlasImageAsset, type AtlasPanelProps } from "./AtlasImage";
+export { GameIcon, type GameIconProps } from "./GameIcon";
 export { FilterPill, type FilterPillProps, type FilterPillVariant, type FilterPillSize, } from "./FilterPill";
 export { Spinner, type SpinnerProps } from "./Spinner";
 export { Avatar, type AvatarProps, type AvatarSize, type AvatarStatus, } from "./Avatar";
@@ -46,6 +47,6 @@ export { PatternTile, getTileDimensions, type PatternTileProps, type PatternVari
 export { AnimatedReveal, type AnimatedRevealProps, type RevealTrigger, type RevealAnimation } from "../../marketing/atoms/AnimatedReveal";
 export { AnimatedGraphic, type AnimatedGraphicProps, type GraphicAnimation } from "../../marketing/atoms/AnimatedGraphic";
 export { TraitFrame, type TraitFrameProps } from "./TraitFrame";
-export * from "../../game/2d/molecules/index";
+export * from "../../game/molecules/index";
 export { LearningCanvas, type LearningCanvasProps, type LearningShape, type LearningPoint, type LearningShapeType, } from "../../learning/atoms/LearningCanvas";
 export { type UiError, type LinkAction, type ImageSource, type Point, type Rect, } from "./types";

package/dist/components/core/molecules/index.d.ts

@@ -51,7 +51,7 @@ export { DateRangeSelector, type DateRangeSelectorProps, type DateRangeSelectorO
 export { ChartLegend, type ChartLegendProps, type ChartLegendItem } from './ChartLegend';
 export { LineChart, type LineChartProps, type ChartDataPoint } from './LineChart';
 export { ProgressDots, type ProgressDotsProps, type DotState, type DotSize } from './ProgressDots';
-export * from '../../game/2d/molecules/index';
+export * from '../../game/molecules/index';
 export { MathCanvas, type MathCanvasProps, type MathCurve, type MathPoint, type MathVector, } from '../../learning/molecules/MathCanvas';
 export { PhysicsCanvas, type PhysicsCanvasProps, type LearningPhysicsBody, type LearningPhysicsConstraint, } from '../../learning/molecules/PhysicsCanvas';
 export { BiologyCanvas, type BiologyCanvasProps, type BiologyNode, type BiologyEdge, } from '../../learning/molecules/BiologyCanvas';

package/dist/components/core/organisms/index.d.ts

@@ -9,7 +9,7 @@ export { MasterDetail, type MasterDetailProps } from "./MasterDetail";
 export { StateMachineView, DomStateMachineVisualizer, OrbitalStateMachineView, type StateMachineViewProps, type TransitionBundle, } from "./StateMachineView";
 export * from "./book/index";
 export * from "./layout/index";
-export * from "../../game/2d/molecules/index";
+export * from "../../game/molecules/index";
 export { UISlotRenderer, UISlotComponent, SlotContentRenderer, type UISlotRendererProps, } from "./UISlotRenderer";
 export { ModalSlot, type ModalSlotProps } from "./ModalSlot";
 export { DrawerSlot, type DrawerSlotProps } from "./DrawerSlot";

package/dist/components/core/templates/index.d.ts

@@ -2,9 +2,8 @@ export type { TemplateProps } from './types';
 export { DashboardLayout, type DashboardLayoutProps, type NavItem } from './DashboardLayout';
 export { AuthLayout, type AuthLayoutProps } from '../../marketing/templates/AuthLayout';
 export { CounterTemplate, type CounterTemplateProps, type CounterSize, type CounterVariant } from './CounterTemplate';
-export { GameTemplate, type GameTemplateProps } from '../../game/2d/templates/GameTemplate';
 export { GenericAppTemplate, type GenericAppTemplateProps } from './GenericAppTemplate';
-export { GameShell, type GameShellProps } from '../../game/2d/templates/GameShell';
+export { GameShell, type GameShellProps } from '../../game/templates/GameShell';
 export { LandingPageTemplate, type LandingPageTemplateProps, type LandingPageEntity, } from '../../marketing/templates/LandingPageTemplate';
 export { PricingPageTemplate, type PricingPageTemplateProps, type PricingPageEntity, } from '../../marketing/templates/PricingPageTemplate';
 export { FeatureDetailPageTemplate, type FeatureDetailPageTemplateProps, type FeatureDetailPageEntity, type FeatureDetailSection, } from '../../marketing/templates/FeatureDetailPageTemplate';

package/dist/components/game/{2d/atoms → atoms}/ChoiceButton.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { type IconInput } from '../../../core/atoms/Icon';
+import { type IconInput } from '../../core/atoms/Icon';
 import type { Asset, EventKey } from '@almadar/core';
 export interface ChoiceButtonProps {
     /** Choice text content */

package/dist/components/game/{2d/atoms → atoms}/ControlButton.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import type { EventKey, Asset } from "@almadar/core";
-import { type IconInput } from '../../../core/atoms/Icon';
+import { type IconInput } from '../../core/atoms/Icon';
 export interface ControlButtonProps {
     /** Sprite asset — takes precedence over icon when provided */
     assetUrl?: Asset;

package/dist/components/game/atoms/DrawShape.d.ts

@@ -0,0 +1,50 @@
+/**
+ * `draw-shape` — the neutral vector-fill/stroke drawable atom (dimension-agnostic).
+ *
+ * ONE descriptor (`DrawShapeProps`, grounded in core `ScenePos`) with TWO
+ * backends: `paintShape` (2D, here) and an R3F ground-plane mesh (`Shape3D` in
+ * `lib/drawable/mesh3d`, kept OUT of this file so the 2D path never pulls R3F).
+ * Paints a cell footprint, an axis-aligned rect, an ellipse, or a poly at a scene
+ * position, fill and/or stroke. Genre uses (tile fallback, iso/hex diamond
+ * fallback, cell highlight, feature disc, unit selection ring, unit fallback
+ * circle, ground/ghost discs, solid backgrounds, side-view platform rects) are
+ * all this atom with different `shape`/`anchor`/geometry — composed in `.lolo`,
+ * not here. The React component renders `null`; it exists so the pattern pipeline
+ * registers a `draw-shape` pattern and standalone pages stay inspectable.
+ */
+import type React from 'react';
+import type { ScenePos } from '@almadar/core';
+import type { PainterPoint } from '../../../lib/painter2d';
+import type { DrawableAnchor, DrawableBase, PaintFn } from '../../../lib/drawable/contract';
+export type ShapeKind = 'cell' | 'rect' | 'ellipse' | 'poly';
+export interface DrawShapeProps extends DrawableBase {
+    type: 'draw-shape';
+    shape: ShapeKind;
+    /** Logical scene position; the projector maps it to pixels / world. */
+    position: ScenePos;
+    /** How the shape aligns to its projected position. Default varies by `shape`. */
+    anchor?: DrawableAnchor;
+    /** Rect width in px. */
+    width?: number;
+    /** Rect height in px. */
+    height?: number;
+    /** Ellipse horizontal radius in px. */
+    radiusX?: number;
+    /** Ellipse vertical radius in px; omitted → `radiusX` (a circle). */
+    radiusY?: number;
+    /** Fine px nudge from the anchor point (e.g. a disc drawn at `groundY - 8*scale`). */
+    offsetX?: number;
+    offsetY?: number;
+    /** Poly vertices as px offsets relative to the cell's projected top-left. */
+    points?: PainterPoint[];
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    /** 0..1 opacity. */
+    opacity?: number;
+}
+/** Paint a {@link DrawShapeProps}. Skips a draw when its required geometry is missing — never throws. */
+export declare const paintShape: PaintFn<DrawShapeProps>;
+/** Registry/standalone stub — the host paints this atom; the DOM renders nothing. */
+export declare function DrawShape(_props: DrawShapeProps): React.JSX.Element | null;
+export default DrawShape;

package/dist/components/game/atoms/DrawSprite.d.ts

@@ -0,0 +1,47 @@
+/**
+ * `draw-sprite` — the neutral image/atlas-frame drawable atom (dimension-agnostic).
+ *
+ * ONE descriptor (`DrawSpriteProps`, grounded in core `ScenePos` + `Asset`) with
+ * TWO backends: `paintSprite` (2D, here — via the portable `Painter2D` seam) and
+ * an R3F mesh (`Sprite3D` in `lib/drawable/mesh3d`, kept OUT of this file so the
+ * 2D paint path never pulls `three`/`drei` into an app bundle — the codebase
+ * code-splits R3F). The canvas host picks the backend by `mode`; that is what
+ * makes canvas-2d and canvas-3d the same `children` interface. Genre uses (tile,
+ * unit body, feature, effect, movement ghost, background cover) are all this atom
+ * with different `anchor`/`size`/`frame`/`flip`/`shadow` — composed in `.lolo`,
+ * not here. The React component renders `null` (a drawable is painted by the host,
+ * not the DOM); it exists so the pattern pipeline registers a `draw-sprite`
+ * pattern and standalone pages stay inspectable.
+ */
+import type React from 'react';
+import type { Asset, ScenePos } from '@almadar/core';
+import type { BlitSrc, PainterShadow } from '../../../lib/painter2d';
+import type { DrawableAnchor, DrawableBase, PaintFn } from '../../../lib/drawable/contract';
+export interface DrawSpriteProps extends DrawableBase {
+    type: 'draw-sprite';
+    /** Logical scene position; the projector maps it to pixels / world. */
+    position: ScenePos;
+    /** The image / atlas reference to blit. */
+    asset: Asset;
+    /** How the sprite aligns to its projected position. Default `'top-left'`. */
+    anchor?: DrawableAnchor;
+    /** Draw width in px (2D) / world units (3D); omitted → resolved source width. */
+    width?: number;
+    /** Draw height in px (2D) / world units (3D); omitted → resolved source height. */
+    height?: number;
+    /** Explicit atlas sub-rect override (px); omitted → resolved from `asset.atlas`/`asset.sprite`. */
+    frame?: BlitSrc;
+    /** Mirror horizontally (facing). */
+    flipX?: boolean;
+    /** Rotation in radians about the sprite's center. */
+    rotation?: number;
+    /** 0..1 opacity. */
+    opacity?: number;
+    /** Drop shadow (e.g. a team-colored glow). */
+    shadow?: PainterShadow;
+}
+/** Paint a {@link DrawSpriteProps}. Renders nothing (returns) when a resource is not ready — never throws. */
+export declare const paintSprite: PaintFn<DrawSpriteProps>;
+/** Registry/standalone stub — the host paints this atom; the DOM renders nothing. */
+export declare function DrawSprite(_props: DrawSpriteProps): React.JSX.Element | null;
+export default DrawSprite;

package/dist/components/game/atoms/DrawText.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `draw-text` — the neutral text drawable atom (dimension-agnostic).
+ *
+ * ONE descriptor (`DrawTextProps`, grounded in core `ScenePos`) with TWO backends:
+ * `paintText` (2D, here) and an R3F billboarded `<Text>` (`Text3D` in
+ * `lib/drawable/mesh3d`, kept OUT of this file so the 2D path never pulls R3F).
+ * Paints a string at a scene position with font/color/alignment. The React
+ * component renders `null` (a drawable is painted by the host, not the DOM).
+ */
+import type React from 'react';
+import type { ScenePos } from '@almadar/core';
+import type { DrawableAnchor, DrawableBase, PaintFn } from '../../../lib/drawable/contract';
+export interface DrawTextProps extends DrawableBase {
+    type: 'draw-text';
+    text: string;
+    /** Logical scene position; the projector maps it to pixels / world. */
+    position: ScenePos;
+    anchor?: DrawableAnchor;
+    offsetX?: number;
+    offsetY?: number;
+    color: string;
+    font?: string;
+    align?: CanvasTextAlign;
+    baseline?: CanvasTextBaseline;
+    opacity?: number;
+}
+/** Paint a {@link DrawTextProps}. */
+export declare const paintText: PaintFn<DrawTextProps>;
+/** Registry/standalone stub — the host paints this atom; the DOM renders nothing. */
+export declare function DrawText(_props: DrawTextProps): React.JSX.Element | null;
+export default DrawText;

package/dist/components/game/{2d/atoms → atoms}/GameAudioToggle.d.ts

@@ -12,7 +12,7 @@
  */
 import React from 'react';
 import type { Asset } from '@almadar/core';
-import type { UiError } from '../../../core/atoms/types';
+import type { UiError } from '../../core/atoms/types';
 export interface GameAudioToggleProps {
     /** Button size */
     size?: 'sm' | 'md' | 'lg';

package/dist/components/game/{2d/atoms → atoms}/MiniMap.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import type { Asset } from '@almadar/core';
-import type { Rect } from '../../../core/atoms/types';
+import type { Rect } from '../../core/atoms/types';
 export interface MiniMapTile {
     x: number;
     y: number;

package/dist/components/game/{2d/atoms → atoms}/ScoreDisplay.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { type IconInput } from '../../../core/atoms/Icon';
+import { type IconInput } from '../../core/atoms/Icon';
 import type { Asset } from '@almadar/core';
 export interface ScoreDisplayProps {
     /** Sprite asset — takes precedence over icon when provided */

package/dist/components/game/{2d/atoms → atoms}/StateIndicator.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { type IconInput } from '../../../core/atoms/Icon';
+import { type IconInput } from '../../core/atoms/Icon';
 import type { Asset } from '@almadar/core';
 export interface StateStyle {
     icon: IconInput;

package/dist/components/game/{2d/molecules → molecules}/ActionTile.d.ts

@@ -8,7 +8,7 @@
  * @packageDocumentation
  */
 import React from 'react';
-import type { DisplayStateProps } from '../../../core/organisms/types';
+import type { DisplayStateProps } from '../../core/organisms/types';
 import type { SlotItemData } from './TraitSlot';
 export interface ActionTileProps extends DisplayStateProps {
     /** The action data */

package/dist/components/game/molecules/Canvas.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Canvas — the unified game canvas draw-host (P6 closing).
+ *
+ * A single `type: canvas` host that renders authored `drawables` (the neutral
+ * `draw-*` children) through the 2D painter or the 3D painter selected by `mode`.
+ * Both painters consume the EXACT same `drawables`; they differ only in how a
+ * `ScenePos` projects and how a sprite/shape/text is rasterized vs meshed. This
+ * retires the direct use of `canvas-2d` / `game-canvas-3d` from board authoring:
+ * a board writes `{ type: canvas, mode, camera, children: [...] }`.
+ *
+ * Camera: the neutral core `Camera` ({ mode, zoom, ... }) is mapped to each
+ * host's legacy vocab here (2D `camera` string / 3D `cameraMode`; `zoom` → `scale`),
+ * so the board carries one camera object regardless of painter.
+ *
+ * Interaction: a click/hover event is one event-name string forwarded to whichever
+ * painter `mode` selects. Its payload phantom is the merge of both painters' emit
+ * shapes so the single value stays assignable to either host's prop (the two hosts
+ * still emit their own coordinate shape at runtime).
+ *
+ * The 3D host (three.js/R3F) is lazy-imported so a 2D-only app never pulls the
+ * 3D bundle — the code-split boundary the drawable atoms were built R3F-free for.
+ *
+ * @packageDocumentation
+ */
+import * as React from 'react';
+import type { Asset, AssetUrl, Camera, EventEmit } from '@almadar/core';
+import type { DrawableNode } from '../../../lib/drawable/paintDispatch';
+import { type Projection } from './Canvas2D';
+/** Painter selection. Same `drawables` for both; differ only in projection + rasterizer. */
+export type CanvasMode = '2d' | '3d';
+export interface CanvasProps {
+    /** Painter: 2D sprite/shape/text raster, or 3D mesh. Default '2d'. */
+    mode?: CanvasMode;
+    /** Neutral drawable descriptors — the `draw-*` children. Routed to the host's painter. */
+    drawables?: DrawableNode[];
+    /** Neutral camera pose. Mapped to the underlying host's framing + zoom. */
+    camera?: Camera;
+    /** 2D grid layout (2D mode only): isometric / hex / flat / free / side. */
+    projection?: Projection;
+    className?: string;
+    isLoading?: boolean;
+    /** Unit draw-size multiplier (both painters). */
+    unitScale?: number;
+    /** Minimap overlay (2D). */
+    showMinimap?: boolean;
+    /** Backdrop image (2D iso/hex/flat/free/side). */
+    backgroundImage?: AssetUrl | Asset;
+    /** Solid backdrop colour — 2D `side` fill and 3D scene clear colour. */
+    backgroundColor?: string;
+    /** Side/free world bounds (2D `side`) and 3D world extent. */
+    worldWidth?: number;
+    worldHeight?: number;
+    /** 3D world-unit → pixel scale (perspective/side depth). 3D only. */
+    pixelsPerUnit?: number;
+    /** 3D-only presentation. */
+    showGrid?: boolean;
+    shadows?: boolean;
+    showCoordinates?: boolean;
+    showTileInfo?: boolean;
+    fogOfWar?: boolean[][];
+    tileClickEvent?: EventEmit<{
+        x: number;
+        y: number;
+    } & {
+        tileId: string;
+        z: number;
+    }>;
+    unitClickEvent?: EventEmit<{
+        unitId: string;
+    } & {
+        x: number;
+        z: number;
+    }>;
+    tileHoverEvent?: EventEmit<{
+        x: number;
+        y: number;
+    } & {
+        tileId: string;
+        z: number;
+    }>;
+    tileLeaveEvent?: EventEmit<Record<string, never>>;
+    /** Feature-click event (3D only). */
+    featureClickEvent?: EventEmit<{
+        featureId: string;
+        x: number;
+        z: number;
+        type?: string;
+        elevation?: number;
+    }>;
+    keyMap?: Record<string, string>;
+    keyUpMap?: Record<string, string>;
+}
+export declare function Canvas({ mode, drawables, camera, projection, className, isLoading, unitScale, showMinimap, backgroundImage, backgroundColor, worldWidth, worldHeight, pixelsPerUnit, showGrid, shadows, showCoordinates, showTileInfo, fogOfWar, tileClickEvent, unitClickEvent, tileHoverEvent, tileLeaveEvent, featureClickEvent, keyMap, keyUpMap, }: CanvasProps): React.JSX.Element;
+export declare namespace Canvas {
+    var displayName: string;
+}

package/dist/components/game/molecules/Canvas2D.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Canvas2D — the thin 2D draw-host (Drawable Canvas, P6 closing).
+ *
+ * A pure walker: the board authors a `drawables` list (the neutral `draw-*`
+ * children) and this host paints them through the portable `Painter2D` seam,
+ * projecting each `ScenePos` for the chosen `projection` (iso/hex/flat/free/side).
+ * It owns NO game data — tiles, units, features, effects, highlights, health bars
+ * and labels are all `draw-*` children composed in `.lolo`, not props here. The
+ * only local state is view state: viewport size, camera, sprite/atlas cache.
+ *
+ * Projections: iso/hex/flat/free go through the shared `create2DProjector`; `side`
+ * reuses the `free` (identity, world-pixel) projector — side boards author their
+ * platforms/player as `draw-*` children like every other board.
+ *
+ * Camera: `pan-zoom` (drag+wheel), `fixed` (still), or `follow` (lerps to the
+ * neutral core `Camera.target`, forwarded as `followTarget`). The unit-position
+ * interpolation of the old data-prop host is gone — the LOLO state machine owns
+ * entity motion; this host only tweens the camera.
+ *
+ * Interaction: a pointer emits the projector-unprojected scene coordinate as
+ * `tileClickEvent`/`tileHoverEvent` `{ x, y }` (the FSM validates the cell) and
+ * `tileLeaveEvent` `{}`. `unitClickEvent` needs a per-entity id the neutral
+ * drawable descriptors don't carry (they hold only a `ScenePos`); its hit-test is
+ * a deferred, tracked fork (see docs/Almadar_Std_Game_V2_PLAN.md) — the prop is
+ * accepted but not yet emitted from a coordinate.
+ *
+ * @packageDocumentation
+ */
+import * as React from 'react';
+import type { Asset, AssetUrl, EventEmit, ScenePos } from '@almadar/core';
+import { type DrawableNode } from '../../../lib/drawable/paintDispatch';
+import type { UiError } from '../../core/atoms/types';
+export interface TileCoord {
+    x: number;
+    y: number;
+}
+/** Projection axis. iso/hex/flat use `isoToScreen`; `free`/`side` are world-pixel-direct. */
+export type Projection = 'isometric' | 'hex' | 'flat' | 'free' | 'side';
+/** Camera behavior. `pan-zoom` = user drag+wheel; `follow` = track `followTarget`;
+ *  `fixed` = no camera motion. */
+export type CameraMode = 'pan-zoom' | 'follow' | 'fixed';
+/** A side-view platform (AABB rect). Retained as a shared type for the 3D side
+ *  scene; side boards now author platforms as `draw-*` children, not this shape. */
+export interface Platform {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    type?: 'ground' | 'platform' | 'hazard' | 'goal';
+}
+/** A side-view player. Retained as a shared type for the 3D side scene; side
+ *  boards now author the player as a `draw-sprite` child, not this shape. */
+export interface SidePlayer {
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+    vx?: number;
+    vy?: number;
+    grounded?: boolean;
+    facingRight?: boolean;
+    animation?: string;
+    frame?: number;
+}
+export interface Canvas2DProps {
+    /** Additional CSS classes */
+    className?: string;
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: UiError | null;
+    /** Projection axis (default 'isometric'). */
+    projection?: Projection;
+    /** Neutral drawable descriptors (the `draw-*` children). The host walks these. */
+    drawables?: DrawableNode[];
+    /** Background image (tiled behind iso/hex/flat/free; cover-scaled for atlas slices).
+     * A bare URL string is accepted as shorthand for a standalone backdrop. */
+    backgroundImage?: AssetUrl | Asset;
+    /** Emits UI:{tileClickEvent} with the unprojected scene { x, y } on click. */
+    tileClickEvent?: EventEmit<{
+        x: number;
+        y: number;
+    }>;
+    /**
+     * Unit-click event. The neutral drawable host cannot resolve a click to a
+     * per-entity id (descriptors carry only a `ScenePos`, no id), so this prop is
+     * accepted but not yet emitted — the id-hit-test is a tracked fork
+     * (docs/Almadar_Std_Game_V2_PLAN.md).
+     */
+    unitClickEvent?: EventEmit<{
+        unitId: string;
+    }>;
+    /** Emits UI:{tileHoverEvent} with the unprojected scene { x, y } on hover. */
+    tileHoverEvent?: EventEmit<{
+        x: number;
+        y: number;
+    }>;
+    /** Emits UI:{tileLeaveEvent} with {} on pointer leave. */
+    tileLeaveEvent?: EventEmit<Record<string, never>>;
+    /** Maps a keydown `e.code` → the board's SEMANTIC event (device-agnostic input). */
+    keyMap?: Record<string, string>;
+    /** Maps a keyup `e.code` → the board's SEMANTIC event. */
+    keyUpMap?: Record<string, string>;
+    /** Camera behavior (default 'pan-zoom'). */
+    camera?: CameraMode;
+    /** Render scale (0.4 = 40% zoom). Ignored by `free`/`side` (world-pixel-direct). */
+    scale?: number;
+    /** Toggle minimap overlay. */
+    showMinimap?: boolean;
+    /** Follow-camera target in scene space (the neutral core `Camera.target`). When
+     *  `camera:'follow'` the host lerps to keep this point centered. */
+    followTarget?: ScenePos;
+    /** Solid backdrop colour (drawn when no `backgroundImage`). */
+    bgColor?: string;
+}
+export declare function Canvas2D({ className, isLoading, error, projection, drawables, backgroundImage: backgroundImageRaw, tileClickEvent, unitClickEvent, tileHoverEvent, tileLeaveEvent, keyMap, keyUpMap, camera, scale, showMinimap, followTarget, bgColor, }: Canvas2DProps): React.JSX.Element;
+export declare namespace Canvas2D {
+    var displayName: string;
+}
+export default Canvas2D;

package/dist/components/game/{2d/molecules → molecules}/ControlGrid.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import type { EventEmit, Asset } from '@almadar/core';
-import type { IconInput } from '../../../core/atoms/index';
+import type { IconInput } from '../../core/atoms/index';
 export type ControlGridKind = 'dpad' | 'actions';
 export interface ControlGridButton {
     id: string;

package/dist/components/game/molecules/DrawShapeLayer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `draw-shape-layer` — batch of shapes in one descriptor for O(layers) perf.
+ *
+ * Composes the `draw-shape` atom; drawable-by-composition (its `items` are
+ * `draw-shape` descriptors, each grounded in core `ScenePos`). The React
+ * component renders `null` (a drawable is painted by the host, not the DOM).
+ */
+import type React from 'react';
+import type { DrawableBase, PaintFn } from '../../../lib/drawable/contract';
+import { type DrawShapeProps } from '../atoms/DrawShape';
+export interface DrawShapeLayerProps extends DrawableBase {
+    type: 'draw-shape-layer';
+    items: DrawShapeProps[];
+}
+/** Paint a {@link DrawShapeLayerProps}. */
+export declare const paintShapeLayer: PaintFn<DrawShapeLayerProps>;
+/** Registry/standalone stub — the host paints this molecule; the DOM renders nothing. */
+export declare function DrawShapeLayer(_props: DrawShapeLayerProps): React.JSX.Element | null;
+export default DrawShapeLayer;

package/dist/components/game/molecules/DrawSpriteLayer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `draw-sprite-layer` — batch multiple sprites in one descriptor for O(layers) rendering.
+ *
+ * Composes the `draw-sprite` atom; the layer itself carries no `position` — each
+ * item does. It is drawable-by-composition: its `items` are `draw-sprite`
+ * descriptors (each grounded in core `ScenePos`), which is what stamps the layer
+ * `drawable` at pattern-sync time.
+ */
+import type React from 'react';
+import type { DrawableBase, PaintFn } from '../../../lib/drawable/contract';
+import { type DrawSpriteProps } from '../atoms/DrawSprite';
+export interface DrawSpriteLayerProps extends DrawableBase {
+    type: 'draw-sprite-layer';
+    /** Sprites painted in array order; z-ordering is the caller's responsibility. */
+    items: DrawSpriteProps[];
+}
+/** Paint a {@link DrawSpriteLayerProps}. Renders all sprites in order; never throws. */
+export declare const paintSpriteLayer: PaintFn<DrawSpriteLayerProps>;
+/** Registry/standalone stub — the host paints this molecule; the DOM renders nothing. */
+export declare function DrawSpriteLayer(_props: DrawSpriteLayerProps): React.JSX.Element | null;
+export default DrawSpriteLayer;

package/dist/components/game/molecules/DrawTextLayer.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `draw-text-layer` — batch of text labels in one descriptor for O(layers) perf.
+ *
+ * Composes the `draw-text` atom; drawable-by-composition (its `items` are
+ * `draw-text` descriptors, each grounded in core `ScenePos`). Covers the batched
+ * world-space text pass — fx messages, damage numbers, unit labels — that a
+ * board maps from an entity array (`items: (array/map @entity.fx (fn ...))`),
+ * which a literal `children` array can't express. The React component renders
+ * `null` (a drawable is painted by the host, not the DOM).
+ */
+import type React from 'react';
+import type { DrawableBase, PaintFn } from '../../../lib/drawable/contract';
+import { type DrawTextProps } from '../atoms/DrawText';
+export interface DrawTextLayerProps extends DrawableBase {
+    type: 'draw-text-layer';
+    items: DrawTextProps[];
+}
+/** Paint a {@link DrawTextLayerProps}. */
+export declare const paintTextLayer: PaintFn<DrawTextLayerProps>;
+/** Registry/standalone stub — the host paints this molecule; the DOM renders nothing. */
+export declare function DrawTextLayer(_props: DrawTextLayerProps): React.JSX.Element | null;
+export default DrawTextLayer;

package/dist/components/game/{2d/molecules → molecules}/GameHud.d.ts

@@ -1,7 +1,7 @@
 import * as React from "react";
 import { type StatBadgeProps } from "./StatBadge";
 import type { Asset } from "@almadar/core";
-import type { IconInput } from "../../../core/atoms/index";
+import type { IconInput } from "../../core/atoms/index";
 export interface GameHudStat extends Omit<StatBadgeProps, "size"> {
     /** Data source entity name */
     source?: string;

package/dist/components/game/{2d/molecules → molecules}/StatBadge.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { type IconInput } from '../../../core/atoms/Icon';
+import { type IconInput } from '../../core/atoms/Icon';
 import type { Asset } from '@almadar/core';
 /**
  * StatBadge — game stat display molecule (distinct from core Badge atom).

package/dist/components/game/{2d/molecules → molecules}/StateNode.d.ts

@@ -7,7 +7,7 @@
  * @packageDocumentation
  */
 import React from 'react';
-import { type Point } from '../../../core/atoms/index';
+import { type Point } from '../../core/atoms/index';
 export interface StateNodeProps {
     /** State name */
     name: string;

package/dist/components/game/{2d/molecules → molecules}/TraitSlot.d.ts

@@ -20,7 +20,7 @@
 import React from 'react';
 import type { Asset, EventEmit } from '@almadar/core';
 import { type TraitStateMachineDefinition } from './TraitStateViewer';
-import type { UiError } from '../../../core/atoms/types';
+import type { UiError } from '../../core/atoms/types';
 /** Data shape for a slot's equipped item */
 export type SlotItemData = {
     id: string;

package/dist/components/game/{2d/molecules → molecules}/TraitStateViewer.d.ts

@@ -11,7 +11,7 @@
  */
 import React from 'react';
 import { type StateStyle } from '../atoms/StateIndicator';
-import type { UiError } from '../../../core/atoms/types';
+import type { UiError } from '../../core/atoms/types';
 export type TraitTransition = {
     from: string;
     to: string;

package/dist/components/game/{2d/molecules → molecules}/TransitionArrow.d.ts

@@ -7,7 +7,7 @@
  * @packageDocumentation
  */
 import React from 'react';
-import type { Point } from '../../../core/atoms/types';
+import type { Point } from '../../core/atoms/types';
 export interface TransitionArrowProps {
     /** Start position (center of from-node) */
     from: Point;