@almadar/std 16.178.0 → 16.180.0

package/behaviors/lolo/ui/core/atoms/std-detail-layout.lolo

@@ -0,0 +1,82 @@
+app std-detail-layout "1.0.0"
+"std-detail-layout — detail-page chrome band (back button + navigation-stack breadcrumb trail) above a single contentTrait slot. Use as the contentTrait of a detail page's AppShell binding: the band renders `← Back | Contracts › Contract details` from the orbital-scoped client navigation stack (session history, seeded from declared page-path ancestry on cold loads — the trail is never empty), and the consumer's detail trait renders below it. Back pops the stack; crumb clicks navigate to their level; a list router's `(navigate path payload { crumb: ?row.title })` labels the detail crumb with the real record title. Bind once per detail page — `XDetailLayout = DetailShell.traits.DetailLayout` with `contentTrait: @trait.XDetail`."
+;; @capabilities "detail page shell, breadcrumb trail, back navigation, record detail chrome, navigation stack, drill-down hierarchy"
+orbital DetailLayoutOrbital {
+  entity DetailLayoutData [runtime] {
+    id : string!
+  }
+
+  trait DetailLayout -> @rebindable DetailLayoutData [interaction, instance] {
+    initial: composing
+
+    state composing {
+      INIT -> composing
+        (render-ui main {
+          type: stack
+          direction: vertical
+          gap: lg
+          className: "w-full"
+          children: [{
+            type: stack
+            direction: horizontal
+            align: center
+            gap: sm
+            className: "w-full border-b border-border pb-3"
+            children: [{
+              type: button
+              variant: ghost
+              size: sm
+              icon: arrow-left
+              label: @config.backLabel
+              action: BACK
+            }, {
+              type: breadcrumb
+              fromNavStack: true
+              itemEvent: CRUMB_NAV
+            }]
+          },
+          @config.contentTrait]
+        })
+      BACK -> composing
+        (navigate-back)
+      CRUMB_NAV -> composing
+        (navigate ?href)
+    }
+
+    emits {
+      BACK
+        @description "The shell's back affordance was pressed; the layout pops the navigation stack."
+        @synonyms "go back, return, previous page, up one level"
+        @tier "internal"
+      CRUMB_NAV
+        @description "A breadcrumb level was clicked; the layout navigates to that level's href."
+        @synonyms "breadcrumb click, jump to level, trail navigation"
+        @tier "internal"
+    }
+
+    listens {
+      CRUMB_NAV {
+        label : string
+        href : string!
+        index : number
+      }
+        @description "Breadcrumb level picked from the navigation-stack trail."
+        @synonyms "breadcrumb click, trail navigation"
+        @tier "internal"
+    }
+
+    config {
+      contentTrait : trait
+        @label "Content trait"
+        @description "The detail trait rendered below the navigation band (the DetailPanel + sections view)."
+        @tier "presentation"
+      backLabel : string = Back
+        @label "Back button label"
+        @description "Label on the band's back button, e.g. \"Back to contracts\"."
+        @synonyms "back text, return label"
+        @tier "presentation"
+    }
+  }
+
+  page "/detail-layout" as DetailLayoutPage -> DetailLayout
+}

package/behaviors/lolo/ui/core/molecules/ui-breadcrumb.lolo

@@ -21,6 +21,8 @@ orbital BreadcrumbOrbital {
       INIT -> idle
         (render-ui main {
           items: @config.items
+          fromNavStack: @config.fromNavStack
+          itemEvent: @config.itemEvent
           separator: @config.separator
           maxItems: @config.maxItems
           className: @config.className
@@ -28,10 +30,26 @@ orbital BreadcrumbOrbital {
         })
     }
 
+    emits {
+      @config.itemEvent -> external {
+        id : string
+      }
+        @description "Event emitted when a non-current crumb is clicked, with payload `{ label, href, index }` — the trait handles it with `(navigate ?href)`. Without it, stack crumbs navigate directly."
+        @tier "essential"
+    }
+
     config {
-      items : [BreadcrumbItemsItem] = [{ label: "Label", href: "Href", path: "Path", icon: "circle", isCurrent: false }, { label: "Label 2", href: "Href 2", path: "Path 2", icon: "circle", isCurrent: true }]
+      items : [BreadcrumbItemsItem] = []
         @label "Items"
-        @description "Breadcrumb items"
+        @description "Breadcrumb items. Omit together with `fromNavStack` to render the orbital-scoped navigation stack instead of an authored trail."
+        @tier "presentation"
+      fromNavStack : boolean = false
+        @label "From Nav Stack"
+        @description "Render the current orbital's navigation stack (NavStackProvider) as the trail: one crumb per visited/declared level, last entry current. The stack is client-session state both execution paths maintain; outside a provider this renders nothing."
+        @tier "presentation"
+      itemEvent : string = "ITEM"
+        @label "Item Event"
+        @description "Event emitted when a non-current crumb is clicked, with payload `{ label, href, index }` — the trait handles it with `(navigate ?href)`. Without it, stack crumbs navigate directly."
         @tier "presentation"
       separator : icon
         @label "Separator"

package/behaviors/lolo/ui/core/molecules/ui-fx-overlay.lolo

@@ -0,0 +1,63 @@
+app ui-fx-overlay "1.0.0"
+"FxOverlay — UI factory (1:1 with the @almadar/ui fx-overlay pattern)."
+orbital FxOverlayOrbital {
+  type FxOverlayItemsItem = {
+    id : string!
+    type : string!
+    effect : "confetti" | "flash" | "shake" | "sparkle" | "float-text" | "streak-glow"
+    message : string
+    color : string
+    size : number
+    x : number
+    z : number
+    y : number
+    ttl : number!
+    maxTtl : number
+    bornAt : number
+    space : "world" | "screen"
+    particleCount : number
+    vx : number
+    vy : number
+    vz : number
+  }
+
+  entity FxOverlayItem [runtime] {
+    id : string!
+  }
+
+  trait FxOverlayRender -> @rebindable FxOverlayItem [interaction, instance] {
+    initial: idle
+
+    state idle {
+      INIT -> idle
+        (render-ui main {
+          items: @config.items
+          tickMs: @config.tickMs
+          children: @config.children
+          className: @config.className
+          type: fx-overlay
+        })
+    }
+
+    config {
+      items : [FxOverlayItemsItem] = [{ id: "e1", x: 2, y: 2, type: "spawn", message: "Unit spawned" }, { id: "e2", x: 3, y: 1, type: "effect", message: "Attack landed" }]
+        @label "Items"
+        @description "Live screen-space fx entries (the mechanic's fx list filtered to `space == 'screen'`); mount starts each item's animation, ttl decay unmounts it."
+        @tier "presentation"
+      tickMs : number
+        @label "Tick Ms"
+        @description "The fx mechanic's decay tick period in ms; per-item animation duration = maxTtl × tickMs. Default 500."
+        @tier "presentation"
+      children : node
+        @label "Children"
+        @description "Wrapped content — the `shake` target and the overlay's bounds."
+        @tier "presentation"
+      className : string
+        @label "Class Name"
+        @description "Additional class names on the outermost element."
+        @tier "presentation"
+    }
+  }
+
+  page "/fx-overlay" as FxOverlayPage -> FxOverlayRender
+}

package/behaviors/lolo/ui/core/molecules/ui-page-header.lolo

@@ -94,7 +94,7 @@ orbital PageHeaderOrbital {
         @tier "presentation"
       status : PageHeaderStatus
         @label "Status"
-        @description "Status badge"
+        @description "Status badge — a bare string (an entity's status field bound directly, e.g. `status: @entity.status`) renders as a default-variant badge"
         @tier "presentation"
       actions : [PageHeaderActionsItem] = []
         @label "Actions"

package/behaviors/lolo/ui/core/organisms/ui-detail-panel.lolo

@@ -79,6 +79,7 @@ orbital DetailPanelOrbital {
           avatar: @config.avatar
           sections: @config.sections
           actions: @config.actions
+          maxInlineActions: @config.maxInlineActions
           backAction: @config.backAction
           footer: @config.footer
           slideOver: @config.slideOver
@@ -113,6 +114,7 @@ orbital DetailPanelOrbital {
           avatar: @config.avatar
           sections: @config.sections
           actions: @config.actions
+          maxInlineActions: @config.maxInlineActions
           backAction: @config.backAction
           footer: @config.footer
           slideOver: @config.slideOver
@@ -206,6 +208,10 @@ orbital DetailPanelOrbital {
         @label "Actions"
         @description "Unified actions array - first action with variant='primary' is the main action"
         @tier "presentation"
+      maxInlineActions : number
+        @label "Max Inline Actions"
+        @description "Max inline action buttons before the rest collapse into a '⋯' overflow menu (mirrors DataGrid's maxInlineActions). Omit = all inline."
+        @tier "presentation"
       backAction : DetailPanelBackAction
         @label "Back Action"
         @description "Navigation-back affordance. Renders top-LEFT before the title (OS/back convention — Almadar_UX §8.4), spatially separated from the right-aligned action buttons + close X. Never inferred from actions[] labels."

package/behaviors/lolo/ui/core/organisms/ui-form-section.lolo

@@ -69,10 +69,10 @@ orbital FormSectionOrbital {
     message : string!
   }
   type FormSectionEvaluationContext = {
-    formValues : object!
+    formValues : Map string object!
     globalVariables : Map string json!
     localVariables : Map string json
-    entity : object
+    entity : Map string object
   }
   type FormSectionSectionsItem = {
     id : string!

package/behaviors/lolo/ui/core/organisms/ui-form.lolo

@@ -69,10 +69,10 @@ orbital FormOrbital {
     message : string!
   }
   type FormEvaluationContext = {
-    formValues : object!
+    formValues : Map string object!
     globalVariables : Map string json!
     localVariables : Map string json
-    entity : object
+    entity : Map string object
   }
   type FormSectionsItem = {
     id : string!

package/behaviors/lolo/ui/core/templates/ui-dashboard-layout.lolo

@@ -10,7 +10,7 @@ orbital DashboardLayoutOrbital {
   }
   type DashboardLayoutUser = {
     name : string!
-    email : string!
+    email : string
     avatar : asset
   }
   type DashboardLayoutTopBarActionsItem = {
@@ -98,7 +98,7 @@ orbital DashboardLayoutOrbital {
         @tier "presentation"
       user : DashboardLayoutUser
         @label "User"
-        @description "Current user info (optional - auto-populated from auth context if not provided)"
+        @description "Current user info (optional - auto-populated from auth context if not provided). Accepts `null` as well as `undefined`: the `.lolo` substrate's signed-out spelling is `(if @config.viewerName {…} null)`, and the compiled path passes that `null` through verbatim."
         @tier "presentation"
       headerActions : node
         @label "Header Actions"

package/behaviors/lolo/ui/game/atoms/std-fx-particles.lolo

@@ -1,5 +1,5 @@
-app std-fx-particles "1.0.0"
-"Headless floating-text/particle mechanic: decays each fx entry's ttl every tick and drops the dead ones, and appends spawned particles on BURST. Composed onto a [runtime, shared] game entity; renders nothing (the board owns the single render authority)."
+app std-fx-particles "1.1.0"
+"Headless transient-fx mechanic serving BOTH game boards and learning shells: appends spawned particles on BURST — stamping maxTtl (fade envelope) and bornAt (epoch ms, smooth render interpolation) when absent — decays each entry's ttl every tick, drops the dead ones, and clears on RESTART. Name-blind mechanism: the effect-kind vocabulary is consumer-declared (FxPreset tables at the render call sites). Composed onto a [runtime, shared] entity; renders nothing — the board/shell owns the single render authority (draw-fx-layer for space \"world\", fx-overlay for space \"screen\")."
 orbital FxParticlesOrbital {
   type Fx = {
     id : string!
@@ -9,6 +9,16 @@ orbital FxParticlesOrbital {
     y : number
     message : string
     ttl : number!
+    maxTtl : number
+    bornAt : number
+    space : string
+    effect : string
+    color : string
+    size : number
+    vx : number
+    vy : number
+    vz : number
+    particleCount : number
   }
 
   entity FxState [runtime, shared] {
@@ -21,9 +31,17 @@ orbital FxParticlesOrbital {
 
     state active {
       INIT -> active
-        (set @entity.fx @config.fx)
+        (set @entity.fx (array/map @config.fx (fn p (object/merge @p {
+          maxTtl: (if (object/get @p maxTtl) (object/get @p maxTtl) (object/get @p ttl))
+          bornAt: (if (object/get @p bornAt) (object/get @p bornAt) (time/now))
+        }))))
       BURST -> active
-        (set @entity.fx (array/concat @entity.fx @payload.particles))
+        (set @entity.fx (array/concat @entity.fx (array/map @payload.particles (fn p (object/merge @p {
+          maxTtl: (if (object/get @p maxTtl) (object/get @p maxTtl) (object/get @p ttl))
+          bornAt: (if (object/get @p bornAt) (object/get @p bornAt) (time/now))
+        })))))
+      RESTART -> active
+        (set @entity.fx [])
     }
 
     ticks {
@@ -36,6 +54,7 @@ orbital FxParticlesOrbital {
 
     listens {
       BURST { particles : [Fx] }
+      RESTART { }
     }
 
     config {

package/behaviors/lolo/ui/game/atoms/std-platformer-body.lolo

@@ -0,0 +1,251 @@
+app std-platformer-body "1.0.0"
+"Headless run/jump platformer-physics authority: the SOLE writer of body + fell + hazardId + goalId on side-view boards. Where std-motion-body owns free 2D drift (no collision), this atom owns the platformer contract: every 33ms physics tick it integrates gravity into the body's vertical velocity, steps position in per-second units, and collides the body rect against the config platforms with one-way semantics — a body moving in the gravity direction that overlaps a ground/platform tile lands on its anti-gravity face (vy zeroed, grounded set), while a body moving against gravity passes through, so jumping up through a platform and walking up a staircase both just work. The sign of gravity IS the vertical convention: positive pulls toward +y (screen boards, y down — sprite canvases), negative toward −y (math canvases, y up); jumps always fire against it. Intents: STEER sets horizontal velocity (dir −1/0/1 × moveSpeed, hold-to-run: keydown steers, keyup steers 0), JUMP kicks vertical velocity when grounded, PLACE teleports (spawns, hazard respawns), RESTART reseeds. Emits BODY_MOVED every tick for the render layer (boards that don't subscribe pay nothing), plus the sparse rule signals a board needs to score: BODY_JUMPED, BODY_LANDED (with impact speed), BODY_HAZARD (once per hazard entry, re-arms on exit), BODY_GOAL (same arming), BODY_FELL (once per fall past killY, re-armed by PLACE/RESTART). Curve skating: when config.skate is on and the grounded body comes within skateSnap of the config.skateCurve surface, the body rides the curve — y snaps to the interpolated surface and tangential gravity (g·slope/(1+slope²)) accelerates vx, so the body slides downhill along the graph itself and launches ballistically off its ends; jumping kicks free. Sparse BODY_SKATE_START/BODY_SKATE_END signals fire on engage/disengage so boards can layer fx. Lives, score, and win/lose stay downstream — this atom simulates, it never judges. Renders nothing."
+orbital PlatformerBodyOrbital {
+  type PlatformerBody = {
+    x : number!
+    y : number!
+    width : number!
+    height : number!
+    vx : number
+    vy : number
+    grounded : boolean
+    facingRight : boolean
+  }
+  type PlatformerPlatform = {
+    id : string
+    x : number!
+    y : number!
+    width : number!
+    height : number!
+    type : "ground" | "platform" | "hazard" | "goal"
+  }
+  type PlatformerCurveSample = {
+    x : number!
+    y : number!
+  }
+
+  entity PlatformerBodyData [runtime, shared] {
+    id : string!
+    body : PlatformerBody = { x: 0, y: 0, width: 1, height: 1, vx: 0, vy: 0, grounded: false, facingRight: true }
+    fell : boolean = false
+    hazardId : string = ""
+    goalId : string = ""
+    skating : boolean = false
+  }
+
+  trait PlatformerBody -> @rebindable PlatformerBodyData [lifecycle] {
+    initial: active
+
+    state active {
+      INIT -> active
+        (set @entity.body @config.spawn)
+        (set @entity.fell false)
+        (set @entity.hazardId "")
+        (set @entity.goalId "")
+        (set @entity.skating false)
+
+      STEER -> active when @config.running
+        (set @entity.body (object/merge @entity.body { vx: (* @payload.dir @config.moveSpeed), facingRight: (if (!= @payload.dir 0) (> @payload.dir 0) @entity.body.facingRight) }))
+
+      JUMP -> active when (and @config.running (== @entity.body.grounded true))
+        (set @entity.body (object/merge @entity.body { vy: (if (> @config.gravity 0) (- 0 @config.jumpStrength) @config.jumpStrength), grounded: false }))
+        (emit BODY_JUMPED { x: @entity.body.x, y: @entity.body.y })
+
+      PLACE -> active
+        (set @entity.body (object/merge @entity.body { x: @payload.x, y: @payload.y, vx: 0, vy: 0, grounded: false }))
+        (set @entity.fell false)
+        (set @entity.hazardId "")
+        (set @entity.skating false)
+
+      RESTART -> active
+        (set @entity.body @config.spawn)
+        (set @entity.fell false)
+        (set @entity.hazardId "")
+        (set @entity.goalId "")
+        (set @entity.skating false)
+    }
+
+    ticks {
+      physicsTick every 33ms
+        when (and @config.running (> @entity.body.width 0))
+        (let ((gdir (if (> @config.gravity 0) 1 -1)))
+        (let ((vy1 (math/clamp (+ @entity.body.vy (* @config.gravity 0.033)) (- 0 @config.maxFallSpeed) @config.maxFallSpeed)))
+        (let ((bw (object/get @entity.body width)) (bh (object/get @entity.body height)))
+        (let ((nx (math/clamp (+ @entity.body.x (* @entity.body.vx 0.033)) @config.xMin @config.xMax)))
+        (let ((ny (+ @entity.body.y (* @vy1 0.033))))
+        (let ((rect { x: @nx, y: @ny, w: @bw, h: @bh }))
+        (let ((hit (array/find @config.platforms (fn p (and (or (== (object/get @p type) "ground") (== (object/get @p type) "platform")) (geo/aabb-overlap @rect { x: @p.x, y: @p.y, w: @p.width, h: @p.height }))))))
+        (let ((landed (and (!= @hit null) (> (* @vy1 @gdir) 0))))
+        (let ((ny2 (if @landed (if (> @gdir 0) (- (object/get @hit y) @bh) (+ (object/get @hit y) (object/get @hit height))) @ny)) (vy2 (if @landed 0 @vy1)))
+        (let ((cx (+ @nx (/ @bw 2))))
+        (let ((inRange (and @config.skate (and (> (array/len @config.skateCurve) 1) (and (>= @cx (object/get (array/first @config.skateCurve) x)) (< @cx (object/get (array/last @config.skateCurve) x)))))))
+        (let ((leftSamp (if @inRange (array/last (array/filter @config.skateCurve (fn s (<= (object/get @s x) @cx)))) { x: 0, y: 0 })))
+        (let ((rightSamp (if @inRange (array/first (array/filter @config.skateCurve (fn s (> (object/get @s x) @cx)))) { x: 1, y: 0 })))
+        (let ((slope (if @inRange (/ (- (object/get @rightSamp y) (object/get @leftSamp y)) (- (object/get @rightSamp x) (object/get @leftSamp x))) 0)))
+        (let ((curveY (if @inRange (+ (object/get @leftSamp y) (* @slope (- @cx (object/get @leftSamp x)))) 0)))
+        (let ((movingUp (< (* @vy1 @gdir) -0.01)))
+        (let ((skateNow (and @inRange (and (<= (math/abs (- @ny2 @curveY)) @config.skateSnap) (and (or @landed @entity.skating) (or @entity.body.grounded (not @movingUp)))))))
+        (let ((vx2 (if @skateNow (math/clamp (+ @entity.body.vx (* (/ (* @config.gravity @slope) (+ 1 (* @slope @slope))) 0.033)) (- 0 @config.maxFallSpeed) @config.maxFallSpeed) @entity.body.vx)))
+        (let ((fy (if @skateNow @curveY @ny2)) (fvy (if @skateNow (* @slope @vx2) @vy2)) (fgrounded (or @landed @skateNow)))
+        (let ((hazardHit (array/find @config.platforms (fn p (and (== (object/get @p type) "hazard") (geo/aabb-overlap @rect { x: @p.x, y: @p.y, w: @p.width, h: @p.height }))))))
+        (let ((goalHit (array/find @config.platforms (fn p (and (== (object/get @p type) "goal") (geo/aabb-overlap @rect { x: @p.x, y: @p.y, w: @p.width, h: @p.height }))))))
+        (let ((fellNow (if (> @gdir 0) (> @fy @config.killY) (< @fy @config.killY))))
+          (do
+            (set @entity.body (object/merge @entity.body { x: @nx, y: @fy, vx: (if (or (== @nx @config.xMin) (== @nx @config.xMax)) 0 @vx2), vy: @fvy, grounded: @fgrounded }))
+            (set @entity.skating @skateNow)
+            (if (and @skateNow (== @entity.skating false))
+              (emit BODY_SKATE_START { x: @nx, y: @fy, slope: @slope })
+              null)
+            (if (and (== @skateNow false) (== @entity.skating true))
+              (emit BODY_SKATE_END { x: @nx, y: @fy })
+              null)
+            (if (and @landed (== @entity.body.grounded false))
+              (emit BODY_LANDED { x: @nx, y: @fy, impact: (* @vy1 @gdir) })
+              null)
+            (if (!= @hazardHit null)
+              (if (!= @entity.hazardId (object/get @hazardHit "id" ""))
+                (do
+                  (set @entity.hazardId (object/get @hazardHit "id" ""))
+                  (emit BODY_HAZARD { id: (object/get @hazardHit "id" ""), x: @nx, y: @fy }))
+                null)
+              (set @entity.hazardId ""))
+            (if (!= @goalHit null)
+              (if (!= @entity.goalId (object/get @goalHit "id" ""))
+                (do
+                  (set @entity.goalId (object/get @goalHit "id" ""))
+                  (emit BODY_GOAL { id: (object/get @goalHit "id" ""), x: @nx, y: @fy }))
+                null)
+              (set @entity.goalId ""))
+            (if (and @fellNow (== @entity.fell false))
+              (do
+                (set @entity.fell true)
+                (emit BODY_FELL { x: @nx, y: @fy }))
+              null)
+            (emit BODY_MOVED { x: @nx, y: @fy, vx: @entity.body.vx, vy: @fvy, grounded: @fgrounded, skating: @skateNow, speed: (math/hypot @entity.body.vx @fvy) }))))))))))))))))))))))))
+    }
+
+    emits {
+      BODY_MOVED -> external {
+        x : number!
+        y : number!
+        vx : number!
+        vy : number!
+        grounded : boolean!
+        skating : boolean!
+        speed : number!
+      }
+        @description "The body after this physics tick: position, velocity, grounded and skating flags, and scalar speed; render layers subscribe (or read the shared entity), rule layers stay on the sparse signals"
+        @tier "domain"
+      BODY_SKATE_START -> external {
+        x : number!
+        y : number!
+        slope : number!
+      }
+        @description "Body engaged curve skating this tick (grounded within skateSnap of the skateCurve surface); slope is the local dy/dx — boards layer fx and equation readouts"
+        @tier "domain"
+      BODY_SKATE_END -> external {
+        x : number!
+        y : number!
+      }
+        @description "Body left the curve surface (jumped, walked past an end, or drifted beyond skateSnap); boards tear down skate fx"
+        @tier "domain"
+      BODY_JUMPED -> external {
+        x : number!
+        y : number!
+      }
+        @description "Jump accepted (grounded at intent time) and vertical velocity kicked against gravity; boards layer squash/sound fx"
+        @tier "domain"
+      BODY_LANDED -> external {
+        x : number!
+        y : number!
+        impact : number!
+      }
+        @description "Body transitioned airborne → standing on a ground/platform tile this tick; impact is the pre-landing fall speed in units/s so boards can scale dust or damage"
+        @tier "domain"
+      BODY_HAZARD -> external {
+        id : string!
+        x : number!
+        y : number!
+      }
+        @description "Body entered overlap with a hazard tile; fires once per entry and re-arms only after the body leaves, so damage rules stay sparse"
+        @tier "domain"
+      BODY_GOAL -> external {
+        id : string!
+        x : number!
+        y : number!
+      }
+        @description "Body entered overlap with a goal tile; fires once per entry and re-arms only after the body leaves — the board's win-rule trigger"
+        @tier "domain"
+      BODY_FELL -> external {
+        x : number!
+        y : number!
+      }
+        @description "Body crossed killY in the gravity direction (pit fall); fires once per fall and re-arms on PLACE/RESTART, leaving the respawn rule to the board"
+        @tier "domain"
+    }
+
+    listens {
+      STEER { dir : number! }
+      JUMP { id : string }
+      PLACE { x : number!, y : number! }
+      RESTART { id : string }
+    }
+
+    config {
+      running : boolean = true
+        @label "Running"
+        @description "When true the 33ms physics tick integrates and collides; toggle to freeze the body"
+        @tier "domain"
+      spawn : PlatformerBody = { x: 2, y: 8, width: 0.6, height: 0.6, vx: 0, vy: 0, grounded: false, facingRight: true }
+        @label "Spawn Body"
+        @description "Initial body rect (min-corner x/y plus width/height) seeded on INIT/RESTART; width/height also define the collision box"
+        @tier "domain"
+      platforms : [PlatformerPlatform] = []
+        @label "Platforms"
+        @description "Level geometry as min-corner rects: ground/platform tiles are solid one-way landing surfaces, hazard tiles emit BODY_HAZARD on touch, goal tiles emit BODY_GOAL"
+        @tier "domain"
+      gravity : number = 24
+        @label "Gravity"
+        @description "Units/s² added to vertical velocity; the SIGN is the vertical convention — positive pulls toward +y (screen boards, y down), negative toward −y (math canvases, y up) — and jumps always fire against it"
+        @tier "domain"
+      jumpStrength : number = 11
+        @label "Jump Strength"
+        @description "Vertical speed in units/s imparted by JUMP, directed against gravity; apex height ≈ jumpStrength² / (2·|gravity|)"
+        @tier "domain"
+      moveSpeed : number = 5
+        @label "Move Speed"
+        @description "Horizontal run speed in units/s applied by STEER dir ±1"
+        @tier "domain"
+      maxFallSpeed : number = 14
+        @label "Max Fall Speed"
+        @description "Terminal velocity cap in units/s applied to vertical speed each tick"
+        @tier "presentation"
+      xMin : number = -1000000
+        @label "Left Wall"
+        @description "Smallest x the body's min corner may hold (world bounds, not level geometry)"
+        @tier "presentation"
+      xMax : number = 1000000
+        @label "Right Wall"
+        @description "Largest x the body's min corner may hold (world bounds, not level geometry)"
+        @tier "presentation"
+      killY : number = 1000000
+        @description "Fall line: crossing it in the gravity direction fires BODY_FELL once (past it downward on y-down boards, below it on y-up canvases); y-up consumers must set a value below their world floor"
+        @label "Kill Y"
+        @tier "domain"
+      skate : boolean = false
+        @label "Curve Skating"
+        @description "When true, a grounded body within skateSnap of the skateCurve surface rides the curve: y snaps to the interpolated surface and tangential gravity (g·slope/(1+slope²)) accelerates vx, so the body slides downhill along the graph and launches off its ends; JUMP kicks free"
+        @tier "domain"
+      skateCurve : [PlatformerCurveSample] = []
+        @label "Skate Curve"
+        @description "Surface samples (x strictly increasing) the body skates when skate is on; y is the surface height for the body's MIN corner, linearly interpolated between bracketing samples — mirror the render-side curve so what you see is what you ride"
+        @tier "domain"
+      skateSnap : number = 0.75
+        @label "Skate Snap"
+        @description "Max vertical gap (world units) between the body's min corner and the curve surface for skating to engage or stay engaged; larger values grab earlier on landing, smaller values release sooner on bumps"
+        @tier "domain"
+    }
+  }
+
+  page "/platformer-body" as PlatformerBodyPage -> PlatformerBody
+}