@almadar/ui 1.0.30 → 1.0.32

package/dist/components/index.d.ts

@@ -1,18 +1,20 @@
 import * as React$1 from 'react';
-import React__default from 'react';
+import React__default, { ReactNode, ErrorInfo } from 'react';
 import { LucideIcon } from 'lucide-react';
 import { SExpr } from '@almadar/evaluator';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-export { AuthContextValue, AuthUser, ChangeSummary, CompileResult, CompileStage, ENTITY_EVENTS, EntityDataAdapter, EntityDataProvider, EntityDataRecord, EntityMutationResult, Extension, ExtensionManifest, FileSystemFile, FileSystemStatus, GitHubRepo, GitHubStatus, HistoryTimelineItem, OpenFile, OrbitalEventPayload, OrbitalEventResponse, QuerySingletonEntity, QuerySingletonResult, QuerySingletonState, QueryState, RevertResult, SelectedFile, UseCompileResult, UseEntityDetailResult, UseEntityListOptions, UseEntityListResult, UseEntityMutationsOptions, UseExtensionsOptions, UseExtensionsResult, UseFileEditorOptions, UseFileEditorResult, UseFileSystemResult, UseOrbitalHistoryOptions, UseOrbitalHistoryResult, entityDataKeys, parseQueryBinding, useAgentChat, useAuthContext, useCompile, useConnectGitHub, useCreateEntity, useDeepAgentGeneration, useDeleteEntity, useDisconnectGitHub, useEmitEvent, useEntities, useEntitiesByType, useEntity, useEntityById, useEntityDataAdapter, useEntityDetail, useEntityList, useEntityMutations, useEventBus, useEventListener, useExtensions, useFileEditor, useFileSystem, useGitHubBranches, useGitHubRepo, useGitHubRepos, useGitHubStatus, useInput, useOrbitalHistory, useOrbitalMutations, usePhysics, usePlayer, usePreview, useQuerySingleton, useSelectedEntity, useSendOrbitalEvent, useSingletonEntity, useUIEvents, useUpdateEntity, useValidation } from '../hooks/index.js';
-import { E as EventBusContextType } from '../event-bus-types-8-cjyMxw.js';
-export { a as EventListener, K as KFlowEvent, U as Unsubscribe } from '../event-bus-types-8-cjyMxw.js';
-import { S as SlotContent, a as UISlot } from '../useUISlots-mnggE9X9.js';
-export { D as DEFAULT_SLOTS, R as RenderUIConfig, b as SlotAnimation, c as SlotChangeCallback, U as UISlotManager, u as useUISlotManager } from '../useUISlots-mnggE9X9.js';
-export { c as cn } from '../cn-mqkxz8Sd.js';
+import { b as DomLayoutData, d as DomStateNode, V as VisualizerConfig, e as DomTransitionLabel, C as ContentSegment } from '../cn-BoBXsxuX.js';
+export { h as cn } from '../cn-BoBXsxuX.js';
+import { I as IsometricTile, a as IsometricUnit, b as IsometricFeature, C as CameraState } from '../isometric-ynNHVPZx.js';
+export { AuthContextValue, AuthUser, ChangeSummary, CompileResult, CompileStage, ENTITY_EVENTS, EntityDataAdapter, EntityDataProvider, EntityDataRecord, EntityMutationResult, Extension, ExtensionManifest, FileSystemFile, FileSystemStatus, GitHubRepo, GitHubStatus, HistoryTimelineItem, I18nContextValue, I18nProvider, OpenFile, OrbitalEventPayload, OrbitalEventResponse, QuerySingletonEntity, QuerySingletonResult, QuerySingletonState, QueryState, ResolvedEntity, RevertResult, SelectedFile, TranslateFunction, UseCompileResult, UseEntityDetailResult, UseEntityListOptions, UseEntityListResult, UseEntityMutationsOptions, UseExtensionsOptions, UseExtensionsResult, UseFileEditorOptions, UseFileEditorResult, UseFileSystemResult, UseOrbitalHistoryOptions, UseOrbitalHistoryResult, createTranslate, entityDataKeys, parseQueryBinding, useAgentChat, useAuthContext, useCompile, useConnectGitHub, useCreateEntity, useDeepAgentGeneration, useDeleteEntity, useDisconnectGitHub, useEmitEvent, useEntities, useEntitiesByType, useEntity, useEntityById, useEntityDataAdapter, useEntityDetail, useEntityList, useEntityListSuspense, useEntityMutations, useEntitySuspense, useEventBus, useEventListener, useExtensions, useFileEditor, useFileSystem, useGitHubBranches, useGitHubRepo, useGitHubRepos, useGitHubStatus, useInput, useOrbitalHistory, useOrbitalMutations, usePhysics, usePlayer, usePreview, useQuerySingleton, useResolvedEntity, useSelectedEntity, useSendOrbitalEvent, useSingletonEntity, useTranslate, useUIEvents, useUpdateEntity, useValidation } from '../hooks/index.js';
+import { E as EventBusContextType } from '../event-bus-types-CjJduURa.js';
+export { a as EventListener, K as KFlowEvent, U as Unsubscribe } from '../event-bus-types-CjJduURa.js';
+import { S as SlotContent, a as UISlot } from '../useUISlots-D0mttBSP.js';
+export { D as DEFAULT_SLOTS, R as RenderUIConfig, b as SlotAnimation, c as SlotChangeCallback, U as UISlotManager, u as useUISlotManager } from '../useUISlots-D0mttBSP.js';
 export { Entity, clearEntities, getAllEntities, getByType, getEntity, getSingleton, removeEntity, spawnEntity, updateEntity, updateSingleton } from '../stores/index.js';
+import 'clsx';
 import '@almadar/core';
 import '@tanstack/react-query';
-import 'clsx';
 
 type ButtonVariant = "primary" | "secondary" | "ghost" | "danger" | "success" | "warning" | "default";
 type ButtonSize = "sm" | "md" | "lg";
@@ -895,11 +897,6 @@ declare namespace ControlButton {
     var displayName: string;
 }
 
-/**
- * Sprite Component
- *
- * Renders a single frame from a spritesheet with transform support.
- */
 interface SpriteProps {
     /** Spritesheet image URL */
     spritesheet: string;
@@ -957,6 +954,89 @@ declare function Sprite({ spritesheet, frameWidth, frameHeight, frame, x, y, sca
  */
 declare function drawSprite(ctx: CanvasRenderingContext2D, image: HTMLImageElement, props: Omit<SpriteProps, 'spritesheet' | 'className' | 'onClick'>): void;
 
+/**
+ * StateIndicator Component
+ *
+ * Displays a visual indicator for a game entity's current state.
+ * Generic — not tied to any specific game. Projects can extend
+ * the state styles via the `stateStyles` prop.
+ */
+interface StateStyle {
+    icon: string;
+    bgClass: string;
+}
+interface StateIndicatorProps {
+    /** The current state name */
+    state: string;
+    /** Optional label override (defaults to capitalized state name) */
+    label?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Whether to show pulse animation on non-idle states */
+    animated?: boolean;
+    /** Custom state styles to extend/override defaults */
+    stateStyles?: Record<string, StateStyle>;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare function StateIndicator({ state, label, size, animated, stateStyles, className, }: StateIndicatorProps): JSX.Element;
+declare namespace StateIndicator {
+    var displayName: string;
+}
+
+interface ErrorBoundaryProps {
+    /** Content to render when no error */
+    children: ReactNode;
+    /** Fallback UI when an error is caught — ReactNode or render function */
+    fallback?: ReactNode | ((error: Error, reset: () => void) => ReactNode);
+    /** Additional CSS classes for the wrapper */
+    className?: string;
+    /** Called when an error is caught (for logging/telemetry) */
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+}
+interface ErrorBoundaryState {
+    error: Error | null;
+}
+/**
+ * ErrorBoundary — catches React render errors in child components.
+ *
+ * Uses `getDerivedStateFromError` and `componentDidCatch` to capture errors
+ * and render a fallback UI. Supports both static ReactNode fallbacks and
+ * render-function fallbacks that receive the error and a reset function.
+ *
+ * @example
+ * ```tsx
+ * // Static fallback
+ * <ErrorBoundary fallback={<Alert variant="error">Something broke</Alert>}>
+ *   <MyComponent />
+ * </ErrorBoundary>
+ *
+ * // Render function fallback with reset
+ * <ErrorBoundary fallback={(error, reset) => (
+ *   <VStack>
+ *     <Typography>Error: {error.message}</Typography>
+ *     <Button onClick={reset}>Try Again</Button>
+ *   </VStack>
+ * )}>
+ *   <MyComponent />
+ * </ErrorBoundary>
+ *
+ * // Default fallback (uses ErrorState molecule)
+ * <ErrorBoundary>
+ *   <MyComponent />
+ * </ErrorBoundary>
+ * ```
+ */
+declare class ErrorBoundary extends React__default.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    static displayName: string;
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    private reset;
+    render(): ReactNode;
+    private renderFallback;
+}
+
 /**
  * FormField Molecule Component
  *
@@ -1018,6 +1098,41 @@ interface ErrorStateProps {
 }
 declare const ErrorState: React__default.FC<ErrorStateProps>;
 
+type SkeletonVariant = 'header' | 'table' | 'form' | 'card' | 'text';
+interface SkeletonProps {
+    /** The skeleton variant to render */
+    variant?: SkeletonVariant;
+    /** Number of rows for table/text variants */
+    rows?: number;
+    /** Number of columns for table variant */
+    columns?: number;
+    /** Number of fields for form variant */
+    fields?: number;
+    /** Additional CSS classes */
+    className?: string;
+}
+/**
+ * Skeleton — loading placeholder with 5 variants for Suspense fallbacks.
+ *
+ * Variants: `header`, `table`, `form`, `card`, `text`.
+ * Used as fallback content inside `<Suspense>` boundaries.
+ *
+ * @example
+ * ```tsx
+ * <Suspense fallback={<Skeleton variant="table" rows={8} columns={5} />}>
+ *   <DataTable entity="Task" />
+ * </Suspense>
+ *
+ * <Suspense fallback={<Skeleton variant="form" fields={6} />}>
+ *   <Form entity="Task" />
+ * </Suspense>
+ * ```
+ */
+declare function Skeleton({ variant, rows, columns, fields, className, }: SkeletonProps): React__default.ReactElement;
+declare namespace Skeleton {
+    var displayName: string;
+}
+
 /**
  * Accordion Molecule Component
  *
@@ -1320,6 +1435,9 @@ interface CardProps {
  * Card component for displaying content in a contained box
  */
 declare function Card({ title, subtitle, image, actions, children, onClick, className, action, }: CardProps): react_jsx_runtime.JSX.Element;
+declare namespace Card {
+    var displayName: string;
+}
 
 /**
  * Container Component
@@ -2146,6 +2264,100 @@ interface WizardNavigationProps {
  */
 declare const WizardNavigation: React__default.FC<WizardNavigationProps>;
 
+/**
+ * MarkdownContent Molecule Component
+ *
+ * Renders markdown content with support for GFM (GitHub Flavored Markdown)
+ * and math equations (KaTeX). Handles inline code only — fenced code blocks
+ * should be parsed out and rendered with CodeBlock component.
+ *
+ * Event Contract:
+ * - No events emitted (display-only component)
+ * - entityAware: false
+ *
+ * NOTE: react-markdown's `components` override API requires native HTML
+ * elements — this is the same library-boundary exception as `<iframe>` in
+ * DocumentViewer and `<svg>` in JazariStateMachine/StateMachineView.
+ */
+
+interface MarkdownContentProps {
+    /** The markdown content to render */
+    content: string;
+    /** Text direction */
+    direction?: 'rtl' | 'ltr';
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const MarkdownContent: React__default.NamedExoticComponent<MarkdownContentProps>;
+
+/**
+ * CodeBlock Molecule Component
+ *
+ * A syntax-highlighted code block with copy-to-clipboard functionality.
+ * Preserves scroll position during re-renders.
+ *
+ * Event Contract:
+ * - Emits: UI:COPY_CODE { language, success }
+ */
+
+interface CodeBlockProps {
+    /** The code content to display */
+    code: string;
+    /** Programming language for syntax highlighting */
+    language?: string;
+    /** Show the copy button */
+    showCopyButton?: boolean;
+    /** Show the language badge */
+    showLanguageBadge?: boolean;
+    /** Maximum height before scrolling */
+    maxHeight?: string;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const CodeBlock: React__default.NamedExoticComponent<CodeBlockProps>;
+
+/**
+ * QuizBlock Molecule Component
+ *
+ * A collapsible Q&A block for embedded quiz questions in content.
+ * Shows the question with a reveal button for the answer.
+ *
+ * Event Contract:
+ * - No events emitted (self-contained interaction)
+ * - entityAware: false
+ */
+
+interface QuizBlockProps {
+    /** The quiz question */
+    question: string;
+    /** The quiz answer (revealed on toggle) */
+    answer: string;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const QuizBlock: React__default.FC<QuizBlockProps>;
+
+/**
+ * ScaledDiagram Molecule
+ *
+ * Wraps a fixed-size diagram (like JazariStateMachine / StateMachineView)
+ * and CSS-scales it to fit the parent container width.
+ *
+ * The diagram renders at its natural (large) size. We observe the content
+ * element and once the diagram is measured we apply transform:scale() with
+ * a corrected container height so surrounding layout flows correctly.
+ *
+ * Event Contract:
+ * - No events emitted (layout-only wrapper)
+ * - entityAware: false
+ */
+
+interface ScaledDiagramProps {
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare const ScaledDiagram: React__default.FC<ScaledDiagramProps>;
+
 /**
  * RepeatableFormSection
  *
@@ -2286,6 +2498,72 @@ interface FormSectionHeaderProps {
 }
 declare const FormSectionHeader: React__default.FC<FormSectionHeaderProps>;
 
+/**
+ * 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.
+ */
+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";
+};
+interface SortPayload {
+    field: string;
+    direction: 'asc' | 'desc';
+}
+interface PaginatePayload {
+    page: number;
+    pageSize?: number;
+}
+interface SearchPayload {
+    query: string;
+}
+interface FilterPayload {
+    field: string;
+    operator: string;
+    value: unknown;
+}
+interface SelectPayload {
+    ids: (string | number)[];
+}
+interface EntityDisplayProps<T = unknown> {
+    /** Entity name for schema-driven integration */
+    entity?: string;
+    /** Data array provided by the trait via render-ui */
+    data?: readonly T[] | T[];
+    /** Additional CSS classes */
+    className?: string;
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | 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, unknown>;
+    /** Currently selected item IDs */
+    selectedIds?: readonly (string | number)[];
+}
+
 interface Column<T> {
     key: keyof T | string;
     header: string;
@@ -2299,70 +2577,35 @@ interface RowAction<T> {
     onClick: (row: T) => void;
     variant?: "default" | "danger";
     show?: (row: T) => boolean;
-    /** Event name for testability (data-event attribute) */
     event?: string;
 }
 interface DataTableProps<T extends {
     id: string | number;
-}> {
+}> extends EntityDisplayProps<T> {
     /** Fields to display - accepts string[] or Column[] for unified interface. Alias for columns */
     fields?: readonly Column<T>[] | readonly string[];
-    /** Columns can be Column objects or simple string field names - accepts readonly for generated const arrays */
+    /** Columns can be Column objects or simple string field names */
     columns?: readonly Column<T>[] | readonly string[];
-    /** Data array - primary prop for data. Accepts readonly or mutable arrays, and unknown for generated components */
-    data?: readonly T[] | T[] | readonly unknown[] | unknown[] | unknown;
-    /** Entity name for auto-fetch OR data array (backwards compatible) */
-    entity?: string | readonly T[] | T[];
     /** Item actions from generated code - maps to rowActions */
     itemActions?: readonly {
         label: string;
         event?: string;
-        /** Navigation URL - supports template interpolation like "/products/{{id}}" or "/products/:id" */
         navigatesTo?: string;
-        /** Action used by generated code - alternative to event */
         action?: string;
-        /** Placement accepts string for compatibility with generated code */
         placement?: "row" | "bulk" | string;
         icon?: LucideIcon;
-        /** Variant accepts all button variants for compatibility */
         variant?: "default" | "primary" | "secondary" | "ghost" | "danger" | string;
-        /** Click handler from generated code */
-        onClick?: (row: T) => void;
     }[];
-    /** Loading state indicator */
-    isLoading?: boolean;
-    /** Error state */
-    error?: Error | null;
     emptyIcon?: LucideIcon;
     emptyTitle?: string;
     emptyDescription?: string;
     emptyAction?: {
         label: string;
-        onClick: () => void;
+        event?: string;
     };
     selectable?: boolean;
-    selectedIds?: readonly (string | number)[];
-    onSelectionChange?: (ids: (string | number)[]) => void;
-    sortBy?: string;
-    sortDirection?: "asc" | "desc";
-    onSort?: (key: string, direction: "asc" | "desc") => void;
-    pagination?: {
-        page: number;
-        pageSize: number;
-        total: number;
-        onPageChange: (page: number) => void;
-        onPageSizeChange?: (size: number) => void;
-    };
-    enablePagination?: boolean;
-    /** Items per page for automatic pagination (default: 20) */
-    defaultPageSize?: number;
-    /** Show total count in pagination */
-    showTotal?: boolean;
     searchable?: boolean;
-    searchValue?: string;
-    onSearch?: (value: string) => void;
     searchPlaceholder?: string;
-    onRowClick?: (row: T) => void;
     rowActions?: readonly RowAction<T>[];
     bulkActions?: ReadonlyArray<{
         label: string;
@@ -2371,17 +2614,15 @@ interface DataTableProps<T extends {
         variant?: "default" | "danger";
     }>;
     headerActions?: React__default.ReactNode;
-    /**
-     * Query singleton binding for filter/sort state.
-     * When provided, syncs with the query singleton for filtering and sorting.
-     * Example: "@TaskQuery"
-     */
-    query?: string;
-    className?: string;
+    /** Show total count in pagination */
+    showTotal?: boolean;
 }
 declare function DataTable<T extends {
     id: string | number;
-}>({ fields, columns, data, entity, itemActions, isLoading, error: externalError, emptyIcon, emptyTitle, emptyDescription, emptyAction, selectable, selectedIds, onSelectionChange, sortBy: externalSortBy, sortDirection: externalSortDirection, onSort, pagination, enablePagination, defaultPageSize, showTotal, searchable, searchValue, onSearch, searchPlaceholder, onRowClick, rowActions: externalRowActions, bulkActions, headerActions, query, className, }: DataTableProps<T>): react_jsx_runtime.JSX.Element;
+}>({ fields, columns, data, entity, itemActions, isLoading, error, emptyIcon, emptyTitle, emptyDescription, emptyAction, selectable, selectedIds, sortBy, sortDirection, searchable, searchValue, searchPlaceholder, page, pageSize, totalCount, rowActions: externalRowActions, bulkActions, headerActions, showTotal, className, }: DataTableProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace DataTable {
+    var displayName: string;
+}
 
 /**
  * Schema metric definition
@@ -2488,6 +2729,10 @@ interface PageHeaderProps {
     actions?: readonly Readonly<SchemaAction>[];
     /** Loading state indicator */
     isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
     /** Tabs for sub-navigation */
     tabs?: ReadonlyArray<{
         label: string;
@@ -2507,8 +2752,8 @@ declare const PageHeader: React__default.FC<PageHeaderProps>;
  *
  * Composes atoms and molecules to create a professional detail view.
  *
- * When `entity` prop is provided without `data`, automatically fetches data
- * using the useEntityDetail hook with ID from URL params.
+ * Data is provided by the trait via the `data` prop (render-ui effect).
+ * See EntityDisplayProps in ./types.ts for base prop contract.
  */
 
 interface DetailField {
@@ -2542,7 +2787,7 @@ type FieldDef$2 = string | {
     key: string;
     header?: string;
 };
-interface DetailPanelProps {
+interface DetailPanelProps extends Omit<EntityDisplayProps<Record<string, unknown>>, 'data'> {
     title?: string;
     subtitle?: string;
     status?: {
@@ -2555,20 +2800,16 @@ interface DetailPanelProps {
     actions?: readonly DetailPanelAction[];
     footer?: React__default.ReactNode;
     slideOver?: boolean;
-    onClose?: () => void;
-    className?: string;
-    entity?: string;
     /** Fields to display - accepts string[], {key, header}[], or DetailField[] */
     fields?: readonly (FieldDef$2 | DetailField)[];
     /** Alias for fields - backwards compatibility */
     fieldNames?: readonly string[];
+    /** Data object provided by the trait via render-ui */
     data?: Record<string, unknown> | unknown;
     /** Initial data for edit mode (passed by compiler) */
     initialData?: Record<string, unknown> | unknown;
     /** Display mode (passed by compiler) */
     mode?: string;
-    isLoading?: boolean;
-    error?: Error | null;
     /** Panel position (for drawer/sidebar placement) */
     position?: "left" | "right";
     /** Panel width (CSS value, e.g., '400px', '50%') */
@@ -2592,6 +2833,12 @@ interface FormSectionProps {
     /** Grid columns for fields */
     columns?: 1 | 2 | 3;
     className?: string;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity name */
+    entity?: string;
 }
 declare const FormSection$1: React__default.FC<FormSectionProps>;
 /**
@@ -2602,6 +2849,12 @@ interface FormLayoutProps {
     /** Show section dividers */
     dividers?: boolean;
     className?: string;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity name */
+    entity?: string;
 }
 declare const FormLayout: React__default.FC<FormLayoutProps>;
 /**
@@ -2614,6 +2867,12 @@ interface FormActionsProps {
     /** Alignment */
     align?: "left" | "right" | "between" | "center";
     className?: string;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity name */
+    entity?: string;
 }
 declare const FormActions: React__default.FC<FormActionsProps>;
 
@@ -2730,13 +2989,18 @@ interface SchemaField {
     /** Whether field is disabled (alternative to readonly for compatibility) */
     disabled?: boolean;
 }
+/**
+ * Form is the ONE EXCEPTION to the "no internal state" rule for organisms.
+ * It manages local `formData` state for field input tracking.
+ * See EntityDisplayProps in ./types.ts for documentation.
+ */
 interface FormProps extends Omit<React__default.FormHTMLAttributes<HTMLFormElement>, "onSubmit"> {
     /** Form fields (traditional React children) */
     children?: React__default.ReactNode;
-    /** Submit handler - receives form data, or event name string for trait dispatch */
-    onSubmit?: ((e: React__default.FormEvent<HTMLFormElement>, data?: Record<string, unknown>) => void) | string;
-    /** Cancel handler - function or event name string for trait dispatch */
-    onCancel?: (() => void) | string;
+    /** Submit event name for trait dispatch (emitted via eventBus as UI:{onSubmit}) */
+    onSubmit?: string;
+    /** Cancel event name for trait dispatch (emitted via eventBus as UI:{onCancel}) */
+    onCancel?: string;
     /** Form layout */
     layout?: "vertical" | "horizontal" | "inline";
     /** Gap between fields */
@@ -2889,6 +3153,18 @@ interface HeaderProps {
      * Additional CSS classes
      */
     className?: string;
+    /**
+     * Loading state indicator (closed circuit)
+     */
+    isLoading?: boolean;
+    /**
+     * Error state (closed circuit)
+     */
+    error?: Error | null;
+    /**
+     * Entity name for schema-driven auto-fetch (closed circuit)
+     */
+    entity?: string;
 }
 declare const Header: React__default.FC<HeaderProps>;
 
@@ -2951,6 +3227,12 @@ interface NavigationProps {
      * Additional CSS classes
      */
     className?: string;
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
 }
 declare const Navigation: React__default.FC<NavigationProps>;
 
@@ -2986,6 +3268,12 @@ interface SectionProps {
     contentClassName?: string;
     /** HTML element to render as */
     as?: React__default.ElementType;
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
 }
 /**
  * Section - Semantic content grouping with header
@@ -3048,6 +3336,12 @@ interface SidebarProps {
     onLogoClick?: () => void;
     /** Additional CSS classes */
     className?: string;
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
 }
 declare const Sidebar: React__default.FC<SidebarProps>;
 
@@ -3081,13 +3375,19 @@ interface SplitProps {
     rightClassName?: string;
     /** Exactly two children: [left, right] */
     children: [React__default.ReactNode, React__default.ReactNode];
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
 }
 /**
  * Split - Two-column layout with flexible ratios
  */
 declare const Split: React__default.FC<SplitProps>;
 
-type SortDirection = "asc" | "desc" | null;
+type SortDirection = "asc" | "desc";
 interface TableColumn<T = any> {
     /**
      * Column key
@@ -3111,49 +3411,29 @@ interface TableColumn<T = any> {
      */
     width?: string;
 }
-interface TableProps<T = any> {
+interface TableProps<T = Record<string, unknown>> extends EntityDisplayProps<T> {
     /**
      * Table columns
      */
     columns: TableColumn<T>[];
-    /**
-     * Table entity data
-     */
-    entity: T[];
-    /**
-     * Row key getter
-     */
-    getRowKey: (row: T, index: number) => string;
     /**
      * Enable row selection
      * @default false
      */
     selectable?: boolean;
-    /**
-     * Selected row keys
-     */
-    selectedRows?: string[];
-    /**
-     * Callback when selection changes
-     */
-    onSelectionChange?: (selectedKeys: string[]) => void;
     /**
      * Enable sorting
      * @default false
      */
     sortable?: boolean;
     /**
-     * Current sort column
+     * Current sort column (display hint, mapped from sortBy)
      */
     sortColumn?: string;
     /**
-     * Current sort direction
+     * Current sort direction (display hint)
      */
     sortDirection?: SortDirection;
-    /**
-     * Callback when sort changes
-     */
-    onSortChange?: (column: string, direction: SortDirection) => void;
     /**
      * Enable search/filter
      * @default false
@@ -3169,17 +3449,13 @@ interface TableProps<T = any> {
      */
     paginated?: boolean;
     /**
-     * Current page
+     * Current page (display hint)
      */
     currentPage?: number;
     /**
-     * Total pages
+     * Total pages (display hint)
      */
     totalPages?: number;
-    /**
-     * Callback when page changes
-     */
-    onPageChange?: (page: number) => void;
     /**
      * Row actions menu items
      */
@@ -3193,13 +3469,9 @@ interface TableProps<T = any> {
      * @default false
      */
     loading?: boolean;
-    /**
-     * Additional CSS classes
-     */
-    className?: string;
 }
 declare const Table: {
-    <T extends Record<string, any>>({ columns, entity, getRowKey, selectable, selectedRows, onSelectionChange, sortable, sortColumn, sortDirection, onSortChange, searchable, searchPlaceholder, paginated, currentPage, totalPages, onPageChange, rowActions, emptyMessage, loading, className, }: TableProps<T>): react_jsx_runtime.JSX.Element;
+    <T extends Record<string, any>>({ columns, entity, data, className, isLoading, error, sortBy, sortDirection: entitySortDirection, searchValue, page, pageSize, totalCount, selectedIds, selectable, sortable, sortColumn: sortColumnProp, sortDirection: sortDirectionProp, searchable, searchPlaceholder, paginated, currentPage: currentPageProp, totalPages: totalPagesProp, rowActions, emptyMessage, loading, }: TableProps<T>): react_jsx_runtime.JSX.Element;
     displayName: string;
 };
 
@@ -3215,11 +3487,11 @@ declare const Table: {
  * - Delightful hover micro-interactions
  * - Elegant status indicators
  *
- * Orbital Component Interface Compliance:
- * - Entity binding with auto-fetch when entity is a string
- * - Event emission via useEventBus (UI:* events)
- * - Event listening for UI:SEARCH and UI:CLEAR_SEARCH
- * - isLoading and error state props
+ * Closed Circuit Compliance (Dumb Organism):
+ * - Receives ALL data via props (no internal fetch)
+ * - Emits events via useEventBus (UI:SELECT, UI:DESELECT, UI:VIEW)
+ * - Never listens to events — only emits
+ * - No internal search/filter state — trait provides filtered data
  */
 
 interface ListItem {
@@ -3259,55 +3531,33 @@ type FieldDef$1 = string | {
     key: string;
     header?: string;
 };
-interface ListProps {
-    /** Entity name for auto-fetch OR data array (backwards compatible) */
-    entity?: ListItem[] | readonly {
-        id: string;
-    }[] | readonly unknown[] | string;
-    /** Data array - primary prop for data */
-    data?: ListItem[] | readonly {
-        id: string;
-    }[] | readonly unknown[] | unknown;
+interface ListProps extends EntityDisplayProps {
     /** Entity type name for display */
     entityType?: string;
-    /** Loading state */
-    isLoading?: boolean;
-    /** Error state */
-    error?: Error | null;
     selectable?: boolean;
-    selectedItems?: readonly string[];
-    onSelectionChange?: (selectedIds: string[]) => void;
     /** Item actions - schema-driven or function-based */
     itemActions?: ((item: ListItem) => MenuItem[]) | readonly SchemaItemAction[];
     showDividers?: boolean;
     variant?: "default" | "card";
     emptyMessage?: string;
-    className?: string;
     renderItem?: (item: ListItem, index: number) => React__default.ReactNode;
     children?: React__default.ReactNode;
-    onItemAction?: (action: string, item: ListItem, index: number) => void;
-    onRowClick?: (item: ListItem) => void;
     /** Fields to display - accepts string[] or {key, header}[] for unified interface */
     fields?: readonly FieldDef$1[];
     /** Alias for fields - backwards compatibility */
     fieldNames?: readonly string[];
-    /**
-     * Query singleton binding for filter/sort state.
-     * When provided, syncs with the query singleton for filtering and sorting.
-     * Example: "@TaskQuery"
-     */
-    query?: string;
 }
 declare const List: React__default.FC<ListProps>;
 
 /**
  * CardGrid Component
  *
- * A responsive grid specifically designed for card layouts.
+ * A dumb, responsive grid specifically designed for card layouts.
  * Uses CSS Grid auto-fit for automatic responsive columns.
  *
- * When `entity` prop is provided without `data`, automatically fetches data
- * using the useEntityList hook. Supports server-side pagination and search.
+ * Data comes exclusively from the `data` prop (provided by the trait via render-ui).
+ * All user interactions emit events via useEventBus — never manages internal state
+ * for pagination, filtering, or search. All state is owned by the trait state machine.
  */
 
 type CardGridGap = 'none' | 'sm' | 'md' | 'lg' | 'xl';
@@ -3337,7 +3587,7 @@ type FieldDef = string | {
     key: string;
     header?: string;
 };
-interface CardGridProps {
+interface CardGridProps extends EntityDisplayProps {
     /** Minimum width of each card (default: 280px) */
     minCardWidth?: number;
     /** Maximum number of columns */
@@ -3346,45 +3596,18 @@ interface CardGridProps {
     gap?: CardGridGap;
     /** Align cards vertically in their cells */
     alignItems?: 'start' | 'center' | 'end' | 'stretch';
-    /** Custom class name */
-    className?: string;
     /** Children elements (cards) - optional when using entity/data props */
     children?: React__default.ReactNode;
-    /** Entity type for data-bound usage */
-    entity?: string;
     /** Fields to display - accepts string[] or {key, header}[] for unified interface */
     fields?: readonly FieldDef[];
     /** Alias for fields - backwards compatibility */
     fieldNames?: readonly string[];
     /** Alias for fields - backwards compatibility */
     columns?: readonly FieldDef[];
-    /** Data array for data-bound usage - accepts readonly for generated const arrays */
-    data?: readonly unknown[] | unknown;
-    /** Loading state indicator */
-    isLoading?: boolean;
-    /** Error state */
-    error?: Error | null;
     /** Actions for each card item (schema-driven) */
     itemActions?: readonly CardItemAction[];
-    /** Callback when a card is clicked */
-    onCardClick?: (item: unknown) => void;
-    /** Enable server-side pagination */
-    enablePagination?: boolean;
-    /** Items per page (default: 20) */
-    pageSize?: number;
     /** Show total count in pagination */
     showTotal?: boolean;
-    /** Filter configuration for entity data */
-    filter?: {
-        field: string;
-        value?: string;
-    };
-    /**
-     * Query singleton binding for filter/sort state.
-     * When provided, syncs with the query singleton for filtering and sorting.
-     * Example: "@TaskQuery"
-     */
-    query?: string;
 }
 /**
  * CardGrid - Responsive card collection layout
@@ -3393,7 +3616,8 @@ interface CardGridProps {
  * 1. With children: <CardGrid><Card>...</Card></CardGrid>
  * 2. With data: <CardGrid entity="Task" fieldNames={['title']} data={tasks} />
  *
- * Supports server-side pagination when enablePagination is true.
+ * All data comes from the `data` prop. Pagination display hints come from
+ * `page`, `pageSize`, and `totalCount` props (set by the trait via render-ui).
  */
 declare const CardGrid: React__default.FC<CardGridProps>;
 
@@ -3429,17 +3653,13 @@ interface MasterDetailProps<T extends {
     isLoading?: boolean;
     /** Error state */
     error?: Error | null;
-    /** Row click handler */
-    onRowClick?: (row: T) => void;
-    /** Selection change handler */
-    onSelectionChange?: (ids: (string | number)[]) => void;
     /** Additional class name */
     className?: string;
 }
 declare function MasterDetail<T extends {
     id: string | number;
 }>({ entity, masterFields, detailFields: _detailFields, // Captured but not used here - detail handled separately
-data: externalData, loading: externalLoading, isLoading: externalIsLoading, error: externalError, onRowClick, onSelectionChange, className, ...rest }: MasterDetailProps<T>): React__default.ReactElement;
+data: externalData, loading: externalLoading, isLoading: externalIsLoading, error: externalError, className, ...rest }: MasterDetailProps<T>): React__default.ReactElement;
 declare namespace MasterDetail {
     var displayName: string;
 }
@@ -3481,6 +3701,10 @@ interface ConfirmDialogProps {
     size?: ModalSize;
     /** Loading state for confirm button */
     isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
     /** Additional CSS classes */
     className?: string;
 }
@@ -3637,7 +3861,11 @@ interface WizardContainerProps {
     compact?: boolean;
     /** Additional CSS classes */
     className?: string;
-    /** Entity type name (schema-driven) */
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity type name (schema-driven) */
     entity?: string;
 }
 /**
@@ -3684,9 +3912,304 @@ interface OrbitalVisualizationProps {
     onClick?: () => void;
     /** Additional CSS classes */
     className?: string;
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
 }
 declare const OrbitalVisualization: React__default.FC<OrbitalVisualizationProps>;
 
+/**
+ * StateMachineView - Reusable State Machine Visualizer
+ *
+ * A hybrid DOM/SVG component for visualizing state machines.
+ * Uses SVG for arrow paths, DOM for tooltips.
+ *
+ * Moved from projects/builder to @almadar/ui for reuse across projects.
+ *
+ * BUNDLING: When multiple transitions exist between the same states (same direction),
+ * they are bundled into a single arrow with a badge showing the count.
+ * Hovering shows all events and their effects in a detailed tooltip.
+ *
+ * Events Emitted:
+ * - UI:STATE_CLICK - When a state node is clicked
+ * - UI:TRANSITION_CLICK - When a transition bundle is clicked
+ */
+
+/** Bundled transitions between same from→to states */
+interface TransitionBundle {
+    id: string;
+    from: string;
+    to: string;
+    labels: DomTransitionLabel[];
+    isBidirectional: boolean;
+    isReverse: boolean;
+}
+interface StateMachineViewProps extends EntityDisplayProps {
+    layoutData: DomLayoutData;
+    /** Custom state node renderer — when provided, replaces the default circle nodes */
+    renderStateNode?: (state: DomStateNode, config: VisualizerConfig) => React__default.ReactNode;
+}
+declare const StateMachineView: React__default.FC<StateMachineViewProps>;
+
+/**
+ * JazariStateMachine — Al-Jazari themed state machine diagram.
+ *
+ * Thin wrapper around StateMachineView that:
+ * 1. Extracts a state machine from an orbital schema (or accepts a trait directly)
+ * 2. Converts it to DomLayoutData via the visualizer lib
+ * 3. Applies Al-Jazari brass/gold/lapis color theme
+ * 4. Renders gear-shaped state nodes via the renderStateNode prop
+ */
+
+interface SmState {
+    name: string;
+    isInitial?: boolean;
+    isTerminal?: boolean;
+    isFinal?: boolean;
+}
+interface SmTransition {
+    from: string;
+    to: string;
+    event: string;
+    guard?: unknown;
+    effects?: unknown[];
+}
+interface SmStateMachine {
+    states: SmState[];
+    transitions: SmTransition[];
+}
+interface SmTrait {
+    name: string;
+    stateMachine?: SmStateMachine;
+    linkedEntity?: string;
+}
+interface SmEntity {
+    name: string;
+    fields?: Array<{
+        name: string;
+    }>;
+}
+interface SmOrbital {
+    entity?: SmEntity;
+    traits?: SmTrait[];
+}
+interface SmSchema {
+    orbitals?: SmOrbital[];
+}
+interface JazariStateMachineProps extends EntityDisplayProps {
+    /** Full schema — extracts first trait's state machine */
+    schema?: SmSchema;
+    /** Or pass a single trait directly */
+    trait?: SmTrait;
+    /** Which trait to visualize (default: 0) */
+    traitIndex?: number;
+    /** Override entity field labels */
+    entityFields?: string[];
+    /** Text direction (default: 'ltr') */
+    direction?: 'ltr' | 'rtl';
+}
+declare const JazariStateMachine: React__default.FC<JazariStateMachineProps>;
+
+/**
+ * ContentRenderer Organism
+ *
+ * Renders rich content as a sequence of typed segments: markdown, code,
+ * orbital diagrams (via JazariStateMachine), and quiz blocks. Accepts
+ * either raw content string (auto-parsed) or pre-parsed segments.
+ *
+ * Event Contract:
+ * - Delegates to child components (CodeBlock -> UI:COPY_CODE)
+ * - entityAware: false
+ */
+
+interface ContentRendererProps extends EntityDisplayProps {
+    /** Raw content string — auto-parsed into segments */
+    content?: string;
+    /** Pre-parsed segments (overrides content) */
+    segments?: ContentSegment[];
+    /** Text direction for markdown */
+    direction?: 'rtl' | 'ltr';
+}
+declare const ContentRenderer: React__default.FC<ContentRendererProps>;
+
+/**
+ * BookViewer shared types
+ *
+ * Field names are canonical English. When entity data arrives from a
+ * schema with non-English field names (e.g. Arabic .orb), a field map
+ * translates them before passing to BookViewer. See `mapBookData()`.
+ */
+interface BookData {
+    title: string;
+    subtitle?: string;
+    author?: string;
+    coverImageUrl?: string;
+    direction?: 'rtl' | 'ltr';
+    parts: BookPart[];
+}
+interface BookPart {
+    title: string;
+    chapters: BookChapter[];
+}
+interface BookChapter {
+    id: string;
+    title: string;
+    content: string;
+    orbitalSchema?: unknown;
+}
+/**
+ * Maps raw entity field names to canonical BookData field names.
+ * Each key is a canonical field, each value is the entity field name.
+ *
+ * @example
+ * ```ts
+ * // Arabic schema
+ * const AR_BOOK_FIELDS: BookFieldMap = {
+ *   title: 'العنوان',
+ *   subtitle: 'العنوان_الفرعي',
+ *   author: 'المؤلف',
+ *   coverImageUrl: 'صورة_الغلاف',
+ *   direction: 'الاتجاه',
+ *   parts: 'الأجزاء',
+ *   partTitle: 'العنوان',
+ *   chapters: 'الفصول',
+ *   chapterId: 'المعرف',
+ *   chapterTitle: 'العنوان',
+ *   chapterContent: 'المحتوى',
+ *   chapterOrbitalSchema: 'المخطط_المداري',
+ * };
+ * ```
+ */
+interface BookFieldMap {
+    title: string;
+    subtitle: string;
+    author: string;
+    coverImageUrl: string;
+    direction: string;
+    parts: string;
+    partTitle: string;
+    chapters: string;
+    chapterId: string;
+    chapterTitle: string;
+    chapterContent: string;
+    chapterOrbitalSchema: string;
+}
+/** Identity map — entity already uses canonical English field names */
+declare const IDENTITY_BOOK_FIELDS: BookFieldMap;
+/** Arabic field map for الأمة_الرقمية schema */
+declare const AR_BOOK_FIELDS: BookFieldMap;
+/**
+ * Resolves a fieldMap prop to a BookFieldMap object.
+ * Accepts a BookFieldMap object directly, a locale string key ("ar"),
+ * or undefined (defaults to identity/English).
+ */
+declare function resolveFieldMap(fieldMap: BookFieldMap | string | undefined): BookFieldMap;
+/**
+ * Maps a raw entity record to a typed BookData using a field map.
+ * Pass `IDENTITY_BOOK_FIELDS` for English schemas, `AR_BOOK_FIELDS` for Arabic, etc.
+ */
+declare function mapBookData(raw: Record<string, unknown>, fields?: BookFieldMap): BookData;
+
+/**
+ * BookViewer Organism
+ *
+ * Flippable book reader with cover, TOC, chapter views, and navigation.
+ * Supports RTL layout (Arabic), CSS slide transitions, and print mode.
+ *
+ * Page model:
+ *   0 = cover, 1 = TOC, 2+ = chapters (flattened from parts)
+ *
+ * Field mapping:
+ *   Entity data may use non-English field names (e.g. Arabic .orb schemas).
+ *   Pass a `fieldMap` prop to translate entity fields to canonical BookData.
+ *   Default: IDENTITY_BOOK_FIELDS (English field names, no translation).
+ *
+ * Event Contract:
+ * - Emits: UI:BOOK_PAGE_CHANGE { pageIndex, chapterId? }
+ * - Listens: UI:BOOK_START, UI:BOOK_NAVIGATE, UI:BOOK_PAGE_PREV/NEXT, UI:BOOK_PRINT, UI:BOOK_SHOW_TOC
+ */
+
+interface BookViewerProps extends EntityDisplayProps {
+    /** Initial page index (default: 0 = cover) */
+    initialPage?: number;
+    /** Field name translation map — a BookFieldMap object or locale key ("ar") */
+    fieldMap?: BookFieldMap | string;
+}
+declare const BookViewer: React__default.FC<BookViewerProps>;
+
+/**
+ * BookChapterView Organism
+ *
+ * Renders a single chapter: title + optional orbital diagram +
+ * rich content via ContentRenderer.
+ *
+ * Event Contract:
+ * - Delegates to ContentRenderer children
+ */
+
+interface BookChapterViewProps extends EntityDisplayProps {
+    chapter: BookChapter;
+    direction?: 'rtl' | 'ltr';
+}
+declare const BookChapterView: React__default.FC<BookChapterViewProps>;
+
+/**
+ * BookCoverPage Molecule
+ *
+ * Renders a book cover with title, subtitle, author, and optional image.
+ * Centered layout suitable for the first "page" of a BookViewer.
+ *
+ * Event Contract:
+ * - Emits: UI:BOOK_START
+ */
+
+interface BookCoverPageProps extends EntityDisplayProps {
+    title: string;
+    subtitle?: string;
+    author?: string;
+    coverImageUrl?: string;
+    direction?: 'rtl' | 'ltr';
+}
+declare const BookCoverPage: React__default.FC<BookCoverPageProps>;
+
+/**
+ * BookTableOfContents Molecule
+ *
+ * Renders a clickable table of contents grouped by parts.
+ * Highlights the current chapter.
+ *
+ * Event Contract:
+ * - Emits: UI:BOOK_NAVIGATE { chapterId }
+ */
+
+interface BookTableOfContentsProps extends EntityDisplayProps {
+    parts: BookPart[];
+    currentChapterId?: string;
+    direction?: 'rtl' | 'ltr';
+}
+declare const BookTableOfContents: React__default.FC<BookTableOfContentsProps>;
+
+/**
+ * BookNavBar Molecule
+ *
+ * Navigation bar for the BookViewer with prev/next, page indicator,
+ * print button, and TOC toggle.
+ *
+ * Event Contract:
+ * - Emits: UI:BOOK_PAGE_PREV, UI:BOOK_PAGE_NEXT, UI:BOOK_PRINT, UI:BOOK_SHOW_TOC
+ */
+
+interface BookNavBarProps extends EntityDisplayProps {
+    currentPage: number;
+    totalPages: number;
+    chapterTitle?: string;
+    direction?: 'rtl' | 'ltr';
+}
+declare const BookNavBar: React__default.FC<BookNavBarProps>;
+
 /**
  * SplitPane Component
  *
@@ -3797,116 +4320,6 @@ interface TabbedContainerProps {
  */
 declare const TabbedContainer: React__default.FC<TabbedContainerProps>;
 
-/**
- * Isometric Game Types
- *
- * Type definitions for isometric grid rendering: tiles, units, features.
- * Used by IsometricCanvas and game hooks.
- *
- * @packageDocumentation
- */
-/** A single isometric tile on the grid */
-interface IsometricTile {
-    /** Optional unique identifier (required for 3D rendering) */
-    id?: string;
-    /** Grid x coordinate */
-    x: number;
-    /** Grid y coordinate (2D) */
-    y: number;
-    /** Grid z coordinate (3D alternative to y) */
-    z?: number;
-    /** Terrain type key (e.g., 'grass', 'stone', 'water') - 2D */
-    terrain?: string;
-    /** Tile type for visual rendering (3D) */
-    type?: string;
-    /** Direct sprite URL override (bypasses getTerrainSprite resolver) */
-    terrainSprite?: string;
-    /** Whether units can traverse this tile (default true) */
-    passable?: boolean;
-    /** Movement cost for pathfinding (default 1) */
-    movementCost?: number;
-    /** Optional tile type for visual variants */
-    tileType?: string;
-    /** Elevation offset for 3D rendering */
-    elevation?: number;
-}
-/** A unit positioned on the isometric grid */
-interface IsometricUnit {
-    /** Unique unit identifier */
-    id: string;
-    /** Current grid position (2D format) */
-    position?: {
-        x: number;
-        y: number;
-    };
-    /** Grid x coordinate (3D format) */
-    x?: number;
-    /** Grid y coordinate (3D format) */
-    y?: number;
-    /** Grid z coordinate (3D format) */
-    z?: number;
-    /** Static sprite URL (used when no sprite sheet animation) */
-    sprite?: string;
-    /** Unit archetype key for sprite resolution */
-    unitType?: string;
-    /** Hero identifier for sprite sheet lookup */
-    heroId?: string;
-    /** Display name rendered below the unit */
-    name?: string;
-    /** Team affiliation for coloring */
-    team?: 'player' | 'enemy' | 'neutral';
-    /** Faction for 3D rendering (player/enemy/neutral) */
-    faction?: 'player' | 'enemy' | 'neutral';
-    /** Current health */
-    health?: number;
-    /** Maximum health */
-    maxHealth?: number;
-    /** Trait attachments for state display */
-    traits?: {
-        name: string;
-        currentState: string;
-        states: string[];
-        cooldown: number;
-    }[];
-    /** Previous position for movement trail ghost */
-    previousPosition?: {
-        x: number;
-        y: number;
-    };
-    /** Elevation offset for 3D rendering */
-    elevation?: number;
-}
-/** A map feature (resource, building, portal, etc.) */
-interface IsometricFeature {
-    /** Optional unique identifier (required for 3D rendering) */
-    id?: string;
-    /** Grid x coordinate */
-    x: number;
-    /** Grid y coordinate (2D) */
-    y: number;
-    /** Grid z coordinate (3D alternative to y) */
-    z?: number;
-    /** Feature type key (e.g., 'goldMine', 'castle', 'portal') */
-    type: string;
-    /** Direct sprite URL override (bypasses getFeatureSprite resolver) */
-    sprite?: string;
-    /** 3D model URL (GLB format) for GameCanvas3D */
-    assetUrl?: string;
-    /** Color override for 3D rendering */
-    color?: string;
-    /** Elevation offset for 3D rendering */
-    elevation?: number;
-}
-/** Camera state for pan/zoom */
-interface CameraState {
-    /** Camera X offset in pixels */
-    x: number;
-    /** Camera Y offset in pixels */
-    y: number;
-    /** Zoom level (1.0 = 100%) */
-    zoom: number;
-}
-
 /**
  * Sprite Sheet Animation Types
  *
@@ -3981,25 +4394,6 @@ interface SpriteSheetUrls {
     sw: string;
 }
 
-/**
- * IsometricCanvas
- *
- * Core isometric game renderer. Maps to the `game-canvas` pattern.
- * Adapted from projects/trait-wars/design-system/organisms/IsometricGameCanvas.tsx
- * with full closed-circuit pattern compliance (className, isLoading, error, entity).
- *
- * Architecture:
- * - 2:1 diamond isometric projection
- * - Painter's algorithm (tile → feature → unit depth sort)
- * - Camera pan/zoom with lerp
- * - Off-screen culling
- * - Minimap on separate canvas
- * - Sprite sheet animation via resolveUnitFrame
- * - Event bus–friendly handlers (onTileClick, onUnitClick, etc.)
- *
- * @packageDocumentation
- */
-
 interface IsometricCanvasProps {
     /** Additional CSS classes */
     className?: string;
@@ -4138,23 +4532,6 @@ interface EffectAssetManifest {
     };
 }
 
-/**
- * CanvasEffect Component
- *
- * Renders animated visual effects using a `<canvas>` element with
- * sprite-based particles, frame-sequence animations, and overlays.
- * This is a render-ui pattern that can be placed in any slot —
- * it renders on top of whatever occupies that slot.
- *
- * Pattern: canvas-effect
- *
- * When an EffectAssetManifest is provided (via assetManifest prop),
- * the component uses the full particle engine with tinted sprites.
- * Without a manifest, it falls back to emoji-based rendering.
- *
- * @packageDocumentation
- */
-
 interface CanvasEffectProps {
     /** The type of combat action to visualise */
     actionType: CombatActionType;
@@ -4194,15 +4571,117 @@ declare namespace CanvasEffect {
     var displayName: string;
 }
 
+interface SoundEntry {
+    /** Single path or array of paths — array picks randomly on each play */
+    path: string | string[];
+    /** Volume 0–1 (multiplied by masterVolume; default 1) */
+    volume?: number;
+    /** Whether this sound loops (background music) */
+    loop?: boolean;
+    /** Number of concurrent Audio instances in the pool (default 1) */
+    poolSize?: number;
+    /** Start automatically on first user interaction */
+    autostart?: boolean;
+    /** Use crossfade transitions when played via playMusic() */
+    crossfade?: boolean;
+    /** Crossfade duration in ms (default 1500) */
+    crossfadeDurationMs?: number;
+}
+type AudioManifest = Record<string, SoundEntry>;
+interface GameAudioControls {
+    /** Play a sound effect (instant, pooled) */
+    play: (key: string) => void;
+    /** Stop all instances of a sound effect */
+    stop: (key: string) => void;
+    /** Stop all sounds including music */
+    stopAll: () => void;
+    /** Crossfade to a new music track */
+    playMusic: (key: string) => void;
+    /** Fade out and stop the current music */
+    stopMusic: (fadeDurationMs?: number) => void;
+    muted: boolean;
+    setMuted: (muted: boolean) => void;
+    masterVolume: number;
+    setMasterVolume: (volume: number) => void;
+}
+interface UseGameAudioOptions {
+    /** Sound definitions keyed by logical name */
+    manifest: AudioManifest;
+    /** Prefix prepended to all `path` values (default '') */
+    baseUrl?: string;
+    /** Start muted (default false) */
+    initialMuted?: boolean;
+    /** Master volume 0–1 (default 1) */
+    initialVolume?: number;
+}
+declare function useGameAudio({ manifest, baseUrl, initialMuted, initialVolume, }: UseGameAudioOptions): GameAudioControls;
+declare namespace useGameAudio {
+    var displayName: string;
+}
+
 /**
- * useImageCache Hook
+ * GameAudioProvider
  *
- * Preloads and caches images by URL for canvas rendering.
- * Returns a getter function that returns loaded HTMLImageElement instances.
- * Tracks loading progress to support isLoading state.
+ * Context provider that wires the audio system to the Almadar event bus.
+ * Wrap your game organism with this provider, then emit:
+ *
+ *   emit('UI:PLAY_SOUND', { key: 'footstep' })
+ *
+ * from anywhere inside the tree and the corresponding sound will play.
+ *
+ * The provider also exposes `muted`/`setMuted` and `masterVolume`/
+ * `setMasterVolume` via the `GameAudioContext` for toggle buttons.
+ *
+ * Closed-circuit props (`className`, `isLoading`, `error`, `entity`) are
+ * accepted but intentionally unused — the provider renders only its children.
  *
  * @packageDocumentation
  */
+
+type GameAudioContextValue = Pick<GameAudioControls, 'muted' | 'setMuted' | 'masterVolume' | 'setMasterVolume' | 'play' | 'playMusic' | 'stopMusic'>;
+declare const GameAudioContext: React__default.Context<GameAudioContextValue | null>;
+/**
+ * Access the game audio context.
+ * Must be called from within a `<GameAudioProvider>` tree.
+ */
+declare function useGameAudioContext(): GameAudioContextValue;
+interface GameAudioProviderProps {
+    /** Sound manifest — keys mapped to SoundEntry definitions */
+    manifest: AudioManifest;
+    /** Base URL prepended to all sound paths (default '') */
+    baseUrl?: string;
+    /** Children to render */
+    children: React__default.ReactNode;
+    /** Initial muted state */
+    initialMuted?: boolean;
+    /** Closed-circuit props (unused, accepted for runtime compatibility) */
+    className?: string;
+    isLoading?: boolean;
+    error?: Error | null;
+    entity?: string;
+}
+declare function GameAudioProvider({ manifest, baseUrl, children, initialMuted, }: GameAudioProviderProps): JSX.Element;
+declare namespace GameAudioProvider {
+    var displayName: string;
+}
+
+interface GameAudioToggleProps {
+    /** Button size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Additional CSS classes */
+    className?: string;
+    /** Loading state (passed through) */
+    isLoading?: boolean;
+    /** Error state (passed through) */
+    error?: Error | null;
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
+}
+declare function GameAudioToggle({ size, className, }: GameAudioToggleProps): JSX.Element;
+declare namespace GameAudioToggle {
+    var displayName: string;
+}
+
 interface ImageCacheResult {
     /** Get a cached image by URL. Returns undefined if not yet loaded. */
     getImage: (url: string) => HTMLImageElement | undefined;
@@ -4219,15 +4698,6 @@ interface ImageCacheResult {
  */
 declare function useImageCache(urls: string[]): ImageCacheResult;
 
-/**
- * useCamera Hook
- *
- * Manages camera pan/zoom state for canvas rendering.
- * Provides mouse event handlers and coordinate conversion.
- *
- * @packageDocumentation
- */
-
 interface CameraResult {
     /** Mutable camera state ref (x, y, zoom) */
     cameraRef: React.MutableRefObject<CameraState>;
@@ -4268,19 +4738,6 @@ interface CameraResult {
  */
 declare function useCamera(): CameraResult;
 
-/**
- * useSpriteAnimations Hook
- *
- * Manages per-unit sprite sheet animation state for the canvas draw loop.
- * Follows the useCanvasEffects pattern: mutable state in refs, pure functions
- * in utils, no re-renders per frame.
- *
- * Project-agnostic: accepts generic sprite sheet resolution callbacks
- * rather than a project-specific asset manifest.
- *
- * @packageDocumentation
- */
-
 interface UseSpriteAnimationsResult {
     /**
      * Sync unit list and advance all animation timers.
@@ -4426,40 +4883,6 @@ declare class PhysicsManager {
     reset(): void;
 }
 
-/**
- * usePhysics2D Hook
- *
- * React hook for integrating 2D physics with the IsometricCanvas.
- * Provides physics state management and tick synchronization.
- *
- * @example
- * ```tsx
- * const { registerUnit, getPosition, applyForce, tick } = usePhysics2D({
- *   gravity: 0.5,
- *   groundY: 400
- * });
- *
- * // Register units
- * useEffect(() => {
- *   units.forEach(unit => {
- *     registerUnit(unit.id, { x: unit.x, y: unit.y, mass: 1 });
- *   });
- * }, [units]);
- *
- * // In animation loop
- * useEffect(() => {
- *   const animate = (timestamp) => {
- *     tick(16); // Run physics
- *     draw();   // Render
- *     requestAnimationFrame(animate);
- *   };
- *   requestAnimationFrame(animate);
- * }, []);
- * ```
- *
- * @packageDocumentation
- */
-
 interface UsePhysics2DOptions extends PhysicsConfig {
     /** Enable physics debug visualization */
     debug?: boolean;
@@ -4802,11 +5225,6 @@ declare namespace GameOverScreen {
     var displayName: string;
 }
 
-/**
- * InventoryPanel Component
- *
- * Grid-based inventory UI with item selection and tooltips.
- */
 interface InventoryItem {
     id: string;
     type: string;
@@ -4861,11 +5279,6 @@ interface InventoryPanelProps {
  */
 declare function InventoryPanel({ items, slots, columns, selectedSlot, onSelectSlot, onUseItem, onDropItem, selectSlotEvent, useItemEvent, dropItemEvent, showTooltips, className, slotSize, }: InventoryPanelProps): JSX.Element;
 
-/**
- * DialogueBox Component
- *
- * NPC dialogue display with typewriter effect and choices.
- */
 interface DialogueChoice {
     text: string;
     action?: string;
@@ -4928,13 +5341,19 @@ declare function DialogueBox({ dialogue, typewriterSpeed, position, onComplete,
 /**
  * BattleBoard
  *
- * Core game-logic organism extracted from BattleTemplate.
- * Handles turn-based phase management, movement animation, valid-move/attack-target
- * calculation, screen shake/flash, and game-over detection.
+ * Core rendering organism for turn-based battles.
+ *
+ * This is a **controlled-only** component: all game state (units, phase,
+ * turn, gameResult, selectedUnitId) must be provided via the `entity` prop.
+ * User interactions are communicated via event bus emissions so the parent
+ * (typically an Orbital trait or the `useBattleState` hook) can manage
+ * state transitions.
+ *
+ * For a self-managing version, use `UncontrolledBattleBoard` which
+ * composes this component with the `useBattleState` hook.
  *
- * Accepts a single `entity` prop (BattleEntity) containing all board data,
- * plus optional render-prop slots, callback overrides, and declarative event props
- * that emit via `useEventBus()`.
+ * Animation-only state (movement interpolation, screen shake, hover) is
+ * always managed locally.
  *
  * @packageDocumentation
  */
@@ -4972,10 +5391,20 @@ interface BattleTile {
     terrain: string;
     terrainSprite?: string;
 }
-/** Entity prop containing all board data */
+/** Entity prop containing all board data.
+ *
+ * BattleBoard is **controlled-only**: all game-state fields (`units`, `phase`,
+ * `turn`, `gameResult`, `selectedUnitId`) must be provided.  Mutations are
+ * communicated via event bus emissions — the component never calls `setState`
+ * for game-logic values.
+ *
+ * For a self-managing variant, use `UncontrolledBattleBoard`.
+ *
+ * Animation-only state (`movingPositions`, `isShaking`, `hoveredTile`) is
+ * always managed locally.
+ */
 interface BattleEntity {
     id: string;
-    initialUnits: BattleUnit[];
     tiles: IsometricTile[];
     features?: IsometricFeature[];
     boardWidth?: number;
@@ -4988,6 +5417,16 @@ interface BattleEntity {
         effects?: Record<string, string>;
     };
     backgroundImage?: string;
+    /** Current unit state. */
+    units: BattleUnit[];
+    /** Current battle phase. */
+    phase: BattlePhase;
+    /** Current turn number. */
+    turn: number;
+    /** Game result. `null` = still in progress. */
+    gameResult: 'victory' | 'defeat' | null;
+    /** Currently selected unit ID. */
+    selectedUnitId: string | null;
 }
 /** Context exposed to render-prop slots */
 interface BattleSlotContext {
@@ -5064,16 +5503,68 @@ declare namespace BattleBoard {
     var displayName: string;
 }
 
+interface UncontrolledBattleBoardProps extends Omit<BattleBoardProps, 'entity'> {
+    entity: Omit<BattleBoardProps['entity'], 'units' | 'phase' | 'turn' | 'gameResult' | 'selectedUnitId'> & {
+        initialUnits: BattleUnit[];
+    };
+}
+declare function UncontrolledBattleBoard({ entity, ...rest }: UncontrolledBattleBoardProps): react_jsx_runtime.JSX.Element;
+declare namespace UncontrolledBattleBoard {
+    var displayName: string;
+}
+
+interface BattleStateEventConfig {
+    tileClickEvent?: string;
+    unitClickEvent?: string;
+    endTurnEvent?: string;
+    cancelEvent?: string;
+    gameEndEvent?: string;
+    playAgainEvent?: string;
+    attackEvent?: string;
+}
+interface BattleStateCallbacks {
+    /** Called when a unit attacks another */
+    onAttack?: (attacker: BattleUnit, target: BattleUnit, damage: number) => void;
+    /** Called when battle ends */
+    onGameEnd?: (result: 'victory' | 'defeat') => void;
+    /** Called after a unit moves */
+    onUnitMove?: (unit: BattleUnit, to: {
+        x: number;
+        y: number;
+    }) => void;
+    /** Custom combat damage calculator */
+    calculateDamage?: (attacker: BattleUnit, target: BattleUnit) => number;
+}
+interface BattleStateResult {
+    units: BattleUnit[];
+    selectedUnitId: string | null;
+    phase: BattlePhase;
+    turn: number;
+    gameResult: 'victory' | 'defeat' | null;
+    handleTileClick: (x: number, y: number) => void;
+    handleUnitClick: (unitId: string) => void;
+    handleEndTurn: () => void;
+    handleRestart: () => void;
+}
+declare function useBattleState(initialUnits: BattleUnit[], eventConfig?: BattleStateEventConfig, callbacks?: BattleStateCallbacks): BattleStateResult;
+
 /**
  * WorldMapBoard
  *
- * Organism that contains ALL game logic for the strategic world-map view.
- * Renders an isometric hex/iso map with hero selection, movement animation,
- * and encounter callbacks. Game-specific panels (hero detail, hero lists,
- * resource bars) are injected via render-prop slots.
+ * Organism for the strategic world-map view.  Renders an isometric hex/iso
+ * map with hero selection, movement animation, and encounter callbacks.
+ * Game-specific panels (hero detail, hero lists, resource bars) are injected
+ * via render-prop slots.
+ *
+ * **State categories (closed-circuit compliant):**
+ * - Game data (hexes, heroes, selectedHeroId, features) → received via
+ *   `entity` prop; the Orbital trait owns this state.
+ * - Rendering state (hoveredTile, movingPositions animation) → local only.
+ * - Events → emitted via `useEventBus()` for trait integration.
  *
- * This component is the logic-heavy core; WorldMapTemplate is a thin layout
- * wrapper that delegates to WorldMapBoard.
+ * This component is mostly prop-driven.  The only internal state is hover
+ * tracking and movement animation interpolation, both of which are
+ * rendering-only concerns that cannot (and should not) be externalised.
  *
  * @packageDocumentation
  */
@@ -5147,6 +5638,10 @@ interface WorldMapEntity {
 interface WorldMapBoardProps {
     /** World map entity data */
     entity: WorldMapEntity;
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
     /** Canvas render scale */
     scale?: number;
     /** Unit draw-size multiplier */
@@ -5185,11 +5680,15 @@ interface WorldMapBoardProps {
     onBattleEncounter?: (attackerId: string, defenderId: string) => void;
     /** Called when hero enters a feature hex (castle, resource, etc.) */
     onFeatureEnter?: (heroId: string, hex: MapHex) => void;
+    /** Override for the diamond-top Y offset within tile sprites (default: 374). */
+    diamondTopY?: number;
+    /** Disable pan/zoom camera (default: true). Set false for fixed maps where overlay labels need stable positions. */
+    enableCamera?: boolean;
     effectSpriteUrls?: string[];
     resolveUnitFrame?: (unitId: string) => ResolvedFrame | null;
     className?: string;
 }
-declare function WorldMapBoard({ entity, scale, unitScale, allowMoveAllHeroes, isInRange, heroSelectEvent, heroMoveEvent, battleEncounterEvent, featureEnterEvent, tileClickEvent, header, sidePanel, overlay, footer, onHeroSelect, onHeroMove, onBattleEncounter, onFeatureEnter, effectSpriteUrls, resolveUnitFrame, className, }: WorldMapBoardProps): JSX.Element;
+declare function WorldMapBoard({ entity, scale, unitScale, allowMoveAllHeroes, isInRange, heroSelectEvent, heroMoveEvent, battleEncounterEvent, featureEnterEvent, tileClickEvent, header, sidePanel, overlay, footer, onHeroSelect, onHeroMove, onBattleEncounter, onFeatureEnter, diamondTopY, enableCamera, effectSpriteUrls, resolveUnitFrame, className, }: WorldMapBoardProps): JSX.Element;
 declare namespace WorldMapBoard {
     var displayName: string;
 }
@@ -5278,6 +5777,111 @@ declare namespace CastleBoard {
     var displayName: string;
 }
 
+interface TraitTransition {
+    from: string;
+    to: string;
+    event: string;
+    guardHint?: string;
+}
+interface TraitStateMachineDefinition {
+    name: string;
+    states: string[];
+    currentState: string;
+    transitions: TraitTransition[];
+    description?: string;
+}
+interface TraitStateViewerProps {
+    /** The trait / state machine to visualize */
+    trait: TraitStateMachineDefinition;
+    /** Display variant */
+    variant?: 'linear' | 'compact' | 'full';
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Whether to show transition labels */
+    showTransitions?: boolean;
+    /** Click handler for states */
+    onStateClick?: (state: string) => void;
+    /** Custom state styles passed to StateIndicator */
+    stateStyles?: Record<string, StateStyle>;
+    /** Additional CSS classes */
+    className?: string;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
+}
+declare function TraitStateViewer({ trait, variant, size, showTransitions, onStateClick, stateStyles, className, }: TraitStateViewerProps): JSX.Element;
+declare namespace TraitStateViewer {
+    var displayName: string;
+}
+
+/** Data shape for a slot's equipped item */
+interface SlotItemData {
+    id: string;
+    name: string;
+    category: string;
+    description?: string;
+    /** Emoji or text icon */
+    iconEmoji?: string;
+    /** Image URL icon (takes precedence over iconEmoji) */
+    iconUrl?: string;
+    /** Optional state machine for tooltip display */
+    stateMachine?: TraitStateMachineDefinition;
+}
+interface TraitSlotProps {
+    /** Slot index (1-based) */
+    slotNumber: number;
+    /** Currently equipped item, if any */
+    equippedItem?: SlotItemData;
+    /** Whether slot is locked */
+    locked?: boolean;
+    /** Label shown when locked */
+    lockLabel?: string;
+    /** Whether slot is selected */
+    selected?: boolean;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Show tooltip on hover */
+    showTooltip?: boolean;
+    /** Category → color mapping */
+    categoryColors?: Record<string, {
+        bg: string;
+        border: string;
+    }>;
+    /** Optional tooltip frame image URL */
+    tooltipFrameUrl?: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
+    /** Called when an item is dropped on this slot */
+    onItemDrop?: (item: SlotItemData) => void;
+    /** Whether this slot's equipped item is draggable */
+    draggable?: boolean;
+    /** Called when drag starts from this slot */
+    onDragStart?: (item: SlotItemData) => void;
+    /** Per-slot correctness feedback after a failed attempt */
+    feedback?: 'correct' | 'wrong' | null;
+    /** Click handler */
+    onClick?: () => void;
+    /** Remove handler */
+    onRemove?: () => void;
+    /** Emits UI:{clickEvent} with { slotNumber } */
+    clickEvent?: string;
+    /** Emits UI:{removeEvent} with { slotNumber } */
+    removeEvent?: string;
+}
+declare function TraitSlot({ slotNumber, equippedItem, locked, lockLabel, selected, size, showTooltip, categoryColors, tooltipFrameUrl, className, feedback, onItemDrop, draggable, onDragStart, onClick, onRemove, clickEvent, removeEvent, }: TraitSlotProps): JSX.Element;
+declare namespace TraitSlot {
+    var displayName: string;
+}
+
 type EditorMode = 'select' | 'paint' | 'unit' | 'feature' | 'erase';
 declare const TERRAIN_COLORS: Record<string, string>;
 declare const FEATURE_TYPES: readonly ["goldMine", "resonanceCrystal", "traitCache", "salvageYard", "portal", "battleMarker", "treasure", "castle"];
@@ -5392,12 +5996,21 @@ declare namespace EditorToolbar {
  * @packageDocumentation
  */
 
+interface SuspenseConfig {
+    /** Enable Suspense boundaries around slot content */
+    enabled: boolean;
+    /** Custom fallback per slot, overrides default Skeleton variant */
+    slotFallbacks?: Partial<Record<UISlot, React__default.ReactNode>>;
+}
 interface UISlotComponentProps {
     slot: UISlot;
     portal?: boolean;
     position?: "left" | "right" | "top-right" | "top-left" | "bottom-right" | "bottom-left";
     className?: string;
     draggable?: boolean;
+    isLoading?: boolean;
+    error?: Error | null;
+    entity?: string;
 }
 /**
  * Individual slot renderer.
@@ -5408,6 +6021,10 @@ declare function UISlotComponent({ slot, portal, position, className, }: UISlotC
 interface SlotContentRendererProps {
     content: SlotContent;
     onDismiss: () => void;
+    className?: string;
+    isLoading?: boolean;
+    error?: Error | null;
+    entity?: string;
 }
 /**
  * Renders the actual content of a slot.
@@ -5423,6 +6040,18 @@ interface UISlotRendererProps {
     includeFloating?: boolean;
     /** Additional class name for the container */
     className?: string;
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
+    /**
+     * Enable Suspense boundaries around each slot.
+     * When true, each inline slot is wrapped in `<ErrorBoundary><Suspense>` with
+     * Skeleton fallbacks. Opt-in — existing isLoading prop pattern still works.
+     */
+    suspense?: boolean | SuspenseConfig;
 }
 /**
  * Main UI Slot Renderer component.
@@ -5440,7 +6069,7 @@ interface UISlotRendererProps {
  * }
  * ```
  */
-declare function UISlotRenderer({ includeHud, includeFloating, className, }: UISlotRendererProps): React__default.ReactElement;
+declare function UISlotRenderer({ includeHud, includeFloating, className, suspense, }: UISlotRendererProps): React__default.ReactElement;
 declare namespace UISlotRenderer {
     var displayName: string;
 }
@@ -5466,6 +6095,12 @@ interface ModalSlotProps {
     size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
     /** Custom class name */
     className?: string;
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
 }
 /**
  * ModalSlot - Wrapper for modal slot content
@@ -5499,6 +6134,12 @@ interface DrawerSlotProps {
     size?: DrawerSize;
     /** Custom class name */
     className?: string;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
 }
 /**
  * DrawerSlot - Wrapper for drawer slot content
@@ -5531,6 +6172,12 @@ interface ToastSlotProps {
     duration?: number;
     /** Custom class name */
     className?: string;
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
 }
 /**
  * ToastSlot - Wrapper for toast slot content
@@ -6100,15 +6747,23 @@ declare const AuthLayout: React__default.FC<AuthLayoutProps>;
 
 type CounterSize = "sm" | "md" | "lg";
 type CounterVariant = "minimal" | "standard" | "full";
-interface CounterTemplateProps {
+interface CounterEntity {
+    /** Entity ID */
+    id: string;
     /** Current count value */
     count: number;
-    /** Minimum allowed value */
-    min?: number;
-    /** Maximum allowed value */
-    max?: number;
-    /** Step size for increment/decrement */
-    step?: 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;
+}
+interface CounterTemplateProps extends TemplateProps<CounterEntity> {
     /** Called when increment is clicked */
     onIncrement?: () => void;
     /** Called when decrement is clicked */
@@ -6123,266 +6778,9 @@ interface CounterTemplateProps {
     size?: CounterSize;
     /** Template variant */
     variant?: CounterVariant;
-    /** Additional class name */
-    className?: string;
 }
 declare const CounterTemplate: React__default.FC<CounterTemplateProps>;
 
-/**
- * ListTemplate
- *
- * A presentational template for list-based features like todos, shopping lists, notes.
- * Supports add, toggle, delete, and filter operations.
- */
-
-type FilterValue = "all" | "active" | "completed";
-type ListVariant = "minimal" | "standard" | "full";
-interface ListTemplateItem {
-    id: string;
-    title: string;
-    completed?: boolean;
-    [key: string]: unknown;
-}
-interface ListTemplateProps {
-    /** Array of list items */
-    items: ListTemplateItem[];
-    /** Whether data is loading */
-    isLoading?: boolean;
-    /** Error object if loading failed */
-    error?: Error | string | null;
-    /** Current filter value */
-    filter?: FilterValue;
-    /** Called when a new item is added */
-    onAdd?: (title: string) => void;
-    /** Called when an item is toggled */
-    onToggle?: (id: string) => void;
-    /** Called when an item is deleted */
-    onDelete?: (id: string) => void;
-    /** Called when filter changes */
-    onFilterChange?: (filter: FilterValue) => void;
-    /** Called to retry loading */
-    onRetry?: () => void;
-    /** Title displayed above the list */
-    title?: string;
-    /** Placeholder for the input field */
-    placeholder?: string;
-    /** Whether to show filter buttons */
-    showFilters?: boolean;
-    /** Whether to show item count */
-    showCount?: boolean;
-    /** Message shown when list is empty */
-    emptyMessage?: string;
-    /** Template variant */
-    variant?: ListVariant;
-    /** Additional class name */
-    className?: string;
-}
-declare const ListTemplate: React__default.FC<ListTemplateProps>;
-
-/**
- * FormTemplate
- *
- * A presentational template for form-based features like contact forms, feedback, surveys.
- * Supports submission, validation, and success/error states.
- */
-
-type FormVariant = "minimal" | "standard" | "full";
-interface FormFieldConfig {
-    name: string;
-    label: string;
-    type: "text" | "email" | "password" | "tel" | "url" | "number" | "textarea" | "select" | "checkbox";
-    placeholder?: string;
-    required?: boolean;
-    options?: Array<{
-        value: string;
-        label: string;
-    }>;
-    rows?: number;
-}
-interface FormTemplateProps {
-    /** Current form field values */
-    formData: Record<string, unknown>;
-    /** Whether form is being submitted */
-    isSubmitting?: boolean;
-    /** Whether submission was successful */
-    isSuccess?: boolean;
-    /** Error object if submission failed */
-    error?: Error | string | null;
-    /** Field-level validation errors */
-    validationErrors?: Record<string, string>;
-    /** Called when form is submitted */
-    onSubmit?: (formData: Record<string, unknown>) => void;
-    /** Called when a field value changes */
-    onFieldChange?: (field: string, value: unknown) => void;
-    /** Called to reset the form */
-    onReset?: () => void;
-    /** Called to dismiss success message */
-    onDismissSuccess?: () => void;
-    /** Form title */
-    title?: string;
-    /** Form subtitle/description */
-    subtitle?: string;
-    /** Submit button label */
-    submitLabel?: string;
-    /** Success message */
-    successMessage?: string;
-    /** Whether to show reset button */
-    showReset?: boolean;
-    /** Form field definitions */
-    fields?: FormFieldConfig[];
-    /** Template variant */
-    variant?: FormVariant;
-    /** Additional class name */
-    className?: string;
-}
-declare const FormTemplate: React__default.FC<FormTemplateProps>;
-
-/**
- * CrudTemplate
- *
- * A presentational template for CRUD (Create, Read, Update, Delete) features.
- * Includes data table, search, and modal forms for create/edit.
- */
-
-type CrudVariant = "minimal" | "standard" | "full";
-interface CrudItem {
-    id: string;
-    [key: string]: unknown;
-}
-interface ColumnConfig {
-    key: string;
-    label: string;
-    sortable?: boolean;
-    width?: string;
-    render?: (value: unknown, row: CrudItem) => React__default.ReactNode;
-}
-interface FieldConfig {
-    key: string;
-    label: string;
-    type?: "text" | "email" | "number" | "textarea" | "select";
-    required?: boolean;
-    placeholder?: string;
-    options?: Array<{
-        value: string;
-        label: string;
-    }>;
-}
-interface CrudTemplateProps {
-    /** Array of items to display */
-    items: CrudItem[];
-    /** Whether data is loading */
-    isLoading?: boolean;
-    /** Error object if loading failed */
-    error?: Error | string | null;
-    /** Currently selected item for editing */
-    selectedItem?: CrudItem | null;
-    /** Whether the create/edit modal is open */
-    isModalOpen?: boolean;
-    /** Current search query */
-    searchQuery?: string;
-    /** Current sort field */
-    sortBy?: string;
-    /** Current sort order */
-    sortOrder?: "asc" | "desc";
-    /** Called to load/refresh items */
-    onLoad?: () => void;
-    /** Called when creating a new item */
-    onCreate?: (data: Record<string, unknown>) => void;
-    /** Called when updating an item */
-    onUpdate?: (id: string, data: Record<string, unknown>) => void;
-    /** Called when deleting an item */
-    onDelete?: (id: string) => void;
-    /** Called when selecting an item for editing */
-    onSelect?: (id: string) => void;
-    /** Called when viewing an item */
-    onView?: (id: string) => void;
-    /** Called when search query changes */
-    onSearch?: (query: string) => void;
-    /** Called when sort changes */
-    onSort?: (field: string, order: "asc" | "desc") => void;
-    /** Called to open create/edit modal */
-    onOpenModal?: () => void;
-    /** Called to close modal */
-    onCloseModal?: () => void;
-    /** Page title */
-    title?: string;
-    /** Singular entity name for labels */
-    entityName?: string;
-    /** Table column definitions */
-    columns?: ColumnConfig[];
-    /** Form field definitions for create/edit */
-    fields?: FieldConfig[];
-    /** Whether to show search input */
-    showSearch?: boolean;
-    /** Search input placeholder */
-    searchPlaceholder?: string;
-    /** Whether to show view action */
-    showViewAction?: boolean;
-    /** Template variant */
-    variant?: CrudVariant;
-    /** Additional class name */
-    className?: string;
-}
-declare const CrudTemplate: React__default.FC<CrudTemplateProps>;
-
-/**
- * SettingsTemplate
- *
- * A presentational template for settings/preferences features.
- * Supports sections with various input types and save/reset operations.
- */
-
-type SettingsVariant = "minimal" | "standard" | "full";
-interface SettingsFieldConfig {
-    key: string;
-    label: string;
-    type: "text" | "email" | "number" | "select" | "toggle" | "checkbox";
-    description?: string;
-    placeholder?: string;
-    options?: string[] | Array<{
-        value: string;
-        label: string;
-    }>;
-}
-interface SettingsSectionConfig {
-    title: string;
-    description?: string;
-    fields: SettingsFieldConfig[];
-}
-interface SettingsTemplateProps {
-    /** Current settings values */
-    settings: Record<string, unknown>;
-    /** Whether settings are being saved */
-    isSaving?: boolean;
-    /** Whether there are unsaved changes */
-    hasChanges?: boolean;
-    /** Error object if save failed */
-    error?: Error | string | null;
-    /** Success message after save */
-    successMessage?: string | null;
-    /** Called when saving settings */
-    onSave?: (settings: Record<string, unknown>) => void;
-    /** Called when a setting value changes */
-    onChange?: (key: string, value: unknown) => void;
-    /** Called to reset to default settings */
-    onReset?: () => void;
-    /** Called to revert unsaved changes */
-    onRevert?: () => void;
-    /** Called to dismiss success message */
-    onDismissSuccess?: () => void;
-    /** Page title */
-    title?: string;
-    /** Settings sections */
-    sections?: SettingsSectionConfig[];
-    /** Whether to show reset to defaults button */
-    showResetToDefaults?: boolean;
-    /** Template variant */
-    variant?: SettingsVariant;
-    /** Additional class name */
-    className?: string;
-}
-declare const SettingsTemplate: React__default.FC<SettingsTemplateProps>;
-
 /**
  * GameTemplate
  *
@@ -6391,7 +6789,11 @@ declare const SettingsTemplate: React__default.FC<SettingsTemplateProps>;
  * **Atomic Design**: Composed using Box, Typography, and Layout molecules/atoms.
  */
 
-interface GameTemplateProps {
+interface GameEntity {
+    id: string;
+    title?: string;
+}
+interface GameTemplateProps extends TemplateProps<GameEntity> {
     /** Title of the game */
     title?: string;
     /** The main game canvas or content */
@@ -6422,7 +6824,12 @@ declare const GameTemplate: React__default.FC<GameTemplateProps>;
  * **Atomic Design**: Composed using Box, Typography, and Button atoms.
  */
 
-interface GenericAppTemplateProps {
+interface GenericAppEntity {
+    id: string;
+    title?: string;
+    subtitle?: string;
+}
+interface GenericAppTemplateProps extends TemplateProps<GenericAppEntity> {
     /** Page title */
     title: string;
     /** Subtitle or description */
@@ -6530,12 +6937,14 @@ interface WorldMapTemplateProps extends TemplateProps<WorldMapEntity> {
     scale?: number;
     /** Unit draw-size multiplier */
     unitScale?: number;
+    /** Override for the diamond-top Y offset within tile sprites (default: 374). */
+    diamondTopY?: number;
     /** Allow selecting / moving ALL heroes (including enemy). For testing. */
     allowMoveAllHeroes?: boolean;
 }
-declare function WorldMapTemplate({ entity, scale, unitScale, allowMoveAllHeroes, className, }: WorldMapTemplateProps): JSX.Element;
+declare function WorldMapTemplate({ entity, scale, unitScale, diamondTopY, allowMoveAllHeroes, className, }: WorldMapTemplateProps): JSX.Element;
 declare namespace WorldMapTemplate {
     var displayName: string;
 }
 
-export { Accordion, type AccordionItem, type AccordionProps, Card as ActionCard, type CardProps as ActionCardProps, Alert, type AlertProps, type AlertVariant, type AnimationDef, type AnimationName, AuthLayout, type AuthLayoutProps, Avatar, type AvatarProps, type AvatarSize, type AvatarStatus, Badge, type BadgeProps, type BadgeVariant, BattleBoard, type BattleBoardProps, type BattleEntity, type BattlePhase, type BattleSlotContext, BattleTemplate, type BattleTemplateProps, type BattleTile, type BattleUnit, Box, type BoxBg, type BoxMargin, type BoxPadding, type BoxProps, type BoxRounded, type BoxShadow, Breadcrumb, type BreadcrumbItem, type BreadcrumbProps, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, type CameraState, CanvasEffect, type CanvasEffectProps, Card$1 as Card, type CardAction, CardBody, CardContent, CardFooter, CardGrid, type CardGridGap, type CardGridProps, CardHeader, type CardProps$1 as CardProps, CardTitle, CastleBoard, type CastleBoardProps, type CastleEntity, type CastleSlotContext, CastleTemplate, type CastleTemplateProps, Center, type CenterProps, Chart, type ChartDataPoint, type ChartProps, type ChartSeries, type ChartType, Checkbox, type CheckboxProps, CodeViewer, type CodeViewerMode, type CodeViewerProps, CollapsibleSection, type CollapsibleSectionProps, type Column, type ColumnConfig, type CombatActionType, type ConditionalContext, ConditionalWrapper, type ConditionalWrapperProps, ConfirmDialog, type ConfirmDialogProps, type ConfirmDialogVariant, Container, type ContainerProps, ControlButton, type ControlButtonProps, type CounterSize, CounterTemplate, type CounterTemplateProps, type CounterVariant, type CrudItem, CrudTemplate, type CrudTemplateProps, type CrudVariant, DIAMOND_TOP_Y, DashboardGrid, type DashboardGridCell, type DashboardGridProps, DashboardLayout, type DashboardLayoutProps, DataTable, type DataTableProps, type DetailField, DetailPanel, type DetailPanelProps, type DetailSection, DialogueBox, type DialogueBoxProps, type DialogueChoice, type DialogueNode, type DiffLine, Divider, type DividerOrientation, type DividerProps, type DocumentType, DocumentViewer, type DocumentViewerProps, Drawer, type DrawerPosition, type DrawerProps, type DrawerSize, DrawerSlot, type DrawerSlotProps, EditorCheckbox, type EditorCheckboxProps, type EditorMode, EditorSelect, type EditorSelectProps, EditorSlider, type EditorSliderProps, EditorTextInput, type EditorTextInputProps, EditorToolbar, type EditorToolbarProps, EmptyState, type EmptyStateProps, ErrorState, type ErrorStateProps, EventBusContextType, FEATURE_COLORS, FEATURE_TYPES, FLOOR_HEIGHT, type FacingDirection, type FieldConfig, type FilterDefinition, FilterGroup, type FilterGroupProps, type FilterValue, Flex, type FlexProps, FloatingActionButton, type FloatingActionButtonProps, Form, FormActions, type FormActionsProps, FormField, type FormFieldConfig, type FormFieldProps, FormLayout, type FormLayoutProps, type FormProps, FormSection$1 as FormSection, FormSectionHeader, type FormSectionHeaderProps, type FormSectionProps, FormTemplate, type FormTemplateProps, type FormVariant, type FrameDimsResolver, GameHud, type GameHudElement, type GameHudProps, type GameHudStat, GameMenu, type GameMenuProps, type GameOverAction, GameOverScreen, type GameOverScreenProps, type GameOverStat, GameShell, type GameShellProps, GameTemplate, type GameTemplateProps, GenericAppTemplate, type GenericAppTemplateProps, GraphCanvas, type GraphCanvasProps, type GraphEdge, type GraphNode, Grid, type GridProps, HStack, type HStackProps, Header, type HeaderProps, Heading, type HeadingProps, HealthBar, type HealthBarProps, type HighlightType, Icon, type IconAnimation, type IconProps, type IconSize, Input, InputGroup, type InputGroupProps, type InputProps, type InventoryItem, InventoryPanel, type InventoryPanelProps, IsometricCanvas, type IsometricCanvasProps, type IsometricFeature, type IsometricTile, type IsometricUnit, Label, type LabelProps, type LawReference, LawReferenceTooltip, type LawReferenceTooltipProps, List, type ListItem, type ListProps, ListTemplate, type ListTemplateItem, type ListTemplateProps, type ListVariant, LoadingState, type LoadingStateProps, type MapHero, type MapHex, MasterDetail, type MasterDetailProps, MediaGallery, type MediaGalleryProps, type MediaItem, Menu, type MenuItem, type MenuOption, type MenuProps, Meter, type MeterProps, type MeterThreshold, type MeterVariant, Modal, type ModalProps, type ModalSize, ModalSlot, type ModalSlotProps, type NavItem, Navigation, type NavigationItem, type NavigationProps, OrbitalVisualization, type OrbitalVisualizationProps, Overlay, type OverlayProps, type PageBreadcrumb, PageHeader, type PageHeaderProps, Pagination, type PaginationProps, type Physics2DState, type PhysicsBounds, type PhysicsConfig, PhysicsManager, Popover, type PopoverProps, ProgressBar, type ProgressBarColor, type ProgressBarProps, type ProgressBarVariant, Radio, type RadioProps, type RelationOption, RelationSelect, type RelationSelectProps, RepeatableFormSection, type RepeatableFormSectionProps, type RepeatableItem, type ResolvedFrame, type RowAction, SHEET_COLUMNS, SPRITE_SHEET_LAYOUT, ScoreDisplay, type ScoreDisplayProps, SearchInput, type SearchInputProps, Section, type SectionProps, Select, type SelectOption, type SelectProps, type SettingsFieldConfig, type SettingsSectionConfig, SettingsTemplate, type SettingsTemplateProps, type SettingsVariant, type SheetUrlResolver, SidePanel, type SidePanelProps, Sidebar, type SidebarItem, type SidebarProps, SignaturePad, type SignaturePadProps, SimpleGrid, type SimpleGridProps, SlotContent, SlotContentRenderer, type SortDirection, Spacer, type SpacerProps, type SpacerSize, Spinner, type SpinnerProps, Split, SplitPane, type SplitPaneProps, type SplitProps, Sprite, type SpriteDirection, type SpriteFrameDims, type SpriteProps, type SpriteSheetUrls, Stack, type StackAlign, type StackDirection, type StackGap, type StackJustify, type StackProps, StatCard, type StatCardProps, StatusBar, type StatusBarProps, Switch, type SwitchProps, TERRAIN_COLORS, TILE_HEIGHT, TILE_WIDTH, type TabDefinition, type TabItem, TabbedContainer, type TabbedContainerProps, Table, type TableColumn, type TableProps, Tabs, type TabsProps, type TemplateProps, TerrainPalette, type TerrainPaletteProps, Text, TextHighlight, type TextHighlightProps, type TextProps, Textarea, type TextareaProps, ThemeSelector, ThemeToggle, type ThemeToggleProps, Timeline, type TimelineItem, type TimelineItemStatus, type TimelineProps, Toast, type ToastProps, ToastSlot, type ToastSlotProps, type ToastVariant, Tooltip, type TooltipProps, Typography, type TypographyProps, type TypographyVariant, UISlot, UISlotComponent, UISlotRenderer, type UISlotRendererProps, type UnitAnimationState, type UsePhysics2DOptions, type UsePhysics2DReturn, type UseSpriteAnimationsOptions, type UseSpriteAnimationsResult, VStack, type VStackProps, ViolationAlert, type ViolationAlertProps, type ViolationRecord, WizardContainer, type WizardContainerProps, WizardNavigation, type WizardNavigationProps, WizardProgress, type WizardProgressProps, type WizardProgressStep, type WizardStep, WorldMapBoard, type WorldMapBoardProps, type WorldMapEntity, type WorldMapSlotContext, WorldMapTemplate, type WorldMapTemplateProps, createUnitAnimationState, drawSprite, getCurrentFrame, inferDirection, isoToScreen, resolveFrame, resolveSheetDirection, screenToIso, tickAnimationState, transitionAnimation, useCamera, useImageCache, usePhysics2D, useSpriteAnimations };
+export { AR_BOOK_FIELDS, Accordion, type AccordionItem, type AccordionProps, Card as ActionCard, type CardProps as ActionCardProps, Alert, type AlertProps, type AlertVariant, type AnimationDef, type AnimationName, type AudioManifest, AuthLayout, type AuthLayoutProps, Avatar, type AvatarProps, type AvatarSize, type AvatarStatus, Badge, type BadgeProps, type BadgeVariant, BattleBoard, type BattleBoardProps, type BattleEntity, type BattlePhase, type BattleSlotContext, type BattleStateCallbacks, type BattleStateEventConfig, type BattleStateResult, BattleTemplate, type BattleTemplateProps, type BattleTile, type BattleUnit, type BookChapter, BookChapterView, type BookChapterViewProps, BookCoverPage, type BookCoverPageProps, type BookData, type BookFieldMap, BookNavBar, type BookNavBarProps, type BookPart, BookTableOfContents, type BookTableOfContentsProps, BookViewer, type BookViewerProps, Box, type BoxBg, type BoxMargin, type BoxPadding, type BoxProps, type BoxRounded, type BoxShadow, Breadcrumb, type BreadcrumbItem, type BreadcrumbProps, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, CameraState, CanvasEffect, type CanvasEffectProps, Card$1 as Card, type CardAction, CardBody, CardContent, CardFooter, CardGrid, type CardGridGap, type CardGridProps, CardHeader, type CardProps$1 as CardProps, CardTitle, CastleBoard, type CastleBoardProps, type CastleEntity, type CastleSlotContext, CastleTemplate, type CastleTemplateProps, Center, type CenterProps, Chart, type ChartDataPoint, type ChartProps, type ChartSeries, type ChartType, Checkbox, type CheckboxProps, CodeBlock, type CodeBlockProps, CodeViewer, type CodeViewerMode, type CodeViewerProps, CollapsibleSection, type CollapsibleSectionProps, type Column, type CombatActionType, type ConditionalContext, ConditionalWrapper, type ConditionalWrapperProps, ConfirmDialog, type ConfirmDialogProps, type ConfirmDialogVariant, Container, type ContainerProps, ContentRenderer, type ContentRendererProps, ControlButton, type ControlButtonProps, type CounterSize, CounterTemplate, type CounterTemplateProps, type CounterVariant, DIAMOND_TOP_Y, DashboardGrid, type DashboardGridCell, type DashboardGridProps, DashboardLayout, type DashboardLayoutProps, DataTable, type DataTableProps, type DetailField, DetailPanel, type DetailPanelProps, type DetailSection, DialogueBox, type DialogueBoxProps, type DialogueChoice, type DialogueNode, type DiffLine, Divider, type DividerOrientation, type DividerProps, type DocumentType, DocumentViewer, type DocumentViewerProps, StateMachineView as DomStateMachineVisualizer, Drawer, type DrawerPosition, type DrawerProps, type DrawerSize, DrawerSlot, type DrawerSlotProps, EditorCheckbox, type EditorCheckboxProps, type EditorMode, EditorSelect, type EditorSelectProps, EditorSlider, type EditorSliderProps, EditorTextInput, type EditorTextInputProps, EditorToolbar, type EditorToolbarProps, EmptyState, type EmptyStateProps, EntityDisplayEvents, type EntityDisplayProps, ErrorBoundary, type ErrorBoundaryProps, ErrorState, type ErrorStateProps, EventBusContextType, FEATURE_COLORS, FEATURE_TYPES, FLOOR_HEIGHT, type FacingDirection, type FilterDefinition, FilterGroup, type FilterGroupProps, type FilterPayload, Flex, type FlexProps, FloatingActionButton, type FloatingActionButtonProps, Form, FormActions, type FormActionsProps, FormField, type FormFieldProps, FormLayout, type FormLayoutProps, type FormProps, FormSection$1 as FormSection, FormSectionHeader, type FormSectionHeaderProps, type FormSectionProps, type FrameDimsResolver, GameAudioContext, type GameAudioContextValue, type GameAudioControls, GameAudioProvider, type GameAudioProviderProps, GameAudioToggle, type GameAudioToggleProps, GameHud, type GameHudElement, type GameHudProps, type GameHudStat, GameMenu, type GameMenuProps, type GameOverAction, GameOverScreen, type GameOverScreenProps, type GameOverStat, GameShell, type GameShellProps, GameTemplate, type GameTemplateProps, GenericAppTemplate, type GenericAppTemplateProps, GraphCanvas, type GraphCanvasProps, type GraphEdge, type GraphNode, Grid, type GridProps, HStack, type HStackProps, Header, type HeaderProps, Heading, type HeadingProps, HealthBar, type HealthBarProps, type HighlightType, IDENTITY_BOOK_FIELDS, Icon, type IconAnimation, type IconProps, type IconSize, Input, InputGroup, type InputGroupProps, type InputProps, type InventoryItem, InventoryPanel, type InventoryPanelProps, IsometricCanvas, type IsometricCanvasProps, IsometricFeature, IsometricTile, IsometricUnit, JazariStateMachine, type JazariStateMachineProps, Label, type LabelProps, type LawReference, LawReferenceTooltip, type LawReferenceTooltipProps, List, type ListItem, type ListProps, LoadingState, type LoadingStateProps, type MapHero, type MapHex, MarkdownContent, type MarkdownContentProps, MasterDetail, type MasterDetailProps, MediaGallery, type MediaGalleryProps, type MediaItem, Menu, type MenuItem, type MenuOption, type MenuProps, Meter, type MeterProps, type MeterThreshold, type MeterVariant, Modal, type ModalProps, type ModalSize, ModalSlot, type ModalSlotProps, type NavItem, Navigation, type NavigationItem, type NavigationProps, StateMachineView as OrbitalStateMachineView, OrbitalVisualization, type OrbitalVisualizationProps, Overlay, type OverlayProps, type PageBreadcrumb, PageHeader, type PageHeaderProps, type PaginatePayload, Pagination, type PaginationProps, type Physics2DState, type PhysicsBounds, type PhysicsConfig, PhysicsManager, Popover, type PopoverProps, ProgressBar, type ProgressBarColor, type ProgressBarProps, type ProgressBarVariant, QuizBlock, type QuizBlockProps, Radio, type RadioProps, type RelationOption, RelationSelect, type RelationSelectProps, RepeatableFormSection, type RepeatableFormSectionProps, type RepeatableItem, type ResolvedFrame, type RowAction, SHEET_COLUMNS, SPRITE_SHEET_LAYOUT, ScaledDiagram, type ScaledDiagramProps, ScoreDisplay, type ScoreDisplayProps, SearchInput, type SearchInputProps, type SearchPayload, Section, type SectionProps, Select, type SelectOption, type SelectPayload, type SelectProps, type SheetUrlResolver, SidePanel, type SidePanelProps, Sidebar, type SidebarItem, type SidebarProps, SignaturePad, type SignaturePadProps, SimpleGrid, type SimpleGridProps, Skeleton, type SkeletonProps, type SkeletonVariant, SlotContent, SlotContentRenderer, type SlotItemData, type SortDirection, type SortPayload, type SoundEntry, Spacer, type SpacerProps, type SpacerSize, Spinner, type SpinnerProps, Split, SplitPane, type SplitPaneProps, type SplitProps, Sprite, type SpriteDirection, type SpriteFrameDims, type SpriteProps, type SpriteSheetUrls, Stack, type StackAlign, type StackDirection, type StackGap, type StackJustify, type StackProps, StatCard, type StatCardProps, StateIndicator, type StateIndicatorProps, StateMachineView, type StateMachineViewProps, type StateStyle, StatusBar, type StatusBarProps, Switch, type SwitchProps, TERRAIN_COLORS, TILE_HEIGHT, TILE_WIDTH, type TabDefinition, type TabItem, TabbedContainer, type TabbedContainerProps, Table, type TableColumn, type TableProps, Tabs, type TabsProps, type TemplateProps, TerrainPalette, type TerrainPaletteProps, Text, TextHighlight, type TextHighlightProps, type TextProps, Textarea, type TextareaProps, ThemeSelector, ThemeToggle, type ThemeToggleProps, Timeline, type TimelineItem, type TimelineItemStatus, type TimelineProps, Toast, type ToastProps, ToastSlot, type ToastSlotProps, type ToastVariant, Tooltip, type TooltipProps, TraitSlot, type TraitSlotProps, type TraitStateMachineDefinition, TraitStateViewer, type TraitStateViewerProps, type TraitTransition, type TransitionBundle, Typography, type TypographyProps, type TypographyVariant, UISlot, UISlotComponent, UISlotRenderer, type UISlotRendererProps, UncontrolledBattleBoard, type UncontrolledBattleBoardProps, type UnitAnimationState, type UseGameAudioOptions, type UsePhysics2DOptions, type UsePhysics2DReturn, type UseSpriteAnimationsOptions, type UseSpriteAnimationsResult, VStack, type VStackProps, ViolationAlert, type ViolationAlertProps, type ViolationRecord, WizardContainer, type WizardContainerProps, WizardNavigation, type WizardNavigationProps, WizardProgress, type WizardProgressProps, type WizardProgressStep, type WizardStep, WorldMapBoard, type WorldMapBoardProps, type WorldMapEntity, type WorldMapSlotContext, WorldMapTemplate, type WorldMapTemplateProps, createUnitAnimationState, drawSprite, getCurrentFrame, inferDirection, isoToScreen, mapBookData, resolveFieldMap, resolveFrame, resolveSheetDirection, screenToIso, tickAnimationState, transitionAnimation, useBattleState, useCamera, useGameAudio, useGameAudioContext, useImageCache, usePhysics2D, useSpriteAnimations };