@almadar/ui 5.79.0 → 5.79.1

package/dist/components/game/3d/molecules/Camera3D.d.ts

@@ -1,60 +0,0 @@
-/**
- * Camera3D
- *
- * Three.js camera component with orbit controls.
- * Supports isometric, perspective, and top-down camera modes.
- *
- * @packageDocumentation
- */
-import React from 'react';
-import * as THREE from 'three';
-export type CameraMode = 'isometric' | 'perspective' | 'top-down';
-export interface Camera3DProps {
-    /** Camera mode */
-    mode?: CameraMode;
-    /** Initial camera position */
-    position?: [number, number, number];
-    /** Target to look at */
-    target?: [number, number, number];
-    /** Zoom level */
-    zoom?: number;
-    /** Field of view (perspective mode only) */
-    fov?: number;
-    /** Enable orbit controls */
-    enableOrbit?: boolean;
-    /** Minimum zoom distance */
-    minDistance?: number;
-    /** Maximum zoom distance */
-    maxDistance?: number;
-    /** Called when camera changes */
-    onChange?: (camera: THREE.Camera) => void;
-}
-export interface Camera3DHandle {
-    /** Get current camera */
-    getCamera: () => THREE.Camera;
-    /** Set camera position */
-    setPosition: (x: number, y: number, z: number) => void;
-    /** Look at target */
-    lookAt: (x: number, y: number, z: number) => void;
-    /** Reset to initial position */
-    reset: () => void;
-    /** Get current view bounds */
-    getViewBounds: () => {
-        min: THREE.Vector3;
-        max: THREE.Vector3;
-    };
-}
-/**
- * Camera3D Component
- *
- * Configurable camera with orbit controls and multiple modes.
- *
- * @example
- * ```tsx
- * <Canvas>
- *     <Camera3D mode="isometric" position={[10, 10, 10]} target={[0, 0, 0]} />
- * </Canvas>
- * ```
- */
-export declare const Camera3D: React.ForwardRefExoticComponent<Camera3DProps & React.RefAttributes<Camera3DHandle>>;
-export default Camera3D;

package/dist/components/game/3d/molecules/Canvas3D.d.ts

@@ -1,45 +0,0 @@
-import React from 'react';
-import type { EventEmit } from '@almadar/core';
-import type { IsometricTile, IsometricUnit, IsometricFeature } from '../../shared/isometricTypes';
-/** Props for Canvas3D — cleaned prop surface per docs/Almadar_Std_Game.md §4.4 */
-export interface Canvas3DProps {
-    tiles?: IsometricTile[];
-    units?: IsometricUnit[];
-    features?: IsometricFeature[];
-    cameraMode?: 'isometric' | 'perspective' | 'top-down';
-    shadows?: boolean;
-    showGrid?: boolean;
-    selectedUnitId?: string | null;
-    validMoves?: Array<{
-        x: number;
-        z: number;
-    }>;
-    attackTargets?: Array<{
-        x: number;
-        z: number;
-    }>;
-    tileClickEvent?: EventEmit<{
-        tileId: string;
-        x: number;
-        z: number;
-    }>;
-    unitClickEvent?: EventEmit<{
-        unitId: string;
-        x: number;
-        z: number;
-    }>;
-    unitScale?: number;
-    className?: string;
-    isLoading?: boolean;
-    error?: string | null;
-}
-/**
- * Canvas3D — pure 3D renderer.  Game logic lives in LOLO; this component
- * receives pre-computed state via props and emits events via EventEmit props.
- *
- * Wraps GameCanvas3D under the canonical §4.4 prop surface.
- * GameCanvas3D is preserved for the Wave 4 migration; Canvas3D is the
- * stable public name going forward.
- */
-export declare function Canvas3D(props: Canvas3DProps): React.JSX.Element;
-export default Canvas3D;

package/dist/components/game/3d/molecules/Canvas3DErrorBoundary.d.ts

@@ -1,51 +0,0 @@
-/**
- * Canvas3DErrorBoundary
- *
- * Error boundary for 3D canvas components.
- * Catches Three.js and React Three Fiber errors gracefully.
- *
- * @packageDocumentation
- */
-import { Component, type ReactNode, type ErrorInfo } from 'react';
-import './Canvas3DErrorBoundary.css';
-export interface Canvas3DErrorBoundaryProps {
-    /** Child components */
-    children: ReactNode;
-    /** Custom fallback component */
-    fallback?: ReactNode;
-    /** Error callback */
-    onError?: (error: Error, errorInfo: ErrorInfo) => void;
-    /** Reset callback */
-    onReset?: () => void;
-}
-export interface Canvas3DErrorBoundaryState {
-    /** Whether an error has occurred */
-    hasError: boolean;
-    /** The error that occurred */
-    error: Error | null;
-    /** Error info from React */
-    errorInfo: ErrorInfo | null;
-}
-/**
- * Canvas3DErrorBoundary Component
- *
- * Catches errors in 3D canvas and displays a user-friendly fallback.
- *
- * @example
- * ```tsx
- * <Canvas3DErrorBoundary
- *     onError={(error) => console.error('3D Error:', error)}
- *     onReset={() => console.log('Resetting...')}
- * >
- *     <GameCanvas3D {...props} />
- * </Canvas3DErrorBoundary>
- * ```
- */
-export declare class Canvas3DErrorBoundary extends Component<Canvas3DErrorBoundaryProps, Canvas3DErrorBoundaryState> {
-    constructor(props: Canvas3DErrorBoundaryProps);
-    static getDerivedStateFromError(error: Error): Canvas3DErrorBoundaryState;
-    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
-    handleReset: () => void;
-    render(): ReactNode;
-}
-export default Canvas3DErrorBoundary;

package/dist/components/game/3d/molecules/Canvas3DLoadingState.d.ts

@@ -1,44 +0,0 @@
-/**
- * Canvas3DLoadingState
- *
- * Loading state component for 3D canvas with progress indicator.
- * Displays asset loading progress and estimated time remaining.
- *
- * @packageDocumentation
- */
-import React from 'react';
-import './Canvas3DLoadingState.css';
-export interface Canvas3DLoadingStateProps {
-    /** Current loading progress (0-100) */
-    progress?: number;
-    /** Number of assets loaded */
-    loaded?: number;
-    /** Total assets to load */
-    total?: number;
-    /** Loading message */
-    message?: string;
-    /** Secondary details message */
-    details?: string;
-    /** Whether to show spinner */
-    showSpinner?: boolean;
-    /** Custom className */
-    className?: string;
-}
-/**
- * Canvas3DLoadingState Component
- *
- * Displays loading progress for 3D assets.
- *
- * @example
- * ```tsx
- * <Canvas3DLoadingState
- *     progress={65}
- *     loaded={13}
- *     total={20}
- *     message="Loading 3D models..."
- *     details="character-knight.glb"
- * />
- * ```
- */
-export declare function Canvas3DLoadingState({ progress, loaded, total, message, details, showSpinner, className, }: Canvas3DLoadingStateProps): React.JSX.Element;
-export default Canvas3DLoadingState;

package/dist/components/game/3d/molecules/GameCanvas3D.d.ts

@@ -1,226 +0,0 @@
-/**
- * GameCanvas3D
- *
- * 3D game canvas component using Three.js.
- * Mirrors the IsometricCanvas API for easy migration.
- *
- * **State categories (closed-circuit compliant):**
- * - All game data (tiles, units, features, selection, validMoves) → received via props
- * - Rendering state (hoveredTile, internalError, asset loading, camera) → local only
- * - Events → emitted via `useGameCanvas3DEvents()` hook for trait integration
- *
- * This component is a **pure 3D renderer** — it holds no game logic state.
- *
- * @packageDocumentation
- */
-import React from 'react';
-import type { EventEmit } from '@almadar/core';
-import * as THREE from 'three';
-import { AssetLoader } from '../../shared/lib/AssetLoader';
-import { type MinimalMouseEvent } from '../../shared/hooks/useGameCanvas3DEvents';
-import type { IsometricTile, IsometricUnit, IsometricFeature } from '../../shared/isometricTypes';
-import './GameCanvas3D.css';
-export type { IsometricTile, IsometricUnit, IsometricFeature };
-/** Game event for canvas display */
-export interface GameEvent {
-    id: string;
-    type: string;
-    x: number;
-    z?: number;
-    y?: number;
-    message?: string;
-}
-/** Camera mode for 3D view */
-export type CameraMode = 'isometric' | 'perspective' | 'top-down';
-/** Map orientation */
-export type MapOrientation = 'standard' | 'rotated';
-/** Overlay control */
-export type OverlayControl = 'default' | 'hidden' | 'minimap';
-/** Props for GameCanvas3D component */
-export interface GameCanvas3DProps {
-    /** Additional CSS classes */
-    className?: string;
-    /** Children to render inside the 3D canvas (e.g., physics objects, custom meshes) */
-    children?: React.ReactNode;
-    /** Loading state indicator */
-    isLoading?: boolean;
-    /** Error state */
-    error?: string | null;
-    /** Array of tiles to render */
-    tiles?: IsometricTile[];
-    /** Array of units to render */
-    units?: IsometricUnit[];
-    /** Array of features to render */
-    features?: IsometricFeature[];
-    /** Array of events to display */
-    events?: Array<GameEvent>;
-    /** Fog of war data */
-    fogOfWar?: boolean[][];
-    /** Map orientation */
-    orientation?: MapOrientation;
-    /** Camera mode */
-    cameraMode?: CameraMode;
-    /** Show grid */
-    showGrid?: boolean;
-    /** Show coordinates overlay */
-    showCoordinates?: boolean;
-    /** Show tile information */
-    showTileInfo?: boolean;
-    /** Overlay control mode */
-    overlay?: OverlayControl;
-    /** Enable shadows */
-    shadows?: boolean;
-    /** Background color */
-    backgroundColor?: string;
-    /** Callback when a tile is clicked */
-    onTileClick?: (tile: IsometricTile, event: MinimalMouseEvent) => void;
-    /** Callback when a unit is clicked */
-    onUnitClick?: (unit: IsometricUnit, event: MinimalMouseEvent) => void;
-    /** Callback when a feature is clicked */
-    onFeatureClick?: (feature: IsometricFeature, event: MinimalMouseEvent) => void;
-    /** Callback when canvas is clicked (background) */
-    onCanvasClick?: (event: MinimalMouseEvent) => void;
-    /** Callback when mouse moves over a tile */
-    onTileHover?: (tile: IsometricTile | null, event: MinimalMouseEvent) => void;
-    /** Callback for unit animation state change */
-    onUnitAnimation?: (unitId: string, state: string) => void;
-    /** Asset loader instance (uses global singleton if not provided) */
-    assetLoader?: AssetLoader;
-    /** Custom tile renderer component */
-    tileRenderer?: React.FC<{
-        tile: IsometricTile;
-        position: [number, number, number];
-    }>;
-    /** Custom unit renderer component */
-    unitRenderer?: React.FC<{
-        unit: IsometricUnit;
-        position: [number, number, number];
-    }>;
-    /** Custom feature renderer component */
-    featureRenderer?: React.FC<{
-        feature: IsometricFeature;
-        position: [number, number, number];
-    }>;
-    /** URLs to preload */
-    preloadAssets?: string[];
-    /** Declarative event: tile click */
-    tileClickEvent?: EventEmit<{
-        tileId: string;
-        x: number;
-        z: number;
-        type?: string;
-        terrain?: string;
-        elevation?: number;
-    }>;
-    /** Declarative event: unit click */
-    unitClickEvent?: EventEmit<{
-        unitId: string;
-        x: number;
-        z: number;
-        unitType?: string;
-        name?: string;
-        team?: string;
-        faction?: string;
-        health?: number;
-        maxHealth?: number;
-    }>;
-    /** Declarative event: feature click */
-    featureClickEvent?: EventEmit<{
-        featureId: string;
-        x: number;
-        z: number;
-        type?: string;
-        elevation?: number;
-    }>;
-    /** Declarative event: canvas click */
-    canvasClickEvent?: EventEmit<{
-        clientX: number;
-        clientY: number;
-        button: number;
-    }>;
-    /** Declarative event: tile hover */
-    tileHoverEvent?: EventEmit<{
-        tileId: string;
-        x: number;
-        z: number;
-        type?: string;
-    }>;
-    /** Declarative event: tile leave */
-    tileLeaveEvent?: EventEmit<Record<string, never>>;
-    /** Declarative event: unit animation */
-    unitAnimationEvent?: EventEmit<{
-        unitId: string;
-        state: string;
-        timestamp: number;
-    }>;
-    /** Declarative event: camera change */
-    cameraChangeEvent?: EventEmit<{
-        position: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        timestamp: number;
-    }>;
-    /** Loading message */
-    loadingMessage?: string;
-    /** Whether to use instancing for tiles */
-    useInstancing?: boolean;
-    /** Valid move positions */
-    validMoves?: Array<{
-        x: number;
-        z: number;
-    }>;
-    /** Attack target positions */
-    attackTargets?: Array<{
-        x: number;
-        z: number;
-    }>;
-    /** Selected tile IDs */
-    selectedTileIds?: string[];
-    /** Selected unit ID */
-    selectedUnitId?: string | null;
-    /** Unit draw-size multiplier. 1 = default tile-proportional size. */
-    unitScale?: number;
-    /** Board zoom/group scale. Applied to the scene group. Default 0.45. */
-    scale?: number;
-}
-/** Imperative handle for GameCanvas3D */
-export interface GameCanvas3DHandle {
-    /** Get current camera position */
-    getCameraPosition: () => THREE.Vector3 | null;
-    /** Set camera position */
-    setCameraPosition: (x: number, y: number, z: number) => void;
-    /** Look at a specific point */
-    lookAt: (x: number, y: number, z: number) => void;
-    /** Reset camera to default position */
-    resetCamera: () => void;
-    /** Take a screenshot */
-    screenshot: () => string | null;
-    /** Export current view as data */
-    export: () => {
-        tiles: IsometricTile[];
-        units: IsometricUnit[];
-        features: IsometricFeature[];
-    };
-}
-/**
- * GameCanvas3D Component
- *
- * 3D game canvas that mirrors the IsometricCanvas API.
- * Uses Three.js and React Three Fiber for rendering.
- *
- * @example
- * ```tsx
- * <GameCanvas3D
- *   tiles={tiles}
- *   units={units}
- *   features={features}
- *   cameraMode="isometric"
- *   tileClickEvent="TILE_SELECTED"
- *   onTileClick={(tile) => console.log('Clicked:', tile)}
- * />
- * ```
- */
-export declare const GameCanvas3D: React.ForwardRefExoticComponent<GameCanvas3DProps & React.RefAttributes<GameCanvas3DHandle>>;
-export default GameCanvas3D;

package/dist/components/game/3d/molecules/Lighting3D.d.ts

@@ -1,47 +0,0 @@
-/**
- * Lighting3D
- *
- * Default lighting setup for 3D game scenes.
- * Includes ambient, directional, and optional point lights.
- *
- * @packageDocumentation
- */
-import React from 'react';
-export interface Lighting3DProps {
-    /** Ambient light intensity */
-    ambientIntensity?: number;
-    /** Ambient light color */
-    ambientColor?: string;
-    /** Directional light intensity */
-    directionalIntensity?: number;
-    /** Directional light color */
-    directionalColor?: string;
-    /** Directional light position */
-    directionalPosition?: [number, number, number];
-    /** Enable shadows */
-    shadows?: boolean;
-    /** Shadow map size */
-    shadowMapSize?: number;
-    /** Shadow camera size */
-    shadowCameraSize?: number;
-    /** Show helper for directional light */
-    showHelpers?: boolean;
-}
-/**
- * Lighting3D Component
- *
- * Pre-configured lighting setup for game scenes.
- *
- * @example
- * ```tsx
- * <Canvas>
- *     <Lighting3D
- *         ambientIntensity={0.6}
- *         directionalIntensity={1.0}
- *         shadows={true}
- *     />
- * </Canvas>
- * ```
- */
-export declare function Lighting3D({ ambientIntensity, ambientColor, directionalIntensity, directionalColor, directionalPosition, shadows, shadowMapSize, shadowCameraSize, showHelpers, }: Lighting3DProps): React.JSX.Element;
-export default Lighting3D;

package/dist/components/game/3d/molecules/ModelLoader.d.ts

@@ -1,44 +0,0 @@
-/**
- * ModelLoader Component
- *
- * React Three Fiber component for loading and displaying GLB/GLTF models from URLs.
- * Handles loading states and errors without requiring React Suspense.
- *
- * @packageDocumentation
- */
-import React from 'react';
-export interface ModelLoaderProps {
-    /** URL to the GLB/GLTF model */
-    url: string;
-    /** Position [x, y, z] */
-    position?: [number, number, number];
-    /** Scale - either a single number or [x, y, z] */
-    scale?: number | [number, number, number];
-    /** Rotation in degrees [x, y, z] */
-    rotation?: [number, number, number];
-    /** Whether the model is selected */
-    isSelected?: boolean;
-    /** Whether the model is hovered */
-    isHovered?: boolean;
-    /** Click handler */
-    onClick?: () => void;
-    /** Hover handler */
-    onHover?: (hovered: boolean) => void;
-    /** Fallback geometry type */
-    fallbackGeometry?: 'box' | 'sphere' | 'cylinder' | 'none';
-    /** Enable shadows */
-    castShadow?: boolean;
-    /** Receive shadows */
-    receiveShadow?: boolean;
-    /**
-     * Base path for shared resources (textures, materials).
-     * If not provided, auto-detected from the URL by looking for a `/3d/` segment.
-     * E.g. "https://host/3d/" so that "Textures/colormap.png" resolves correctly.
-     */
-    resourceBasePath?: string;
-}
-/**
- * ModelLoader component for rendering GLB models in React Three Fiber
- */
-export declare function ModelLoader({ url, position, scale, rotation, isSelected, isHovered, onClick, onHover, fallbackGeometry, castShadow, receiveShadow, resourceBasePath, }: ModelLoaderProps): React.JSX.Element;
-export default ModelLoader;

package/dist/components/game/3d/molecules/Scene3D.d.ts

@@ -1,37 +0,0 @@
-/**
- * Scene3D
- *
- * Three.js scene wrapper component for React Three Fiber.
- * Manages the scene environment, fog, and background.
- *
- * @packageDocumentation
- */
-import React from 'react';
-export interface Scene3DProps {
-    /** Background color or URL */
-    background?: string;
-    /** Fog configuration */
-    fog?: {
-        color: string;
-        near: number;
-        far: number;
-    };
-    /** Children to render in scene */
-    children?: React.ReactNode;
-}
-/**
- * Scene3D Component
- *
- * Manages Three.js scene settings like background and fog.
- *
- * @example
- * ```tsx
- * <Canvas>
- *     <Scene3D background="#1a1a2e" fog={{ color: '#1a1a2e', near: 10, far: 50 }}>
- *         <GameObjects />
- *     </Scene3D>
- * </Canvas>
- * ```
- */
-export declare function Scene3D({ background, fog, children }: Scene3DProps): React.JSX.Element;
-export default Scene3D;

package/dist/components/game/3d/molecules/index.d.ts

@@ -1,36 +0,0 @@
-/**
- * Game 3D (three.js)
- *
- * Three.js components, hooks, loaders, renderers, and the GameCanvas3D family.
- * Code-split behind the `@almadar/ui/components/molecules/game/three` subpath.
- *
- * @packageDocumentation
- */
-export { Scene3D, type Scene3DProps } from './Scene3D';
-export { Camera3D, type Camera3DProps, type Camera3DHandle, type CameraMode } from './Camera3D';
-export { Lighting3D, type Lighting3DProps } from './Lighting3D';
-export { Canvas3DLoadingState, type Canvas3DLoadingStateProps, } from './Canvas3DLoadingState';
-export { Canvas3DErrorBoundary, type Canvas3DErrorBoundaryProps, type Canvas3DErrorBoundaryState, } from './Canvas3DErrorBoundary';
-export { ModelLoader, type ModelLoaderProps, } from './ModelLoader';
-export { useThree, type UseThreeOptions, type UseThreeReturn, } from '../../shared/hooks/useThree';
-export { useAssetLoader, type UseAssetLoaderOptions, type UseAssetLoaderReturn, type AssetLoadingState, } from '../../shared/hooks/useAssetLoader';
-export { useSceneGraph, type UseSceneGraphReturn, type SceneGraphNode, type NodeType, } from '../../shared/hooks/useSceneGraph';
-export { useRaycaster, type UseRaycasterOptions, type UseRaycasterReturn, type RaycastHit, type GridHit, } from '../../shared/hooks/useRaycaster';
-export { useGameCanvas3DEvents, type UseGameCanvas3DEventsOptions, type UseGameCanvas3DEventsReturn, type GameCanvas3DEventConfig, } from '../../shared/hooks/useGameCanvas3DEvents';
-export { AssetLoader, assetLoader, type LoadedModel, } from '../../shared/lib/AssetLoader';
-export type { UnitAnimationState } from '../../shared/spriteAnimationTypes';
-export { GameCanvas3D, type GameCanvas3DProps } from './GameCanvas3D';
-export { Canvas3D, type Canvas3DProps } from './Canvas3D';
-export { GameCanvas3DBattleTemplate, type GameCanvas3DBattleTemplateProps } from '../templates/GameCanvas3DBattleTemplate';
-export { GameCanvas3DCastleTemplate, type GameCanvas3DCastleTemplateProps } from '../templates/GameCanvas3DCastleTemplate';
-export { GameCanvas3DWorldMapTemplate, type GameCanvas3DWorldMapTemplateProps } from '../templates/GameCanvas3DWorldMapTemplate';
-export { gridToWorld, worldToGrid, raycastToPlane, raycastToObjects, gridDistance, gridManhattanDistance, getNeighbors, isInBounds, getCellsInRadius, createGridHighlight, normalizeMouseCoordinates, type Grid3DConfig, type GridCoordinate, } from '../../shared/lib/grid3D';
-export { Avl3DViewer, type Avl3DViewerProps } from '../../../avl/organisms/Avl3DViewer';
-export { Avl3DApplicationScene, type Avl3DApplicationSceneProps } from '../../../avl/organisms/Avl3DApplicationScene';
-export { Avl3DOrbitalScene, type Avl3DOrbitalSceneProps } from '../../../avl/organisms/Avl3DOrbitalScene';
-export { Avl3DTraitScene, type Avl3DTraitSceneProps } from '../../../avl/organisms/Avl3DTraitScene';
-export { Avl3DTransitionScene, type Avl3DTransitionSceneProps } from '../../../avl/organisms/Avl3DTransitionScene';
-export { Avl3DEffects, type Avl3DEffectsProps } from '../../../avl/organisms/Avl3DEffects';
-export { Avl3DContext, useAvl3DConfig, type Avl3DModelOverrides, type Avl3DConfig } from '../../../avl/providers/avl-3d-context';
-export { AVL_3D_COLORS, CAMERA_POSITIONS, goldenSpiralPositions, fibonacciSpherePositions, orbitRingPositions, arcCurve3D, selfLoopCurve3D, treeLayout3D, type Position3D, } from '../../../avl/lib/avl-3d-layout';
-export { isInFrustum, filterByFrustum, getVisibleIndices, calculateLODLevel, updateInstanceLOD, cullInstancedMesh, SpatialHashGrid, type CullingOptions, type LODLevel, type LODConfig, } from '../../shared/lib/culling';

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

@@ -1,66 +0,0 @@
-/**
- * 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 '../../shared/isometricTypes';
-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;
-    /** Unit draw-size multiplier forwarded to GameCanvas3D. Default 1. */
-    unitScale?: number;
-    /** Board zoom/group scale forwarded to GameCanvas3D. Default 0.45. */
-    scale?: number;
-    /** 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, unitScale, scale, 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/3d/patterns.d.ts

@@ -1,20 +0,0 @@
-/**
- * Curated list of the PUBLIC 3D (Three.js) render-ui pattern components.
- *
- * The 3D family is a code-split optional surface (published via the
- * `@almadar/ui/components/{organisms,molecules}/game/three` subpath, never in
- * the main barrel — that would pull @react-three/fiber into every app). This
- * file is the source of truth for WHICH 3D components are render-ui patterns:
- * `pattern-sync` discovers `patterns.ts` files by walking the tree and admits
- * exactly the names listed here, so the 3D scene internals re-exported alongside
- * them (Scene3D, Camera3D, Lighting3D, ModelLoader, Canvas3D, …) do NOT leak in
- * as factory patterns. Move this file anywhere under `components/` and the
- * scanner still finds it.
- *
- * @packageDocumentation
- */
-export { GameCanvas3D } from './molecules/GameCanvas3D';
-export { GameBoard3D } from './organisms/GameBoard3D';
-export { GameCanvas3DBattleTemplate } from './templates/GameCanvas3DBattleTemplate';
-export { GameCanvas3DCastleTemplate } from './templates/GameCanvas3DCastleTemplate';
-export { GameCanvas3DWorldMapTemplate } from './templates/GameCanvas3DWorldMapTemplate';