@almadar/std 16.186.0 → 16.188.0

package/behaviors/lolo/ui/core/atoms/std-selection.lolo

@@ -1,5 +1,6 @@
 app std-selection "1.0.0"
 "std-selection as a Function"
+type FilterSpec = { field : string!, label : string, options : [string] }
 orbital SelectableItemOrbital {
     type SelectableItemLoaded = Event { data : [SelectableItem] } "Fired when SelectableItem finishes loading; payload.data holds the list"
 
@@ -46,7 +47,37 @@ orbital SelectableItemOrbital {
             direction: horizontal
             gap: sm
             type: stack
-          }, { type: divider }, {
+          }, (if @config.bodySearch {
+            children: [{
+              className: "w-full max-w-md"
+              clearable: true
+              event: REFETCH_QUERY
+              placeholder: @config.searchPlaceholder
+              type: search-input
+            }]
+            direction: horizontal
+            gap: sm
+            type: stack
+          } {
+            children: []
+            gap: none
+            type: stack
+          }), (if [">", (array/len @config.filters), 0] {
+            children: [{
+              entity: SelectableItem
+              event: REFETCH_FILTER
+              filters: @config.filters
+              look: @config.filterBarLook
+              type: filter-group
+            }]
+            direction: horizontal
+            gap: sm
+            type: stack
+          } {
+            children: []
+            gap: none
+            type: stack
+          }), { type: divider }, {
             color: muted
             content: "Choose a selectableitem to continue."
             type: typography
@@ -61,6 +92,7 @@ orbital SelectableItemOrbital {
               label: Select
             }]
             look: @config.tableLook
+            pageSize: @config.displayPageSize
             renderItem: (fn item {
               align: center
               children: [{ label: @item.name, type: checkbox }]
@@ -105,6 +137,106 @@ orbital SelectableItemOrbital {
     }
 
     state idle {
+      ;; REFETCH_* stays in `idle` and DOES NOT replace the pick-list with a
+      ;; spinner — same reasoning as std-browse's REFETCH_* arms: a skeleton
+      ;; on refetch unmounts the list and flickers every keystroke. The fetch
+      ;; fires in the background; the SelectableItemLoaded arm below
+      ;; re-renders in place once it lands.
+      REFETCH_QUERY -> idle
+        (fetch SelectableItem {
+          emit: { failure: SelectableItemLoadFailed, success: SelectableItemLoaded }
+          filter: (or ["=", ?searchTerm, ""] (str/includes (object/get @entity name) ?searchTerm))
+        })
+      REFETCH_FILTER -> idle
+        (fetch SelectableItem {
+          emit: { failure: SelectableItemLoadFailed, success: SelectableItemLoaded }
+          filter: (or ["=", ?value, ""] ["=", (object/get @entity ?field), ?value])
+        })
+      ;; No filter carried over on REFETCH_PAGE, mirroring std-browse exactly.
+      ;; Paging is safe here: this atom's selection is a single transient id
+      ;; carried only in the SELECT/CONFIRM_SELECTION payload (`?id`), never
+      ;; accumulated into a persisted @entity array, so turning a page cannot
+      ;; strand an "already selected" item — there is no multi-item selection
+      ;; state to strand. A future multi-select variant that DOES accumulate
+      ;; picks into an @entity field would need to carry that array across
+      ;; REFETCH_PAGE explicitly; this single-pick atom does not need to.
+      REFETCH_PAGE -> idle
+        (fetch SelectableItem {
+          emit: { failure: SelectableItemLoadFailed, success: SelectableItemLoaded }
+          limit: @config.pageSize
+          offset: ["*", ["-", ?page, 1], @config.pageSize]
+        })
+      SelectableItemLoaded -> idle
+        (render-ui main {
+          children: [{
+            align: center
+            children: [{ name: check-square, type: icon }, {
+              content: SelectableItems
+              type: typography
+              variant: h2
+            }]
+            direction: horizontal
+            gap: sm
+            type: stack
+          }, (if @config.bodySearch {
+            children: [{
+              className: "w-full max-w-md"
+              clearable: true
+              event: REFETCH_QUERY
+              placeholder: @config.searchPlaceholder
+              type: search-input
+            }]
+            direction: horizontal
+            gap: sm
+            type: stack
+          } {
+            children: []
+            gap: none
+            type: stack
+          }), (if [">", (array/len @config.filters), 0] {
+            children: [{
+              entity: SelectableItem
+              event: REFETCH_FILTER
+              filters: @config.filters
+              look: @config.filterBarLook
+              type: filter-group
+            }]
+            direction: horizontal
+            gap: sm
+            type: stack
+          } {
+            children: []
+            gap: none
+            type: stack
+          }), { type: divider }, {
+            color: muted
+            content: "Choose a selectableitem to continue."
+            type: typography
+            variant: caption
+          }, {
+            className: "transition-shadow hover:shadow-md cursor-pointer"
+            entity: ?data
+            fields: []
+            itemActions: [{
+              event: SELECT
+              icon: check
+              label: Select
+            }]
+            look: @config.tableLook
+            pageSize: @config.displayPageSize
+            renderItem: (fn item {
+              align: center
+              children: [{ label: @item.name, type: checkbox }]
+              direction: horizontal
+              gap: sm
+              type: stack
+            })
+            type: data-grid
+          }]
+          direction: vertical
+          gap: lg
+          type: stack
+        })
       SELECT -> selecting
         (render-ui main {
           children: [{
@@ -269,6 +401,25 @@ orbital SelectableItemOrbital {
         @description "Indicates a selectable item failed to load."
         @synonyms "error, failure, problem, load error"
         @tier "internal"
+      REFETCH_QUERY {
+        searchTerm : string!
+      }
+        @description "Triggers a pick-list refresh based on the current search term."
+        @synonyms "refresh, reload, update, re-query, search"
+        @tier "domain"
+      REFETCH_FILTER {
+        field : string!
+        value : string!
+      }
+        @description "Triggers a pick-list refresh based on current filter criteria."
+        @synonyms "refresh, filter, update, reload"
+        @tier "domain"
+      REFETCH_PAGE {
+        page : number!
+      }
+        @description "Triggers a pick-list page refresh."
+        @synonyms "reload, refresh, update, paginate"
+        @tier "domain"
     }
 
     config {
@@ -276,6 +427,36 @@ orbital SelectableItemOrbital {
         @label "Table look"
         @description "Layer 2 visual treatment for the data table rendered by this atom."
         @tier "presentation"
+      bodySearch : boolean = false
+        @label "Show the pick-list's own search box?"
+        @description "Embeds a search box above the pick-list. Set true only when the page has no other search affordance (e.g. no page-level std-search), so the surface shows one search box instead of two. False is the default — this atom has never had a search box (0 consumers today)."
+        @synonyms "inline search, list search, built-in search, show search"
+        @tier "presentation"
+      searchPlaceholder : string = "Search…"
+        @label "Search box placeholder text"
+        @description "Hint text inside the pick-list search box."
+        @synonyms "search hint, placeholder, search box text"
+        @tier "presentation"
+      filters : [FilterSpec] = []
+        @label "Which filters should appear above the pick-list?"
+        @description "Dropdown filter facets by field, rendered as an embedded filter bar above the rows; each selection fires REFETCH_FILTER on this trait. Empty (the default) = no filter bar, the right setting whenever the page already composes std-filter beside this list and routes XFilter.FILTER -> REFETCH_FILTER — that is the wired owner and remains the primary path. Use this knob only for a standalone pick-list with no page-level filter affordance."
+        @synonyms "filter bar, faceted filters, field filters, dropdowns"
+        @tier "presentation"
+      filterBarLook : "toolbar" | "chips" | "pills" | "popover-trigger" | "inline-column-header" = toolbar
+        @label "Filter bar look"
+        @description "Visual treatment for the embedded filter bar, mirroring std-filter's own enum. Only applies when `filters` is non-empty."
+        @synonyms "filter bar style, facet style, chips, pills"
+        @tier "presentation"
+      pageSize : number = 20
+        @label "How many candidates per page when paging?"
+        @description "Records fetched from the server per REFETCH_PAGE request. The initial load and search/filter refetches remain unpaginated (load every candidate) unless a consumer wires REFETCH_PAGE, so the default pick-list surface is unchanged. Safe to page: this atom's selection is a single transient id (never an accumulated array), so no already-picked item can be stranded on another page."
+        @synonyms "fetch limit, records per page, page limit"
+        @tier "presentation"
+      displayPageSize : number = 20
+        @label "How many candidates to show at once?"
+        @description "Rows visible per page before the data-grid's own pagination control appears — 20 matches the pick-list density sweet spot (Miller's law, 10-25 rows)."
+        @synonyms "visible rows, items per page, display limit, show per page"
+        @tier "presentation"
     }
   }
 

package/behaviors/lolo/ui/core/atoms/std-tree.lolo

@@ -1,5 +1,6 @@
 app std-tree "1.0.0"
-"std-tree — generic hierarchical node browser. Fetches a flat TreeNode collection and renders it through file-tree's flat `items` mode (parentId-nested at render time by the component, not the .lolo); OPEN_NODE is the external handoff for a selected node's id. Rebindable: pass `fields` at the call site to retarget it at any parent-pointer entity (categories, org units, comment threads)."
+"std-tree — generic hierarchical node browser. Fetches a flat TreeNode collection and renders it through file-tree's flat `items` mode (parentId-nested at render time by the component, not the .lolo); OPEN_NODE is the external handoff for a selected node's id. Rebindable: pass `fields` at the call site to retarget it at any parent-pointer entity (categories, org units, comment threads). Search/filter are wired (REFETCH_QUERY/REFETCH_FILTER re-fetch the flat node set server-side); pagination is deliberately NOT offered — a hierarchy is not a paged list, and paging a flat node set would sever children from parents that fell on another page."
+type FilterSpec = { field : string!, label : string, options : [string] }
 orbital TreeNodeOrbital {
     type TreeNodeLoaded = Event { data : [TreeNode] } "Fired when the tree node collection finishes loading"
 
@@ -51,7 +52,37 @@ orbital TreeNodeOrbital {
             direction: horizontal
             gap: sm
             type: stack
-          }, { type: divider }, {
+          }, { type: divider }, (if @config.bodySearch {
+            children: [{
+              className: "w-full max-w-md"
+              clearable: true
+              event: REFETCH_QUERY
+              placeholder: @config.searchPlaceholder
+              type: search-input
+            }]
+            direction: horizontal
+            gap: sm
+            type: stack
+          } {
+            children: []
+            gap: none
+            type: stack
+          }), (if [">", (array/len @config.filters), 0] {
+            children: [{
+              entity: TreeNode
+              event: REFETCH_FILTER
+              filters: @config.filters
+              look: @config.filterBarLook
+              type: filter-group
+            }]
+            direction: horizontal
+            gap: sm
+            type: stack
+          } {
+            children: []
+            gap: none
+            type: stack
+          }), {
             items: (array/map ?data (fn row {
               icon: @row.icon
               id: @row.id
@@ -113,6 +144,22 @@ orbital TreeNodeOrbital {
           gap: md
           type: stack
         })
+      ;; REFETCH_* stays in `browsing` and DOES NOT replace the tree with a
+      ;; spinner — search-as-you-type would otherwise unmount file-tree every
+      ;; keystroke and flicker. The fetch fires in the background; when
+      ;; TreeNodeLoaded arrives (handler below) React reconciles the tree in
+      ;; place. No REFETCH_PAGE: a hierarchy is not a paged list — paging the
+      ;; flat node set would sever children from parents on another page.
+      REFETCH_QUERY -> browsing
+        (fetch TreeNode {
+          emit: { failure: TreeNodeLoadFailed, success: TreeNodeLoaded }
+          filter: (or ["=", ?searchTerm, ""] (str/includes (object/get @entity name) ?searchTerm))
+        })
+      REFETCH_FILTER -> browsing
+        (fetch TreeNode {
+          emit: { failure: TreeNodeLoadFailed, success: TreeNodeLoaded }
+          filter: (or ["=", ?value, ""] ["=", (object/get @entity ?field), ?value])
+        })
       OPEN_NODE -> browsing
         (set @entity.id ?id)
       TreeNodeLoaded -> browsing
@@ -132,7 +179,37 @@ orbital TreeNodeOrbital {
             direction: horizontal
             gap: sm
             type: stack
-          }, { type: divider }, {
+          }, { type: divider }, (if @config.bodySearch {
+            children: [{
+              className: "w-full max-w-md"
+              clearable: true
+              event: REFETCH_QUERY
+              placeholder: @config.searchPlaceholder
+              type: search-input
+            }]
+            direction: horizontal
+            gap: sm
+            type: stack
+          } {
+            children: []
+            gap: none
+            type: stack
+          }), (if [">", (array/len @config.filters), 0] {
+            children: [{
+              entity: TreeNode
+              event: REFETCH_FILTER
+              filters: @config.filters
+              look: @config.filterBarLook
+              type: filter-group
+            }]
+            direction: horizontal
+            gap: sm
+            type: stack
+          } {
+            children: []
+            gap: none
+            type: stack
+          }), {
             items: (array/map ?data (fn row {
               icon: @row.icon
               id: @row.id
@@ -214,6 +291,19 @@ orbital TreeNodeOrbital {
     }
 
     listens {
+      REFETCH_QUERY {
+        searchTerm : string!
+      }
+        @description "Triggers a tree refresh based on the current search query."
+        @synonyms "refresh, reload, update, re-query"
+        @tier "domain"
+      REFETCH_FILTER {
+        field : string!
+        value : string!
+      }
+        @description "Triggers a tree refresh based on current filter criteria."
+        @synonyms "refresh, filter, update, reload"
+        @tier "domain"
       OPEN_NODE {
         id : string!
       }
@@ -240,6 +330,26 @@ orbital TreeNodeOrbital {
         @label "Section title"
         @description "Heading shown above the tree"
         @tier "presentation"
+      bodySearch : boolean = false
+        @label "Show the tree's own search box?"
+        @description "Embeds a search box above the tree that re-fetches the flat node set server-side. Set false (the default) when the page already provides a search affordance (a toolbar Search molecule), so the surface shows one search box instead of two."
+        @synonyms "inline search, list search, built-in search, show search, duplicate search"
+        @tier "presentation"
+      searchPlaceholder : string = "Search…"
+        @label "Search box placeholder text"
+        @description "Hint text inside the tree search box (e.g. 'Search nodes…')."
+        @synonyms "search hint, placeholder, search box text, search label"
+        @tier "presentation"
+      filters : [FilterSpec] = []
+        @label "Which filters should appear above the tree?"
+        @description "Dropdown filter facets by field, rendered as an embedded filter bar above the tree; each selection fires REFETCH_FILTER on this trait, re-fetching the flat node set. Empty (the default) = no filter bar, which is the right setting whenever the page already composes std-filter beside this tree and routes `XFilter.FILTER -> REFETCH_FILTER` — that is the wired owner and remains the primary path."
+        @synonyms "filter bar, faceted filters, field filters, dropdowns"
+        @tier "presentation"
+      filterBarLook : "toolbar" | "chips" | "pills" | "popover-trigger" | "inline-column-header" = toolbar
+        @label "Filter bar look"
+        @description "Visual treatment for the embedded filter bar, mirroring std-filter's own enum. Only applies when `filters` is non-empty."
+        @synonyms "filter bar style, facet style, chips, pills"
+        @tier "presentation"
     }
   }
 

package/behaviors/lolo/ui/game/atoms/std-area-fill.lolo

@@ -0,0 +1,93 @@
+app std-area-fill "1.0.0"
+"Headless area-fill mechanic: the player paints area under a curve by moving through a fill region. Listens BODY_MOVED and, per fill, accumulates height(x) × |dx| while the player is inside the fill's x-range (the per-tick step is clamped to 0.5 world units — the physical per-tick maximum — so teleports and respawns paint nothing) — height is linear interpolation of the config curve samples above the fill's baseline (the platformer body's leftSamp/rightSamp idiom). rateMode picks the rate: \"area\" (height × |dx|, default — fills fastest where the curve is tallest), \"speed\" (|dx| only, flat rate), or \"ride\" (|dx| only while the move reports skating — walking the same distance paints nothing). When a fill's filled reaches its target it flips reported and emits AREA_FILLED once (the shared entity carries the rest); each fill also stamps a frontier (x0 + span × min(1, filled/target)) so boards can shade the painted region left-to-right as the gauge grows. RESTART resets every fill. Renders nothing; boards shade the painted region and read filled/frontier from the shared entity (the render authority)."
+orbital AreaFillOrbital {
+  type AreaFillSample = {
+    x : number!
+    y : number!
+  }
+  type AreaFill = {
+    id : string!
+    x0 : number!
+    x1 : number!
+    baseline : number!
+    target : number!
+    rateMode : string
+    hint : string
+    samples : [AreaFillSample]!
+    filled : number
+    frontier : number
+    reported : boolean
+  }
+
+  entity AreaFillData [runtime, shared] {
+    id : string!
+    fills : [AreaFill] = []
+    lastX : number = 0
+  }
+
+  trait AreaFill -> @rebindable AreaFillData [lifecycle] {
+    initial: active
+
+    state active {
+      INIT -> active
+        (set @entity.fills (array/map @config.fills (fn f (object/merge @f { filled: 0, frontier: (object/get @f x0), reported: false }))))
+        (set @entity.lastX 0)
+
+      BODY_MOVED -> active when @config.running
+        (let ((adx (math/abs (- @payload.x @entity.lastX))))
+        (set @entity.fills (array/map @entity.fills (fn f
+          (let ((inside (and (>= @payload.x (object/get @f x0)) (<= @payload.x (object/get @f x1)))))
+          (let ((leftSamp (array/last (array/filter (object/get @f samples) (fn s (<= (object/get @s x) @payload.x))))))
+          (let ((rightSamp (array/first (array/filter (object/get @f samples) (fn s (> (object/get @s x) @payload.x))))))
+          (let ((h (if (or (== @leftSamp null) (== @rightSamp null)) 0
+                     (- (+ (object/get @leftSamp y) (* (/ (- (object/get @rightSamp y) (object/get @leftSamp y)) (- (object/get @rightSamp x) (object/get @leftSamp x))) (- @payload.x (object/get @leftSamp x)))) (object/get @f baseline)))))
+          (let ((step (math/min @adx 0.5)))
+          (let ((rate (if @inside
+                        (if (== (object/get @f rateMode) "ride") (if @payload.skating @step 0)
+                          (if (== (object/get @f rateMode) "speed") @step
+                            (* @step @h)))
+                        0)))
+          (let ((newFilled (+ (object/get @f filled) @rate)))
+            (object/merge @f { filled: @newFilled, frontier: (+ (object/get @f x0) (* (- (object/get @f x1) (object/get @f x0)) (math/min 1 (/ @newFilled (object/get @f target))))) }))))))))))))
+        (set @entity.lastX @payload.x)
+        (let ((newly (array/filter @entity.fills (fn f (and (>= (object/get @f filled) (object/get @f target)) (== (object/get @f reported) false))))))
+        (if (> (array/len @newly) 0)
+          (do
+            (set @entity.fills (array/map @entity.fills (fn f (if (== (object/get @f id) (object/get (array/first @newly) id)) (object/merge @f { reported: true }) @f))))
+            (emit AREA_FILLED { id: (object/get (array/first @newly) id), x: @payload.x, y: @payload.y }))
+          null))
+
+      RESTART -> active
+        (set @entity.fills (array/map @config.fills (fn f (object/merge @f { filled: 0, frontier: (object/get @f x0), reported: false }))))
+        (set @entity.lastX 0)
+    }
+
+    emits {
+      AREA_FILLED -> external {
+        id : string!
+        x : number!
+        y : number!
+      }
+        @description "A fill's painted area reached its target (x, y = the player's position at completion, for burst placement). When several fills complete on one move, the first reports and the shared entity carries the rest."
+        @tier "domain"
+    }
+
+    listens {
+      BODY_MOVED { x : number!, y : number!, vx : number!, vy : number!, grounded : boolean!, skating : boolean!, speed : number! }
+      RESTART { id : string }
+    }
+
+    config {
+      running : boolean = true
+        @label "Running"
+        @description "When true, BODY_MOVED paints every fill the player moves through; toggle to freeze every fill as-is."
+        @tier "domain"
+      fills : [AreaFill] = []
+        @label "Fills"
+        @description "One row per fill region: id, x-range (x0..x1 in world units), baseline the height is measured from, target area, rateMode (area | speed | ride — default area), optional hint, and the curve samples to interpolate. filled/frontier/reported are stamped at runtime."
+        @tier "domain"
+    }
+  }
+
+  page "/area-fill" as AreaFillPage -> AreaFill
+}

package/behaviors/lolo/ui/game/atoms/std-loop-lock.lolo

@@ -0,0 +1,79 @@
+app std-loop-lock "1.0.0"
+"Headless winding-lock mechanic: locks that open only after the player travels a full revolution around their anchor. Listens BODY_MOVED and, while the player stays within a radial band of a lock's ring, accumulates the wrapped angular delta of their position into swept (radians, signed — either direction counts); when |swept| reaches turns × 2π the lock flips unlocked and emits LOOP_UNLOCKED once. Entering the band reseeds the angle so leaving and returning never jumps the sweep; progress is kept across exits, so a revolution can be completed in stages. RESTART re-locks every lock. Renders nothing; boards draw the ring/chest and read swept from the shared entity (the render authority)."
+orbital LoopLockOrbital {
+  type LoopLock = {
+    id : string!
+    x : number!
+    y : number!
+    radius : number!
+    band : number!
+    turns : number!
+    swept : number
+    lastAngle : number
+    inside : boolean
+    unlocked : boolean
+    reported : boolean
+  }
+
+  entity LoopLockData [runtime, shared] {
+    id : string!
+    locks : [LoopLock] = []
+  }
+
+  trait LoopLock -> @rebindable LoopLockData [lifecycle] {
+    initial: active
+
+    state active {
+      INIT -> active
+        (set @entity.locks (array/map @config.locks (fn l (object/merge @l { swept: 0, lastAngle: 0, inside: false, unlocked: false, reported: false }))))
+
+      BODY_MOVED -> active when @config.running
+        (set @entity.locks (array/map @entity.locks (fn l
+          (let ((dx (- @payload.x (object/get @l x))) (dy (- @payload.y (object/get @l y))))
+          (let ((dist (math/hypot @dx @dy)) (ang (math/atan2 @dy @dx)))
+          (let ((in (<= (math/abs (- @dist (object/get @l radius))) (object/get @l band))))
+          (let ((d (if (and @in (== (object/get @l inside) true))
+                     (math/atan2 (math/sin (- @ang (object/get @l lastAngle))) (math/cos (- @ang (object/get @l lastAngle))))
+                     0)))
+          (let ((swept (+ (object/get @l swept) @d)))
+            (object/merge @l { inside: @in, lastAngle: (if @in @ang (object/get @l lastAngle)), swept: @swept, unlocked: (or (object/get @l unlocked) (>= (math/abs @swept) (* (object/get @l turns) 6.283185307179586))) })))))))))
+        (let ((newly (array/filter @entity.locks (fn l (and (== (object/get @l unlocked) true) (== (object/get @l reported) false))))))
+        (if (> (array/len @newly) 0)
+          (do
+            (set @entity.locks (array/map @entity.locks (fn l (if (== (object/get @l id) (object/get (array/first @newly) id)) (object/merge @l { reported: true }) @l))))
+            (emit LOOP_UNLOCKED { id: (object/get (array/first @newly) id), x: (object/get (array/first @newly) x), y: (object/get (array/first @newly) y) }))
+          null))
+
+      RESTART -> active
+        (set @entity.locks (array/map @config.locks (fn l (object/merge @l { swept: 0, lastAngle: 0, inside: false, unlocked: false, reported: false }))))
+    }
+
+    emits {
+      LOOP_UNLOCKED -> external {
+        id : string!
+        x : number!
+        y : number!
+      }
+        @description "A lock's angular sweep reached turns × 2π and it flipped unlocked; boards layer treasure fx and rewards. When several locks open on one move, the first reports and the shared entity carries the rest."
+        @tier "domain"
+    }
+
+    listens {
+      BODY_MOVED { x : number!, y : number!, vx : number!, vy : number!, grounded : boolean!, skating : boolean!, speed : number! }
+      RESTART { id : string }
+    }
+
+    config {
+      running : boolean = true
+        @label "Running"
+        @description "When true, BODY_MOVED accumulates angular sweep and unlocks locks; toggle to freeze every lock as-is."
+        @tier "domain"
+      locks : [LoopLock] = []
+        @label "Locks"
+        @description "One row per winding lock: id, anchor (x, y in world units), ring radius, radial tolerance band, and revolutions required. swept/inside/unlocked are stamped at runtime."
+        @tier "domain"
+    }
+  }
+
+  page "/loop-lock" as LoopLockPage -> LoopLock
+}

package/behaviors/lolo/ui/game/atoms/std-pad-lock.lolo

@@ -0,0 +1,93 @@
+app std-pad-lock "1.0.0"
+"Headless pad-lock mechanic: floor pads that light when the player steps on them, completing a set when every pad is lit. Listens BODY_MOVED and lights any unlit live pad the player's rect touches (|dx| <= reachX, |dy| <= reachY of the pad center); a lit pad stays lit. Pads may carry a group number (grp 0 = ungrouped, always live): when groups are used, only pads of the lowest uncompleted group are live — pads of later groups refuse to light until the current group finishes, so one sum must be finished before the next. When a group completes the trait emits PAD_GROUP_COMPLETED once for it (first newly completed group reports; the shared entity carries the rest); when every pad in the set is lit it stamps completed and emits PAD_SET_COMPLETED once. RESTART unlights every pad and resets the set. Renders nothing; boards draw the pads and read lit from the shared entity (the render authority)."
+orbital PadLockOrbital {
+  type PadLock = {
+    id : string!
+    x : number!
+    y : number!
+    grp : number!
+    lit : boolean
+  }
+
+  entity PadLockData [runtime, shared] {
+    id : string!
+    pads : [PadLock] = []
+    groupsDone : [number] = []
+    completed : boolean = false
+  }
+
+  trait PadLock -> @rebindable PadLockData [lifecycle] {
+    initial: active
+
+    state active {
+      INIT -> active
+        (set @entity.pads (array/map @config.pads (fn p (object/merge @p { lit: false }))))
+        (set @entity.groupsDone [])
+        (set @entity.completed false)
+
+      BODY_MOVED -> active when @config.running
+        (let ((grpIds (array/reduce (array/map (array/filter @entity.pads (fn p (> (object/get @p grp) 0))) (fn p (object/get @p grp))) [] (fn acc g (if (> (array/len (array/filter @acc (fn x (== @x @g)))) 0) @acc (array/append @acc @g))))))
+        (let ((openGrps (array/filter @grpIds (fn g (< (array/len (array/filter @entity.pads (fn p (and (== (object/get @p grp) @g) (== (object/get @p lit) true))))) (array/len (array/filter @entity.pads (fn p (== (object/get @p grp) @g)))))))))
+        (let ((currentGrp (array/reduce @openGrps 9999 (fn acc g (math/min @acc @g)))))
+        (let ((newPads (array/map @entity.pads (fn p
+          (object/merge @p { lit: (or (object/get @p lit) (and (or (== (object/get @p grp) 0) (== (object/get @p grp) @currentGrp)) (and (<= (math/abs (- @payload.x (object/get @p x))) @config.reachX) (<= (math/abs (- @payload.y (object/get @p y))) @config.reachY)))) })))))
+        (let ((doneNow (array/filter @grpIds (fn g (== (array/len (array/filter @newPads (fn p (and (== (object/get @p grp) @g) (== (object/get @p lit) true))))) (array/len (array/filter @newPads (fn p (== (object/get @p grp) @g)))))))))
+        (let ((newlyGrp (array/filter @doneNow (fn g (== (array/len (array/filter @entity.groupsDone (fn d (== @d @g)))) 0)))))
+        (do
+          (set @entity.pads @newPads)
+          (if (> (array/len @newlyGrp) 0)
+            (do
+              (set @entity.groupsDone @doneNow)
+              (emit PAD_GROUP_COMPLETED { grp: (array/first @newlyGrp) }))
+            null)
+          (if (and (== @entity.completed false) (== (array/len (array/filter @newPads (fn p (== (object/get @p lit) false)))) 0))
+            (do
+              (set @entity.completed true)
+              (emit PAD_SET_COMPLETED {}))
+            null))))))))
+
+      RESTART -> active
+        (set @entity.pads (array/map @config.pads (fn p (object/merge @p { lit: false }))))
+        (set @entity.groupsDone [])
+        (set @entity.completed false)
+    }
+
+    emits {
+      PAD_GROUP_COMPLETED -> external {
+        grp : number!
+      }
+        @description "Every pad of one group is lit; fires once per group, in group order — later groups stay dead until the lowest uncompleted group finishes. Boards layer a small fx and unlock the next group's pads."
+        @tier "domain"
+      PAD_SET_COMPLETED -> external {
+      }
+        @description "Every pad in the set is lit; fires once per run. Boards layer the treasure fx and spill the bonus reward."
+        @tier "domain"
+    }
+
+    listens {
+      BODY_MOVED { x : number!, y : number!, vx : number!, vy : number!, grounded : boolean!, skating : boolean!, speed : number! }
+      RESTART { id : string }
+    }
+
+    config {
+      running : boolean = true
+        @label "Running"
+        @description "When true, BODY_MOVED lights touched live pads and reports group/set completion; toggle to freeze every pad as-is."
+        @tier "domain"
+      pads : [PadLock] = []
+        @label "Pads"
+        @description "One row per floor pad: id, center (x, y in world units), and grp (0 = ungrouped, always live; N = live only while it is the lowest uncompleted group). lit is stamped at runtime."
+        @tier "domain"
+      reachX : number = 0.7
+        @label "Reach X"
+        @description "Horizontal tolerance (world units) around a pad's center when testing player contact (approximates the body's half-width plus a step)."
+        @tier "domain"
+      reachY : number = 1.2
+        @label "Reach Y"
+        @description "Vertical tolerance (world units) around a pad's center when testing player contact (covers skating over the surface the pad sits on)."
+        @tier "domain"
+    }
+  }
+
+  page "/pad-lock" as PadLockPage -> PadLock
+}