@almadar/ui 1.0.21 → 1.0.23

package/dist/components/index.d.ts

@@ -3,7 +3,7 @@ import React__default from 'react';
 import { LucideIcon } from 'lucide-react';
 import { SExpr } from '@almadar/evaluator';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-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';
+export { AuthContextValue, AuthUser, ChangeSummary, CompileResult, CompileStage, ENTITY_EVENTS, EntityDataAdapter, EntityDataProvider, 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, useEntityDataAdapter, 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';
@@ -3803,12 +3803,18 @@ declare const TabbedContainer: React__default.FC<TabbedContainerProps>;
  */
 /** A single isometric tile on the grid */
 interface IsometricTile {
+    /** Optional unique identifier (required for 3D rendering) */
+    id?: string;
     /** Grid x coordinate */
     x: number;
-    /** Grid y coordinate */
+    /** Grid y coordinate (2D) */
     y: number;
-    /** Terrain type key (e.g., 'grass', 'stone', 'water') */
-    terrain: string;
+    /** Grid z coordinate (3D alternative to y) */
+    z?: number;
+    /** Terrain type key (e.g., 'grass', 'stone', 'water') - 2D */
+    terrain?: string;
+    /** Tile type for visual rendering (3D) */
+    type?: string;
     /** Direct sprite URL override (bypasses getTerrainSprite resolver) */
     terrainSprite?: string;
     /** Whether units can traverse this tile (default true) */
@@ -3817,16 +3823,24 @@ interface IsometricTile {
     movementCost?: number;
     /** Optional tile type for visual variants */
     tileType?: string;
+    /** Elevation offset for 3D rendering */
+    elevation?: number;
 }
 /** A unit positioned on the isometric grid */
 interface IsometricUnit {
     /** Unique unit identifier */
     id: string;
-    /** Current grid position */
-    position: {
+    /** Current grid position (2D format) */
+    position?: {
         x: number;
         y: number;
     };
+    /** Grid x coordinate (3D format) */
+    x?: number;
+    /** Grid y coordinate (3D format) */
+    y?: number;
+    /** Grid z coordinate (3D format) */
+    z?: number;
     /** Static sprite URL (used when no sprite sheet animation) */
     sprite?: string;
     /** Unit archetype key for sprite resolution */
@@ -3837,6 +3851,8 @@ interface IsometricUnit {
     name?: string;
     /** Team affiliation for coloring */
     team?: 'player' | 'enemy' | 'neutral';
+    /** Faction for 3D rendering (player/enemy/neutral) */
+    faction?: 'player' | 'enemy' | 'neutral';
     /** Current health */
     health?: number;
     /** Maximum health */
@@ -3853,17 +3869,29 @@ interface IsometricUnit {
         x: number;
         y: number;
     };
+    /** Elevation offset for 3D rendering */
+    elevation?: number;
 }
 /** A map feature (resource, building, portal, etc.) */
 interface IsometricFeature {
+    /** Optional unique identifier (required for 3D rendering) */
+    id?: string;
     /** Grid x coordinate */
     x: number;
-    /** Grid y coordinate */
+    /** Grid y coordinate (2D) */
     y: number;
+    /** Grid z coordinate (3D alternative to y) */
+    z?: number;
     /** Feature type key (e.g., 'goldMine', 'castle', 'portal') */
     type: string;
     /** Direct sprite URL override (bypasses getFeatureSprite resolver) */
     sprite?: string;
+    /** 3D model URL (GLB format) for GameCanvas3D */
+    assetUrl?: string;
+    /** Color override for 3D rendering */
+    color?: string;
+    /** Elevation offset for 3D rendering */
+    elevation?: number;
 }
 /** Camera state for pan/zoom */
 interface CameraState {
@@ -4028,6 +4056,9 @@ interface IsometricCanvasProps {
     enableCamera?: boolean;
     /** Extra scale multiplier for unit draw size. 1 = default. */
     unitScale?: number;
+    /** Override for the diamond-top Y offset within the tile sprite (default: 374).
+     *  This controls where the flat diamond face sits vertically inside the tile image. */
+    diamondTopY?: number;
     /** Resolve terrain sprite URL from terrain key */
     getTerrainSprite?: (terrain: string) => string | undefined;
     /** Resolve feature sprite URL from feature type key */
@@ -4055,7 +4086,7 @@ interface IsometricCanvasProps {
         effects?: Record<string, string>;
     };
 }
-declare function IsometricCanvas({ className, isLoading, error, entity, tiles: tilesProp, units, features, selectedUnitId, validMoves, attackTargets, hoveredTile, onTileClick, onUnitClick, onTileHover, onTileLeave, tileClickEvent, unitClickEvent, tileHoverEvent, tileLeaveEvent, scale, debug, backgroundImage, showMinimap, enableCamera, unitScale, getTerrainSprite, getFeatureSprite, getUnitSprite, resolveUnitFrame, effectSpriteUrls, onDrawEffects, hasActiveEffects, assetBaseUrl, assetManifest, }: IsometricCanvasProps): JSX.Element;
+declare function IsometricCanvas({ className, isLoading, error, entity, tiles: tilesProp, units, features, selectedUnitId, validMoves, attackTargets, hoveredTile, onTileClick, onUnitClick, onTileHover, onTileLeave, tileClickEvent, unitClickEvent, tileHoverEvent, tileLeaveEvent, scale, debug, backgroundImage, showMinimap, enableCamera, unitScale, getTerrainSprite, getFeatureSprite, getUnitSprite, resolveUnitFrame, effectSpriteUrls, onDrawEffects, hasActiveEffects, diamondTopY: diamondTopYProp, assetBaseUrl, assetManifest, }: IsometricCanvasProps): JSX.Element;
 declare namespace IsometricCanvas {
     var displayName: string;
 }
@@ -4288,6 +4319,187 @@ type FrameDimsResolver = (unit: IsometricUnit) => SpriteFrameDims | null;
  */
 declare function useSpriteAnimations(getSheetUrls: SheetUrlResolver, getFrameDims: FrameDimsResolver, options?: UseSpriteAnimationsOptions): UseSpriteAnimationsResult;
 
+/**
+ * PhysicsManager
+ *
+ * Manages 2D physics simulation for entities with Physics2D state.
+ * This implements the tick logic that would normally be compiled from .orb schemas.
+ *
+ * @packageDocumentation
+ */
+interface Physics2DState {
+    id: string;
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    isGrounded: boolean;
+    gravity: number;
+    friction: number;
+    airResistance: number;
+    maxVelocityY: number;
+    mass?: number;
+    restitution?: number;
+    state: 'Active' | 'Frozen';
+}
+interface PhysicsBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface PhysicsConfig {
+    gravity?: number;
+    friction?: number;
+    airResistance?: number;
+    maxVelocityY?: number;
+    groundY?: number;
+}
+declare class PhysicsManager {
+    private entities;
+    private config;
+    constructor(config?: PhysicsConfig);
+    /**
+     * Register an entity for physics simulation
+     */
+    registerEntity(entityId: string, initialState?: Partial<Physics2DState>): Physics2DState;
+    /**
+     * Unregister an entity from physics simulation
+     */
+    unregisterEntity(entityId: string): void;
+    /**
+     * Get physics state for an entity
+     */
+    getState(entityId: string): Physics2DState | undefined;
+    /**
+     * Get all registered entities
+     */
+    getAllEntities(): Physics2DState[];
+    /**
+     * Apply a force to an entity (impulse)
+     */
+    applyForce(entityId: string, fx: number, fy: number): void;
+    /**
+     * Set velocity directly
+     */
+    setVelocity(entityId: string, vx: number, vy: number): void;
+    /**
+     * Set position directly
+     */
+    setPosition(entityId: string, x: number, y: number): void;
+    /**
+     * Freeze/unfreeze an entity
+     */
+    setFrozen(entityId: string, frozen: boolean): void;
+    /**
+     * Main tick function - call this every frame
+     * Implements the logic from std-physics2d ticks
+     */
+    tick(deltaTime?: number): void;
+    /**
+     * ApplyGravity tick implementation
+     */
+    private applyGravity;
+    /**
+     * ApplyVelocity tick implementation
+     */
+    private applyVelocity;
+    /**
+     * Check and handle ground collision
+     */
+    private checkGroundCollision;
+    /**
+     * Check AABB collision between two entities
+     */
+    checkCollision(entityIdA: string, entityIdB: string, boundsA: PhysicsBounds, boundsB: PhysicsBounds): boolean;
+    /**
+     * Resolve collision with bounce
+     */
+    resolveCollision(entityIdA: string, entityIdB: string): void;
+    /**
+     * Reset all physics state
+     */
+    reset(): void;
+}
+
+/**
+ * usePhysics2D Hook
+ *
+ * React hook for integrating 2D physics with the IsometricCanvas.
+ * Provides physics state management and tick synchronization.
+ *
+ * @example
+ * ```tsx
+ * const { registerUnit, getPosition, applyForce, tick } = usePhysics2D({
+ *   gravity: 0.5,
+ *   groundY: 400
+ * });
+ *
+ * // Register units
+ * useEffect(() => {
+ *   units.forEach(unit => {
+ *     registerUnit(unit.id, { x: unit.x, y: unit.y, mass: 1 });
+ *   });
+ * }, [units]);
+ *
+ * // In animation loop
+ * useEffect(() => {
+ *   const animate = (timestamp) => {
+ *     tick(16); // Run physics
+ *     draw();   // Render
+ *     requestAnimationFrame(animate);
+ *   };
+ *   requestAnimationFrame(animate);
+ * }, []);
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+interface UsePhysics2DOptions extends PhysicsConfig {
+    /** Enable physics debug visualization */
+    debug?: boolean;
+    /** Callback when collision occurs */
+    onCollision?: (entityIdA: string, entityIdB: string) => void;
+    /** Ground Y position (default: 500) */
+    groundY?: number;
+}
+interface UsePhysics2DReturn {
+    /** Register a unit for physics simulation */
+    registerUnit: (unitId: string, options?: Partial<Physics2DState>) => void;
+    /** Unregister a unit from physics */
+    unregisterUnit: (unitId: string) => void;
+    /** Get current physics position for a unit */
+    getPosition: (unitId: string) => {
+        x: number;
+        y: number;
+    } | null;
+    /** Get full physics state for a unit */
+    getState: (unitId: string) => Physics2DState | undefined;
+    /** Apply force to a unit */
+    applyForce: (unitId: string, fx: number, fy: number) => void;
+    /** Set velocity directly */
+    setVelocity: (unitId: string, vx: number, vy: number) => void;
+    /** Set position directly (teleport) */
+    setPosition: (unitId: string, x: number, y: number) => void;
+    /** Run physics tick - call this in your RAF loop */
+    tick: (deltaTime?: number) => void;
+    /** Check collision between two units */
+    checkCollision: (unitIdA: string, unitIdB: string, boundsA: PhysicsBounds, boundsB: PhysicsBounds) => boolean;
+    /** Resolve collision between two units */
+    resolveCollision: (unitIdA: string, unitIdB: string) => void;
+    /** Freeze/unfreeze a unit */
+    setFrozen: (unitId: string, frozen: boolean) => void;
+    /** Get all physics-enabled units */
+    getAllUnits: () => Physics2DState[];
+    /** Reset all physics */
+    reset: () => void;
+}
+/**
+ * Hook for managing 2D physics simulation
+ */
+declare function usePhysics2D(options?: UsePhysics2DOptions): UsePhysics2DReturn;
+
 /**
  * Isometric Coordinate Utilities
  *
@@ -4298,10 +4510,21 @@ declare function useSpriteAnimations(getSheetUrls: SheetUrlResolver, getFrameDim
  */
 /** 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;
+/** Base tile height in pixels (before scale) — full sprite image height (Kenney 256×512) */
+declare const TILE_HEIGHT = 512;
+/** Floor diamond height — the "walkable surface" portion of the tile (TILE_WIDTH / 2 for 2:1 ratio) */
+declare const FLOOR_HEIGHT = 128;
+/**
+ * Measured Y offset from sprite top to the diamond top vertex within a Kenney
+ * 256×512 tile sprite.  The code previously assumed `TILE_HEIGHT - FLOOR_HEIGHT = 384`,
+ * but the actual diamond (dirt_E.png) begins at y = 374 because the 3D side walls
+ * occupy 10 extra pixels above the pure 128 px diamond.
+ *
+ * Use `DIAMOND_TOP_Y * scale` for highlight positioning, unit groundY, feature
+ * placement, and hit-testing — NOT `(TILE_HEIGHT - FLOOR_HEIGHT) * scale`.
+ * `FLOOR_HEIGHT` remains 128 for the isoToScreen spacing formula (2:1 ratio).
+ */
+declare const DIAMOND_TOP_Y = 374;
 /**
  * Feature type → fallback color mapping (when sprites not loaded).
  */
@@ -4698,6 +4921,459 @@ interface DialogueBoxProps {
  */
 declare function DialogueBox({ dialogue, typewriterSpeed, position, onComplete, onChoice, onAdvance, completeEvent, choiceEvent, advanceEvent, className, }: DialogueBoxProps): JSX.Element;
 
+/**
+ * BattleBoard
+ *
+ * Core game-logic organism extracted from BattleTemplate.
+ * Handles turn-based phase management, movement animation, valid-move/attack-target
+ * calculation, screen shake/flash, and game-over detection.
+ *
+ * Accepts a single `entity` prop (BattleEntity) containing all board data,
+ * plus optional render-prop slots, callback overrides, and declarative event props
+ * that emit via `useEventBus()`.
+ *
+ * @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;
+}
+/** Entity prop containing all board data */
+interface BattleEntity {
+    id: string;
+    initialUnits: BattleUnit[];
+    tiles: IsometricTile[];
+    features?: IsometricFeature[];
+    boardWidth?: number;
+    boardHeight?: number;
+    assetManifest?: {
+        baseUrl: string;
+        terrains?: Record<string, string>;
+        units?: Record<string, string>;
+        features?: Record<string, string>;
+        effects?: Record<string, string>;
+    };
+    backgroundImage?: 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 BattleBoardProps {
+    /** Entity containing all board data */
+    entity: BattleEntity;
+    /** Canvas render scale */
+    scale?: number;
+    /** 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;
+    /** 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;
+    /** Emits UI:{tileClickEvent} with { x, y } on tile click */
+    tileClickEvent?: string;
+    /** Emits UI:{unitClickEvent} with { unitId } on unit click */
+    unitClickEvent?: string;
+    /** Emits UI:{endTurnEvent} with {} on end turn */
+    endTurnEvent?: string;
+    /** Emits UI:{cancelEvent} with {} on cancel */
+    cancelEvent?: string;
+    /** Emits UI:{gameEndEvent} with { result } on game end */
+    gameEndEvent?: string;
+    /** Emits UI:{playAgainEvent} with {} on play again / reset */
+    playAgainEvent?: string;
+    /** Emits UI:{attackEvent} with { attackerId, targetId, damage } on attack */
+    attackEvent?: string;
+    className?: string;
+}
+declare function BattleBoard({ entity, scale, unitScale, header, sidebar, actions, overlay, gameOverOverlay, onAttack, onGameEnd, onUnitMove, calculateDamage, onDrawEffects, hasActiveEffects, effectSpriteUrls, resolveUnitFrame, tileClickEvent, unitClickEvent, endTurnEvent, cancelEvent, gameEndEvent, playAgainEvent, attackEvent, className, }: BattleBoardProps): JSX.Element;
+declare namespace BattleBoard {
+    var displayName: string;
+}
+
+/**
+ * WorldMapBoard
+ *
+ * Organism that contains ALL game logic for the strategic world-map view.
+ * 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.
+ *
+ * This component is the logic-heavy core; WorldMapTemplate is a thin layout
+ * wrapper that delegates to WorldMapBoard.
+ *
+ * @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 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;
+}
+/** Entity shape for the WorldMapBoard */
+interface WorldMapEntity {
+    id: string;
+    hexes: MapHex[];
+    heroes: MapHero[];
+    features?: IsometricFeature[];
+    selectedHeroId?: string | null;
+    assetManifest?: {
+        baseUrl: string;
+        terrains?: Record<string, string>;
+        units?: Record<string, string>;
+        features?: Record<string, string>;
+    };
+    backgroundImage?: string;
+}
+interface WorldMapBoardProps {
+    /** World map entity data */
+    entity: WorldMapEntity;
+    /** Canvas render scale */
+    scale?: number;
+    /** Unit draw-size multiplier */
+    unitScale?: number;
+    /** 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;
+    /** Emits UI:{heroSelectEvent} with { heroId } */
+    heroSelectEvent?: string;
+    /** Emits UI:{heroMoveEvent} with { heroId, toX, toY } */
+    heroMoveEvent?: string;
+    /** Emits UI:{battleEncounterEvent} with { attackerId, defenderId } */
+    battleEncounterEvent?: string;
+    /** Emits UI:{featureEnterEvent} with { heroId, feature, hex } */
+    featureEnterEvent?: string;
+    /** Emits UI:{tileClickEvent} with { x, y } */
+    tileClickEvent?: string;
+    /** 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 WorldMapBoard({ entity, scale, unitScale, allowMoveAllHeroes, isInRange, heroSelectEvent, heroMoveEvent, battleEncounterEvent, featureEnterEvent, tileClickEvent, header, sidePanel, overlay, footer, onHeroSelect, onHeroMove, onBattleEncounter, onFeatureEnter, effectSpriteUrls, resolveUnitFrame, className, }: WorldMapBoardProps): JSX.Element;
+declare namespace WorldMapBoard {
+    var displayName: string;
+}
+
+/**
+ * CastleBoard
+ *
+ * Self-contained castle / base-management game board organism. Encapsulates all
+ * isometric canvas rendering, hover/selection state, and slot-based layout.
+ * Designed to be consumed by CastleTemplate (thin wrapper) or embedded directly
+ * in any page that needs an isometric castle view.
+ *
+ * Accepts an `entity` prop conforming to `CastleEntity` and optional declarative
+ * event props (`featureClickEvent`, `unitClickEvent`, `tileClickEvent`) that
+ * emit through the Orbital event bus.
+ *
+ * @packageDocumentation
+ */
+
+/** Entity shape consumed by CastleBoard */
+interface CastleEntity {
+    id: string;
+    tiles: IsometricTile[];
+    features?: IsometricFeature[];
+    units?: IsometricUnit[];
+    assetManifest?: {
+        baseUrl: string;
+        terrains?: Record<string, string>;
+        units?: Record<string, string>;
+        features?: Record<string, string>;
+    };
+    backgroundImage?: string;
+}
+/** 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 CastleBoardProps {
+    /** Castle entity data */
+    entity: CastleEntity;
+    /** Canvas render scale */
+    scale?: number;
+    /** 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;
+    /** Event name to emit via event bus when a feature is clicked (emits UI:{featureClickEvent}) */
+    featureClickEvent?: string;
+    /** Event name to emit via event bus when a unit is clicked (emits UI:{unitClickEvent}) */
+    unitClickEvent?: string;
+    /** Event name to emit via event bus when a tile is clicked (emits UI:{tileClickEvent}) */
+    tileClickEvent?: string;
+    className?: string;
+}
+declare function CastleBoard({ entity, scale, header, sidePanel, overlay, footer, onFeatureClick, onUnitClick, onTileClick, featureClickEvent, unitClickEvent, tileClickEvent, className, }: CastleBoardProps): JSX.Element;
+declare namespace CastleBoard {
+    var displayName: string;
+}
+
+type EditorMode = 'select' | 'paint' | 'unit' | 'feature' | 'erase';
+declare const TERRAIN_COLORS: Record<string, string>;
+declare const FEATURE_TYPES: readonly ["goldMine", "resonanceCrystal", "traitCache", "salvageYard", "portal", "battleMarker", "treasure", "castle"];
+interface CollapsibleSectionProps {
+    title: string;
+    expanded: boolean;
+    onToggle: () => void;
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function CollapsibleSection({ title, expanded, onToggle, children, className }: CollapsibleSectionProps): react_jsx_runtime.JSX.Element;
+declare namespace CollapsibleSection {
+    var displayName: string;
+}
+interface EditorSliderProps {
+    label: string;
+    value: number;
+    min: number;
+    max: number;
+    step?: number;
+    onChange: (value: number) => void;
+    className?: string;
+}
+declare function EditorSlider({ label, value, min, max, step, onChange, className }: EditorSliderProps): react_jsx_runtime.JSX.Element;
+declare namespace EditorSlider {
+    var displayName: string;
+}
+interface EditorSelectProps {
+    label: string;
+    value: string;
+    options: Array<{
+        value: string;
+        label: string;
+    }>;
+    onChange: (value: string) => void;
+    className?: string;
+}
+declare function EditorSelect({ label, value, options, onChange, className }: EditorSelectProps): react_jsx_runtime.JSX.Element;
+declare namespace EditorSelect {
+    var displayName: string;
+}
+interface EditorCheckboxProps {
+    label: string;
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    className?: string;
+}
+declare function EditorCheckbox({ label, checked, onChange, className }: EditorCheckboxProps): react_jsx_runtime.JSX.Element;
+declare namespace EditorCheckbox {
+    var displayName: string;
+}
+interface EditorTextInputProps {
+    label: string;
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    className?: string;
+}
+declare function EditorTextInput({ label, value, onChange, placeholder, className }: EditorTextInputProps): react_jsx_runtime.JSX.Element;
+declare namespace EditorTextInput {
+    var displayName: string;
+}
+interface StatusBarProps {
+    hoveredTile: {
+        x: number;
+        y: number;
+    } | null;
+    mode: EditorMode;
+    gridSize?: {
+        width: number;
+        height: number;
+    };
+    unitCount?: number;
+    featureCount?: number;
+    className?: string;
+}
+declare function StatusBar({ hoveredTile, mode, gridSize, unitCount, featureCount, className }: StatusBarProps): react_jsx_runtime.JSX.Element;
+declare namespace StatusBar {
+    var displayName: string;
+}
+interface TerrainPaletteProps {
+    terrains: string[];
+    selectedTerrain: string;
+    onSelect: (terrain: string) => void;
+    className?: string;
+}
+declare function TerrainPalette({ terrains, selectedTerrain, onSelect, className }: TerrainPaletteProps): react_jsx_runtime.JSX.Element;
+declare namespace TerrainPalette {
+    var displayName: string;
+}
+interface EditorToolbarProps {
+    mode: EditorMode;
+    onModeChange: (mode: EditorMode) => void;
+    className?: string;
+}
+declare function EditorToolbar({ mode, onModeChange, className }: EditorToolbarProps): react_jsx_runtime.JSX.Element;
+declare namespace EditorToolbar {
+    var displayName: string;
+}
+
 /**
  * UISlotRenderer Component
  *
@@ -5348,6 +6024,24 @@ interface CodeViewerProps {
 }
 declare const CodeViewer: React__default.FC<CodeViewerProps>;
 
+/**
+ * Base template types for Almadar UI.
+ *
+ * All templates MUST extend `TemplateProps<E>` to enforce entity-only data flow
+ * and JSON round-trip compatibility with the flattener pipeline.
+ *
+ * @see docs/Almadar_Templates.md
+ */
+/** Base props for all templates — enforces entity-only data flow. */
+interface TemplateProps<E extends {
+    id: string;
+}> {
+    /** Entity data — the sole source of runtime state */
+    entity: E;
+    /** External styling override */
+    className?: string;
+}
+
 interface NavItem {
     label: string;
     href: string;
@@ -5777,124 +6471,21 @@ declare const GameShell: React__default.FC<GameShellProps>;
 /**
  * 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.
+ * Thin declarative wrapper around BattleBoard organism.
+ * All game logic (turn phases, movement animation, combat, etc.) lives in BattleBoard.
  *
- * Game-specific UI (combat log, trait viewer, damage popups, etc.) is injected via
- * render-prop slots so this template remains project-agnostic.
+ * Compliant with Almadar_Templates.md: no hooks, no callbacks, entity-only data flow.
  *
  * @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[];
+interface BattleTemplateProps extends TemplateProps<BattleEntity> {
     /** 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 function BattleTemplate({ entity, scale, unitScale, className, }: BattleTemplateProps): JSX.Element;
 declare namespace BattleTemplate {
     var displayName: string;
 }
@@ -5902,71 +6493,19 @@ declare namespace BattleTemplate {
 /**
  * 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).
+ * Thin declarative wrapper around CastleBoard organism.
+ * All game logic (hover state, feature selection, etc.) lives in CastleBoard.
+ *
+ * Compliant with Almadar_Templates.md: no hooks, no callbacks, entity-only data flow.
  *
  * @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[];
+interface CastleTemplateProps extends TemplateProps<CastleEntity> {
     /** 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 function CastleTemplate({ entity, scale, className, }: CastleTemplateProps): JSX.Element;
 declare namespace CastleTemplate {
     var displayName: string;
 }
@@ -5974,118 +6513,25 @@ declare namespace CastleTemplate {
 /**
  * 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.
+ * Thin declarative wrapper around WorldMapBoard organism.
+ * All game logic (hero movement, encounters, hex conversion, etc.) lives in WorldMapBoard.
+ *
+ * Compliant with Almadar_Templates.md: no hooks, no callbacks, entity-only data flow.
  *
  * @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;
+interface WorldMapTemplateProps extends TemplateProps<WorldMapEntity> {
     /** 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 function WorldMapTemplate({ entity, scale, unitScale, allowMoveAllHeroes, 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, Heading, type HeadingProps, 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, Text, TextHighlight, type TextHighlightProps, type TextProps, 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 };
+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, BattleBoard, type BattleBoardProps, type BattleEntity, 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, CastleBoard, type CastleBoardProps, type CastleEntity, 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, CollapsibleSection, type CollapsibleSectionProps, 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, DIAMOND_TOP_Y, 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, EditorCheckbox, type EditorCheckboxProps, type EditorMode, EditorSelect, type EditorSelectProps, EditorSlider, type EditorSliderProps, EditorTextInput, type EditorTextInputProps, EditorToolbar, type EditorToolbarProps, EmptyState, type EmptyStateProps, ErrorState, type ErrorStateProps, EventBusContextType, FEATURE_COLORS, FEATURE_TYPES, 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, Heading, type HeadingProps, 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, type Physics2DState, type PhysicsBounds, type PhysicsConfig, PhysicsManager, 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, StatusBar, type StatusBarProps, Switch, type SwitchProps, TERRAIN_COLORS, TILE_HEIGHT, TILE_WIDTH, type TabDefinition, type TabItem, TabbedContainer, type TabbedContainerProps, Table, type TableColumn, type TableProps, Tabs, type TabsProps, type TemplateProps, TerrainPalette, type TerrainPaletteProps, Text, TextHighlight, type TextHighlightProps, type TextProps, 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 UsePhysics2DOptions, type UsePhysics2DReturn, 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, WorldMapBoard, type WorldMapBoardProps, type WorldMapEntity, type WorldMapSlotContext, WorldMapTemplate, type WorldMapTemplateProps, createUnitAnimationState, drawSprite, getCurrentFrame, inferDirection, isoToScreen, resolveFrame, resolveSheetDirection, screenToIso, tickAnimationState, transitionAnimation, useCamera, useImageCache, usePhysics2D, useSpriteAnimations };