@almadar/std 16.203.0 → 16.205.0

package/dist/behaviors-registry.json

@@ -1,13 +1,13 @@
 {
-  "$generated": "2026-09-04T04:56:15.851Z",
+  "$generated": "2026-09-04T12:00:35.866Z",
   "$source": "tools/almadar-pattern-sync/behaviors",
   "$package": "@almadar/std",
-  "totalBehaviors": 461,
+  "totalBehaviors": 462,
   "atoms": 298,
   "molecules": 111,
-  "organisms": 52,
+  "organisms": 53,
   "layers": {
-    "UI Patterns": 448,
+    "UI Patterns": 449,
     "ML": 13
   },
   "behaviors": {
@@ -145237,6 +145237,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -145555,6 +145556,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -145904,6 +145906,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -146271,6 +146274,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -146698,6 +146702,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -147107,6 +147112,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong-rally",
         "std-production",
         "std-round-flow",
@@ -147398,7 +147404,7 @@
       "topic": "ui/game",
       "family": "ui/game",
       "layer": "UI Patterns",
-      "description": "Headless choice-gate mechanic for side-view boards: a gate of N labeled option platforms where progress stops until the player commits to an answer. Listens BODY_MOVED and judges a gate when the player stands grounded on one of its option platforms (|dx| <= reachX of the option center, |dy| <= reachY of the gate's option plane — the pad-lock touch pattern): the correct option stamps the gate solved + chosen on the shared entity and emits CHOICE_CORRECT once (a solved gate never judges again, so the path stays open); a wrong option emits CHOICE_WRONG carrying the gate id, the chosen optionId, and the option's world position, so the board can bounce the player back and float the gate's hint (the board owns the bounce — the atom only reports). RESTART unsolves every gate. Renders nothing; boards draw the option platforms and labels from the shared entity (the render authority).",
+      "description": "Headless choice-gate mechanic for side-view boards: a gate of N labeled option platforms where progress stops until the player commits to an answer. Listens BODY_MOVED and judges a gate when the player stands grounded on one of its option platforms (|dx| <= reachX of the option center, |dy| <= reachY of the gate's option plane — the pad-lock touch pattern): the correct option stamps the gate solved + chosen on the shared entity and emits CHOICE_CORRECT once (a solved gate never judges again, so the path stays open); a wrong option emits CHOICE_WRONG carrying the gate id, the chosen optionId, and the option's world position, so the board can bounce the player back and float the gate's hint (the board owns the bounce — the atom only reports). RESTART unsolves every gate. Renders nothing; boards draw the option platforms and labels from the shared entity (the render authority). Corresponds to the design-sheet field(s): challenge, agency.",
       "defaultOrbitalName": "ChoiceGateOrbital",
       "statePattern": "active",
       "complexity": {
@@ -147486,6 +147492,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -147851,6 +147858,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -148244,6 +148252,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -148549,6 +148558,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -148913,7 +148923,7 @@
       "topic": "ui/game",
       "family": "ui/game",
       "layer": "UI Patterns",
-      "description": "Headless pedagogy→fx translator for game boards and learning shells: turns high-level narrative events into big transient screen-space or world-space text effects consumed by std-fx-particles / fx-overlay. Levels emit NARRATE { text, style } and get a correctly styled, centered (or positioned) floating text burst without hand-rolling particle structs. Tutorials emit TUTORIAL_SHOW and the atom forwards SHOW to a composed std-tutorial-overlay trait. Renders nothing; centralizes the FX vocabulary so every level's teaching text looks and behaves the same.",
+      "description": "Headless pedagogy→fx translator for game boards and learning shells: turns high-level narrative events into big transient screen-space or world-space text effects consumed by std-fx-particles / fx-overlay. Levels emit NARRATE { text, style } and get a correctly styled, centered (or positioned) floating text burst without hand-rolling particle structs. Tutorials emit TUTORIAL_SHOW and the atom forwards SHOW to a composed std-tutorial-overlay trait. Renders nothing; centralizes the FX vocabulary so every level's teaching text looks and behaves the same. Corresponds to the design-sheet field(s): feedback.",
       "defaultOrbitalName": "FxNarrativeOrbital",
       "statePattern": "active",
       "complexity": {
@@ -148989,6 +148999,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong-rally",
         "std-production",
         "std-round-flow",
@@ -149227,7 +149238,7 @@
       "topic": "ui/game",
       "family": "ui/game",
       "layer": "UI Patterns",
-      "description": "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\").",
+      "description": "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\"). Corresponds to the design-sheet field(s): feedback, rewards.",
       "defaultOrbitalName": "FxParticlesOrbital",
       "statePattern": "active",
       "complexity": {
@@ -149317,6 +149328,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -149704,6 +149716,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -149887,7 +149900,7 @@
       "topic": "ui/game",
       "family": "ui/game",
       "layer": "UI Patterns",
-      "description": "Headless collectible-gate mechanic: doors that stay shut until the player's collected total reaches their cost. Listens COLLECT (the board's running total — stars, coins, keys) and flips every door whose cost is met, stamping open on the shared door rows and emitting GATE_OPENED for the first newly opened door (the shared entity is the render authority for the rest). While a closed door's rect contains the player it emits GATE_BLOCKED once per approach — re-arming only after the player steps out — so the board can answer with a PLACE back and a locked fx. RESTART re-locks every door and zeroes the total. Renders nothing; boards draw closed doors as bars/walls and open ones as gaps.",
+      "description": "Headless collectible-gate mechanic: doors that stay shut until the player's collected total reaches their cost. Listens COLLECT (the board's running total — stars, coins, keys) and flips every door whose cost is met, stamping open on the shared door rows and emitting GATE_OPENED for the first newly opened door (the shared entity is the render authority for the rest). While a closed door's rect contains the player it emits GATE_BLOCKED once per approach — re-arming only after the player steps out — so the board can answer with a PLACE back and a locked fx. RESTART re-locks every door and zeroes the total. Renders nothing; boards draw closed doors as bars/walls and open ones as gaps. Corresponds to the design-sheet field(s): challenge, rewards.",
       "defaultOrbitalName": "GateLockOrbital",
       "statePattern": "active",
       "complexity": {
@@ -149981,6 +149994,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -150336,6 +150350,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -150769,6 +150784,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -151040,6 +151056,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong-rally",
         "std-production",
         "std-round-flow",
@@ -151479,6 +151496,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -151802,7 +151820,7 @@
       "topic": "ui/game",
       "family": "ui/game",
       "layer": "UI Patterns",
-      "description": "Headless lives + checkpoint authority for boards with stakes: owns lives, the current respawn point, and nothing else. DAMAGE (call sites rename their hazard sources — BODY_HAZARD, BODY_FELL, PATROL_HIT — onto it) costs one life, respecting an invulnerability window so overlapping hazards can't chain-drain; losing a life emits LIFE_LOST plus RESPAWN with the current checkpoint (boards route RESPAWN to the body authority's PLACE), and losing the last emits GAME_OVER instead. Checkpoints advance automatically: BODY_MOVED crossing a configured checkpoint's atX moves the respawn point forward and emits CHECKPOINT_REACHED once per checkpoint (tracked by furthest atX reached, so checkpoints are ordered along the run). RESTART reseeds lives and respawn to the spawn. Renders nothing — HUDs read lives off the shared entity.",
+      "description": "Headless lives + checkpoint authority for boards with stakes: owns lives, the current respawn point, and nothing else. DAMAGE (call sites rename their hazard sources — BODY_HAZARD, BODY_FELL, PATROL_HIT — onto it) costs one life, respecting an invulnerability window so overlapping hazards can't chain-drain; losing a life emits LIFE_LOST plus RESPAWN with the current checkpoint (boards route RESPAWN to the body authority's PLACE), and losing the last emits GAME_OVER instead. Checkpoints advance automatically: BODY_MOVED crossing a configured checkpoint's atX moves the respawn point forward and emits CHECKPOINT_REACHED once per checkpoint (tracked by furthest atX reached, so checkpoints are ordered along the run). RESTART reseeds lives and respawn to the spawn. Renders nothing — HUDs read lives off the shared entity. Corresponds to the design-sheet field(s): challenge, feedback.",
       "defaultOrbitalName": "LivesOrbital",
       "statePattern": "active",
       "complexity": {
@@ -151910,6 +151928,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -152184,7 +152203,7 @@
       "topic": "ui/game",
       "family": "ui/game",
       "layer": "UI Patterns",
-      "description": "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).",
+      "description": "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). Corresponds to the design-sheet field(s): challenge, rewards.",
       "defaultOrbitalName": "LoopLockOrbital",
       "statePattern": "active",
       "complexity": {
@@ -152272,6 +152291,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -152603,6 +152623,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -152887,6 +152908,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -153143,6 +153165,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -153455,7 +153478,7 @@
       "topic": "ui/game",
       "family": "ui/game",
       "layer": "UI Patterns",
-      "description": "Headless win/lose authority for objective boards: owns only result. Listens PROGRESS (objectivesLeft + movesLeft) and sets result to won when every objective is reached, lost when the move budget runs out first, else none. Renders nothing.",
+      "description": "Headless win/lose authority for objective boards: owns only result. Listens PROGRESS (objectivesLeft + movesLeft) and sets result to won when every objective is reached, lost when the move budget runs out first, else none. Renders nothing. Corresponds to the design-sheet field(s): goals, feedback.",
       "defaultOrbitalName": "ObjectiveFlowOrbital",
       "statePattern": "active",
       "complexity": {
@@ -153543,6 +153566,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -153842,6 +153866,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -154192,7 +154217,7 @@
       "topic": "ui/game",
       "family": "ui/game",
       "layer": "UI Patterns",
-      "description": "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. The lowest uncompleted group is stamped on the shared entity as currentGrp so boards can pulse exactly the live pads (0 = no group open / ungrouped pads). RESTART unlights every pad and resets the set. Renders nothing; boards draw the pads and read lit from the shared entity (the render authority).",
+      "description": "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. The lowest uncompleted group is stamped on the shared entity as currentGrp so boards can pulse exactly the live pads (0 = no group open / ungrouped pads). RESTART unlights every pad and resets the set. Renders nothing; boards draw the pads and read lit from the shared entity (the render authority). Corresponds to the design-sheet field(s): challenge, mechanics.",
       "defaultOrbitalName": "PadLockOrbital",
       "statePattern": "active",
       "complexity": {
@@ -154295,6 +154320,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -154639,6 +154665,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -154973,7 +155000,7 @@
       "topic": "ui/game",
       "family": "ui/game",
       "layer": "UI Patterns",
-      "description": "Headless patrol-hazard mechanic for side-view boards: moves each configured patrol back and forth along its [x0, x1] beat at its own speed (33ms tick, ping-pong with clamped turnarounds; a patrol declaring waveAmp/wavePeriod also bobs vertically — cy = y + waveAmp·sin(2πt/wavePeriod from a per-row time accumulator — and the hit test and render read cy, so a waveAmp of 0 keeps the flat beat), tracks the player position off the body authority's BODY_MOVED, and emits PATROL_HIT once per contact — a per-patrol hit flag re-arms only after the player separates, so damage rules stay sparse (when two patrols connect on the same tick the first reports; the other reports on the next tick). Patrols live on a [runtime, shared] entity for the render layer (boards draw them as markers/sprites); damage, lives, and respawn stay downstream (std-lives) — this atom simulates, it never judges. Renders nothing.",
+      "description": "Headless patrol-hazard mechanic for side-view boards: moves each configured patrol back and forth along its [x0, x1] beat at its own speed (33ms tick, ping-pong with clamped turnarounds; a patrol declaring waveAmp/wavePeriod also bobs vertically — cy = y + waveAmp·sin(2πt/wavePeriod from a per-row time accumulator — and the hit test and render read cy, so a waveAmp of 0 keeps the flat beat), tracks the player position off the body authority's BODY_MOVED, and emits PATROL_HIT once per contact — a per-patrol hit flag re-arms only after the player separates, so damage rules stay sparse (when two patrols connect on the same tick the first reports; the other reports on the next tick). Patrols live on a [runtime, shared] entity for the render layer (boards draw them as markers/sprites); damage, lives, and respawn stay downstream (std-lives) — this atom simulates, it never judges. Renders nothing. Corresponds to the design-sheet field(s): challenge, dynamics.",
       "defaultOrbitalName": "PatrolHazardOrbital",
       "statePattern": "active",
       "complexity": {
@@ -155071,6 +155098,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -155355,7 +155383,7 @@
       "topic": "ui/game",
       "family": "ui/game",
       "layer": "UI Patterns",
-      "description": "Headless side-view collectible authority — the platformer twin of grid std-gather. Listens BODY_MOVED and, when the player touches an uncollected feature (|dx| <= reachX, |dy| <= reachY of the feature center — the coef-pad touch idiom minus the grounded requirement, so airborne pickups work), stamps it collected on the shared entity and emits PICKED once per item (id, kind, position, glyph, message) plus COLLECT{total} with the running count (the event std-gate-lock already consumes). When every feature is collected it emits PICKUP_SET_COMPLETED once. RESTART re-arms every feature and zeroes the count. kind is board-defined vocabulary (star, boost, …) — this atom reports, boards judge. Renders nothing; boards draw the features and read collected from the shared entity.",
+      "description": "Headless side-view collectible authority — the platformer twin of grid std-gather. Listens BODY_MOVED and, when the player touches an uncollected feature (|dx| <= reachX, |dy| <= reachY of the feature center — the coef-pad touch idiom minus the grounded requirement, so airborne pickups work), stamps it collected on the shared entity and emits PICKED once per item (id, kind, position, glyph, message) plus COLLECT{total} with the running count (the event std-gate-lock already consumes). When every feature is collected it emits PICKUP_SET_COMPLETED once. RESTART re-arms every feature and zeroes the count. kind is board-defined vocabulary (star, boost, …) — this atom reports, boards judge. Renders nothing; boards draw the features and read collected from the shared entity. Corresponds to the design-sheet field(s): rewards.",
       "defaultOrbitalName": "PickupOrbital",
       "statePattern": "active",
       "complexity": {
@@ -155454,6 +155482,7 @@
         "std-patrol-hazard",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -155711,7 +155740,7 @@
       "topic": "ui/game",
       "family": "ui/game",
       "layer": "UI Patterns",
-      "description": "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). Drift regions: config.driftRegions lists axis-aligned rects each carrying a constant acceleration (ax, ay) applied with the same 0.033s dt whenever the body's center is inside (empty list = zero behavior change). 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, and the vertical velocity is the tangential projection (s = vx·cos θ, vy = s·sin θ — no discontinuous jumps at sample boundaries), 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.",
+      "description": "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). Drift regions: config.driftRegions lists axis-aligned rects each carrying a constant acceleration (ax, ay) applied with the same 0.033s dt whenever the body's center is inside (empty list = zero behavior change). 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, and the vertical velocity is the tangential projection (s = vx·cos θ, vy = s·sin θ — no discontinuous jumps at sample boundaries), 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. Corresponds to the design-sheet field(s): mechanics, dynamics.",
       "defaultOrbitalName": "PlatformerBodyOrbital",
       "statePattern": "active",
       "complexity": {
@@ -155839,6 +155868,7 @@
         "std-patrol-hazard",
         "std-pickup",
         "std-platformer-board-2d",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -156461,6 +156491,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-round-flow",
         "std-score",
         "std-service-accounting",
@@ -156769,6 +156800,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong-rally",
         "std-production",
         "std-score",
@@ -157032,6 +157064,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-service-accounting",
@@ -157299,6 +157332,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -157572,6 +157606,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -157808,6 +157843,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -158043,7 +158079,7 @@
       "topic": "ui/game",
       "family": "ui/game",
       "layer": "UI Patterns",
-      "description": "Tutorial modal with live-demo steps for game boards and learning shells: a paged overlay — title, a live previewTrait frame playing the mechanic via std-tutorial-autodemo (a bare game canvas, no shell chrome), one line of body copy, a step counter, and Back / Next / Skip — composed entirely from registered render types (stack + text + button + trait frame) into the overlay slot, so no new UI component is needed. autoShow opens it on INIT for first-time players; a board's help button re-opens it any time via SHOW (which rewinds to step one). DISMISS (or finishing the last step) marks the run done, clears the overlay, and emits TUTORIAL_DONE so the board can unpause or log. Steps are pure config — a board teaches a new mechanic by adding one { id, title, body, demoId } row plus a previewTrait binding.",
+      "description": "Tutorial modal with live-demo steps for game boards and learning shells: a paged overlay — title, a live previewTrait frame playing the mechanic via std-tutorial-autodemo (a bare game canvas, no shell chrome), one line of body copy, a step counter, and Back / Next / Skip — composed entirely from registered render types (stack + text + button + trait frame) into the overlay slot, so no new UI component is needed. autoShow opens it on INIT for first-time players; a board's help button re-opens it any time via SHOW (which rewinds to step one). DISMISS (or finishing the last step) marks the run done, clears the overlay, and emits TUTORIAL_DONE so the board can unpause or log. Steps are pure config — a board teaches a new mechanic by adding one { id, title, body, demoId } row plus a previewTrait binding. Corresponds to the design-sheet field(s): feedback, agency.",
       "defaultOrbitalName": "TutorialOverlayOrbital",
       "statePattern": "idle",
       "complexity": {
@@ -158116,6 +158152,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -158378,7 +158415,7 @@
       "topic": "ui/game",
       "family": "ui/game",
       "layer": "UI Patterns",
-      "description": "Headless velocity-gate mechanic: gates that open only when the player crosses them inside a speed band, optionally in a required direction, optionally sustained for a dwell. Listens BODY_MOVED and, per closed gate, tests the player's rect (padded by reachMargin), their speed against [minSpeed, maxSpeed], and their horizontal direction against dir (0 = either). Instant gates (dwellMs 0) open on the first passing cross; dwell gates (dwellMs > 0) accumulate ~33ms per passing move and open once held reaches dwellMs — a failing move resets the hold. The first newly opened gate emits VELOCITY_GATE_OPENED (the shared entity carries the rest). Entering a closed INSTANT gate while NOT passing emits VELOCITY_GATE_DENIED once per approach — re-arming only after the player steps out — so the board can answer with a PLACE back and a hint fx; dwell gates never deny (a hot entry is fine — coming to rest inside is the point), a failed hold simply resets. RESTART re-closes every gate. Renders nothing; boards draw the gate band/chest and read open/held from the shared entity (the render authority).",
+      "description": "Headless velocity-gate mechanic: gates that open only when the player crosses them inside a speed band, optionally in a required direction, optionally sustained for a dwell. Listens BODY_MOVED and, per closed gate, tests the player's rect (padded by reachMargin), their speed against [minSpeed, maxSpeed], and their horizontal direction against dir (0 = either). Instant gates (dwellMs 0) open on the first passing cross; dwell gates (dwellMs > 0) accumulate ~33ms per passing move and open once held reaches dwellMs — a failing move resets the hold. The first newly opened gate emits VELOCITY_GATE_OPENED (the shared entity carries the rest). Entering a closed INSTANT gate while NOT passing emits VELOCITY_GATE_DENIED once per approach — re-arming only after the player steps out — so the board can answer with a PLACE back and a hint fx; dwell gates never deny (a hot entry is fine — coming to rest inside is the point), a failed hold simply resets. RESTART re-closes every gate. Renders nothing; boards draw the gate band/chest and read open/held from the shared entity (the render authority). Corresponds to the design-sheet field(s): challenge, mechanics.",
       "defaultOrbitalName": "VelocityGateOrbital",
       "statePattern": "active",
       "complexity": {
@@ -158467,6 +158504,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -158829,6 +158867,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -159153,6 +159192,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -159450,6 +159490,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -159978,6 +160019,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -160546,6 +160588,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -161082,6 +161125,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -161886,6 +161930,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -162281,6 +162326,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -162669,6 +162715,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -163236,6 +163283,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -163568,6 +163616,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -164155,6 +164204,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -164524,6 +164574,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -165139,6 +165190,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -166206,6 +166258,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -167005,6 +167058,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -167505,6 +167559,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -167927,6 +167982,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -168257,6 +168313,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -168561,6 +168618,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -168838,6 +168896,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -169280,6 +169339,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -169700,6 +169760,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -170125,6 +170186,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -170570,6 +170632,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -170904,6 +170967,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -171498,6 +171562,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -171937,6 +172002,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -172242,6 +172308,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -172530,6 +172597,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -172877,6 +172945,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -173805,6 +173874,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -175546,6 +175616,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-purchase-order",
         "std-round-flow",
@@ -177712,6 +177783,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -180612,6 +180684,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -182964,6 +183037,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -184837,6 +184911,7 @@
         "std-patrol-hazard",
         "std-pickup",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -186621,6 +186696,1714 @@
       ],
       "sourceValid": true
     },
+    "std-platformer-puzzle": {
+      "name": "std-platformer-puzzle",
+      "level": "organism",
+      "topic": "ui/game",
+      "family": "ui/game",
+      "layer": "UI Patterns",
+      "description": "Platformer + puzzle genre substrate organism. Composes the standard authorities — platformer-body, pickup, objective-flow, choice-gate, fx-particles, fx-narrative, tutorial-overlay — and enforces five trait-typed pillar slots: agency, challenge, goal, reward, feedback. Levels consume this organism, fill every slot with a local rebinding trait, and add their own geometry, render, and math rules. Math targets and grade levels stay downstream in the domain package; this substrate is domain-agnostic.",
+      "defaultOrbitalName": "PlatformerPuzzleOrbital",
+      "statePattern": "idle",
+      "complexity": {
+        "states": 1,
+        "events": 1,
+        "transitions": 1
+      },
+      "defaultEntity": {
+        "name": "PlatformerPuzzleData",
+        "persistence": "runtime",
+        "fields": [
+          {
+            "name": "id",
+            "type": "string",
+            "required": true
+          },
+          {
+            "name": "body",
+            "type": "object",
+            "default": {
+              "facingRight": true,
+              "grounded": false,
+              "height": 1,
+              "vx": 0,
+              "vy": 0,
+              "width": 1,
+              "x": 0,
+              "y": 0
+            }
+          },
+          {
+            "name": "fell",
+            "type": "boolean",
+            "default": false
+          },
+          {
+            "name": "hazardId",
+            "type": "string",
+            "default": ""
+          },
+          {
+            "name": "goalId",
+            "type": "string",
+            "default": ""
+          },
+          {
+            "name": "skating",
+            "type": "boolean",
+            "default": false
+          },
+          {
+            "name": "curveMods",
+            "type": "array",
+            "default": []
+          },
+          {
+            "name": "tuning",
+            "type": "object",
+            "default": {}
+          },
+          {
+            "name": "pickups",
+            "type": "array",
+            "default": []
+          },
+          {
+            "name": "pickupCompleted",
+            "type": "boolean",
+            "default": false
+          },
+          {
+            "name": "total",
+            "type": "number",
+            "default": 0
+          },
+          {
+            "name": "choices",
+            "type": "array",
+            "default": []
+          },
+          {
+            "name": "result",
+            "type": "string",
+            "default": "none"
+          },
+          {
+            "name": "fx",
+            "type": "array",
+            "default": []
+          },
+          {
+            "name": "narrativeSeq",
+            "type": "number",
+            "default": 0
+          },
+          {
+            "name": "lastNarrative",
+            "type": "string",
+            "default": ""
+          },
+          {
+            "name": "step",
+            "type": "number",
+            "default": 0
+          },
+          {
+            "name": "done",
+            "type": "boolean",
+            "default": false
+          },
+          {
+            "name": "score",
+            "type": "number",
+            "default": 0
+          },
+          {
+            "name": "lives",
+            "type": "number",
+            "default": 3
+          },
+          {
+            "name": "objectivesLeft",
+            "type": "number",
+            "default": 1
+          },
+          {
+            "name": "celebrated",
+            "type": "boolean",
+            "default": false
+          }
+        ]
+      },
+      "defaultLabels": {
+        "title": "PlatformerPuzzleDatas",
+        "entitySingular": "PlatformerPuzzleData",
+        "entityPlural": "PlatformerPuzzleDatas"
+      },
+      "defaultIcons": [],
+      "composableWith": [
+        "std-arcade-board-3d",
+        "std-arcade-flow",
+        "std-arcade-play",
+        "std-area-fill",
+        "std-audio-cue",
+        "std-camera-rig",
+        "std-chase-ai",
+        "std-choice-gate",
+        "std-coef-pad",
+        "std-crew-board-2d",
+        "std-curve-fog",
+        "std-dungeon-board-2d",
+        "std-dungeon-combat",
+        "std-fx-narrative",
+        "std-fx-particles",
+        "std-fx-trail",
+        "std-gate-lock",
+        "std-gather",
+        "std-gold",
+        "std-grid-tactics",
+        "std-hero-nav",
+        "std-integration-settings",
+        "std-lives",
+        "std-loop-lock",
+        "std-market-board-3d",
+        "std-market-flow",
+        "std-mesh-asset-art",
+        "std-motion-body",
+        "std-objective-board-3d",
+        "std-objective-flow",
+        "std-objective-reach",
+        "std-pad-lock",
+        "std-patience",
+        "std-patrol-hazard",
+        "std-pickup",
+        "std-platformer-board-2d",
+        "std-platformer-body",
+        "std-production",
+        "std-round-flow",
+        "std-score",
+        "std-service-accounting",
+        "std-service-arxiv",
+        "std-service-banking",
+        "std-service-calendar",
+        "std-service-calendar-ical",
+        "std-service-cli",
+        "std-service-custom-bearer",
+        "std-service-database",
+        "std-service-deepagent",
+        "std-service-docker",
+        "std-service-drive",
+        "std-service-email",
+        "std-service-esign",
+        "std-service-github",
+        "std-service-iconify",
+        "std-service-llm",
+        "std-service-maps",
+        "std-service-marketplace",
+        "std-service-meta-ads",
+        "std-service-ml",
+        "std-service-oauth",
+        "std-service-otel",
+        "std-service-print",
+        "std-service-push",
+        "std-service-queue",
+        "std-service-redis",
+        "std-service-research-assistant",
+        "std-service-storage",
+        "std-service-stripe",
+        "std-service-twilio",
+        "std-service-webhook",
+        "std-service-wikimedia",
+        "std-service-youtube",
+        "std-survival-board-3d",
+        "std-survival-flow",
+        "std-svg-asset-art",
+        "std-tactics-board-2d",
+        "std-tactics-board-3d",
+        "std-tutorial-autodemo",
+        "std-tutorial-overlay",
+        "std-velocity-gate",
+        "std-worldmap-board-2d",
+        "std-xp",
+        "std-zone-card",
+        "ui-action-palette",
+        "ui-action-tile",
+        "ui-canvas",
+        "ui-canvas-2d",
+        "ui-choice-button",
+        "ui-control-button",
+        "ui-control-grid",
+        "ui-dialogue-bubble",
+        "ui-draw-fx-layer",
+        "ui-draw-group",
+        "ui-draw-mesh",
+        "ui-draw-shape",
+        "ui-draw-shape-layer",
+        "ui-draw-sprite",
+        "ui-draw-sprite-layer",
+        "ui-draw-text",
+        "ui-draw-text-layer",
+        "ui-game-audio-cue",
+        "ui-game-audio-toggle",
+        "ui-game-hud",
+        "ui-game-menu",
+        "ui-game-shell",
+        "ui-health-bar",
+        "ui-score-display",
+        "ui-sequence-bar",
+        "ui-stat-badge",
+        "ui-state-graph",
+        "ui-state-json-view",
+        "ui-timer-display",
+        "ui-trait-slot"
+      ],
+      "connectableEvents": [],
+      "eventPayloads": {},
+      "exposure": "palette",
+      "provenance": "generated",
+      "traits": [
+        {
+          "name": "PlatformerPuzzleBody",
+          "orbital": "PlatformerPuzzleOrbital",
+          "role": "authority",
+          "emittedEvents": [],
+          "listenedEvents": [],
+          "overridableConfigKeys": [
+            {
+              "key": "curveModsEnabled",
+              "type": "boolean",
+              "default": false,
+              "label": "Curve Mods Enabled",
+              "description": "When true, entity.curveMods reshape the skate surface inside each mod's x-range: the road samples the base curve at b·(x − h) and applies a·y + k (slope scales by a·b) — coefficient pads lift/tilt/compress the segment the player is riding. Multiple overlapping mods stack by summing each mod's delta from the base surface; a mod whose shifted sample leaves the curve range is skipped. Default off: boards without coef pads pay nothing.",
+              "tier": "domain"
+            },
+            {
+              "key": "driftRegions",
+              "type": "[BodyDriftRegion]",
+              "default": [],
+              "label": "Drift Regions",
+              "description": "Axis-aligned rects (x0..x1, y0..y1 in world units) each carrying a constant acceleration (ax, ay in units/s²) applied with the physics dt whenever the body's center is inside — winds, currents, gradient pushes. Empty list = zero behavior change.",
+              "tier": "domain",
+              "items": {
+                "properties": {
+                  "ax": {
+                    "name": "ax",
+                    "required": true,
+                    "type": "number"
+                  },
+                  "ay": {
+                    "name": "ay",
+                    "required": true,
+                    "type": "number"
+                  },
+                  "id": {
+                    "name": "id",
+                    "required": true,
+                    "type": "string"
+                  },
+                  "x0": {
+                    "name": "x0",
+                    "required": true,
+                    "type": "number"
+                  },
+                  "x1": {
+                    "name": "x1",
+                    "required": true,
+                    "type": "number"
+                  },
+                  "y0": {
+                    "name": "y0",
+                    "required": true,
+                    "type": "number"
+                  },
+                  "y1": {
+                    "name": "y1",
+                    "required": true,
+                    "type": "number"
+                  }
+                },
+                "type": "object"
+              }
+            },
+            {
+              "key": "gravity",
+              "type": "number",
+              "default": 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"
+            },
+            {
+              "key": "jumpStrength",
+              "type": "number",
+              "default": 11,
+              "label": "Jump Strength",
+              "description": "Vertical speed in units/s imparted by JUMP, directed against gravity; apex height ≈ jumpStrength² / (2·|gravity|)",
+              "tier": "domain"
+            },
+            {
+              "key": "killY",
+              "type": "number",
+              "default": 1000000,
+              "label": "Kill Y",
+              "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",
+              "tier": "domain"
+            },
+            {
+              "key": "maxFallSpeed",
+              "type": "number",
+              "default": 14,
+              "label": "Max Fall Speed",
+              "description": "Terminal velocity cap in units/s applied to vertical speed each tick",
+              "tier": "presentation"
+            },
+            {
+              "key": "moveSpeed",
+              "type": "number",
+              "default": 5,
+              "label": "Move Speed",
+              "description": "Horizontal run speed in units/s applied by STEER dir ±1",
+              "tier": "domain"
+            },
+            {
+              "key": "platforms",
+              "type": "[PlatformerPlatform]",
+              "default": [],
+              "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",
+              "items": {
+                "properties": {
+                  "height": {
+                    "name": "height",
+                    "required": true,
+                    "type": "number"
+                  },
+                  "id": {
+                    "name": "id",
+                    "required": false,
+                    "type": "string"
+                  },
+                  "type": {
+                    "name": "type",
+                    "required": false,
+                    "type": "string",
+                    "values": [
+                      "ground",
+                      "platform",
+                      "hazard",
+                      "goal"
+                    ]
+                  },
+                  "width": {
+                    "name": "width",
+                    "required": true,
+                    "type": "number"
+                  },
+                  "x": {
+                    "name": "x",
+                    "required": true,
+                    "type": "number"
+                  },
+                  "y": {
+                    "name": "y",
+                    "required": true,
+                    "type": "number"
+                  }
+                },
+                "type": "object"
+              }
+            },
+            {
+              "key": "running",
+              "type": "boolean",
+              "default": true,
+              "label": "Running",
+              "description": "When true the 33ms physics tick integrates and collides; toggle to freeze the body",
+              "tier": "domain"
+            },
+            {
+              "key": "skate",
+              "type": "boolean",
+              "default": 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. Engages when grounded, when landing on a tile, or when a falling (not rising) body passes within skateSnap above the surface.",
+              "tier": "domain"
+            },
+            {
+              "key": "skateCurve",
+              "type": "[PlatformerCurveSample]",
+              "default": [],
+              "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",
+              "items": {
+                "properties": {
+                  "x": {
+                    "name": "x",
+                    "required": true,
+                    "type": "number"
+                  },
+                  "y": {
+                    "name": "y",
+                    "required": true,
+                    "type": "number"
+                  }
+                },
+                "type": "object"
+              }
+            },
+            {
+              "key": "skateMaxGap",
+              "type": "number",
+              "default": 0,
+              "label": "Skate Max Gap",
+              "description": "Largest x-gap between consecutive skateCurve samples that still counts as surface. 0 = unlimited (sparse two-sample lines skate fine). Dense resampled curves with real gaps between segments (stitched worlds) MUST set this — otherwise the sampler invents a skatable chord across every gap (an invisible line above the bridge/terrain that the body snaps to and glides along).",
+              "tier": "domain"
+            },
+            {
+              "key": "skateSnap",
+              "type": "number",
+              "default": 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"
+            },
+            {
+              "key": "spawn",
+              "type": "PlatformerBody",
+              "default": {
+                "facingRight": true,
+                "grounded": false,
+                "height": 0.6,
+                "vx": 0,
+                "vy": 0,
+                "width": 0.6,
+                "x": 2,
+                "y": 8
+              },
+              "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",
+              "properties": {
+                "facingRight": {
+                  "name": "facingRight",
+                  "required": false,
+                  "type": "boolean"
+                },
+                "grounded": {
+                  "name": "grounded",
+                  "required": false,
+                  "type": "boolean"
+                },
+                "height": {
+                  "name": "height",
+                  "required": true,
+                  "type": "number"
+                },
+                "vx": {
+                  "name": "vx",
+                  "required": false,
+                  "type": "number"
+                },
+                "vy": {
+                  "name": "vy",
+                  "required": false,
+                  "type": "number"
+                },
+                "width": {
+                  "name": "width",
+                  "required": true,
+                  "type": "number"
+                },
+                "x": {
+                  "name": "x",
+                  "required": true,
+                  "type": "number"
+                },
+                "y": {
+                  "name": "y",
+                  "required": true,
+                  "type": "number"
+                }
+              }
+            },
+            {
+              "key": "xMax",
+              "type": "number",
+              "default": 1000000,
+              "label": "Right Wall",
+              "description": "Largest x the body's min corner may hold (world bounds, not level geometry)",
+              "tier": "presentation"
+            },
+            {
+              "key": "xMin",
+              "type": "number",
+              "default": -1000000,
+              "label": "Left Wall",
+              "description": "Smallest x the body's min corner may hold (world bounds, not level geometry)",
+              "tier": "presentation"
+            }
+          ],
+          "capabilities": [],
+          "ticks": [
+            {
+              "name": "physicsTick",
+              "interval": 33
+            }
+          ],
+          "rendersUi": false,
+          "ref": "Body.traits.PlatformerBody",
+          "category": "lifecycle",
+          "entityRebindable": true,
+          "linkedEntity": "PlatformerPuzzleData",
+          "entityContract": {
+            "requires": [],
+            "provides": [
+              "body",
+              "curveMods",
+              "fell",
+              "goalId",
+              "hazardId",
+              "skating",
+              "tuning"
+            ]
+          },
+          "transitionEvents": [
+            "CURVE_MOD_ADD",
+            "CURVE_MOD_CLEAR",
+            "INIT",
+            "JUMP",
+            "PLACE",
+            "RESTART",
+            "SET_TUNING",
+            "STEER"
+          ],
+          "definerKnobs": []
+        },
+        {
+          "name": "PlatformerPuzzlePickup",
+          "orbital": "PlatformerPuzzleOrbital",
+          "role": "reactor",
+          "emittedEvents": [],
+          "listenedEvents": [],
+          "overridableConfigKeys": [
+            {
+              "key": "features",
+              "type": "[PickupFeature]",
+              "default": [],
+              "label": "Features",
+              "description": "One row per collectible: id, center (x, y in world units), board-defined kind (star, boost, …), display glyph and message floated on pickup. collected is stamped at runtime.",
+              "tier": "domain",
+              "items": {
+                "properties": {
+                  "collected": {
+                    "name": "collected",
+                    "required": false,
+                    "type": "boolean"
+                  },
+                  "glyph": {
+                    "name": "glyph",
+                    "required": false,
+                    "type": "string"
+                  },
+                  "id": {
+                    "name": "id",
+                    "required": true,
+                    "type": "string"
+                  },
+                  "kind": {
+                    "name": "kind",
+                    "required": true,
+                    "type": "string"
+                  },
+                  "message": {
+                    "name": "message",
+                    "required": false,
+                    "type": "string"
+                  },
+                  "x": {
+                    "name": "x",
+                    "required": true,
+                    "type": "number"
+                  },
+                  "y": {
+                    "name": "y",
+                    "required": true,
+                    "type": "number"
+                  }
+                },
+                "type": "object"
+              }
+            },
+            {
+              "key": "reachX",
+              "type": "number",
+              "default": 0.7,
+              "label": "Reach X",
+              "description": "Horizontal tolerance (world units) around a feature's center when testing player contact.",
+              "tier": "domain"
+            },
+            {
+              "key": "reachY",
+              "type": "number",
+              "default": 1.2,
+              "label": "Reach Y",
+              "description": "Vertical tolerance (world units) around a feature's center when testing player contact; generous values catch fly-through pickups.",
+              "tier": "domain"
+            },
+            {
+              "key": "running",
+              "type": "boolean",
+              "default": true,
+              "label": "Running",
+              "description": "When true, BODY_MOVED collects touched features; toggle to freeze the set as-is.",
+              "tier": "domain"
+            }
+          ],
+          "capabilities": [],
+          "ticks": [],
+          "rendersUi": false,
+          "ref": "Pickup.traits.Pickup",
+          "category": "lifecycle",
+          "entityRebindable": true,
+          "linkedEntity": "PlatformerPuzzleData",
+          "entityContract": {
+            "requires": [],
+            "provides": [
+              "pickupCompleted",
+              "pickups",
+              "total"
+            ]
+          },
+          "transitionEvents": [
+            "BODY_MOVED",
+            "INIT",
+            "RESTART"
+          ],
+          "definerKnobs": []
+        },
+        {
+          "name": "PlatformerPuzzleObjective",
+          "orbital": "PlatformerPuzzleOrbital",
+          "role": "reactor",
+          "emittedEvents": [],
+          "listenedEvents": [],
+          "overridableConfigKeys": [
+            {
+              "key": "running",
+              "type": "boolean",
+              "default": true,
+              "label": "Running",
+              "description": "When true, PROGRESS signals resolve win/lose; toggle to freeze",
+              "tier": "domain"
+            }
+          ],
+          "capabilities": [],
+          "ticks": [],
+          "rendersUi": false,
+          "ref": "Gate.traits.ObjectiveFlow",
+          "category": "lifecycle",
+          "entityRebindable": true,
+          "linkedEntity": "PlatformerPuzzleData",
+          "entityContract": {
+            "requires": [],
+            "provides": [
+              "result"
+            ]
+          },
+          "transitionEvents": [
+            "INIT",
+            "PROGRESS",
+            "RESTART"
+          ],
+          "definerKnobs": []
+        },
+        {
+          "name": "PlatformerPuzzleChoice",
+          "orbital": "PlatformerPuzzleOrbital",
+          "role": "reactor",
+          "emittedEvents": [],
+          "listenedEvents": [],
+          "overridableConfigKeys": [
+            {
+              "key": "gates",
+              "type": "[ChoiceGate]",
+              "default": [],
+              "label": "Choice Gates",
+              "description": "One row per gate: id, gate center (x, y — y is the option-platform surface the judge tests against), the hint floated on a wrong answer, and the options: id, dx offset from the gate center, the label drawn above the platform, and correct. solved/chosen are stamped at runtime.",
+              "tier": "domain",
+              "items": {
+                "properties": {
+                  "chosen": {
+                    "name": "chosen",
+                    "required": false,
+                    "type": "string"
+                  },
+                  "hint": {
+                    "name": "hint",
+                    "required": false,
+                    "type": "string"
+                  },
+                  "id": {
+                    "name": "id",
+                    "required": true,
+                    "type": "string"
+                  },
+                  "options": {
+                    "name": "options",
+                    "required": true,
+                    "type": "array",
+                    "items": {
+                      "properties": {
+                        "correct": {
+                          "name": "correct",
+                          "required": true,
+                          "type": "boolean"
+                        },
+                        "dx": {
+                          "name": "dx",
+                          "required": true,
+                          "type": "number"
+                        },
+                        "id": {
+                          "name": "id",
+                          "required": true,
+                          "type": "string"
+                        },
+                        "label": {
+                          "name": "label",
+                          "required": true,
+                          "type": "string"
+                        }
+                      },
+                      "type": "object"
+                    }
+                  },
+                  "solved": {
+                    "name": "solved",
+                    "required": false,
+                    "type": "boolean"
+                  },
+                  "x": {
+                    "name": "x",
+                    "required": true,
+                    "type": "number"
+                  },
+                  "y": {
+                    "name": "y",
+                    "required": true,
+                    "type": "number"
+                  }
+                },
+                "type": "object"
+              }
+            },
+            {
+              "key": "reachX",
+              "type": "number",
+              "default": 0.7,
+              "label": "Reach X",
+              "description": "Horizontal tolerance (world units) around an option platform's center when testing a landing (approximates the body's half-width plus a step).",
+              "tier": "domain"
+            },
+            {
+              "key": "reachY",
+              "type": "number",
+              "default": 1.2,
+              "label": "Reach Y",
+              "description": "Vertical tolerance (world units) around the gate's option plane when testing a landing (covers small hops onto the platform surface).",
+              "tier": "domain"
+            },
+            {
+              "key": "running",
+              "type": "boolean",
+              "default": true,
+              "label": "Running",
+              "description": "When true, BODY_MOVED judges option landings; toggle to freeze every gate as-is.",
+              "tier": "domain"
+            }
+          ],
+          "capabilities": [],
+          "ticks": [],
+          "rendersUi": false,
+          "ref": "Choice.traits.ChoiceGate",
+          "category": "lifecycle",
+          "entityRebindable": true,
+          "linkedEntity": "PlatformerPuzzleData",
+          "entityContract": {
+            "requires": [],
+            "provides": [
+              "choices"
+            ]
+          },
+          "transitionEvents": [
+            "BODY_MOVED",
+            "INIT",
+            "RESTART"
+          ],
+          "definerKnobs": []
+        },
+        {
+          "name": "PlatformerPuzzleFx",
+          "orbital": "PlatformerPuzzleOrbital",
+          "role": "authority",
+          "emittedEvents": [],
+          "listenedEvents": [],
+          "overridableConfigKeys": [
+            {
+              "key": "decayRate",
+              "type": "number",
+              "default": 1,
+              "label": "Decay Rate",
+              "description": "Ttl units removed from every fx entry each tick; higher fades particles faster.",
+              "tier": "domain"
+            },
+            {
+              "key": "fx",
+              "type": "[Fx]",
+              "default": [],
+              "label": "Initial Fx",
+              "description": "Seed particles rendered before the first BURST; usually empty.",
+              "tier": "domain",
+              "items": {
+                "properties": {
+                  "animation": {
+                    "name": "animation",
+                    "required": false,
+                    "type": "string"
+                  },
+                  "bornAt": {
+                    "name": "bornAt",
+                    "required": false,
+                    "type": "number"
+                  },
+                  "color": {
+                    "name": "color",
+                    "required": false,
+                    "type": "string"
+                  },
+                  "effect": {
+                    "name": "effect",
+                    "required": false,
+                    "type": "string"
+                  },
+                  "id": {
+                    "name": "id",
+                    "required": true,
+                    "type": "string"
+                  },
+                  "maxTtl": {
+                    "name": "maxTtl",
+                    "required": false,
+                    "type": "number"
+                  },
+                  "message": {
+                    "name": "message",
+                    "required": false,
+                    "type": "string"
+                  },
+                  "particleCount": {
+                    "name": "particleCount",
+                    "required": false,
+                    "type": "number"
+                  },
+                  "size": {
+                    "name": "size",
+                    "required": false,
+                    "type": "number"
+                  },
+                  "space": {
+                    "name": "space",
+                    "required": false,
+                    "type": "string"
+                  },
+                  "ttl": {
+                    "name": "ttl",
+                    "required": true,
+                    "type": "number"
+                  },
+                  "type": {
+                    "name": "type",
+                    "required": true,
+                    "type": "string"
+                  },
+                  "vx": {
+                    "name": "vx",
+                    "required": false,
+                    "type": "number"
+                  },
+                  "vy": {
+                    "name": "vy",
+                    "required": false,
+                    "type": "number"
+                  },
+                  "vz": {
+                    "name": "vz",
+                    "required": false,
+                    "type": "number"
+                  },
+                  "x": {
+                    "name": "x",
+                    "required": true,
+                    "type": "number"
+                  },
+                  "y": {
+                    "name": "y",
+                    "required": false,
+                    "type": "number"
+                  },
+                  "z": {
+                    "name": "z",
+                    "required": false,
+                    "type": "number"
+                  }
+                },
+                "type": "object"
+              }
+            },
+            {
+              "key": "running",
+              "type": "boolean",
+              "default": true,
+              "label": "Running",
+              "description": "When true the decay tick runs; toggle to freeze effects.",
+              "tier": "domain"
+            }
+          ],
+          "capabilities": [],
+          "ticks": [
+            {
+              "name": "fxTick",
+              "interval": 500
+            }
+          ],
+          "rendersUi": false,
+          "ref": "Particles.traits.FxParticles",
+          "category": "lifecycle",
+          "entityRebindable": true,
+          "linkedEntity": "PlatformerPuzzleData",
+          "entityContract": {
+            "requires": [],
+            "provides": [
+              "fx"
+            ]
+          },
+          "transitionEvents": [
+            "BURST",
+            "INIT",
+            "RESTART"
+          ],
+          "definerKnobs": []
+        },
+        {
+          "name": "PlatformerPuzzleNarrative",
+          "orbital": "PlatformerPuzzleOrbital",
+          "role": "reactor",
+          "emittedEvents": [],
+          "listenedEvents": [],
+          "overridableConfigKeys": [
+            {
+              "key": "running",
+              "type": "boolean",
+              "default": true,
+              "label": "Running",
+              "description": "When false all narrative events are ignored.",
+              "tier": "domain"
+            },
+            {
+              "key": "styles",
+              "type": "Map<string,StyleDef>",
+              "default": {
+                "celebrate": {
+                  "color": "#facc15",
+                  "effect": "sparkle",
+                  "size": 0.9,
+                  "ttl": 3
+                },
+                "fact": {
+                  "color": "#38bdf8",
+                  "effect": "float-text",
+                  "size": 0.7,
+                  "ttl": 3
+                },
+                "hint": {
+                  "color": "#a78bfa",
+                  "effect": "float-text",
+                  "size": 0.6,
+                  "ttl": 2
+                },
+                "warn": {
+                  "color": "#f87171",
+                  "effect": "shake",
+                  "size": 0.6,
+                  "ttl": 1.5
+                }
+              },
+              "label": "Styles",
+              "description": "Map of narrative style to color, size, ttl, and effect. Override per game theme.",
+              "tier": "presentation",
+              "items": {
+                "properties": {
+                  "color": {
+                    "name": "color",
+                    "required": true,
+                    "type": "string"
+                  },
+                  "effect": {
+                    "name": "effect",
+                    "required": true,
+                    "type": "string"
+                  },
+                  "size": {
+                    "name": "size",
+                    "required": true,
+                    "type": "number"
+                  },
+                  "ttl": {
+                    "name": "ttl",
+                    "required": true,
+                    "type": "number"
+                  }
+                },
+                "type": "object"
+              }
+            }
+          ],
+          "capabilities": [],
+          "ticks": [],
+          "rendersUi": false,
+          "ref": "Narrative.traits.FxNarrative",
+          "category": "lifecycle",
+          "entityRebindable": true,
+          "linkedEntity": "PlatformerPuzzleData",
+          "entityContract": {
+            "requires": [],
+            "provides": [
+              "lastText",
+              "seq"
+            ]
+          },
+          "transitionEvents": [
+            "INIT",
+            "NARRATE",
+            "TUTORIAL_SHOW"
+          ],
+          "definerKnobs": []
+        },
+        {
+          "name": "PlatformerPuzzleTutorial",
+          "orbital": "PlatformerPuzzleOrbital",
+          "role": "renderer",
+          "emittedEvents": [],
+          "listenedEvents": [],
+          "overridableConfigKeys": [
+            {
+              "key": "autoShow",
+              "type": "boolean",
+              "default": false,
+              "label": "Auto Show",
+              "description": "When true the tutorial opens on INIT for this run; when false it stays hidden until SHOW.",
+              "tier": "domain"
+            },
+            {
+              "key": "previewTrait",
+              "type": "trait",
+              "default": "@trait.PlatformerPuzzleNoopPreview",
+              "label": "Preview trait",
+              "description": "Trait rendered in the media position of the modal — the live, demo-driven preview of the mechanic (a bare game canvas, no shell chrome). '@trait.TutorialEmptyPreview' leaves the slot blank. Override with '@trait.<TraitName>' to show a board's live frame.",
+              "tier": "presentation"
+            },
+            {
+              "key": "steps",
+              "type": "[TutorialStep]",
+              "default": [],
+              "label": "Steps",
+              "description": "One row per tutorial page: title, one line of body copy, and an optional demoId that plays a scripted live demo (std-tutorial-autodemo) for the mechanic being taught.",
+              "tier": "presentation",
+              "items": {
+                "properties": {
+                  "body": {
+                    "name": "body",
+                    "required": false,
+                    "type": "string"
+                  },
+                  "demoId": {
+                    "name": "demoId",
+                    "required": false,
+                    "type": "string"
+                  },
+                  "id": {
+                    "name": "id",
+                    "required": true,
+                    "type": "string"
+                  },
+                  "title": {
+                    "name": "title",
+                    "required": true,
+                    "type": "string"
+                  }
+                },
+                "type": "object"
+              }
+            }
+          ],
+          "capabilities": [],
+          "ticks": [],
+          "rendersUi": true,
+          "ref": "Tutorial.traits.TutorialOverlay",
+          "category": "interaction",
+          "entityRebindable": true,
+          "linkedEntity": "PlatformerPuzzleData",
+          "entityContract": {
+            "requires": [],
+            "provides": [
+              "done",
+              "step"
+            ]
+          },
+          "transitionEvents": [
+            "INIT",
+            "SHOW",
+            "TUT_AUTO",
+            "TUT_BACK",
+            "TUT_DISMISS",
+            "TUT_NEXT"
+          ],
+          "definerKnobs": []
+        },
+        {
+          "name": "PlatformerPuzzleNoopPreview",
+          "orbital": "PlatformerPuzzleOrbital",
+          "role": "reactor",
+          "emittedEvents": [],
+          "listenedEvents": [],
+          "overridableConfigKeys": [],
+          "capabilities": [],
+          "ticks": [],
+          "rendersUi": false,
+          "category": "interaction",
+          "linkedEntity": "PlatformerPuzzleData",
+          "transitionEvents": [
+            "INIT"
+          ],
+          "events": [
+            {
+              "name": "INIT",
+              "direction": "listen"
+            }
+          ],
+          "definerKnobs": []
+        },
+        {
+          "name": "PlatformerPuzzle",
+          "orbital": "PlatformerPuzzleOrbital",
+          "role": "reactor",
+          "emittedEvents": [],
+          "listenedEvents": [],
+          "overridableConfigKeys": [
+            {
+              "key": "agencyTrait",
+              "type": "trait",
+              "label": "Agency trait",
+              "description": "Trait that provides player verbs and immediate response. Usually a rebinding of std-platformer-body, std-motion-body, or std-hero-nav.",
+              "tier": "domain"
+            },
+            {
+              "key": "backgroundAsset",
+              "type": "Asset",
+              "default": {},
+              "label": "Background Asset",
+              "description": "Game-shell background panel sprite (theme chrome).",
+              "tier": "presentation",
+              "properties": {
+                "animations": {
+                  "name": "animations",
+                  "required": false,
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                "aspect": {
+                  "name": "aspect",
+                  "required": false,
+                  "type": "string"
+                },
+                "atlas": {
+                  "name": "atlas",
+                  "required": false,
+                  "type": "string"
+                },
+                "category": {
+                  "name": "category",
+                  "required": false,
+                  "type": "string"
+                },
+                "dimension": {
+                  "name": "dimension",
+                  "required": false,
+                  "type": "string"
+                },
+                "name": {
+                  "name": "name",
+                  "required": false,
+                  "type": "string"
+                },
+                "role": {
+                  "name": "role",
+                  "required": false,
+                  "type": "string"
+                },
+                "sprite": {
+                  "name": "sprite",
+                  "required": false,
+                  "type": "string"
+                },
+                "style": {
+                  "name": "style",
+                  "required": false,
+                  "type": "string"
+                },
+                "thumbnailUrl": {
+                  "name": "thumbnailUrl",
+                  "required": false,
+                  "type": "string"
+                },
+                "url": {
+                  "name": "url",
+                  "required": false,
+                  "type": "string"
+                },
+                "variant": {
+                  "name": "variant",
+                  "required": false,
+                  "type": "string"
+                }
+              }
+            },
+            {
+              "key": "challengeTrait",
+              "type": "trait",
+              "label": "Challenge trait",
+              "description": "Trait that provides the obstacle, decision, or opposition. Usually a rebinding of std-choice-gate, std-gate-lock, std-patrol-hazard, std-velocity-gate, std-loop-lock, or std-pad-lock.",
+              "tier": "domain"
+            },
+            {
+              "key": "directionAssets",
+              "type": "DirectionAssets",
+              "default": {},
+              "label": "Direction Assets",
+              "description": "D-pad direction icon sprites.",
+              "tier": "presentation",
+              "properties": {
+                "down": {
+                  "name": "down",
+                  "required": false,
+                  "properties": {
+                    "animations": {
+                      "name": "animations",
+                      "required": false,
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      }
+                    },
+                    "aspect": {
+                      "name": "aspect",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "atlas": {
+                      "name": "atlas",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "category": {
+                      "name": "category",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "dimension": {
+                      "name": "dimension",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "name": {
+                      "name": "name",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "role": {
+                      "name": "role",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "sprite": {
+                      "name": "sprite",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "style": {
+                      "name": "style",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "thumbnailUrl": {
+                      "name": "thumbnailUrl",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "url": {
+                      "name": "url",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "variant": {
+                      "name": "variant",
+                      "required": false,
+                      "type": "string"
+                    }
+                  },
+                  "type": "object"
+                },
+                "left": {
+                  "name": "left",
+                  "required": false,
+                  "properties": {
+                    "animations": {
+                      "name": "animations",
+                      "required": false,
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      }
+                    },
+                    "aspect": {
+                      "name": "aspect",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "atlas": {
+                      "name": "atlas",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "category": {
+                      "name": "category",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "dimension": {
+                      "name": "dimension",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "name": {
+                      "name": "name",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "role": {
+                      "name": "role",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "sprite": {
+                      "name": "sprite",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "style": {
+                      "name": "style",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "thumbnailUrl": {
+                      "name": "thumbnailUrl",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "url": {
+                      "name": "url",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "variant": {
+                      "name": "variant",
+                      "required": false,
+                      "type": "string"
+                    }
+                  },
+                  "type": "object"
+                },
+                "right": {
+                  "name": "right",
+                  "required": false,
+                  "properties": {
+                    "animations": {
+                      "name": "animations",
+                      "required": false,
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      }
+                    },
+                    "aspect": {
+                      "name": "aspect",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "atlas": {
+                      "name": "atlas",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "category": {
+                      "name": "category",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "dimension": {
+                      "name": "dimension",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "name": {
+                      "name": "name",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "role": {
+                      "name": "role",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "sprite": {
+                      "name": "sprite",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "style": {
+                      "name": "style",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "thumbnailUrl": {
+                      "name": "thumbnailUrl",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "url": {
+                      "name": "url",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "variant": {
+                      "name": "variant",
+                      "required": false,
+                      "type": "string"
+                    }
+                  },
+                  "type": "object"
+                },
+                "up": {
+                  "name": "up",
+                  "required": false,
+                  "properties": {
+                    "animations": {
+                      "name": "animations",
+                      "required": false,
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      }
+                    },
+                    "aspect": {
+                      "name": "aspect",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "atlas": {
+                      "name": "atlas",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "category": {
+                      "name": "category",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "dimension": {
+                      "name": "dimension",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "name": {
+                      "name": "name",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "role": {
+                      "name": "role",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "sprite": {
+                      "name": "sprite",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "style": {
+                      "name": "style",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "thumbnailUrl": {
+                      "name": "thumbnailUrl",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "url": {
+                      "name": "url",
+                      "required": false,
+                      "type": "string"
+                    },
+                    "variant": {
+                      "name": "variant",
+                      "required": false,
+                      "type": "string"
+                    }
+                  },
+                  "type": "object"
+                }
+              }
+            },
+            {
+              "key": "feedbackTrait",
+              "type": "trait",
+              "label": "Feedback trait",
+              "description": "Trait that provides visual, audio, or narrative feedback. Usually a rebinding of std-fx-particles, std-fx-narrative, std-tutorial-overlay, std-audio-cue, or std-zone-card.",
+              "tier": "domain"
+            },
+            {
+              "key": "goalTrait",
+              "type": "trait",
+              "label": "Goal trait",
+              "description": "Trait that resolves the win condition. Usually a rebinding of std-objective-flow or std-objective-reach.",
+              "tier": "domain"
+            },
+            {
+              "key": "hudBackgroundAsset",
+              "type": "Asset",
+              "default": {},
+              "label": "HUD Background Asset",
+              "description": "HUD panel background sprite (theme chrome).",
+              "tier": "presentation",
+              "properties": {
+                "animations": {
+                  "name": "animations",
+                  "required": false,
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                "aspect": {
+                  "name": "aspect",
+                  "required": false,
+                  "type": "string"
+                },
+                "atlas": {
+                  "name": "atlas",
+                  "required": false,
+                  "type": "string"
+                },
+                "category": {
+                  "name": "category",
+                  "required": false,
+                  "type": "string"
+                },
+                "dimension": {
+                  "name": "dimension",
+                  "required": false,
+                  "type": "string"
+                },
+                "name": {
+                  "name": "name",
+                  "required": false,
+                  "type": "string"
+                },
+                "role": {
+                  "name": "role",
+                  "required": false,
+                  "type": "string"
+                },
+                "sprite": {
+                  "name": "sprite",
+                  "required": false,
+                  "type": "string"
+                },
+                "style": {
+                  "name": "style",
+                  "required": false,
+                  "type": "string"
+                },
+                "thumbnailUrl": {
+                  "name": "thumbnailUrl",
+                  "required": false,
+                  "type": "string"
+                },
+                "url": {
+                  "name": "url",
+                  "required": false,
+                  "type": "string"
+                },
+                "variant": {
+                  "name": "variant",
+                  "required": false,
+                  "type": "string"
+                }
+              }
+            },
+            {
+              "key": "rewardTrait",
+              "type": "trait",
+              "label": "Reward trait",
+              "description": "Trait that provides collectibles or scoring. Usually a rebinding of std-pickup, std-score, std-xp, or std-gold.",
+              "tier": "domain"
+            }
+          ],
+          "capabilities": [],
+          "ticks": [],
+          "rendersUi": false,
+          "category": "interaction",
+          "entityRebindable": true,
+          "linkedEntity": "PlatformerPuzzleData",
+          "entityContract": {
+            "requires": [],
+            "provides": []
+          },
+          "transitionEvents": [
+            "INIT"
+          ],
+          "events": [
+            {
+              "name": "INIT",
+              "direction": "listen"
+            }
+          ],
+          "definerKnobs": []
+        }
+      ],
+      "factoryPath": "behaviors/functions/ui/game/organisms/std-platformer-puzzle.ts",
+      "roles": [
+        "authority",
+        "reactor",
+        "renderer"
+      ],
+      "sourceValid": true
+    },
     "std-survival-board-3d": {
       "name": "std-survival-board-3d",
       "level": "organism",
@@ -186899,6 +188682,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-pong",
         "std-pong-rally",
         "std-production",
@@ -188660,6 +190444,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-purchase-order",
         "std-round-flow",
@@ -190663,6 +192448,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-purchase-order",
         "std-round-flow",
@@ -192742,6 +194528,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",
@@ -194353,6 +196140,7 @@
         "std-pickup",
         "std-platformer-board-2d",
         "std-platformer-body",
+        "std-platformer-puzzle",
         "std-production",
         "std-round-flow",
         "std-score",