@almadar/ui 1.0.13 → 1.0.14

package/dist/components/index.d.ts

@@ -1,16 +1,15 @@
-import * as React from 'react';
+import * as React$1 from 'react';
 import React__default from 'react';
 import { LucideIcon } from 'lucide-react';
 import { SExpr } from '@almadar/evaluator';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { Entity } from '../stores/index.js';
-export { clearEntities, getAllEntities, getByType, getEntity, getSingleton, removeEntity, spawnEntity, updateEntity, updateSingleton } from '../stores/index.js';
 export { AuthContextValue, AuthUser, ChangeSummary, CompileResult, CompileStage, ENTITY_EVENTS, EntityDataRecord, EntityMutationResult, Extension, ExtensionManifest, FileSystemFile, FileSystemStatus, GitHubRepo, GitHubStatus, HistoryTimelineItem, OpenFile, OrbitalEventPayload, OrbitalEventResponse, QuerySingletonEntity, QuerySingletonResult, QuerySingletonState, QueryState, RevertResult, SelectedFile, UseCompileResult, UseEntityDetailResult, UseEntityListOptions, UseEntityListResult, UseEntityMutationsOptions, UseExtensionsOptions, UseExtensionsResult, UseFileEditorOptions, UseFileEditorResult, UseFileSystemResult, UseOrbitalHistoryOptions, UseOrbitalHistoryResult, entityDataKeys, parseQueryBinding, useAgentChat, useAuthContext, useCompile, useConnectGitHub, useCreateEntity, useDeepAgentGeneration, useDeleteEntity, useDisconnectGitHub, useEmitEvent, useEntities, useEntitiesByType, useEntity, useEntityById, useEntityDetail, useEntityList, useEntityMutations, useEventBus, useEventListener, useExtensions, useFileEditor, useFileSystem, useGitHubBranches, useGitHubRepo, useGitHubRepos, useGitHubStatus, useInput, useOrbitalHistory, useOrbitalMutations, usePhysics, usePlayer, usePreview, useQuerySingleton, useSelectedEntity, useSendOrbitalEvent, useSingletonEntity, useUIEvents, useUpdateEntity, useValidation } from '../hooks/index.js';
 import { E as EventBusContextType } from '../event-bus-types-8-cjyMxw.js';
 export { a as EventListener, K as KFlowEvent, U as Unsubscribe } from '../event-bus-types-8-cjyMxw.js';
 import { S as SlotContent, a as UISlot } from '../useUISlots-mnggE9X9.js';
 export { D as DEFAULT_SLOTS, R as RenderUIConfig, b as SlotAnimation, c as SlotChangeCallback, U as UISlotManager, u as useUISlotManager } from '../useUISlots-mnggE9X9.js';
 export { c as cn } from '../cn-mqkxz8Sd.js';
+export { Entity, clearEntities, getAllEntities, getByType, getEntity, getSingleton, removeEntity, spawnEntity, updateEntity, updateSingleton } from '../stores/index.js';
 import '@almadar/core';
 import '@tanstack/react-query';
 import 'clsx';
@@ -36,9 +35,9 @@ interface SelectOption$1 {
     value: string;
     label: string;
 }
-interface InputProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
+interface InputProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, "onChange"> {
     /** Input type - supports 'select' and 'textarea' in addition to standard types */
-    type?: "text" | "email" | "password" | "number" | "tel" | "url" | "search" | "date" | "datetime-local" | "time" | "checkbox" | "select" | "textarea";
+    inputType?: "text" | "email" | "password" | "number" | "tel" | "url" | "search" | "date" | "datetime-local" | "time" | "checkbox" | "select" | "textarea";
     error?: string;
     leftIcon?: React__default.ReactNode;
     rightIcon?: React__default.ReactNode;
@@ -340,7 +339,7 @@ interface ProgressBarProps {
      * Type of the progress bar (linear, circular, stepped)
      * @default 'linear'
      */
-    type?: ProgressBarType;
+    progressType?: ProgressBarType;
     /**
      * Variant/color of the progress bar
      * @default 'primary'
@@ -418,7 +417,7 @@ interface SwitchProps {
     name?: string;
     className?: string;
 }
-declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Switch: React$1.ForwardRefExoticComponent<SwitchProps & React$1.RefAttributes<HTMLButtonElement>>;
 
 /**
  * Spacer Component
@@ -519,7 +518,7 @@ interface TextHighlightProps {
     /**
      * Type of highlight (determines color)
      */
-    type: HighlightType;
+    highlightType: HighlightType;
     /**
      * Whether the highlight is currently active/focused
      * @default false
@@ -806,7 +805,7 @@ interface ScoreDisplayProps {
     /** Label to display before score */
     label?: string;
     /** Icon component or emoji */
-    icon?: React.ReactNode;
+    icon?: React$1.ReactNode;
     /** Size variant */
     size?: 'sm' | 'md' | 'lg' | 'xl';
     /** Additional CSS classes */
@@ -825,7 +824,7 @@ interface ControlButtonProps {
     /** Button label text */
     label?: string;
     /** Icon component or emoji */
-    icon?: React.ReactNode;
+    icon?: React$1.ReactNode;
     /** Size variant */
     size?: 'sm' | 'md' | 'lg' | 'xl' | string;
     /** Shape variant */
@@ -3184,7 +3183,7 @@ interface ListProps {
         id: string;
     }[] | readonly unknown[] | unknown;
     /** Entity type name for display */
-    type?: string;
+    entityType?: string;
     /** Loading state */
     isLoading?: boolean;
     /** Error state */
@@ -3713,97 +3712,616 @@ interface TabbedContainerProps {
 declare const TabbedContainer: React__default.FC<TabbedContainerProps>;
 
 /**
- * Game entity with position and rendering data
+ * Isometric Game Types
+ *
+ * Type definitions for isometric grid rendering: tiles, units, features.
+ * Used by IsometricCanvas and game hooks.
+ *
+ * @packageDocumentation
  */
-interface GameEntity extends Entity {
+/** A single isometric tile on the grid */
+interface IsometricTile {
+    /** Grid x coordinate */
     x: number;
+    /** Grid y coordinate */
     y: number;
-    vx?: number;
-    vy?: number;
-    width?: number;
-    height?: number;
-    layer?: number;
+    /** Terrain type key (e.g., 'grass', 'stone', 'water') */
+    terrain: string;
+    /** Direct sprite URL override (bypasses getTerrainSprite resolver) */
+    terrainSprite?: string;
+    /** Whether units can traverse this tile (default true) */
+    passable?: boolean;
+    /** Movement cost for pathfinding (default 1) */
+    movementCost?: number;
+    /** Optional tile type for visual variants */
+    tileType?: string;
+}
+/** A unit positioned on the isometric grid */
+interface IsometricUnit {
+    /** Unique unit identifier */
+    id: string;
+    /** Current grid position */
+    position: {
+        x: number;
+        y: number;
+    };
+    /** Static sprite URL (used when no sprite sheet animation) */
     sprite?: string;
-    color?: string;
-    rotation?: number;
-    scale?: number;
-    visible?: boolean;
-    collider?: {
-        width: number;
-        height: number;
-        offsetX?: number;
-        offsetY?: number;
+    /** Unit archetype key for sprite resolution */
+    unitType?: string;
+    /** Hero identifier for sprite sheet lookup */
+    heroId?: string;
+    /** Display name rendered below the unit */
+    name?: string;
+    /** Team affiliation for coloring */
+    team?: 'player' | 'enemy' | 'neutral';
+    /** Current health */
+    health?: number;
+    /** Maximum health */
+    maxHealth?: number;
+    /** Trait attachments for state display */
+    traits?: {
+        name: string;
+        currentState: string;
+        states: string[];
+        cooldown: number;
+    }[];
+    /** Previous position for movement trail ghost */
+    previousPosition?: {
+        x: number;
+        y: number;
     };
 }
+/** A map feature (resource, building, portal, etc.) */
+interface IsometricFeature {
+    /** Grid x coordinate */
+    x: number;
+    /** Grid y coordinate */
+    y: number;
+    /** Feature type key (e.g., 'goldMine', 'castle', 'portal') */
+    type: string;
+    /** Direct sprite URL override (bypasses getFeatureSprite resolver) */
+    sprite?: string;
+}
+/** Camera state for pan/zoom */
+interface CameraState {
+    /** Camera X offset in pixels */
+    x: number;
+    /** Camera Y offset in pixels */
+    y: number;
+    /** Zoom level (1.0 = 100%) */
+    zoom: number;
+}
+
+/**
+ * Sprite Sheet Animation Types
+ *
+ * Type definitions for frame-based sprite sheet animation system.
+ * Supports standard 8-column × 5-row character sheets.
+ *
+ * @packageDocumentation
+ */
+/** Animation names matching sprite sheet row layout */
+type AnimationName = 'idle' | 'walk' | 'attack' | 'hit' | 'death';
+/** Sheet file directions (physical PNG files) */
+type SpriteDirection = 'se' | 'sw';
+/** Unit facing direction on screen (4 isometric directions) */
+type FacingDirection = 'se' | 'sw' | 'ne' | 'nw';
+/** Definition for a single animation row in the sprite sheet */
+interface AnimationDef {
+    /** Row index in the sprite sheet (0-4) */
+    row: number;
+    /** Number of frames in this animation */
+    frames: number;
+    /** Frames per second */
+    frameRate: number;
+    /** Whether the animation loops */
+    loop: boolean;
+}
+/** A resolved frame ready to draw on canvas */
+interface ResolvedFrame {
+    /** URL of the sprite sheet image */
+    sheetUrl: string;
+    /** Source X in the sheet (pixel offset) */
+    sx: number;
+    /** Source Y in the sheet (pixel offset) */
+    sy: number;
+    /** Source width (frame width) */
+    sw: number;
+    /** Source height (frame height) */
+    sh: number;
+    /** Whether to flip horizontally when drawing (for NE/NW directions) */
+    flipX: boolean;
+    /** When true, canvas should apply sine-bob breathing offset (frozen idle frame) */
+    applyBreathing?: boolean;
+}
+/** Per-unit animation state tracked in the animation system */
+interface UnitAnimationState {
+    /** Unit identifier */
+    unitId: string;
+    /** Current animation playing */
+    animation: AnimationName;
+    /** Current facing direction */
+    direction: FacingDirection;
+    /** Current frame index within the animation */
+    frame: number;
+    /** Elapsed time in current animation (ms) */
+    elapsed: number;
+    /** Animation to play after current one-shot completes (null = idle) */
+    queuedAnimation: AnimationName | null;
+    /** Whether the current one-shot animation has finished its last frame */
+    finished: boolean;
+}
+/** Frame dimensions for a sprite sheet */
+interface SpriteFrameDims {
+    /** Width of a single frame in pixels */
+    width: number;
+    /** Height of a single frame in pixels */
+    height: number;
+}
+/** Sheet URLs for both directions */
+interface SpriteSheetUrls {
+    /** Southeast-facing sheet URL */
+    se: string;
+    /** Southwest-facing sheet URL */
+    sw: string;
+}
+
 /**
- * Entity renderer function type
+ * IsometricCanvas
+ *
+ * Core isometric game renderer. Maps to the `game-canvas` pattern.
+ * Adapted from projects/trait-wars/design-system/organisms/IsometricGameCanvas.tsx
+ * with full closed-circuit pattern compliance (className, isLoading, error, entity).
+ *
+ * Architecture:
+ * - 2:1 diamond isometric projection
+ * - Painter's algorithm (tile → feature → unit depth sort)
+ * - Camera pan/zoom with lerp
+ * - Off-screen culling
+ * - Minimap on separate canvas
+ * - Sprite sheet animation via resolveUnitFrame
+ * - Event bus–friendly handlers (onTileClick, onUnitClick, etc.)
+ *
+ * @packageDocumentation
  */
-type EntityRenderer = (ctx: CanvasRenderingContext2D, entity: GameEntity) => void;
-/** Input key bindings - supports both field-based and event-based formats */
-interface InputBinding$1 {
-    key: string;
-    /** Direct field mapping (e.g., 'left', 'right', 'jump') */
-    field?: 'left' | 'right' | 'jump' | 'attack';
-    /** Event-based mapping (e.g., 'MOVE_LEFT', 'JUMP') - mapped to fields */
-    event?: string;
-    /** Whether to hold the input (continuous) or trigger once */
-    hold?: boolean;
-}
-/** Collision definition from schema */
-interface CollisionDef {
-    /** Entity types that collide [typeA, typeB] */
-    between: [string, string];
-    /** Collision type: 'solid' resolves overlap, 'trigger' emits event */
-    type: 'solid' | 'trigger';
-    /** Event to emit for trigger collisions */
-    emits?: string;
-}
-interface GameCanvasProps {
-    /** Entity type names to render (optional filter) */
-    renderEntities?: string[];
-    /** Rendering functions per entity type */
-    renderers?: Record<string, EntityRenderer>;
-    /**
-     * Renderer type hint from schema (e.g., 'phaser', 'canvas').
-     * Currently ignored - component uses Canvas2D.
-     * Reserved for future multi-renderer support.
-     */
-    renderer?: string;
-    /** Background color or gradient */
-    background?: string;
-    /** Canvas width in pixels or 'full' for responsive */
-    width?: number | 'full';
-    /** Canvas height in pixels or 'auto' for aspect ratio */
-    height?: number | 'auto';
-    /** Aspect ratio (e.g., '16:9', '4:3') */
-    aspectRatio?: string;
-    /** Camera offset for scrolling */
-    cameraOffset?: {
+
+interface IsometricCanvasProps {
+    /** Additional CSS classes */
+    className?: string;
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
+    /** Array of tiles to render */
+    tiles?: IsometricTile[];
+    /** Array of units on the board */
+    units?: IsometricUnit[];
+    /** Array of features (resources, portals, buildings, etc.) */
+    features?: IsometricFeature[];
+    /** Currently selected unit ID */
+    selectedUnitId?: string | null;
+    /** Valid move positions (shown as pulsing green highlights) */
+    validMoves?: Array<{
         x: number;
         y: number;
-    };
-    /** Debug mode shows hitboxes and entity info */
+    }>;
+    /** Attack target positions (shown as pulsing red highlights) */
+    attackTargets?: Array<{
+        x: number;
+        y: number;
+    }>;
+    /** Hovered tile position */
+    hoveredTile?: {
+        x: number;
+        y: number;
+    } | null;
+    /** Tile click handler */
+    onTileClick?: (x: number, y: number) => void;
+    /** Unit click handler */
+    onUnitClick?: (unitId: string) => void;
+    /** Tile hover handler */
+    onTileHover?: (x: number, y: number) => void;
+    /** Tile leave handler */
+    onTileLeave?: () => void;
+    /** Render scale (0.4 = 40% zoom) */
+    scale?: number;
+    /** Show debug grid lines and coordinates */
     debug?: boolean;
+    /** Background image URL tiled behind the isometric grid */
+    backgroundImage?: string;
+    /** Toggle minimap overlay */
+    showMinimap?: boolean;
+    /** Enable camera pan/zoom controls */
+    enableCamera?: boolean;
+    /** Extra scale multiplier for unit draw size. 1 = default. */
+    unitScale?: number;
+    /** Resolve terrain sprite URL from terrain key */
+    getTerrainSprite?: (terrain: string) => string | undefined;
+    /** Resolve feature sprite URL from feature type key */
+    getFeatureSprite?: (featureType: string) => string | undefined;
+    /** Resolve unit static sprite URL */
+    getUnitSprite?: (unit: IsometricUnit) => string | undefined;
+    /** Resolve animated sprite sheet frame for a unit */
+    resolveUnitFrame?: (unitId: string) => ResolvedFrame | null;
+    /** Additional sprite URLs to preload (e.g., effect sprites) */
+    effectSpriteUrls?: string[];
+    /** Callback to draw canvas effects after units */
+    onDrawEffects?: (ctx: CanvasRenderingContext2D, animTime: number, getImage: (url: string) => HTMLImageElement | undefined) => void;
+    /** Whether there are active effects — keeps RAF loop alive */
+    hasActiveEffects?: boolean;
+    /** Base URL for remote asset resolution. When set, manifest paths
+     *  are prefixed with this URL. Example: "https://trait-wars-assets.web.app" */
+    assetBaseUrl?: string;
+    /** Manifest mapping entity keys to relative sprite paths.
+     *  Combined with assetBaseUrl to produce full URLs.
+     *  Used as a fallback when inline URLs and callbacks don't resolve. */
+    assetManifest?: {
+        terrains?: Record<string, string>;
+        units?: Record<string, string>;
+        features?: Record<string, string>;
+        effects?: Record<string, string>;
+    };
+}
+declare function IsometricCanvas({ className, isLoading, error, entity, tiles: tilesProp, units, features, selectedUnitId, validMoves, attackTargets, hoveredTile, onTileClick, onUnitClick, onTileHover, onTileLeave, scale, debug, backgroundImage, showMinimap, enableCamera, unitScale, getTerrainSprite, getFeatureSprite, getUnitSprite, resolveUnitFrame, effectSpriteUrls, onDrawEffects, hasActiveEffects, assetBaseUrl, assetManifest, }: IsometricCanvasProps): JSX.Element;
+declare namespace IsometricCanvas {
+    var displayName: string;
+}
+
+/**
+ * Combat action types that map to effect compositions.
+ * Superset of trait-wars types + almadar-ui originals.
+ */
+type CombatActionType = 'melee' | 'ranged' | 'magic' | 'heal' | 'defend' | 'hit' | 'death' | 'buff' | 'debuff' | 'shield' | 'aoe' | 'critical';
+/**
+ * Effect asset manifest — the sprites and animation frames available for
+ * the particle engine. This is the `assetManifest.effects` section.
+ */
+interface EffectAssetManifest {
+    /** Base URL for all asset paths */
+    baseUrl: string;
+    /** Particle sprite groups (white-on-transparent, tinted at runtime) */
+    particles?: {
+        slash?: string[];
+        magic?: string[];
+        fire?: string[];
+        flame?: string[];
+        smoke?: string[];
+        scorch?: string[];
+        circle?: string[];
+        flare?: string;
+        spark?: string[];
+        muzzle?: string[];
+        star?: string[];
+        trace?: string[];
+        twirl?: string[];
+        light?: string[];
+        dirt?: string[];
+        scratch?: string[];
+        symbol?: string[];
+    };
+    /** Frame-sequence animations (array of frame image paths) */
+    animations?: {
+        explosion?: string[];
+        smokePuff?: string[];
+        flash?: string[];
+        blackSmoke?: string[];
+        gasSmoke?: string[];
+        smokeExplosion?: string[];
+    };
+}
+
+/**
+ * CanvasEffect Component
+ *
+ * Renders animated visual effects using a `<canvas>` element with
+ * sprite-based particles, frame-sequence animations, and overlays.
+ * This is a render-ui pattern that can be placed in any slot —
+ * it renders on top of whatever occupies that slot.
+ *
+ * Pattern: canvas-effect
+ *
+ * When an EffectAssetManifest is provided (via assetManifest prop),
+ * the component uses the full particle engine with tinted sprites.
+ * Without a manifest, it falls back to emoji-based rendering.
+ *
+ * @packageDocumentation
+ */
+
+interface CanvasEffectProps {
+    /** The type of combat action to visualise */
+    actionType: CombatActionType;
+    /** Screen-space X position (center of the effect) */
+    x: number;
+    /** Screen-space Y position (center of the effect) */
+    y: number;
+    /** Duration in ms before auto-dismiss (default 2000 for canvas, 800 for emoji) */
+    duration?: number;
+    /** Optional intensity multiplier (1 = normal, 2 = double size/brightness) */
+    intensity?: number;
+    /** Callback when the effect animation completes */
+    onComplete?: () => void;
     /** Additional CSS classes */
     className?: string;
-    /** Click handler for canvas */
-    onClick?: (x: number, y: number, entity?: GameEntity) => void;
-    /** Enable keyboard input handling (updates Input entity) */
-    enableInput?: boolean;
-    /** Custom input key bindings */
-    inputBindings?: InputBinding$1[];
-    /** Collision definitions from schema */
-    collisions?: CollisionDef[];
-    /** Event bus for emitting collision events */
-    eventBus?: {
-        emit: (event: string, payload?: unknown) => void;
-    };
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Sprite URL for the effect (emoji fallback mode).
+     *  When set without assetManifest, renders this image instead of emoji. */
+    effectSpriteUrl?: string;
+    /** Base URL for remote assets. Prepended to relative effectSpriteUrl paths. */
+    assetBaseUrl?: string;
+    /** Full effect asset manifest for the sprite particle engine.
+     *  When provided, enables the canvas-based particle system. */
+    assetManifest?: EffectAssetManifest;
+    /** Canvas width (default 400) */
+    width?: number;
+    /** Canvas height (default 300) */
+    height?: number;
 }
-declare function GameCanvas({ renderEntities, renderers, background, width, height, aspectRatio, cameraOffset, debug, className, onClick, enableInput, inputBindings, collisions, eventBus, }: GameCanvasProps): react_jsx_runtime.JSX.Element;
-declare namespace GameCanvas {
+declare function CanvasEffect(props: CanvasEffectProps): JSX.Element | null;
+declare namespace CanvasEffect {
     var displayName: string;
 }
 
+/**
+ * useImageCache Hook
+ *
+ * Preloads and caches images by URL for canvas rendering.
+ * Returns a getter function that returns loaded HTMLImageElement instances.
+ * Tracks loading progress to support isLoading state.
+ *
+ * @packageDocumentation
+ */
+interface ImageCacheResult {
+    /** Get a cached image by URL. Returns undefined if not yet loaded. */
+    getImage: (url: string) => HTMLImageElement | undefined;
+    /** Whether all requested images have loaded */
+    isLoaded: boolean;
+    /** Number of images currently loading */
+    pendingCount: number;
+}
+/**
+ * Preload and cache images for canvas rendering.
+ *
+ * @param urls - Array of image URLs to preload
+ * @returns Cache getter, loading state, and pending count
+ */
+declare function useImageCache(urls: string[]): ImageCacheResult;
+
+/**
+ * useCamera Hook
+ *
+ * Manages camera pan/zoom state for canvas rendering.
+ * Provides mouse event handlers and coordinate conversion.
+ *
+ * @packageDocumentation
+ */
+
+interface CameraResult {
+    /** Mutable camera state ref (x, y, zoom) */
+    cameraRef: React.MutableRefObject<CameraState>;
+    /** Target camera position for smooth lerp centering. Set to null when reached. */
+    targetCameraRef: React.MutableRefObject<{
+        x: number;
+        y: number;
+    } | null>;
+    /** Whether the user is currently dragging */
+    isDragging: () => boolean;
+    /** Total drag distance — used to distinguish click from pan (threshold: 5px) */
+    dragDistance: () => number;
+    /** Mouse down handler — starts panning */
+    handleMouseDown: (e: React.MouseEvent) => void;
+    /** Mouse up handler — stops panning */
+    handleMouseUp: () => void;
+    /** Mouse move handler — pans camera if dragging, returns true if panning */
+    handleMouseMove: (e: React.MouseEvent, drawFn?: () => void) => boolean;
+    /** Mouse leave handler — cancels drag */
+    handleMouseLeave: () => void;
+    /** Wheel handler — zoom in/out */
+    handleWheel: (e: React.WheelEvent, drawFn?: () => void) => void;
+    /** Convert screen coordinates to world coordinates (inverse camera transform) */
+    screenToWorld: (clientX: number, clientY: number, canvas: HTMLCanvasElement, viewportSize: {
+        width: number;
+        height: number;
+    }) => {
+        x: number;
+        y: number;
+    };
+    /** Lerp camera toward target. Call in animation loop. Returns true if still animating. */
+    lerpToTarget: (t?: number) => boolean;
+}
+/**
+ * Camera hook for pan/zoom canvas rendering.
+ *
+ * @returns Camera state, event handlers, and coordinate conversion
+ */
+declare function useCamera(): CameraResult;
+
+/**
+ * useSpriteAnimations Hook
+ *
+ * Manages per-unit sprite sheet animation state for the canvas draw loop.
+ * Follows the useCanvasEffects pattern: mutable state in refs, pure functions
+ * in utils, no re-renders per frame.
+ *
+ * Project-agnostic: accepts generic sprite sheet resolution callbacks
+ * rather than a project-specific asset manifest.
+ *
+ * @packageDocumentation
+ */
+
+interface UseSpriteAnimationsResult {
+    /**
+     * Sync unit list and advance all animation timers.
+     * Call once per animation frame. Auto-detects movement
+     * and infers direction from position deltas.
+     */
+    syncUnits: (units: IsometricUnit[], deltaMs: number) => void;
+    /**
+     * Explicitly set a unit's animation (for combat: attack, hit, death).
+     * Optionally override direction.
+     */
+    setUnitAnimation: (unitId: string, animation: AnimationName, direction?: FacingDirection) => void;
+    /**
+     * Resolve the current frame for a unit. Returns null if no sprite sheet
+     * is available for this unit (falls back to static sprite in canvas).
+     * Pass this to IsometricCanvas.resolveUnitFrame.
+     */
+    resolveUnitFrame: (unitId: string) => ResolvedFrame | null;
+}
+interface UseSpriteAnimationsOptions {
+    /** Playback speed multiplier. 1.0 = baseline, 2.0 = double speed. Default: 1. */
+    speed?: number;
+}
+/**
+ * Resolve sprite sheet URLs for a unit. Return null if no sheet available.
+ * This is the project-agnostic callback version — projects pass manifest-specific logic.
+ */
+type SheetUrlResolver = (unit: IsometricUnit) => SpriteSheetUrls | null;
+/**
+ * Resolve frame dimensions for a unit's sprite sheet.
+ * Projects pass manifest-specific logic.
+ */
+type FrameDimsResolver = (unit: IsometricUnit) => SpriteFrameDims | null;
+/**
+ * Hook for managing per-unit sprite sheet animations.
+ *
+ * @param getSheetUrls - Callback to resolve sprite sheet URLs for a unit
+ * @param getFrameDims - Callback to resolve frame dimensions for a unit
+ * @param options - Playback speed options
+ */
+declare function useSpriteAnimations(getSheetUrls: SheetUrlResolver, getFrameDims: FrameDimsResolver, options?: UseSpriteAnimationsOptions): UseSpriteAnimationsResult;
+
+/**
+ * Isometric Coordinate Utilities
+ *
+ * Pure functions for 2:1 diamond isometric coordinate conversion.
+ * No React dependencies — usable in any context.
+ *
+ * @packageDocumentation
+ */
+/** Base tile width in pixels (before scale) */
+declare const TILE_WIDTH = 256;
+/** Base tile height in pixels (before scale) — full diamond height */
+declare const TILE_HEIGHT = 384;
+/** Floor diamond height — the "walkable surface" portion of the tile */
+declare const FLOOR_HEIGHT = 149;
+/**
+ * Feature type → fallback color mapping (when sprites not loaded).
+ */
+declare const FEATURE_COLORS: Record<string, string>;
+/**
+ * Convert tile grid coordinates to screen pixel coordinates.
+ *
+ * Uses 2:1 diamond isometric projection:
+ * - X increases to the lower-right
+ * - Y increases to the lower-left
+ *
+ * @param tileX - Grid X coordinate
+ * @param tileY - Grid Y coordinate
+ * @param scale - Render scale factor
+ * @param baseOffsetX - Horizontal offset to center the grid
+ * @returns Screen position { x, y } of the tile's top-left corner
+ */
+declare function isoToScreen(tileX: number, tileY: number, scale: number, baseOffsetX: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Convert screen pixel coordinates back to tile grid coordinates.
+ *
+ * Inverse of isoToScreen. Snaps to nearest integer tile position.
+ *
+ * @param screenX - Screen X in pixels
+ * @param screenY - Screen Y in pixels
+ * @param scale - Render scale factor
+ * @param baseOffsetX - Horizontal offset used in isoToScreen
+ * @returns Snapped grid position { x, y }
+ */
+declare function screenToIso(screenX: number, screenY: number, scale: number, baseOffsetX: number): {
+    x: number;
+    y: number;
+};
+
+/**
+ * Sprite Animation Engine
+ *
+ * Pure functions for sprite sheet animation: direction inference,
+ * frame computation, sheet resolution, and animation state management.
+ * No React dependencies — usable in any context.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Infer facing direction from a movement delta on the isometric grid.
+ * dx/dy are tile coordinate deltas (not screen pixels).
+ *
+ * Isometric grid:
+ *   NW ← (-x)    NE ← (-y)
+ *   SW ← (+y)    SE ← (+x)
+ */
+declare function inferDirection(dx: number, dy: number): FacingDirection;
+/**
+ * Map a 4-direction facing to the actual sheet file direction + flipX flag.
+ * We only have SE and SW sheet images. NE/NW are rendered by flipping:
+ *   SE → SE sheet, no flip
+ *   SW → SW sheet, no flip
+ *   NE → SW sheet, flipX (mirror of SW gives NE)
+ *   NW → SE sheet, flipX (mirror of SE gives NW)
+ */
+declare function resolveSheetDirection(facing: FacingDirection): {
+    sheetDir: SpriteDirection;
+    flipX: boolean;
+};
+/**
+ * Compute the current frame index and whether the animation has finished.
+ */
+declare function getCurrentFrame(animName: AnimationName, elapsed: number): {
+    frame: number;
+    finished: boolean;
+};
+/**
+ * Resolve a complete frame descriptor for canvas drawing.
+ * Returns null if no sprite sheet URLs are available for this unit.
+ */
+declare function resolveFrame(sheetUrls: SpriteSheetUrls | null, frameDims: SpriteFrameDims, animState: UnitAnimationState): ResolvedFrame | null;
+/**
+ * Create initial animation state for a unit (idle, facing SE).
+ */
+declare function createUnitAnimationState(unitId: string): UnitAnimationState;
+/**
+ * Transition to a new animation. Resets elapsed time.
+ * Optionally updates direction. Death cannot be overridden.
+ */
+declare function transitionAnimation(state: UnitAnimationState, newAnim: AnimationName, direction?: FacingDirection): UnitAnimationState;
+/**
+ * Advance animation state by deltaMs.
+ * Handles one-shot → queued/idle transitions automatically.
+ */
+declare function tickAnimationState(state: UnitAnimationState, deltaMs: number): UnitAnimationState;
+
+/**
+ * Sprite Sheet Constants
+ *
+ * Standard layout for 8-column × 5-row character sprite sheets.
+ * All characters share identical sheet geometry.
+ *
+ * @packageDocumentation
+ */
+
+/** Number of columns in a sprite sheet (frames per row) */
+declare const SHEET_COLUMNS = 8;
+/**
+ * Standard sprite sheet row layout.
+ * Row 0 = idle, Row 1 = walk, Row 2 = attack, Row 3 = hit, Row 4 = death.
+ */
+declare const SPRITE_SHEET_LAYOUT: Record<AnimationName, AnimationDef>;
+
 interface StatBadgeProps {
     /** Stat label */
     label: string;
@@ -3818,7 +4336,7 @@ interface StatBadgeProps {
     /** Display format */
     format?: 'number' | 'hearts' | 'bar' | 'text' | string;
     /** Icon component or emoji */
-    icon?: React.ReactNode;
+    icon?: React$1.ReactNode;
     /** Size variant */
     size?: 'sm' | 'md' | 'lg' | string;
     /** Visual variant */
@@ -3867,43 +4385,6 @@ declare namespace GameHud {
     var displayName: string;
 }
 
-interface GameControl {
-    /** Unique identifier */
-    id?: string;
-    /** Alias for id (schema compatibility) */
-    key?: string;
-    /** Event to emit on press */
-    event: string;
-    /** Display label */
-    label?: string;
-    /** Icon component or emoji */
-    icon?: React.ReactNode;
-    /** Button variant */
-    variant?: "primary" | "secondary" | "ghost" | string;
-}
-interface GameControlsProps {
-    /** Control layout type */
-    layout: "dpad" | "joystick" | "buttons" | "custom" | string;
-    /** Position on screen */
-    position: "bottom-left" | "bottom-right" | "bottom-center" | "split" | string;
-    /** Controls to display - accepts readonly for compatibility with generated const arrays */
-    controls?: readonly GameControl[];
-    /** Called when control is pressed/released */
-    onControl?: (event: string, pressed: boolean) => void;
-    /** Size variant */
-    size?: "sm" | "md" | "lg";
-    /** Additional CSS classes */
-    className?: string;
-    /** Whether controls are visible */
-    visible?: boolean;
-    /** Opacity when visible */
-    opacity?: number;
-}
-declare function GameControls({ layout, position, controls, onControl, size, className, visible, opacity, }: GameControlsProps): react_jsx_runtime.JSX.Element | null;
-declare namespace GameControls {
-    var displayName: string;
-}
-
 interface MenuOption {
     /** Optional ID (generated from index if not provided) */
     id?: string;
@@ -3947,39 +4428,6 @@ declare namespace GameMenu {
     var displayName: string;
 }
 
-interface PauseOption {
-    /** Display label */
-    label: string;
-    /** Event to emit on click */
-    event?: string;
-    /** Page to navigate to */
-    navigatesTo?: string;
-    /** Button variant */
-    variant?: "primary" | "secondary" | "ghost" | "destructive";
-}
-interface GamePauseOverlayProps {
-    /** Pause menu options */
-    options?: PauseOption[];
-    /** Alias for options (schema compatibility) */
-    menuItems?: PauseOption[];
-    /** Called when an option is selected (legacy callback, prefer event bus) */
-    onSelect?: (option: PauseOption) => void;
-    /** Event bus for emitting UI events (optional, uses hook if not provided) */
-    eventBus?: EventBusContextType;
-    /** Title (default: "PAUSED") */
-    title?: string;
-    /** Additional CSS classes */
-    className?: string;
-    /** Whether the pause menu is visible */
-    visible?: boolean;
-    /** Called when clicking outside the menu */
-    onDismiss?: () => void;
-}
-declare function GamePauseOverlay({ options, menuItems, onSelect, eventBus: eventBusProp, title, className, visible, onDismiss, }: GamePauseOverlayProps): react_jsx_runtime.JSX.Element | null;
-declare namespace GamePauseOverlay {
-    var displayName: string;
-}
-
 interface GameOverStat {
     /** Stat label */
     label: string;
@@ -3994,7 +4442,7 @@ interface GameOverStat {
     /** Display format */
     format?: "number" | "time" | "text";
     /** Icon */
-    icon?: React.ReactNode;
+    icon?: React$1.ReactNode;
 }
 interface GameOverAction {
     /** Display label */
@@ -4035,145 +4483,18 @@ declare namespace GameOverScreen {
     var displayName: string;
 }
 
-interface LevelData {
-    /** Unique level identifier */
+/**
+ * InventoryPanel Component
+ *
+ * Grid-based inventory UI with item selection and tooltips.
+ */
+interface InventoryItem {
     id: string;
-    /** Level ID (alternative to id) */
-    levelId?: string;
-    /** Level number */
-    number?: number;
-    /** Level name/title */
+    type: string;
+    quantity: number;
+    sprite?: string;
     name?: string;
-    /** Stars earned (0-3) */
-    stars?: number;
-    /** Difficulty level */
-    difficulty?: 'easy' | 'medium' | 'hard' | string;
-    /** Whether the level is locked */
-    isLocked?: boolean;
-    /** Best score on this level */
-    bestScore?: number;
-    /** Thumbnail image URL */
-    thumbnail?: string;
-    /** Allow additional properties from schema */
-    [key: string]: unknown;
-}
-interface LevelFieldDisplay {
-    /** Field name */
-    field?: string;
-    /** Display type */
-    display?: 'title' | 'number' | 'stars' | 'locked' | 'thumbnail' | string;
-}
-interface LevelSelectProps {
-    /** Level data */
-    levels?: LevelData[];
-    /** Entity name (schema config) */
-    entity?: string;
-    /** Layout variant */
-    layout?: 'grid' | 'list' | 'carousel' | string;
-    /** Fields to display per level */
-    fields?: LevelFieldDisplay[];
-    /** Event to emit on selection (schema config) */
-    selectEvent?: string;
-    /** Called when a level is selected */
-    onSelect?: (level: LevelData) => void;
-    /** Path to navigate to on selection. Supports :id, :levelId, :number placeholders */
-    navigatesTo?: string;
-    /** Currently selected level ID */
-    selectedId?: string;
-    /** Maximum stars possible per level */
-    maxStars?: number;
-    /** Additional CSS classes */
-    className?: string;
-    /** Title above the level grid */
-    title?: string;
-}
-declare function LevelSelect({ levels, entity: _entity, layout, fields, selectEvent: _selectEvent, onSelect, navigatesTo, selectedId, maxStars, className, title, }: LevelSelectProps): react_jsx_runtime.JSX.Element;
-declare namespace LevelSelect {
-    var displayName: string;
-}
-
-/**
- * TilemapRenderer Component
- *
- * Canvas-based tilemap renderer with culling and parallax support.
- */
-interface TileLayer {
-    name: string;
-    data: number[];
-    width: number;
-    height: number;
-    visible?: boolean;
-}
-interface Tileset {
-    url: string;
-    tileWidth: number;
-    tileHeight: number;
-    columns: number;
-}
-interface ParallaxConfig {
-    layer: string;
-    factor: number;
-}
-interface TilemapRendererProps {
-    /** Tile layers to render */
-    layers: TileLayer[];
-    /** Tileset configuration */
-    tileset: Tileset;
-    /** Camera position */
-    camera: {
-        x: number;
-        y: number;
-    };
-    /** Viewport width in pixels */
-    viewportWidth: number;
-    /** Viewport height in pixels */
-    viewportHeight: number;
-    /** Enable pixel art rendering (no smoothing) */
-    pixelArt?: boolean;
-    /** Parallax configuration per layer */
-    parallaxLayers?: ParallaxConfig[];
-    /** Optional className */
-    className?: string;
-    /** Scale factor for rendering */
-    scale?: number;
-    /** Show debug grid */
-    debug?: boolean;
-}
-/**
- * Tilemap renderer component with efficient canvas-based rendering
- *
- * @example
- * ```tsx
- * <TilemapRenderer
- *   layers={levelData.layers}
- *   tileset={{
- *     url: '/tilesets/terrain.png',
- *     tileWidth: 16,
- *     tileHeight: 16,
- *     columns: 16
- *   }}
- *   camera={{ x: playerX - 160, y: playerY - 120 }}
- *   viewportWidth={320}
- *   viewportHeight={240}
- *   pixelArt
- *   scale={2}
- * />
- * ```
- */
-declare function TilemapRenderer({ layers, tileset, camera, viewportWidth, viewportHeight, pixelArt, parallaxLayers, className, scale, debug, }: TilemapRendererProps): JSX.Element;
-
-/**
- * InventoryPanel Component
- *
- * Grid-based inventory UI with item selection and tooltips.
- */
-interface InventoryItem {
-    id: string;
-    type: string;
-    quantity: number;
-    sprite?: string;
-    name?: string;
-    description?: string;
+    description?: string;
 }
 interface InventoryPanelProps {
     /** Array of items in inventory */
@@ -4273,102 +4594,6 @@ interface DialogueBoxProps {
  */
 declare function DialogueBox({ dialogue, typewriterSpeed, position, onComplete, onChoice, onAdvance, className, }: DialogueBoxProps): JSX.Element;
 
-/**
- * InputListener - Invisible component that captures keyboard input
- *
- * Rendered by InputCapture trait via render_ui effect.
- * Listens for keydown/keyup events and:
- * 1. Updates the Input singleton entity
- * 2. Emits INPUT:* events via event bus
- *
- * This follows the closed circuit pattern:
- * Trait (render_ui) → Component (InputListener) → Events (INPUT:*) → Trait (state machine)
- *
- * @generated pattern component
- */
-
-/**
- * Input binding configuration
- */
-interface InputBinding {
-    /** Key code or key value (e.g., 'ArrowLeft', 'KeyA', 'Space') */
-    key: string;
-    /** Field name in the Input singleton (e.g., 'left', 'right', 'jump') */
-    field: string;
-    /** Optional custom event name (defaults to INPUT:{FIELD}_DOWN/UP) */
-    event?: string;
-}
-/**
- * InputListener props
- */
-interface InputListenerProps {
-    /** Key bindings configuration */
-    bindings?: readonly InputBinding[];
-    /** Whether input listening is enabled */
-    enabled?: boolean;
-    /** Event bus for emitting events (optional, uses hook if not provided) */
-    eventBus?: EventBusContextType;
-}
-/**
- * InputListener Component
- *
- * Invisible component that captures keyboard input and emits events.
- * Designed to be rendered by the InputCapture trait via render_ui effect.
- */
-declare function InputListener({ bindings, enabled, eventBus: eventBusProp, }: InputListenerProps): null;
-declare namespace InputListener {
-    var displayName: string;
-}
-
-/**
- * CollisionDetector - Invisible component that runs collision detection
- *
- * Rendered by Collision2DSystem trait via render_ui effect.
- * Runs AABB collision checks each frame and emits collision events.
- *
- * This follows the closed circuit pattern:
- * Trait (render_ui) → Component (CollisionDetector) → Events (COLLISION_*) → Trait (state machine)
- *
- * @generated pattern component
- */
-
-/**
- * Collision rule configuration
- */
-interface CollisionRule {
-    /** Entity type A */
-    typeA: string;
-    /** Entity type B */
-    typeB: string;
-    /** Whether this is a trigger (pass-through) or solid collision */
-    isTrigger?: boolean;
-    /** Custom event name to emit (defaults to COLLISION_ENTER/TRIGGER_ENTER) */
-    event?: string;
-}
-/**
- * CollisionDetector props
- */
-interface CollisionDetectorProps {
-    /** Collision detection algorithm */
-    algorithm?: 'aabb' | 'circle';
-    /** Collision rules to check */
-    rules?: readonly CollisionRule[];
-    /** Whether collision detection is enabled */
-    enabled?: boolean;
-    /** Event bus for emitting events (optional, uses hook if not provided) */
-    eventBus?: EventBusContextType;
-}
-/**
- * CollisionDetector Component
- *
- * Invisible component that runs collision detection each frame and emits events.
- * Designed to be rendered by the Collision2DSystem trait via render_ui effect.
- */
-declare function CollisionDetector({ algorithm, rules, enabled, eventBus: eventBusProp, }: CollisionDetectorProps): null;
-declare namespace CollisionDetector {
-    var displayName: string;
-}
-
 /**
  * UISlotRenderer Component
  *
@@ -4531,6 +4756,494 @@ interface ToastSlotProps {
  */
 declare const ToastSlot: React__default.FC<ToastSlotProps>;
 
+/**
+ * Chart Organism Component
+ *
+ * A data visualization component supporting bar, line, pie, and area chart types.
+ * Composes atoms and molecules for layout, uses CSS variables for theming.
+ *
+ * Orbital Component Interface Compliance:
+ * - Entity binding with auto-fetch when entity is a string
+ * - Event emission via useEventBus (UI:* events)
+ * - isLoading and error state props
+ * - className for external styling
+ */
+
+type ChartType = "bar" | "line" | "pie" | "area" | "donut";
+interface ChartDataPoint {
+    label: string;
+    value: number;
+    color?: string;
+}
+interface ChartSeries {
+    name: string;
+    data: readonly ChartDataPoint[];
+    color?: string;
+}
+interface ChartAction {
+    label: string;
+    event?: string;
+    navigatesTo?: string;
+    variant?: "primary" | "secondary" | "ghost";
+}
+interface ChartProps {
+    /** Chart title */
+    title?: string;
+    /** Chart subtitle / description */
+    subtitle?: string;
+    /** Chart type */
+    chartType?: ChartType;
+    /** Data series */
+    series?: readonly ChartSeries[];
+    /** Simple data (single series shorthand) */
+    data?: readonly ChartDataPoint[];
+    /** Chart height in px */
+    height?: number;
+    /** Show legend */
+    showLegend?: boolean;
+    /** Show values on chart */
+    showValues?: boolean;
+    /** Actions for chart interactions */
+    actions?: readonly ChartAction[];
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const Chart: React__default.FC<ChartProps>;
+
+/**
+ * Meter Organism Component
+ *
+ * A gauge/meter component for displaying a value within a range.
+ * Supports linear, radial, and segmented display modes.
+ *
+ * Orbital Component Interface Compliance:
+ * - Entity binding with auto-fetch when entity is a string
+ * - Event emission via useEventBus (UI:* events)
+ * - isLoading and error state props
+ * - className for external styling
+ */
+
+type MeterVariant = "linear" | "radial" | "segmented";
+interface MeterThreshold {
+    value: number;
+    color: string;
+    label?: string;
+}
+interface MeterAction {
+    label: string;
+    event?: string;
+    navigatesTo?: string;
+    variant?: "primary" | "secondary" | "ghost";
+}
+interface MeterProps {
+    /** Current value */
+    value: number;
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Display label */
+    label?: string;
+    /** Unit suffix (e.g., '%', 'MB', 'credits') */
+    unit?: string;
+    /** Display variant */
+    variant?: MeterVariant;
+    /** Color thresholds */
+    thresholds?: readonly MeterThreshold[];
+    /** Number of segments (for segmented variant) */
+    segments?: number;
+    /** Show value text */
+    showValue?: boolean;
+    /** Size (for radial variant) */
+    size?: "sm" | "md" | "lg";
+    /** Actions */
+    actions?: readonly MeterAction[];
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const Meter: React__default.FC<MeterProps>;
+
+/**
+ * Timeline Organism Component
+ *
+ * A vertical timeline component for displaying chronological events.
+ * Composes atoms and molecules for layout, uses CSS variables for theming.
+ *
+ * Orbital Component Interface Compliance:
+ * - Entity binding with auto-fetch when entity is a string
+ * - Event emission via useEventBus (UI:* events)
+ * - isLoading and error state props
+ * - className for external styling
+ */
+
+type TimelineItemStatus = "complete" | "active" | "pending" | "error";
+interface TimelineItem {
+    /** Unique identifier */
+    id: string;
+    /** Item title */
+    title: string;
+    /** Item description */
+    description?: string;
+    /** Timestamp string */
+    date?: string;
+    /** Status indicator */
+    status?: TimelineItemStatus;
+    /** Icon override */
+    icon?: LucideIcon;
+    /** Additional metadata tags */
+    tags?: readonly string[];
+}
+interface TimelineAction {
+    label: string;
+    event?: string;
+    navigatesTo?: string;
+    variant?: "primary" | "secondary" | "ghost";
+}
+interface TimelineProps {
+    /** Timeline title */
+    title?: string;
+    /** Timeline items */
+    items?: readonly TimelineItem[];
+    /** Schema-driven data */
+    data?: readonly Record<string, unknown>[];
+    /** Fields to display */
+    fields?: readonly string[];
+    /** Actions per item */
+    itemActions?: readonly TimelineAction[];
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const Timeline: React__default.FC<TimelineProps>;
+
+/**
+ * MediaGallery Organism Component
+ *
+ * A gallery component for displaying images and media in a grid layout.
+ * Supports lightbox viewing, selection, and upload interactions.
+ *
+ * Orbital Component Interface Compliance:
+ * - Entity binding with auto-fetch when entity is a string
+ * - Event emission via useEventBus (UI:* events)
+ * - isLoading and error state props
+ * - className for external styling
+ */
+
+interface MediaItem {
+    /** Unique identifier */
+    id: string;
+    /** Media URL */
+    src: string;
+    /** Alt text */
+    alt?: string;
+    /** Thumbnail URL (defaults to src) */
+    thumbnail?: string;
+    /** Media type */
+    mediaType?: "image" | "video";
+    /** Caption */
+    caption?: string;
+    /** File size */
+    fileSize?: string;
+}
+interface MediaGalleryAction {
+    label: string;
+    event?: string;
+    navigatesTo?: string;
+    variant?: "primary" | "secondary" | "ghost";
+}
+interface MediaGalleryProps {
+    /** Gallery title */
+    title?: string;
+    /** Media items */
+    items?: readonly MediaItem[];
+    /** Schema-driven data */
+    data?: readonly Record<string, unknown>[];
+    /** Column count */
+    columns?: 2 | 3 | 4 | 5 | 6;
+    /** Enable item selection */
+    selectable?: boolean;
+    /** Selected item IDs */
+    selectedItems?: readonly string[];
+    /** Selection change callback */
+    onSelectionChange?: (ids: string[]) => void;
+    /** Show upload button */
+    showUpload?: boolean;
+    /** Actions */
+    actions?: readonly MediaGalleryAction[];
+    /** Aspect ratio for thumbnails */
+    aspectRatio?: "square" | "landscape" | "portrait";
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const MediaGallery: React__default.FC<MediaGalleryProps>;
+
+/**
+ * SignaturePad Organism Component
+ *
+ * A canvas-based signature capture pad.
+ * Uses a minimal canvas wrapper (necessary for drawing) but composes all
+ * surrounding UI with atoms and molecules.
+ *
+ * Orbital Component Interface Compliance:
+ * - Event emission via useEventBus (UI:* events)
+ * - isLoading and error state props
+ * - className for external styling
+ */
+
+interface SignaturePadProps {
+    /** Label above the pad */
+    label?: string;
+    /** Helper text */
+    helperText?: string;
+    /** Stroke color */
+    strokeColor?: string;
+    /** Stroke width */
+    strokeWidth?: number;
+    /** Pad height */
+    height?: number;
+    /** Whether the pad is read-only */
+    readOnly?: boolean;
+    /** Existing signature image URL */
+    value?: string;
+    /** Callback when signature changes */
+    onChange?: (dataUrl: string | null) => void;
+    /** Event to emit on sign */
+    signEvent?: string;
+    /** Event to emit on clear */
+    clearEvent?: string;
+    /** Entity name for schema-driven context */
+    entity?: string;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const SignaturePad: React__default.FC<SignaturePadProps>;
+
+/**
+ * DocumentViewer Organism Component
+ *
+ * A document viewer for displaying PDFs, documents, and rich text content.
+ * Uses iframe for PDF rendering (necessary) and atoms for all surrounding UI.
+ *
+ * Orbital Component Interface Compliance:
+ * - Entity binding with auto-fetch when entity is a string
+ * - Event emission via useEventBus (UI:* events)
+ * - isLoading and error state props
+ * - className for external styling
+ */
+
+type DocumentType = "pdf" | "text" | "html" | "markdown";
+interface DocumentAction {
+    label: string;
+    event?: string;
+    navigatesTo?: string;
+    variant?: "primary" | "secondary" | "ghost";
+}
+interface DocumentViewerProps {
+    /** Document title */
+    title?: string;
+    /** Document URL (for PDF/external documents) */
+    src?: string;
+    /** Document content (for text/html/markdown) */
+    content?: string;
+    /** Document type */
+    documentType?: DocumentType;
+    /** Current page (for multi-page documents) */
+    currentPage?: number;
+    /** Total pages */
+    totalPages?: number;
+    /** Viewer height */
+    height?: number | string;
+    /** Show toolbar */
+    showToolbar?: boolean;
+    /** Show download button */
+    showDownload?: boolean;
+    /** Show print button */
+    showPrint?: boolean;
+    /** Actions */
+    actions?: readonly DocumentAction[];
+    /** Multiple documents (tabbed view) */
+    documents?: readonly {
+        label: string;
+        src?: string;
+        content?: string;
+        documentType?: DocumentType;
+    }[];
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const DocumentViewer: React__default.FC<DocumentViewerProps>;
+
+/**
+ * GraphCanvas Organism Component
+ *
+ * A force-directed graph visualization component for node-link data.
+ * Uses canvas (necessary for performant graph rendering) with atom wrappers.
+ *
+ * Orbital Component Interface Compliance:
+ * - Entity binding with auto-fetch when entity is a string
+ * - Event emission via useEventBus (UI:* events)
+ * - isLoading and error state props
+ * - className for external styling
+ */
+
+interface GraphNode {
+    id: string;
+    label?: string;
+    group?: string;
+    color?: string;
+    size?: number;
+    /** Position (optional, computed if missing) */
+    x?: number;
+    y?: number;
+}
+interface GraphEdge {
+    source: string;
+    target: string;
+    label?: string;
+    weight?: number;
+    color?: string;
+}
+interface GraphAction {
+    label: string;
+    event?: string;
+    navigatesTo?: string;
+    variant?: "primary" | "secondary" | "ghost";
+}
+interface GraphCanvasProps {
+    /** Graph title */
+    title?: string;
+    /** Graph nodes */
+    nodes?: readonly GraphNode[];
+    /** Graph edges */
+    edges?: readonly GraphEdge[];
+    /** Canvas height */
+    height?: number;
+    /** Show node labels */
+    showLabels?: boolean;
+    /** Enable zoom/pan */
+    interactive?: boolean;
+    /** Enable node dragging */
+    draggable?: boolean;
+    /** Actions */
+    actions?: readonly GraphAction[];
+    /** On node click */
+    onNodeClick?: (node: GraphNode) => void;
+    /** Node click event */
+    nodeClickEvent?: string;
+    /** Layout algorithm */
+    layout?: "force" | "circular" | "grid";
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const GraphCanvas: React__default.FC<GraphCanvasProps>;
+
+/**
+ * CodeViewer Organism Component
+ *
+ * A code/diff viewer with syntax highlighting and line numbers.
+ * Composes atoms and molecules for layout. Uses pre/code elements
+ * which are semantically necessary for code display.
+ *
+ * Orbital Component Interface Compliance:
+ * - Entity binding with auto-fetch when entity is a string
+ * - Event emission via useEventBus (UI:* events)
+ * - isLoading and error state props
+ * - className for external styling
+ */
+
+type CodeViewerMode = "code" | "diff";
+interface DiffLine {
+    type: "add" | "remove" | "context";
+    content: string;
+    lineNumber?: number;
+}
+interface CodeViewerAction {
+    label: string;
+    event?: string;
+    navigatesTo?: string;
+    variant?: "primary" | "secondary" | "ghost";
+}
+interface CodeViewerProps {
+    /** Viewer title */
+    title?: string;
+    /** Code content */
+    code?: string;
+    /** Language for display label */
+    language?: string;
+    /** Diff lines (for diff mode) */
+    diff?: readonly DiffLine[];
+    /** Old value (for generating diff) */
+    oldValue?: string;
+    /** New value (for generating diff) */
+    newValue?: string;
+    /** Display mode */
+    mode?: CodeViewerMode;
+    /** Show line numbers */
+    showLineNumbers?: boolean;
+    /** Show copy button */
+    showCopy?: boolean;
+    /** Enable word wrap */
+    wordWrap?: boolean;
+    /** Max height before scrolling */
+    maxHeight?: number | string;
+    /** Multiple files (tabbed view) */
+    files?: readonly {
+        label: string;
+        code: string;
+        language?: string;
+    }[];
+    /** Actions */
+    actions?: readonly CodeViewerAction[];
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const CodeViewer: React__default.FC<CodeViewerProps>;
+
 interface NavItem {
     label: string;
     href: string;
@@ -4957,4 +5670,318 @@ interface GameShellProps {
  */
 declare const GameShell: React__default.FC<GameShellProps>;
 
-export { Accordion, type AccordionItem, type AccordionProps, Card as ActionCard, type CardProps as ActionCardProps, Alert, type AlertProps, type AlertVariant, AuthLayout, type AuthLayoutProps, Avatar, type AvatarProps, type AvatarSize, type AvatarStatus, Badge, type BadgeProps, type BadgeVariant, Box, type BoxBg, type BoxMargin, type BoxPadding, type BoxProps, type BoxRounded, type BoxShadow, Breadcrumb, type BreadcrumbItem, type BreadcrumbProps, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, Card$1 as Card, type CardAction, CardBody, CardContent, CardFooter, CardGrid, type CardGridGap, type CardGridProps, CardHeader, type CardProps$1 as CardProps, CardTitle, Center, type CenterProps, Checkbox, type CheckboxProps, type CollisionDef, CollisionDetector, type CollisionDetectorProps, type CollisionRule, type Column, type ColumnConfig, type ConditionalContext, ConditionalWrapper, type ConditionalWrapperProps, ConfirmDialog, type ConfirmDialogProps, type ConfirmDialogVariant, Container, type ContainerProps, ControlButton, type ControlButtonProps, type CounterSize, CounterTemplate, type CounterTemplateProps, type CounterVariant, type CrudItem, CrudTemplate, type CrudTemplateProps, type CrudVariant, DashboardGrid, type DashboardGridCell, type DashboardGridProps, DashboardLayout, type DashboardLayoutProps, DataTable, type DataTableProps, type DetailField, DetailPanel, type DetailPanelProps, type DetailSection, DialogueBox, type DialogueBoxProps, type DialogueChoice, type DialogueNode, Divider, type DividerOrientation, type DividerProps, Drawer, type DrawerPosition, type DrawerProps, type DrawerSize, DrawerSlot, type DrawerSlotProps, EmptyState, type EmptyStateProps, Entity, type EntityRenderer, ErrorState, type ErrorStateProps, EventBusContextType, type FieldConfig, type FilterDefinition, FilterGroup, type FilterGroupProps, type FilterValue, Flex, type FlexProps, FloatingActionButton, type FloatingActionButtonProps, Form, FormActions, type FormActionsProps, FormField, type FormFieldConfig, type FormFieldProps, FormLayout, type FormLayoutProps, type FormProps, FormSection$1 as FormSection, FormSectionHeader, type FormSectionHeaderProps, type FormSectionProps, FormTemplate, type FormTemplateProps, type FormVariant, GameCanvas, type GameCanvasProps, type GameControl, GameControls, type GameControlsProps, type GameEntity, GameHud, type GameHudElement, type GameHudProps, type GameHudStat, GameMenu, type GameMenuProps, type GameOverAction, GameOverScreen, type GameOverScreenProps, type GameOverStat, GamePauseOverlay, type GamePauseOverlayProps, GameShell, type GameShellProps, GameTemplate, type GameTemplateProps, GenericAppTemplate, type GenericAppTemplateProps, Grid, type GridProps, HStack, type HStackProps, Header, type HeaderProps, HealthBar, type HealthBarProps, type HighlightType, Icon, type IconAnimation, type IconProps, type IconSize, Input, type InputBinding, InputGroup, type InputGroupProps, InputListener, type InputListenerProps, type InputProps, type InventoryItem, InventoryPanel, type InventoryPanelProps, Label, type LabelProps, type LawReference, LawReferenceTooltip, type LawReferenceTooltipProps, type LevelData, type LevelFieldDisplay, LevelSelect, type LevelSelectProps, List, type ListItem, type ListProps, ListTemplate, type ListTemplateItem, type ListTemplateProps, type ListVariant, LoadingState, type LoadingStateProps, MasterDetail, type MasterDetailProps, Menu, type MenuItem, type MenuOption, type MenuProps, Modal, type ModalProps, type ModalSize, ModalSlot, type ModalSlotProps, type NavItem, Navigation, type NavigationItem, type NavigationProps, OrbitalVisualization, type OrbitalVisualizationProps, Overlay, type OverlayProps, type PageBreadcrumb, PageHeader, type PageHeaderProps, Pagination, type PaginationProps, type ParallaxConfig, type PauseOption, Popover, type PopoverProps, ProgressBar, type ProgressBarColor, type ProgressBarProps, type ProgressBarVariant, Radio, type RadioProps, type RelationOption, RelationSelect, type RelationSelectProps, RepeatableFormSection, type RepeatableFormSectionProps, type RepeatableItem, type RowAction, ScoreDisplay, type ScoreDisplayProps, SearchInput, type SearchInputProps, Section, type SectionProps, Select, type SelectOption, type SelectProps, type SettingsFieldConfig, type SettingsSectionConfig, SettingsTemplate, type SettingsTemplateProps, type SettingsVariant, SidePanel, type SidePanelProps, Sidebar, type SidebarItem, type SidebarProps, SimpleGrid, type SimpleGridProps, SlotContent, SlotContentRenderer, type SortDirection, Spacer, type SpacerProps, type SpacerSize, Spinner, type SpinnerProps, Split, SplitPane, type SplitPaneProps, type SplitProps, Sprite, type SpriteProps, Stack, type StackAlign, type StackDirection, type StackGap, type StackJustify, type StackProps, StatCard, type StatCardProps, Switch, type SwitchProps, type TabDefinition, type TabItem, TabbedContainer, type TabbedContainerProps, Table, type TableColumn, type TableProps, Tabs, type TabsProps, TextHighlight, type TextHighlightProps, Textarea, type TextareaProps, ThemeSelector, ThemeToggle, type ThemeToggleProps, TilemapRenderer, type TilemapRendererProps, type TileLayer as TilemapTileLayer, type Tileset as TilemapTileset, Toast, type ToastProps, ToastSlot, type ToastSlotProps, type ToastVariant, Tooltip, type TooltipProps, Typography, type TypographyProps, type TypographyVariant, UISlot, UISlotComponent, UISlotRenderer, type UISlotRendererProps, VStack, type VStackProps, ViolationAlert, type ViolationAlertProps, type ViolationRecord, WizardContainer, type WizardContainerProps, WizardNavigation, type WizardNavigationProps, WizardProgress, type WizardProgressProps, type WizardProgressStep, type WizardStep, drawSprite };
+/**
+ * BattleTemplate
+ *
+ * Generalized tactical battle template composing IsometricCanvas from almadar-ui.
+ * Provides turn-based phase management, movement animation, valid-move/attack-target
+ * calculation, screen shake/flash, and a game-over overlay.
+ *
+ * Game-specific UI (combat log, trait viewer, damage popups, etc.) is injected via
+ * render-prop slots so this template remains project-agnostic.
+ *
+ * @packageDocumentation
+ */
+
+/** Battle phases an encounter walks through */
+type BattlePhase = 'observation' | 'selection' | 'movement' | 'action' | 'enemy_turn' | 'game_over';
+/** A unit participating in battle */
+interface BattleUnit {
+    id: string;
+    name: string;
+    unitType?: string;
+    heroId?: string;
+    sprite?: string;
+    team: 'player' | 'enemy';
+    position: {
+        x: number;
+        y: number;
+    };
+    health: number;
+    maxHealth: number;
+    movement: number;
+    attack: number;
+    defense: number;
+    traits?: {
+        name: string;
+        currentState: string;
+        states: string[];
+        cooldown?: number;
+    }[];
+}
+/** Minimal tile for map generation */
+interface BattleTile {
+    x: number;
+    y: number;
+    terrain: string;
+    terrainSprite?: string;
+}
+/** Context exposed to render-prop slots */
+interface BattleSlotContext {
+    phase: BattlePhase;
+    turn: number;
+    selectedUnit: BattleUnit | null;
+    hoveredUnit: BattleUnit | null;
+    playerUnits: BattleUnit[];
+    enemyUnits: BattleUnit[];
+    gameResult: 'victory' | 'defeat' | null;
+    onEndTurn: () => void;
+    onCancel: () => void;
+    onReset: () => void;
+    attackTargets: Array<{
+        x: number;
+        y: number;
+    }>;
+    /** Resolve screen position of a tile for overlays */
+    tileToScreen: (x: number, y: number) => {
+        x: number;
+        y: number;
+    };
+}
+interface BattleTemplateProps {
+    /** Initial units for the battle */
+    initialUnits: BattleUnit[];
+    /** Isometric tiles (pre-resolved with terrainSprite) */
+    tiles: IsometricTile[];
+    /** Canvas render scale */
+    scale?: number;
+    /** Board width for bounds checking */
+    boardWidth?: number;
+    /** Board height for bounds checking */
+    boardHeight?: number;
+    /** Asset manifest for IsometricCanvas */
+    assetManifest?: {
+        baseUrl: string;
+        terrains?: Record<string, string>;
+        units?: Record<string, string>;
+        features?: Record<string, string>;
+        effects?: Record<string, string>;
+    };
+    /** Background image URL for canvas */
+    backgroundImage?: string;
+    /** Unit draw-size multiplier */
+    unitScale?: number;
+    /** Header area — receives battle context */
+    header?: (ctx: BattleSlotContext) => React__default.ReactNode;
+    /** Sidebar content (combat log, unit roster, etc.) */
+    sidebar?: (ctx: BattleSlotContext) => React__default.ReactNode;
+    /** Floating action buttons */
+    actions?: (ctx: BattleSlotContext) => React__default.ReactNode;
+    /** Floating overlays above the canvas (damage popups, tooltips) */
+    overlay?: (ctx: BattleSlotContext) => React__default.ReactNode;
+    /** Game-over screen overlay */
+    gameOverOverlay?: (ctx: BattleSlotContext) => React__default.ReactNode;
+    /** Static features (obstacles, decorations) rendered on the grid */
+    features?: IsometricFeature[];
+    /** Called when a unit attacks another */
+    onAttack?: (attacker: BattleUnit, target: BattleUnit, damage: number) => void;
+    /** Called when battle ends */
+    onGameEnd?: (result: 'victory' | 'defeat') => void;
+    /** Called after a unit moves */
+    onUnitMove?: (unit: BattleUnit, to: {
+        x: number;
+        y: number;
+    }) => void;
+    /** Custom combat damage calculator */
+    calculateDamage?: (attacker: BattleUnit, target: BattleUnit) => number;
+    onDrawEffects?: (ctx: CanvasRenderingContext2D, timestamp: number) => void;
+    hasActiveEffects?: boolean;
+    effectSpriteUrls?: string[];
+    resolveUnitFrame?: (unitId: string) => ResolvedFrame | null;
+    className?: string;
+}
+declare function BattleTemplate({ initialUnits, tiles, scale, boardWidth, boardHeight, assetManifest, backgroundImage, unitScale, header, sidebar, actions, overlay, gameOverOverlay, features, onAttack, onGameEnd, onUnitMove, calculateDamage, onDrawEffects, hasActiveEffects, effectSpriteUrls, resolveUnitFrame, className, }: BattleTemplateProps): JSX.Element;
+declare namespace BattleTemplate {
+    var displayName: string;
+}
+
+/**
+ * CastleTemplate
+ *
+ * Generalized castle / base-management template composing IsometricCanvas from
+ * almadar-ui. Renders an isometric courtyard/base view and exposes a side-panel
+ * area via slots for game-specific UI (building details, recruitment, garrison).
+ *
+ * @packageDocumentation
+ */
+
+/** Context exposed to render-prop slots */
+interface CastleSlotContext {
+    /** Currently hovered tile coordinates (null when not hovering) */
+    hoveredTile: {
+        x: number;
+        y: number;
+    } | null;
+    /** Feature that sits on the hovered tile, if any */
+    hoveredFeature: IsometricFeature | null;
+    /** Unit that sits on the hovered tile, if any */
+    hoveredUnit: IsometricUnit | null;
+    /** The clicked feature (e.g. building) for detail view */
+    selectedFeature: IsometricFeature | null;
+    /** Clear selected feature */
+    clearSelection: () => void;
+    /** Resolve screen position for overlay positioning */
+    tileToScreen: (x: number, y: number) => {
+        x: number;
+        y: number;
+    };
+    /** Canvas scale */
+    scale: number;
+}
+interface CastleTemplateProps {
+    /** Isometric tiles (pre-resolved with terrainSprite) */
+    tiles: IsometricTile[];
+    /** Building features rendered on the grid */
+    features?: IsometricFeature[];
+    /** Garrison / stationed units on the grid */
+    units?: IsometricUnit[];
+    /** Canvas render scale */
+    scale?: number;
+    /** Asset manifest for IsometricCanvas */
+    assetManifest?: {
+        baseUrl: string;
+        terrains?: Record<string, string>;
+        units?: Record<string, string>;
+        features?: Record<string, string>;
+    };
+    /** Background image URL */
+    backgroundImage?: string;
+    /** Top bar / header */
+    header?: (ctx: CastleSlotContext) => React__default.ReactNode;
+    /** Side panel content (buildings list, recruit tab, garrison tab) */
+    sidePanel?: (ctx: CastleSlotContext) => React__default.ReactNode;
+    /** Canvas overlay (hover tooltips, etc.) */
+    overlay?: (ctx: CastleSlotContext) => React__default.ReactNode;
+    /** Bottom bar (income summary, etc.) */
+    footer?: (ctx: CastleSlotContext) => React__default.ReactNode;
+    /** Called when a feature (building) is clicked */
+    onFeatureClick?: (feature: IsometricFeature) => void;
+    /** Called when a unit is clicked */
+    onUnitClick?: (unit: IsometricUnit) => void;
+    /** Called when any tile is clicked */
+    onTileClick?: (x: number, y: number) => void;
+    className?: string;
+}
+declare function CastleTemplate({ tiles, features, units, scale, assetManifest, backgroundImage, header, sidePanel, overlay, footer, onFeatureClick, onUnitClick, onTileClick, className, }: CastleTemplateProps): JSX.Element;
+declare namespace CastleTemplate {
+    var displayName: string;
+}
+
+/**
+ * WorldMapTemplate
+ *
+ * Generalized strategic world-map template composing IsometricCanvas from
+ * almadar-ui. Renders an isometric hex/iso map with hero selection, movement
+ * animation, and encounter callbacks. Game-specific panels (hero detail, hero
+ * lists, resource bars) are injected via render-prop slots.
+ *
+ * @packageDocumentation
+ */
+
+/** A hero on the world map */
+interface MapHero {
+    id: string;
+    name: string;
+    owner: 'player' | 'enemy' | string;
+    position: {
+        x: number;
+        y: number;
+    };
+    movement: number;
+    sprite?: string;
+    level?: number;
+}
+/** A feature hex on the map */
+interface MapHex {
+    x: number;
+    y: number;
+    terrain: string;
+    terrainSprite?: string;
+    feature?: string;
+    featureData?: Record<string, unknown>;
+    passable?: boolean;
+}
+/** Context exposed to render-prop slots */
+interface WorldMapSlotContext {
+    /** Currently hovered tile */
+    hoveredTile: {
+        x: number;
+        y: number;
+    } | null;
+    /** Hex at the hovered tile */
+    hoveredHex: MapHex | null;
+    /** Hero at the hovered tile */
+    hoveredHero: MapHero | null;
+    /** Currently selected hero */
+    selectedHero: MapHero | null;
+    /** Valid move tiles for selected hero */
+    validMoves: Array<{
+        x: number;
+        y: number;
+    }>;
+    /** Selects a hero */
+    selectHero: (id: string) => void;
+    /** Resolve screen position of a tile for overlays */
+    tileToScreen: (x: number, y: number) => {
+        x: number;
+        y: number;
+    };
+    /** Canvas scale */
+    scale: number;
+}
+interface WorldMapTemplateProps {
+    /** All map hexes (with pre-resolved terrain sprites) */
+    hexes: MapHex[];
+    /** Heroes on the map */
+    heroes: MapHero[];
+    /** Features rendered on tiles */
+    features?: IsometricFeature[];
+    /** Currently selected hero ID */
+    selectedHeroId?: string | null;
+    /** Canvas render scale */
+    scale?: number;
+    /** Unit draw-size multiplier */
+    unitScale?: number;
+    /** Asset manifest for IsometricCanvas */
+    assetManifest?: {
+        baseUrl: string;
+        terrains?: Record<string, string>;
+        units?: Record<string, string>;
+        features?: Record<string, string>;
+    };
+    /** Background image URL */
+    backgroundImage?: string;
+    /** Allow selecting / moving ALL heroes (including enemy). For testing. */
+    allowMoveAllHeroes?: boolean;
+    /** Custom movement range validator */
+    isInRange?: (from: {
+        x: number;
+        y: number;
+    }, to: {
+        x: number;
+        y: number;
+    }, range: number) => boolean;
+    /** Header / top bar */
+    header?: (ctx: WorldMapSlotContext) => React__default.ReactNode;
+    /** Side panel (hero detail, hero lists, etc.) */
+    sidePanel?: (ctx: WorldMapSlotContext) => React__default.ReactNode;
+    /** Canvas overlay (tooltips, popups) */
+    overlay?: (ctx: WorldMapSlotContext) => React__default.ReactNode;
+    /** Footer */
+    footer?: (ctx: WorldMapSlotContext) => React__default.ReactNode;
+    onHeroSelect?: (heroId: string) => void;
+    onHeroMove?: (heroId: string, toX: number, toY: number) => void;
+    /** Called when hero clicks an enemy hero tile */
+    onBattleEncounter?: (attackerId: string, defenderId: string) => void;
+    /** Called when hero enters a feature hex (castle, resource, etc.) */
+    onFeatureEnter?: (heroId: string, hex: MapHex) => void;
+    effectSpriteUrls?: string[];
+    resolveUnitFrame?: (unitId: string) => ResolvedFrame | null;
+    className?: string;
+}
+declare function WorldMapTemplate({ hexes, heroes, features, selectedHeroId, scale, unitScale, assetManifest, backgroundImage, allowMoveAllHeroes, isInRange, header, sidePanel, overlay, footer, onHeroSelect, onHeroMove, onBattleEncounter, onFeatureEnter, effectSpriteUrls, resolveUnitFrame, className, }: WorldMapTemplateProps): JSX.Element;
+declare namespace WorldMapTemplate {
+    var displayName: string;
+}
+
+export { Accordion, type AccordionItem, type AccordionProps, Card as ActionCard, type CardProps as ActionCardProps, Alert, type AlertProps, type AlertVariant, type AnimationDef, type AnimationName, AuthLayout, type AuthLayoutProps, Avatar, type AvatarProps, type AvatarSize, type AvatarStatus, Badge, type BadgeProps, type BadgeVariant, type BattlePhase, type BattleSlotContext, BattleTemplate, type BattleTemplateProps, type BattleTile, type BattleUnit, Box, type BoxBg, type BoxMargin, type BoxPadding, type BoxProps, type BoxRounded, type BoxShadow, Breadcrumb, type BreadcrumbItem, type BreadcrumbProps, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, type CameraState, CanvasEffect, type CanvasEffectProps, Card$1 as Card, type CardAction, CardBody, CardContent, CardFooter, CardGrid, type CardGridGap, type CardGridProps, CardHeader, type CardProps$1 as CardProps, CardTitle, type CastleSlotContext, CastleTemplate, type CastleTemplateProps, Center, type CenterProps, Chart, type ChartDataPoint, type ChartProps, type ChartSeries, type ChartType, Checkbox, type CheckboxProps, CodeViewer, type CodeViewerMode, type CodeViewerProps, type Column, type ColumnConfig, type CombatActionType, type ConditionalContext, ConditionalWrapper, type ConditionalWrapperProps, ConfirmDialog, type ConfirmDialogProps, type ConfirmDialogVariant, Container, type ContainerProps, ControlButton, type ControlButtonProps, type CounterSize, CounterTemplate, type CounterTemplateProps, type CounterVariant, type CrudItem, CrudTemplate, type CrudTemplateProps, type CrudVariant, DashboardGrid, type DashboardGridCell, type DashboardGridProps, DashboardLayout, type DashboardLayoutProps, DataTable, type DataTableProps, type DetailField, DetailPanel, type DetailPanelProps, type DetailSection, DialogueBox, type DialogueBoxProps, type DialogueChoice, type DialogueNode, type DiffLine, Divider, type DividerOrientation, type DividerProps, type DocumentType, DocumentViewer, type DocumentViewerProps, Drawer, type DrawerPosition, type DrawerProps, type DrawerSize, DrawerSlot, type DrawerSlotProps, EmptyState, type EmptyStateProps, ErrorState, type ErrorStateProps, EventBusContextType, FEATURE_COLORS, FLOOR_HEIGHT, type FacingDirection, type FieldConfig, type FilterDefinition, FilterGroup, type FilterGroupProps, type FilterValue, Flex, type FlexProps, FloatingActionButton, type FloatingActionButtonProps, Form, FormActions, type FormActionsProps, FormField, type FormFieldConfig, type FormFieldProps, FormLayout, type FormLayoutProps, type FormProps, FormSection$1 as FormSection, FormSectionHeader, type FormSectionHeaderProps, type FormSectionProps, FormTemplate, type FormTemplateProps, type FormVariant, type FrameDimsResolver, GameHud, type GameHudElement, type GameHudProps, type GameHudStat, GameMenu, type GameMenuProps, type GameOverAction, GameOverScreen, type GameOverScreenProps, type GameOverStat, GameShell, type GameShellProps, GameTemplate, type GameTemplateProps, GenericAppTemplate, type GenericAppTemplateProps, GraphCanvas, type GraphCanvasProps, type GraphEdge, type GraphNode, Grid, type GridProps, HStack, type HStackProps, Header, type HeaderProps, HealthBar, type HealthBarProps, type HighlightType, Icon, type IconAnimation, type IconProps, type IconSize, Input, InputGroup, type InputGroupProps, type InputProps, type InventoryItem, InventoryPanel, type InventoryPanelProps, IsometricCanvas, type IsometricCanvasProps, type IsometricFeature, type IsometricTile, type IsometricUnit, Label, type LabelProps, type LawReference, LawReferenceTooltip, type LawReferenceTooltipProps, List, type ListItem, type ListProps, ListTemplate, type ListTemplateItem, type ListTemplateProps, type ListVariant, LoadingState, type LoadingStateProps, type MapHero, type MapHex, MasterDetail, type MasterDetailProps, MediaGallery, type MediaGalleryProps, type MediaItem, Menu, type MenuItem, type MenuOption, type MenuProps, Meter, type MeterProps, type MeterThreshold, type MeterVariant, Modal, type ModalProps, type ModalSize, ModalSlot, type ModalSlotProps, type NavItem, Navigation, type NavigationItem, type NavigationProps, OrbitalVisualization, type OrbitalVisualizationProps, Overlay, type OverlayProps, type PageBreadcrumb, PageHeader, type PageHeaderProps, Pagination, type PaginationProps, Popover, type PopoverProps, ProgressBar, type ProgressBarColor, type ProgressBarProps, type ProgressBarVariant, Radio, type RadioProps, type RelationOption, RelationSelect, type RelationSelectProps, RepeatableFormSection, type RepeatableFormSectionProps, type RepeatableItem, type ResolvedFrame, type RowAction, SHEET_COLUMNS, SPRITE_SHEET_LAYOUT, ScoreDisplay, type ScoreDisplayProps, SearchInput, type SearchInputProps, Section, type SectionProps, Select, type SelectOption, type SelectProps, type SettingsFieldConfig, type SettingsSectionConfig, SettingsTemplate, type SettingsTemplateProps, type SettingsVariant, type SheetUrlResolver, SidePanel, type SidePanelProps, Sidebar, type SidebarItem, type SidebarProps, SignaturePad, type SignaturePadProps, SimpleGrid, type SimpleGridProps, SlotContent, SlotContentRenderer, type SortDirection, Spacer, type SpacerProps, type SpacerSize, Spinner, type SpinnerProps, Split, SplitPane, type SplitPaneProps, type SplitProps, Sprite, type SpriteDirection, type SpriteFrameDims, type SpriteProps, type SpriteSheetUrls, Stack, type StackAlign, type StackDirection, type StackGap, type StackJustify, type StackProps, StatCard, type StatCardProps, Switch, type SwitchProps, TILE_HEIGHT, TILE_WIDTH, type TabDefinition, type TabItem, TabbedContainer, type TabbedContainerProps, Table, type TableColumn, type TableProps, Tabs, type TabsProps, TextHighlight, type TextHighlightProps, Textarea, type TextareaProps, ThemeSelector, ThemeToggle, type ThemeToggleProps, Timeline, type TimelineItem, type TimelineItemStatus, type TimelineProps, Toast, type ToastProps, ToastSlot, type ToastSlotProps, type ToastVariant, Tooltip, type TooltipProps, Typography, type TypographyProps, type TypographyVariant, UISlot, UISlotComponent, UISlotRenderer, type UISlotRendererProps, type UnitAnimationState, type UseSpriteAnimationsOptions, type UseSpriteAnimationsResult, VStack, type VStackProps, ViolationAlert, type ViolationAlertProps, type ViolationRecord, WizardContainer, type WizardContainerProps, WizardNavigation, type WizardNavigationProps, WizardProgress, type WizardProgressProps, type WizardProgressStep, type WizardStep, type WorldMapSlotContext, WorldMapTemplate, type WorldMapTemplateProps, createUnitAnimationState, drawSprite, getCurrentFrame, inferDirection, isoToScreen, resolveFrame, resolveSheetDirection, screenToIso, tickAnimationState, transitionAnimation, useCamera, useImageCache, useSpriteAnimations };