@almadar/ui 5.79.1 → 5.79.2

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

@@ -0,0 +1,37 @@
+import React from 'react';
+import type { AssetUrl, EventEmit } from '@almadar/core';
+import type { IsometricTile, IsometricUnit, IsometricFeature } from '../../shared/isometricTypes';
+import type { DisplayStateProps } from '../../../core/organisms/types';
+import type { Canvas2DProps } from '../molecules/Canvas2D';
+export interface MinigolfBoardProps extends DisplayStateProps {
+    /** Isometric grid tiles */
+    tiles?: IsometricTile[];
+    /** Units on the board */
+    units?: IsometricUnit[];
+    /** Features (holes, obstacles, etc.) on the board */
+    features?: IsometricFeature[];
+    /** Asset sprite manifest (same shape as Canvas2D.assetManifest) */
+    assetManifest?: Canvas2DProps['assetManifest'];
+    /** Base URL prepended to manifest sprite paths */
+    assetBaseUrl?: AssetUrl;
+    /** Render scale */
+    scale?: number;
+    /** Show minimap overlay */
+    showMinimap?: boolean;
+    /** Enable camera pan/zoom controls */
+    enableCamera?: boolean;
+    /** Declarative event: emits UI:{tileClickEvent} with { x, y } on tile click */
+    tileClickEvent?: EventEmit<{
+        x: number;
+        y: number;
+    }>;
+    /** Declarative event: emits UI:{unitClickEvent} with { unitId } on unit click */
+    unitClickEvent?: EventEmit<{
+        unitId: string;
+    }>;
+}
+export declare function MinigolfBoard({ tiles, units, features, assetManifest, assetBaseUrl, scale, showMinimap, enableCamera, tileClickEvent, unitClickEvent, isLoading, error, className, }: MinigolfBoardProps): React.ReactElement;
+export declare namespace MinigolfBoard {
+    var displayName: string;
+}
+export default MinigolfBoard;

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

@@ -0,0 +1,56 @@
+/**
+ * NegotiatorBoard
+ *
+ * Turn-based decision matrix game. The player makes choices
+ * over multiple rounds against an AI opponent. Each round
+ * both sides pick an action, and payoffs are determined by
+ * the combination.
+ *
+ * Good for: ethics, business, game theory, economics stories.
+ *
+ * Events emitted via completeEvent (default UI:PUZZLE_COMPLETE).
+ */
+import React from 'react';
+import type { EventEmit, EntityRow, Asset } from '@almadar/core';
+import type { DisplayStateProps } from '../../../core/organisms/types';
+/** A selectable round action (UI value DTO read off the entity). */
+export interface NegotiatorAction {
+    id: string;
+    label: string;
+    description?: string;
+}
+/** A payoff-matrix cell (UI value DTO read off the entity). */
+export interface PayoffEntry {
+    playerAction: string;
+    opponentAction: string;
+    playerPayoff: number;
+    opponentPayoff: number;
+}
+export interface NegotiatorBoardProps extends DisplayStateProps {
+    /** Puzzle board-state entity (single row or array). The board reads
+     *  `score` / `round` / `result` / `targetScore` / `maxRounds` plus the
+     *  `actions` / `payoffMatrix` arrays and title/description/hint off the row.
+     *  Score accumulation + win/lose are owned by the gameplay machine. */
+    entity?: EntityRow | readonly EntityRow[];
+    completeEvent?: EventEmit<{
+        success: boolean;
+        score: number;
+    }>;
+    /** Emits UI:{playRoundEvent} with the picked action + the UI-resolved payoff. */
+    playRoundEvent?: EventEmit<{
+        playerAction: string;
+        payoff: number;
+    }>;
+    /** Emits UI:{finishEvent} with {} when all rounds are spent. */
+    finishEvent?: EventEmit<Record<string, never>>;
+    /** Emits UI:{playAgainEvent} with {} on play again / reset. */
+    playAgainEvent?: EventEmit<Record<string, never>>;
+    /** Optional per-semantic-key asset overrides for icons (correct/arrow). */
+    assetManifest?: {
+        ui?: Record<string, Asset>;
+    };
+}
+export declare function NegotiatorBoard({ entity, completeEvent, playRoundEvent, finishEvent, playAgainEvent, assetManifest, className, }: NegotiatorBoardProps): React.JSX.Element | null;
+export declare namespace NegotiatorBoard {
+    var displayName: string;
+}

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

@@ -0,0 +1,27 @@
+/**
+ * ObjectRulePanel Component
+ *
+ * Shows the rules panel for a selected world object in the Event Handler tier.
+ * Displays object info, its current state (via TraitStateViewer), and
+ * a list of WHEN/THEN rules the kid has set.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import type { EntityRow } from '@almadar/core';
+import { type RuleDefinition } from './RuleEditor';
+export interface ObjectRulePanelProps {
+    /** The selected puzzle-object row (`EntityRow` carrying the editable object data) */
+    object: EntityRow;
+    /** Called when rules change */
+    onRulesChange: (objectId: string, rules: RuleDefinition[]) => void;
+    /** Whether editing is disabled */
+    disabled?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function ObjectRulePanel({ object, onRulesChange, disabled, className, }: ObjectRulePanelProps): React.JSX.Element;
+export declare namespace ObjectRulePanel {
+    var displayName: string;
+}
+export default ObjectRulePanel;

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

@@ -0,0 +1,43 @@
+import React from 'react';
+import type { Asset, AssetUrl, EventEmit, EntityRow } from '@almadar/core';
+import type { DisplayStateProps } from '../../../core/organisms/types';
+/** Asset manifest shape for PinballBoard. */
+type PinballAssetManifest = {
+    terrains?: Record<string, Asset>;
+    units?: Record<string, Asset>;
+    features?: Record<string, Asset>;
+    effects?: Record<string, Asset>;
+    ui?: Record<string, Asset>;
+};
+export interface PinballBoardProps extends DisplayStateProps {
+    /** Playfield tiles */
+    tiles?: readonly EntityRow[];
+    /** Ball units on the board */
+    units?: readonly EntityRow[];
+    /** Features (bumpers, paddles, etc.) on the board */
+    features?: readonly EntityRow[];
+    /** Asset sprite manifest */
+    assetManifest?: PinballAssetManifest;
+    /** Base URL prepended to manifest sprite paths */
+    assetBaseUrl?: AssetUrl;
+    /** Render scale */
+    scale?: number;
+    /** Show minimap overlay */
+    showMinimap?: boolean;
+    /** Enable camera pan/zoom controls */
+    enableCamera?: boolean;
+    /** Declarative event: emits UI:{tileClickEvent} with { x, y } on tile click */
+    tileClickEvent?: EventEmit<{
+        x: number;
+        y: number;
+    }>;
+    /** Declarative event: emits UI:{unitClickEvent} with { unitId } on unit click */
+    unitClickEvent?: EventEmit<{
+        unitId: string;
+    }>;
+}
+export declare function PinballBoard({ tiles: _tiles, units: _units, features: _features, assetManifest, assetBaseUrl: _assetBaseUrl, scale: _scale, showMinimap, enableCamera, tileClickEvent, unitClickEvent, isLoading, error, className, }: PinballBoardProps): React.ReactElement;
+export declare namespace PinballBoard {
+    var displayName: string;
+}
+export default PinballBoard;

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

@@ -0,0 +1,44 @@
+import React from 'react';
+import type { Asset, AssetUrl, EventEmit } from '@almadar/core';
+import type { IsometricTile, IsometricUnit, IsometricFeature } from '../../shared/isometricTypes';
+import type { DisplayStateProps } from '../../../core/organisms/types';
+/** Asset manifest shape for PirateBoard. */
+type PirateAssetManifest = {
+    terrains?: Record<string, Asset>;
+    units?: Record<string, Asset>;
+    features?: Record<string, Asset>;
+    effects?: Record<string, Asset>;
+    ui?: Record<string, Asset>;
+};
+export interface PirateBoardProps extends DisplayStateProps {
+    /** Sea/island grid tiles */
+    tiles?: IsometricTile[];
+    /** Ship and crew units on the board */
+    units?: IsometricUnit[];
+    /** Features (ports, treasures, etc.) on the board */
+    features?: IsometricFeature[];
+    /** Asset sprite manifest */
+    assetManifest?: PirateAssetManifest;
+    /** Base URL prepended to manifest sprite paths */
+    assetBaseUrl?: AssetUrl;
+    /** Render scale */
+    scale?: number;
+    /** Show minimap overlay */
+    showMinimap?: boolean;
+    /** Enable camera pan/zoom controls */
+    enableCamera?: boolean;
+    /** Declarative event: emits UI:{tileClickEvent} with { x, y } on tile click */
+    tileClickEvent?: EventEmit<{
+        x: number;
+        y: number;
+    }>;
+    /** Declarative event: emits UI:{unitClickEvent} with { unitId } on unit click */
+    unitClickEvent?: EventEmit<{
+        unitId: string;
+    }>;
+}
+export declare function PirateBoard({ tiles, units, features, assetManifest, assetBaseUrl, scale, showMinimap, enableCamera, tileClickEvent, unitClickEvent, isLoading, error, className, }: PirateBoardProps): React.ReactElement;
+export declare namespace PirateBoard {
+    var displayName: string;
+}
+export default PirateBoard;

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

@@ -0,0 +1,46 @@
+import * as React from 'react';
+import type { Asset, EventEmit, EntityRow } from '@almadar/core';
+import type { Platform, SidePlayer } from '../molecules/Canvas2D';
+export interface PlatformerBoardProps {
+    /** Entity containing all board state (result, lives, score, level, player, platforms) */
+    entity?: EntityRow | readonly EntityRow[];
+    /** Direct player state — takes priority over entity-derived player */
+    player?: SidePlayer;
+    /** Direct platform data — takes priority over entity-derived platforms */
+    platforms?: Platform[];
+    /** Game result read from entity */
+    result?: 'none' | 'won' | 'lost';
+    /** Lives remaining */
+    lives?: number;
+    /** Current score */
+    score?: number;
+    /** Current level */
+    level?: number;
+    /** World/canvas dimensions (kept for entity resolution; not forwarded to Canvas2D) */
+    worldWidth?: number;
+    worldHeight?: number;
+    canvasWidth?: number;
+    canvasHeight?: number;
+    /** Player sprite */
+    playerSprite?: Asset;
+    /** Map of platform type to tile sprite */
+    tileSprites?: Record<string, Asset>;
+    /** Canvas background color (not supported by Canvas2D; kept for API compat) */
+    bgColor?: string;
+    /** Emits UI:{keyEvent} with { key } on keydown (replaces per-direction events) */
+    keyEvent?: EventEmit<{
+        key: string;
+    }>;
+    /** Emits UI:{playAgainEvent} on restart */
+    playAgainEvent?: EventEmit<Record<string, never>>;
+    /** Emits UI:{gameEndEvent} with { result } when result becomes won/lost */
+    gameEndEvent?: EventEmit<{
+        result: 'won' | 'lost';
+    }>;
+    className?: string;
+}
+export declare function PlatformerBoard({ entity, player: propPlayer, platforms: propPlatforms, result: propResult, lives: propLives, score: propScore, level: propLevel, worldWidth, worldHeight, canvasWidth: _canvasWidth, canvasHeight: _canvasHeight, playerSprite, tileSprites, bgColor: _bgColor, keyEvent, playAgainEvent, gameEndEvent, className, }: PlatformerBoardProps): React.JSX.Element;
+export declare namespace PlatformerBoard {
+    var displayName: string;
+}
+export default PlatformerBoard;

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

@@ -0,0 +1,44 @@
+import React from 'react';
+import type { Asset, AssetUrl, EventEmit } from '@almadar/core';
+import type { IsometricTile, IsometricUnit, IsometricFeature } from '../../shared/isometricTypes';
+import type { DisplayStateProps } from '../../../core/organisms/types';
+/** Asset manifest shape for RacingBoard. */
+type RacingAssetManifest = {
+    terrains?: Record<string, Asset>;
+    units?: Record<string, Asset>;
+    features?: Record<string, Asset>;
+    effects?: Record<string, Asset>;
+    ui?: Record<string, Asset>;
+};
+export interface RacingBoardProps extends DisplayStateProps {
+    /** Road + grass terrain tiles forming the race circuit */
+    tiles?: IsometricTile[];
+    /** Car units on the track */
+    units?: IsometricUnit[];
+    /** Track features (pit lane markers, start/finish line, etc.) */
+    features?: IsometricFeature[];
+    /** Asset sprite manifest */
+    assetManifest?: RacingAssetManifest;
+    /** Base URL prepended to manifest sprite paths */
+    assetBaseUrl?: AssetUrl;
+    /** Render scale */
+    scale?: number;
+    /** Show minimap overlay */
+    showMinimap?: boolean;
+    /** Enable camera pan/zoom controls */
+    enableCamera?: boolean;
+    /** Declarative event: emits UI:{tileClickEvent} with { x, y } on tile click */
+    tileClickEvent?: EventEmit<{
+        x: number;
+        y: number;
+    }>;
+    /** Declarative event: emits UI:{unitClickEvent} with { unitId } on unit click */
+    unitClickEvent?: EventEmit<{
+        unitId: string;
+    }>;
+}
+export declare function RacingBoard({ tiles, units, features, assetManifest, assetBaseUrl, scale, showMinimap, enableCamera, tileClickEvent, unitClickEvent, isLoading, error, className, }: RacingBoardProps): React.ReactElement;
+export declare namespace RacingBoard {
+    var displayName: string;
+}
+export default RacingBoard;

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

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

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

@@ -0,0 +1,39 @@
+/**
+ * RuleEditor Component
+ *
+ * A single WHEN/THEN rule row for the Event Handler tier (ages 9-12).
+ * Kid picks an event trigger and an action from dropdowns.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+export type RuleDefinition = {
+    id: string;
+    whenEvent: string;
+    thenAction: string;
+};
+export interface RuleOption {
+    value: string;
+    label: string;
+}
+export interface RuleEditorProps {
+    /** The current rule */
+    rule: RuleDefinition;
+    /** Available event triggers to listen for */
+    availableEvents: RuleOption[];
+    /** Available actions to perform */
+    availableActions: RuleOption[];
+    /** Called when rule changes */
+    onChange: (rule: RuleDefinition) => void;
+    /** Called when rule is removed */
+    onRemove?: () => void;
+    /** Whether editing is disabled (during playback) */
+    disabled?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function RuleEditor({ rule, availableEvents, availableActions, onChange, onRemove, disabled, className, }: RuleEditorProps): React.JSX.Element;
+export declare namespace RuleEditor {
+    var displayName: string;
+}
+export default RuleEditor;

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

@@ -0,0 +1,41 @@
+/**
+ * SequenceBar Component
+ *
+ * A row of TraitSlot components forming the action sequence for the
+ * Sequencer tier (ages 5-8). Kids drag ActionTiles from the palette
+ * into these slots to build their sequence.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import type { SlotItemData } from './TraitSlot';
+export interface SequenceBarProps {
+    /** The current sequence (sparse — undefined means empty slot) */
+    slots: Array<SlotItemData | undefined>;
+    /** Max number of slots */
+    maxSlots: number;
+    /** Called when an item is dropped into slot at index */
+    onSlotDrop: (index: number, item: SlotItemData) => void;
+    /** Called when a slot is cleared */
+    onSlotRemove: (index: number) => void;
+    /** Whether the sequence is currently playing (disable interaction) */
+    playing?: boolean;
+    /** Current step index during playback (-1 = not playing) */
+    currentStep?: number;
+    /** Category → color mapping */
+    categoryColors?: Record<string, {
+        bg: string;
+        border: string;
+    }>;
+    /** Per-slot correctness feedback shown after a failed attempt */
+    slotFeedback?: Array<'correct' | 'wrong' | null>;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function SequenceBar({ slots, maxSlots, onSlotDrop, onSlotRemove, playing, currentStep, categoryColors, slotFeedback, size, className, }: SequenceBarProps): React.JSX.Element;
+export declare namespace SequenceBar {
+    var displayName: string;
+}
+export default SequenceBar;

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

@@ -0,0 +1,65 @@
+/**
+ * SequencerBoard Organism
+ *
+ * Contains ALL game logic for the Sequencer tier (ages 5-8).
+ * Manages the action sequence, validates it, and animates Kekec
+ * executing each step on the puzzle scene.
+ *
+ * Feedback-first UX:
+ * - On failure: slots stay in place, each slot gets a green or red
+ *   ring showing exactly which steps are correct and which need to change.
+ * - Modifying a slot clears its individual feedback so the kid can re-try.
+ * - After 3 failures a persistent hint appears above the sequence bar.
+ * - "Reset" clears everything including attempts / hint.
+ *
+ * TraitStateViewer states use indexed labels ("1. Walk", "2. Jump") so that
+ * repeated actions are correctly highlighted during playback.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import type { EventEmit, EntityRow } from '@almadar/core';
+import type { DisplayStateProps } from '../../../core/organisms/types';
+export interface SequencerBoardProps extends DisplayStateProps {
+    /** Puzzle board-state entity (single row or array). The board reads
+     *  `availableActions` / `maxSlots` / `solutions` etc. off the row.
+     *  `availableActions` carries `SlotItemData[]` (a UI drag-DTO, not entity
+     *  data — it holds a non-FieldValue `stateMachine` member). */
+    entity?: EntityRow | readonly EntityRow[];
+    /** Category → color mapping */
+    categoryColors?: Record<string, {
+        bg: string;
+        border: string;
+    }>;
+    /** Playback speed in ms per step */
+    stepDurationMs?: number;
+    /** Emits UI:{playEvent} with { sequence: string[] } */
+    playEvent?: EventEmit<{
+        sequence: string[];
+    }>;
+    /** Emits UI:{completeEvent} with { success: boolean } */
+    completeEvent?: EventEmit<{
+        success: boolean;
+        sequence: string[];
+    }>;
+    /** Emits UI:{placeEvent} with { slotIndex, actionId } when an action is dropped into a slot */
+    placeEvent?: EventEmit<{
+        slotIndex: number;
+        actionId: string;
+    }>;
+    /** Emits UI:{removeEvent} with { slotIndex } when an action is removed from a slot */
+    removeEvent?: EventEmit<{
+        slotIndex: number;
+    }>;
+    /** Emits UI:{checkEvent} with { sequence } when the player submits the sequence */
+    checkEvent?: EventEmit<{
+        sequence: string[];
+    }>;
+    /** Emits UI:{playAgainEvent} with {} on reset */
+    playAgainEvent?: EventEmit<Record<string, never>>;
+}
+export declare function SequencerBoard({ entity, categoryColors, stepDurationMs, playEvent, completeEvent, placeEvent, removeEvent, checkEvent, playAgainEvent, className, }: SequencerBoardProps): React.JSX.Element | null;
+export declare namespace SequencerBoard {
+    var displayName: string;
+}
+export default SequencerBoard;

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

@@ -0,0 +1,27 @@
+/**
+ * SimulationCanvas
+ *
+ * Pure renderer: paints the initial preset bodies and, when the `bodies` prop
+ * is provided, interpolates externally-driven snapshots to 60fps.
+ * Physics integration is owned by the LOLO animTick — this canvas does NOT
+ * self-advance positions.
+ */
+import React from 'react';
+import type { PhysicsPreset, PhysicsBody } from '../../shared/lib/physicsTypes';
+export type PhysicsPresetId = 'mechanics-projectile' | 'mechanics-pendulum' | 'mechanics-spring';
+export interface SimulationCanvasProps {
+    preset: PhysicsPresetId | PhysicsPreset;
+    width?: number;
+    height?: number;
+    running: boolean;
+    speed?: number;
+    /** External model-authoritative body snapshots (~30Hz). When provided,
+     *  the self-simulation loop is bypassed and positions are interpolated
+     *  to 60fps between consecutive snapshots. */
+    bodies?: readonly Pick<PhysicsBody, 'id' | 'x' | 'y'>[];
+    className?: string;
+}
+export declare function SimulationCanvas({ preset: presetProp, width, height, bodies: externalBodies, className, }: SimulationCanvasProps): React.JSX.Element;
+export declare namespace SimulationCanvas {
+    var displayName: string;
+}

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

@@ -0,0 +1,34 @@
+/**
+ * SimulationControls
+ *
+ * Play/pause/step/reset controls with speed and parameter sliders.
+ */
+import React from 'react';
+import type { Asset } from '@almadar/core';
+export interface SimulationParameter {
+    value: number;
+    min: number;
+    max: number;
+    step: number;
+    label: string;
+}
+export interface SimulationControlsProps {
+    running: boolean;
+    speed: number;
+    parameters: Record<string, SimulationParameter>;
+    onPlay: () => void;
+    onPause: () => void;
+    onStep: () => void;
+    onReset: () => void;
+    onSpeedChange: (speed: number) => void;
+    onParameterChange: (name: string, value: number) => void;
+    /** Optional per-semantic-key asset overrides for icons (play/pause/step/reset). */
+    assetManifest?: {
+        ui?: Record<string, Asset>;
+    };
+    className?: string;
+}
+export declare function SimulationControls({ running, speed, parameters, onPlay, onPause, onStep, onReset, onSpeedChange, onParameterChange, assetManifest, className, }: SimulationControlsProps): React.JSX.Element;
+export declare namespace SimulationControls {
+    var displayName: string;
+}

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

@@ -0,0 +1,25 @@
+/**
+ * SimulationGraph
+ *
+ * Real-time measurement graph for physics simulations.
+ * Renders measurement data as a simple line chart on canvas.
+ */
+import React from 'react';
+export interface MeasurementPoint {
+    time: number;
+    value: number;
+}
+export interface SimulationGraphProps {
+    label: string;
+    unit: string;
+    data: MeasurementPoint[];
+    maxPoints?: number;
+    width?: number;
+    height?: number;
+    color?: string;
+    className?: string;
+}
+export declare function SimulationGraph({ label, unit, data, maxPoints, width, height, color, className, }: SimulationGraphProps): React.JSX.Element;
+export declare namespace SimulationGraph {
+    var displayName: string;
+}

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

@@ -0,0 +1,58 @@
+/**
+ * SimulatorBoard
+ *
+ * Parameter-slider game board. The player adjusts two parameters (A and B)
+ * and observes the machine-derived output. Correct parameter values must
+ * bring the output within tolerance of the target to win.
+ *
+ * Good for: physics, economics, system design stories.
+ *
+ * Controlled-only: params, output, attempts, and result are owned by the
+ * gameplay machine and read off the bound entity. Slider/check/play-again
+ * interactions are emitted as events; the machine recomputes and re-renders.
+ */
+import React from 'react';
+import type { EventEmit, EntityRow, Asset } from '@almadar/core';
+import type { DisplayStateProps } from '../../../core/organisms/types';
+/** A tunable simulation parameter slider descriptor (UI value DTO read off the entity). */
+export interface SimulatorParameter {
+    id: string;
+    label: string;
+    unit: string;
+    min: number;
+    max: number;
+    step: number;
+    initial: number;
+    correct: number;
+    tolerance: number;
+}
+export interface SimulatorBoardProps extends DisplayStateProps {
+    /** Puzzle board-state entity (single row or array). The board reads the
+     *  `parameters` slider descriptors plus the machine-owned `paramA`/`paramB`/
+     *  `output`/`target`/`tolerance`/`attempts`/`result` fields off the row. */
+    entity?: EntityRow | readonly EntityRow[];
+    completeEvent?: EventEmit<{
+        success: boolean;
+        attempts: number;
+    }>;
+    /** Emits UI:{setAEvent} with { value } when parameter A's slider changes. */
+    setAEvent?: EventEmit<{
+        value: number;
+    }>;
+    /** Emits UI:{setBEvent} with { value } when parameter B's slider changes. */
+    setBEvent?: EventEmit<{
+        value: number;
+    }>;
+    /** Emits UI:{checkEvent} with {} on simulate / check. */
+    checkEvent?: EventEmit<Record<string, never>>;
+    /** Emits UI:{playAgainEvent} with {} on reset / play again. */
+    playAgainEvent?: EventEmit<Record<string, never>>;
+    /** Optional per-semantic-key asset overrides for icons (correct/incorrect/play/reset). */
+    assetManifest?: {
+        ui?: Record<string, Asset>;
+    };
+}
+export declare function SimulatorBoard({ entity, completeEvent, setAEvent, setBEvent, checkEvent, playAgainEvent, assetManifest, className, }: SimulatorBoardProps): React.JSX.Element | null;
+export declare namespace SimulatorBoard {
+    var displayName: string;
+}