@almadar/ui 5.35.0 → 5.37.0

package/dist/components/game/organisms/puzzles/builder/BuilderBoard.d.ts

@@ -21,23 +21,36 @@ export interface BuilderComponent {
     iconUrl?: AssetUrl;
     category?: string;
 }
-/** A blueprint slot accepting a component (UI value DTO read off the entity). */
+/** 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;
+    label?: string;
     description?: string;
-    acceptsComponentId: 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 title/description/hint off the row. */
+     *  `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>>;
 }
-export declare function BuilderBoard({ entity, completeEvent, className, }: BuilderBoardProps): React.JSX.Element | null;
+export declare function BuilderBoard({ entity, completeEvent, placeEvent, checkEvent, playAgainEvent, className, }: BuilderBoardProps): React.JSX.Element | null;
 export declare namespace BuilderBoard {
     var displayName: string;
 }

package/dist/components/game/organisms/puzzles/classifier/ClassifierBoard.d.ts

@@ -7,7 +7,12 @@
  *
  * Good for: taxonomy, pattern recognition, sorting stories.
  *
- * Events emitted via completeEvent (default UI:PUZZLE_COMPLETE).
+ * 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 } from '@almadar/core';
@@ -18,6 +23,8 @@ export interface ClassifierItem {
     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;
 }
@@ -31,14 +38,25 @@ export interface ClassifierCategory {
 }
 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` / `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>>;
 }
-export declare function ClassifierBoard({ entity, completeEvent, className, }: ClassifierBoardProps): React.JSX.Element | null;
+export declare function ClassifierBoard({ entity, completeEvent, assignEvent, checkEvent, playAgainEvent, className, }: ClassifierBoardProps): React.JSX.Element | null;
 export declare namespace ClassifierBoard {
     var displayName: string;
 }

package/dist/components/game/organisms/puzzles/debugger/DebuggerBoard.d.ts

@@ -16,18 +16,28 @@ 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 plus title/description/bugCount/hint off the row. */
+     *  `lines` array (each with `isFlagged`), `result`, `attempts`, plus
+     *  title/description/bugCount/hint off the row. */
     entity?: EntityRow | 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>>;
 }
-export declare function DebuggerBoard({ entity, completeEvent, className, }: DebuggerBoardProps): React.JSX.Element | null;
+export declare function DebuggerBoard({ entity, completeEvent, toggleFlagEvent, checkEvent, playAgainEvent, className, }: DebuggerBoardProps): React.JSX.Element | null;
 export declare namespace DebuggerBoard {
     var displayName: string;
 }

package/dist/components/game/organisms/puzzles/negotiator/NegotiatorBoard.d.ts

@@ -28,15 +28,25 @@ export interface PayoffEntry {
 }
 export interface NegotiatorBoardProps extends DisplayStateProps {
     /** Puzzle board-state entity (single row or array). The board reads
-     *  `actions` / `payoffMatrix` arrays plus title/description/rounds/hint off
-     *  the row. */
+     *  `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>>;
 }
-export declare function NegotiatorBoard({ entity, completeEvent, className, }: NegotiatorBoardProps): React.JSX.Element | null;
+export declare function NegotiatorBoard({ entity, completeEvent, playRoundEvent, finishEvent, playAgainEvent, className, }: NegotiatorBoardProps): React.JSX.Element | null;
 export declare namespace NegotiatorBoard {
     var displayName: string;
 }

package/dist/components/game/organisms/puzzles/simulator/SimulatorBoard.d.ts

@@ -1,18 +1,20 @@
 /**
  * SimulatorBoard
  *
- * Parameter-slider game board. The player adjusts parameters
- * and observes real-time output. Correct parameter values
- * must bring the output within a target range to win.
+ * 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.
  *
- * Events emitted via completeEvent (default UI:PUZZLE_COMPLETE).
+ * 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 } from '@almadar/core';
 import type { DisplayStateProps } from '../../../../core/organisms/types';
-/** A tunable simulation parameter (UI value DTO read off the entity). */
+/** A tunable simulation parameter slider descriptor (UI value DTO read off the entity). */
 export interface SimulatorParameter {
     id: string;
     label: string;
@@ -26,14 +28,27 @@ export interface SimulatorParameter {
 }
 export interface SimulatorBoardProps extends DisplayStateProps {
     /** Puzzle board-state entity (single row or array). The board reads the
-     *  `parameters` array plus title/description/target/hint off the row. */
+     *  `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>>;
 }
-export declare function SimulatorBoard({ entity, completeEvent, className, }: SimulatorBoardProps): React.JSX.Element | null;
+export declare function SimulatorBoard({ entity, completeEvent, setAEvent, setBEvent, checkEvent, playAgainEvent, className, }: SimulatorBoardProps): React.JSX.Element | null;
 export declare namespace SimulatorBoard {
     var displayName: string;
 }