@almadar/ui 5.86.0 → 5.89.0

package/dist/components/game/2d/molecules/StateGraph.d.ts

@@ -0,0 +1,38 @@
+/**
+ * StateGraph (molecule)
+ *
+ * Dumb visual renderer for a state-machine graph: lays states out on a circle,
+ * draws the player's transitions as SVG arrows, and emits a node-click event.
+ * All state (which transitions exist, the pending "from" selection, test results)
+ * lives in the .lolo FSM — this molecule only renders and reports clicks.
+ */
+import * as React from 'react';
+import type { EventKey } from '@almadar/core';
+export interface StateGraphTransition {
+    from: string;
+    to: string;
+    event: string;
+    guardHint?: string;
+}
+export interface StateGraphProps {
+    /** All states in the machine (node labels). */
+    states: string[];
+    /** Player-built transitions rendered as arrows. */
+    transitions?: StateGraphTransition[];
+    /** State highlighted as current (test playback / initial). */
+    currentState?: string;
+    /** State the player has selected (first click). */
+    selectedState?: string;
+    /** When set, the graph is in "pick a target" mode from this state. */
+    addingFrom?: string;
+    /** The machine's initial state (ring-marked). */
+    initialState?: string;
+    /** Graph canvas width. */
+    width?: number;
+    /** Graph canvas height. */
+    height?: number;
+    /** Emits UI:{nodeClickEvent} with { stateId } when a node is clicked. */
+    nodeClickEvent?: EventKey;
+    className?: string;
+}
+export declare function StateGraph({ states, transitions, currentState, selectedState, addingFrom, initialState, width, height, nodeClickEvent, className, }: StateGraphProps): React.JSX.Element;

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

@@ -32,29 +32,38 @@ export { InventoryGrid, type InventoryGridProps, type InventoryGridItem } from '
 export { ResourceBar, type ResourceBarProps, type ResourceBarResource } from './ResourceBar';
 export { GameHud, type GameHudProps, type GameHudStat, type GameHudElement } from './GameHud';
 export { GameMenu, type GameMenuProps, type MenuOption } from './GameMenu';
+export { StateGraph, type StateGraphProps, type StateGraphTransition } from './StateGraph';
 export { Canvas2D, type Canvas2DProps, type Projection, type CameraMode, type Platform, type SidePlayer, type TileCoord, } from './Canvas2D';
 export { useUnitSpriteAtlas } from '../../shared/hooks/useUnitSpriteAtlas';
 export { GameAudioProvider, GameAudioContext, useGameAudioContext, type GameAudioProviderProps, type GameAudioContextValue, } from '../../shared/providers/GameAudioProvider';
 export { GameAudioToggle, type GameAudioToggleProps, } from '../atoms/GameAudioToggle';
 export { useGameAudio, type AudioManifest, type SoundEntry, type GameAudioControls, type UseGameAudioOptions, } from '../../shared/hooks/useGameAudio';
 export { useCamera } from '../../shared/hooks/useCamera';
-export { TraitStateViewer, type TraitStateViewerProps, type TraitStateMachineDefinition, type TraitTransition, } from './TraitStateViewer';
-export { TraitSlot, type TraitSlotProps, type SlotItemData, } from './TraitSlot';
+export { TraitStateViewer, type TraitStateViewerProps, type TraitStateMachineDefinition, type TraitTransition, } from '../organisms/TraitStateViewer';
+export { TraitSlot, type TraitSlotProps, type SlotItemData, } from '../organisms/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 '../../shared/lib/editorUtils';
-export { ActionTile, type ActionTileProps } from './ActionTile';
-export { ActionPalette, type ActionPaletteProps } from './ActionPalette';
-export { SequenceBar, type SequenceBarProps } from './SequenceBar';
-export { RuleEditor, type RuleEditorProps, type RuleDefinition } from './RuleEditor';
-export { EventLog, type EventLogProps, type EventLogEntry } from './EventLog';
-export { ObjectRulePanel, type ObjectRulePanelProps } from './ObjectRulePanel';
+export { ActionTile, type ActionTileProps } from '../organisms/ActionTile';
+export { ActionPalette, type ActionPaletteProps } from '../organisms/ActionPalette';
+export { SequenceBar, type SequenceBarProps } from '../organisms/SequenceBar';
+export { SequencerBoard, type SequencerBoardProps } from '../organisms/SequencerBoard';
+export { RuleEditor, type RuleEditorProps, type RuleDefinition } from '../organisms/RuleEditor';
+export { EventLog, type EventLogProps, type EventLogEntry } from '../organisms/EventLog';
+export { ObjectRulePanel, type ObjectRulePanelProps } from '../organisms/ObjectRulePanel';
+export { EventHandlerBoard, type EventHandlerBoardProps } from '../organisms/EventHandlerBoard';
 export * from '../../shared/lib/puzzleObject';
-export { StateNode, type StateNodeProps } from './StateNode';
-export { TransitionArrow, type TransitionArrowProps } from './TransitionArrow';
-export { VariablePanel, type VariablePanelProps } from './VariablePanel';
-export { StateJsonView, type StateJsonViewProps } from './StateJsonView';
-export { SimulationCanvas, type SimulationCanvasProps } from './SimulationCanvas';
-export { SimulationControls, type SimulationControlsProps } from './SimulationControls';
-export { SimulationGraph, type SimulationGraphProps, type MeasurementPoint } from './SimulationGraph';
+export { StateNode, type StateNodeProps } from '../organisms/StateNode';
+export { TransitionArrow, type TransitionArrowProps } from '../organisms/TransitionArrow';
+export { VariablePanel, type VariablePanelProps } from '../organisms/VariablePanel';
+export { StateJsonView, type StateJsonViewProps } from '../organisms/StateJsonView';
+export { StateArchitectBoard, type StateArchitectBoardProps, type StateArchitectTransition, type TestCase, } from '../organisms/StateArchitectBoard';
+export { SimulatorBoard, type SimulatorBoardProps, type SimulatorParameter } from '../organisms/SimulatorBoard';
+export { ClassifierBoard, type ClassifierBoardProps, type ClassifierItem, type ClassifierCategory } from '../organisms/ClassifierBoard';
+export { BuilderBoard, type BuilderBoardProps, type BuilderComponent, type BuilderSlot } from '../organisms/BuilderBoard';
+export { DebuggerBoard, type DebuggerBoardProps, type DebuggerLine } from '../organisms/DebuggerBoard';
+export { NegotiatorBoard, type NegotiatorBoardProps, type NegotiatorAction, type PayoffEntry } from '../organisms/NegotiatorBoard';
+export { SimulationCanvas, type SimulationCanvasProps } from '../organisms/SimulationCanvas';
+export { SimulationControls, type SimulationControlsProps } from '../organisms/SimulationControls';
+export { SimulationGraph, type SimulationGraphProps, type MeasurementPoint } from '../organisms/SimulationGraph';
 export type { PhysicsPreset, PhysicsBody, PhysicsConstraint } from '../../shared/lib/physicsTypes';
 export { projectileMotion, pendulum, springOscillator, ALL_PRESETS } from '../../shared/lib/physicsPresets';
 export { GameTemplate, type GameTemplateProps } from '../templates/GameTemplate';

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

@@ -0,0 +1,60 @@
+/**
+ * BuilderBoard
+ *
+ * Component-snapping game board. The player places components
+ * onto slots in a blueprint. Correct placement completes the build.
+ *
+ * Good for: architecture, circuits, molecules, system design stories.
+ *
+ * Events emitted via completeEvent (default UI:PUZZLE_COMPLETE).
+ */
+import React from 'react';
+import type { AssetUrl, EventEmit, EntityRow, Asset } from '@almadar/core';
+import type { DisplayStateProps } from '../../../core/organisms/types';
+/** A draggable build component (UI value DTO read off the entity). */
+export interface BuilderComponent {
+    id: string;
+    label: string;
+    description?: string;
+    iconEmoji?: string;
+    /** Image URL icon (takes precedence over iconEmoji) */
+    iconUrl?: AssetUrl;
+    category?: string;
+}
+/** A blueprint slot accepting a component (UI value DTO read off the entity).
+ *  Mirrors the state machine's `BuilderBoardSlotsItem`: the required component
+ *  and the currently placed component both live on the entity. */
+export interface BuilderSlot {
+    id: string;
+    label?: string;
+    description?: string;
+    requiredComponentId: string;
+    placedComponentId?: string;
+}
+export interface BuilderBoardProps extends DisplayStateProps {
+    /** Puzzle board-state entity (single row or array). The board reads
+     *  `components` / `slots` arrays plus `attempts` / `result` off the row —
+     *  the state machine is the single source of truth for placements. */
+    entity?: EntityRow | readonly EntityRow[];
+    completeEvent?: EventEmit<{
+        success: boolean;
+        attempts: number;
+    }>;
+    /** Emits UI:{placeEvent} with { slotId, componentId } on component placement. */
+    placeEvent?: EventEmit<{
+        slotId: string;
+        componentId: string;
+    }>;
+    /** Emits UI:{checkEvent} with {} when the player checks the build. */
+    checkEvent?: 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/incorrect/reset/build). */
+    assetManifest?: {
+        ui?: Record<string, Asset>;
+    };
+}
+export declare function BuilderBoard({ entity, completeEvent, placeEvent, checkEvent, playAgainEvent, assetManifest, className, }: BuilderBoardProps): React.JSX.Element | null;
+export declare namespace BuilderBoard {
+    var displayName: string;
+}

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

@@ -0,0 +1,66 @@
+/**
+ * ClassifierBoard
+ *
+ * Drag-and-drop classification game. The player sorts items
+ * into the correct category buckets. All items must be correctly
+ * classified to win.
+ *
+ * Good for: taxonomy, pattern recognition, sorting stories.
+ *
+ * Gameplay events are emitted onto the bus so the bound Orbital trait
+ * (ui-classifier-board.lolo: menu -> playing -> complete) owns the state:
+ * assignEvent (ASSIGN), checkEvent (CHECK), playAgainEvent (PLAY_AGAIN),
+ * plus completeEvent (default UI:PUZZLE_COMPLETE). When the entity carries
+ * per-item `assignedCategory` / `result` / `attempts`, the board renders
+ * from those; otherwise it self-manages with local state.
+ */
+import React from 'react';
+import type { AssetUrl, EventEmit, EntityRow, Asset } from '@almadar/core';
+import type { DisplayStateProps } from '../../../core/organisms/types';
+/** A sortable item (UI value DTO read off the entity). */
+export interface ClassifierItem {
+    id: string;
+    label: string;
+    description?: string;
+    correctCategory: string;
+    /** Category the player has assigned (entity-provided; machine-owned). */
+    assignedCategory?: string;
+    /** Image URL icon for story-specific visual skin */
+    iconUrl?: AssetUrl;
+}
+/** A category bucket (UI value DTO read off the entity). */
+export interface ClassifierCategory {
+    id: string;
+    label: string;
+    color?: string;
+    /** Image URL for story-specific category header */
+    imageUrl?: AssetUrl;
+}
+export interface ClassifierBoardProps extends DisplayStateProps {
+    /** Puzzle board-state entity (single row or array). The board reads
+     *  `items` / `categories` arrays plus title/description/hint off the row.
+     *  Items may carry `assignedCategory`; the row may carry `result` and
+     *  `attempts` — all machine-owned. */
+    entity?: EntityRow | readonly EntityRow[];
+    completeEvent?: EventEmit<{
+        success: boolean;
+        attempts: number;
+    }>;
+    /** Emits UI:{assignEvent} with { itemId, categoryId } when an item is sorted. */
+    assignEvent?: EventEmit<{
+        itemId: string;
+        categoryId: string;
+    }>;
+    /** Emits UI:{checkEvent} with {} when the player submits/checks. */
+    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/reset/send). */
+    assetManifest?: {
+        ui?: Record<string, Asset>;
+    };
+}
+export declare function ClassifierBoard({ entity, completeEvent, assignEvent, checkEvent, playAgainEvent, assetManifest, className, }: ClassifierBoardProps): React.JSX.Element | null;
+export declare namespace ClassifierBoard {
+    var displayName: string;
+}

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

@@ -0,0 +1,61 @@
+/**
+ * DebuggerBoard
+ *
+ * Error-finding game board. The player reviews a code/system
+ * listing and identifies lines or elements that contain bugs.
+ *
+ * Good for: programming, logic, troubleshooting stories.
+ *
+ * Events emitted via completeEvent (default UI:PUZZLE_COMPLETE).
+ */
+import React from 'react';
+import type { EventEmit, EntityRow, EntityWith, Asset } from '@almadar/core';
+import type { DisplayStateProps } from '../../../core/organisms/types';
+/** A reviewable code line (UI value DTO read off the entity). */
+export interface DebuggerLine {
+    id: string;
+    content: string;
+    isBug: boolean;
+    isFlagged?: boolean;
+    explanation?: string;
+}
+export interface DebuggerBoardProps extends DisplayStateProps {
+    /** Puzzle board-state entity (single row or array). The board reads
+     *  `lines` array (each with `isFlagged`), `result`, `attempts`, plus
+     *  title/description/bugCount/hint off the row. */
+    entity?: EntityWith<{
+        lines?: DebuggerLine[];
+        result?: string;
+        attempts?: number;
+        title?: string;
+        description?: string;
+        bugCount?: number;
+        hint?: string;
+        headerImage?: string;
+        theme?: {
+            background?: string;
+            accentColor?: string;
+        };
+        successMessage?: string;
+    }> | readonly EntityRow[];
+    completeEvent?: EventEmit<{
+        success: boolean;
+        attempts: number;
+    }>;
+    /** Emits UI:{toggleFlagEvent} with { lineId } when a line's bug-flag is toggled. */
+    toggleFlagEvent?: EventEmit<{
+        lineId: string;
+    }>;
+    /** Emits UI:{checkEvent} with {} when the player checks/submits. */
+    checkEvent?: 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/incorrect/reset/bug/send). */
+    assetManifest?: {
+        ui?: Record<string, Asset>;
+    };
+}
+export declare function DebuggerBoard({ entity, completeEvent, toggleFlagEvent, checkEvent, playAgainEvent, assetManifest, className, }: DebuggerBoardProps): React.JSX.Element | null;
+export declare namespace DebuggerBoard {
+    var displayName: string;
+}

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

@@ -0,0 +1,42 @@
+/**
+ * EventHandlerBoard Organism
+ *
+ * Contains ALL game logic for the Event Handler tier (ages 9-12).
+ * Kids click on world objects, set WHEN/THEN rules, and watch
+ * event chains cascade during playback.
+ *
+ * Encourages experimentation: on failure, resets to editing so the kid
+ * can try different rules. After 3 failures, shows a progressive hint.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import type { EventEmit, EntityRow } from '@almadar/core';
+import type { DisplayStateProps } from '../../../core/organisms/types';
+import type { RuleDefinition } from './RuleEditor';
+export interface EventHandlerBoardProps extends DisplayStateProps {
+    /** Puzzle board-state entity (single row or array). The board reads
+     *  `objects` / `triggerEvents` / `goalEvent` etc. off the row; the editable
+     *  puzzle objects are themselves `EntityRow`s carried under `objects`. */
+    entity?: EntityRow | readonly EntityRow[];
+    /** Playback speed in ms per event */
+    stepDurationMs?: number;
+    /** Emits UI:{playEvent} */
+    playEvent?: EventEmit<Record<string, never>>;
+    /** Emits UI:{completeEvent} with { success } */
+    completeEvent?: EventEmit<{
+        success: boolean;
+    }>;
+    /** Emits UI:{editRuleEvent} with { objectId, rules } — model updates @entity.objects */
+    editRuleEvent?: EventEmit<{
+        objectId: string;
+        rules: RuleDefinition[];
+    }>;
+    /** Emits UI:{playAgainEvent} to reset the model */
+    playAgainEvent?: EventEmit<Record<string, never>>;
+}
+export declare function EventHandlerBoard({ entity, stepDurationMs, playEvent, completeEvent, editRuleEvent, playAgainEvent, className, }: EventHandlerBoardProps): React.JSX.Element | null;
+export declare namespace EventHandlerBoard {
+    var displayName: string;
+}
+export default EventHandlerBoard;

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/{molecules → organisms}/SequenceBar.d.ts

@@ -8,7 +8,6 @@
  * @packageDocumentation
  */
 import React from 'react';
-import type { EventKey } from '@almadar/core';
 import type { SlotItemData } from './TraitSlot';
 export interface SequenceBarProps {
     /** The current sequence (sparse — undefined means empty slot) */
@@ -16,13 +15,9 @@ export interface SequenceBarProps {
     /** Max number of slots */
     maxSlots: number;
     /** Called when an item is dropped into slot at index */
-    onSlotDrop?: (index: number, item: SlotItemData) => void;
+    onSlotDrop: (index: number, item: SlotItemData) => void;
     /** Called when a slot is cleared */
-    onSlotRemove?: (index: number) => void;
-    /** Declarative event — emits UI:{slotDropEvent} with { slotIndex, actionId } on drop */
-    slotDropEvent?: EventKey;
-    /** Declarative event — emits UI:{slotRemoveEvent} with { slotIndex } on clear */
-    slotRemoveEvent?: EventKey;
+    onSlotRemove: (index: number) => void;
     /** Whether the sequence is currently playing (disable interaction) */
     playing?: boolean;
     /** Current step index during playback (-1 = not playing) */
@@ -39,7 +34,7 @@ export interface SequenceBarProps {
     /** Additional CSS classes */
     className?: string;
 }
-export declare function SequenceBar({ slots, maxSlots, onSlotDrop, onSlotRemove, slotDropEvent, slotRemoveEvent, playing, currentStep, categoryColors, slotFeedback, size, className, }: SequenceBarProps): React.JSX.Element;
+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;
 }

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

@@ -0,0 +1,69 @@
+/**
+ * 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>>;
+    /** Emits UI:{stepEvent} with { step } during playback animation advancement */
+    stepEvent?: EventEmit<{
+        step: number;
+    }>;
+}
+export declare function SequencerBoard({ entity, categoryColors, stepDurationMs, playEvent, completeEvent, placeEvent, removeEvent, checkEvent, playAgainEvent, stepEvent, className, }: SequencerBoardProps): React.JSX.Element | null;
+export declare namespace SequencerBoard {
+    var displayName: string;
+}
+export default SequencerBoard;

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;
+}

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

@@ -0,0 +1,61 @@
+/**
+ * StateArchitectBoard Organism
+ *
+ * Contains ALL game logic for the State Architect tier (ages 13+).
+ * Kids design state machines via a visual graph editor, then run
+ * them to see if the behavior matches the puzzle goal.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import type { EventEmit, EntityRow } from '@almadar/core';
+import type { DisplayStateProps } from '../../../core/organisms/types';
+/** A kid-built transition in the visual graph editor (UI value DTO). */
+export interface StateArchitectTransition {
+    id: string;
+    from: string;
+    to: string;
+    event: string;
+    guardHint?: string;
+}
+/** A puzzle test case (UI value DTO). */
+export interface TestCase {
+    /** Sequence of events to fire */
+    events: string[];
+    /** Expected final state */
+    expectedState: string;
+    /** Description */
+    label: string;
+}
+export interface StateArchitectBoardProps extends DisplayStateProps {
+    /** Puzzle board-state entity (single row or array). The board reads
+     *  `variables` / `states` / `transitions` / `testCases` etc. off the row. */
+    entity?: EntityRow | readonly EntityRow[];
+    /** Playback speed */
+    stepDurationMs?: number;
+    /** Emits UI:{testEvent} */
+    testEvent?: EventEmit<Record<string, never>>;
+    /** Emits UI:{completeEvent} with { success, passedTests } */
+    completeEvent?: EventEmit<{
+        success: boolean;
+        passedTests: number;
+    }>;
+    /** Emits UI:{addTransitionEvent} — lolo handles ADD_TRANSITION */
+    addTransitionEvent?: EventEmit<{
+        id: string;
+        from: string;
+        to: string;
+        event: string;
+    }>;
+    /** Emits UI:{removeTransitionEvent} — lolo handles REMOVE_TRANSITION */
+    removeTransitionEvent?: EventEmit<{
+        id: string;
+    }>;
+    /** Emits UI:{playAgainEvent} — lolo handles PLAY_AGAIN */
+    playAgainEvent?: EventEmit<Record<string, never>>;
+}
+export declare function StateArchitectBoard({ entity, stepDurationMs, testEvent, completeEvent, addTransitionEvent, removeTransitionEvent, playAgainEvent, className, }: StateArchitectBoardProps): React.JSX.Element | null;
+export declare namespace StateArchitectBoard {
+    var displayName: string;
+}
+export default StateArchitectBoard;

package/dist/components/game/shared/lib/puzzleObject.d.ts

@@ -9,7 +9,7 @@
  * @packageDocumentation
  */
 import type { EntityWith } from '@almadar/core';
-import type { RuleDefinition, RuleOption } from '../../2d/molecules/RuleEditor';
+import type { RuleDefinition, RuleOption } from '../../2d/organisms/RuleEditor';
 type PuzzleObjectRow = EntityWith<{
     name?: string;
     icon?: string;