@almadar/ui 5.61.0 → 5.63.1

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

@@ -0,0 +1,63 @@
+import React from 'react';
+import type { AssetUrl, EventEmit, EntityRow } from '@almadar/core';
+import type { DisplayStateProps } from '../../core/organisms/types';
+/** Manifest of asset base-url + per-kind sprite maps (UI value DTO). */
+type CityBuilderAssetManifest = {
+    baseUrl?: AssetUrl;
+    terrains?: Record<string, AssetUrl>;
+    units?: Record<string, AssetUrl>;
+    features?: Record<string, AssetUrl>;
+};
+export interface CityBuilderTile {
+    x: number;
+    y: number;
+    terrain?: string;
+    terrainSprite?: AssetUrl;
+    passable?: boolean;
+}
+export interface CityBuilderBuilding {
+    id: string;
+    x: number;
+    y: number;
+    type: string;
+}
+/** A placeable building type shown in the build palette (UI value DTO). */
+export interface CityBuilderBuildType {
+    type: string;
+    label: string;
+    cost: number;
+}
+export interface CityBuilderBoardProps extends DisplayStateProps {
+    entity?: EntityRow | readonly EntityRow[];
+    tiles?: CityBuilderTile[];
+    buildings?: CityBuilderBuilding[];
+    /** Asset base-url + terrain/unit/feature sprite maps (organism owns asset choice). */
+    assetManifest?: CityBuilderAssetManifest;
+    buildTypes?: CityBuilderBuildType[];
+    pendingBuildType?: string;
+    gold?: number;
+    wood?: number;
+    population?: number;
+    tick?: number;
+    result?: 'none' | 'won' | 'lost';
+    scale?: number;
+    unitScale?: number;
+    spriteHeightRatio?: number;
+    spriteMaxWidthRatio?: number;
+    selectBuildTypeEvent?: EventEmit<{
+        buildType: string;
+    }>;
+    placeBuildingEvent?: EventEmit<{
+        x: number;
+        y: number;
+    }>;
+    gameEndEvent?: EventEmit<{
+        result: 'won' | 'lost';
+    }>;
+    className?: string;
+}
+export declare function CityBuilderBoard({ entity, tiles: propTiles, buildings: propBuildings, assetManifest: propAssetManifest, buildTypes: propBuildTypes, pendingBuildType: propPendingBuildType, gold: propGold, wood: propWood, population: propPopulation, result: propResult, scale, unitScale, spriteHeightRatio, spriteMaxWidthRatio, selectBuildTypeEvent, placeBuildingEvent, gameEndEvent, className, }: CityBuilderBoardProps): React.JSX.Element;
+export declare namespace CityBuilderBoard {
+    var displayName: string;
+}
+export default CityBuilderBoard;

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

@@ -0,0 +1,64 @@
+import * as React from 'react';
+import type { AssetUrl, EventEmit, EntityRow } from '@almadar/core';
+/** Asset base-url + per-kind sprite maps (organism owns asset choice; UI value DTO). */
+type ShooterAssetManifest = {
+    baseUrl?: AssetUrl;
+    units?: Record<string, AssetUrl>;
+    features?: Record<string, AssetUrl>;
+    background?: AssetUrl;
+};
+export interface ShooterPlayer {
+    x: number;
+    y: number;
+}
+export interface ShooterEnemy {
+    id: string;
+    x: number;
+    y: number;
+    hp: number;
+}
+export interface ShooterProjectile {
+    id: string;
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+}
+export interface TopDownShooterBoardProps {
+    /** Entity carrying all board state (player, enemies, projectiles, score, wave, lives, result). */
+    entity?: EntityRow | readonly EntityRow[];
+    /** Direct state — each takes priority over its entity-derived value. */
+    player?: ShooterPlayer;
+    enemies?: ShooterEnemy[];
+    projectiles?: ShooterProjectile[];
+    score?: number;
+    wave?: number;
+    lives?: number;
+    result?: 'none' | 'won' | 'lost';
+    /** Asset base-url + unit/feature sprite maps + background. */
+    assetManifest?: ShooterAssetManifest;
+    /** Canvas / arena dimensions in pixels. */
+    width?: number;
+    height?: number;
+    /** Pixel draw-size of sprites. */
+    spriteSize?: number;
+    /** Closed-circuit event emits (UI:{event}). */
+    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 TopDownShooterBoard({ entity, player: propPlayer, enemies: propEnemies, projectiles: propProjectiles, score: propScore, wave: propWave, lives: propLives, result: propResult, assetManifest: propAssetManifest, width, height, spriteSize, moveEvent, fireEvent, playAgainEvent, gameEndEvent, className, }: TopDownShooterBoardProps): React.JSX.Element;
+export declare namespace TopDownShooterBoard {
+    var displayName: string;
+}
+export default TopDownShooterBoard;

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

@@ -1,6 +1,13 @@
 import React from 'react';
 import type { AssetUrl, EventEmit, EntityRow } from '@almadar/core';
 import type { DisplayStateProps } from '../../core/organisms/types';
+/** Manifest of asset base-url + per-kind sprite maps (UI value DTO). */
+type TowerDefenseAssetManifest = {
+    baseUrl?: AssetUrl;
+    terrains?: Record<string, AssetUrl>;
+    units?: Record<string, AssetUrl>;
+    features?: Record<string, AssetUrl>;
+};
 export interface TowerDefenseTile {
     x: number;
     y: number;
@@ -41,6 +48,8 @@ export interface TowerDefenseBoardProps extends DisplayStateProps {
     path?: TowerDefensePathPoint[];
     towers?: TowerDefenseTower[];
     creeps?: TowerDefenseCreep[];
+    /** Asset base-url + terrain/unit/feature sprite maps (organism owns asset choice). */
+    assetManifest?: TowerDefenseAssetManifest;
     gold?: number;
     lives?: number;
     wave?: number;
@@ -70,7 +79,7 @@ export interface TowerDefenseBoardProps extends DisplayStateProps {
     }>;
     className?: string;
 }
-export declare function TowerDefenseBoard({ entity, tiles: propTiles, path: propPath, towers: propTowers, creeps: propCreeps, hero: propHero, gold: propGold, lives: propLives, wave: propWave, maxWaves: propMaxWaves, result: propResult, waveActive: propWaveActive, towerCost, scale, unitScale, spriteHeightRatio, spriteMaxWidthRatio, placeTowerEvent, startWaveEvent, playAgainEvent, gameEndEvent, moveHeroEvent, className, }: TowerDefenseBoardProps): React.JSX.Element;
+export declare function TowerDefenseBoard({ entity, tiles: propTiles, path: propPath, towers: propTowers, creeps: propCreeps, assetManifest: propAssetManifest, hero: propHero, gold: propGold, lives: propLives, wave: propWave, maxWaves: propMaxWaves, result: propResult, waveActive: propWaveActive, towerCost, scale, unitScale, spriteHeightRatio, spriteMaxWidthRatio, placeTowerEvent, startWaveEvent, playAgainEvent, gameEndEvent, moveHeroEvent, className, }: TowerDefenseBoardProps): React.JSX.Element;
 export declare namespace TowerDefenseBoard {
     var displayName: string;
 }

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

@@ -29,9 +29,7 @@ export type SlotItemData = {
     description?: string;
     /** Emoji or text icon */
     iconEmoji?: string;
-    /** Image URL icon (takes precedence over iconEmoji)
-     * @default https://almadar-kflow-assets.web.app/shared/platformer/items/platformPack_item001.png
-     */
+    /** Image URL icon (takes precedence over iconEmoji); falls back to iconEmoji when absent. */
     iconUrl?: AssetUrl;
     /** Optional state machine for tooltip display */
     stateMachine?: TraitStateMachineDefinition;

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

@@ -0,0 +1,53 @@
+/**
+ * VisualNovelBoard
+ *
+ * Dialogue-scene game board: walks a dialogue graph node-by-node, rendering each
+ * node's scene background + character portrait + speaker text + branching choices.
+ * Composes the extended `DialogueBox` molecule; resolves every asset key against
+ * the `assetManifest` prop (organism owns asset choice — no hardcoded URLs).
+ */
+import React from 'react';
+import type { AssetUrl, EventEmit, EntityRow } from '@almadar/core';
+import type { DisplayStateProps } from '../../core/organisms/types';
+/** Manifest of asset base-url + per-key scene + portrait maps (UI value DTO). */
+type VisualNovelAssetManifest = {
+    baseUrl?: AssetUrl;
+    backgrounds?: Record<string, AssetUrl>;
+    portraits?: Record<string, AssetUrl>;
+};
+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/organisms/hooks/useCamera.d.ts

@@ -21,6 +21,22 @@ interface CameraResult {
     handleMouseLeave: () => void;
     /** Wheel handler — zoom in/out */
     handleWheel: (e: React.WheelEvent, drawFn?: () => void) => void;
+    /** Pointer down — starts panning (mouse/touch/pen via Pointer Events). */
+    handlePointerDown: (e: React.PointerEvent) => void;
+    /** Pointer up — stops panning. */
+    handlePointerUp: () => void;
+    /** Pointer move — pans camera if dragging, returns true if panning. */
+    handlePointerMove: (e: React.PointerEvent, drawFn?: () => void) => boolean;
+    /** Apply a two-finger pan delta (screen px) directly to the camera. */
+    panBy: (dx: number, dy: number, drawFn?: () => void) => void;
+    /**
+     * Multiplicative zoom by `factor` keeping the world point under (centerX,centerY)
+     * — screen px relative to the canvas — fixed. Used by wheel + pinch.
+     */
+    zoomAtPoint: (factor: number, centerX: number, centerY: number, viewportSize: {
+        width: number;
+        height: number;
+    }, drawFn?: () => void) => void;
     /** Convert screen coordinates to world coordinates (inverse camera transform) */
     screenToWorld: (clientX: number, clientY: number, canvas: HTMLCanvasElement, viewportSize: {
         width: number;

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

@@ -28,7 +28,11 @@ export { CastleBoard, type CastleBoardProps, type CastleSlotContext, } from './C
 export { PlatformerBoard, type PlatformerBoardProps, } from './PlatformerBoard';
 export { TowerDefenseBoard, type TowerDefenseBoardProps, } from './TowerDefenseBoard';
 export { RoguelikeBoard, type RoguelikeBoardProps, } from './RoguelikeBoard';
+export { TopDownShooterBoard, type TopDownShooterBoardProps, } from './TopDownShooterBoard';
+export { CityBuilderBoard, type CityBuilderBoardProps, } from './CityBuilderBoard';
 export { GameBoard3D, type GameBoard3DProps, } from './GameBoard3D';
+export { VisualNovelBoard, type VisualNovelBoardProps, type VisualNovelNode, type VisualNovelChoice, } from './VisualNovelBoard';
+export { CardBattlerBoard, type CardBattlerBoardProps, type CardBattlerCard, } from './CardBattlerBoard';
 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/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/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/templates/GameCanvas3DBattleTemplate.d.ts

@@ -20,11 +20,14 @@
 import React from 'react';
 import type { IsometricTile, IsometricFeature } from '../organisms/types/isometric';
 import type { TemplateProps } from '../../core/templates/types';
+import { type Game3DAssetManifest } from './game3dAssetManifest';
 export interface GameCanvas3DBattleTemplateProps extends TemplateProps {
-    /** Fallback tile data when no entity is present */
+    /** Fallback tile data when no entity is present (layout only — model URLs resolve from assetManifest) */
     tiles?: IsometricTile[];
     /** Fallback feature data when no entity is present */
     features?: IsometricFeature[];
+    /** GLB model URLs keyed by terrain — owns all asset choice (no hardcoded URLs in this template). */
+    assetManifest?: Game3DAssetManifest;
     /** 3D camera mode - defaults to perspective for dramatic effect */
     cameraMode?: 'isometric' | 'perspective' | 'top-down';
     /** Show grid helper */
@@ -72,7 +75,7 @@ export interface GameCanvas3DBattleTemplateProps extends TemplateProps {
  * />
  * ```
  */
-export declare function GameCanvas3DBattleTemplate({ entity, tiles: propTiles, features: propFeatures, cameraMode, backgroundColor, tileClickEvent, unitClickEvent, endTurnEvent, cancelEvent, attackEvent, playAgainEvent, gameEndEvent, unitScale, scale, className, }: GameCanvas3DBattleTemplateProps): React.JSX.Element | null;
+export declare function GameCanvas3DBattleTemplate({ entity, tiles: propTiles, features: propFeatures, assetManifest, cameraMode, backgroundColor, tileClickEvent, unitClickEvent, endTurnEvent, cancelEvent, attackEvent, playAgainEvent, gameEndEvent, unitScale, scale, className, }: GameCanvas3DBattleTemplateProps): React.JSX.Element | null;
 export declare namespace GameCanvas3DBattleTemplate {
     var displayName: string;
 }

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

@@ -21,11 +21,14 @@
 import React from 'react';
 import type { IsometricTile, IsometricFeature } from '../organisms/types/isometric';
 import type { TemplateProps } from '../../core/templates/types';
+import { type Game3DAssetManifest } from './game3dAssetManifest';
 export interface GameCanvas3DCastleTemplateProps extends TemplateProps {
-    /** Fallback tile data when no entity is present */
+    /** Fallback tile data when no entity is present (layout only — model URLs resolve from assetManifest) */
     tiles?: IsometricTile[];
     /** Fallback feature data when no entity is present */
     features?: IsometricFeature[];
+    /** GLB model URLs keyed by terrain — owns all asset choice (no hardcoded URLs in this template). */
+    assetManifest?: Game3DAssetManifest;
     /** 3D camera mode */
     cameraMode?: 'isometric' | 'perspective' | 'top-down';
     /** Show grid helper */
@@ -77,7 +80,7 @@ export interface GameCanvas3DCastleTemplateProps extends TemplateProps {
  * />
  * ```
  */
-export declare function GameCanvas3DCastleTemplate({ entity, tiles: propTiles, features: propFeatures, cameraMode, backgroundColor, buildingClickEvent, unitClickEvent, endTurnEvent, cancelEvent, attackEvent, playAgainEvent, gameEndEvent, showHeader, unitScale, scale, className, }: GameCanvas3DCastleTemplateProps): React.JSX.Element | null;
+export declare function GameCanvas3DCastleTemplate({ entity, tiles: propTiles, features: propFeatures, assetManifest, cameraMode, backgroundColor, buildingClickEvent, unitClickEvent, endTurnEvent, cancelEvent, attackEvent, playAgainEvent, gameEndEvent, showHeader, unitScale, scale, className, }: GameCanvas3DCastleTemplateProps): React.JSX.Element | null;
 export declare namespace GameCanvas3DCastleTemplate {
     var displayName: string;
 }

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

@@ -22,11 +22,14 @@
 import React from 'react';
 import type { IsometricTile, IsometricFeature } from '../organisms/types/isometric';
 import type { TemplateProps } from '../../core/templates/types';
+import { type Game3DAssetManifest } from './game3dAssetManifest';
 export interface GameCanvas3DWorldMapTemplateProps extends TemplateProps {
-    /** Fallback tile data when no entity is present */
+    /** Fallback tile data when no entity is present (layout only — model URLs resolve from assetManifest) */
     tiles?: IsometricTile[];
     /** Fallback feature data when no entity is present */
     features?: IsometricFeature[];
+    /** GLB model URLs keyed by terrain — owns all asset choice (no hardcoded URLs in this template). */
+    assetManifest?: Game3DAssetManifest;
     /** 3D camera mode */
     cameraMode?: 'isometric' | 'perspective' | 'top-down';
     /** Show grid helper */
@@ -85,7 +88,7 @@ export interface GameCanvas3DWorldMapTemplateProps extends TemplateProps {
  * />
  * ```
  */
-export declare function GameCanvas3DWorldMapTemplate({ entity, tiles: propTiles, features: propFeatures, cameraMode, backgroundColor, tileClickEvent, unitClickEvent, endTurnEvent, cancelEvent, attackEvent, playAgainEvent, gameEndEvent, unitScale, scale, className, }: GameCanvas3DWorldMapTemplateProps): React.JSX.Element | null;
+export declare function GameCanvas3DWorldMapTemplate({ entity, tiles: propTiles, features: propFeatures, assetManifest, cameraMode, backgroundColor, tileClickEvent, unitClickEvent, endTurnEvent, cancelEvent, attackEvent, playAgainEvent, gameEndEvent, unitScale, scale, className, }: GameCanvas3DWorldMapTemplateProps): React.JSX.Element | null;
 export declare namespace GameCanvas3DWorldMapTemplate {
     var displayName: string;
 }

package/dist/components/game/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/templates/VisualNovelTemplate.d.ts

@@ -0,0 +1,28 @@
+/**
+ * VisualNovelTemplate
+ *
+ * Thin template wrapper: titled header + VisualNovelBoard.
+ * All scene state is driven by the entity/props 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 { VisualNovelNode } from '../organisms/VisualNovelBoard';
+export interface VisualNovelTemplateProps extends TemplateProps {
+    title?: string;
+    nodes?: VisualNovelNode[];
+    currentNodeId?: string;
+    typewriterSpeed?: number;
+    portraitScale?: number;
+    chooseEvent?: EventEmit<{
+        choiceIndex: number;
+    }>;
+    advanceEvent?: EventEmit<Record<string, never>>;
+    restartEvent?: EventEmit<Record<string, never>>;
+    className?: string;
+}
+export declare function VisualNovelTemplate({ entity, title, nodes, currentNodeId, typewriterSpeed, portraitScale, chooseEvent, advanceEvent, restartEvent, className, }: VisualNovelTemplateProps): React.JSX.Element;
+export declare namespace VisualNovelTemplate {
+    var displayName: string;
+}
+export default VisualNovelTemplate;

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

@@ -0,0 +1,50 @@
+/**
+ * game3dAssetManifest — shared, asset-URL-free helpers for the 3D game-canvas
+ * templates (battle / castle / world-map).
+ *
+ * Every GLB model URL lives in the lolo `assetManifest` config and arrives via
+ * props; these helpers resolve a tile's / feature's `modelUrl` from that manifest
+ * by terrain/feature key. NO asset URLs are declared here — the templates and this
+ * module stay pure, exactly like the `GameCanvas3D` molecule.
+ *
+ * @packageDocumentation
+ */
+import type { AssetUrl, EntityRow } from '@almadar/core';
+import type { IsometricTile, IsometricFeature } from '../organisms/types/isometric';
+/** GLB model URLs for a 3D board, keyed by terrain "kind" and (optionally) feature type. */
+export interface Game3DAssetManifest {
+    /** Base URL prepended to manifest-relative model paths (absolute paths pass through). */
+    baseUrl?: AssetUrl;
+    /** Floor model URLs by terrain kind ('wall' | 'dirt' | 'open'). */
+    models?: Record<string, AssetUrl>;
+    /** Feature/structure model URLs by feature type ('gold_mine', 'portal', …). */
+    features?: Record<string, AssetUrl>;
+}
+/** Layout-only tile (no model URL): position + terrain kind. */
+export interface Tile3DLayout {
+    id?: string;
+    x: number;
+    y: number;
+    z?: number;
+    type: string;
+    passable?: boolean;
+    /** Terrain kind that maps into `assetManifest.models` (wall | dirt | open). */
+    kind: string;
+}
+/**
+ * Resolve a layout tile array into render-ready `IsometricTile[]`, attaching each
+ * tile's `modelUrl` from `assetManifest.models` by terrain kind. Pure: URLs come
+ * only from the manifest.
+ */
+export declare function resolveTilesWithModels(layout: readonly Tile3DLayout[], manifest: Game3DAssetManifest | undefined): IsometricTile[];
+/**
+ * Map prop `IsometricTile[]` (which already carry `type`/`passable` but no model)
+ * into render-ready tiles with manifest-resolved model URLs.
+ */
+export declare function resolvePropTiles(tiles: readonly IsometricTile[], manifest: Game3DAssetManifest | undefined): IsometricTile[];
+/** Read entity-carried tile rows into render-ready `IsometricTile[]` with manifest-resolved models. */
+export declare function resolveEntityTiles(entity: EntityRow | readonly EntityRow[] | undefined, manifest: Game3DAssetManifest | undefined): IsometricTile[];
+/** Resolve feature model URLs from `assetManifest.features` by feature type. */
+export declare function resolveFeaturesWithModels(features: readonly IsometricFeature[], manifest: Game3DAssetManifest | undefined): IsometricFeature[];
+/** Read entity-carried feature rows into render-ready `IsometricFeature[]` with manifest models. */
+export declare function resolveEntityFeatures(entity: EntityRow | readonly EntityRow[] | undefined, manifest: Game3DAssetManifest | undefined): IsometricFeature[];

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

@@ -0,0 +1,4 @@
+export { TopDownShooterTemplate, type TopDownShooterTemplateProps, } from './TopDownShooterTemplate';
+export { CityBuilderTemplate, type CityBuilderTemplateProps, } from './CityBuilderTemplate';
+export { VisualNovelTemplate, type VisualNovelTemplateProps, } from './VisualNovelTemplate';
+export { CardBattlerTemplate, type CardBattlerTemplateProps, } from './CardBattlerTemplate';