@almadar/ui 5.47.0 → 5.49.0

package/dist/components/game/organisms/CastleBoard.d.ts

@@ -44,6 +44,13 @@ export type CastleSlotContext = {
     };
     /** Canvas scale */
     scale: number;
+    gold: number;
+    health: number;
+    maxHealth: number;
+    wave: number;
+    tickCount: number;
+    buildings: readonly EntityRow[];
+    result: 'none' | 'victory' | 'defeat';
 };
 export interface CastleBoardProps {
     /** Castle board-state entity (single row or array). The board reads
@@ -89,9 +96,11 @@ export interface CastleBoardProps {
         x: number;
         y: number;
     }>;
+    /** Emits UI:{playAgainEvent} with {} on play again / reset */
+    playAgainEvent?: EventEmit<Record<string, never>>;
     className?: string;
 }
-export declare function CastleBoard({ entity, tiles: propTiles, units: propUnits, features: propFeatures, assetManifest: propAssetManifest, scale, header, sidePanel, overlay, footer, onFeatureClick, onUnitClick, onTileClick, featureClickEvent, unitClickEvent, tileClickEvent, className, }: CastleBoardProps): React.JSX.Element;
+export declare function CastleBoard({ entity, tiles: propTiles, units: propUnits, features: propFeatures, assetManifest: propAssetManifest, scale, header, sidePanel, overlay, footer, onFeatureClick, onUnitClick, onTileClick, featureClickEvent, unitClickEvent, tileClickEvent, playAgainEvent, className, }: CastleBoardProps): React.JSX.Element;
 export declare namespace CastleBoard {
     var displayName: string;
 }

package/dist/components/game/organisms/GameBoard3D.d.ts

@@ -0,0 +1,62 @@
+/**
+ * GameBoard3D
+ *
+ * Controlled 3D tactics board organism. Reads all gameplay state
+ * (selectedUnitId, validMoves, attackTargets, phase, result) from the entity
+ * prop and renders <GameCanvas3D> with those controlled values.
+ * Emits user interactions via event bus so the parent Orbital trait drives
+ * all state transitions.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import type { EventEmit, EntityRow } from '@almadar/core';
+import type { CameraMode } from '../molecules/GameCanvas3D';
+import type { IsometricTile, IsometricFeature } from './types/isometric';
+export interface GameBoard3DProps {
+    /** Entity row carrying all gameplay state (controlled). */
+    entity?: EntityRow | readonly EntityRow[];
+    /** Static tile data (config default). */
+    tiles?: IsometricTile[];
+    /** Static feature data (config default). */
+    features?: IsometricFeature[];
+    /** Camera mode forwarded to GameCanvas3D. */
+    cameraMode?: CameraMode;
+    /** Background color forwarded to GameCanvas3D. */
+    backgroundColor?: string;
+    /** Declarative tile click event emitted to the model. */
+    tileClickEvent?: EventEmit<{
+        tileId: string;
+        x: number;
+        z: number;
+    }>;
+    /** Declarative unit click event emitted to the model. */
+    unitClickEvent?: EventEmit<{
+        unitId: string;
+        x: number;
+        z: number;
+    }>;
+    /** Emits UI:{attackEvent} with { attackerId, targetId, damage } on attack. */
+    attackEvent?: EventEmit<{
+        attackerId: string;
+        targetId: string;
+        damage: number;
+    }>;
+    /** Emits UI:{endTurnEvent} with {} on end turn. */
+    endTurnEvent?: EventEmit<Record<string, never>>;
+    /** Emits UI:{cancelEvent} with {} on cancel. */
+    cancelEvent?: EventEmit<Record<string, never>>;
+    /** Emits UI:{playAgainEvent} with {} on play again / reset. */
+    playAgainEvent?: EventEmit<Record<string, never>>;
+    /** Emits UI:{gameEndEvent} with { result } when win/loss is detected. */
+    gameEndEvent?: EventEmit<{
+        result: 'victory' | 'defeat';
+    }>;
+    /** Additional CSS class. */
+    className?: string;
+}
+export declare function GameBoard3D({ entity, tiles, features, cameraMode, backgroundColor, tileClickEvent, unitClickEvent, attackEvent, endTurnEvent, cancelEvent, playAgainEvent, gameEndEvent, className, }: GameBoard3DProps): React.JSX.Element | null;
+export declare namespace GameBoard3D {
+    var displayName: string;
+}
+export default GameBoard3D;

package/dist/components/game/organisms/PlatformerBoard.d.ts

@@ -0,0 +1,51 @@
+import * as React from 'react';
+import type { AssetUrl, EventEmit, EntityRow } from '@almadar/core';
+import type { PlatformerPlatform, PlatformerPlayer } from '../molecules/PlatformerCanvas';
+export interface PlatformerBoardProps {
+    /** Entity containing all board state (result, lives, score, level, player, platforms) */
+    entity?: EntityRow | readonly EntityRow[];
+    /** Direct player state — takes priority over entity-derived player */
+    player?: PlatformerPlayer;
+    /** Direct platform data — takes priority over entity-derived platforms */
+    platforms?: PlatformerPlatform[];
+    /** Game result read from entity */
+    result?: 'none' | 'won' | 'lost';
+    /** Lives remaining */
+    lives?: number;
+    /** Current score */
+    score?: number;
+    /** Current level */
+    level?: number;
+    /** World/canvas dimensions */
+    worldWidth?: number;
+    worldHeight?: number;
+    canvasWidth?: number;
+    canvasHeight?: number;
+    /** Player sprite URL */
+    playerSprite?: AssetUrl;
+    /** Map of platform type to tile sprite URL */
+    tileSprites?: Record<string, AssetUrl>;
+    /** Canvas background color */
+    bgColor?: string;
+    /** Event names forwarded to PlatformerCanvas */
+    leftEvent?: EventEmit<{
+        direction: number;
+    }>;
+    rightEvent?: EventEmit<{
+        direction: number;
+    }>;
+    jumpEvent?: EventEmit<Record<string, never>>;
+    stopEvent?: EventEmit<Record<string, never>>;
+    /** Emits UI:{playAgainEvent} on restart */
+    playAgainEvent?: EventEmit<Record<string, never>>;
+    /** Emits UI:{gameEndEvent} with { result } when result becomes won/lost */
+    gameEndEvent?: EventEmit<{
+        result: 'won' | 'lost';
+    }>;
+    className?: string;
+}
+export declare function PlatformerBoard({ entity, player: propPlayer, platforms: propPlatforms, result: propResult, lives: propLives, score: propScore, level: propLevel, worldWidth, worldHeight, canvasWidth, canvasHeight, playerSprite, tileSprites, bgColor, leftEvent, rightEvent, jumpEvent, stopEvent, playAgainEvent, gameEndEvent, className, }: PlatformerBoardProps): React.JSX.Element;
+export declare namespace PlatformerBoard {
+    var displayName: string;
+}
+export default PlatformerBoard;

package/dist/components/game/organisms/RoguelikeBoard.d.ts

@@ -0,0 +1,59 @@
+import React from 'react';
+import type { AssetUrl, EventEmit, EntityRow } from '@almadar/core';
+import type { DisplayStateProps } from '../../core/organisms/types';
+import type { IsometricTile } from './types/isometric';
+type PlayerPos = {
+    x: number;
+    y: number;
+};
+type EnemyRow = {
+    id: string;
+    x: number;
+    y: number;
+    hp: number;
+    attack: number;
+};
+type ItemRow = {
+    id: string;
+    x: number;
+    y: number;
+    kind: 'health_potion' | 'sword' | 'shield';
+};
+type RoguelikeAssetManifest = {
+    baseUrl?: AssetUrl;
+    terrains?: Record<string, AssetUrl>;
+    units?: Record<string, AssetUrl>;
+    features?: Record<string, AssetUrl>;
+};
+export interface RoguelikeBoardProps extends DisplayStateProps {
+    entity?: EntityRow | readonly EntityRow[];
+    tiles?: IsometricTile[];
+    enemies?: EnemyRow[];
+    items?: ItemRow[];
+    player?: PlayerPos;
+    playerHp?: number;
+    playerMaxHp?: number;
+    playerAttack?: number;
+    depth?: number;
+    result?: 'none' | 'won' | 'lost';
+    phase?: string;
+    stairsX?: number;
+    stairsY?: number;
+    assetManifest?: RoguelikeAssetManifest;
+    scale?: number;
+    unitScale?: number;
+    moveEvent?: EventEmit<{
+        dx: number;
+        dy: number;
+    }>;
+    playAgainEvent?: EventEmit<Record<string, never>>;
+    gameEndEvent?: EventEmit<{
+        result: string;
+    }>;
+    className?: string;
+}
+export declare function RoguelikeBoard({ entity, tiles: propTiles, enemies: propEnemies, items: propItems, player: propPlayer, playerHp: propPlayerHp, playerMaxHp: propPlayerMaxHp, playerAttack: propPlayerAttack, depth: propDepth, result: propResult, phase: propPhase, stairsX: propStairsX, stairsY: propStairsY, assetManifest: propAssetManifest, scale, unitScale, moveEvent, playAgainEvent, gameEndEvent, className, }: RoguelikeBoardProps): React.JSX.Element;
+export declare namespace RoguelikeBoard {
+    var displayName: string;
+}
+export default RoguelikeBoard;

package/dist/components/game/organisms/TowerDefenseBoard.d.ts

@@ -0,0 +1,64 @@
+import React from 'react';
+import type { AssetUrl, EventEmit, EntityRow } from '@almadar/core';
+import type { DisplayStateProps } from '../../core/organisms/types';
+export interface TowerDefenseTile {
+    x: number;
+    y: number;
+    terrain?: string;
+    terrainSprite?: AssetUrl;
+    passable?: boolean;
+}
+export interface TowerDefensePathPoint {
+    x: number;
+    y: number;
+}
+export interface TowerDefenseTower {
+    id: string;
+    x: number;
+    y: number;
+    range: number;
+    damage: number;
+    cooldown: number;
+    lastFiredAt?: number;
+}
+export interface TowerDefenseCreep {
+    id: string;
+    x: number;
+    y: number;
+    hp: number;
+    maxHp: number;
+    pathIndex: number;
+    speed: number;
+}
+export interface TowerDefenseBoardProps extends DisplayStateProps {
+    entity?: EntityRow | readonly EntityRow[];
+    tiles?: TowerDefenseTile[];
+    path?: TowerDefensePathPoint[];
+    towers?: TowerDefenseTower[];
+    creeps?: TowerDefenseCreep[];
+    gold?: number;
+    lives?: number;
+    wave?: number;
+    maxWaves?: number;
+    result?: 'none' | 'won' | 'lost';
+    waveActive?: boolean;
+    towerCost?: number;
+    scale?: number;
+    placeTowerEvent?: EventEmit<{
+        x: number;
+        y: number;
+    }>;
+    startWaveEvent?: EventEmit<{
+        wave: number;
+    }>;
+    playAgainEvent?: EventEmit<Record<string, never>>;
+    gameEndEvent?: EventEmit<{
+        result: 'won' | 'lost';
+    }>;
+    className?: string;
+}
+export declare function TowerDefenseBoard({ entity, tiles: propTiles, path: propPath, towers: propTowers, creeps: propCreeps, gold: propGold, lives: propLives, wave: propWave, maxWaves: propMaxWaves, result: propResult, waveActive: propWaveActive, towerCost, scale, placeTowerEvent, startWaveEvent, playAgainEvent, gameEndEvent, className, }: TowerDefenseBoardProps): React.JSX.Element;
+export declare namespace TowerDefenseBoard {
+    var displayName: string;
+}
+export default TowerDefenseBoard;

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

@@ -25,6 +25,10 @@ export { UncontrolledBattleBoard, type UncontrolledBattleBoardProps, } from './U
 export { useBattleState, type BattleStateEventConfig, type BattleStateCallbacks, type BattleStateResult, } from './hooks/useBattleState';
 export { WorldMapBoard, type WorldMapBoardProps, type WorldMapSlotContext, } from './WorldMapBoard';
 export { CastleBoard, type CastleBoardProps, type CastleSlotContext, } from './CastleBoard';
+export { PlatformerBoard, type PlatformerBoardProps, } from './PlatformerBoard';
+export { TowerDefenseBoard, type TowerDefenseBoardProps, } from './TowerDefenseBoard';
+export { RoguelikeBoard, type RoguelikeBoardProps, } from './RoguelikeBoard';
+export { GameBoard3D, type GameBoard3DProps, } from './GameBoard3D';
 export { TraitStateViewer, type TraitStateViewerProps, type TraitStateMachineDefinition, type TraitTransition, } from './TraitStateViewer';
 export { TraitSlot, type TraitSlotProps, type SlotItemData, } from './TraitSlot';
 export { CollapsibleSection, EditorSlider, EditorSelect, EditorCheckbox, EditorTextInput, StatusBar, TerrainPalette, EditorToolbar, TERRAIN_COLORS, FEATURE_TYPES, type EditorMode, type CollapsibleSectionProps, type EditorSliderProps, type EditorSelectProps, type EditorCheckboxProps, type EditorTextInputProps, type StatusBarProps, type TerrainPaletteProps, type EditorToolbarProps, } from './editor';

package/dist/components/game/organisms/puzzles/event-handler/EventHandlerBoard.d.ts

@@ -13,6 +13,7 @@
 import React from 'react';
 import type { EventEmit, EntityRow } from '@almadar/core';
 import type { DisplayStateProps } from '../../../../core/organisms/types';
+import type { RuleDefinition } from './RuleEditor';
 export interface EventHandlerBoardProps extends DisplayStateProps {
     /** Puzzle board-state entity (single row or array). The board reads
      *  `objects` / `triggerEvents` / `goalEvent` etc. off the row; the editable
@@ -26,8 +27,15 @@ export interface EventHandlerBoardProps extends DisplayStateProps {
     completeEvent?: EventEmit<{
         success: boolean;
     }>;
+    /** Emits UI:{editRuleEvent} with { objectId, rules } — model updates @entity.objects */
+    editRuleEvent?: EventEmit<{
+        objectId: string;
+        rules: RuleDefinition[];
+    }>;
+    /** Emits UI:{playAgainEvent} to reset the model */
+    playAgainEvent?: EventEmit<Record<string, never>>;
 }
-export declare function EventHandlerBoard({ entity, stepDurationMs, playEvent, completeEvent, className, }: EventHandlerBoardProps): React.JSX.Element | null;
+export declare function EventHandlerBoard({ entity, stepDurationMs, playEvent, completeEvent, editRuleEvent, playAgainEvent, className, }: EventHandlerBoardProps): React.JSX.Element | null;
 export declare namespace EventHandlerBoard {
     var displayName: string;
 }

package/dist/components/game/organisms/puzzles/state-architect/StateArchitectBoard.d.ts

@@ -40,8 +40,21 @@ export interface StateArchitectBoardProps extends DisplayStateProps {
         success: boolean;
         passedTests: number;
     }>;
+    /** Emits UI:{addTransitionEvent} — lolo handles ADD_TRANSITION */
+    addTransitionEvent?: EventEmit<{
+        id: string;
+        from: string;
+        to: string;
+        event: string;
+    }>;
+    /** Emits UI:{removeTransitionEvent} — lolo handles REMOVE_TRANSITION */
+    removeTransitionEvent?: EventEmit<{
+        id: string;
+    }>;
+    /** Emits UI:{playAgainEvent} — lolo handles PLAY_AGAIN */
+    playAgainEvent?: EventEmit<Record<string, never>>;
 }
-export declare function StateArchitectBoard({ entity, stepDurationMs, testEvent, completeEvent, className, }: StateArchitectBoardProps): React.JSX.Element | null;
+export declare function StateArchitectBoard({ entity, stepDurationMs, testEvent, completeEvent, addTransitionEvent, removeTransitionEvent, playAgainEvent, className, }: StateArchitectBoardProps): React.JSX.Element | null;
 export declare namespace StateArchitectBoard {
     var displayName: string;
 }

package/dist/components/game/templates/GameCanvas3DBattleTemplate.d.ts

@@ -1,31 +1,28 @@
 /**
  * GameCanvas3DBattleTemplate
  *
- * Pure declarative template wrapper for 3D battle scenes.
- * Optimized for tactical combat view with turn indicators.
+ * Declarative template for 3D battle/tactical combat.
+ * Delegates all interaction state (selectedUnitId, validMoves, attackTargets)
+ * to <GameBoard3D> so the model (not this template) owns gameplay state.
  *
  * Page: Battle3DPage
- * Entity: Battle3D
+ * Entity: Battle3D / GameBoard3DItem
  * ViewType: detail
  *
  * Events Emitted:
- * - TILE_SELECTED - When a tile is clicked
- * - UNIT_SELECTED - When a unit is clicked
- * - UNIT_ATTACK - When attacking a unit
- * - UNIT_MOVE - When moving a unit
- * - END_TURN - When ending turn
+ * - TILE_CLICK - When a tile is clicked
+ * - UNIT_CLICK - When a unit is clicked
+ * - END_TURN   - When ending turn
  * - EXIT_BATTLE - When exiting battle
  *
  * @packageDocumentation
  */
 import React from 'react';
-import type { IsometricTile, IsometricUnit, IsometricFeature } from '../organisms/types/isometric';
+import type { IsometricTile, IsometricFeature } from '../organisms/types/isometric';
 import type { TemplateProps } from '../../core/templates/types';
 export interface GameCanvas3DBattleTemplateProps extends TemplateProps {
     /** Fallback tile data when no entity is present */
     tiles?: IsometricTile[];
-    /** Fallback unit data when no entity is present */
-    units?: IsometricUnit[];
     /** Fallback feature data when no entity is present */
     features?: IsometricFeature[];
     /** 3D camera mode - defaults to perspective for dramatic effect */
@@ -36,30 +33,22 @@ export interface GameCanvas3DBattleTemplateProps extends TemplateProps {
     shadows?: boolean;
     /** Background color - darker for battle atmosphere */
     backgroundColor?: string;
-    /** Event name for tile clicks */
+    /** Event name for tile clicks — forwarded to the model */
     tileClickEvent?: string;
-    /** Event name for unit clicks */
+    /** Event name for unit clicks — forwarded to the model */
     unitClickEvent?: string;
-    /** Event name for unit attack */
-    unitAttackEvent?: string;
-    /** Event name for unit move */
-    unitMoveEvent?: string;
     /** Event name for ending turn */
     endTurnEvent?: string;
+    /** Event name for cancel/deselect */
+    cancelEvent?: string;
+    /** Event name for attack emission */
+    attackEvent?: string;
+    /** Event name for play again / reset */
+    playAgainEvent?: string;
+    /** Event name for game end detection */
+    gameEndEvent?: string;
     /** Event name for exiting battle */
     exitEvent?: string;
-    /** Currently selected unit ID */
-    selectedUnitId?: string | null;
-    /** Valid move positions */
-    validMoves?: Array<{
-        x: number;
-        z: number;
-    }>;
-    /** Valid attack targets */
-    attackTargets?: Array<{
-        x: number;
-        z: number;
-    }>;
     /** Show turn indicator overlay */
     showTurnIndicator?: boolean;
 }
@@ -67,21 +56,19 @@ export interface GameCanvas3DBattleTemplateProps extends TemplateProps {
  * GameCanvas3DBattleTemplate Component
  *
  * Template for 3D battle/tactical combat view.
+ * Interaction state lives in the entity (model), not in this component.
  *
  * @example
  * ```tsx
  * <GameCanvas3DBattleTemplate
  *     entity={battleEntity}
  *     cameraMode="perspective"
- *     selectedUnitId="unit-1"
- *     validMoves={[{ x: 2, z: 3 }]}
- *     attackTargets={[{ x: 5, z: 5 }]}
- *     tileClickEvent="SELECT_TILE"
- *     unitClickEvent="SELECT_UNIT"
+ *     tileClickEvent="TILE_CLICK"
+ *     unitClickEvent="UNIT_CLICK"
  * />
  * ```
  */
-export declare function GameCanvas3DBattleTemplate({ entity, tiles: propTiles, units: propUnits, features: propFeatures, cameraMode, showGrid, shadows, backgroundColor, tileClickEvent, unitClickEvent, unitAttackEvent, unitMoveEvent, endTurnEvent, exitEvent, selectedUnitId, validMoves, attackTargets, className, }: GameCanvas3DBattleTemplateProps): React.JSX.Element | null;
+export declare function GameCanvas3DBattleTemplate({ entity, tiles: propTiles, features: propFeatures, cameraMode, backgroundColor, tileClickEvent, unitClickEvent, endTurnEvent, cancelEvent, attackEvent, playAgainEvent, gameEndEvent, className, }: GameCanvas3DBattleTemplateProps): React.JSX.Element | null;
 export declare namespace GameCanvas3DBattleTemplate {
     var displayName: string;
 }

package/dist/components/game/templates/GameCanvas3DCastleTemplate.d.ts

@@ -1,30 +1,29 @@
 /**
  * GameCanvas3DCastleTemplate
  *
- * Pure declarative template wrapper for 3D castle/settlement view.
- * Shows castle layout with buildings and garrisoned units.
+ * Declarative template for 3D castle/settlement view.
+ * Delegates interaction state (selectedUnitId, validMoves, attackTargets)
+ * to <GameBoard3D> so the model owns all gameplay state.
  *
  * Page: Castle3DPage, Settlement3DPage
- * Entity: Castle3D, Settlement3D
+ * Entity: Castle3D / GameBoard3DItem
  * ViewType: detail
  *
  * Events Emitted:
  * - BUILDING_SELECTED - When a building is clicked
- * - UNIT_SELECTED - When a garrison unit is clicked
- * - BUILD - When building/upgrading
- * - RECRUIT - When recruiting units
- * - EXIT - When exiting castle view
+ * - UNIT_SELECTED     - When a garrison unit is clicked
+ * - BUILD             - When building/upgrading
+ * - RECRUIT           - When recruiting units
+ * - EXIT              - When exiting castle view
  *
  * @packageDocumentation
  */
 import React from 'react';
-import type { IsometricTile, IsometricUnit, IsometricFeature } from '../organisms/types/isometric';
+import type { IsometricTile, IsometricFeature } from '../organisms/types/isometric';
 import type { TemplateProps } from '../../core/templates/types';
 export interface GameCanvas3DCastleTemplateProps extends TemplateProps {
     /** Fallback tile data when no entity is present */
     tiles?: IsometricTile[];
-    /** Fallback unit data when no entity is present */
-    units?: IsometricUnit[];
     /** Fallback feature data when no entity is present */
     features?: IsometricFeature[];
     /** 3D camera mode */
@@ -35,32 +34,34 @@ export interface GameCanvas3DCastleTemplateProps extends TemplateProps {
     shadows?: boolean;
     /** Background color */
     backgroundColor?: string;
-    /** Event name for building clicks */
+    /** Event name for building (feature) clicks */
     buildingClickEvent?: string;
     /** Event name for unit clicks */
     unitClickEvent?: string;
+    /** Event name for ending turn */
+    endTurnEvent?: string;
+    /** Event name for cancel/deselect */
+    cancelEvent?: string;
+    /** Event name for attack emission */
+    attackEvent?: string;
+    /** Event name for play again / reset */
+    playAgainEvent?: string;
+    /** Event name for game end detection */
+    gameEndEvent?: string;
     /** Event name for build action */
     buildEvent?: string;
     /** Event name for recruit action */
     recruitEvent?: string;
     /** Event name for exit */
     exitEvent?: string;
-    /** Currently selected building ID */
-    selectedBuildingId?: string | null;
-    /** Available build positions */
-    availableBuildSites?: Array<{
-        x: number;
-        z: number;
-    }>;
     /** Show castle name header */
     showHeader?: boolean;
-    /** Pre-computed selected tile IDs array */
-    selectedTileIds?: string[];
 }
 /**
  * GameCanvas3DCastleTemplate Component
  *
  * Template for 3D castle/settlement management view.
+ * Interaction state lives in the entity (model), not in this component.
  *
  * @example
  * ```tsx
@@ -68,12 +69,11 @@ export interface GameCanvas3DCastleTemplateProps extends TemplateProps {
  *     entity={castleEntity}
  *     cameraMode="isometric"
  *     showHeader={true}
- *     buildingClickEvent="SELECT_BUILDING"
- *     buildEvent="BUILD_STRUCTURE"
+ *     buildingClickEvent="UNIT_CLICK"
  * />
  * ```
  */
-export declare function GameCanvas3DCastleTemplate({ entity, tiles: propTiles, units: propUnits, features: propFeatures, cameraMode, showGrid, shadows, backgroundColor, buildingClickEvent, unitClickEvent, buildEvent, recruitEvent, exitEvent, selectedBuildingId, selectedTileIds, availableBuildSites, showHeader, className, }: GameCanvas3DCastleTemplateProps): React.JSX.Element | null;
+export declare function GameCanvas3DCastleTemplate({ entity, tiles: propTiles, features: propFeatures, cameraMode, backgroundColor, buildingClickEvent, unitClickEvent, endTurnEvent, cancelEvent, attackEvent, playAgainEvent, gameEndEvent, showHeader, className, }: GameCanvas3DCastleTemplateProps): React.JSX.Element | null;
 export declare namespace GameCanvas3DCastleTemplate {
     var displayName: string;
 }

package/dist/components/game/templates/GameCanvas3DWorldMapTemplate.d.ts

@@ -1,31 +1,30 @@
 /**
  * GameCanvas3DWorldMapTemplate
  *
- * Pure declarative template wrapper for 3D world map.
- * No hooks, no callbacks, no local state -- just entity data and config props.
+ * Declarative template for 3D world map.
+ * Delegates interaction state (selectedUnitId, validMoves, attackTargets)
+ * to <GameBoard3D> so the model owns all gameplay state.
  *
  * Page: WorldMap3DPage
- * Entity: WorldMap3D
+ * Entity: WorldMap3D / GameBoard3DItem
  * ViewType: detail
  *
  * Events Emitted:
- * - TILE_SELECTED - When a tile is clicked ({ tileId, x, z, type })
- * - UNIT_SELECTED - When a unit is clicked ({ unitId, x, z, name })
- * - FEATURE_SELECTED - When a feature is clicked ({ featureId, x, z, type })
- * - TILE_HOVERED - When hovering over a tile ({ tileId, x, z })
- * - TILE_LEAVE - When leaving a tile ({})
- * - CAMERA_CHANGED - When camera position changes ({ position })
+ * - TILE_CLICK    - When a tile is clicked ({ tileId, x, z, type })
+ * - UNIT_CLICK    - When a unit is clicked ({ unitId, x, z, name })
+ * - FEATURE_CLICK - When a feature is clicked ({ featureId, x, z, type })
+ * - TILE_HOVER    - When hovering over a tile ({ tileId, x, z })
+ * - TILE_LEAVE    - When leaving a tile ({})
+ * - CAMERA_CHANGE - When camera position changes ({ position })
  *
  * @packageDocumentation
  */
 import React from 'react';
-import type { IsometricTile, IsometricUnit, IsometricFeature } from '../organisms/types/isometric';
+import type { IsometricTile, IsometricFeature } from '../organisms/types/isometric';
 import type { TemplateProps } from '../../core/templates/types';
 export interface GameCanvas3DWorldMapTemplateProps extends TemplateProps {
     /** Fallback tile data when no entity is present */
     tiles?: IsometricTile[];
-    /** Fallback unit data when no entity is present */
-    units?: IsometricUnit[];
     /** Fallback feature data when no entity is present */
     features?: IsometricFeature[];
     /** 3D camera mode */
@@ -40,10 +39,20 @@ export interface GameCanvas3DWorldMapTemplateProps extends TemplateProps {
     shadows?: boolean;
     /** Background color */
     backgroundColor?: string;
-    /** Event name for tile clicks */
+    /** Event name for tile clicks — forwarded to the model */
     tileClickEvent?: string;
-    /** Event name for unit clicks */
+    /** Event name for unit clicks — forwarded to the model */
     unitClickEvent?: string;
+    /** Event name for ending turn */
+    endTurnEvent?: string;
+    /** Event name for cancel/deselect */
+    cancelEvent?: string;
+    /** Event name for attack emission */
+    attackEvent?: string;
+    /** Event name for play again / reset */
+    playAgainEvent?: string;
+    /** Event name for game end detection */
+    gameEndEvent?: string;
     /** Event name for feature clicks */
     featureClickEvent?: string;
     /** Event name for tile hover */
@@ -54,36 +63,25 @@ export interface GameCanvas3DWorldMapTemplateProps extends TemplateProps {
     cameraChangeEvent?: string;
     /** Exit/back event name */
     exitEvent?: string;
-    /** Currently selected unit ID */
-    selectedUnitId?: string | null;
-    /** Valid move positions for selected unit */
-    validMoves?: Array<{
-        x: number;
-        z: number;
-    }>;
-    /** Attack target positions */
-    attackTargets?: Array<{
-        x: number;
-        z: number;
-    }>;
 }
 /**
  * GameCanvas3DWorldMapTemplate Component
  *
  * Template for 3D world map view.
+ * Interaction state lives in the entity (model), not in this component.
  *
  * @example
  * ```tsx
  * <GameCanvas3DWorldMapTemplate
  *     entity={worldMapEntity}
  *     cameraMode="isometric"
- *     tileClickEvent="SELECT_TILE"
- *     unitClickEvent="SELECT_UNIT"
+ *     tileClickEvent="TILE_CLICK"
+ *     unitClickEvent="UNIT_CLICK"
  *     showCoordinates={true}
  * />
  * ```
  */
-export declare function GameCanvas3DWorldMapTemplate({ entity, tiles: propTiles, units: propUnits, features: propFeatures, cameraMode, showGrid, showCoordinates, showTileInfo, shadows, backgroundColor, tileClickEvent, unitClickEvent, featureClickEvent, tileHoverEvent, tileLeaveEvent, cameraChangeEvent, selectedUnitId, validMoves, attackTargets, className, }: GameCanvas3DWorldMapTemplateProps): React.JSX.Element | null;
+export declare function GameCanvas3DWorldMapTemplate({ entity, tiles: propTiles, features: propFeatures, cameraMode, backgroundColor, tileClickEvent, unitClickEvent, endTurnEvent, cancelEvent, attackEvent, playAgainEvent, gameEndEvent, className, }: GameCanvas3DWorldMapTemplateProps): React.JSX.Element | null;
 export declare namespace GameCanvas3DWorldMapTemplate {
     var displayName: string;
 }

package/dist/components/game/templates/PlatformerTemplate.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import type { TemplateProps } from '../../core/templates/types';
+import type { PlatformerBoardProps } from '../organisms/PlatformerBoard';
+export interface PlatformerTemplateProps extends TemplateProps {
+    /** Level geometry forwarded to PlatformerBoard */
+    platforms?: PlatformerBoardProps['platforms'];
+    /** World dimensions */
+    worldWidth?: number;
+    worldHeight?: number;
+    /** Canvas display size */
+    canvasWidth?: number;
+    canvasHeight?: number;
+    /** Player sprite URL */
+    playerSprite?: string;
+    /** Map of platform type to tile sprite URL */
+    tileSprites?: Record<string, string>;
+    /** Canvas background color */
+    bgColor?: string;
+    /** Forwarded to PlatformerBoard to emit GAME_END into the FSM */
+    gameEndEvent?: PlatformerBoardProps['gameEndEvent'];
+}
+export declare function PlatformerTemplate({ entity, platforms, worldWidth, worldHeight, canvasWidth, canvasHeight, playerSprite, tileSprites, bgColor, gameEndEvent, className, }: PlatformerTemplateProps): React.JSX.Element | null;
+export declare namespace PlatformerTemplate {
+    var displayName: string;
+}
+export default PlatformerTemplate;