@almadar/shell-web 1.0.0 → 1.1.0

package/dist/Canvas3DHost-BkZQB5l2.d.ts

@@ -1,552 +0,0 @@
-import { AnimationName, Asset, ScenePos, EventEmit, EventKey } from '@almadar/core';
-import React__default from 'react';
-import * as THREE from 'three';
-import { D as DrawableNode } from './paintDispatch-CuJLsr9Y.js';
-
-/**
- * Sprite Sheet Animation Types
- *
- * Type definitions for frame-based sprite sheet animation system.
- * Supports standard 8-column × 5-row character sheets.
- *
- * `AnimationName`, `AnimationDef`, and `SpriteDirection` are canonically owned
- * by `@almadar/core` (they travel with a `spriteSheet`-role `Asset.url`'s
- * resolved atlas contract) — re-exported here so existing call sites in this
- * package don't need to change their import path.
- *
- * @packageDocumentation
- */
-
-/** Unit facing direction on screen (4 isometric directions) */
-type FacingDirection = 'se' | 'sw' | 'ne' | 'nw';
-/** A resolved frame ready to draw on canvas */
-interface ResolvedFrame {
-    /** URL of the sprite sheet image */
-    sheetUrl: string;
-    /** Source X in the sheet (pixel offset) */
-    sx: number;
-    /** Source Y in the sheet (pixel offset) */
-    sy: number;
-    /** Source width (frame width) */
-    sw: number;
-    /** Source height (frame height) */
-    sh: number;
-    /** Whether to flip horizontally when drawing (for NE/NW directions) */
-    flipX: boolean;
-    /** When true, canvas should apply sine-bob breathing offset (frozen idle frame) */
-    applyBreathing?: boolean;
-}
-/** Per-unit animation state tracked in the animation system */
-interface UnitAnimationState {
-    /** Unit identifier */
-    unitId: string;
-    /** Current animation playing */
-    animation: AnimationName;
-    /** Current facing direction */
-    direction: FacingDirection;
-    /** Current frame index within the animation */
-    frame: number;
-    /** Elapsed time in current animation (ms) */
-    elapsed: number;
-    /** Animation to play after current one-shot completes (null = idle) */
-    queuedAnimation: AnimationName | null;
-    /** Whether the current one-shot animation has finished its last frame */
-    finished: boolean;
-}
-/** Frame dimensions for a sprite sheet */
-interface SpriteFrameDims {
-    /** Width of a single frame in pixels */
-    width: number;
-    /** Height of a single frame in pixels */
-    height: number;
-}
-/**
- * Sheet URLs per facing. Legacy hand-drawn packs ship only se/sw (ne/nw are
- * mirror-flipped — a cheat that shows the face while walking away); 3D-baked
- * sheets also ship real ne/nw, which `resolveFrame` prefers when present.
- */
-interface SpriteSheetUrls {
-    /** Southeast-facing sheet URL */
-    se: string;
-    /** Southwest-facing sheet URL */
-    sw: string;
-    /** Northeast-facing sheet URL (real back view; omitted → mirror of sw) */
-    ne?: string;
-    /** Northwest-facing sheet URL (real back view; omitted → mirror of se) */
-    nw?: string;
-}
-
-/**
- * Game Types — Generalized
- *
- * Core type definitions for tactical game state.
- * Extracted from Trait Wars and generalized for any game project.
- */
-interface Position {
-    x: number;
-    y: number;
-}
-interface GameUnit {
-    id: string;
-    name: string;
-    characterType: string;
-    team: 'player' | 'enemy' | 'neutral';
-    position: Position;
-    health: number;
-    maxHealth: number;
-    movement: number;
-    attack: number;
-    defense: number;
-    traits: UnitTrait[];
-}
-interface UnitTrait {
-    name: string;
-    currentState: string;
-    states: string[];
-    cooldown: number;
-}
-interface BoardTile {
-    terrain: string;
-    unitId?: string;
-    isBlocked?: boolean;
-}
-type GamePhase = 'observation' | 'planning' | 'execution' | 'tick';
-interface GameState {
-    board: BoardTile[][];
-    units: Record<string, GameUnit>;
-    currentPhase: GamePhase;
-    currentTurn: number;
-    activeTeam: 'player' | 'enemy' | 'neutral';
-    selectedUnitId?: string;
-    validMoves: Position[];
-    attackTargets: Position[];
-}
-type GameAction = {
-    type: 'SELECT_UNIT';
-    unitId: string;
-} | {
-    type: 'MOVE_UNIT';
-    from: Position;
-    to: Position;
-} | {
-    type: 'ATTACK';
-    attackerId: string;
-    targetId: string;
-} | {
-    type: 'END_TURN';
-} | {
-    type: 'EXECUTE_TRAITS';
-};
-/**
- * Create the initial game state with board and units.
- *
- * @param {number} width - Board width in tiles
- * @param {number} height - Board height in tiles
- * @param {GameUnit[]} units - Initial units to place on the board
- * @param {string} [defaultTerrain] - Default terrain type for empty tiles
- * @returns {GameState} The initialized game state
- */
-declare function createInitialGameState(width: number, height: number, units: GameUnit[], defaultTerrain?: string): GameState;
-/**
- * Calculate valid movement positions for a unit.
- *
- * Returns all tiles within the unit's movement range that are
- * not blocked and don't contain other units.
- *
- * @param {GameState} state - Current game state
- * @param {string} unitId - ID of the unit to calculate moves for
- * @returns {Position[]} Array of valid move positions
- */
-declare function calculateValidMoves(state: GameState, unitId: string): Position[];
-/**
- * Calculate valid attack targets for a unit.
- *
- * Returns adjacent positions containing enemy units that can be attacked.
- *
- * @param {GameState} state - Current game state
- * @param {string} unitId - ID of the unit to calculate targets for
- * @returns {Position[]} Array of valid attack target positions
- */
-declare function calculateAttackTargets(state: GameState, unitId: string): Position[];
-
-/** A single isometric tile on the grid */
-interface IsometricTile {
-    /** Optional unique identifier (required for 3D rendering) */
-    id?: string;
-    /** Grid x coordinate */
-    x: number;
-    /** Grid y coordinate (2D) */
-    y: number;
-    /** Grid z coordinate (3D alternative to y) */
-    z?: number;
-    /** Terrain type key (e.g., 'grass', 'stone', 'water') - 2D */
-    terrain?: string;
-    /** Tile type for visual rendering (3D) */
-    type?: string;
-    /** Direct sprite URL override (bypasses getTerrainSprite resolver) */
-    terrainSprite?: Asset;
-    /** Fallback/override fill color (2D + 3D) — bypasses the terrain color map. `.lolo`-computed. */
-    color?: string;
-    /** Whether units can traverse this tile (default true) */
-    passable?: boolean;
-    /** Movement cost for pathfinding (default 1) */
-    movementCost?: number;
-    /** Optional tile type for visual variants */
-    tileType?: string;
-    /** Elevation offset for 3D rendering */
-    elevation?: number;
-    /** 3D model URL (GLB format) for GameCanvas3D — rendered via ModelLoader with box fallback */
-    modelUrl?: Asset;
-    /** Y-axis rotation in degrees (3D) — orients directional pieces (track corners, road bends) */
-    rotation?: number;
-}
-/** A unit positioned on the isometric grid */
-type IsometricUnit = {
-    /** Unique unit identifier */
-    id: string;
-    /** Current grid position (2D format) */
-    position?: {
-        x: number;
-        y: number;
-    };
-    /** Grid x coordinate (3D format) */
-    x?: number;
-    /** Grid y coordinate (3D format) */
-    y?: number;
-    /** Grid z coordinate (3D format) */
-    z?: number;
-    /** Static sprite URL (used when no sprite sheet animation) */
-    sprite?: Asset;
-    /** Sprite-sheet atlas JSON URL (e.g. `.../guardian-sprite-sheet.json`).
-     *  When set, the canvas loads the atlas and crops/animates a single frame
-     *  by animation state instead of drawing the whole sheet. */
-    spriteSheet?: Asset;
-    /** 3D model URL (GLB format) for GameCanvas3D — rendered via ModelLoader with box fallback */
-    modelUrl?: Asset;
-    /** Unit archetype key for sprite resolution */
-    unitType?: string;
-    /** Hero identifier for sprite sheet lookup */
-    heroId?: string;
-    /** Display name rendered below the unit */
-    name?: string;
-    /** Team affiliation for coloring */
-    team?: 'player' | 'enemy' | 'neutral';
-    /** Faction for 3D rendering (player/enemy/neutral) */
-    faction?: 'player' | 'enemy' | 'neutral';
-    /** Fallback/override tint color (2D + 3D) — bypasses the team/faction color map. `.lolo`-computed. */
-    tint?: string;
-    /** Current health */
-    health?: number;
-    /** Maximum health */
-    maxHealth?: number;
-    /** Trait attachments for state display */
-    traits?: UnitTrait[];
-    /** Previous position for movement trail ghost */
-    previousPosition?: {
-        x: number;
-        y: number;
-    };
-    /** Elevation offset for 3D rendering */
-    elevation?: number;
-    /** Animation name — driven by the LOLO state machine; renderer defaults to 'idle' */
-    animation?: AnimationName;
-    /** Frame index within the animation — driven by the LOLO state machine; renderer defaults to 0 */
-    frame?: number;
-    /** Y-axis heading in radians (3D) — travel/facing direction. Orients the unit model and
-     *  drives the `chase` camera (behind + above, looking along heading). Driving boards set this. */
-    heading?: number;
-};
-/** A map feature (resource, building, portal, etc.) */
-type IsometricFeature = {
-    /** Optional unique identifier (required for 3D rendering) */
-    id?: string;
-    /** Grid x coordinate */
-    x: number;
-    /** Grid y coordinate (2D) */
-    y: number;
-    /** Grid z coordinate (3D alternative to y) */
-    z?: number;
-    /** Feature type key (e.g., 'goldMine', 'castle', 'portal') */
-    type: string;
-    /** Direct sprite URL override (bypasses getFeatureSprite resolver) */
-    sprite?: Asset;
-    /** 3D model URL (GLB format) for GameCanvas3D */
-    assetUrl?: Asset;
-    /** Color override for 3D rendering */
-    color?: string;
-    /** Elevation offset for 3D rendering */
-    elevation?: number;
-    /** Y-axis rotation in radians (3D) — orients directional features (arches, signs, docks). */
-    rotation?: number;
-};
-/** Camera state for pan/zoom */
-interface CameraState {
-    /** Camera X offset in pixels */
-    x: number;
-    /** Camera Y offset in pixels */
-    y: number;
-    /** Zoom level (1.0 = 100%) */
-    zoom: number;
-}
-
-/**
- * Canvas3DHost — the thin 3D draw-host: the `canvas` host's 3D painter backend
- * (the R3F "vessel" behind the neutral drawables), the exact 3D analogue of the
- * 2D `Painter2D` seam. Reached only via the lazy `@almadar/ui/.../game/three`
- * subpath so three.js never enters a 2D bundle.
- *
- * The 3D twin of Canvas2D: the board authors a `drawables` list (the neutral
- * `draw-*` children) and this host maps each descriptor through `Drawable3D` to a
- * three.js mesh (a raw descriptor NEVER reaches `<group>{children}` — R3F throws).
- * It owns NO game data — tiles, units, features, selection, health bars and labels
- * are all `draw-*` children composed in `.lolo`, not props here. Only view state
- * (camera, error boundary) is local.
- *
- * Camera: `isometric`/`perspective`/`top-down` frame the scene bounds (derived from
- * the drawn descriptors); `follow`/`chase` track the neutral core `Camera.target`
- * (forwarded as `followTarget`), falling back to the scene centre.
- *
- * Interaction: keyboard maps to semantic events (device-agnostic input). Pointer
- * click on a tagged drawable (a descriptor carrying `DrawableBase.id`) raycasts to
- * the mesh and walks up to the tagged ancestor → `unitClickEvent {unitId,x,z}`;
- * a click that hits no tagged mesh falls back to the ground-plane cell raycast →
- * `tileClickEvent`. Pointer hover/feature events are accepted but not yet
- * emitted (docs/Almadar_Std_Gaps.md S-CANVAS3D-HOVER-DEAD).
- *
- * @packageDocumentation
- */
-
-/** Camera mode for 3D view.
- *  - `follow` tracks `followTarget` (the neutral `Camera.target`) from a fixed offset.
- *  - `chase` sits behind + above the target. */
-type CameraMode = 'isometric' | 'perspective' | 'top-down' | 'front' | 'follow' | 'chase';
-/** Map orientation */
-type MapOrientation = 'standard' | 'rotated';
-/** Overlay control */
-type OverlayControl = 'default' | 'hidden' | 'minimap';
-/** Single light's tunable knobs (ambient/directional share this shape). */
-interface CanvasLightConfig {
-    intensity?: number;
-    color?: string;
-    position?: [number, number, number];
-}
-/** Hemisphere (sky/ground) light config. */
-interface CanvasHemisphereConfig {
-    intensity?: number;
-    color?: string;
-    groundColor?: string;
-}
-/** Point light config — `position` is required since a point light has no
- *  meaningful default placement. */
-interface CanvasPointLightConfig {
-    intensity?: number;
-    color?: string;
-    position: [number, number, number];
-    distance?: number;
-    decay?: number;
-}
-/** Canvas-level 3D light rig, authored as data. Every field is optional — an
- *  omitted field falls back to today's fixed rig (the defaults live in `Lighting3D`). */
-interface CanvasLighting {
-    /** Default intensity 0.6, color '#ffffff'. */
-    ambient?: CanvasLightConfig;
-    /** Default intensity 0.8, color '#ffffff', position [10, 20, 10]. */
-    directional?: CanvasLightConfig;
-    /** Default intensity 0.3, color '#87ceeb', groundColor '#362d1d'. */
-    hemisphere?: CanvasHemisphereConfig;
-    /** Additional point lights. Default none. */
-    points?: CanvasPointLightConfig[];
-    /** Procedural environment for PBR reflection (metals/glass). 'room' uses three's
-     *  RoomEnvironment via PMREMGenerator — no network fetch. Default 'none' (today's
-     *  look). */
-    environment?: 'room' | 'none';
-    /** Output tone mapping. Default 'aces' (R3F's filmic default — the stylized look
-     *  every existing scene was authored under); 'none' renders material colors
-     *  faithfully (raw three default — what GLB viewers show). */
-    toneMapping?: 'aces' | 'none';
-}
-/** Canvas-level post-processing stack. Every field is optional — an omitted field
- *  means that pass is not mounted. */
-interface CanvasPost {
-    bloom?: {
-        intensity?: number;
-        threshold?: number;
-        smoothing?: number;
-    };
-    vignette?: {
-        offset?: number;
-        darkness?: number;
-    };
-}
-/** Props for GameCanvas3D component */
-interface Canvas3DHostProps {
-    /** Additional CSS classes */
-    className?: string;
-    /** Declarative JSX drawable children — rendered in a hidden DOM mount where they
-     *  register their descriptors via DrawableRegistryContext (same contract as Canvas2D). */
-    children?: React__default.ReactNode;
-    /** Neutral drawable descriptors — the same `children` vocabulary as Canvas2D. The
-     *  host maps each through `Drawable3D` to a mesh. */
-    drawables?: DrawableNode[];
-    /** Loading state indicator */
-    isLoading?: boolean;
-    /** Error state */
-    error?: string | null;
-    /** Fog of war data (accepted for API parity; presentation-only). */
-    fogOfWar?: boolean[][];
-    /** Map orientation (data attribute). */
-    orientation?: MapOrientation;
-    /** Camera mode */
-    cameraMode?: CameraMode;
-    /** Follow-camera target in scene space (the neutral core `Camera.target`). */
-    followTarget?: ScenePos;
-    /** Show grid */
-    showGrid?: boolean;
-    /** Show coordinates overlay (accepted for API parity). */
-    showCoordinates?: boolean;
-    /** Show tile information (accepted for API parity). */
-    showTileInfo?: boolean;
-    /** Overlay control mode (data attribute). */
-    overlay?: OverlayControl;
-    /** Enable shadows */
-    shadows?: boolean;
-    /** Background color */
-    /** Overrides the theme's categorical palette (`series-1…N`) for this scene. */
-    series?: string[];
-    backgroundColor?: string;
-    /** Declarative event: tile click. Emitted from a ground-plane raycast → scene cell
-     *  `{ x, z }` (the FSM validates the cell). `tileId` is optional — the neutral host
-     *  has no per-tile id, and the board FSMs key off the coordinate. */
-    tileClickEvent?: EventEmit<{
-        x: number;
-        z: number;
-        tileId?: string;
-        type?: string;
-        terrain?: string;
-        elevation?: number;
-    }>;
-    /** Declarative event: unit click. Emitted `{ unitId, x, z }` when the raycast hits a
-     *  mesh tagged with a descriptor `id` (or lands on a ground cell whose descriptor
-     *  carries an `id`). */
-    unitClickEvent?: EventEmit<{
-        unitId: string;
-        x: number;
-        z: number;
-        unitType?: string;
-        name?: string;
-        team?: string;
-        faction?: string;
-        health?: number;
-        maxHealth?: number;
-    }>;
-    /** Declarative event: feature click. Accepted; not yet emitted (see `tileClickEvent`). */
-    featureClickEvent?: EventEmit<{
-        featureId: string;
-        x: number;
-        z: number;
-        type?: string;
-        elevation?: number;
-    }>;
-    /** Declarative event: canvas (background) click. */
-    canvasClickEvent?: EventEmit<{
-        clientX: number;
-        clientY: number;
-        button: number;
-    }>;
-    /** Declarative event: tile hover. Accepted; not yet emitted (see `tileClickEvent`). */
-    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;
-    /** Unit draw-size multiplier (accepted for API parity; sizing is drawable-authored). */
-    unitScale?: number;
-    /** Board zoom — the neutral `Camera.zoom`. Dollies the camera: the framing
-     *  distance is divided by `zoom` (undefined/1 = default framing; <= 0 ignored). */
-    zoom?: number;
-    /** Enable the orbit camera controls. Default true; `follow`/`chase` modes always
-     *  disable them (the follow camera is authoritative). */
-    controlsEnabled?: boolean;
-    /** Maps a keydown `e.code` — optionally prefixed `Mod+` (⌘/Ctrl), `Shift+`, `Alt+` in that order — to the board's SEMANTIC event (device-agnostic input), emitted as `UI:{event}`; keystrokes inside inputs/textareas never route. */
-    keyMap?: Record<string, EventKey>;
-    /** Maps a keyup `e.code` — optionally prefixed `Mod+` (⌘/Ctrl), `Shift+`, `Alt+` in that order — to the board's SEMANTIC event, emitted as `UI:{event}`; keystrokes inside inputs/textareas never route. */
-    keyUpMap?: Record<string, EventKey>;
-    /** Side-view world size in pixels (accepted for API parity). */
-    worldWidth?: number;
-    /** Side-view world size in pixels (accepted for API parity). */
-    worldHeight?: number;
-    /** Pixel→world-unit divisor for pixel-authored (side-view) scenes: world size =
-     *  scene size ÷ `pixelsPerUnit`. Omitted → 1 world unit per scene unit (grid boards). */
-    pixelsPerUnit?: number;
-    /** Perspective field of view in degrees — the neutral `Camera.fov`. Default 45. */
-    fov?: number;
-    /** Orbit the mode's framing position around the vertical axis through the target, in radians — the neutral `Camera.azimuth`. */
-    azimuth?: number;
-    /** Orbit height angle above the ground plane, in radians — the neutral `Camera.elevation`
-     *  (perspective mode). Omitted → the mode's fixed framing height. */
-    elevation?: number;
-    /** 3D scene light rig as data — ambient/directional/hemisphere/point lights + optional
-     *  'room' environment. Omitted → the standard fixed rig (this host's current
-     *  hardcoded lights, unchanged). */
-    lighting?: CanvasLighting;
-    /** 3D post-processing stack — bloom + vignette. Omitted → no composer pass mounted. */
-    post?: CanvasPost;
-    /** Enter scene-edit mode: click selects/deselects a drawable, drag moves it. */
-    editable?: boolean;
-    /** The currently-selected drawable id (controlled); `null`/undefined = none. */
-    selectedId?: string | null;
-    /** Fired on a click that changes selection — before `selectEvent`. */
-    onSelect?: (id: string | null) => void;
-    /** Fired once per drag gesture, on drop — before `moveEvent`. */
-    onMove?: (id: string, x: number, y: number) => void;
-    /** Declarative selection event, `UI:{selectEvent} { id }`. */
-    selectEvent?: EventEmit<{
-        id: string | null;
-    }>;
-    /** Declarative move event, `UI:{moveEvent} { id, x, y }` — fired once on drop. */
-    moveEvent?: EventEmit<{
-        id: string;
-        x: number;
-        y: number;
-    }>;
-}
-/** Imperative handle for GameCanvas3D */
-interface Canvas3DHostHandle {
-    /** 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;
-}
-/**
- * Canvas3DHost — thin 3D draw-host. Walks `drawables` through `Drawable3D`.
- */
-declare const Canvas3DHost: React__default.ForwardRefExoticComponent<Canvas3DHostProps & React__default.RefAttributes<Canvas3DHostHandle>>;
-
-export { Canvas3DHost as c, calculateAttackTargets as n, calculateValidMoves as o, createInitialGameState as p };
-export type { BoardTile as B, CanvasPointLightConfig as C, FacingDirection as F, GameAction as G, IsometricTile as I, Position as P, ResolvedFrame as R, SpriteSheetUrls as S, UnitAnimationState as U, IsometricUnit as a, IsometricFeature as b, Canvas3DHostHandle as d, Canvas3DHostProps as e, SpriteFrameDims as f, CanvasLighting as g, CanvasPost as h, CameraState as i, GamePhase as j, GameState as k, GameUnit as l, UnitTrait as m };

package/dist/ModuleCard-QHDGK5XK.js

@@ -1,7 +0,0 @@
-export { ModuleCard } from './chunk-E6KA4J6N.js';
-import './chunk-HH5KSMH5.js';
-import './chunk-AB3X7QTE.js';
-import './chunk-DZBQA2OW.js';
-import './chunk-UXLE3IPR.js';
-import './chunk-4YXBKHHM.js';
-import './chunk-G7DCAZ22.js';