@almadar/ui 5.79.1 → 5.80.0

package/dist/components/core/organisms/layout/DashboardGrid.d.ts

@@ -0,0 +1,33 @@
+/**
+ * DashboardGrid Component
+ *
+ * Multi-column grid for widgets and stats cards.
+ * Supports cell spanning for flexible dashboard layouts.
+ *
+ * Uses wireframe theme styling (high contrast, sharp edges).
+ */
+import React from "react";
+import type { DisplayStateProps } from "../types";
+export interface DashboardGridCell {
+    /** Optional unique cell ID */
+    id?: string;
+    /** Content to render in the cell */
+    content?: React.ReactNode;
+    /** Number of columns this cell spans (1-4) */
+    colSpan?: 1 | 2 | 3 | 4;
+    /** Number of rows this cell spans (1-2) */
+    rowSpan?: 1 | 2;
+}
+export interface DashboardGridProps extends DisplayStateProps {
+    /** Number of columns */
+    columns?: 2 | 3 | 4;
+    /** Gap between cells */
+    gap?: "sm" | "md" | "lg";
+    /** Cell definitions */
+    cells: DashboardGridCell[];
+}
+/**
+ * DashboardGrid - Multi-column widget grid
+ */
+export declare const DashboardGrid: React.FC<DashboardGridProps>;
+export default DashboardGrid;

package/dist/components/core/organisms/layout/MasterDetailLayout.d.ts

@@ -0,0 +1,32 @@
+/**
+ * MasterDetail Component
+ *
+ * Classic master-detail pattern with a list on the left
+ * and selected item detail on the right.
+ *
+ * Uses wireframe theme styling (high contrast, sharp edges).
+ */
+import React from "react";
+export interface MasterDetailLayoutProps {
+    /** Master panel content (usually a list) */
+    master: React.ReactNode;
+    /** Detail panel content */
+    detail: React.ReactNode;
+    /** Content shown when nothing is selected */
+    emptyDetail?: React.ReactNode;
+    /** Whether an item is currently selected */
+    hasSelection?: boolean;
+    /** Width of master panel (e.g., '350px', '30%') */
+    masterWidth?: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Class for master pane */
+    masterClassName?: string;
+    /** Class for detail pane */
+    detailClassName?: string;
+}
+/**
+ * MasterDetail - List + detail split layout
+ */
+export declare const MasterDetailLayout: React.FC<MasterDetailLayoutProps>;
+export default MasterDetailLayout;

package/dist/components/core/organisms/layout/SplitPane.d.ts

@@ -0,0 +1,34 @@
+/**
+ * SplitPane Component
+ *
+ * Two-pane resizable split layout for master-detail views,
+ * dual-pane editors, and code + preview layouts.
+ *
+ * Uses wireframe theme styling (high contrast, sharp edges).
+ */
+import React from "react";
+export interface SplitPaneProps {
+    /** Direction of the split */
+    direction?: "horizontal" | "vertical";
+    /** Initial ratio (0-100, percentage of first pane) */
+    ratio?: number;
+    /** Minimum size of either pane in pixels */
+    minSize?: number;
+    /** Allow user resizing */
+    resizable?: boolean;
+    /** Content for the left/top pane */
+    left: React.ReactNode;
+    /** Content for the right/bottom pane */
+    right: React.ReactNode;
+    /** Additional CSS classes */
+    className?: string;
+    /** Class for left/top pane */
+    leftClassName?: string;
+    /** Class for right/bottom pane */
+    rightClassName?: string;
+}
+/**
+ * SplitPane - Two-pane resizable layout
+ */
+export declare const SplitPane: React.FC<SplitPaneProps>;
+export default SplitPane;

package/dist/components/core/organisms/layout/TabbedContainer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * TabbedContainer Component
+ *
+ * Tabbed content areas with shared header/context.
+ * Wraps the Tabs molecule with layout-specific styling.
+ *
+ * Uses wireframe theme styling (high contrast, sharp edges).
+ */
+import React from "react";
+export interface TabDefinition {
+    /** Tab identifier */
+    id: string;
+    /** Tab label */
+    label: string;
+    /** Tab content (optional if using sectionId) */
+    content?: React.ReactNode;
+    /** Section ID to render (alternative to content) */
+    sectionId?: string;
+    /** Optional badge/count */
+    badge?: string | number;
+    /** Disable this tab */
+    disabled?: boolean;
+}
+export interface TabbedContainerProps {
+    /** Tab definitions */
+    tabs: TabDefinition[];
+    /** Default active tab ID */
+    defaultTab?: string;
+    /** Controlled active tab */
+    activeTab?: string;
+    /** Callback when tab changes */
+    onTabChange?: (tabId: string) => void;
+    /** Tab position */
+    position?: "top" | "left";
+    /** Additional CSS classes */
+    className?: string;
+}
+/**
+ * TabbedContainer - Tabbed content areas
+ */
+export declare const TabbedContainer: React.FC<TabbedContainerProps>;
+export default TabbedContainer;

package/dist/components/core/organisms/layout/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Layout organisms index
+ *
+ * Export layout pattern components for adaptive UI.
+ */
+export { SplitPane, type SplitPaneProps } from './SplitPane';
+export { MasterDetailLayout, type MasterDetailLayoutProps } from './MasterDetailLayout';
+export { DashboardGrid, type DashboardGridProps, type DashboardGridCell } from './DashboardGrid';
+export { TabbedContainer, type TabbedContainerProps, type TabDefinition } from './TabbedContainer';

package/dist/components/core/organisms/marketing-types.d.ts

@@ -0,0 +1,8 @@
+/**
+ * (stub) Marketing entity types removed in the entity-row clean slate.
+ *
+ * Marketing organisms now consume `@almadar/core`'s `EntityRow` directly and
+ * coerce concrete fields at the read site; templates declare their nested
+ * content shapes inline. No bespoke per-organism entity interfaces live here.
+ */
+export {};

package/dist/components/core/organisms/trace-edit-focus.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Edit Focus — the contextual-edit selection contract for the trace chat bar.
+ *
+ * A canvas element-pick emits `UI:ELEMENT_SELECTED` on the EventBus carrying an
+ * `EditFocus`. This module names that event and narrows the bus payload back
+ * into a typed `EditFocus` for `ChatBar`'s focus chip. It depends only on
+ * `@almadar/core` types; the DOM→focus build lives at the emitting canvas
+ * (`avl/derive-edit-focus`), not here.
+ */
+import type { EditFocus, EventPayloadValue } from '@almadar/core';
+/** The dedicated bus event a canvas element-pick emits. */
+export declare const ELEMENT_SELECTED_EVENT = "UI:ELEMENT_SELECTED";
+/** Narrow a `UI:ELEMENT_SELECTED` payload value back into an `EditFocus`. */
+export declare function parseEditFocus(value: EventPayloadValue | undefined): EditFocus | null;

package/dist/components/core/organisms/types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Shared types for entity-display organisms.
+ *
+ * All entity-display organisms (DataTable, List, Table, CardGrid, DetailPanel)
+ * extend EntityDisplayProps to guarantee a uniform prop contract.
+ *
+ * Exception: Form manages local `formData` state for field input tracking.
+ * This is the ONE allowed exception — documented here.
+ */
+import type { FieldValue } from '@almadar/core';
+import type { UiError } from '../atoms/types';
+export type { UiError };
+export declare const EntityDisplayEvents: {
+    readonly SORT: "SORT";
+    readonly PAGINATE: "PAGINATE";
+    readonly SEARCH: "SEARCH";
+    readonly FILTER: "FILTER";
+    readonly CLEAR_FILTERS: "CLEAR_FILTERS";
+    readonly SELECT: "SELECT";
+    readonly DESELECT: "DESELECT";
+};
+export interface SortPayload {
+    field: string;
+    direction: 'asc' | 'desc';
+}
+export interface PaginatePayload {
+    page: number;
+    pageSize?: number;
+}
+export interface SearchPayload {
+    query: string;
+}
+export interface FilterPayload {
+    field: string;
+    operator: string;
+    value: FieldValue;
+}
+export interface SelectPayload {
+    ids: (string | number)[];
+}
+/**
+ * Common non-entity display state shared by every display organism — loading,
+ * error, and the render-ui display hints (sort/search/pagination/selection).
+ * Carries NO entity data and NO generic. Components that show entity data add
+ * their own `entity?: EntityRow | readonly EntityRow[]` field directly (the one
+ * unified entity type from `@almadar/core`); components that only need the
+ * loading/hint surface just extend this.
+ */
+export interface DisplayStateProps {
+    /** Additional CSS classes */
+    className?: string;
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: UiError | null;
+    /** Current sort field */
+    sortBy?: string;
+    /** Current sort direction */
+    sortDirection?: 'asc' | 'desc';
+    /** Current search query value */
+    searchValue?: string;
+    /** Current page number (1-indexed) */
+    page?: number;
+    /** Number of items per page */
+    pageSize?: number;
+    /** Total number of items (for pagination display) */
+    totalCount?: number;
+    /** Active filters */
+    activeFilters?: Record<string, FieldValue>;
+    /** Currently selected item IDs */
+    selectedIds?: readonly (string | number)[];
+}

package/dist/components/core/templates/CounterTemplate.d.ts

@@ -0,0 +1,51 @@
+/**
+ * CounterTemplate
+ *
+ * A presentational template for counter/incrementer features.
+ * Supports increment, decrement, and reset operations.
+ */
+import React from "react";
+import type { EventKey } from "@almadar/core";
+import type { TemplateProps } from "./types";
+export type CounterSize = "sm" | "md" | "lg";
+export type CounterVariant = "minimal" | "standard" | "full";
+export interface CounterEntity {
+    /** Entity ID */
+    id: string;
+    /** Current count value */
+    count: number;
+    /** Whether decrement button is disabled */
+    decrementDisabled?: boolean;
+    /** Whether increment button is disabled */
+    incrementDisabled?: boolean;
+    /** Step label for decrement button (e.g. "-5") */
+    decrementLabel?: string;
+    /** Step label for increment button (e.g. "+5") */
+    incrementLabel?: string;
+    /** Formatted range text (e.g. "Range: 0 to 100") */
+    rangeText?: string;
+}
+export interface CounterTemplateProps extends TemplateProps<CounterEntity> {
+    /** Called when increment is clicked */
+    onIncrement?: () => void;
+    /** Called when decrement is clicked */
+    onDecrement?: () => void;
+    /** Called when reset is clicked */
+    onReset?: () => void;
+    /** Declarative event key — emits UI:{incrementEvent} via bus on increment */
+    incrementEvent?: EventKey;
+    /** Declarative event key — emits UI:{decrementEvent} via bus on decrement */
+    decrementEvent?: EventKey;
+    /** Declarative event key — emits UI:{resetEvent} via bus on reset */
+    resetEvent?: EventKey;
+    /** Title displayed above the counter */
+    title?: string;
+    /** Show reset button */
+    showReset?: boolean;
+    /** Counter display size */
+    size?: CounterSize;
+    /** Template variant */
+    variant?: CounterVariant;
+}
+export declare const CounterTemplate: React.FC<CounterTemplateProps>;
+export default CounterTemplate;

package/dist/components/core/templates/DashboardLayout.d.ts

@@ -0,0 +1,110 @@
+import React from "react";
+import type { IconInput } from "../atoms/Icon";
+import type { AssetUrl, EventEmit, EventKey } from "@almadar/core";
+export interface NavItem {
+    label: string;
+    href: string;
+    /** Lucide icon component or string icon name (resolved by @almadar/ui Icon) */
+    icon?: IconInput;
+    badge?: string | number;
+    children?: NavItem[];
+}
+export interface NotificationItem {
+    id: string;
+    /** Short label shown in the dropdown row. */
+    message: string;
+    /** Optional secondary text. */
+    description?: string;
+    /** Optional ISO timestamp string. */
+    createdAt?: string;
+    /** Optional flag — bell badge counts items where read !== true. */
+    read?: boolean;
+}
+/** A generic top-bar action button. Domain-agnostic — consumers wire any
+ *  combination (cart icon, profile, help, custom). Each entry renders as
+ *  an icon button between the search bar and the notifications bell;
+ *  click dispatches the configured event onto the bus. */
+export interface TopBarAction {
+    /** Lucide icon name or component. */
+    icon: IconInput;
+    /** Optional aria-label / tooltip. Falls back to `icon`. */
+    label?: string;
+    /** Bus event fired on click. Dispatched as `UI:{event}` with empty payload.
+     *  Typed as `EventKey` so the pattern-sync detector marks `topBarActions`
+     *  as `event-list` and the validator checks references against trait
+     *  emit/listen sets. */
+    event: EventKey;
+    /** Optional badge — number or string rendered in the corner of the icon. */
+    badge?: number | string;
+    /** Visual variant. Default `"default"`. */
+    variant?: "default" | "primary" | "danger";
+}
+export interface DashboardUser {
+    name: string;
+    email: string;
+    avatar?: AssetUrl;
+}
+export interface DashboardLayoutProps {
+    /** App name shown in sidebar */
+    appName?: string;
+    /** Logo component or URL */
+    logo?: React.ReactNode;
+    /** Navigation items. Apps that need a Settings page should add it
+     *  as a navItems entry, not depend on baked-in chrome. */
+    navItems?: NavItem[];
+    /** Current user info (optional - auto-populated from auth context if not provided) */
+    user?: DashboardUser;
+    /** Header actions (extra slots beyond bell/search/theme). */
+    headerActions?: React.ReactNode;
+    /** Show the top-bar search box. Default `false` — opt in by setting
+     *  `searchEvent` (any truthy value implies showSearch) or this flag. */
+    showSearch?: boolean;
+    /** Declarative search event — fires `UI:{searchEvent}` on the bus
+     *  when the user submits the search box (Enter key). Setting this
+     *  implies `showSearch=true`. Use `onSearchSubmit` for direct React
+     *  usage instead. */
+    searchEvent?: EventEmit<{
+        value: string;
+    }>;
+    /** React-side search submit callback. Used when the host wires the
+     *  layout directly (not via render-ui pattern resolution). */
+    onSearchSubmit?: (value: string) => void;
+    /** Generic top-bar action buttons rendered between the search bar and
+     *  the notifications bell. Each entry: `{icon, label?, event, badge?, variant?}`.
+     *  Domain-agnostic — consumers add a cart icon, profile button, help-bubble,
+     *  or any other top-bar action by appending entries. Empty array (default)
+     *  renders nothing. */
+    topBarActions?: TopBarAction[];
+    /** Notification list. Pass an empty array to show the bell with no
+     *  badge; omit / pass null to hide the bell entirely. */
+    notifications?: NotificationItem[] | null;
+    /** Declarative bell click event — fires `UI:{notificationClickEvent}`
+     *  on the bus with an empty payload when the user clicks the bell. */
+    notificationClickEvent?: EventEmit<Record<string, never>>;
+    /** React-side bell click callback. */
+    onNotificationClick?: () => void;
+    /** Show the theme toggle button in the header. Default `true` —
+     *  universally useful for a11y / dark mode. */
+    showThemeToggle?: boolean;
+    /** Custom sidebar footer (optional). When omitted, the sidebar has
+     *  no footer — apps that need Settings/etc. add them via navItems. */
+    sidebarFooter?: React.ReactNode;
+    /** Active path used to highlight the matching nav item. Falls back
+     *  to `useCurrentPagePath()` (set by `CurrentPagePathProvider`), then
+     *  to `useLocation().pathname`. Production deploys can omit it; the
+     *  studio preview passes the in-frame `?page=` value so highlighting
+     *  works inside the embedded playground where `pathname` would be
+     *  the studio route. */
+    currentPath?: string;
+    /** Callback when user clicks sign out (optional - uses auth context signOut if not provided) */
+    onSignOut?: () => void;
+    /** Layout mode. Default `"sidebar"`.
+     *  - `sidebar`: Left sidebar nav + top header (classic dashboard)
+     *  - `topnav`: Horizontal nav in header, no sidebar
+     *  - `bottomnav`: Bottom tab bar, no sidebar
+     *  - `minimal`: No nav chrome, content only */
+    layoutMode?: "sidebar" | "topnav" | "bottomnav" | "minimal";
+    /** Page content rendered inside the main area */
+    children?: React.ReactNode;
+}
+export declare const DashboardLayout: React.FC<DashboardLayoutProps>;

package/dist/components/core/templates/GenericAppTemplate.d.ts

@@ -0,0 +1,24 @@
+/**
+ * GenericAppTemplate
+ *
+ * A simple, generic template for any application.
+ * Includes a header with title and actions, and a main content area.
+ * **Atomic Design**: Composed using Box, Typography, and Button atoms.
+ */
+import React from "react";
+import type { TemplateProps } from "./types";
+export interface GenericAppTemplateProps extends TemplateProps {
+    /** Page title */
+    title: string;
+    /** Subtitle or description */
+    subtitle?: string;
+    /** Main content */
+    children: React.ReactNode;
+    /** Header actions (buttons, links) */
+    headerActions?: React.ReactNode;
+    /** Footer content */
+    footer?: React.ReactNode;
+    /** Additional class name */
+    className?: string;
+}
+export declare const GenericAppTemplate: React.FC<GenericAppTemplateProps>;

package/dist/components/core/templates/index.d.ts

@@ -0,0 +1,21 @@
+export type { TemplateProps } from './types';
+export { DashboardLayout, type DashboardLayoutProps, type NavItem } from './DashboardLayout';
+export { AuthLayout, type AuthLayoutProps } from '../../marketing/templates/AuthLayout';
+export { CounterTemplate, type CounterTemplateProps, type CounterSize, type CounterVariant } from './CounterTemplate';
+export { GameTemplate, type GameTemplateProps } from '../../game/2d/templates/GameTemplate';
+export { GenericAppTemplate, type GenericAppTemplateProps } from './GenericAppTemplate';
+export { GameShell, type GameShellProps } from '../../game/2d/templates/GameShell';
+export { BattleTemplate, type BattleTemplateProps, type BattlePhase, type BattleSlotContext, } from '../../game/2d/templates/BattleTemplate';
+export { CastleTemplate, type CastleTemplateProps, type CastleSlotContext, } from '../../game/2d/templates/CastleTemplate';
+export { WorldMapTemplate, type WorldMapTemplateProps, type WorldMapSlotContext, } from '../../game/2d/templates/WorldMapTemplate';
+export { PlatformerTemplate, type PlatformerTemplateProps, } from '../../game/2d/templates/PlatformerTemplate';
+export { TowerDefenseTemplate, type TowerDefenseTemplateProps, } from '../../game/2d/templates/TowerDefenseTemplate';
+export { RoguelikeTemplate, type RoguelikeTemplateProps, } from '../../game/2d/templates/RoguelikeTemplate';
+export { TopDownShooterTemplate, type TopDownShooterTemplateProps, } from '../../game/2d/templates/TopDownShooterTemplate';
+export { CityBuilderTemplate, type CityBuilderTemplateProps, } from '../../game/2d/templates/CityBuilderTemplate';
+export { VisualNovelTemplate, type VisualNovelTemplateProps, } from '../../game/2d/templates/VisualNovelTemplate';
+export { CardBattlerTemplate, type CardBattlerTemplateProps, } from '../../game/2d/templates/CardBattlerTemplate';
+export { LandingPageTemplate, type LandingPageTemplateProps, type LandingPageEntity, } from '../../marketing/templates/LandingPageTemplate';
+export { PricingPageTemplate, type PricingPageTemplateProps, type PricingPageEntity, } from '../../marketing/templates/PricingPageTemplate';
+export { FeatureDetailPageTemplate, type FeatureDetailPageTemplateProps, type FeatureDetailPageEntity, type FeatureDetailSection, } from '../../marketing/templates/FeatureDetailPageTemplate';
+export { AboutPageTemplate, type AboutPageTemplateProps, type AboutPageEntity, } from '../../marketing/templates/AboutPageTemplate';

package/dist/components/core/templates/types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Base template types for Almadar UI.
+ *
+ * All templates MUST extend `TemplateProps<E>` to enforce entity-only data flow
+ * and JSON round-trip compatibility with the flattener pipeline.
+ *
+ * The compiler passes `entity` as `E[]` (array from data store), so
+ * TemplateProps accepts the same union as EntityDisplayProps.
+ *
+ * @see docs/Almadar_Templates.md
+ */
+import type { EntityRow } from "@almadar/core";
+/** Base props for all templates — enforces entity-only data flow.
+ *
+ * The constraint is `{ id?: string }` (optional id) so the canonical
+ * `EntityRow` from `@almadar/core` — whose `id` is optional — satisfies it. */
+export interface TemplateProps<E extends {
+    id?: string;
+} = EntityRow> {
+    /**
+     * Entity data — single object or array (pre-resolved by the compiler
+     * from `@payload.data` on the calling trait). The legacy `string`
+     * entity-name branch was removed in V2 Phase 6 along with the
+     * EntityStore resolver.
+     *
+     * The inlet always also accepts the canonical `EntityRow` (and arrays of
+     * it), because the compiler binds the generic data-store row regardless of
+     * a template's curated read-shape `E`. A template that reads specific
+     * fields narrows `entity` to `E` internally (a valid union-narrow) — no
+     * `as unknown` cast and no per-template inlet widening required.
+     */
+    entity?: E | EntityRow | readonly (E | EntityRow)[];
+    /** External styling override */
+    className?: string;
+}

package/dist/components/game/2d/atoms/ActionButton.d.ts

@@ -0,0 +1,30 @@
+import { type IconInput } from '../../../core/atoms/Icon';
+import type { Asset, EventKey } from '@almadar/core';
+export interface ActionButtonProps {
+    /** Sprite asset — takes precedence over icon when provided */
+    assetUrl?: Asset;
+    /** Button label text */
+    label: string;
+    /** Icon displayed before the label */
+    icon?: IconInput;
+    /** Cooldown progress from 0 (ready) to 1 (full cooldown) */
+    cooldown?: number;
+    /** Whether the button is disabled */
+    disabled?: boolean;
+    /** Keyboard hotkey to display as a badge */
+    hotkey?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Visual variant */
+    variant?: 'primary' | 'secondary' | 'danger';
+    /** Click handler */
+    onClick?: () => void;
+    /** Declarative event name — emits UI:{action} via eventBus on click */
+    action?: EventKey;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function ActionButton({ assetUrl, label, icon, cooldown, disabled, hotkey, size, variant, onClick, action, className, }: ActionButtonProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ActionButton {
+    var displayName: string;
+}

package/dist/components/game/2d/atoms/ChoiceButton.d.ts

@@ -0,0 +1,26 @@
+import { type IconInput } from '../../../core/atoms/Icon';
+import type { Asset, EventKey } from '@almadar/core';
+export interface ChoiceButtonProps {
+    /** Choice text content */
+    text: string;
+    /** Choice index number (displayed as prefix) */
+    index?: number;
+    /** Sprite asset — takes precedence over icon when provided */
+    assetUrl?: Asset;
+    /** Icon displayed before the text */
+    icon?: IconInput;
+    /** Whether the choice is disabled */
+    disabled?: boolean;
+    /** Whether the choice is currently selected */
+    selected?: boolean;
+    /** Click handler */
+    onClick?: () => void;
+    /** Declarative event name — emits UI:{action} via eventBus on click */
+    action?: EventKey;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function ChoiceButton({ text, index, assetUrl, icon, disabled, selected, onClick, action, className, }: ChoiceButtonProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ChoiceButton {
+    var displayName: string;
+}

package/dist/components/game/2d/atoms/ComboCounter.d.ts

@@ -0,0 +1,19 @@
+import type { Asset } from '@almadar/core';
+export interface ComboCounterProps {
+    /** Sprite asset displayed alongside the combo number */
+    assetUrl?: Asset;
+    /** Current combo count */
+    combo: number;
+    /** Score multiplier */
+    multiplier?: number;
+    /** Current streak */
+    streak?: number;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function ComboCounter({ assetUrl, combo, multiplier, streak, size, className, }: ComboCounterProps): import("react/jsx-runtime").JSX.Element | null;
+export declare namespace ComboCounter {
+    var displayName: string;
+}

package/dist/components/game/2d/atoms/ControlButton.d.ts

@@ -0,0 +1,34 @@
+import type { EventKey, Asset } from "@almadar/core";
+import { type IconInput } from '../../../core/atoms/Icon';
+export interface ControlButtonProps {
+    /** Sprite asset — takes precedence over icon when provided */
+    assetUrl?: Asset;
+    /** Button label text */
+    label?: string;
+    /** Icon component or emoji */
+    icon?: IconInput;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg' | 'xl' | string;
+    /** Shape variant */
+    shape?: 'circle' | 'rounded' | 'square' | string;
+    /** Visual variant */
+    variant?: 'primary' | 'secondary' | 'ghost' | string;
+    /** Called when button is pressed */
+    onPress?: () => void;
+    /** Called when button is released */
+    onRelease?: () => void;
+    /** Declarative event name emitted on press via useEventBus */
+    pressEvent?: EventKey;
+    /** Declarative event name emitted on release via useEventBus */
+    releaseEvent?: EventKey;
+    /** Whether the button is currently pressed */
+    pressed?: boolean;
+    /** Whether the button is disabled */
+    disabled?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function ControlButton({ assetUrl, label, icon, size, shape, variant, onPress, onRelease, pressEvent, releaseEvent, pressed, disabled, className, }: ControlButtonProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ControlButton {
+    var displayName: string;
+}

package/dist/components/game/2d/atoms/DamageNumber.d.ts

@@ -0,0 +1,17 @@
+import type { Asset } from '@almadar/core';
+export interface DamageNumberProps {
+    /** Sprite asset — displayed as a hit-effect icon alongside the number */
+    assetUrl?: Asset;
+    /** The damage/heal value to display */
+    value: number;
+    /** Type of number display */
+    type?: 'damage' | 'heal' | 'crit' | 'miss';
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function DamageNumber({ assetUrl, value, type, size, className, }: DamageNumberProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace DamageNumber {
+    var displayName: string;
+}

package/dist/components/game/2d/atoms/DialogueBubble.d.ts

@@ -0,0 +1,17 @@
+import type { Asset } from '@almadar/core';
+export interface DialogueBubbleProps {
+    /** Speaker name displayed at the top */
+    speaker?: string;
+    /** Dialogue text content */
+    text: string;
+    /** Speaker portrait asset */
+    portrait?: Asset;
+    /** Position of the bubble on screen */
+    position?: 'top' | 'bottom';
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function DialogueBubble({ speaker, text, portrait, position, className, }: DialogueBubbleProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace DialogueBubble {
+    var displayName: string;
+}