@almadar/std 5.2.2 → 5.3.0

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."
+}

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

@@ -1,7 +1,6 @@
 {
-  "name": "std-quest",
+  "name": "QuestLogOrbital",
   "version": "1.0.0",
-  "description": "Quest/objective tracking behavior: available, active, complete, failed. Pure function: params in, OrbitalDefinition out.",
   "orbitals": [
     {
       "name": "QuestLogOrbital",
@@ -664,6 +663,10 @@
                         }
                       ]
                     }
+                  ],
+                  [
+                    "notify",
+                    "QuestLog updated successfully"
                   ]
                 ]
               },
@@ -1249,5 +1252,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Quest/objective tracking behavior: available, active, complete, failed. 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-rate-limiter.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-rate-limiter",
+  "name": "RateBucketOrbital",
   "version": "1.0.0",
-  "description": "std-rate-limiter as a Function",
   "orbitals": [
     {
       "name": "RateBucketOrbital",
@@ -889,5 +888,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "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. (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-rating.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-rating",
+  "name": "ReviewOrbital",
   "version": "1.0.0",
-  "description": "Rating atom with star-rating input and display. Absorbs: star-rating.",
   "orbitals": [
     {
       "name": "ReviewOrbital",
@@ -325,5 +324,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Rating atom with star-rating input and display. Absorbs: star-rating. (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-score-board.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-score-board",
+  "name": "ScoreBoardEntryOrbital",
   "version": "1.0.0",
-  "description": "Score display atom using the `score-board` pattern. Shows score, high score, combo, multiplier, level.",
   "orbitals": [
     {
       "name": "ScoreBoardEntryOrbital",
@@ -241,5 +240,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Score display atom using the `score-board` pattern. Shows score, high score, combo, multiplier, level. (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-score.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-score",
+  "name": "ScoreEntryOrbital",
   "version": "1.0.0",
-  "description": "std-score as a Function",
   "orbitals": [
     {
       "name": "ScoreEntryOrbital",
@@ -705,5 +704,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "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. (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-search.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-search",
+  "name": "SearchResultOrbital",
   "version": "1.0.0",
-  "description": "std-search as a Function",
   "orbitals": [
     {
       "name": "SearchResultOrbital",
@@ -386,5 +385,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "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. (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-selection.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-selection",
+  "name": "SelectableItemOrbital",
   "version": "1.0.0",
-  "description": "std-selection as a Function",
   "orbitals": [
     {
       "name": "SelectableItemOrbital",
@@ -802,5 +801,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "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. (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-service-custom-bearer.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-service-custom-bearer",
+  "name": "ServiceCustomBearerOrbital",
   "version": "1.0.0",
-  "description": "Custom REST API behavior with Bearer token authentication. Tests the schema-level service declaration pattern with bearer auth. Pure function: params in, OrbitalDefinition out.",
   "orbitals": [
     {
       "name": "ServiceCustomBearerOrbital",
@@ -541,7 +540,19 @@
             }
           ]
         }
+      ],
+      "services": [
+        {
+          "name": "custom-bearer-api",
+          "type": "rest",
+          "baseUrl": "https://api.example.com/v2",
+          "auth": {
+            "type": "bearer",
+            "secretEnv": "CUSTOM_BEARER_TOKEN"
+          }
+        }
       ]
     }
-  ]
-}
+  ],
+  "description": "Custom REST API behavior with Bearer token authentication. Tests the schema-level service declaration pattern with bearer auth. 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-service-custom-header.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-service-custom-header",
+  "name": "ServiceCustomHeaderOrbital",
   "version": "1.0.0",
-  "description": "Custom REST API behavior with header-based API key authentication. Tests the schema-level service declaration pattern (no pre-built integration). Pure function: params in, OrbitalDefinition out.",
   "orbitals": [
     {
       "name": "ServiceCustomHeaderOrbital",
@@ -541,7 +540,21 @@
             }
           ]
         }
+      ],
+      "services": [
+        {
+          "name": "custom-header-api",
+          "type": "rest",
+          "baseUrl": "https://api.example.com/v1",
+          "auth": {
+            "type": "api-key",
+            "keyName": "X-API-Key",
+            "location": "header",
+            "secretEnv": "CUSTOM_API_SECRET"
+          }
+        }
       ]
     }
-  ]
-}
+  ],
+  "description": "Custom REST API behavior with header-based API key authentication. Tests the schema-level service declaration pattern (no pre-built integration). 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-service-custom-noauth.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-service-custom-noauth",
+  "name": "ServiceCustomNoauthOrbital",
   "version": "1.0.0",
-  "description": "Custom REST API behavior with no authentication. Tests the schema-level service declaration pattern for public APIs. Pure function: params in, OrbitalDefinition out.",
   "orbitals": [
     {
       "name": "ServiceCustomNoauthOrbital",
@@ -541,7 +540,15 @@
             }
           ]
         }
+      ],
+      "services": [
+        {
+          "name": "custom-noauth-api",
+          "type": "rest",
+          "baseUrl": "https://api.example.com/v4"
+        }
       ]
     }
-  ]
-}
+  ],
+  "description": "Custom REST API behavior with no authentication. Tests the schema-level service declaration pattern for public APIs. 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-service-custom-query.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-service-custom-query",
+  "name": "ServiceCustomQueryOrbital",
   "version": "1.0.0",
-  "description": "Custom REST API behavior with query-string API key authentication. Tests the schema-level service declaration pattern with query-based auth. Pure function: params in, OrbitalDefinition out.",
   "orbitals": [
     {
       "name": "ServiceCustomQueryOrbital",
@@ -541,7 +540,21 @@
             }
           ]
         }
+      ],
+      "services": [
+        {
+          "name": "custom-query-api",
+          "type": "rest",
+          "baseUrl": "https://api.example.com/v3",
+          "auth": {
+            "type": "api-key",
+            "keyName": "api_key",
+            "location": "query",
+            "secretEnv": "CUSTOM_QUERY_KEY"
+          }
+        }
       ]
     }
-  ]
-}
+  ],
+  "description": "Custom REST API behavior with query-string API key authentication. Tests the schema-level service declaration pattern with query-based auth. 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-service-email.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-service-email",
+  "name": "ServiceEmailOrbital",
   "version": "1.0.0",
-  "description": "Email service integration behavior: compose, send, track delivery status. Wraps the `email` service with call-service for send operations. Pure function: params in, OrbitalDefinition out.",
   "orbitals": [
     {
       "name": "ServiceEmailOrbital",
@@ -537,5 +536,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Email service integration behavior: compose, send, track delivery status. Wraps the `email` service with call-service for send operations. 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-service-github.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-service-github",
+  "name": "ServiceGithubOrbital",
   "version": "1.0.0",
-  "description": "GitHub service integration behavior: idle, creatingPR, prCreated, error. Wraps the `github` integration (listIssues, createPR) with a PR creation flow. Pure function: params in, OrbitalDefinition out.",
   "orbitals": [
     {
       "name": "ServiceGithubOrbital",
@@ -583,5 +582,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "GitHub service integration behavior: idle, creatingPR, prCreated, error. Wraps the `github` integration (listIssues, createPR) with a PR creation flow. 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-service-llm.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-service-llm",
+  "name": "ServiceLlmOrbital",
   "version": "1.0.0",
-  "description": "LLM service integration behavior: generate, classify, summarize text. Wraps the `llm` integration with 4 actions via separate action events. Pure function: params in, OrbitalDefinition out.",
   "orbitals": [
     {
       "name": "ServiceLlmOrbital",
@@ -668,5 +667,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "LLM service integration behavior: generate, classify, summarize text. Wraps the `llm` integration with 4 actions via separate action events. 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-service-oauth.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-service-oauth",
+  "name": "ServiceOauthOrbital",
   "version": "1.0.0",
-  "description": "OAuth service integration behavior: authorize, token exchange, refresh. Wraps the `oauth` integration with a multi-step authorization flow. Pure function: params in, OrbitalDefinition out.",
   "orbitals": [
     {
       "name": "ServiceOauthOrbital",
@@ -761,5 +760,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "OAuth service integration behavior: authorize, token exchange, refresh. Wraps the `oauth` integration with a multi-step authorization flow. 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-service-redis.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-service-redis",
+  "name": "ServiceRedisOrbital",
   "version": "1.0.0",
-  "description": "Redis cache integration behavior: get, set, delete with TTL support. Wraps the `redis` service with separate events for each operation. Pure function: params in, OrbitalDefinition out.",
   "orbitals": [
     {
       "name": "ServiceRedisOrbital",
@@ -577,5 +576,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Redis cache integration behavior: get, set, delete with TTL support. Wraps the `redis` service with separate events for each operation. 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-service-storage.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-service-storage",
+  "name": "ServiceStorageOrbital",
   "version": "1.0.0",
-  "description": "Storage service integration behavior: upload, download, list, delete files. Wraps the `storage` service with separate events for each operation. Pure function: params in, OrbitalDefinition out.",
   "orbitals": [
     {
       "name": "ServiceStorageOrbital",
@@ -661,5 +660,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Storage service integration behavior: upload, download, list, delete files. Wraps the `storage` service with separate events for each operation. 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-service-stripe.orb

@@ -1,7 +1,6 @@
 {
-  "name": "std-service-stripe",
+  "name": "ServiceStripeOrbital",
   "version": "1.0.0",
-  "description": "Stripe payment integration behavior: idle, creating, confirming, succeeded, error. Wraps the `stripe` service integration with a multi-step payment flow. Pure function: params in, OrbitalDefinition out.",
   "orbitals": [
     {
       "name": "ServiceStripeOrbital",
@@ -636,5 +635,6 @@
         }
       ]
     }
-  ]
-}
+  ],
+  "description": "Stripe payment integration behavior: idle, creating, confirming, succeeded, error. Wraps the `stripe` service integration with a multi-step payment flow. 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."
+}