@typecad/ui 1.0.0-alpha.7 → 1.0.0-alpha.8

package/dist/ui-engine/runtime-header/paint-order-coords.js

@@ -30,12 +30,12 @@ static inline uint8_t ui_node_draws_before(uint16_t a, uint16_t b) {
 // re-scanning all nodes for every dirty repaint (O(D·N)).
 static inline void ui_build_draw_order() {
   if (__ui_draw_order || __ui_node_count == 0) return;
-  __ui_draw_order = (uint16_t*)malloc((size_t)__ui_node_count * sizeof(uint16_t));
+  __ui_draw_order = new (std::nothrow) uint16_t[__ui_node_count];
   if (!__ui_draw_order) return;
   for (uint16_t i = 0; i < __ui_node_count; i++) __ui_draw_order[i] = i;
   for (uint16_t a = 1; a < __ui_node_count; a++) {
     uint16_t key = __ui_draw_order[a];
-    int16_t j = (int16_t)a - 1;
+    int16_t j = static_cast<int16_t>(a) - 1;
     while (j >= 0 && ui_node_draws_before(key, __ui_draw_order[j])) {
       __ui_draw_order[j + 1] = __ui_draw_order[j];
       j--;
@@ -44,24 +44,24 @@ static inline void ui_build_draw_order() {
   }
 }
 
-// Index generic (non-list) scroll containers once so scroll prep doesn't scan
-// every node each frame.
+// Index scroll containers once so touch/wheel ownership doesn't scan unrelated
+// nodes each frame.
 static inline void ui_build_scroll_owner_table() {
   if (__ui_scroll_owners || __ui_node_count == 0) return;
   uint16_t count = 0;
   for (uint16_t i = 0; i < __ui_node_count; i++) {
-    if (__ui_nodes[i].scrollable && !__ui_nodes[i].virtualized) count++;
+    if (__ui_nodes[i].scrollable) count++;
   }
   __ui_scroll_owner_count = count;
   if (!count) return;
-  __ui_scroll_owners = (uint16_t*)malloc((size_t)count * sizeof(uint16_t));
+  __ui_scroll_owners = new (std::nothrow) uint16_t[count];
   if (!__ui_scroll_owners) {
     __ui_scroll_owner_count = 0;
     return;
   }
   uint16_t w = 0;
   for (uint16_t i = 0; i < __ui_node_count; i++) {
-    if (__ui_nodes[i].scrollable && !__ui_nodes[i].virtualized) {
+    if (__ui_nodes[i].scrollable) {
       __ui_scroll_owners[w++] = i;
     }
   }
@@ -138,24 +138,54 @@ static inline int16_t ui_draw_y_for_node(uint16_t nodeIdx) {
 // misses. Returns the topmost such node by draw order, or -1 if none.
 static inline int16_t ui_scroll_node_at(int16_t tx, int16_t ty) {
   int16_t bestScroll = -1;
-  for (uint16_t i = 0; i < __ui_node_count; i++) {
-    if (!__ui_nodes[i].scrollable || !ui_is_effectively_visible(i)) continue;
-    if (__ui_nodes[i].screenId != __ui_active_screen) continue;
-    if (__ui_nodes[i].contentHeight <= __ui_nodes[i].box.h) continue;
-    int16_t drawX = ui_draw_x_for_node((uint16_t)i);
-    int16_t drawY = ui_draw_y_for_node((uint16_t)i);
-    if (tx >= drawX && tx < drawX + __ui_nodes[i].box.w &&
-        ty >= drawY && ty < drawY + __ui_nodes[i].box.h) {
-      if (bestScroll < 0 || ui_node_draws_before((uint16_t)bestScroll, i)) bestScroll = (int16_t)i;
+  if (__ui_scroll_owners) {
+    for (uint16_t oi = 0; oi < __ui_scroll_owner_count; oi++) {
+      uint16_t i = __ui_scroll_owners[oi];
+      if (!ui_is_effectively_visible(i)) continue;
+      if (__ui_nodes[i].screenId != __ui_active_screen) continue;
+      if (__ui_nodes[i].contentHeight <= __ui_nodes[i].box.h) continue;
+      int16_t drawX = ui_draw_x_for_node(i);
+      int16_t drawY = ui_draw_y_for_node(i);
+      if (tx >= drawX && tx < drawX + __ui_nodes[i].box.w &&
+          ty >= drawY && ty < drawY + __ui_nodes[i].box.h &&
+          (bestScroll < 0 || ui_node_draws_before(static_cast<uint16_t>(bestScroll), i))) {
+        bestScroll = static_cast<int16_t>(i);
+      }
+    }
+  } else {
+    for (uint16_t i = 0; i < __ui_node_count; i++) {
+      if (!__ui_nodes[i].scrollable || !ui_is_effectively_visible(i)) continue;
+      if (__ui_nodes[i].screenId != __ui_active_screen) continue;
+      if (__ui_nodes[i].contentHeight <= __ui_nodes[i].box.h) continue;
+      int16_t drawX = ui_draw_x_for_node(i);
+      int16_t drawY = ui_draw_y_for_node(i);
+      if (tx >= drawX && tx < drawX + __ui_nodes[i].box.w &&
+          ty >= drawY && ty < drawY + __ui_nodes[i].box.h &&
+          (bestScroll < 0 || ui_node_draws_before(static_cast<uint16_t>(bestScroll), i))) {
+        bestScroll = static_cast<int16_t>(i);
+      }
     }
   }
   return bestScroll;
 }
 
+// Resolve the actual backdrop for a node by walking painted ancestors. A direct
+// parent may be transparent; using its clearColor there can blend against the
+// wrong layer when siblings or an opaque grandparent are behind the node.
 static inline UI_COLOR_T ui_parent_clear_color(uint16_t nodeIdx) {
   uint16_t p = __ui_nodes[nodeIdx].parent;
-  if (p != UI_NO_PARENT && p < __ui_node_count) {
-    return __ui_nodes[p].hasBg ? __ui_nodes[p].bg : __ui_nodes[p].clearColor;
+  while (p != UI_NO_PARENT && p < __ui_node_count) {
+    if (__ui_nodes[p].hasBg) {
+      UI_COLOR_T backdrop = __ui_nodes[p].bg;
+      if (__ui_nodes[p].opacity < 100) {
+        uint16_t pp = __ui_nodes[p].parent;
+        UI_COLOR_T under = __ui_nodes[p].clearColor;
+        if (pp != UI_NO_PARENT && pp < __ui_node_count) under = ui_parent_clear_color(p);
+        backdrop = ui_blend(backdrop, under, __ui_nodes[p].opacity);
+      }
+      return backdrop;
+    }
+    p = __ui_nodes[p].parent;
   }
   return __ui_nodes[nodeIdx].clearColor;
 }

package/dist/ui-engine/runtime-header/paint-rects-repair.js

@@ -9,11 +9,11 @@ static inline void ui_node_paint_rect(uint16_t nodeIdx, int16_t baseX, int16_t b
 
   int16_t faceW = __ui_nodes[nodeIdx].box.w;
   int16_t faceH = __ui_nodes[nodeIdx].box.h;
-  if (__ui_nodes[nodeIdx].kind == NODE_TEXT || __ui_nodes[nodeIdx].kind == NODE_CHECK || __ui_nodes[nodeIdx].kind == NODE_RADIO) {
+  if (__ui_nodes[nodeIdx].kind == NODE_TEXT || __ui_nodes[nodeIdx].kind == NODE_CHECK || __ui_nodes[nodeIdx].kind == NODE_RADIO || __ui_nodes[nodeIdx].kind == NODE_SELECT) {
     if (__ui_nodes[nodeIdx].lastTextWidth > faceW) faceW = __ui_nodes[nodeIdx].lastTextWidth;
     if (__ui_nodes[nodeIdx].lastTextHeight > faceH) faceH = __ui_nodes[nodeIdx].lastTextHeight;
-    if ((int16_t)textW > faceW) faceW = (int16_t)textW;
-    if ((int16_t)textH > faceH) faceH = (int16_t)textH;
+    if (static_cast<int16_t>(textW) > faceW) faceW = static_cast<int16_t>(textW);
+    if (static_cast<int16_t>(textH) > faceH) faceH = static_cast<int16_t>(textH);
   }
   int16_t unrotatedFaceW = faceW;
   int16_t unrotatedFaceH = faceH;
@@ -137,11 +137,18 @@ static inline void ui_clear_press_offset_area(uint16_t nodeIdx, int16_t baseX, i
 
 // Generated-font / AA text and images draw per-pixel when sent straight to SPI.
 // Prefer the RAM paint canvas for these kinds (within the pixel budget).
+// NOTE: ALL NODE_TEXT is treated as pixel-heavy. Even the classic GFX bitmap
+// font renders via drawPixel per font pixel, and on an SPI TFT each drawPixel
+// is a full set_window+RAMWR SPI transaction (~30us) — a single 460x8 text band
+// costs >100ms direct-drawn. Forcing every text node through the paint canvas
+// turns that into one RAM render + one SPI push (~3ms). AA/generated-font text
+// additionally requires getPixel readback for coverage blending, which is only
+// correct against a RAM target.
 static inline uint8_t ui_pixel_heavy_node(uint16_t nodeIdx) {
   if (nodeIdx >= __ui_node_count) return 0;
   if (__ui_nodes[nodeIdx].kind == NODE_IMG) return 1;
-  if (__ui_nodes[nodeIdx].kind == NODE_TEXT &&
-      (__ui_nodes[nodeIdx].fontFace || __ui_nodes[nodeIdx].fontAntialias)) return 1;
+  if (__ui_nodes[nodeIdx].kind == NODE_TEXT) return 1;
+  if (__ui_nodes[nodeIdx].kind == NODE_SELECT) return 1;
   return 0;
 }
 
@@ -150,7 +157,7 @@ static inline uint8_t ui_should_buffer_paint(uint16_t nodeIdx, int16_t w, int16_
   if (__ui_nodes[nodeIdx].kind == NODE_LIST) return 0;
   // <canvas> elements batch via __ui_node_canvas when drawing to the display.
   if (__ui_nodes[nodeIdx].kind == NODE_CANVAS) return 0;
-  if ((uint32_t)w * (uint32_t)h > UI_MAX_BUFFERED_PAINT_PIXELS) return 0;
+  if (static_cast<uint32_t>(w) * static_cast<uint32_t>(h) > UI_MAX_BUFFERED_PAINT_PIXELS) return 0;
   if (ui_pixel_heavy_node(nodeIdx)) return 1;
   if (__ui_nodes[nodeIdx].kind == NODE_FILL &&
       __ui_nodes[nodeIdx].hasBg &&
@@ -167,7 +174,7 @@ static inline uint8_t ui_should_buffer_paint(uint16_t nodeIdx, int16_t w, int16_
   return 1;
 }
 
-static inline void ui_seed_paint_canvas_for_node(uint16_t nodeIdx, CuttlefishCanvas16* canvas, int16_t canvasX, int16_t canvasY) {
+static inline void ui_seed_paint_canvas_for_node(uint16_t nodeIdx, CuttlefishCanvas16* canvas, int16_t canvasX, int16_t canvasY, int16_t bandTop) {
   if (!canvas || !display_canvasBuffer(canvas)) return;
   uint16_t p = __ui_nodes[nodeIdx].parent;
   if (p == UI_NO_PARENT || p >= __ui_node_count) {
@@ -191,7 +198,11 @@ static inline void ui_seed_paint_canvas_for_node(uint16_t nodeIdx, CuttlefishCan
   CuttlefishDisplayTarget* previousGfx = ui_display_get_target();
   ui_display_set_target(canvas);
   __ui_nodes[p].box.x = parentDrawX - canvasX;
-  int16_t localY = parentDrawY - canvasY;
+  // Shift the parent's draw Y up by bandTop so the band canvas shows the
+  // correct slice of the parent fill/border for this band's Y range. bandTop=0
+  // (the main-loop caller) is a no-op shift. canvasY already carries the paint
+  // rect's display-space origin; bandTop further offsets within the rect.
+  int16_t localY = parentDrawY - canvasY - bandTop;
 
   // Parent fill color: blended toward the parent's backdrop when the parent is
   // translucent (matching the main NODE_FILL draw, which uses fillBg). Without
@@ -222,12 +233,17 @@ static inline void ui_seed_paint_canvas_for_node(uint16_t nodeIdx, CuttlefishCan
 
 static inline uint8_t ui_repair_current_node_paint_with_parent(uint16_t nodeIdx, UIRect* r) {
   if (!r || r->w <= 0 || r->h <= 0) return 0;
-  if ((uint32_t)r->w * (uint32_t)r->h > UI_MAX_BUFFERED_PAINT_PIXELS) return 0;
+  if (static_cast<uint32_t>(r->w) * static_cast<uint32_t>(r->h) > UI_MAX_BUFFERED_PAINT_PIXELS) return 0;
   CuttlefishCanvas16* repairCanvas = ui_get_repair_canvas(r->w, r->h);
   if (!repairCanvas) return 0;
-  ui_seed_paint_canvas_for_node(nodeIdx, repairCanvas, r->x, r->y);
-  ui_display_use_default_target();
+  ui_seed_paint_canvas_for_node(nodeIdx, repairCanvas, r->x, r->y, 0);
+  // During a retained-framebuffer tick, publish the repair into the RAM
+  // composition surface. Sending it to the live panel here creates the visible
+  // erase/redraw flash seen on animated transforms.
+  if (__ui_fb) ui_display_set_target((CuttlefishDisplayTarget*)__ui_fb);
+  else ui_display_use_default_target();
   ui_push_canvas_rect(repairCanvas, r->x, r->y, r->w, r->h);
+  ui_display_use_default_target();
   return 1;
 }
 
@@ -375,7 +391,8 @@ static inline void ui_clear_node_paint_rect(uint16_t nodeIdx, const UIRect* pain
   if (nodeIdx >= __ui_node_count || !paintRect || paintRect->w <= 0 || paintRect->h <= 0) return;
   int16_t scrollParent = ui_scroll_ancestor_for_node(nodeIdx);
   UIRect r = *paintRect;
-  ui_display_use_default_target();
+  if (__ui_fb) ui_display_set_target((CuttlefishDisplayTarget*)__ui_fb);
+  else ui_display_use_default_target();
   if (scrollParent >= 0) {
     UIRect clip = {
       __ui_nodes[scrollParent].box.x,
@@ -439,7 +456,7 @@ static inline uint8_t ui_try_repair_geometry_fill(uint16_t nodeIdx, const UIRect
   int16_t y0 = oldRect->y < newRect.y ? oldRect->y : newRect.y;
   int16_t x1 = oldRect->x + oldRect->w > newRect.x + newRect.w ? oldRect->x + oldRect->w : newRect.x + newRect.w;
   int16_t y1 = oldRect->y + oldRect->h > newRect.y + newRect.h ? oldRect->y + oldRect->h : newRect.y + newRect.h;
-  UIRect repair = { x0, y0, (int16_t)(x1 - x0), (int16_t)(y1 - y0) };
+  UIRect repair = { x0, y0, static_cast<int16_t>(x1 - x0), static_cast<int16_t>(y1 - y0) };
   int16_t scrollParent = ui_scroll_ancestor_for_node(nodeIdx);
   if (scrollParent >= 0) {
     UIRect clip = {
@@ -456,11 +473,11 @@ static inline uint8_t ui_try_repair_geometry_fill(uint16_t nodeIdx, const UIRect
     return 0;
   }
   if (repair.w <= 0 || repair.h <= 0) return 0;
-  if ((uint32_t)repair.w * (uint32_t)repair.h > UI_MAX_BUFFERED_PAINT_PIXELS) return 0;
+  if (static_cast<uint32_t>(repair.w) * static_cast<uint32_t>(repair.h) > UI_MAX_BUFFERED_PAINT_PIXELS) return 0;
   CuttlefishCanvas16* repairCanvas = ui_get_repair_canvas(repair.w, repair.h);
   if (!repairCanvas) return 0;
 
-  ui_seed_paint_canvas_for_node(nodeIdx, repairCanvas, repair.x, repair.y);
+  ui_seed_paint_canvas_for_node(nodeIdx, repairCanvas, repair.x, repair.y, 0);
   CuttlefishDisplayTarget* previousGfx = ui_display_get_target();
   ui_display_set_target(repairCanvas);
   UI_COLOR_T fillBg = __ui_nodes[nodeIdx].bg;
@@ -473,8 +490,12 @@ static inline uint8_t ui_try_repair_geometry_fill(uint16_t nodeIdx, const UIRect
   int16_t fillH = ui_rotated_face_h(nodeIdx, __ui_nodes[nodeIdx].box.w, __ui_nodes[nodeIdx].box.h);
   ui_display_fill_rect(drawX, drawY, fillW, fillH, fillBg);
   ui_display_set_target(previousGfx);
-  ui_display_use_default_target();
+  // Keep geometry repair off the physical panel when a retained framebuffer is
+  // active; the final dirty-bounds publish will send the old+new union once.
+  if (__ui_fb) ui_display_set_target((CuttlefishDisplayTarget*)__ui_fb);
+  else ui_display_use_default_target();
   ui_push_canvas_rect(repairCanvas, repair.x, repair.y, repair.w, repair.h);
+  ui_display_use_default_target();
   if (scrollParent >= 0) ui_invalidate_scroll_canvas_for_node(nodeIdx);
   ui_mark_overlapping_higher_layers_dirty_for_rect(nodeIdx, &repair);
   return 1;
@@ -530,7 +551,7 @@ static inline void ui_set_visible(uint16_t nodeIdx, uint8_t visible) {
     ui_clear_subtree_current_paint(nodeIdx);
     int16_t end = __ui_nodes[nodeIdx].subtreeEnd;
     if (end > __ui_node_count) end = __ui_node_count;
-    for (int16_t c = end - 1; c >= (int16_t)nodeIdx; c--) {
+    for (int16_t c = end - 1; c >= static_cast<int16_t>(nodeIdx); c--) {
       if (__ui_nodes[c].screenId != __ui_active_screen) continue;
       __ui_nodes[c].dirty = 0;
     }

package/dist/ui-engine/runtime-header/scroll-physics.js

@@ -9,15 +9,15 @@ export function emitScrollPhysics() {
 // 'none' tier compiles drag scroll out entirely.
 
 static inline int16_t ui_scroll_scale_dy(int16_t dy) {
-  int32_t scaled = (int32_t)dy * (int32_t)UI_SCROLL_DRAG_SCALE_X10;
-  return (int16_t)(scaled >= 0 ? (scaled + 5) / 10 : (scaled - 5) / 10);
+  int32_t scaled = static_cast<int32_t>(dy) * static_cast<int32_t>(UI_SCROLL_DRAG_SCALE_X10);
+  return static_cast<int16_t>(scaled >= 0 ? (scaled + 5) / 10 : (scaled - 5) / 10);
 }
 
 static inline int16_t ui_scroll_smooth_dy(int16_t dy) {
 #if UI_SCROLL_INPUT_TIER_CAPACITIVE
   return ui_scroll_scale_dy(dy);
 #elif UI_SCROLL_INPUT_TIER_RESISTIVE
-  int16_t db = (int16_t)UI_SCROLL_DEADBAND_PX;
+  int16_t db = static_cast<int16_t>(UI_SCROLL_DEADBAND_PX);
   if (dy >= -db && dy <= db) {
     // Deadband: kill per-sample jitter around zero. Steady drag (|dy|>db) below
     // passes through unchanged, so steady-state is 1:1 (spec Q1).
@@ -44,11 +44,11 @@ static inline int16_t ui_scroll_max(int16_t node) {
 // r = maxOverscroll * d / (d + stiffness). stiffness held as X10 fixed-point.
 static inline int16_t ui_scroll_overscroll_for(int16_t d) {
   if (d <= 0) return 0;
-  int16_t maxOv = (int16_t)UI_SCROLL_MAX_OVERSCROLL;
-  int16_t stiffX10 = (int16_t)UI_SCROLL_STIFFNESS_X10;
+  int16_t maxOv = static_cast<int16_t>(UI_SCROLL_MAX_OVERSCROLL);
+  int16_t stiffX10 = static_cast<int16_t>(UI_SCROLL_STIFFNESS_X10);
   if (stiffX10 <= 0) stiffX10 = 1;
-  int32_t r = ((int32_t)maxOv * (int32_t)d) / ((int32_t)d + (int32_t)stiffX10);
-  return r > maxOv ? maxOv : (int16_t)r;
+  int32_t r = (static_cast<int32_t>(maxOv) * static_cast<int32_t>(d)) / (static_cast<int32_t>(d) + static_cast<int32_t>(stiffX10));
+  return r > maxOv ? maxOv : static_cast<int16_t>(r);
 }
 
 // Apply a smoothed drag delta to the owning scroll node. Returns 1 if the view
@@ -56,6 +56,7 @@ static inline int16_t ui_scroll_overscroll_for(int16_t d) {
 // itself never leaves [0, maxScroll] so the committed position stays valid.
 static inline uint8_t ui_apply_scroll_delta(int16_t node, int16_t dy) {
   if (node < 0 || dy == 0) return 0;
+  if (__ui_scroll_render_locked && __ui_scroll_render_locked[node]) return 0;
   int16_t sy = __ui_nodes[node].scrollY;
   int16_t maxS = ui_scroll_max(node);
   int16_t nextY = sy - dy;
@@ -88,7 +89,7 @@ static inline uint8_t ui_apply_scroll_delta(int16_t node, int16_t dy) {
   }
   __ui_nodes[node].overscrollPx = nextOv;
   uint8_t changed = (__ui_nodes[node].scrollY != sy) || (nextOv != prevOv);
-  if (changed) ui_mark_scroll_view_dirty((uint16_t)node);
+  if (changed) ui_mark_scroll_view_dirty(static_cast<uint16_t>(node));
   return changed;
 }
 
@@ -106,7 +107,7 @@ static inline uint8_t ui_scroll_release(int16_t node) {
   } else {
     int16_t sy = __ui_nodes[node].scrollY;
     int16_t maxS = ui_scroll_max(node);
-    int16_t snap = (int16_t)UI_SCROLL_EDGE_SNAP_PX;
+    int16_t snap = static_cast<int16_t>(UI_SCROLL_EDGE_SNAP_PX);
     if (sy > 0 && sy <= snap) {
       __ui_nodes[node].settling = 1;
       __ui_settle_from_scrollY = sy;            // positive → snap toward 0
@@ -126,27 +127,27 @@ static inline uint8_t ui_scroll_release(int16_t node) {
 
 // Advance the settle animation for a node (called from ui_tick). Ease-out over
 // UI_SCROLL_SETTLE_MS, terminating at the boundary. Bounded — always ends.
-static inline void ui_scroll_advance_settle(uint8_t node, uint16_t deltaMs) {
+static inline void ui_scroll_advance_settle(uint16_t node, uint16_t deltaMs) {
   (void)deltaMs;
   if (node >= __ui_node_count || !__ui_nodes[node].settling) return;
   uint32_t elapsed = millis() - __ui_settle_start_ms;
-  uint16_t dur = (uint16_t)UI_SCROLL_SETTLE_MS;
+  uint16_t dur = static_cast<uint16_t>(UI_SCROLL_SETTLE_MS);
   // ease-out: k = 1 - (1 - t)^2, t in [0,1]
   uint32_t t = elapsed >= dur ? 100 : (elapsed * 100) / dur;
   uint32_t k = 100 - ((100 - t) * (100 - t)) / 100;
   if (__ui_nodes[node].overscrollPx != 0) {
     int16_t from = __ui_settle_from_overscroll;
-    __ui_nodes[node].overscrollPx = (int16_t)(from - (int32_t)(from * k) / 100);
+    __ui_nodes[node].overscrollPx = static_cast<int16_t>(from - static_cast<int32_t>(from * k) / 100);
     if (t >= 100) __ui_nodes[node].overscrollPx = 0;
   } else if (__ui_settle_from_scrollY != 0) {
     int16_t from = __ui_settle_from_scrollY;   // +toward 0, -toward max
     int16_t maxS = ui_scroll_max(node);
     if (from > 0) {
-      __ui_nodes[node].scrollY = (int16_t)(from - (int32_t)(from * k) / 100);
+      __ui_nodes[node].scrollY = static_cast<int16_t>(from - static_cast<int32_t>(from * k) / 100);
       if (t >= 100) __ui_nodes[node].scrollY = 0;
     } else {  // from < 0: snap toward maxS
       int16_t target = maxS;
-      __ui_nodes[node].scrollY = target + (int16_t)((int32_t)from * (100 - k) / 100);
+      __ui_nodes[node].scrollY = target + static_cast<int16_t>(static_cast<int32_t>(from) * (100 - k) / 100);
       if (t >= 100) __ui_nodes[node].scrollY = target;
     }
   }

package/dist/ui-engine/runtime-header/state-bindings-nav.js

@@ -17,14 +17,24 @@ static int16_t __ui_scroll_node = -1;            // owning scroll container (int
 // frozen-but-not-torn rather than allowed to scroll with unclipped children.
 // Sized at runtime via __ui_node_count; defaults to all-zero (lock until proven).
 static uint8_t* __ui_scroll_canvas_ok = nullptr;
-// One-shot scroll memory warnings (indexed by node).
-static uint8_t* __ui_scroll_mem_warned = nullptr;
 // Precomputed draw order (lower z-index first, then source index). Built once in
 // ui_init; zIndex is static after mount so this stays valid for the app lifetime.
 static uint16_t* __ui_draw_order = nullptr;
-// Non-virtualized scroll-container node indices (built once in ui_init).
+// Scroll-container node indices (built once in ui_init). Includes lists for
+// hit-testing; the generic scroll compositor filters virtualized lists out.
 static uint16_t* __ui_scroll_owners = nullptr;
 static uint16_t __ui_scroll_owner_count = 0;
+// Set when neither a viewport nor a band canvas can be allocated. The current
+// pixels are retained and future drag deltas are rejected rather than exposing
+// a direct per-primitive SPI fallback (which tears).
+static uint8_t* __ui_scroll_render_locked = nullptr;
+struct UIScrollPaintCandidate {
+  uint16_t node;
+  int16_t screenY;
+  int16_t faceH;
+};
+static UIScrollPaintCandidate* __ui_scroll_candidates = nullptr;
+static uint16_t __ui_scroll_candidate_count = 0;
 // First NODE_FILL on the active screen (for framebuffer bg seed).
 static uint16_t __ui_active_screen_bg_node = 0xFFFF;
 static uint32_t __ui_settle_start_ms = 0;        // when the active settle animation began
@@ -112,24 +122,24 @@ static inline uint8_t ui_ease_lerp_k(uint8_t timing, uint8_t k) {
   // converges. Products of four /1000 values are /1e12; t³ is /1e9 (×1000 to align).
   // int64 accumulation avoids overflow (3e12 > INT32_MAX). Identical algorithm +
   // control points to easeCurveLerpK in model.ts — preview and device must agree.
-  int32_t targetX = (int32_t)k * 10;          // input on the /1000 x axis
+  int32_t targetX = static_cast<int32_t>(k) * 10;          // input on the /1000 x axis
   int32_t lo = 0, hi = 1000;
   for (uint8_t i = 0; i < 14; i++) {
     int32_t t = (lo + hi) >> 1;
     int32_t mt = 1000 - t;
-    int64_t termX1 = (int64_t)3 * mt * mt * t * x1;   // /1e12
-    int64_t termX2 = (int64_t)3 * mt * t * t * x2;    // /1e12
-    int64_t termX3 = (int64_t)t * t * t * 1000;       // /1e12 (t³ was /1e9)
-    int32_t X = (int32_t)((termX1 + termX2 + termX3) / 1000000000LL);  // back to /1000
+    int64_t termX1 = static_cast<int64_t>(3) * mt * mt * t * x1;   // /1e12
+    int64_t termX2 = static_cast<int64_t>(3) * mt * t * t * x2;    // /1e12
+    int64_t termX3 = static_cast<int64_t>(t) * t * t * 1000;       // /1e12 (t³ was /1e9)
+    int32_t X = static_cast<int32_t>((termX1 + termX2 + termX3) / 1000000000LL);  // back to /1000
     if (X < targetX) lo = t; else hi = t;
   }
   int32_t t = (lo + hi) >> 1;
   int32_t mt = 1000 - t;
-  int64_t termY1 = (int64_t)3 * mt * mt * t * y1;
-  int64_t termY2 = (int64_t)3 * mt * t * t * y2;
-  int64_t termY3 = (int64_t)t * t * t * 1000;
-  int32_t Y = (int32_t)((termY1 + termY2 + termY3) / 1000000000LL);  // /1000
-  return (uint8_t)(Y / 10);  // back to /100
+  int64_t termY1 = static_cast<int64_t>(3) * mt * mt * t * y1;
+  int64_t termY2 = static_cast<int64_t>(3) * mt * t * t * y2;
+  int64_t termY3 = static_cast<int64_t>(t) * t * t * 1000;
+  int32_t Y = static_cast<int32_t>((termY1 + termY2 + termY3) / 1000000000LL);  // /1000
+  return static_cast<uint8_t>(Y / 10);  // back to /100
 }
 extern const UIKeyframeSet __ui_keyframe_sets[];
 extern const uint16_t __ui_keyframe_set_count;

package/dist/ui-engine/runtime-header/structs.js

@@ -3,7 +3,7 @@
 // See docs/superpowers/specs/2026-07-12-split-runtime-header-design.md.
 export function emitStructs() {
     return `
-enum UINodeKind { NODE_FILL, NODE_TEXT, NODE_BUTTON, NODE_CHECK, NODE_RADIO, NODE_PROGRESS, NODE_RANGE, NODE_INPUT, NODE_IMG, NODE_LIST, NODE_CANVAS };
+enum UINodeKind { NODE_FILL, NODE_TEXT, NODE_BUTTON, NODE_CHECK, NODE_RADIO, NODE_PROGRESS, NODE_RANGE, NODE_INPUT, NODE_IMG, NODE_LIST, NODE_CANVAS, NODE_SELECT };
 enum UIProperty { PROP_BG, PROP_FG, PROP_TEXT, PROP_VISIBLE, PROP_BORDER_COLOR, PROP_VALUE };
 
 struct UIRect { int16_t x, y, w, h; };
@@ -160,7 +160,7 @@ struct UITransition {
   uint32_t pressedTarget;
   uint32_t baseTarget;
   // runtime
-  uint16_t elapsed;
+  uint32_t elapsed;
   uint32_t prevValue;
   uint32_t targetValue;
   uint8_t  active;
@@ -170,6 +170,8 @@ struct UIBinding {
   UIProperty prop;
   uint32_t (*fn)(void);       // for color/numeric bindings
   void (*textFn)(char* buf, uint8_t size); // for text bindings (PROP_TEXT): fills buf
+  uint32_t lastValue;         // numeric binding cache; avoids redundant dirty work
+  uint8_t initialized;        // first evaluation establishes the baseline
 };
 
 // Color lerp for transitions (rgb565). For mono, this collapses to a snap.
@@ -181,10 +183,10 @@ static inline uint16_t lerp_color(uint16_t a, uint16_t b, uint8_t k100) {
   uint8_t br5 = (b >> 11) & 0x1f, bg6 = (b >> 5) & 0x3f, bb5 = b & 0x1f;
   uint16_t ar8 = (ar5 << 3) | (ar5 >> 2), ag8 = (ag6 << 2) | (ag6 >> 4), ab8 = (ab5 << 3) | (ab5 >> 2);
   uint16_t br8 = (br5 << 3) | (br5 >> 2), bg8 = (bg6 << 2) | (bg6 >> 4), bb8 = (bb5 << 3) | (bb5 >> 2);
-  int16_t r = (int16_t)(ar8 + (int16_t)((br8 - ar8) * k100 / 100));
-  int16_t g = (int16_t)(ag8 + (int16_t)((bg8 - ag8) * k100 / 100));
-  int16_t bl = (int16_t)(ab8 + (int16_t)((bb8 - ab8) * k100 / 100));
-  return ((uint16_t)((r >> 3) & 0x1f) << 11) | ((uint16_t)((g >> 2) & 0x3f) << 5) | (uint16_t)((bl >> 3) & 0x1f);
+  int16_t r = static_cast<int16_t>(ar8 + static_cast<int16_t>((br8 - ar8) * k100 / 100));
+  int16_t g = static_cast<int16_t>(ag8 + static_cast<int16_t>((bg8 - ag8) * k100 / 100));
+  int16_t bl = static_cast<int16_t>(ab8 + static_cast<int16_t>((bb8 - ab8) * k100 / 100));
+  return (static_cast<uint16_t>((r >> 3) & 0x1f) << 11) | (static_cast<uint16_t>((g >> 2) & 0x3f) << 5) | static_cast<uint16_t>((bl >> 3) & 0x1f);
 }
 
 // RGB888 lerp — for transitions on RGB888/RGB666 targets (Phase 2+). Unused in
@@ -194,10 +196,10 @@ static inline uint32_t lerp_color_888(uint32_t a, uint32_t b, uint8_t k100) {
   if (k100 >= 100) return b;
   uint8_t ar = (a >> 16) & 0xff, ag = (a >> 8) & 0xff, ab = a & 0xff;
   uint8_t br = (b >> 16) & 0xff, bg = (b >> 8) & 0xff, bb = b & 0xff;
-  int16_t r = ar + (int16_t)(((int16_t)br - (int16_t)ar) * k100 / 100);
-  int16_t g = ag + (int16_t)(((int16_t)bg - (int16_t)ag) * k100 / 100);
-  int16_t bl = ab + (int16_t)(((int16_t)bb - (int16_t)ab) * k100 / 100);
-  return ((uint32_t)(r & 0xff) << 16) | ((uint32_t)(g & 0xff) << 8) | (uint32_t)(bl & 0xff);
+  int16_t r = ar + static_cast<int16_t>((static_cast<int16_t>(br) - static_cast<int16_t>(ar)) * k100 / 100);
+  int16_t g = ag + static_cast<int16_t>((static_cast<int16_t>(bg) - static_cast<int16_t>(ag)) * k100 / 100);
+  int16_t bl = ab + static_cast<int16_t>((static_cast<int16_t>(bb) - static_cast<int16_t>(ab)) * k100 / 100);
+  return (static_cast<uint32_t>(r & 0xff) << 16) | (static_cast<uint32_t>(g & 0xff) << 8) | static_cast<uint32_t>(bl & 0xff);
 }
 
 // Declared by the lowering output (the tables). Matches the mutable (non-const)