@almadar/std 5.2.1 → 5.3.0

package/behaviors/exports/atoms/std-cache-aside.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-cache-aside",
+  "name": "CacheEntryOrbital",
   "version": "1.0.0",
-  "description": "Cache management behavior: empty, cached, stale with fetch/invalidate cycle. Pure function: params in, OrbitalDefinition out.",
   "orbitals": [
     {
       "name": "CacheEntryOrbital",
@@ -637,6 +636,10 @@
                         }
                       ]
                     }
+                  ],
+                  [
+                    "notify",
+                    "CacheEntry updated successfully"
                   ]
                 ]
               },
@@ -1089,5 +1092,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Cache management behavior: empty, cached, stale with fetch/invalidate cycle. Pure function: params in, OrbitalDefinition out. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-calendar.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-calendar",
+  "name": "CalendarEventOrbital",
   "version": "1.0.0",
-  "description": "Calendar browsing atom with month/day/slot views. Absorbs: calendar-grid, day-cell, time-slot-cell, date-range-selector.",
   "orbitals": [
     {
       "name": "CalendarEventOrbital",
@@ -767,5 +766,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Calendar browsing atom with month/day/slot views. Absorbs: calendar-grid, day-cell, time-slot-cell, date-range-selector. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-circuit-breaker.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-circuit-breaker",
+  "name": "ServiceNodeOrbital",
   "version": "1.0.0",
-  "description": "Circuit breaker pattern behavior: closed, open, halfOpen. Protects services from cascading failures with automatic recovery. Pure function: params in, OrbitalDefinition out.",
   "orbitals": [
     {
       "name": "ServiceNodeOrbital",
@@ -991,5 +990,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Circuit breaker pattern behavior: closed, open, halfOpen. Protects services from cascading failures with automatic recovery. Pure function: params in, OrbitalDefinition out. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-collision.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-collision",
+  "name": "CollidableBodyOrbital",
   "version": "1.0.0",
-  "description": "std-collision as a Function",
   "orbitals": [
     {
       "name": "CollidableBodyOrbital",
@@ -686,5 +685,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "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. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-combat-log.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-combat-log",
+  "name": "CombatLogEntryOrbital",
   "version": "1.0.0",
-  "description": "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.",
   "orbitals": [
     {
       "name": "CombatLogEntryOrbital",
@@ -260,5 +259,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "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. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-combat.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-combat",
+  "name": "CombatantOrbital",
   "version": "1.0.0",
-  "description": "Attack cycle behavior: ready, attacking, cooldown, defeated. Pure function: params in, OrbitalDefinition out.",
   "orbitals": [
     {
       "name": "CombatantOrbital",
@@ -413,5 +412,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Attack cycle behavior: ready, attacking, cooldown, defeated. Pure function: params in, OrbitalDefinition out. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-confirmation.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-confirmation",
+  "name": "ConfirmActionOrbital",
   "version": "1.0.0",
-  "description": "std-confirmation as a Function",
   "orbitals": [
     {
       "name": "ConfirmActionOrbital",
@@ -492,5 +491,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "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. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-dialogue-box.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-dialogue-box",
+  "name": "DialogueNodeOrbital",
   "version": "1.0.0",
-  "description": "RPG dialogue atom using the `dialogue-box` pattern. Shows speaker, portrait, typewriter text, and choices.",
   "orbitals": [
     {
       "name": "DialogueNodeOrbital",
@@ -241,5 +240,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "RPG dialogue atom using the `dialogue-box` pattern. Shows speaker, portrait, typewriter text, and choices. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-display.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-display",
+  "name": "DisplayItemOrbital",
   "version": "1.0.0",
-  "description": "Read-only display molecule with loading/refresh. Single trait (display is self-contained, no modal atoms needed). Used for dashboards, stats panels, KPIs.",
   "orbitals": [
     {
       "name": "DisplayItemOrbital",
@@ -1650,5 +1649,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Read-only display molecule with loading/refresh. Single trait (display is self-contained, no modal atoms needed). Used for dashboards, stats panels, KPIs. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-drawer.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-drawer",
+  "name": "DrawerContentOrbital",
   "version": "1.0.0",
-  "description": "std-drawer as a Function",
   "orbitals": [
     {
       "name": "DrawerContentOrbital",
@@ -520,5 +519,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "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. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-filter.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-filter",
+  "name": "FilterTargetOrbital",
   "version": "1.0.0",
-  "description": "Filter atom. Shows filter buttons per field with predefined values. Clicking a filter value transitions to filtered state. Clear resets.",
   "orbitals": [
     {
       "name": "FilterTargetOrbital",
@@ -633,5 +632,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Filter atom. Shows filter buttons per field with predefined values. Clicking a filter value transitions to filtered state. Clear resets. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-flip-card.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-flip-card",
+  "name": "FlashcardOrbital",
   "version": "1.0.0",
-  "description": "Flip card atom for flashcard-style front/back content. Absorbs: flip-container, flip-card.",
   "orbitals": [
     {
       "name": "FlashcardOrbital",
@@ -593,5 +592,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Flip card atom for flashcard-style front/back content. Absorbs: flip-container, flip-card. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-gallery.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-gallery",
+  "name": "GalleryItemOrbital",
   "version": "1.0.0",
-  "description": "Image gallery atom with carousel browsing and lightbox viewing. Absorbs: carousel, lightbox.",
   "orbitals": [
     {
       "name": "GalleryItemOrbital",
@@ -379,5 +378,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Image gallery atom with carousel browsing and lightbox viewing. Absorbs: carousel, lightbox. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-game-audio.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-game-audio",
+  "name": "AudioTrackOrbital",
   "version": "1.0.0",
-  "description": "Game audio provider atom using the `game-audio-provider` pattern. Wraps child content with an audio context, providing sound playback and mute toggling.",
   "orbitals": [
     {
       "name": "AudioTrackOrbital",
@@ -342,5 +341,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Game audio provider atom using the `game-audio-provider` pattern. Wraps child content with an audio context, providing sound playback and mute toggling. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-game-canvas2d.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-game-canvas2d",
+  "name": "GameCanvas2dOrbital",
   "version": "1.0.0",
-  "description": "2D game canvas atom using the `game-canvas-2d` pattern. Provides a render loop with configurable FPS, width, and height. Handles init, start, stop, and per-frame tick events.",
   "orbitals": [
     {
       "name": "GameCanvas2dOrbital",
@@ -257,4 +256,4 @@
       ]
     }
   ]
-}
+}

package/behaviors/exports/atoms/std-game-canvas3d.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-game-canvas3d",
+  "name": "Canvas3dSceneOrbital",
   "version": "1.0.0",
-  "description": "3D game canvas atom using the `game-canvas-3d` pattern. Renders tiles, units, and features in a 3D scene with configurable orientation, camera mode, grid, shadows, and background color.",
   "orbitals": [
     {
       "name": "Canvas3dSceneOrbital",
@@ -395,4 +394,4 @@
       ]
     }
   ]
-}
+}

package/behaviors/exports/atoms/std-game-hud.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-game-hud",
+  "name": "HudStateOrbital",
   "version": "1.0.0",
-  "description": "Heads-up display atom. Renders the `game-hud` pattern showing health, score, lives, and other stats.",
   "orbitals": [
     {
       "name": "HudStateOrbital",
@@ -154,5 +153,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Heads-up display atom. Renders the `game-hud` pattern showing health, score, lives, and other stats. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-game-menu.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-game-menu",
+  "name": "MenuStateOrbital",
   "version": "1.0.0",
-  "description": "Game main menu atom using the `game-menu` pattern. Shows title, subtitle, and menu options (Start, Options, Credits, etc.).",
   "orbitals": [
     {
       "name": "MenuStateOrbital",
@@ -214,5 +213,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Game main menu atom using the `game-menu` pattern. Shows title, subtitle, and menu options (Start, Options, Credits, etc.). (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-game-over-screen.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-game-over-screen",
+  "name": "GameOverStateOrbital",
   "version": "1.0.0",
-  "description": "Game over screen atom using the `game-over-screen` pattern. Shows final score, high score, and retry/quit actions.",
   "orbitals": [
     {
       "name": "GameOverStateOrbital",
@@ -198,5 +197,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Game over screen atom using the `game-over-screen` pattern. Shows final score, high score, and retry/quit actions. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-gameflow.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-gameflow",
+  "name": "GameSessionOrbital",
   "version": "1.0.0",
-  "description": "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)",
   "orbitals": [
     {
       "name": "GameSessionOrbital",
@@ -411,5 +410,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "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. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-input.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-input",
+  "name": "TextInputOrbital",
   "version": "1.0.0",
-  "description": "std-input as a Function",
   "orbitals": [
     {
       "name": "TextInputOrbital",
@@ -632,5 +631,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "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. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-inventory-panel.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-inventory-panel",
+  "name": "InventorySlotOrbital",
   "version": "1.0.0",
-  "description": "Grid-based inventory atom using the `inventory-panel` pattern. Shows items in a grid with select, use, and drop actions.",
   "orbitals": [
     {
       "name": "InventorySlotOrbital",
@@ -235,6 +234,10 @@
                       "dropItemEvent": "DROP_ITEM",
                       "showTooltips": true
                     }
+                  ],
+                  [
+                    "notify",
+                    "InventorySlot deleted successfully"
                   ]
                 ]
               }
@@ -254,5 +257,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Grid-based inventory atom using the `inventory-panel` pattern. Shows items in a grid with select, use, and drop actions. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-isometric-canvas.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-isometric-canvas",
+  "name": "IsometricWorldOrbital",
   "version": "1.0.0",
-  "description": "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.",
   "orbitals": [
     {
       "name": "IsometricWorldOrbital",
@@ -634,5 +633,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "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. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-loading.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-loading",
+  "name": "LoadableItemOrbital",
   "version": "1.0.0",
-  "description": "std-loading as a Function",
   "orbitals": [
     {
       "name": "LoadableItemOrbital",
@@ -488,5 +487,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "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. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-modal.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-modal",
+  "name": "ModalRecordOrbital",
   "version": "1.0.0",
-  "description": "Modal overlay atom. Accepts content injection so molecules can control what renders inside the open state.",
   "orbitals": [
     {
       "name": "ModalRecordOrbital",
@@ -417,5 +416,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Modal overlay atom. Accepts content injection so molecules can control what renders inside the open state. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-movement.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-movement",
+  "name": "MovableEntityOrbital",
   "version": "1.0.0",
-  "description": "Entity movement behavior: idle, moving, collision detection and resolution. Pure function: params in, OrbitalDefinition out.",
   "orbitals": [
     {
       "name": "MovableEntityOrbital",
@@ -1405,5 +1404,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Entity movement behavior: idle, moving, collision detection and resolution. Pure function: params in, OrbitalDefinition out. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-notification.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-notification",
+  "name": "NotificationOrbital",
   "version": "1.0.0",
-  "description": "std-notification as a Function",
   "orbitals": [
     {
       "name": "NotificationOrbital",
@@ -438,5 +437,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Notification behavior parameterized for any domain. Provides a show/hide notification display. The state machine structure is fixed. The caller controls data and presentation. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-overworld.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-overworld",
+  "name": "WorldRegionOrbital",
   "version": "1.0.0",
-  "description": "Map/zone navigation behavior: exploring, transitioning, entered. Pure function: params in, OrbitalDefinition out.",
   "orbitals": [
     {
       "name": "WorldRegionOrbital",
@@ -509,5 +508,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Map/zone navigation behavior: exploring, transitioning, entered. Pure function: params in, OrbitalDefinition out. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-pagination.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-pagination",
+  "name": "PagedItemOrbital",
   "version": "1.0.0",
-  "description": "std-pagination as a Function",
   "orbitals": [
     {
       "name": "PagedItemOrbital",
@@ -258,5 +257,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "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. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-physics2d.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-physics2d",
+  "name": "PhysicsBodyOrbital",
   "version": "1.0.0",
-  "description": "std-physics2d as a Function",
   "orbitals": [
     {
       "name": "PhysicsBodyOrbital",
@@ -422,5 +421,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "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. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}

package/behaviors/exports/atoms/std-platformer-canvas.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-platformer-canvas",
+  "name": "PlatformerWorldOrbital",
   "version": "1.0.0",
-  "description": "Side-scrolling platformer atom using the `platformer-canvas` pattern. Renders player, platforms, and handles movement events.",
   "orbitals": [
     {
       "name": "PlatformerWorldOrbital",
@@ -260,5 +259,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Side-scrolling platformer atom using the `platformer-canvas` pattern. Renders player, platforms, and handles movement events. (2026-04-08). The canonical source for std behaviors is now the registry `.orb` file at `packages/almadar-std/behaviors/registry/<level>/<name>.orb`, which is generated from this TS source by `tools/almadar-behavior-ts-to-orb/` and consumed by the compiler's embedded loader. Consumers should import behaviors via `.lolo`/`.orb` `uses` declarations and reference them as `Alias.entity` / `Alias.traits.X` / `Alias.pages.X`, applying overrides at the call site (`linkedEntity`, `name`, `events`, `effects`, `listens`, `emitsScope`). The TS `*Params` interface and the exported factory functions remain ONLY as the authoring path for the converter; they are NOT a stable public API and may change without notice. See `docs/Almadar_Orb_Behaviors.md` for the orbital-as-function model and `docs/LOLO_Gaps.md` for the migration plan."
+}