@almadar/ui 5.79.1 → 5.80.0

package/dist/components/game/2d/organisms/TransitionArrow.d.ts

@@ -0,0 +1,31 @@
+/**
+ * TransitionArrow Component
+ *
+ * An SVG arrow connecting two state nodes in the graph editor.
+ * Shows the event name as a label on the arrow.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import type { Point } from '../../../core/atoms/types';
+export interface TransitionArrowProps {
+    /** Start position (center of from-node) */
+    from: Point;
+    /** End position (center of to-node) */
+    to: Point;
+    /** Event label shown on the arrow */
+    eventLabel: string;
+    /** Guard hint shown below event */
+    guardHint?: string;
+    /** Whether this transition is currently active */
+    isActive?: boolean;
+    /** Click handler */
+    onClick?: () => void;
+    /** Additional CSS classes for the SVG group */
+    className?: string;
+}
+export declare function TransitionArrow({ from, to, eventLabel, guardHint, isActive, onClick, className, }: TransitionArrowProps): React.JSX.Element;
+export declare namespace TransitionArrow {
+    var displayName: string;
+}
+export default TransitionArrow;

package/dist/components/game/2d/organisms/UncontrolledBattleBoard.d.ts

@@ -0,0 +1,43 @@
+/**
+ * UncontrolledBattleBoard
+ *
+ * Thin wrapper that composes `useBattleState` + `BattleBoard` for
+ * self-managing game state.  Accepts `initialUnits` instead of the
+ * controlled-mode fields and manages units, phase, turn, gameResult,
+ * and selectedUnitId internally via the hook.
+ *
+ * Use this component when you want the BattleBoard to manage its own
+ * game logic (e.g. in Storybook, prototypes, or simple integrations).
+ * For Orbital trait integration, use `BattleBoard` directly in
+ * controlled mode.
+ *
+ * @packageDocumentation
+ */
+import * as React from 'react';
+import type { EntityRow, EventEmit } from '@almadar/core';
+import { type BattleBoardProps } from './BattleBoard';
+import type { IsometricTile, IsometricUnit, IsometricFeature } from '../../shared/isometricTypes';
+export interface UncontrolledBattleBoardProps extends Omit<BattleBoardProps, 'entity'> {
+    entity?: EntityRow | readonly EntityRow[];
+    /** Direct tile data — takes priority over entity-derived tiles. */
+    tiles?: IsometricTile[];
+    /** Direct unit data — takes priority over entity-derived units. */
+    units?: IsometricUnit[];
+    /** Direct feature data — takes priority over entity-derived features. */
+    features?: IsometricFeature[];
+    /** Direct asset manifest — takes priority over entity-derived manifest. */
+    assetManifest?: BattleBoardProps['assetManifest'];
+    /** Emits UI:{stepEvent} with { attackerId, targetId, damage } each battle round */
+    stepEvent?: EventEmit<{
+        attackerId: string;
+        targetId: string;
+        damage: number;
+    }>;
+    /** Emits UI:{playAgainEvent} with {} on restart */
+    playAgainEvent?: EventEmit<Record<string, never>>;
+}
+export declare function UncontrolledBattleBoard({ entity, tiles, units, features, assetManifest, ...rest }: UncontrolledBattleBoardProps): React.JSX.Element | null;
+export declare namespace UncontrolledBattleBoard {
+    var displayName: string;
+}
+export default UncontrolledBattleBoard;

package/dist/components/game/2d/organisms/VariablePanel.d.ts

@@ -0,0 +1,22 @@
+/**
+ * VariablePanel Component
+ *
+ * Shows entity variables and their current values during State Architect playback.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import type { EntityRow } from '@almadar/core';
+export interface VariablePanelProps {
+    /** Entity name */
+    entityName: string;
+    /** Variable rows to display (`EntityRow` carrying name/value/min/max/unit) */
+    variables: readonly EntityRow[];
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function VariablePanel({ entityName, variables, className, }: VariablePanelProps): React.JSX.Element;
+export declare namespace VariablePanel {
+    var displayName: string;
+}
+export default VariablePanel;

package/dist/components/game/2d/organisms/VisualNovelBoard.d.ts

@@ -0,0 +1,44 @@
+import React from 'react';
+import type { Asset, EventEmit, EntityRow } from '@almadar/core';
+import type { DisplayStateProps } from '../../../core/organisms/types';
+/** Manifest of per-key scene + portrait maps (UI value DTO). */
+type VisualNovelAssetManifest = {
+    backgrounds?: Record<string, Asset>;
+    portraits?: Record<string, Asset>;
+};
+export interface VisualNovelChoice {
+    label: string;
+    nextId: string;
+}
+export interface VisualNovelNode {
+    id: string;
+    speaker: string;
+    text: string;
+    backgroundKey?: string;
+    portraitKey?: string;
+    choices?: VisualNovelChoice[];
+}
+export interface VisualNovelBoardProps extends DisplayStateProps {
+    entity?: EntityRow | readonly EntityRow[];
+    /** Full dialogue graph. */
+    nodes?: VisualNovelNode[];
+    /** Id of the node currently displayed. */
+    currentNodeId?: string;
+    /** Asset base-url + scene/portrait sprite maps (organism owns asset choice). */
+    assetManifest?: VisualNovelAssetManifest;
+    /** Typewriter speed in ms per character (0 = instant). */
+    typewriterSpeed?: number;
+    /** Portrait draw-size multiplier. */
+    portraitScale?: number;
+    chooseEvent?: EventEmit<{
+        choiceIndex: number;
+    }>;
+    advanceEvent?: EventEmit<Record<string, never>>;
+    restartEvent?: EventEmit<Record<string, never>>;
+    className?: string;
+}
+export declare function VisualNovelBoard({ entity, nodes: propNodes, currentNodeId: propCurrentNodeId, assetManifest: propAssetManifest, typewriterSpeed, portraitScale, chooseEvent, advanceEvent, restartEvent, className, }: VisualNovelBoardProps): React.JSX.Element;
+export declare namespace VisualNovelBoard {
+    var displayName: string;
+}
+export default VisualNovelBoard;

package/dist/components/game/2d/organisms/WorldMapBoard.d.ts

@@ -0,0 +1,155 @@
+/**
+ * WorldMapBoard
+ *
+ * Organism 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.
+ *
+ * **State categories (closed-circuit compliant):**
+ * - Game data (hexes, heroes, selectedHeroId, features) → received via
+ *   `entity` prop; the Orbital trait owns this state.
+ * - Rendering state (hoveredTile, movingPositions animation) → local only.
+ * - Events → emitted via `useEventBus()` for trait integration.
+ *
+ * This component is mostly prop-driven.  The only internal state is hover
+ * tracking and movement animation interpolation, both of which are
+ * rendering-only concerns that cannot (and should not) be externalised.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import type { Asset, AssetUrl, EventEmit, EntityRow } from '@almadar/core';
+import type { IsometricTile, IsometricUnit, IsometricFeature } from '../../shared/isometricTypes';
+import type { ResolvedFrame } from '../../shared/spriteAnimationTypes';
+import type { UiError } from '../../../core/atoms/types';
+/** Manifest of per-kind sprite maps (UI value DTO). */
+type WorldMapAssetManifest = {
+    terrains?: Record<string, Asset>;
+    units?: Record<string, Asset>;
+    features?: Record<string, Asset>;
+    ui?: Record<string, Asset>;
+};
+/** Context exposed to render-prop slots. Hex / hero rows are `EntityRow`. */
+export type WorldMapSlotContext = {
+    /** Currently hovered tile */
+    hoveredTile: {
+        x: number;
+        y: number;
+    } | null;
+    /** Hex row at the hovered tile */
+    hoveredHex: EntityRow | null;
+    /** Hero row at the hovered tile */
+    hoveredHero: EntityRow | null;
+    /** Currently selected hero row */
+    selectedHero: EntityRow | 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;
+};
+/** Event Contract:
+ *  Emits: UI:HERO_SELECT
+ *  Emits: UI:HERO_MOVE
+ *  Emits: UI:BATTLE_ENCOUNTER
+ *  Emits: UI:FEATURE_ENTER
+ *  Emits: UI:TILE_CLICK
+ */
+export interface WorldMapBoardProps {
+    /** Additional CSS classes */
+    className?: string;
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: UiError | null;
+    /** World-map board-state entity (single row or array). The board reads
+     *  `hexes` / `heroes` / `features` arrays + `selectedHeroId` off it. */
+    entity?: EntityRow | readonly EntityRow[];
+    /** Direct tile data — takes priority over entity-derived tiles. */
+    tiles?: IsometricTile[];
+    /** Direct unit data — takes priority over entity-derived units. */
+    units?: IsometricUnit[];
+    /** Direct feature data — takes priority over entity-derived features. */
+    features?: IsometricFeature[];
+    /** Direct asset manifest — takes priority over entity-derived manifest. */
+    assetManifest?: WorldMapAssetManifest;
+    /** Canvas render scale */
+    scale?: number;
+    /** Unit draw-size multiplier */
+    unitScale?: number;
+    /** Ratio of unit draw height to scaledFloorHeight. Default 1.5. */
+    spriteHeightRatio?: number;
+    /** Max unit draw width as a ratio of scaledTileWidth. Default 0.6. */
+    spriteMaxWidthRatio?: 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?: EventEmit<{
+        heroId: string;
+    }>;
+    /** Emits UI:{heroMoveEvent} with { heroId, toX, toY } */
+    heroMoveEvent?: EventEmit<{
+        heroId: string;
+        toX: number;
+        toY: number;
+    }>;
+    /** Emits UI:{battleEncounterEvent} with { attackerId, defenderId } */
+    battleEncounterEvent?: EventEmit<{
+        attackerId: string;
+        defenderId: string;
+    }>;
+    /** Emits UI:{featureEnterEvent} with { heroId, feature, hex } */
+    featureEnterEvent?: EventEmit<{
+        heroId: string;
+        feature: string;
+        hex: EntityRow;
+    }>;
+    /** Emits UI:{tileClickEvent} with { x, y } */
+    tileClickEvent?: EventEmit<{
+        x: number;
+        y: number;
+    }>;
+    /** Header / top bar */
+    header?: (ctx: WorldMapSlotContext) => React.ReactNode;
+    /** Side panel (hero detail, hero lists, etc.) */
+    sidePanel?: (ctx: WorldMapSlotContext) => React.ReactNode;
+    /** Canvas overlay (tooltips, popups) */
+    overlay?: (ctx: WorldMapSlotContext) => React.ReactNode;
+    /** Footer */
+    footer?: (ctx: WorldMapSlotContext) => React.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: EntityRow) => void;
+    /** Override for the diamond-top Y offset within tile sprites (default: 374). */
+    diamondTopY?: number;
+    /** Disable pan/zoom camera (default: true). Set false for fixed maps where overlay labels need stable positions. */
+    enableCamera?: boolean;
+    effectSpriteUrls?: AssetUrl[];
+    resolveUnitFrame?: (unitId: string) => ResolvedFrame | null;
+}
+export declare function WorldMapBoard({ entity, tiles: propTiles, units: propUnits, features: propFeatures, assetManifest: propAssetManifest, isLoading, scale, unitScale, spriteHeightRatio, spriteMaxWidthRatio, allowMoveAllHeroes, isInRange, heroSelectEvent, heroMoveEvent, battleEncounterEvent, featureEnterEvent, tileClickEvent, header, sidePanel, overlay, footer, onHeroSelect, onHeroMove, onBattleEncounter, onFeatureEnter, diamondTopY, enableCamera, effectSpriteUrls, resolveUnitFrame, className, }: WorldMapBoardProps): React.JSX.Element;
+export declare namespace WorldMapBoard {
+    var displayName: string;
+}
+export default WorldMapBoard;

package/dist/components/game/2d/templates/BattleTemplate.d.ts

@@ -0,0 +1,34 @@
+/**
+ * BattleTemplate
+ *
+ * Thin declarative wrapper around BattleBoard organism.
+ * All game logic (turn phases, movement animation, combat, etc.) lives in BattleBoard.
+ *
+ * Compliant with Almadar_Templates.md: no hooks, no callbacks, entity-only data flow.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import type { TemplateProps } from '../../../core/templates/types';
+import type { BattleBoardProps } from '../organisms/BattleBoard';
+import type { IsometricTile, IsometricUnit, IsometricFeature } from '../../shared/isometricTypes';
+export type { BattlePhase, BattleSlotContext, } from '../organisms/BattleBoard';
+export interface BattleTemplateProps extends TemplateProps {
+    /** Canvas render scale */
+    scale?: number;
+    /** Unit draw-size multiplier */
+    unitScale?: number;
+    /** Direct tile data — forwarded to BattleBoard; takes priority over entity. */
+    tiles?: IsometricTile[];
+    /** Direct unit data — forwarded to BattleBoard; takes priority over entity. */
+    units?: IsometricUnit[];
+    /** Direct feature data — forwarded to BattleBoard; takes priority over entity. */
+    features?: IsometricFeature[];
+    /** Direct asset manifest — forwarded to BattleBoard; takes priority over entity. */
+    assetManifest?: BattleBoardProps['assetManifest'];
+}
+export declare function BattleTemplate({ entity, scale, unitScale, tiles, units, features, assetManifest, className, }: BattleTemplateProps): React.JSX.Element | null;
+export declare namespace BattleTemplate {
+    var displayName: string;
+}
+export default BattleTemplate;

package/dist/components/game/2d/templates/CardBattlerTemplate.d.ts

@@ -0,0 +1,35 @@
+/**
+ * CardBattlerTemplate
+ *
+ * Thin template wrapper: titled header + CardBattlerBoard.
+ * All game state is driven by the entity prop (passed through from the orbital trait).
+ */
+import React from 'react';
+import type { EventEmit } from '@almadar/core';
+import type { TemplateProps } from '../../../core/templates/types';
+import type { CardBattlerBoardProps, CardBattlerCard } from '../organisms/CardBattlerBoard';
+export interface CardBattlerTemplateProps extends TemplateProps {
+    title?: string;
+    deck?: CardBattlerCard[];
+    hand?: CardBattlerCard[];
+    board?: CardBattlerCard[];
+    mana?: number;
+    maxMana?: number;
+    turn?: number;
+    result?: 'none' | 'won' | 'lost';
+    assetManifest?: CardBattlerBoardProps['assetManifest'];
+    playCardEvent?: EventEmit<{
+        cardId: string;
+    }>;
+    endTurnEvent?: EventEmit<Record<string, never>>;
+    playAgainEvent?: EventEmit<Record<string, never>>;
+    gameEndEvent?: EventEmit<{
+        result: 'won' | 'lost';
+    }>;
+    className?: string;
+}
+export declare function CardBattlerTemplate({ entity, title, deck, hand, board, mana, maxMana, turn, result, assetManifest, playCardEvent, endTurnEvent, playAgainEvent, gameEndEvent, className, }: CardBattlerTemplateProps): React.JSX.Element;
+export declare namespace CardBattlerTemplate {
+    var displayName: string;
+}
+export default CardBattlerTemplate;

package/dist/components/game/2d/templates/CastleTemplate.d.ts

@@ -0,0 +1,32 @@
+/**
+ * CastleTemplate
+ *
+ * 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
+ */
+import React from 'react';
+import type { TemplateProps } from '../../../core/templates/types';
+import type { CastleBoardProps } from '../organisms/CastleBoard';
+import type { IsometricTile, IsometricUnit, IsometricFeature } from '../../shared/isometricTypes';
+export type { CastleSlotContext } from '../organisms/CastleBoard';
+export interface CastleTemplateProps extends TemplateProps {
+    /** Canvas render scale */
+    scale?: number;
+    /** Direct tile data — forwarded to CastleBoard; takes priority over entity. */
+    tiles?: IsometricTile[];
+    /** Direct unit data — forwarded to CastleBoard; takes priority over entity. */
+    units?: IsometricUnit[];
+    /** Direct feature data — forwarded to CastleBoard; takes priority over entity. */
+    features?: IsometricFeature[];
+    /** Direct asset manifest — forwarded to CastleBoard; takes priority over entity. */
+    assetManifest?: CastleBoardProps['assetManifest'];
+}
+export declare function CastleTemplate({ entity, scale, tiles, units, features, assetManifest, className, }: CastleTemplateProps): React.JSX.Element | null;
+export declare namespace CastleTemplate {
+    var displayName: string;
+}
+export default CastleTemplate;

package/dist/components/game/2d/templates/CityBuilderTemplate.d.ts

@@ -0,0 +1,40 @@
+/**
+ * CityBuilderTemplate
+ *
+ * Thin template wrapper: titled header + CityBuilderBoard.
+ * All game state is driven by the entity prop (passed through from the orbital trait).
+ */
+import React from 'react';
+import type { EventEmit } from '@almadar/core';
+import type { TemplateProps } from '../../../core/templates/types';
+import type { CityBuilderBoardProps, CityBuilderTile, CityBuilderBuilding, CityBuilderBuildType } from '../organisms/CityBuilderBoard';
+export interface CityBuilderTemplateProps extends TemplateProps {
+    title?: string;
+    tiles?: CityBuilderTile[];
+    buildings?: CityBuilderBuilding[];
+    buildTypes?: CityBuilderBuildType[];
+    pendingBuildType?: string;
+    assetManifest?: CityBuilderBoardProps['assetManifest'];
+    gold?: number;
+    wood?: number;
+    population?: number;
+    result?: 'none' | 'won' | 'lost';
+    scale?: number;
+    unitScale?: number;
+    selectBuildTypeEvent?: EventEmit<{
+        buildType: string;
+    }>;
+    placeBuildingEvent?: EventEmit<{
+        x: number;
+        y: number;
+    }>;
+    gameEndEvent?: EventEmit<{
+        result: 'won' | 'lost';
+    }>;
+    className?: string;
+}
+export declare function CityBuilderTemplate({ entity, title, tiles, buildings, buildTypes, pendingBuildType, assetManifest, gold, wood, population, result, scale, unitScale, selectBuildTypeEvent, placeBuildingEvent, gameEndEvent, className, }: CityBuilderTemplateProps): React.JSX.Element;
+export declare namespace CityBuilderTemplate {
+    var displayName: string;
+}
+export default CityBuilderTemplate;

package/dist/components/game/2d/templates/GameShell.d.ts

@@ -0,0 +1,39 @@
+/**
+ * GameShell
+ *
+ * A full-screen layout wrapper for game applications.
+ * Replaces DashboardLayout for game clients — no sidebar nav, just full-viewport
+ * rendering with an optional HUD overlay bar.
+ *
+ * Wrap game page content directly as children:
+ *   <GameShell appName="TraitWars">
+ *     <WorldMapPage />
+ *   </GameShell>
+ *
+ * @generated pattern — can be customised per-game via props
+ */
+import React from "react";
+import type { Asset } from "@almadar/core";
+export interface GameShellProps {
+    /** Application / game title shown in the HUD bar */
+    appName?: string;
+    /** Optional HUD content rendered above the main area */
+    hud?: React.ReactNode;
+    /** Extra class name on the root container */
+    className?: string;
+    /** Whether to show the minimal top bar (default: true) */
+    showTopBar?: boolean;
+    /** Game content rendered inside the full-screen area */
+    children?: React.ReactNode;
+    /** Background image for the shell/main area (e.g. Kenny panel frame). Falls back to CSS #0a0a0f. */
+    backgroundAsset?: Asset;
+    /** Background image for the HUD bar. Falls back to CSS #12121f surface color. */
+    hudBackgroundAsset?: Asset;
+}
+/**
+ * Full-viewport game shell layout.
+ *
+ * Renders children inside a full-height flex container.
+ * An optional top bar shows the game title and can host HUD widgets.
+ */
+export declare const GameShell: React.FC<GameShellProps>;

package/dist/components/game/2d/templates/GameTemplate.d.ts

@@ -0,0 +1,35 @@
+/**
+ * GameTemplate
+ *
+ * A presentational template for game applications.
+ * Includes a main game canvas/area, HUD overlay, and an optional debug sidebar.
+ * **Atomic Design**: Composed using Box, Typography, and Layout molecules/atoms.
+ */
+import React from "react";
+import type { Asset } from "@almadar/core";
+import type { TemplateProps } from "../../../core/templates/types";
+export interface GameControls {
+    onPlay?: () => void;
+    onPause?: () => void;
+    onReset?: () => void;
+    isPlaying?: boolean;
+}
+export interface GameTemplateProps extends TemplateProps {
+    /** Title of the game */
+    title?: string;
+    /** The main game canvas or content */
+    children: React.ReactNode;
+    /** HUD overlay content (scores, health, etc.) */
+    hud?: React.ReactNode;
+    /** Debug panel content */
+    debugPanel?: React.ReactNode;
+    /** Whether the debug panel is visible */
+    showDebugPanel?: boolean;
+    /** Game controls */
+    controls?: GameControls;
+    /** Additional class name */
+    className?: string;
+    /** Background image for the canvas area. Falls back to bg-muted flat color. */
+    backgroundAsset?: Asset;
+}
+export declare const GameTemplate: React.FC<GameTemplateProps>;

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

@@ -0,0 +1,27 @@
+import React from 'react';
+import type { Asset } from '@almadar/core';
+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 asset */
+    playerSprite?: Asset;
+    /** Map of platform type to tile sprite asset */
+    tileSprites?: Record<string, Asset>;
+    /** 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;

package/dist/components/game/2d/templates/RoguelikeTemplate.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import type { EventEmit } from '@almadar/core';
+import type { TemplateProps } from '../../../core/templates/types';
+import type { RoguelikeBoardProps } from '../organisms/RoguelikeBoard';
+import type { IsometricTile } from '../../shared/isometricTypes';
+export interface RoguelikeTemplateProps extends TemplateProps {
+    scale?: number;
+    unitScale?: number;
+    tiles?: IsometricTile[];
+    enemies?: RoguelikeBoardProps['enemies'];
+    items?: RoguelikeBoardProps['items'];
+    stairsX?: number;
+    stairsY?: number;
+    assetManifest?: RoguelikeBoardProps['assetManifest'];
+    gameEndEvent?: EventEmit<{
+        result: string;
+    }>;
+}
+export declare function RoguelikeTemplate({ entity, scale, unitScale, tiles, enemies, items, stairsX, stairsY, assetManifest, gameEndEvent, className, }: RoguelikeTemplateProps): React.JSX.Element | null;
+export declare namespace RoguelikeTemplate {
+    var displayName: string;
+}
+export default RoguelikeTemplate;

package/dist/components/game/2d/templates/TopDownShooterTemplate.d.ts

@@ -0,0 +1,42 @@
+/**
+ * TopDownShooterTemplate
+ *
+ * Thin template wrapper: titled header + TopDownShooterBoard.
+ * All game state is driven by the entity prop (passed through from the orbital trait).
+ */
+import React from 'react';
+import type { EventEmit } from '@almadar/core';
+import type { TemplateProps } from '../../../core/templates/types';
+import type { TopDownShooterBoardProps, ShooterPlayer, ShooterEnemy, ShooterProjectile } from '../organisms/TopDownShooterBoard';
+export interface TopDownShooterTemplateProps extends TemplateProps {
+    title?: string;
+    player?: ShooterPlayer;
+    enemies?: ShooterEnemy[];
+    projectiles?: ShooterProjectile[];
+    score?: number;
+    wave?: number;
+    lives?: number;
+    result?: 'none' | 'won' | 'lost';
+    assetManifest?: TopDownShooterBoardProps['assetManifest'];
+    width?: number;
+    height?: number;
+    spriteSize?: number;
+    moveEvent?: EventEmit<{
+        dx: number;
+        dy: number;
+    }>;
+    fireEvent?: EventEmit<{
+        tx: number;
+        ty: number;
+    }>;
+    playAgainEvent?: EventEmit<Record<string, never>>;
+    gameEndEvent?: EventEmit<{
+        result: 'won' | 'lost';
+    }>;
+    className?: string;
+}
+export declare function TopDownShooterTemplate({ entity, title, player, enemies, projectiles, score, wave, lives, result, assetManifest, width, height, spriteSize, moveEvent, fireEvent, playAgainEvent, gameEndEvent, className, }: TopDownShooterTemplateProps): React.JSX.Element;
+export declare namespace TopDownShooterTemplate {
+    var displayName: string;
+}
+export default TopDownShooterTemplate;

package/dist/components/game/2d/templates/TowerDefenseTemplate.d.ts

@@ -0,0 +1,43 @@
+/**
+ * TowerDefenseTemplate
+ *
+ * Thin template wrapper: titled header + TowerDefenseBoard.
+ * All game state is driven by the entity prop (passed through from the orbital trait).
+ */
+import React from 'react';
+import type { TemplateProps } from '../../../core/templates/types';
+import type { TowerDefenseTile, TowerDefensePathPoint, TowerDefenseTower } from '../organisms/TowerDefenseBoard';
+import type { EventEmit } from '@almadar/core';
+export interface TowerDefenseTemplateProps extends TemplateProps {
+    title?: string;
+    tiles?: TowerDefenseTile[];
+    path?: TowerDefensePathPoint[];
+    towers?: TowerDefenseTower[];
+    gold?: number;
+    lives?: number;
+    maxWaves?: number;
+    towerCost?: number;
+    towerRange?: number;
+    towerDamage?: number;
+    creepsPerWave?: number;
+    creepBaseHp?: number;
+    goldPerKill?: 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 TowerDefenseTemplate({ entity, title, tiles, path, towers, gold, lives, maxWaves, towerCost, scale, placeTowerEvent, startWaveEvent, playAgainEvent, gameEndEvent, className, }: TowerDefenseTemplateProps): React.JSX.Element;
+export declare namespace TowerDefenseTemplate {
+    var displayName: string;
+}
+export default TowerDefenseTemplate;