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

package/dist/ui-engine/runtime-header/forward-decls.js

@@ -1,20 +1,31 @@
 // Slice of the C++ runtime header (original source lines 622-752).
 // navigate, canvas/scroll/text/paint/clip/AA/image forward declarations, persistent canvas globals.
 // See docs/superpowers/specs/2026-07-12-split-runtime-header-design.md.
+//
+// EMIT BOUNDARY: This file is the structural head of the UI runtime header
+// surface (C) — every partial emitter in this directory produces bytes that are
+// assembled into the C++ header inlined into user sketches. The emitted bytes
+// are covered by the TypeCAD Runtime Exception (see RUNTIME_EXCEPTION.md at the
+// repository root) and are not subject to the license of this tool source.
 export function emitForwardDecls() {
     return `
-static uint8_t __ui_fade_opacity = 100;  // fade-in animation (0=transparent, 100=full)
-static uint16_t __ui_fade_elapsed = 0;
-static uint16_t __ui_fade_duration = 200; // ms
-
 // Early forward declaration: ui_navigate (below) calls ui_release_canvas_state
 // and ui_set_pressed (defined later) during screen changes. Needed on native
 // (single TU, no Arduino auto-prototyper).
 static inline void ui_release_canvas_state();
 static inline void ui_set_pressed(uint16_t nodeIdx, uint8_t pressed);
 static inline void ui_refresh_active_screen_bg_node();
+static inline CuttlefishCanvas16* ui_get_framebuffer();
+// Set when the next frame must be composed from the active screen background;
+// declared before ui_navigate because navigation can request that composition.
+static uint8_t __ui_fb_needs_compose = 1;
 
-// Navigate to a screen by index. Marks the new screen's nodes dirty + starts fade.
+// Navigate to a screen by index. Marks the new screen's nodes dirty, releases
+// persistent canvas state, and requests a complete off-screen composition when
+// the full-frame path is available. The physical panel is never cleared here on
+// that path: navigation must not expose an intermediate frame while the next
+// frame is built. Without a full-frame buffer, the fallback remains best-effort;
+// no-TE TFT hardware cannot provide a strict tear-free guarantee.
 static inline void ui_navigate(uint8_t screenIdx) {
   if (screenIdx >= __ui_screen_count || screenIdx == __ui_active_screen) return;
   __ui_active_screen = screenIdx;
@@ -26,7 +37,7 @@ static inline void ui_navigate(uint8_t screenIdx) {
   // and the button would stay stuck in its :pressed color.
   if (__ui_touch_node >= 0 && __ui_touch_node < __ui_node_count &&
       __ui_nodes[__ui_touch_node].kind == NODE_BUTTON && __ui_nodes[__ui_touch_node].value != 0) {
-    ui_set_pressed((uint16_t)__ui_touch_node, 0);
+    ui_set_pressed(static_cast<uint16_t>(__ui_touch_node), 0);
   }
   __ui_scroll_node = -1;
   __ui_touch_node = -1;
@@ -37,17 +48,34 @@ static inline void ui_navigate(uint8_t screenIdx) {
   // resident and fragments the heap, so the new screen's buffer can't get a
   // contiguous block (the "works first, then blanks until reset" symptom).
   ui_release_canvas_state();
-  // Clear the entire display so old screen content doesn't show. On deferred-
-  // refresh panels (e-ink) a full clear flashes, so skip it — the all-nodes-
-  // dirty marking below drives a full repaint via partial refresh instead.
+  // A framebuffer-capable target keeps the old frame visible until the new one
+  // is complete. Targets without enough memory retain the legacy clear fallback
+  // so stale pixels from the old screen cannot remain; this constrained path is
+  // best-effort because the panel has no TE/vblank synchronization.
+  if (ui_get_framebuffer()) {
+    __ui_fb_needs_compose = 1;
+  } else {
 #ifndef UI_REFRESH_DEFERRED
-  display_fillScreen(0x0000);
+    UI_COLOR_T navBg = (UI_COLOR_T)0;
+    if (__ui_active_screen_bg_node < __ui_node_count) {
+      navBg = __ui_nodes[__ui_active_screen_bg_node].hasBg
+        ? __ui_nodes[__ui_active_screen_bg_node].bg
+        : __ui_nodes[__ui_active_screen_bg_node].clearColor;
+    }
+    display_fillScreen(navBg);
 #endif
+  }
   // Mark all nodes dirty so the new screen fully redraws.
   for (uint16_t i = 0; i < __ui_node_count; i++) {
     __ui_nodes[i].dirty = 1;
     __ui_nodes[i].lastTextHeight = 0;
     __ui_nodes[i].layoutCacheKey = 0;
+    if (__ui_nodes[i].scrollable) {
+      // The next screen needs a complete scroll-canvas seed; subsequent local
+      // child updates can use retained-canvas repairs.
+      __ui_nodes[i].lastPaintedScrollY = static_cast<int16_t>(
+        __ui_nodes[i].scrollY - (__ui_nodes[i].box.h > 0 ? __ui_nodes[i].box.h : 1));
+    }
     if (__ui_nodes[i].kind == NODE_PROGRESS || __ui_nodes[i].kind == NODE_RANGE) __ui_nodes[i].lastTextWidth = -1;
     else __ui_nodes[i].lastTextWidth = 0;
   }
@@ -80,6 +108,7 @@ static inline uint8_t ui_subtree_current_paint_rect(uint16_t nodeIdx, UIRect* ou
 static inline void ui_mark_overlapping_higher_layers_dirty(uint16_t nodeIdx);
 static inline void ui_mark_overlapping_higher_layers_dirty_for_rect(uint16_t nodeIdx, const UIRect* r);
 static inline void ui_mark_scroll_view_dirty(uint16_t scrollNode);
+static inline UI_COLOR_T ui_parent_clear_color(uint16_t nodeIdx);
 static inline void ui_release_canvas_state();
 static inline void ui_set_visible(uint16_t nodeIdx, uint8_t visible);
 static inline void ui_invalidate_scroll_canvas_for_node(uint16_t nodeIdx);
@@ -93,15 +122,22 @@ static inline void ui_draw_node_decoration_clipped(uint16_t nodeIdx, int16_t dra
 // single native translation unit (Arduino's auto-prototyper hides this;
 // native emits one TU so explicit forwards are needed).
 static inline int8_t ui_rich_link_hit(uint16_t nodeIdx, int16_t px, int16_t py);
+#ifdef UI_AA
 static inline CuttlefishCanvas16* ui_aa_begin(int16_t w, int16_t h, UI_COLOR_T bg);
 static inline void ui_aa_end(CuttlefishCanvas16* c);
 static inline void ui_aa_push(CuttlefishCanvas16* c, int16_t dx, int16_t dy);
 static inline void ui_aa_line(CuttlefishCanvas16* c, float x0, float y0, float x1, float y1, UI_COLOR_T color);
 static inline void ui_aa_circle(CuttlefishCanvas16* c, int16_t cx, int16_t cy, float r, UI_COLOR_T color);
 static inline void ui_aa_fill_circle(CuttlefishCanvas16* c, int16_t cx, int16_t cy, float r, UI_COLOR_T color);
+#endif
 static inline uint8_t ui_repair_current_node_paint_with_parent(uint16_t nodeIdx, UIRect* r);
 static inline void ui_clear_node_paint_rect(uint16_t nodeIdx, const UIRect* paintRect);
 static inline uint8_t ui_try_repair_geometry_fill(uint16_t nodeIdx, const UIRect* oldRect);
+// Band renderers (defined in node-draw-body; forward-declared so the NODE_LIST
+// case can fall back to ui_render_list_bands before its definition site).
+static inline uint8_t ui_render_node_bands(uint16_t nodeIdx, int16_t prX, int16_t prY, int16_t prW, int16_t prH);
+static inline uint8_t ui_render_list_bands(uint16_t i);
+static inline uint8_t ui_render_list_direct(uint16_t i);
 static inline void ui_draw_node_border(uint16_t i, int16_t drawX, int16_t drawY, UI_COLOR_T color);
 static inline void ui_draw_node_outline(uint16_t i, int16_t drawX, int16_t drawY);
 static inline void ui_draw_gradient_fill(uint16_t i, int16_t drawY);
@@ -115,6 +151,10 @@ static inline void ui_draw_scaled_image(const UIImage* img, int16_t x, int16_t y
                                          int16_t drawW, int16_t drawH);
 
 static CuttlefishDisplayTarget* __ui_gfx = display_defaultTarget();
+// Full-frame composition is required for the first frame and after navigation.
+// Once composed, subsequent dirty updates can safely modify the retained
+// framebuffer without rebuilding unchanged nodes. The flags are declared
+// before ui_navigate above because navigation sets the compose request.
 // Persistent canvas slots, all freed on screen change (ui_navigate) so each
 // screen starts with a clean heap. Without this, the first screen's canvas
 // buffer stays resident and fragments the heap, so a later screen's buffer
@@ -126,6 +166,8 @@ static CuttlefishCanvas16* __ui_list_canvas = nullptr;       // virtualized <lis
 static int16_t __ui_list_canvas_node = -1;                   // node currently represented by __ui_list_canvas
 static CuttlefishCanvas16* __ui_node_canvas = nullptr;       // <canvas> element offscreen
 static CuttlefishCanvas16* __ui_repair_canvas = nullptr;     // buffered-paint / exposed-strip
+static CuttlefishCanvas16* __ui_band_canvas = nullptr;       // band renderer (no-PSRAM scroll)
+static CuttlefishCanvas16* __ui_kb_canvas = nullptr;         // on-screen keyboard overlay
 static int16_t __ui_canvas_fallback_w = 0;                   // dimensions for direct <canvas> fallback
 static int16_t __ui_canvas_fallback_h = 0;
 // Draw offset: normally zero. The <canvas> allocation fallback sets it so

package/dist/ui-engine/runtime-header/image-drawing.js

@@ -3,12 +3,54 @@
 // See docs/superpowers/specs/2026-07-12-split-runtime-header-design.md.
 export function emitImageDrawing() {
     return `
-// ── Full-screen framebuffer (opt-in PSRAM perf experiment) ───────────────────
-// Disabled by default: pushing a full 320×240 frame for a tiny dirty button can
-// look like a global brightness flash on SPI TFTs. Enable only when a target
-// has enough PSRAM and a full-frame repaint is preferable to partial updates.
+// ── Full-screen framebuffer (opt-in PSRAM composition path) ──────────────────
+// Composes a complete frame off-screen so navigation and dirty-node updates do
+// not expose intermediate clears/primitive writes. The panel still receives a
+// sequential SPI transfer; without a TE/vblank signal this is a strong tearing
+// reduction, not a strict hardware-level tear-free guarantee.
 static CuttlefishCanvas16* __ui_fb = nullptr;
 static uint8_t __ui_fb_tried = 0;  // 0 = not yet attempted, 1 = alloc attempted
+// Dirty bounds for the retained framebuffer. A local touch update should not
+// retransmit the entire panel: the full-frame burst is long enough to look like
+// a brightness dip on SPI TFTs even though the framebuffer itself is coherent.
+static uint8_t __ui_fb_dirty = 0;
+static int16_t __ui_fb_dirty_x0 = 0;
+static int16_t __ui_fb_dirty_y0 = 0;
+static int16_t __ui_fb_dirty_x1 = 0;
+static int16_t __ui_fb_dirty_y1 = 0;
+
+static inline void ui_fb_begin_frame() {
+  __ui_fb_dirty = 0;
+  __ui_fb_dirty_x0 = display_width();
+  __ui_fb_dirty_y0 = display_height();
+  __ui_fb_dirty_x1 = 0;
+  __ui_fb_dirty_y1 = 0;
+}
+
+static inline void ui_fb_add_rect(int16_t x, int16_t y, int16_t w, int16_t h) {
+  if (w <= 0 || h <= 0) return;
+  int16_t x0 = x < 0 ? 0 : x;
+  int16_t y0 = y < 0 ? 0 : y;
+  int16_t x1 = x + w;
+  int16_t y1 = y + h;
+  int16_t dw = display_width();
+  int16_t dh = display_height();
+  if (x1 > dw) x1 = dw;
+  if (y1 > dh) y1 = dh;
+  if (x0 >= x1 || y0 >= y1) return;
+  if (!__ui_fb_dirty) {
+    __ui_fb_dirty_x0 = x0;
+    __ui_fb_dirty_y0 = y0;
+    __ui_fb_dirty_x1 = x1;
+    __ui_fb_dirty_y1 = y1;
+    __ui_fb_dirty = 1;
+    return;
+  }
+  if (x0 < __ui_fb_dirty_x0) __ui_fb_dirty_x0 = x0;
+  if (y0 < __ui_fb_dirty_y0) __ui_fb_dirty_y0 = y0;
+  if (x1 > __ui_fb_dirty_x1) __ui_fb_dirty_x1 = x1;
+  if (y1 > __ui_fb_dirty_y1) __ui_fb_dirty_y1 = y1;
+}
 
 // Get the framebuffer, allocating once (in PSRAM when available). Returns null
 // when PSRAM is absent or the allocation failed — callers fall back to direct.
@@ -31,14 +73,42 @@ static inline CuttlefishCanvas16* ui_get_framebuffer() {
   return __ui_fb;
 }
 
-// Push the entire framebuffer to the display in one bulk SPI transaction.
+// Push only the changed framebuffer bounds. Rows are sent separately when the
+// dirty union is narrower than the framebuffer because the source canvas has a
+// wider stride than the panel window. Each row is complete before it reaches
+// the panel, and the display adapter can synchronize each window to scanline.
 static inline void ui_push_framebuffer() {
-  if (!__ui_fb || !display_canvasBuffer(__ui_fb)) return;
-  int16_t w = display_canvasWidth(__ui_fb);
-  int16_t h = display_canvasHeight(__ui_fb);
+  if (!__ui_fb || !display_canvasBuffer(__ui_fb) || !__ui_fb_dirty) return;
+  int16_t fw = display_canvasWidth(__ui_fb);
+  int16_t fh = display_canvasHeight(__ui_fb);
+  int16_t x = __ui_fb_dirty_x0;
+  int16_t y = __ui_fb_dirty_y0;
+  int16_t w = static_cast<int16_t>(__ui_fb_dirty_x1 - x);
+  int16_t h = static_cast<int16_t>(__ui_fb_dirty_y1 - y);
+  if (x < 0 || y < 0 || w <= 0 || h <= 0 || x >= fw || y >= fh) return;
+  if (x + w > fw) w = static_cast<int16_t>(fw - x);
+  if (y + h > fh) h = static_cast<int16_t>(fh - y);
+  // Use the panel's native bulk-pixel path, not drawRGBBitmap(). The native
+  // CuttlefishGFX implementation of drawRGBBitmap is intentionally generic and
+  // emits one writePixel transaction per pixel; using it for a retained-frame
+  // flush turns a small local update into hundreds of visible SPI flashes.
+  UI_COLOR_T* pixels = display_canvasBuffer(__ui_fb);
   display_startWrite();
-  display_setAddrWindow(0, 0, w, h);
-  display_writePixels(display_canvasBuffer(__ui_fb), (uint32_t)w * h);
+  if (x == 0 && w == fw) {
+    // Full-width rows are contiguous and can use one bulk write.
+    display_setAddrWindow(x, y, w, h);
+    display_writePixels(pixels + static_cast<int32_t>(y) * fw,
+      static_cast<uint32_t>(w) * h);
+  } else {
+    // Narrow dirty bounds require one row at a time because the source stride
+    // is fw while each destination window is only w pixels wide.
+    for (int16_t row = 0; row < h; row++) {
+      display_setAddrWindow(x, static_cast<int16_t>(y + row), w, 1);
+      display_writePixels(
+        pixels + static_cast<int32_t>(y + row) * fw + x,
+        static_cast<uint32_t>(w));
+    }
+  }
   display_endWrite();
 }
 
@@ -82,8 +152,8 @@ static inline void ui_draw_image_with_fit(const UIImage* img, int16_t x, int16_t
     offX = 0;
     offY = 0;
   } else if (fitMode == 2 || fitMode == 3 || fitMode == 4) {
-    int32_t scaleX = ((int32_t)targetW * 1000) / srcW;
-    int32_t scaleY = ((int32_t)targetH * 1000) / srcH;
+    int32_t scaleX = (static_cast<int32_t>(targetW) * 1000) / srcW;
+    int32_t scaleY = (static_cast<int32_t>(targetH) * 1000) / srcH;
     if (scaleX < 1) scaleX = 1;
     if (scaleY < 1) scaleY = 1;
     int32_t scale = scaleX;
@@ -95,8 +165,8 @@ static inline void ui_draw_image_with_fit(const UIImage* img, int16_t x, int16_t
       if (scaleY < scaleX) scale = scaleY;
       if (scale > 1000) scale = 1000;
     }
-    drawW = (int16_t)((int32_t)srcW * scale / 1000);
-    drawH = (int16_t)((int32_t)srcH * scale / 1000);
+    drawW = static_cast<int16_t>(static_cast<int32_t>(srcW) * scale / 1000);
+    drawH = static_cast<int16_t>(static_cast<int32_t>(srcH) * scale / 1000);
     if (drawW < 1) drawW = 1;
     if (drawH < 1) drawH = 1;
     if (fitMode == 3) {
@@ -115,40 +185,40 @@ static inline void ui_draw_image_with_fit(const UIImage* img, int16_t x, int16_t
   if (!ui_clip_rect_to_display_target(&clipX, &clipY, &clipW, &clipH)) return;
   int16_t txStart = 0, txEnd = targetW, tyStart = 0, tyEnd = targetH;
   if (q == 0) {
-    txStart = ui_clamp_i16((int16_t)(clipX - x), 0, targetW);
-    txEnd = ui_clamp_i16((int16_t)(clipX + clipW - x), 0, targetW);
-    tyStart = ui_clamp_i16((int16_t)(clipY - y), 0, targetH);
-    tyEnd = ui_clamp_i16((int16_t)(clipY + clipH - y), 0, targetH);
+    txStart = ui_clamp_i16(static_cast<int16_t>(clipX - x), 0, targetW);
+    txEnd = ui_clamp_i16(static_cast<int16_t>(clipX + clipW - x), 0, targetW);
+    tyStart = ui_clamp_i16(static_cast<int16_t>(clipY - y), 0, targetH);
+    tyEnd = ui_clamp_i16(static_cast<int16_t>(clipY + clipH - y), 0, targetH);
   } else if (q == 1) {
-    txStart = ui_clamp_i16((int16_t)(clipY - y), 0, targetW);
-    txEnd = ui_clamp_i16((int16_t)(clipY + clipH - y), 0, targetW);
-    tyStart = ui_clamp_i16((int16_t)(x + targetH - (clipX + clipW)), 0, targetH);
-    tyEnd = ui_clamp_i16((int16_t)(x + targetH - clipX), 0, targetH);
+    txStart = ui_clamp_i16(static_cast<int16_t>(clipY - y), 0, targetW);
+    txEnd = ui_clamp_i16(static_cast<int16_t>(clipY + clipH - y), 0, targetW);
+    tyStart = ui_clamp_i16(static_cast<int16_t>(x + targetH - (clipX + clipW)), 0, targetH);
+    tyEnd = ui_clamp_i16(static_cast<int16_t>(x + targetH - clipX), 0, targetH);
   } else if (q == 2) {
-    txStart = ui_clamp_i16((int16_t)(x + targetW - (clipX + clipW)), 0, targetW);
-    txEnd = ui_clamp_i16((int16_t)(x + targetW - clipX), 0, targetW);
-    tyStart = ui_clamp_i16((int16_t)(y + targetH - (clipY + clipH)), 0, targetH);
-    tyEnd = ui_clamp_i16((int16_t)(y + targetH - clipY), 0, targetH);
+    txStart = ui_clamp_i16(static_cast<int16_t>(x + targetW - (clipX + clipW)), 0, targetW);
+    txEnd = ui_clamp_i16(static_cast<int16_t>(x + targetW - clipX), 0, targetW);
+    tyStart = ui_clamp_i16(static_cast<int16_t>(y + targetH - (clipY + clipH)), 0, targetH);
+    tyEnd = ui_clamp_i16(static_cast<int16_t>(y + targetH - clipY), 0, targetH);
   } else {
-    txStart = ui_clamp_i16((int16_t)(y + targetW - (clipY + clipH)), 0, targetW);
-    txEnd = ui_clamp_i16((int16_t)(y + targetW - clipY), 0, targetW);
-    tyStart = ui_clamp_i16((int16_t)(clipX - x), 0, targetH);
-    tyEnd = ui_clamp_i16((int16_t)(clipX + clipW - x), 0, targetH);
+    txStart = ui_clamp_i16(static_cast<int16_t>(y + targetW - (clipY + clipH)), 0, targetW);
+    txEnd = ui_clamp_i16(static_cast<int16_t>(y + targetW - clipY), 0, targetW);
+    tyStart = ui_clamp_i16(static_cast<int16_t>(clipX - x), 0, targetH);
+    tyEnd = ui_clamp_i16(static_cast<int16_t>(clipX + clipW - x), 0, targetH);
   }
   if (txStart >= txEnd || tyStart >= tyEnd) return;
   for (int16_t ty = tyStart; ty < tyEnd; ty++) {
     int16_t localY = ty - offY;
     if (localY < 0 || localY >= drawH) continue;
-    int16_t srcY = ((int32_t)localY * srcH) / drawH;
+    int16_t srcY = (static_cast<int32_t>(localY) * srcH) / drawH;
     if (srcY < 0) srcY = 0;
     if (srcY >= srcH) srcY = srcH - 1;
     for (int16_t tx = txStart; tx < txEnd; tx++) {
       int16_t localX = tx - offX;
       if (localX < 0 || localX >= drawW) continue;
-      int16_t srcX = ((int32_t)localX * srcW) / drawW;
+      int16_t srcX = (static_cast<int32_t>(localX) * srcW) / drawW;
       if (srcX < 0) srcX = 0;
       if (srcX >= srcW) srcX = srcW - 1;
-      UI_COLOR_T color = img->data[(int32_t)srcY * srcW + srcX];
+      UI_COLOR_T color = img->data[static_cast<int32_t>(srcY) * srcW + srcX];
       int16_t dx = tx;
       int16_t dy = ty;
       if (q == 1) {
@@ -177,43 +247,43 @@ static inline void ui_draw_scaled_image(const UIImage* img, int16_t x, int16_t y
   if (!ui_clip_rect_to_display_target(&clipX, &clipY, &clipW, &clipH)) return;
   int16_t dxStart = 0, dxEnd = drawW, dyStart = 0, dyEnd = drawH;
   if (q == 0) {
-    dxStart = ui_clamp_i16((int16_t)(clipX - x), 0, drawW);
-    dxEnd = ui_clamp_i16((int16_t)(clipX + clipW - x), 0, drawW);
-    dyStart = ui_clamp_i16((int16_t)(clipY - y), 0, drawH);
-    dyEnd = ui_clamp_i16((int16_t)(clipY + clipH - y), 0, drawH);
+    dxStart = ui_clamp_i16(static_cast<int16_t>(clipX - x), 0, drawW);
+    dxEnd = ui_clamp_i16(static_cast<int16_t>(clipX + clipW - x), 0, drawW);
+    dyStart = ui_clamp_i16(static_cast<int16_t>(clipY - y), 0, drawH);
+    dyEnd = ui_clamp_i16(static_cast<int16_t>(clipY + clipH - y), 0, drawH);
   } else if (q == 1) {
-    dxStart = ui_clamp_i16((int16_t)(clipY - y), 0, drawW);
-    dxEnd = ui_clamp_i16((int16_t)(clipY + clipH - y), 0, drawW);
-    dyStart = ui_clamp_i16((int16_t)(x + drawH - (clipX + clipW)), 0, drawH);
-    dyEnd = ui_clamp_i16((int16_t)(x + drawH - clipX), 0, drawH);
+    dxStart = ui_clamp_i16(static_cast<int16_t>(clipY - y), 0, drawW);
+    dxEnd = ui_clamp_i16(static_cast<int16_t>(clipY + clipH - y), 0, drawW);
+    dyStart = ui_clamp_i16(static_cast<int16_t>(x + drawH - (clipX + clipW)), 0, drawH);
+    dyEnd = ui_clamp_i16(static_cast<int16_t>(x + drawH - clipX), 0, drawH);
   } else if (q == 2) {
-    dxStart = ui_clamp_i16((int16_t)(x + drawW - (clipX + clipW)), 0, drawW);
-    dxEnd = ui_clamp_i16((int16_t)(x + drawW - clipX), 0, drawW);
-    dyStart = ui_clamp_i16((int16_t)(y + drawH - (clipY + clipH)), 0, drawH);
-    dyEnd = ui_clamp_i16((int16_t)(y + drawH - clipY), 0, drawH);
+    dxStart = ui_clamp_i16(static_cast<int16_t>(x + drawW - (clipX + clipW)), 0, drawW);
+    dxEnd = ui_clamp_i16(static_cast<int16_t>(x + drawW - clipX), 0, drawW);
+    dyStart = ui_clamp_i16(static_cast<int16_t>(y + drawH - (clipY + clipH)), 0, drawH);
+    dyEnd = ui_clamp_i16(static_cast<int16_t>(y + drawH - clipY), 0, drawH);
   } else {
-    dxStart = ui_clamp_i16((int16_t)(y + drawW - (clipY + clipH)), 0, drawW);
-    dxEnd = ui_clamp_i16((int16_t)(y + drawW - clipY), 0, drawW);
-    dyStart = ui_clamp_i16((int16_t)(clipX - x), 0, drawH);
-    dyEnd = ui_clamp_i16((int16_t)(clipX + clipW - x), 0, drawH);
+    dxStart = ui_clamp_i16(static_cast<int16_t>(y + drawW - (clipY + clipH)), 0, drawW);
+    dxEnd = ui_clamp_i16(static_cast<int16_t>(y + drawW - clipY), 0, drawW);
+    dyStart = ui_clamp_i16(static_cast<int16_t>(clipX - x), 0, drawH);
+    dyEnd = ui_clamp_i16(static_cast<int16_t>(clipX + clipW - x), 0, drawH);
   }
   if (dxStart >= dxEnd || dyStart >= dyEnd) return;
   if (q == 0) {
     // Simple case: no rotation, draw with scaling
     if (drawW == img->w && drawH == img->h) {
-      int16_t rows = (int16_t)(dyEnd - dyStart);
-      int16_t cols = (int16_t)(dxEnd - dxStart);
+      int16_t rows = static_cast<int16_t>(dyEnd - dyStart);
+      int16_t cols = static_cast<int16_t>(dxEnd - dxStart);
       for (int16_t row = 0; row < rows; row++) {
-        ui_display_draw_rgb_bitmap((int16_t)(x + dxStart), (int16_t)(y + dyStart + row),
-          img->data + (int32_t)(dyStart + row) * img->w + dxStart, cols, 1);
+        ui_display_draw_rgb_bitmap(static_cast<int16_t>(x + dxStart), static_cast<int16_t>(y + dyStart + row),
+          img->data + static_cast<int32_t>(dyStart + row) * img->w + dxStart, cols, 1);
       }
     } else {
       // Scale using nearest-neighbor
       for (int16_t dy = dyStart; dy < dyEnd; dy++) {
-        int16_t srcY = ((int32_t)dy * img->h) / drawH;
+        int16_t srcY = (static_cast<int32_t>(dy) * img->h) / drawH;
         for (int16_t dx = dxStart; dx < dxEnd; dx++) {
-          int16_t srcX = ((int32_t)dx * img->w) / drawW;
-          UI_COLOR_T color = img->data[(int32_t)srcY * img->w + srcX];
+          int16_t srcX = (static_cast<int32_t>(dx) * img->w) / drawW;
+          UI_COLOR_T color = img->data[static_cast<int32_t>(srcY) * img->w + srcX];
           ui_display_draw_pixel(x + dx, y + dy, color);
         }
       }
@@ -221,10 +291,10 @@ static inline void ui_draw_scaled_image(const UIImage* img, int16_t x, int16_t y
     return;
   }
   for (int16_t dy = dyStart; dy < dyEnd; dy++) {
-    int16_t srcY = ((int32_t)dy * img->h) / drawH;
+    int16_t srcY = (static_cast<int32_t>(dy) * img->h) / drawH;
     for (int16_t dx = dxStart; dx < dxEnd; dx++) {
-      int16_t srcX = ((int32_t)dx * img->w) / drawW;
-      UI_COLOR_T color = img->data[(int32_t)srcY * img->w + srcX];
+      int16_t srcX = (static_cast<int32_t>(dx) * img->w) / drawW;
+      UI_COLOR_T color = img->data[static_cast<int32_t>(srcY) * img->w + srcX];
       int16_t rdx = 0, rdy = 0;
       if (q == 1) {
         rdx = drawH - 1 - dy;
@@ -249,48 +319,48 @@ static inline void ui_draw_image_rotated(const UIImage* img, int16_t x, int16_t
    int16_t clipH = (q == 1 || q == 3) ? img->w : img->h;
    if (!ui_clip_rect_to_display_target(&clipX, &clipY, &clipW, &clipH)) return;
    if (q == 0) {
-     int16_t sx0 = ui_clamp_i16((int16_t)(clipX - x), 0, (int16_t)img->w);
-     int16_t sy0 = ui_clamp_i16((int16_t)(clipY - y), 0, (int16_t)img->h);
-     int16_t sw = ui_clamp_i16(clipW, 0, (int16_t)(img->w - sx0));
-     int16_t sh = ui_clamp_i16(clipH, 0, (int16_t)(img->h - sy0));
+     int16_t sx0 = ui_clamp_i16(static_cast<int16_t>(clipX - x), 0, static_cast<int16_t>(img->w));
+     int16_t sy0 = ui_clamp_i16(static_cast<int16_t>(clipY - y), 0, static_cast<int16_t>(img->h));
+     int16_t sw = ui_clamp_i16(clipW, 0, static_cast<int16_t>(img->w - sx0));
+     int16_t sh = ui_clamp_i16(clipH, 0, static_cast<int16_t>(img->h - sy0));
      for (int16_t row = 0; row < sh; row++) {
-       ui_display_draw_rgb_bitmap((int16_t)(x + sx0), (int16_t)(y + sy0 + row),
-         img->data + (int32_t)(sy0 + row) * img->w + sx0, sw, 1);
+       ui_display_draw_rgb_bitmap(static_cast<int16_t>(x + sx0), static_cast<int16_t>(y + sy0 + row),
+         img->data + static_cast<int32_t>(sy0 + row) * img->w + sx0, sw, 1);
      }
      return;
    }
    uint16_t sxStart = 0, sxEnd = img->w, syStart = 0, syEnd = img->h;
    if (q == 1) {
-     sxStart = (uint16_t)ui_clamp_i16((int16_t)(clipY - y), 0, (int16_t)img->w);
-     sxEnd = (uint16_t)ui_clamp_i16((int16_t)(clipY + clipH - y), 0, (int16_t)img->w);
-     syStart = (uint16_t)ui_clamp_i16((int16_t)(x + img->h - (clipX + clipW)), 0, (int16_t)img->h);
-     syEnd = (uint16_t)ui_clamp_i16((int16_t)(x + img->h - clipX), 0, (int16_t)img->h);
+     sxStart = static_cast<uint16_t>(ui_clamp_i16(static_cast<int16_t>(clipY - y), 0, static_cast<int16_t>(img->w)));
+     sxEnd = static_cast<uint16_t>(ui_clamp_i16(static_cast<int16_t>(clipY + clipH - y), 0, static_cast<int16_t>(img->w)));
+     syStart = static_cast<uint16_t>(ui_clamp_i16(static_cast<int16_t>(x + img->h - (clipX + clipW)), 0, static_cast<int16_t>(img->h)));
+     syEnd = static_cast<uint16_t>(ui_clamp_i16(static_cast<int16_t>(x + img->h - clipX), 0, static_cast<int16_t>(img->h)));
    } else if (q == 2) {
-     sxStart = (uint16_t)ui_clamp_i16((int16_t)(x + img->w - (clipX + clipW)), 0, (int16_t)img->w);
-     sxEnd = (uint16_t)ui_clamp_i16((int16_t)(x + img->w - clipX), 0, (int16_t)img->w);
-     syStart = (uint16_t)ui_clamp_i16((int16_t)(y + img->h - (clipY + clipH)), 0, (int16_t)img->h);
-     syEnd = (uint16_t)ui_clamp_i16((int16_t)(y + img->h - clipY), 0, (int16_t)img->h);
+     sxStart = static_cast<uint16_t>(ui_clamp_i16(static_cast<int16_t>(x + img->w - (clipX + clipW)), 0, static_cast<int16_t>(img->w)));
+     sxEnd = static_cast<uint16_t>(ui_clamp_i16(static_cast<int16_t>(x + img->w - clipX), 0, static_cast<int16_t>(img->w)));
+     syStart = static_cast<uint16_t>(ui_clamp_i16(static_cast<int16_t>(y + img->h - (clipY + clipH)), 0, static_cast<int16_t>(img->h)));
+     syEnd = static_cast<uint16_t>(ui_clamp_i16(static_cast<int16_t>(y + img->h - clipY), 0, static_cast<int16_t>(img->h)));
    } else {
-     sxStart = (uint16_t)ui_clamp_i16((int16_t)(y + img->w - (clipY + clipH)), 0, (int16_t)img->w);
-     sxEnd = (uint16_t)ui_clamp_i16((int16_t)(y + img->w - clipY), 0, (int16_t)img->w);
-     syStart = (uint16_t)ui_clamp_i16((int16_t)(clipX - x), 0, (int16_t)img->h);
-     syEnd = (uint16_t)ui_clamp_i16((int16_t)(clipX + clipW - x), 0, (int16_t)img->h);
+     sxStart = static_cast<uint16_t>(ui_clamp_i16(static_cast<int16_t>(y + img->w - (clipY + clipH)), 0, static_cast<int16_t>(img->w)));
+     sxEnd = static_cast<uint16_t>(ui_clamp_i16(static_cast<int16_t>(y + img->w - clipY), 0, static_cast<int16_t>(img->w)));
+     syStart = static_cast<uint16_t>(ui_clamp_i16(static_cast<int16_t>(clipX - x), 0, static_cast<int16_t>(img->h)));
+     syEnd = static_cast<uint16_t>(ui_clamp_i16(static_cast<int16_t>(clipX + clipW - x), 0, static_cast<int16_t>(img->h)));
    }
    if (sxStart >= sxEnd || syStart >= syEnd) return;
    for (uint16_t sy = syStart; sy < syEnd; sy++) {
      for (uint16_t sx = sxStart; sx < sxEnd; sx++) {
-       UI_COLOR_T color = img->data[(uint32_t)sy * img->w + sx];
+       UI_COLOR_T color = img->data[static_cast<uint32_t>(sy) * img->w + sx];
        int16_t dx = 0;
        int16_t dy = 0;
        if (q == 1) {
-         dx = (int16_t)(img->h - 1 - sy);
-         dy = (int16_t)sx;
+         dx = static_cast<int16_t>(img->h - 1 - sy);
+         dy = static_cast<int16_t>(sx);
        } else if (q == 2) {
-         dx = (int16_t)(img->w - 1 - sx);
-         dy = (int16_t)(img->h - 1 - sy);
+         dx = static_cast<int16_t>(img->w - 1 - sx);
+         dy = static_cast<int16_t>(img->h - 1 - sy);
        } else {
-         dx = (int16_t)sy;
-         dy = (int16_t)(img->w - 1 - sx);
+         dx = static_cast<int16_t>(sy);
+         dy = static_cast<int16_t>(img->w - 1 - sx);
        }
        ui_display_draw_pixel(x + dx, y + dy, color);
      }

package/dist/ui-engine/runtime-header/init-press-input.js

@@ -13,15 +13,22 @@ static inline void ui_init(void) {
   // containers start locked until the scroll-container loop proves their
   // canvas fits.
   if (!__ui_scroll_canvas_ok && __ui_node_count > 0) {
-    __ui_scroll_canvas_ok = (uint8_t*)calloc(__ui_node_count, sizeof(uint8_t));
+    __ui_scroll_canvas_ok = new (std::nothrow) uint8_t[__ui_node_count]();
   }
-  if (!__ui_scroll_mem_warned && __ui_node_count > 0) {
-    __ui_scroll_mem_warned = (uint8_t*)calloc(__ui_node_count, sizeof(uint8_t));
+  if (!__ui_scroll_render_locked && __ui_node_count > 0) {
+    __ui_scroll_render_locked = new (std::nothrow) uint8_t[__ui_node_count]();
   }
   for (uint16_t i = 0; i < __ui_node_count; i++) {
     __ui_nodes[i].dirty = 1;
     __ui_nodes[i].lastTextHeight = 0;
     __ui_nodes[i].layoutCacheKey = 0;
+    if (__ui_nodes[i].scrollable) {
+      // Force the first scroll-canvas composition to seed every pixel. After
+      // that, a dirty child can be repaired in place without repainting the
+      // entire viewport.
+      __ui_nodes[i].lastPaintedScrollY = static_cast<int16_t>(
+        __ui_nodes[i].scrollY - (__ui_nodes[i].box.h > 0 ? __ui_nodes[i].box.h : 1));
+    }
     if (__ui_nodes[i].kind == NODE_PROGRESS || __ui_nodes[i].kind == NODE_RANGE) {
       __ui_nodes[i].lastTextWidth = -1;
     }
@@ -32,6 +39,11 @@ static inline void ui_init(void) {
       __ui_nodes[n].hasTextBinding = 1;
       strncpy(__ui_nodes[n].textBuffer, __ui_nodes[n].text ? __ui_nodes[n].text : "", UI_TEXT_BUF);
       __ui_nodes[n].textBuffer[UI_TEXT_BUF] = '\\0';
+    } else if (__ui_bindings[i].fn) {
+      // Prime numeric binding caches once at setup; the first tick can then skip
+      // redundant assignments and dirty propagation when values are unchanged.
+      __ui_bindings[i].lastValue = __ui_bindings[i].fn();
+      __ui_bindings[i].initialized = 1;
     }
   }
   // Seed virtualized-list runtime state. The fn pointers can't be baked into
@@ -52,7 +64,7 @@ static inline void ui_init(void) {
     uint16_t ih = __ui_nodes[i].listItemHeight > 0 ? __ui_nodes[i].listItemHeight : 24;
     uint16_t cnt = __ui_nodes[i].listCountFn();
     __ui_nodes[i].listCount = cnt;
-    __ui_nodes[i].contentHeight = (int16_t)((uint32_t)cnt * ih);
+    __ui_nodes[i].contentHeight = static_cast<int16_t>(static_cast<uint32_t>(cnt) * ih);
     __ui_nodes[i].scrollY = 0;
     __ui_nodes[i].overscrollPx = 0;
     __ui_nodes[i].settling = 0;
@@ -61,6 +73,9 @@ static inline void ui_init(void) {
   ui_build_draw_order();
   ui_build_scroll_owner_table();
   ui_refresh_active_screen_bg_node();
+  if (!__ui_scroll_candidates && __ui_node_count > 0) {
+    __ui_scroll_candidates = new (std::nothrow) UIScrollPaintCandidate[__ui_node_count];
+  }
 }
 
 // Debounce: ignore press/release events within 50ms of the last edge.
@@ -99,7 +114,7 @@ static inline void ui_on_release(uint16_t nodeIdx) {
 }
 
 // Pin-watch callback type: void fn(void)
-typedef void (*PinWatchCallback)(void);
+using PinWatchCallback = void (*)(void);
 
 struct UIPinWatch {
   uint8_t pin;