@almadar/std 3.0.1 → 3.0.3

package/dist/behaviors/functions/index.d.ts

@@ -0,0 +1,2533 @@
+import { EntityField, OrbitalDefinition, Entity, Page, Trait, OrbitalSchema } from '@almadar/core/types';
+export { compose, connect, ensureIdField, extractTrait, makeEntity, makeOrbital, makePage, mergeOrbitals, pipe, plural, wire } from '@almadar/core/builders';
+
+/**
+ * std-list
+ *
+ * CRUD list molecule. Composes atoms via shared event bus:
+ * - stdBrowse: data-grid with item actions (fires CREATE, VIEW, EDIT, DELETE)
+ * - stdModal (x3): create form, edit form, detail view (responds to matching events)
+ * - stdConfirmation: delete confirmation (responds to DELETE)
+ *
+ * No emits/listens wiring. Traits on the same page share the event bus.
+ * Only the trait with a matching transition from its current state responds.
+ *
+ * @level molecule
+ * @family crud
+ * @packageDocumentation
+ */
+
+interface StdListParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    listFields?: string[];
+    detailFields?: string[];
+    formFields?: string[];
+    pageTitle?: string;
+    createButtonLabel?: string;
+    editFormTitle?: string;
+    createFormTitle?: string;
+    deleteMessage?: string;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    headerIcon?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdListEntity(params: StdListParams): Entity;
+declare function stdListTrait(params: StdListParams): Trait;
+declare function stdListPage(params: StdListParams): Page;
+declare function stdList(params: StdListParams): OrbitalDefinition;
+
+/**
+ * std-cart
+ *
+ * Shopping cart molecule. Composes atoms:
+ * - Cart-specific browse trait (empty/hasItems/checkout states)
+ * - stdModal for the add-item form (responds to ADD_ITEM)
+ *
+ * @level molecule
+ * @family commerce
+ * @packageDocumentation
+ */
+
+interface StdCartParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    listFields?: string[];
+    formFields?: string[];
+    pageTitle?: string;
+    addButtonLabel?: string;
+    checkoutButtonLabel?: string;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    headerIcon?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdCartEntity(params: StdCartParams): Entity;
+declare function stdCartTrait(params: StdCartParams): Trait;
+declare function stdCartPage(params: StdCartParams): Page;
+declare function stdCart(params: StdCartParams): OrbitalDefinition;
+
+/**
+ * std-detail
+ *
+ * Browse + Create + View molecule. Composes atoms:
+ * - stdBrowse: data-grid with View item action and Create header action
+ * - stdModal: create form (responds to CREATE)
+ * - stdModal: view detail (responds to VIEW)
+ *
+ * No edit/delete from list. Used for feeds, ledgers, galleries.
+ *
+ * @level molecule
+ * @family crud
+ * @packageDocumentation
+ */
+
+interface StdDetailParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    listFields?: string[];
+    detailFields?: string[];
+    formFields?: string[];
+    pageTitle?: string;
+    createButtonLabel?: string;
+    createFormTitle?: string;
+    headerIcon?: string;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdDetailEntity(params: StdDetailParams): Entity;
+declare function stdDetailTrait(params: StdDetailParams): Trait;
+declare function stdDetailPage(params: StdDetailParams): Page;
+declare function stdDetail(params: StdDetailParams): OrbitalDefinition;
+
+/**
+ * std-inventory
+ *
+ * Item collection molecule. Composes atoms via shared event bus:
+ * - stdBrowse: data-grid with item actions (fires ADD_ITEM, USE_ITEM, DROP)
+ * - stdModal (add): create form for adding items (responds to ADD_ITEM)
+ * - stdModal (use): item detail for using items (responds to USE_ITEM)
+ * - stdConfirmation: drop confirmation (responds to DROP)
+ *
+ * No emits/listens wiring. Traits on the same page share the event bus.
+ * Only the trait with a matching transition from its current state responds.
+ *
+ * @level molecule
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdInventoryParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    listFields?: string[];
+    formFields?: string[];
+    pageTitle?: string;
+    addLabel?: string;
+    headerIcon?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdInventoryEntity(params: StdInventoryParams): Entity;
+declare function stdInventoryTrait(params: StdInventoryParams): Trait;
+declare function stdInventoryPage(params: StdInventoryParams): Page;
+declare function stdInventory(params: StdInventoryParams): OrbitalDefinition;
+
+/**
+ * std-messaging
+ *
+ * Messaging molecule. Composes atoms via shared event bus:
+ * - stdBrowse: message list with "Compose" header action, "View" item action
+ * - stdModal (compose): compose/send message form (COMPOSE -> SEND)
+ * - stdModal (view): view message detail (VIEW with id payload)
+ *
+ * No emits/listens wiring. Traits on the same page share the event bus.
+ * Only the trait with a matching transition from its current state responds.
+ *
+ * @level molecule
+ * @family communication
+ * @packageDocumentation
+ */
+
+interface StdMessagingParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    listFields?: string[];
+    formFields?: string[];
+    detailFields?: string[];
+    pageTitle?: string;
+    composerTitle?: string;
+    headerIcon?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdMessagingEntity(params: StdMessagingParams): Entity;
+declare function stdMessagingTrait(params: StdMessagingParams): Trait;
+declare function stdMessagingPage(params: StdMessagingParams): Page;
+declare function stdMessaging(params: StdMessagingParams): OrbitalDefinition;
+
+/**
+ * std-geospatial
+ *
+ * Location selection molecule. Composes atoms via shared event bus:
+ * - stdBrowse: location list with "Select" item action (fires SELECT)
+ * - stdModal: select/view location detail (responds to SELECT)
+ * - stdConfirmation: confirm location selection (responds to CONFIRM_SELECT)
+ *
+ * No emits/listens wiring. Traits on the same page share the event bus.
+ * Only the trait with a matching transition from its current state responds.
+ *
+ * @level molecule
+ * @family location
+ * @packageDocumentation
+ */
+
+interface StdGeospatialParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    listFields?: string[];
+    detailFields?: string[];
+    pageTitle?: string;
+    selectLabel?: string;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    headerIcon?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdGeospatialEntity(params: StdGeospatialParams): Entity;
+declare function stdGeospatialTrait(params: StdGeospatialParams): Trait;
+declare function stdGeospatialPage(params: StdGeospatialParams): Page;
+declare function stdGeospatial(params: StdGeospatialParams): OrbitalDefinition;
+
+/**
+ * std-browse
+ *
+ * Data grid browsing atom. Renders a list of entities with
+ * configurable item actions. The browsing view that molecules
+ * compose with modal/confirmation atoms.
+ *
+ * @level atom
+ * @family browse
+ * @packageDocumentation
+ */
+
+interface StdBrowseParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    traitName?: string;
+    listFields?: string[];
+    headerIcon?: string;
+    pageTitle?: string;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    headerActions?: Array<{
+        label: string;
+        event: string;
+        variant?: string;
+        icon?: string;
+    }>;
+    itemActions?: Array<{
+        label: string;
+        event: string;
+        variant?: string;
+    }>;
+    refreshEvents?: string[];
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdBrowseEntity(params: StdBrowseParams): Entity;
+declare function stdBrowseTrait(params: StdBrowseParams): Trait;
+declare function stdBrowsePage(params: StdBrowseParams): Page;
+declare function stdBrowse(params: StdBrowseParams): OrbitalDefinition;
+
+/**
+ * std-modal
+ *
+ * Modal overlay atom. Accepts content injection so molecules
+ * can control what renders inside the open state.
+ *
+ * @level atom
+ * @family modal
+ * @packageDocumentation
+ */
+
+interface StdModalParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    traitName?: string;
+    modalTitle?: string;
+    headerIcon?: string;
+    /** Render-ui tree for the open state. Defaults to entity field detail view. */
+    openContent?: unknown;
+    /** Event key that opens the modal (default: 'OPEN') */
+    openEvent?: string;
+    /** Payload schema for the open event (e.g., [{ name: 'id', type: 'string', required: true }]) */
+    openPayload?: Array<{
+        name: string;
+        type: string;
+        required?: boolean;
+    }>;
+    /** Event key that closes the modal (default: 'CLOSE') */
+    closeEvent?: string;
+    /** Additional effects to run before render on open (e.g., fetch) */
+    openEffects?: unknown[];
+    /** If provided, adds a save transition: open → closed with these effects */
+    saveEvent?: string;
+    saveEffects?: unknown[];
+    /** When false, INIT renders nothing to main (used inside molecules). Default true. */
+    standalone?: boolean;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdModalEntity(params: StdModalParams): Entity;
+declare function stdModalTrait(params: StdModalParams): Trait;
+declare function stdModalPage(params: StdModalParams): Page;
+declare function stdModal(params: StdModalParams): OrbitalDefinition;
+
+/**
+ * std-confirmation as a Function
+ *
+ * Confirmation dialog behavior parameterized for any domain.
+ * Provides a two-step confirm/cancel flow before performing destructive actions.
+ * The caller handles the actual action via emits/listens.
+ * The state machine structure is fixed. The caller controls data and presentation.
+ *
+ * @level atom
+ * @family confirmation
+ * @packageDocumentation
+ */
+
+interface StdConfirmationParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    traitName?: string;
+    confirmTitle?: string;
+    confirmMessage?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    headerIcon?: string;
+    /** Event key that opens the confirmation (default: 'REQUEST') */
+    requestEvent?: string;
+    /** Event key for confirm action (default: 'CONFIRM') */
+    confirmEvent?: string;
+    /** Additional effects to run on confirm (e.g., persist delete) */
+    confirmEffects?: unknown[];
+    /** When false, INIT renders nothing to main (used inside molecules). Default true. */
+    standalone?: boolean;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdConfirmationEntity(params: StdConfirmationParams): Entity;
+declare function stdConfirmationTrait(params: StdConfirmationParams): Trait;
+declare function stdConfirmationPage(params: StdConfirmationParams): Page;
+declare function stdConfirmation(params: StdConfirmationParams): OrbitalDefinition;
+
+/**
+ * std-search as a Function
+ *
+ * Search behavior parameterized for any domain.
+ * Provides a search input that filters entity data by query string.
+ * The state machine structure is fixed. The caller controls data and presentation.
+ *
+ * @level atom
+ * @family search
+ * @packageDocumentation
+ */
+
+interface StdSearchParams {
+    /** Entity name in PascalCase (e.g., "Product", "Article") */
+    entityName: string;
+    /** Entity fields (id is auto-added) */
+    fields: EntityField[];
+    /** Persistence mode */
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Placeholder text for the search input */
+    placeholder?: string;
+    /** Icon for the search input (Lucide name) */
+    searchIcon?: string;
+    /** Page name (defaults to "{Entity}SearchPage") */
+    pageName?: string;
+    /** Route path (defaults to "/{entities}/search") */
+    pagePath?: string;
+    /** Whether this is the initial/home page */
+    isInitial?: boolean;
+}
+declare function stdSearchEntity(params: StdSearchParams): Entity;
+declare function stdSearchTrait(params: StdSearchParams): Trait;
+declare function stdSearchPage(params: StdSearchParams): Page;
+declare function stdSearch(params: StdSearchParams): OrbitalDefinition;
+
+/**
+ * std-filter
+ *
+ * Filter atom. Shows filter buttons per field with predefined values.
+ * Clicking a filter value transitions to filtered state. Clear resets.
+ *
+ * @level atom
+ * @family filter
+ * @packageDocumentation
+ */
+
+interface StdFilterParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Fields to show as filter buttons (defaults to fields with `values` defined) */
+    filterFields?: string[];
+    headerIcon?: string;
+    pageTitle?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdFilterEntity(params: StdFilterParams): Entity;
+declare function stdFilterTrait(params: StdFilterParams): Trait;
+declare function stdFilterPage(params: StdFilterParams): Page;
+declare function stdFilter(params: StdFilterParams): OrbitalDefinition;
+
+/**
+ * std-sort
+ *
+ * Sort atom. Shows sort-by buttons for each sortable field.
+ * Clicking a field name sorts by that field. Clicking again toggles direction.
+ *
+ * @level atom
+ * @family sort
+ * @packageDocumentation
+ */
+
+interface StdSortParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Fields available for sorting (defaults to all non-id fields) */
+    sortFields?: string[];
+    headerIcon?: string;
+    pageTitle?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdSortEntity(params: StdSortParams): Entity;
+declare function stdSortTrait(params: StdSortParams): Trait;
+declare function stdSortPage(params: StdSortParams): Page;
+declare function stdSort(params: StdSortParams): OrbitalDefinition;
+
+/**
+ * std-pagination as a Function
+ *
+ * Pagination behavior parameterized for any domain.
+ * Provides page/pageSize controls that paginate entity data.
+ * Single idle state with a self-loop that re-renders with the new page applied.
+ *
+ * @level atom
+ * @family pagination
+ * @packageDocumentation
+ */
+
+interface StdPaginationParams {
+    /** Entity name in PascalCase (e.g., "Article", "Product") */
+    entityName: string;
+    /** Entity fields (id is auto-added) */
+    fields: EntityField[];
+    /** Persistence mode */
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Header icon (Lucide name) */
+    headerIcon?: string;
+    /** Page title (defaults to plural entity name) */
+    pageTitle?: string;
+    /** Page name (defaults to "{Entity}PaginationPage") */
+    pageName?: string;
+    /** Route path (defaults to "/{entities}/paginated") */
+    pagePath?: string;
+    /** Whether this is the initial/home page */
+    isInitial?: boolean;
+}
+declare function stdPaginationEntity(params: StdPaginationParams): Entity;
+declare function stdPaginationTrait(params: StdPaginationParams): Trait;
+declare function stdPaginationPage(params: StdPaginationParams): Page;
+declare function stdPagination(params: StdPaginationParams): OrbitalDefinition;
+
+/**
+ * std-drawer as a Function
+ *
+ * Drawer behavior parameterized for any domain.
+ * Provides a slide-out drawer that displays entity detail.
+ * Two states: closed and open, with transitions to toggle visibility.
+ * Similar to std-modal but renders to a "drawer" slot concept.
+ *
+ * @level atom
+ * @family drawer
+ * @packageDocumentation
+ */
+
+interface StdDrawerParams {
+    /** Entity name in PascalCase (e.g., "Panel", "Sidebar") */
+    entityName: string;
+    /** Entity fields (id is auto-added) */
+    fields: EntityField[];
+    /** Persistence mode */
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Drawer title (defaults to "Details") */
+    drawerTitle?: string;
+    /** Header icon (Lucide name) */
+    headerIcon?: string;
+    /** Page name (defaults to "{Entity}DrawerPage") */
+    pageName?: string;
+    /** Route path (defaults to "/{entities}/drawer") */
+    pagePath?: string;
+    /** Whether this is the initial/home page */
+    isInitial?: boolean;
+}
+declare function stdDrawerEntity(params: StdDrawerParams): Entity;
+declare function stdDrawerTrait(params: StdDrawerParams): Trait;
+declare function stdDrawerPage(params: StdDrawerParams): Page;
+declare function stdDrawer(params: StdDrawerParams): OrbitalDefinition;
+
+/**
+ * std-notification as a Function
+ *
+ * Notification behavior parameterized for any domain.
+ * Provides a show/hide notification display.
+ * The state machine structure is fixed. The caller controls data and presentation.
+ *
+ * @level atom
+ * @family notification
+ * @packageDocumentation
+ */
+
+interface StdNotificationParams {
+    /** Entity name in PascalCase (e.g., "Alert", "Notice") */
+    entityName: string;
+    /** Entity fields (id is auto-added) */
+    fields: EntityField[];
+    /** Persistence mode */
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Header icon (Lucide name) */
+    headerIcon?: string;
+    /** Page title */
+    pageTitle?: string;
+    /** Page name (defaults to "{Entity}NotificationPage") */
+    pageName?: string;
+    /** Route path (defaults to "/{entities}/notifications") */
+    pagePath?: string;
+    /** Whether this is the initial/home page */
+    isInitial?: boolean;
+}
+declare function stdNotificationEntity(params: StdNotificationParams): Entity;
+declare function stdNotificationTrait(params: StdNotificationParams): Trait;
+declare function stdNotificationPage(params: StdNotificationParams): Page;
+declare function stdNotification(params: StdNotificationParams): OrbitalDefinition;
+
+/**
+ * std-timer as a Function
+ *
+ * Timer behavior parameterized for any domain.
+ * Provides a countdown timer with start, pause, resume, and reset controls.
+ * The state machine structure is fixed. The caller controls data and presentation.
+ *
+ * @level atom
+ * @family timer
+ * @packageDocumentation
+ */
+
+interface StdTimerParams {
+    /** Entity name in PascalCase (e.g., "Countdown", "Pomodoro") */
+    entityName: string;
+    /** Entity fields (id is auto-added) */
+    fields: EntityField[];
+    /** Persistence mode */
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Default duration in seconds */
+    duration?: number;
+    /** Timer title */
+    timerTitle?: string;
+    /** Header icon (Lucide name) */
+    headerIcon?: string;
+    /** Page name (defaults to "{Entity}TimerPage") */
+    pageName?: string;
+    /** Route path (defaults to "/{entities}/timer") */
+    pagePath?: string;
+    /** Whether this is the initial/home page */
+    isInitial?: boolean;
+}
+declare function stdTimerEntity(params: StdTimerParams): Entity;
+declare function stdTimerTrait(params: StdTimerParams): Trait;
+declare function stdTimerPage(params: StdTimerParams): Page;
+declare function stdTimer(params: StdTimerParams): OrbitalDefinition;
+
+/**
+ * std-tabs
+ *
+ * Tab navigation atom. Uses the `tabs` pattern component
+ * with clickable tab headers. Each tab shows different entity data.
+ *
+ * @level atom
+ * @family tabs
+ * @packageDocumentation
+ */
+
+interface StdTabsParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Tab definitions: each tab has a label and the fields it shows */
+    tabItems?: Array<{
+        label: string;
+        value: string;
+    }>;
+    headerIcon?: string;
+    pageTitle?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdTabsEntity(params: StdTabsParams): Entity;
+declare function stdTabsTrait(params: StdTabsParams): Trait;
+declare function stdTabsPage(params: StdTabsParams): Page;
+declare function stdTabs(params: StdTabsParams): OrbitalDefinition;
+
+/**
+ * std-loading as a Function
+ *
+ * Loading behavior parameterized for any domain.
+ * Provides a multi-state loading lifecycle: idle, loading, success, error.
+ * Tracks async operation status with appropriate UI for each state.
+ *
+ * @level atom
+ * @family loading
+ * @packageDocumentation
+ */
+
+interface StdLoadingParams {
+    /** Entity name in PascalCase (e.g., "Request", "Upload") */
+    entityName: string;
+    /** Entity fields (id is auto-added) */
+    fields: EntityField[];
+    /** Persistence mode */
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Header icon (Lucide name) */
+    headerIcon?: string;
+    /** Title text (defaults to entity name) */
+    title?: string;
+    /** Page name (defaults to "{Entity}LoadingPage") */
+    pageName?: string;
+    /** Route path (defaults to "/{entities}/loading") */
+    pagePath?: string;
+    /** Whether this is the initial/home page */
+    isInitial?: boolean;
+}
+declare function stdLoadingEntity(params: StdLoadingParams): Entity;
+declare function stdLoadingTrait(params: StdLoadingParams): Trait;
+declare function stdLoadingPage(params: StdLoadingParams): Page;
+declare function stdLoading(params: StdLoadingParams): OrbitalDefinition;
+
+/**
+ * std-selection as a Function
+ *
+ * Selection behavior parameterized for any domain.
+ * Provides item selection from a list with confirm/deselect controls.
+ * Three states: idle, selecting, selected with transitions for the full lifecycle.
+ *
+ * @level atom
+ * @family selection
+ * @packageDocumentation
+ */
+
+interface StdSelectionParams {
+    /** Entity name in PascalCase (e.g., "Item", "Option") */
+    entityName: string;
+    /** Entity fields (id is auto-added) */
+    fields: EntityField[];
+    /** Persistence mode */
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Header icon (Lucide name) */
+    headerIcon?: string;
+    /** Page title (defaults to plural entity name) */
+    pageTitle?: string;
+    /** Page name (defaults to "{Entity}SelectionPage") */
+    pageName?: string;
+    /** Route path (defaults to "/{entities}/selection") */
+    pagePath?: string;
+    /** Whether this is the initial/home page */
+    isInitial?: boolean;
+}
+declare function stdSelectionEntity(params: StdSelectionParams): Entity;
+declare function stdSelectionTrait(params: StdSelectionParams): Trait;
+declare function stdSelectionPage(params: StdSelectionParams): Page;
+declare function stdSelection(params: StdSelectionParams): OrbitalDefinition;
+
+/**
+ * std-undo
+ *
+ * Undo/Redo atom using array operators as a stack.
+ * - PUSH: appends to undoStack, clears redoStack
+ * - UNDO: pops from undoStack, pushes to redoStack
+ * - REDO: pops from redoStack, pushes to undoStack
+ * - CLEAR: empties both stacks
+ *
+ * Entity fields: undoStack (array), redoStack (array), current (string)
+ *
+ * @level atom
+ * @family undo
+ * @packageDocumentation
+ */
+
+interface StdUndoParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    headerIcon?: string;
+    pageTitle?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdUndoEntity(params: StdUndoParams): Entity;
+declare function stdUndoTrait(params: StdUndoParams): Trait;
+declare function stdUndoPage(params: StdUndoParams): Page;
+declare function stdUndo(params: StdUndoParams): OrbitalDefinition;
+
+/**
+ * std-input as a Function
+ *
+ * Input state management parameterized for any domain.
+ * Provides idle, focused, and validating states with change tracking.
+ * The state machine structure is fixed. The caller controls data and presentation.
+ *
+ * @level atom
+ * @family input
+ * @packageDocumentation
+ */
+
+interface StdInputParams {
+    /** Entity name in PascalCase (e.g., "Field", "TextInput") */
+    entityName: string;
+    /** Entity fields (id is auto-added) */
+    fields: EntityField[];
+    /** Persistence mode */
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Input label */
+    inputLabel?: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Header icon (Lucide name) */
+    headerIcon?: string;
+    /** Page name (defaults to "{Entity}InputPage") */
+    pageName?: string;
+    /** Route path (defaults to "/{entities}/input") */
+    pagePath?: string;
+    /** Whether this is the initial/home page */
+    isInitial?: boolean;
+}
+declare function stdInputEntity(params: StdInputParams): Entity;
+declare function stdInputTrait(params: StdInputParams): Trait;
+declare function stdInputPage(params: StdInputParams): Page;
+declare function stdInput(params: StdInputParams): OrbitalDefinition;
+
+/**
+ * std-wizard
+ *
+ * Multi-step wizard behavior parameterized for any domain.
+ * Generates a dynamic number of steps based on the `steps` parameter,
+ * with a review screen and completion view.
+ * Pure function: params in, OrbitalDefinition out.
+ *
+ * @level molecule
+ * @family workflow
+ * @packageDocumentation
+ */
+
+interface StdWizardParams {
+    /** Entity name in PascalCase (e.g., "Onboarding") */
+    entityName: string;
+    /** Entity fields (id is auto-added) */
+    fields: EntityField[];
+    /** Persistence mode */
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Collection name for persistent entities (defaults to lowercase plural) */
+    collection?: string;
+    /** Wizard steps: each step has a name and the fields it displays */
+    steps: Array<{
+        name: string;
+        fields: string[];
+    }>;
+    /** Wizard title (defaults to "Setup Wizard") */
+    wizardTitle?: string;
+    /** Completion title (defaults to "Complete!") */
+    completeTitle?: string;
+    /** Completion description (defaults to "Your {entity} has been created successfully.") */
+    completeDescription?: string;
+    /** Submit button label on review (defaults to "Complete") */
+    submitButtonLabel?: string;
+    /** Header icon (Lucide name, defaults to "clipboard") */
+    headerIcon?: string;
+    /** Page name (defaults to "{Entity}Page") */
+    pageName?: string;
+    /** Route path (defaults to "/wizard") */
+    pagePath?: string;
+    /** Whether this is the initial/home page */
+    isInitial?: boolean;
+}
+declare function stdWizardEntity(params: StdWizardParams): Entity;
+declare function stdWizardTrait(params: StdWizardParams): Trait;
+declare function stdWizardPage(params: StdWizardParams): Page;
+declare function stdWizard(params: StdWizardParams): OrbitalDefinition;
+
+/**
+ * std-display
+ *
+ * Read-only display molecule with loading/refresh.
+ * Single trait (display is self-contained, no modal atoms needed).
+ * Used for dashboards, stats panels, KPIs.
+ *
+ * @level molecule
+ * @family display
+ * @packageDocumentation
+ */
+
+interface StdDisplayParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    displayFields?: string[];
+    pageTitle?: string;
+    refreshButtonLabel?: string;
+    headerIcon?: string;
+    columns?: number;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdDisplayEntity(params: StdDisplayParams): Entity;
+declare function stdDisplayTrait(params: StdDisplayParams): Trait;
+declare function stdDisplayPage(params: StdDisplayParams): Page;
+declare function stdDisplay(params: StdDisplayParams): OrbitalDefinition;
+
+/**
+ * std-async
+ *
+ * Async operation behavior: idle, loading, success, error.
+ * Covers fetch, submit, retry, and polling patterns in one molecule.
+ * Pure function: params in, OrbitalDefinition out.
+ *
+ * @level molecule
+ * @family async
+ * @packageDocumentation
+ */
+
+interface StdAsyncParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    loadingMessage?: string;
+    successMessage?: string;
+    errorMessage?: string;
+    headerIcon?: string;
+    retryable?: boolean;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdAsyncEntity(params: StdAsyncParams): Entity;
+declare function stdAsyncTrait(params: StdAsyncParams): Trait;
+declare function stdAsyncPage(params: StdAsyncParams): Page;
+declare function stdAsync(params: StdAsyncParams): OrbitalDefinition;
+
+/**
+ * std-combat
+ *
+ * Attack cycle behavior: ready, attacking, cooldown, defeated.
+ * Pure function: params in, OrbitalDefinition out.
+ *
+ * @level molecule
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdCombatParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    attackLabel?: string;
+    headerIcon?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdCombatEntity(params: StdCombatParams): Entity;
+declare function stdCombatTrait(params: StdCombatParams): Trait;
+declare function stdCombatPage(params: StdCombatParams): Page;
+declare function stdCombat(params: StdCombatParams): OrbitalDefinition;
+
+/**
+ * std-gameflow
+ *
+ * Game state management behavior: menu, playing, paused, gameover.
+ * Uses game UI patterns per state:
+ *   menu     -> game-menu (title, subtitle, Start Game button)
+ *   playing  -> game-hud (score, level stats)
+ *   paused   -> game-menu in modal (Resume, Quit buttons)
+ *   gameover -> game-over-screen (score, Play Again, Main Menu)
+ *
+ * Pure function: params in, OrbitalDefinition out.
+ *
+ * @level molecule
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdGameflowParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    gameTitle?: string;
+    menuTitle?: string;
+    pauseTitle?: string;
+    gameoverTitle?: string;
+    headerIcon?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdGameflowEntity(params: StdGameflowParams): Entity;
+declare function stdGameflowTrait(params: StdGameflowParams): Trait;
+declare function stdGameflowPage(params: StdGameflowParams): Page;
+declare function stdGameflow(params: StdGameflowParams): OrbitalDefinition;
+
+/**
+ * std-movement
+ *
+ * Entity movement behavior: idle, moving, collision detection and resolution.
+ * Pure function: params in, OrbitalDefinition out.
+ *
+ * @level molecule
+ * @family simulation
+ * @packageDocumentation
+ */
+
+interface StdMovementParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    pageTitle?: string;
+    headerIcon?: string;
+    moveSpeed?: number;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdMovementEntity(params: StdMovementParams): Entity;
+declare function stdMovementTrait(params: StdMovementParams): Trait;
+declare function stdMovementPage(params: StdMovementParams): Page;
+declare function stdMovement(params: StdMovementParams): OrbitalDefinition;
+
+/**
+ * std-quest
+ *
+ * Quest/objective tracking behavior: available, active, complete, failed.
+ * Pure function: params in, OrbitalDefinition out.
+ *
+ * @level molecule
+ * @family gameplay
+ * @packageDocumentation
+ */
+
+interface StdQuestParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    listFields?: string[];
+    formFields?: string[];
+    pageTitle?: string;
+    questTitle?: string;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    headerIcon?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdQuestEntity(params: StdQuestParams): Entity;
+declare function stdQuestTrait(params: StdQuestParams): Trait;
+declare function stdQuestPage(params: StdQuestParams): Page;
+declare function stdQuest(params: StdQuestParams): OrbitalDefinition;
+
+/**
+ * std-overworld
+ *
+ * Map/zone navigation behavior: exploring, transitioning, entered.
+ * Pure function: params in, OrbitalDefinition out.
+ *
+ * @level molecule
+ * @family navigation
+ * @packageDocumentation
+ */
+
+interface StdOverworldParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    listFields?: string[];
+    pageTitle?: string;
+    worldTitle?: string;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    headerIcon?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdOverworldEntity(params: StdOverworldParams): Entity;
+declare function stdOverworldTrait(params: StdOverworldParams): Trait;
+declare function stdOverworldPage(params: StdOverworldParams): Page;
+declare function stdOverworld(params: StdOverworldParams): OrbitalDefinition;
+
+/**
+ * std-circuit-breaker
+ *
+ * Circuit breaker pattern behavior: closed, open, halfOpen.
+ * Protects services from cascading failures with automatic recovery.
+ * Pure function: params in, OrbitalDefinition out.
+ *
+ * @level molecule
+ * @family resilience
+ * @packageDocumentation
+ */
+
+interface StdCircuitBreakerParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    closedLabel?: string;
+    openLabel?: string;
+    halfOpenLabel?: string;
+    headerIcon?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdCircuitBreakerEntity(params: StdCircuitBreakerParams): Entity;
+declare function stdCircuitBreakerTrait(params: StdCircuitBreakerParams): Trait;
+declare function stdCircuitBreakerPage(params: StdCircuitBreakerParams): Page;
+declare function stdCircuitBreaker(params: StdCircuitBreakerParams): OrbitalDefinition;
+
+/**
+ * std-cache-aside
+ *
+ * Cache management behavior: empty, cached, stale with fetch/invalidate cycle.
+ * Pure function: params in, OrbitalDefinition out.
+ *
+ * @level molecule
+ * @family infrastructure
+ * @packageDocumentation
+ */
+
+interface StdCacheAsideParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    listFields?: string[];
+    pageTitle?: string;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    headerIcon?: string;
+    ttl?: number;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdCacheAsideEntity(params: StdCacheAsideParams): Entity;
+declare function stdCacheAsideTrait(params: StdCacheAsideParams): Trait;
+declare function stdCacheAsidePage(params: StdCacheAsideParams): Page;
+declare function stdCacheAside(params: StdCacheAsideParams): OrbitalDefinition;
+
+/**
+ * std-score as a Function
+ *
+ * Score tracking parameterized for any domain.
+ * Provides a single-state machine with self-loops for adding, subtracting,
+ * resetting, and applying combo multipliers to a score.
+ * The state machine structure is fixed. The caller controls data and presentation.
+ *
+ * @level atom
+ * @family score
+ * @packageDocumentation
+ */
+
+interface StdScoreParams {
+    /** Entity name in PascalCase (e.g., "Points", "GameScore") */
+    entityName: string;
+    /** Entity fields (id is auto-added) */
+    fields: EntityField[];
+    /** Persistence mode */
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Score title */
+    scoreTitle?: string;
+    /** Header icon (Lucide name) */
+    headerIcon?: string;
+    /** Page name (defaults to "{Entity}ScorePage") */
+    pageName?: string;
+    /** Route path (defaults to "/{entities}/score") */
+    pagePath?: string;
+    /** Whether this is the initial/home page */
+    isInitial?: boolean;
+}
+declare function stdScoreEntity(params: StdScoreParams): Entity;
+declare function stdScoreTrait(params: StdScoreParams): Trait;
+declare function stdScorePage(params: StdScoreParams): Page;
+declare function stdScore(params: StdScoreParams): OrbitalDefinition;
+
+/**
+ * std-collision as a Function
+ *
+ * Game collision detection parameterized for any domain.
+ * Provides idle and detecting states for checking collisions
+ * between game entities. Tracks collision targets via entity fields.
+ * The state machine structure is fixed. The caller controls data and presentation.
+ *
+ * @level atom
+ * @family collision
+ * @packageDocumentation
+ */
+
+interface StdCollisionParams {
+    /** Entity name in PascalCase (e.g., "Hitbox", "Collider") */
+    entityName: string;
+    /** Entity fields (id is auto-added) */
+    fields: EntityField[];
+    /** Persistence mode */
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Header icon (Lucide name) */
+    headerIcon?: string;
+    /** Page title */
+    pageTitle?: string;
+    /** Page name (defaults to "{Entity}CollisionPage") */
+    pageName?: string;
+    /** Route path (defaults to "/{entities}/collision") */
+    pagePath?: string;
+    /** Whether this is the initial/home page */
+    isInitial?: boolean;
+}
+declare function stdCollisionEntity(params: StdCollisionParams): Entity;
+declare function stdCollisionTrait(params: StdCollisionParams): Trait;
+declare function stdCollisionPage(params: StdCollisionParams): Page;
+declare function stdCollision(params: StdCollisionParams): OrbitalDefinition;
+
+/**
+ * std-physics2d as a Function
+ *
+ * 2D physics simulation parameterized for any domain.
+ * Provides idle and simulating states with force application and tick updates.
+ * Tracks position and velocity via entity fields.
+ * The state machine structure is fixed. The caller controls data and presentation.
+ *
+ * @level atom
+ * @family physics2d
+ * @packageDocumentation
+ */
+
+interface StdPhysics2dParams {
+    /** Entity name in PascalCase (e.g., "Body", "Particle") */
+    entityName: string;
+    /** Entity fields (id is auto-added) */
+    fields: EntityField[];
+    /** Persistence mode */
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Header icon (Lucide name) */
+    headerIcon?: string;
+    /** Page title */
+    pageTitle?: string;
+    /** Page name (defaults to "{Entity}PhysicsPage") */
+    pageName?: string;
+    /** Route path (defaults to "/{entities}/physics") */
+    pagePath?: string;
+    /** Whether this is the initial/home page */
+    isInitial?: boolean;
+}
+declare function stdPhysics2dEntity(params: StdPhysics2dParams): Entity;
+declare function stdPhysics2dTrait(params: StdPhysics2dParams): Trait;
+declare function stdPhysics2dPage(params: StdPhysics2dParams): Page;
+declare function stdPhysics2d(params: StdPhysics2dParams): OrbitalDefinition;
+
+/**
+ * std-rate-limiter as a Function
+ *
+ * Rate limiting parameterized for any domain.
+ * Provides open and throttled states for controlling request frequency.
+ * Tracks request count and throttle status via entity fields.
+ * The state machine structure is fixed. The caller controls data and presentation.
+ *
+ * @level atom
+ * @family rate-limiter
+ * @packageDocumentation
+ */
+
+interface StdRateLimiterParams {
+    /** Entity name in PascalCase (e.g., "Limiter", "Throttle") */
+    entityName: string;
+    /** Entity fields (id is auto-added) */
+    fields: EntityField[];
+    /** Persistence mode */
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Header icon (Lucide name) */
+    headerIcon?: string;
+    /** Page title */
+    pageTitle?: string;
+    /** Page name (defaults to "{Entity}RateLimiterPage") */
+    pageName?: string;
+    /** Route path (defaults to "/{entities}/rate-limiter") */
+    pagePath?: string;
+    /** Whether this is the initial/home page */
+    isInitial?: boolean;
+}
+declare function stdRateLimiterEntity(params: StdRateLimiterParams): Entity;
+declare function stdRateLimiterTrait(params: StdRateLimiterParams): Trait;
+declare function stdRateLimiterPage(params: StdRateLimiterParams): Page;
+declare function stdRateLimiter(params: StdRateLimiterParams): OrbitalDefinition;
+
+/**
+ * std-game-hud
+ *
+ * Heads-up display atom. Renders the `game-hud` pattern
+ * showing health, score, lives, and other stats.
+ *
+ * @level atom
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdGameHudParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Stats to display in the HUD (defaults to all non-id fields) */
+    statFields?: string[];
+    /** HUD position: top-left, top-right, bottom-left, bottom-right */
+    position?: string;
+    /** HUD size */
+    size?: string;
+    /** Transparent background */
+    transparent?: boolean;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdGameHudEntity(params: StdGameHudParams): Entity;
+declare function stdGameHudTrait(params: StdGameHudParams): Trait;
+declare function stdGameHudPage(params: StdGameHudParams): Page;
+declare function stdGameHud(params: StdGameHudParams): OrbitalDefinition;
+
+/**
+ * std-score-board
+ *
+ * Score display atom using the `score-board` pattern.
+ * Shows score, high score, combo, multiplier, level.
+ *
+ * @level atom
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdScoreBoardParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdScoreBoardEntity(params: StdScoreBoardParams): Entity;
+declare function stdScoreBoardTrait(params: StdScoreBoardParams): Trait;
+declare function stdScoreBoardPage(params: StdScoreBoardParams): Page;
+declare function stdScoreBoard(params: StdScoreBoardParams): OrbitalDefinition;
+
+/**
+ * std-game-menu
+ *
+ * Game main menu atom using the `game-menu` pattern.
+ * Shows title, subtitle, and menu options (Start, Options, Credits, etc.).
+ *
+ * @level atom
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdGameMenuParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Game title */
+    gameTitle?: string;
+    /** Game subtitle */
+    subtitle?: string;
+    /** Menu items: each has a label and an event to fire */
+    menuItems?: Array<{
+        label: string;
+        event: string;
+    }>;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdGameMenuEntity(params: StdGameMenuParams): Entity;
+declare function stdGameMenuTrait(params: StdGameMenuParams): Trait;
+declare function stdGameMenuPage(params: StdGameMenuParams): Page;
+declare function stdGameMenu(params: StdGameMenuParams): OrbitalDefinition;
+
+/**
+ * std-game-over-screen
+ *
+ * Game over screen atom using the `game-over-screen` pattern.
+ * Shows final score, high score, and retry/quit actions.
+ *
+ * @level atom
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdGameOverScreenParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    title?: string;
+    message?: string;
+    /** Actions: each has a label and event */
+    actions?: Array<{
+        label: string;
+        event: string;
+    }>;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdGameOverScreenEntity(params: StdGameOverScreenParams): Entity;
+declare function stdGameOverScreenTrait(params: StdGameOverScreenParams): Trait;
+declare function stdGameOverScreenPage(params: StdGameOverScreenParams): Page;
+declare function stdGameOverScreen(params: StdGameOverScreenParams): OrbitalDefinition;
+
+/**
+ * std-dialogue-box
+ *
+ * RPG dialogue atom using the `dialogue-box` pattern.
+ * Shows speaker, portrait, typewriter text, and choices.
+ *
+ * @level atom
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdDialogueBoxParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Typewriter speed in ms per character */
+    typewriterSpeed?: number;
+    /** Position: top, bottom, center */
+    position?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdDialogueBoxEntity(params: StdDialogueBoxParams): Entity;
+declare function stdDialogueBoxTrait(params: StdDialogueBoxParams): Trait;
+declare function stdDialogueBoxPage(params: StdDialogueBoxParams): Page;
+declare function stdDialogueBox(params: StdDialogueBoxParams): OrbitalDefinition;
+
+/**
+ * std-inventory-panel
+ *
+ * Grid-based inventory atom using the `inventory-panel` pattern.
+ * Shows items in a grid with select, use, and drop actions.
+ *
+ * @level atom
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdInventoryPanelParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Number of columns in inventory grid */
+    columns?: number;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdInventoryPanelEntity(params: StdInventoryPanelParams): Entity;
+declare function stdInventoryPanelTrait(params: StdInventoryPanelParams): Trait;
+declare function stdInventoryPanelPage(params: StdInventoryPanelParams): Page;
+declare function stdInventoryPanel(params: StdInventoryPanelParams): OrbitalDefinition;
+
+/**
+ * std-combat-log
+ *
+ * Scrollable combat event log atom using the `combat-log` pattern.
+ * Displays timestamped combat events with icons and colors.
+ * Supports appending new events and clearing the log.
+ *
+ * @level atom
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdCombatLogParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Log panel title */
+    title?: string;
+    /** Maximum visible events before scrolling */
+    maxVisible?: number;
+    /** Auto-scroll to newest event */
+    autoScroll?: boolean;
+    /** Show timestamps on each entry */
+    showTimestamps?: boolean;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdCombatLogEntity(params: StdCombatLogParams): Entity;
+declare function stdCombatLogTrait(params: StdCombatLogParams): Trait;
+declare function stdCombatLogPage(params: StdCombatLogParams): Page;
+declare function stdCombatLog(params: StdCombatLogParams): OrbitalDefinition;
+
+/**
+ * std-sprite
+ *
+ * Sprite renderer atom using the `sprite` pattern.
+ * Renders a single frame from a spritesheet with position and scale.
+ * Handles frame changes and click events.
+ *
+ * @level atom
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdSpriteParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Width of each frame in pixels */
+    frameWidth?: number;
+    /** Height of each frame in pixels */
+    frameHeight?: number;
+    /** Scale factor */
+    scale?: number;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdSpriteEntity(params: StdSpriteParams): Entity;
+declare function stdSpriteTrait(params: StdSpriteParams): Trait;
+declare function stdSpritePage(params: StdSpriteParams): Page;
+declare function stdSprite(params: StdSpriteParams): OrbitalDefinition;
+
+/**
+ * std-game-audio
+ *
+ * Game audio provider atom using the `game-audio-provider` pattern.
+ * Wraps child content with an audio context, providing sound playback
+ * and mute toggling.
+ *
+ * @level atom
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdGameAudioParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Initial muted state */
+    initialMuted?: boolean;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdGameAudioEntity(params: StdGameAudioParams): Entity;
+declare function stdGameAudioTrait(params: StdGameAudioParams): Trait;
+declare function stdGameAudioPage(params: StdGameAudioParams): Page;
+declare function stdGameAudio(params: StdGameAudioParams): OrbitalDefinition;
+
+/**
+ * std-isometric-canvas
+ *
+ * Isometric game renderer atom using the `isometric-canvas` pattern.
+ * Renders tiles, units, and features on an isometric grid.
+ * Handles tile clicks, unit clicks, and hover events.
+ *
+ * @level atom
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdIsometricCanvasParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Board width in tiles */
+    boardWidth?: number;
+    /** Board height in tiles */
+    boardHeight?: number;
+    /** Render scale */
+    scale?: number;
+    /** Unit render scale */
+    unitScale?: number;
+    /** Show debug grid */
+    debug?: boolean;
+    /** Show minimap */
+    showMinimap?: boolean;
+    /** Enable camera controls */
+    enableCamera?: boolean;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdIsometricCanvasEntity(params: StdIsometricCanvasParams): Entity;
+declare function stdIsometricCanvasTrait(params: StdIsometricCanvasParams): Trait;
+declare function stdIsometricCanvasPage(params: StdIsometricCanvasParams): Page;
+declare function stdIsometricCanvas(params: StdIsometricCanvasParams): OrbitalDefinition;
+
+/**
+ * std-platformer-canvas
+ *
+ * Side-scrolling platformer atom using the `platformer-canvas` pattern.
+ * Renders player, platforms, and handles movement events.
+ *
+ * @level atom
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdPlatformerCanvasParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Canvas width */
+    canvasWidth?: number;
+    /** Canvas height */
+    canvasHeight?: number;
+    /** World width (scrollable area) */
+    worldWidth?: number;
+    /** World height */
+    worldHeight?: number;
+    /** Follow camera enabled */
+    followCamera?: boolean;
+    /** Background color */
+    bgColor?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdPlatformerCanvasEntity(params: StdPlatformerCanvasParams): Entity;
+declare function stdPlatformerCanvasTrait(params: StdPlatformerCanvasParams): Trait;
+declare function stdPlatformerCanvasPage(params: StdPlatformerCanvasParams): Page;
+declare function stdPlatformerCanvas(params: StdPlatformerCanvasParams): OrbitalDefinition;
+
+/**
+ * std-simulation-canvas
+ *
+ * 2D physics simulation renderer atom using the `simulation-canvas` pattern.
+ * Runs built-in Euler integration for educational presets (pendulum, spring, etc.).
+ * Supports start, stop, and reset controls.
+ *
+ * @level atom
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdSimulationCanvasParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Physics preset name */
+    preset?: string;
+    /** Canvas width in pixels */
+    width?: number;
+    /** Canvas height in pixels */
+    height?: number;
+    /** Simulation speed multiplier */
+    speed?: number;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdSimulationCanvasEntity(params: StdSimulationCanvasParams): Entity;
+declare function stdSimulationCanvasTrait(params: StdSimulationCanvasParams): Trait;
+declare function stdSimulationCanvasPage(params: StdSimulationCanvasParams): Page;
+declare function stdSimulationCanvas(params: StdSimulationCanvasParams): OrbitalDefinition;
+
+/**
+ * std-game-canvas-2d
+ *
+ * 2D game canvas atom using the `game-canvas2-d` pattern.
+ * Provides a render loop with configurable FPS, width, and height.
+ * Handles init, start, stop, and per-frame tick events.
+ *
+ * @level atom
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdGameCanvas2dParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Canvas width in pixels */
+    width?: number;
+    /** Canvas height in pixels */
+    height?: number;
+    /** Target frames per second */
+    fps?: number;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdGameCanvas2dEntity(params: StdGameCanvas2dParams): Entity;
+declare function stdGameCanvas2dTrait(params: StdGameCanvas2dParams): Trait;
+declare function stdGameCanvas2dPage(params: StdGameCanvas2dParams): Page;
+declare function stdGameCanvas2d(params: StdGameCanvas2dParams): OrbitalDefinition;
+
+/**
+ * std-game-canvas-3d
+ *
+ * 3D game canvas atom using the `game-canvas3-d` pattern.
+ * Renders tiles, units, and features in a 3D scene with configurable
+ * orientation, camera mode, grid, shadows, and background color.
+ *
+ * @level atom
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdGameCanvas3dParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    /** Map orientation */
+    orientation?: string;
+    /** Camera mode */
+    cameraMode?: string;
+    /** Show grid overlay */
+    showGrid?: boolean;
+    /** Enable shadows */
+    shadows?: boolean;
+    /** Background color */
+    backgroundColor?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdGameCanvas3dEntity(params: StdGameCanvas3dParams): Entity;
+declare function stdGameCanvas3dTrait(params: StdGameCanvas3dParams): Trait;
+declare function stdGameCanvas3dPage(params: StdGameCanvas3dParams): Page;
+declare function stdGameCanvas3d(params: StdGameCanvas3dParams): OrbitalDefinition;
+
+/**
+ * std-turn-based-battle
+ *
+ * Turn-based strategy game molecule (Fire Emblem, XCOM style).
+ * Composes game atoms into a two-trait orbital:
+ *
+ * 1. BattleFlow trait (primary): menu -> playing -> paused -> gameover
+ *    Renders game-menu, game-hud + combat-log, game-over-screen per state.
+ * 2. BattleLog trait (secondary): idle state, combat-log pattern.
+ *    Only renders when LOG_EVENT fires from the shared event bus.
+ *
+ * Composition pattern: extractTrait from atom orbitals, assemble into
+ * one orbital with one shared entity and one page.
+ *
+ * @level molecule
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdTurnBasedBattleParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    gameTitle?: string;
+    boardWidth?: number;
+    boardHeight?: number;
+    menuSubtitle?: string;
+    pauseTitle?: string;
+    gameoverTitle?: string;
+    logTitle?: string;
+    logMaxVisible?: number;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdTurnBasedBattleEntity(params: StdTurnBasedBattleParams): Entity;
+declare function stdTurnBasedBattleTrait(params: StdTurnBasedBattleParams): Trait;
+declare function stdTurnBasedBattlePage(params: StdTurnBasedBattleParams): Page;
+declare function stdTurnBasedBattle(params: StdTurnBasedBattleParams): OrbitalDefinition;
+
+/**
+ * std-platformer-game
+ *
+ * Side-scrolling platformer game molecule.
+ * Composes game atoms into a two-trait orbital:
+ *
+ * 1. PlatformerFlow trait (primary): menu -> playing -> paused -> gameover
+ *    Renders game-menu, platformer-canvas, game-over-screen per state.
+ * 2. PlatformerCanvas trait (secondary): extracted from stdPlatformerCanvas,
+ *    INIT render-ui removed (standalone: false pattern) so the flow trait
+ *    owns the main render slot.
+ *
+ * @level molecule
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdPlatformerGameParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    gameTitle?: string;
+    canvasWidth?: number;
+    canvasHeight?: number;
+    menuSubtitle?: string;
+    pauseTitle?: string;
+    gameoverTitle?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdPlatformerGameEntity(params: StdPlatformerGameParams): Entity;
+declare function stdPlatformerGameTrait(params: StdPlatformerGameParams): Trait;
+declare function stdPlatformerGamePage(params: StdPlatformerGameParams): Page;
+declare function stdPlatformerGame(params: StdPlatformerGameParams): OrbitalDefinition;
+
+/**
+ * std-puzzle-game
+ *
+ * Puzzle game molecule.
+ * Composes game atoms into a two-trait orbital:
+ *
+ * 1. PuzzleFlow trait (primary): menu -> playing -> paused -> gameover
+ *    Renders game-menu, game-canvas-2d with score-board, game-over-screen.
+ * 2. PuzzleScore trait (secondary): extracted from stdScoreBoard,
+ *    INIT render-ui removed (standalone: false pattern) so the flow trait
+ *    owns the main render slot.
+ *
+ * @level molecule
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdPuzzleGameParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    gameTitle?: string;
+    width?: number;
+    height?: number;
+    menuSubtitle?: string;
+    pauseTitle?: string;
+    gameoverTitle?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdPuzzleGameEntity(params: StdPuzzleGameParams): Entity;
+declare function stdPuzzleGameTrait(params: StdPuzzleGameParams): Trait;
+declare function stdPuzzleGamePage(params: StdPuzzleGameParams): Page;
+declare function stdPuzzleGame(params: StdPuzzleGameParams): OrbitalDefinition;
+
+/**
+ * std-builder-game
+ *
+ * Educational game molecule: menu -> playing -> complete.
+ * Uses the `builder-board` pattern for the playing state.
+ *
+ * @level molecule
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdBuilderGameParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    gameTitle?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdBuilderGameEntity(params: StdBuilderGameParams): Entity;
+declare function stdBuilderGameTrait(params: StdBuilderGameParams): Trait;
+declare function stdBuilderGamePage(params: StdBuilderGameParams): Page;
+declare function stdBuilderGame(params: StdBuilderGameParams): OrbitalDefinition;
+
+/**
+ * std-classifier-game
+ *
+ * Educational game molecule: menu -> playing -> complete.
+ * Uses the `classifier-board` pattern for the playing state.
+ *
+ * @level molecule
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdClassifierGameParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    gameTitle?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdClassifierGameEntity(params: StdClassifierGameParams): Entity;
+declare function stdClassifierGameTrait(params: StdClassifierGameParams): Trait;
+declare function stdClassifierGamePage(params: StdClassifierGameParams): Page;
+declare function stdClassifierGame(params: StdClassifierGameParams): OrbitalDefinition;
+
+/**
+ * std-sequencer-game
+ *
+ * Educational game molecule: menu -> playing -> complete.
+ * Uses the `sequencer-board` pattern for the playing state.
+ *
+ * @level molecule
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdSequencerGameParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    gameTitle?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdSequencerGameEntity(params: StdSequencerGameParams): Entity;
+declare function stdSequencerGameTrait(params: StdSequencerGameParams): Trait;
+declare function stdSequencerGamePage(params: StdSequencerGameParams): Page;
+declare function stdSequencerGame(params: StdSequencerGameParams): OrbitalDefinition;
+
+/**
+ * std-debugger-game
+ *
+ * Educational game molecule: menu -> playing -> complete.
+ * Uses the `debugger-board` pattern for the playing state.
+ *
+ * @level molecule
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdDebuggerGameParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    gameTitle?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdDebuggerGameEntity(params: StdDebuggerGameParams): Entity;
+declare function stdDebuggerGameTrait(params: StdDebuggerGameParams): Trait;
+declare function stdDebuggerGamePage(params: StdDebuggerGameParams): Page;
+declare function stdDebuggerGame(params: StdDebuggerGameParams): OrbitalDefinition;
+
+/**
+ * std-negotiator-game
+ *
+ * Educational game molecule: menu -> playing -> complete.
+ * Uses the `negotiator-board` pattern for the playing state.
+ *
+ * @level molecule
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdNegotiatorGameParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    gameTitle?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdNegotiatorGameEntity(params: StdNegotiatorGameParams): Entity;
+declare function stdNegotiatorGameTrait(params: StdNegotiatorGameParams): Trait;
+declare function stdNegotiatorGamePage(params: StdNegotiatorGameParams): Page;
+declare function stdNegotiatorGame(params: StdNegotiatorGameParams): OrbitalDefinition;
+
+/**
+ * std-simulator-game
+ *
+ * Educational game molecule: menu -> playing -> complete.
+ * Uses the `simulator-board` pattern for the playing state.
+ *
+ * @level molecule
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdSimulatorGameParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    gameTitle?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdSimulatorGameEntity(params: StdSimulatorGameParams): Entity;
+declare function stdSimulatorGameTrait(params: StdSimulatorGameParams): Trait;
+declare function stdSimulatorGamePage(params: StdSimulatorGameParams): Page;
+declare function stdSimulatorGame(params: StdSimulatorGameParams): OrbitalDefinition;
+
+/**
+ * std-event-handler-game
+ *
+ * Educational game molecule: menu -> playing -> complete.
+ * Uses the `event-handler-board` pattern for the playing state.
+ *
+ * @level molecule
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdEventHandlerGameParams {
+    entityName: string;
+    fields: EntityField[];
+    persistence?: 'persistent' | 'runtime' | 'singleton';
+    collection?: string;
+    gameTitle?: string;
+    pageName?: string;
+    pagePath?: string;
+    isInitial?: boolean;
+}
+declare function stdEventHandlerGameEntity(params: StdEventHandlerGameParams): Entity;
+declare function stdEventHandlerGameTrait(params: StdEventHandlerGameParams): Trait;
+declare function stdEventHandlerGamePage(params: StdEventHandlerGameParams): Page;
+declare function stdEventHandlerGame(params: StdEventHandlerGameParams): OrbitalDefinition;
+
+/**
+ * std-social-feed
+ *
+ * Social feed organism. Composes molecules via compose:
+ * - stdDetail(Post): browse + create + view posts
+ * - stdMessaging(Comment): messaging thread for comments
+ *
+ * Pages: /feed (initial), /messages
+ * Connections: COMMENT event wires posts to comments.
+ *
+ * @level organism
+ * @family social
+ * @packageDocumentation
+ */
+
+interface StdSocialFeedParams {
+    appName?: string;
+    postFields?: EntityField[];
+    commentFields?: EntityField[];
+}
+declare function stdSocialFeed(params: StdSocialFeedParams): OrbitalSchema;
+
+/**
+ * std-lms
+ *
+ * Learning management system organism. Composes molecules via compose:
+ * - stdList(Course): CRUD list of courses
+ * - stdWizard(Enrollment): multi-step enrollment wizard
+ * - stdDisplay(Progress): read-only progress dashboard
+ *
+ * Pages: /courses (initial), /enroll, /progress
+ * Connections: ENROLL (courses->enrollment), COMPLETE_LESSON (enrollment->progress)
+ *
+ * @level organism
+ * @family education
+ * @packageDocumentation
+ */
+
+interface StdLmsParams {
+    appName?: string;
+    courseFields?: EntityField[];
+    enrollmentFields?: EntityField[];
+    progressFields?: EntityField[];
+}
+declare function stdLms(params: StdLmsParams): OrbitalSchema;
+
+/**
+ * std-crm
+ *
+ * Customer relationship management organism. Composes molecules via compose:
+ * - stdList(Contact): CRUD list of contacts
+ * - stdList(Deal): CRUD list of deals
+ * - stdDisplay(Pipeline): read-only pipeline dashboard
+ * - stdMessaging(Note): notes/communication thread
+ *
+ * Pages: /contacts (initial), /deals, /pipeline, /notes
+ * Connections: CONVERT_LEAD (contacts->deals), CLOSE_DEAL (deals->pipeline)
+ *
+ * @level organism
+ * @family business
+ * @packageDocumentation
+ */
+
+interface StdCrmParams {
+    appName?: string;
+    contactFields?: EntityField[];
+    dealFields?: EntityField[];
+    pipelineFields?: EntityField[];
+    noteFields?: EntityField[];
+}
+declare function stdCrm(params: StdCrmParams): OrbitalSchema;
+
+/**
+ * std-hr-portal
+ *
+ * HR portal organism. Composes molecules via compose:
+ * - stdList(Employee): CRUD list of employees
+ * - stdWizard(Onboarding): multi-step onboarding wizard
+ * - stdList(TimeOff): CRUD list of time-off requests
+ * - stdDisplay(OrgChart): read-only org chart dashboard
+ *
+ * Pages: /employees (initial), /onboarding, /timeoff, /org-chart
+ * Connections: ONBOARD (employees->onboarding), APPROVE_LEAVE (timeoff->orgchart)
+ *
+ * @level organism
+ * @family hr
+ * @packageDocumentation
+ */
+
+interface StdHrPortalParams {
+    appName?: string;
+    employeeFields?: EntityField[];
+    onboardingFields?: EntityField[];
+    timeOffFields?: EntityField[];
+    orgChartFields?: EntityField[];
+}
+declare function stdHrPortal(params: StdHrPortalParams): OrbitalSchema;
+
+/**
+ * std-helpdesk
+ *
+ * Helpdesk organism. Composes molecules via compose:
+ * - stdList(Ticket): CRUD list of support tickets
+ * - stdMessaging(Response): messaging thread for ticket responses
+ * - stdDisplay(SupportMetrics): read-only metrics dashboard
+ *
+ * Pages: /tickets (initial), /responses, /metrics
+ * Connections: ASSIGN (tickets->responses), RESOLVE (responses->metrics)
+ *
+ * @level organism
+ * @family support
+ * @packageDocumentation
+ */
+
+interface StdHelpdeskParams {
+    appName?: string;
+    ticketFields?: EntityField[];
+    responseFields?: EntityField[];
+    metricsFields?: EntityField[];
+}
+declare function stdHelpdesk(params: StdHelpdeskParams): OrbitalSchema;
+
+/**
+ * std-ecommerce
+ *
+ * E-commerce organism. Composes molecules via compose:
+ * - stdList(Product): product catalog with CRUD
+ * - stdCart(CartItem): shopping cart with add/remove
+ * - stdWizard(Checkout): checkout wizard
+ * - stdList(OrderRecord): order history
+ *
+ * Cross-orbital connections:
+ * - ADD_TO_CART: ProductBrowse -> CartItemCartBrowse
+ * - CHECKOUT_STARTED: CartItemCartBrowse -> CheckoutWizard
+ * - ORDER_PLACED: CheckoutWizard -> OrderRecordBrowse
+ *
+ * @level organism
+ * @family commerce
+ * @packageDocumentation
+ */
+
+interface StdEcommerceParams {
+    appName?: string;
+    productFields?: EntityField[];
+    cartItemFields?: EntityField[];
+    orderFields?: EntityField[];
+}
+declare function stdEcommerce(params: StdEcommerceParams): OrbitalSchema;
+
+/**
+ * std-healthcare
+ *
+ * Healthcare organism. Composes molecules via compose:
+ * - stdList(Patient): patient registry with CRUD
+ * - stdList(Appointment): appointment management
+ * - stdWizard(IntakeForm): patient intake wizard
+ * - stdDetail(Prescription): prescription browse + view
+ * - stdDisplay(Dashboard): clinic dashboard KPIs
+ *
+ * Cross-orbital connections:
+ * - INTAKE_COMPLETE: IntakeFormWizard -> PatientBrowse
+ * - PRESCRIBE: AppointmentBrowse -> PrescriptionBrowse
+ *
+ * @level organism
+ * @family healthcare
+ * @packageDocumentation
+ */
+
+interface StdHealthcareParams {
+    appName?: string;
+    patientFields?: EntityField[];
+    appointmentFields?: EntityField[];
+    intakeFormFields?: EntityField[];
+    prescriptionFields?: EntityField[];
+    dashboardFields?: EntityField[];
+}
+declare function stdHealthcare(params: StdHealthcareParams): OrbitalSchema;
+
+/**
+ * std-cms
+ *
+ * Content management organism. Composes molecules via compose:
+ * - stdList(Article): article management with CRUD
+ * - stdDetail(MediaAsset): media library browse + view
+ * - stdList(Category): category management
+ *
+ * Cross-orbital connections:
+ * - PUBLISH: ArticleBrowse -> MediaAssetBrowse
+ * - CATEGORIZE: ArticleBrowse -> CategoryBrowse
+ *
+ * @level organism
+ * @family content
+ * @packageDocumentation
+ */
+
+interface StdCmsParams {
+    appName?: string;
+    articleFields?: EntityField[];
+    mediaAssetFields?: EntityField[];
+    categoryFields?: EntityField[];
+}
+declare function stdCms(params: StdCmsParams): OrbitalSchema;
+
+/**
+ * std-project-manager
+ *
+ * Project management organism. Composes molecules via compose:
+ * - stdList(Task): task management with CRUD
+ * - stdList(Sprint): sprint management with CRUD
+ * - stdDisplay(Burndown): burndown chart dashboard
+ *
+ * Cross-orbital connections:
+ * - ASSIGN_TASK: SprintBrowse -> TaskBrowse
+ * - COMPLETE_SPRINT: SprintBrowse -> BurndownDisplay
+ *
+ * @level organism
+ * @family productivity
+ * @packageDocumentation
+ */
+
+interface StdProjectManagerParams {
+    appName?: string;
+    taskFields?: EntityField[];
+    sprintFields?: EntityField[];
+    burndownFields?: EntityField[];
+}
+declare function stdProjectManager(params: StdProjectManagerParams): OrbitalSchema;
+
+/**
+ * std-booking-system
+ *
+ * Booking system organism. Composes molecules via compose:
+ * - stdList(Provider): provider directory with CRUD
+ * - stdWizard(Booking): booking wizard
+ * - stdList(Appointment): appointment list with CRUD
+ * - stdDisplay(Schedule): schedule overview dashboard
+ *
+ * Cross-orbital connections:
+ * - BOOK: ProviderBrowse -> BookingWizard
+ * - CONFIRM: BookingWizard -> AppointmentBrowse
+ *
+ * @level organism
+ * @family scheduling
+ * @packageDocumentation
+ */
+
+interface StdBookingSystemParams {
+    appName?: string;
+    providerFields?: EntityField[];
+    bookingFields?: EntityField[];
+    appointmentFields?: EntityField[];
+    scheduleFields?: EntityField[];
+}
+declare function stdBookingSystem(params: StdBookingSystemParams): OrbitalSchema;
+
+/**
+ * std-devops-dashboard
+ *
+ * DevOps monitoring organism.
+ * Composes: stdCircuitBreaker(ServiceNode) + stdDisplay(AlertMetric)
+ *         + stdList(LogEntry) + stdDisplay(SystemMetric)
+ *
+ * Pages: /services (initial), /alerts, /logs, /metrics
+ *
+ * @level organism
+ * @family devops
+ * @packageDocumentation
+ */
+
+interface StdDevopsDashboardParams {
+    serviceNodeFields?: EntityField[];
+    alertMetricFields?: EntityField[];
+    logEntryFields?: EntityField[];
+    systemMetricFields?: EntityField[];
+}
+declare function stdDevopsDashboard(params: StdDevopsDashboardParams): OrbitalSchema;
+
+/**
+ * std-cicd-pipeline
+ *
+ * CI/CD pipeline organism.
+ * Composes: stdList(Build) + stdDisplay(Stage) + stdAsync(Deployment)
+ *
+ * Pages: /builds (initial), /stages, /deploy
+ *
+ * @level organism
+ * @family devops
+ * @packageDocumentation
+ */
+
+interface StdCicdPipelineParams {
+    buildFields?: EntityField[];
+    stageFields?: EntityField[];
+    deploymentFields?: EntityField[];
+}
+declare function stdCicdPipeline(params: StdCicdPipelineParams): OrbitalSchema;
+
+/**
+ * std-api-gateway
+ *
+ * API gateway management organism.
+ * Composes: stdList(Route) + stdCircuitBreaker(Backend) + stdDisplay(Analytics)
+ *
+ * Pages: /routes (initial), /backends, /analytics
+ *
+ * @level organism
+ * @family devops
+ * @packageDocumentation
+ */
+
+interface StdApiGatewayParams {
+    routeFields?: EntityField[];
+    backendFields?: EntityField[];
+    analyticsFields?: EntityField[];
+}
+declare function stdApiGateway(params: StdApiGatewayParams): OrbitalSchema;
+
+/**
+ * std-rpg-game
+ *
+ * RPG game organism.
+ * Composes: stdTurnBasedBattle(BattleState) + stdOverworld(WorldZone)
+ *         + stdInventory(RpgItem) + stdQuest(Mission)
+ *
+ * Pages: /battle, /world (initial), /inventory, /quests
+ * Connections: ENCOUNTER_STARTED (world->battle), LOOT_DROPPED (battle->inventory),
+ *              QUEST_ACCEPTED (world->quests)
+ *
+ * @level organism
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdRpgGameParams {
+    battleStateFields?: EntityField[];
+    worldZoneFields?: EntityField[];
+    rpgItemFields?: EntityField[];
+    missionFields?: EntityField[];
+}
+declare function stdRpgGame(params: StdRpgGameParams): OrbitalSchema;
+
+/**
+ * std-platformer-app
+ *
+ * Platformer game organism.
+ * Composes: stdPlatformerGame(PlatLevel) + stdScoreBoard(PlatScore) + stdInventory(Collectible)
+ *
+ * Pages: /game (initial), /scores, /collectibles
+ *
+ * @level organism
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdPlatformerAppParams {
+    platLevelFields?: EntityField[];
+    platScoreFields?: EntityField[];
+    collectibleFields?: EntityField[];
+}
+declare function stdPlatformerApp(params: StdPlatformerAppParams): OrbitalSchema;
+
+/**
+ * std-puzzle-app
+ *
+ * Puzzle game organism.
+ * Composes: stdPuzzleGame(PuzzleLevel) + stdScoreBoard(PuzzleScore)
+ *
+ * Pages: /puzzle (initial), /scores
+ *
+ * @level organism
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdPuzzleAppParams {
+    puzzleLevelFields?: EntityField[];
+    puzzleScoreFields?: EntityField[];
+}
+declare function stdPuzzleApp(params: StdPuzzleAppParams): OrbitalSchema;
+
+/**
+ * std-strategy-game
+ *
+ * Strategy game organism.
+ * Composes: stdTurnBasedBattle(ArmyBattle) + stdOverworld(Territory) + stdDisplay(Resource)
+ *
+ * Pages: /battle, /map (initial), /resources
+ *
+ * @level organism
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdStrategyGameParams {
+    armyBattleFields?: EntityField[];
+    territoryFields?: EntityField[];
+    resourceFields?: EntityField[];
+}
+declare function stdStrategyGame(params: StdStrategyGameParams): OrbitalSchema;
+
+/**
+ * std-arcade-game
+ *
+ * Arcade game organism.
+ * Composes: stdGameflow(ArcadeState) + stdGameCanvas2d(ArcadeCanvas)
+ *         + stdScoreBoard(ArcadeScore) + stdGameHud(ArcadeHud)
+ *
+ * Pages: /game (initial), /scores
+ *
+ * @level organism
+ * @family game
+ * @packageDocumentation
+ */
+
+interface StdArcadeGameParams {
+    arcadeStateFields?: EntityField[];
+    arcadeCanvasFields?: EntityField[];
+    arcadeScoreFields?: EntityField[];
+    arcadeHudFields?: EntityField[];
+}
+declare function stdArcadeGame(params: StdArcadeGameParams): OrbitalSchema;
+
+/**
+ * std-coding-academy
+ *
+ * Coding academy organism.
+ * Composes: stdSequencerGame(SeqChallenge) + stdBuilderGame(BuildChallenge)
+ *         + stdEventHandlerGame(EventChallenge) + stdDisplay(StudentProgress)
+ *
+ * Pages: /sequencer (initial), /builder, /events, /progress
+ *
+ * @level organism
+ * @family educational
+ * @packageDocumentation
+ */
+
+interface StdCodingAcademyParams {
+    seqChallengeFields?: EntityField[];
+    buildChallengeFields?: EntityField[];
+    eventChallengeFields?: EntityField[];
+    studentProgressFields?: EntityField[];
+}
+declare function stdCodingAcademy(params: StdCodingAcademyParams): OrbitalSchema;
+
+/**
+ * std-stem-lab
+ *
+ * STEM lab organism.
+ * Composes: stdSimulatorGame(Experiment) + stdClassifierGame(Classification)
+ *         + stdDisplay(LabResult)
+ *
+ * Pages: /simulator (initial), /classifier, /results
+ *
+ * @level organism
+ * @family educational
+ * @packageDocumentation
+ */
+
+interface StdStemLabParams {
+    experimentFields?: EntityField[];
+    classificationFields?: EntityField[];
+    labResultFields?: EntityField[];
+}
+declare function stdStemLab(params: StdStemLabParams): OrbitalSchema;
+
+/**
+ * std-logic-training
+ *
+ * Logic training organism.
+ * Composes: stdDebuggerGame(DebugChallenge) + stdNegotiatorGame(NegotiateChallenge)
+ *         + stdScoreBoard(TrainingScore)
+ *
+ * Pages: /debugger (initial), /negotiator, /scores
+ *
+ * @level organism
+ * @family educational
+ * @packageDocumentation
+ */
+
+interface StdLogicTrainingParams {
+    debugChallengeFields?: EntityField[];
+    negotiateChallengeFields?: EntityField[];
+    trainingScoreFields?: EntityField[];
+}
+declare function stdLogicTraining(params: StdLogicTrainingParams): OrbitalSchema;
+
+/**
+ * std-iot-dashboard
+ *
+ * IoT dashboard organism.
+ * Composes: stdDisplay(SensorReading) + stdList(Device) + stdCircuitBreaker(DeviceAlert)
+ *
+ * Pages: /sensors (initial), /devices, /alerts
+ *
+ * @level organism
+ * @family iot
+ * @packageDocumentation
+ */
+
+interface StdIotDashboardParams {
+    sensorReadingFields?: EntityField[];
+    deviceFields?: EntityField[];
+    deviceAlertFields?: EntityField[];
+}
+declare function stdIotDashboard(params: StdIotDashboardParams): OrbitalSchema;
+
+/**
+ * std-realtime-chat
+ *
+ * Realtime chat organism.
+ * Composes: stdMessaging(ChatMessage) + stdList(Channel) + stdDisplay(OnlineUser)
+ *
+ * Pages: /chat (initial), /channels, /online
+ *
+ * @level organism
+ * @family communication
+ * @packageDocumentation
+ */
+
+interface StdRealtimeChatParams {
+    chatMessageFields?: EntityField[];
+    channelFields?: EntityField[];
+    onlineUserFields?: EntityField[];
+}
+declare function stdRealtimeChat(params: StdRealtimeChatParams): OrbitalSchema;
+
+/**
+ * std-finance-tracker
+ *
+ * Finance tracker organism.
+ * Composes: stdList(Transaction) + stdDisplay(FinanceSummary) + stdDetail(FinanceReport)
+ *
+ * Pages: /transactions (initial), /summary, /reports
+ *
+ * @level organism
+ * @family finance
+ * @packageDocumentation
+ */
+
+interface StdFinanceTrackerParams {
+    transactionFields?: EntityField[];
+    financeSummaryFields?: EntityField[];
+    financeReportFields?: EntityField[];
+}
+declare function stdFinanceTracker(params: StdFinanceTrackerParams): OrbitalSchema;
+
+/**
+ * std-trading-dashboard
+ *
+ * Trading dashboard organism.
+ * Composes: stdDisplay(Portfolio) + stdList(TradeOrder) + stdAsync(MarketFeed)
+ *
+ * Pages: /portfolio (initial), /orders, /market
+ *
+ * @level organism
+ * @family finance
+ * @packageDocumentation
+ */
+
+interface StdTradingDashboardParams {
+    portfolioFields?: EntityField[];
+    tradeOrderFields?: EntityField[];
+    marketFeedFields?: EntityField[];
+}
+declare function stdTradingDashboard(params: StdTradingDashboardParams): OrbitalSchema;
+
+export { type StdApiGatewayParams, type StdArcadeGameParams, type StdAsyncParams, type StdBookingSystemParams, type StdBrowseParams, type StdBuilderGameParams, type StdCacheAsideParams, type StdCartParams, type StdCicdPipelineParams, type StdCircuitBreakerParams, type StdClassifierGameParams, type StdCmsParams, type StdCodingAcademyParams, type StdCollisionParams, type StdCombatLogParams, type StdCombatParams, type StdConfirmationParams, type StdCrmParams, type StdDebuggerGameParams, type StdDetailParams, type StdDevopsDashboardParams, type StdDialogueBoxParams, type StdDisplayParams, type StdDrawerParams, type StdEcommerceParams, type StdEventHandlerGameParams, type StdFilterParams, type StdFinanceTrackerParams, type StdGameAudioParams, type StdGameCanvas2dParams, type StdGameCanvas3dParams, type StdGameHudParams, type StdGameMenuParams, type StdGameOverScreenParams, type StdGameflowParams, type StdGeospatialParams, type StdHealthcareParams, type StdHelpdeskParams, type StdHrPortalParams, type StdInputParams, type StdInventoryPanelParams, type StdInventoryParams, type StdIotDashboardParams, type StdIsometricCanvasParams, type StdListParams, type StdLmsParams, type StdLoadingParams, type StdLogicTrainingParams, type StdMessagingParams, type StdModalParams, type StdMovementParams, type StdNegotiatorGameParams, type StdNotificationParams, type StdOverworldParams, type StdPaginationParams, type StdPhysics2dParams, type StdPlatformerAppParams, type StdPlatformerCanvasParams, type StdPlatformerGameParams, type StdProjectManagerParams, type StdPuzzleAppParams, type StdPuzzleGameParams, type StdQuestParams, type StdRateLimiterParams, type StdRealtimeChatParams, type StdRpgGameParams, type StdScoreBoardParams, type StdScoreParams, type StdSearchParams, type StdSelectionParams, type StdSequencerGameParams, type StdSimulationCanvasParams, type StdSimulatorGameParams, type StdSocialFeedParams, type StdSortParams, type StdSpriteParams, type StdStemLabParams, type StdStrategyGameParams, type StdTabsParams, type StdTimerParams, type StdTradingDashboardParams, type StdTurnBasedBattleParams, type StdUndoParams, type StdWizardParams, stdApiGateway, stdArcadeGame, stdAsync, stdAsyncEntity, stdAsyncPage, stdAsyncTrait, stdBookingSystem, stdBrowse, stdBrowseEntity, stdBrowsePage, stdBrowseTrait, stdBuilderGame, stdBuilderGameEntity, stdBuilderGamePage, stdBuilderGameTrait, stdCacheAside, stdCacheAsideEntity, stdCacheAsidePage, stdCacheAsideTrait, stdCart, stdCartEntity, stdCartPage, stdCartTrait, stdCicdPipeline, stdCircuitBreaker, stdCircuitBreakerEntity, stdCircuitBreakerPage, stdCircuitBreakerTrait, stdClassifierGame, stdClassifierGameEntity, stdClassifierGamePage, stdClassifierGameTrait, stdCms, stdCodingAcademy, stdCollision, stdCollisionEntity, stdCollisionPage, stdCollisionTrait, stdCombat, stdCombatEntity, stdCombatLog, stdCombatLogEntity, stdCombatLogPage, stdCombatLogTrait, stdCombatPage, stdCombatTrait, stdConfirmation, stdConfirmationEntity, stdConfirmationPage, stdConfirmationTrait, stdCrm, stdDebuggerGame, stdDebuggerGameEntity, stdDebuggerGamePage, stdDebuggerGameTrait, stdDetail, stdDetailEntity, stdDetailPage, stdDetailTrait, stdDevopsDashboard, stdDialogueBox, stdDialogueBoxEntity, stdDialogueBoxPage, stdDialogueBoxTrait, stdDisplay, stdDisplayEntity, stdDisplayPage, stdDisplayTrait, stdDrawer, stdDrawerEntity, stdDrawerPage, stdDrawerTrait, stdEcommerce, stdEventHandlerGame, stdEventHandlerGameEntity, stdEventHandlerGamePage, stdEventHandlerGameTrait, stdFilter, stdFilterEntity, stdFilterPage, stdFilterTrait, stdFinanceTracker, stdGameAudio, stdGameAudioEntity, stdGameAudioPage, stdGameAudioTrait, stdGameCanvas2d, stdGameCanvas2dEntity, stdGameCanvas2dPage, stdGameCanvas2dTrait, stdGameCanvas3d, stdGameCanvas3dEntity, stdGameCanvas3dPage, stdGameCanvas3dTrait, stdGameHud, stdGameHudEntity, stdGameHudPage, stdGameHudTrait, stdGameMenu, stdGameMenuEntity, stdGameMenuPage, stdGameMenuTrait, stdGameOverScreen, stdGameOverScreenEntity, stdGameOverScreenPage, stdGameOverScreenTrait, stdGameflow, stdGameflowEntity, stdGameflowPage, stdGameflowTrait, stdGeospatial, stdGeospatialEntity, stdGeospatialPage, stdGeospatialTrait, stdHealthcare, stdHelpdesk, stdHrPortal, stdInput, stdInputEntity, stdInputPage, stdInputTrait, stdInventory, stdInventoryEntity, stdInventoryPage, stdInventoryPanel, stdInventoryPanelEntity, stdInventoryPanelPage, stdInventoryPanelTrait, stdInventoryTrait, stdIotDashboard, stdIsometricCanvas, stdIsometricCanvasEntity, stdIsometricCanvasPage, stdIsometricCanvasTrait, stdList, stdListEntity, stdListPage, stdListTrait, stdLms, stdLoading, stdLoadingEntity, stdLoadingPage, stdLoadingTrait, stdLogicTraining, stdMessaging, stdMessagingEntity, stdMessagingPage, stdMessagingTrait, stdModal, stdModalEntity, stdModalPage, stdModalTrait, stdMovement, stdMovementEntity, stdMovementPage, stdMovementTrait, stdNegotiatorGame, stdNegotiatorGameEntity, stdNegotiatorGamePage, stdNegotiatorGameTrait, stdNotification, stdNotificationEntity, stdNotificationPage, stdNotificationTrait, stdOverworld, stdOverworldEntity, stdOverworldPage, stdOverworldTrait, stdPagination, stdPaginationEntity, stdPaginationPage, stdPaginationTrait, stdPhysics2d, stdPhysics2dEntity, stdPhysics2dPage, stdPhysics2dTrait, stdPlatformerApp, stdPlatformerCanvas, stdPlatformerCanvasEntity, stdPlatformerCanvasPage, stdPlatformerCanvasTrait, stdPlatformerGame, stdPlatformerGameEntity, stdPlatformerGamePage, stdPlatformerGameTrait, stdProjectManager, stdPuzzleApp, stdPuzzleGame, stdPuzzleGameEntity, stdPuzzleGamePage, stdPuzzleGameTrait, stdQuest, stdQuestEntity, stdQuestPage, stdQuestTrait, stdRateLimiter, stdRateLimiterEntity, stdRateLimiterPage, stdRateLimiterTrait, stdRealtimeChat, stdRpgGame, stdScore, stdScoreBoard, stdScoreBoardEntity, stdScoreBoardPage, stdScoreBoardTrait, stdScoreEntity, stdScorePage, stdScoreTrait, stdSearch, stdSearchEntity, stdSearchPage, stdSearchTrait, stdSelection, stdSelectionEntity, stdSelectionPage, stdSelectionTrait, stdSequencerGame, stdSequencerGameEntity, stdSequencerGamePage, stdSequencerGameTrait, stdSimulationCanvas, stdSimulationCanvasEntity, stdSimulationCanvasPage, stdSimulationCanvasTrait, stdSimulatorGame, stdSimulatorGameEntity, stdSimulatorGamePage, stdSimulatorGameTrait, stdSocialFeed, stdSort, stdSortEntity, stdSortPage, stdSortTrait, stdSprite, stdSpriteEntity, stdSpritePage, stdSpriteTrait, stdStemLab, stdStrategyGame, stdTabs, stdTabsEntity, stdTabsPage, stdTabsTrait, stdTimer, stdTimerEntity, stdTimerPage, stdTimerTrait, stdTradingDashboard, stdTurnBasedBattle, stdTurnBasedBattleEntity, stdTurnBasedBattlePage, stdTurnBasedBattleTrait, stdUndo, stdUndoEntity, stdUndoPage, stdUndoTrait, stdWizard, stdWizardEntity, stdWizardPage, stdWizardTrait };