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

package/dist/api/shared/display-adapter.js

@@ -14,7 +14,15 @@ const adapters = new Map();
 export function registerDisplayAdapter(driver, gen) {
     adapters.set(driver, gen);
 }
-export function generateDisplayAdapter(display) {
+export function generateDisplayAdapter(display, strategy) {
+    // Strategy-owned adapters take precedence (frameworks supply their own
+    // display driver code). Falls through to cuttlefish's generic built-in
+    // registry (e.g. the SDL native driver) when no strategy provides one.
+    if (strategy?.providesDisplayAdapter?.() && strategy.resolveDisplayAdapter) {
+        const code = strategy.resolveDisplayAdapter(display);
+        if (code)
+            return code;
+    }
     const driver = display.driver;
     const gen = adapters.get(driver);
     if (!gen) {
@@ -23,123 +31,12 @@ export function generateDisplayAdapter(display) {
     }
     return gen(display);
 }
-// ── ST7796S adapter (RGB565 + RGB666 modes) ─────────────────────────────────
-import { st7796Adapter } from "./display-adapters/st7796.js";
-registerDisplayAdapter("st7796", st7796Adapter);
-// ── eink-mono adapter (SSD1680-class, 1-bit, deferred partial refresh) ───────
-import { einkMonoAdapter } from "./display-adapters/eink-mono.js";
-registerDisplayAdapter("ssd1680", einkMonoAdapter);
-// ── SSD1309 OLED adapter (1-bit mono, I2C, page-buffered) ───────────────────
-import { ssd1309Adapter } from "./display-adapters/ssd1309.js";
-registerDisplayAdapter("ssd1309", ssd1309Adapter);
 // ── SDL2 adapter (native desktop window, RGB888) ────────────────────────────
 import { sdlAdapter } from "./display-adapters/sdl.js";
 registerDisplayAdapter("sdl", sdlAdapter);
-// ── ILI9341 adapter ─────────────────────────────────────────────────────────
-// The first built-in adapter. Mirrors the code previously hardcoded in
-// ui-emitter.ts and runtime-header.ts.
-registerDisplayAdapter("ili9341", (display) => {
-    const cs = display._mountCs;
-    const dc = display._mountDc;
-    const rst = display._mountRst;
-    const rotation = display.rotation ?? 1;
-    const spiFreq = display.spiFrequency;
-    return {
-        includes: [
-            `#define CuttlefishDisplayTarget Adafruit_GFX`,
-            `#define CuttlefishCanvas16 GFXcanvas16`,
-            `#include <Adafruit_GFX.h>`,
-            `#include <Adafruit_ILI9341.h>`,
-        ].join("\n"),
-        declaration: `Adafruit_ILI9341 __tc_display = Adafruit_ILI9341(${cs}, ${dc}, ${rst});`,
-        functions: [
-            `// --- Display adapter: ILI9341 ---`,
-            ``,
-            `static inline void display_init() {`,
-            spiFreq
-                ? `  __tc_display.begin(${spiFreq});`
-                : `  __tc_display.begin();`,
-            `  __tc_display.setRotation(${rotation});`,
-            `  __tc_display.fillScreen(0x0000);`,
-            `}`,
-            ``,
-            `static inline void display_fillScreen(uint16_t color) {`,
-            `  __tc_display.fillScreen(color);`,
-            `}`,
-            ``,
-            `static inline CuttlefishDisplayTarget* display_defaultTarget() { return &__tc_display; }`,
-            `static inline int16_t display_width() { return __tc_display.width(); }`,
-            `static inline int16_t display_height() { return __tc_display.height(); }`,
-            ``,
-            `static inline void display_startWrite() { __tc_display.startWrite(); }`,
-            `static inline void display_endWrite() { __tc_display.endWrite(); }`,
-            `static inline void display_setAddrWindow(int16_t x, int16_t y, int16_t w, int16_t h) {`,
-            `  __tc_display.setAddrWindow(x, y, w, h);`,
-            `}`,
-            `static inline void display_writePixels(uint16_t* pixels, uint32_t count) {`,
-            `  __tc_display.writePixels(pixels, count);`,
-            `}`,
-            ``,
-            `static inline CuttlefishCanvas16* display_createCanvas(int16_t w, int16_t h) {`,
-            `  return new GFXcanvas16(w, h);`,
-            `}`,
-            `static inline CuttlefishCanvas16* display_createCanvasPsram(int16_t w, int16_t h) {`,
-            `#if defined(ESP32) && defined(BOARD_HAS_PSRAM)`,
-            `  return new (ps_malloc(sizeof(GFXcanvas16))) GFXcanvas16(w, h);`,
-            `#else`,
-            `  (void)w; (void)h;`,
-            `  return nullptr;`,
-            `#endif`,
-            `}`,
-            `static inline void display_deleteCanvas(CuttlefishCanvas16* canvas) { delete canvas; }`,
-            `static inline int16_t display_canvasWidth(CuttlefishCanvas16* canvas) { return canvas->width(); }`,
-            `static inline int16_t display_canvasHeight(CuttlefishCanvas16* canvas) { return canvas->height(); }`,
-            `static inline uint16_t* display_canvasBuffer(CuttlefishCanvas16* canvas) { return canvas->getBuffer(); }`,
-            `static inline uint16_t display_canvasGetPixel(CuttlefishCanvas16* canvas, int16_t x, int16_t y) { return canvas->getPixel(x, y); }`,
-            `static inline void display_canvasFillScreen(CuttlefishCanvas16* canvas, UI_COLOR_T color) { canvas->fillScreen((uint16_t)color); }`,
-            `static inline void display_canvasFillRect(CuttlefishCanvas16* canvas, int16_t x, int16_t y, int16_t w, int16_t h, UI_COLOR_T color) {`,
-            `  canvas->fillRect(x, y, w, h, (uint16_t)color);`,
-            `}`,
-            ``,
-            `static inline void display_targetDrawPixel(CuttlefishDisplayTarget* target, int16_t x, int16_t y, UI_COLOR_T color) { target->drawPixel(x, y, (uint16_t)color); }`,
-            `static inline int16_t display_targetWidth(CuttlefishDisplayTarget* target) { return target->width(); }`,
-            `static inline int16_t display_targetHeight(CuttlefishDisplayTarget* target) { return target->height(); }`,
-            `static inline void display_targetDrawRGBBitmap(CuttlefishDisplayTarget* target, int16_t x, int16_t y, const uint16_t* bitmap, int16_t w, int16_t h) {`,
-            `  target->drawRGBBitmap(x, y, bitmap, w, h);`,
-            `}`,
-            `static inline void display_targetFillRect(CuttlefishDisplayTarget* target, int16_t x, int16_t y, int16_t w, int16_t h, UI_COLOR_T color) {`,
-            `  target->fillRect(x, y, w, h, (uint16_t)color);`,
-            `}`,
-            `static inline void display_targetDrawFastHLine(CuttlefishDisplayTarget* target, int16_t x, int16_t y, int16_t w, UI_COLOR_T color) {`,
-            `  target->drawFastHLine(x, y, w, (uint16_t)color);`,
-            `}`,
-            `static inline void display_targetDrawFastVLine(CuttlefishDisplayTarget* target, int16_t x, int16_t y, int16_t h, UI_COLOR_T color) {`,
-            `  target->drawFastVLine(x, y, h, (uint16_t)color);`,
-            `}`,
-            `static inline void display_targetFillRoundRect(CuttlefishDisplayTarget* target, int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, UI_COLOR_T color) {`,
-            `  target->fillRoundRect(x, y, w, h, r, (uint16_t)color);`,
-            `}`,
-            `static inline void display_targetDrawRect(CuttlefishDisplayTarget* target, int16_t x, int16_t y, int16_t w, int16_t h, UI_COLOR_T color) {`,
-            `  target->drawRect(x, y, w, h, (uint16_t)color);`,
-            `}`,
-            `static inline void display_targetDrawRoundRect(CuttlefishDisplayTarget* target, int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, UI_COLOR_T color) {`,
-            `  target->drawRoundRect(x, y, w, h, r, (uint16_t)color);`,
-            `}`,
-            `static inline void display_targetDrawLine(CuttlefishDisplayTarget* target, int16_t x0, int16_t y0, int16_t x1, int16_t y1, UI_COLOR_T color) {`,
-            `  target->drawLine(x0, y0, x1, y1, (uint16_t)color);`,
-            `}`,
-            `static inline void display_targetFillCircle(CuttlefishDisplayTarget* target, int16_t x, int16_t y, int16_t r, UI_COLOR_T color) {`,
-            `  target->fillCircle(x, y, r, (uint16_t)color);`,
-            `}`,
-            `static inline void display_targetDrawCircle(CuttlefishDisplayTarget* target, int16_t x, int16_t y, int16_t r, UI_COLOR_T color) {`,
-            `  target->drawCircle(x, y, r, (uint16_t)color);`,
-            `}`,
-            `static inline void display_targetSetCursor(CuttlefishDisplayTarget* target, int16_t x, int16_t y) { target->setCursor(x, y); }`,
-            `static inline void display_targetSetTextColor(CuttlefishDisplayTarget* target, UI_COLOR_T fg) { target->setTextColor((uint16_t)fg); }`,
-            `static inline void display_targetSetTextColorBg(CuttlefishDisplayTarget* target, UI_COLOR_T fg, UI_COLOR_T bg) { target->setTextColor((uint16_t)fg, (uint16_t)bg); }`,
-            `static inline void display_targetSetTextSize(CuttlefishDisplayTarget* target, uint8_t size) { target->setTextSize(size); }`,
-            `static inline void display_targetSetTextWrap(CuttlefishDisplayTarget* target, bool wrap) { target->setTextWrap(wrap); }`,
-            `static inline void display_targetPrint(CuttlefishDisplayTarget* target, const char* text) { target->print(text); }`,
-        ].join("\n"),
-    };
-});
+// NOTE: The Adafruit_GFX-based adapters (ili9341, st7796, ssd1309, ssd1680
+// eink) were moved to @typecad/framework-arduino (src/displays/
+// adafruit-adapters.ts). They are now strategy-owned: ArduinoStrategy.
+// providesDisplayAdapter() returns true and resolveDisplayAdapter() dispatches
+// to them by driver name. Cuttlefish keeps only the generic adapter registry
+// infrastructure + the framework-agnostic sdl driver for native desktop.

package/dist/api/shared/display-adapters/sdl.js

@@ -62,33 +62,33 @@ export const sdlAdapter = (display) => {
             `  uint32_t fg = 0xFFFFFFu, bg = 0x000000u;`,
             `  uint8_t textSize = 1;`,
             `  bool wrap = true;`,
-            `  explicit SdlGfxCanvas(int16_t w, int16_t h) : w_(w), h_(h), buf(new uint32_t[(size_t)w * h]()) {}`,
+            `  explicit SdlGfxCanvas(int16_t w, int16_t h) : w_(w), h_(h), buf(new uint32_t[static_cast<size_t>(w) * h]()) {}`,
             `  virtual ~SdlGfxCanvas() { delete[] buf; }`,
             `  int16_t width() const { return w_; }`,
             `  int16_t height() const { return h_; }`,
             `  inline void put(int16_t x, int16_t y, uint32_t rgba) {`,
             `    if (x < 0 || y < 0 || x >= w_ || y >= h_) return;`,
-            `    buf[(size_t)y * w_ + x] = rgba;`,
+            `    buf[static_cast<size_t>(y) * w_ + x] = rgba;`,
             `  }`,
             `  inline uint32_t get(int16_t x, int16_t y) const {`,
             `    if (x < 0 || y < 0 || x >= w_ || y >= h_) return 0;`,
-            `    return buf[(size_t)y * w_ + x];`,
+            `    return buf[static_cast<size_t>(y) * w_ + x];`,
             `  }`,
-            `  void drawPixel(int16_t x, int16_t y, UI_COLOR_T color) { put(x, y, (uint32_t)color); }`,
+            `  void drawPixel(int16_t x, int16_t y, UI_COLOR_T color) { put(x, y, static_cast<uint32_t>(color)); }`,
             `  void fillRect(int16_t x, int16_t y, int16_t rw, int16_t rh, UI_COLOR_T color) {`,
             `    if (rw <= 0 || rh <= 0) return;`,
-            `    uint32_t rgba = (uint32_t)color;`,
+            `    uint32_t rgba = static_cast<uint32_t>(color);`,
             `    int16_t x0 = x < 0 ? 0 : x;`,
             `    int16_t y0 = y < 0 ? 0 : y;`,
             `    int16_t x1 = x + rw; if (x1 > w_) x1 = w_;`,
             `    int16_t y1 = y + rh; if (y1 > h_) y1 = h_;`,
             `    if (x0 >= x1 || y0 >= y1) return;`,
             `    for (int16_t j = y0; j < y1; j++)`,
-            `      for (int16_t i = x0; i < x1; i++) buf[(size_t)j * w_ + i] = rgba;`,
+            `      for (int16_t i = x0; i < x1; i++) buf[static_cast<size_t>(j) * w_ + i] = rgba;`,
             `  }`,
             `  void fillScreen(UI_COLOR_T color) {`,
-            `    uint32_t rgba = (uint32_t)color;`,
-            `    for (size_t i = 0; i < (size_t)w_ * h_; i++) buf[i] = rgba;`,
+            `    uint32_t rgba = static_cast<uint32_t>(color);`,
+            `    for (size_t i = 0; i < static_cast<size_t>(w_) * h_; i++) buf[i] = rgba;`,
             `  }`,
             `  void drawFastHLine(int16_t x, int16_t y, int16_t len, UI_COLOR_T c) { fillRect(x, y, len, 1, c); }`,
             `  void drawFastVLine(int16_t x, int16_t y, int16_t len, UI_COLOR_T c) { fillRect(x, y, 1, len, c); }`,
@@ -108,7 +108,7 @@ export const sdlAdapter = (display) => {
             `    int16_t err = dx / 2;`,
             `    int16_t ystep = (y0 < y1) ? 1 : -1;`,
             `    for (; x0 <= x1; x0++) {`,
-            `      if (steep) put(y0, x0, (uint32_t)c); else put(x0, y0, (uint32_t)c);`,
+            `      if (steep) put(y0, x0, static_cast<uint32_t>(c)); else put(x0, y0, static_cast<uint32_t>(c));`,
             `      err -= dy; if (err < 0) { y0 += ystep; err += dx; }`,
             `    }`,
             `  }`,
@@ -117,10 +117,10 @@ export const sdlAdapter = (display) => {
             `    while (x < y) {`,
             `      if (f >= 0) { y--; ddFy += 2; f += ddFy; }`,
             `      x++; ddFx += 2; f += ddFx;`,
-            `      if (cn & 0x4) { put(x0 + x, y0 + y, (uint32_t)c); put(x0 + y, y0 + x, (uint32_t)c); }`,
-            `      if (cn & 0x2) { put(x0 + x, y0 - y, (uint32_t)c); put(x0 + y, y0 - x, (uint32_t)c); }`,
-            `      if (cn & 0x8) { put(x0 - y, y0 + x, (uint32_t)c); put(x0 - x, y0 + y, (uint32_t)c); }`,
-            `      if (cn & 0x1) { put(x0 - y, y0 - x, (uint32_t)c); put(x0 - x, y0 - y, (uint32_t)c); }`,
+            `      if (cn & 0x4) { put(x0 + x, y0 + y, static_cast<uint32_t>(c)); put(x0 + y, y0 + x, static_cast<uint32_t>(c)); }`,
+            `      if (cn & 0x2) { put(x0 + x, y0 - y, static_cast<uint32_t>(c)); put(x0 + y, y0 - x, static_cast<uint32_t>(c)); }`,
+            `      if (cn & 0x8) { put(x0 - y, y0 + x, static_cast<uint32_t>(c)); put(x0 - x, y0 + y, static_cast<uint32_t>(c)); }`,
+            `      if (cn & 0x1) { put(x0 - y, y0 - x, static_cast<uint32_t>(c)); put(x0 - x, y0 - y, static_cast<uint32_t>(c)); }`,
             `    }`,
             `  }`,
             `  void fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t corners, int16_t delta, UI_COLOR_T c) {`,
@@ -143,15 +143,15 @@ export const sdlAdapter = (display) => {
             `  }`,
             `  void drawCircle(int16_t x0, int16_t y0, int16_t r, UI_COLOR_T c) {`,
             `    int16_t f = 1 - r, ddFx = 1, ddFy = -2 * r, x = 0, y = r;`,
-            `    put(x0, y0 + r, (uint32_t)c); put(x0, y0 - r, (uint32_t)c);`,
-            `    put(x0 + r, y0, (uint32_t)c); put(x0 - r, y0, (uint32_t)c);`,
+            `    put(x0, y0 + r, static_cast<uint32_t>(c)); put(x0, y0 - r, static_cast<uint32_t>(c));`,
+            `    put(x0 + r, y0, static_cast<uint32_t>(c)); put(x0 - r, y0, static_cast<uint32_t>(c));`,
             `    while (x < y) {`,
             `      if (f >= 0) { y--; ddFy += 2; f += ddFy; }`,
             `      x++; ddFx += 2; f += ddFx;`,
-            `      put(x0 + x, y0 + y, (uint32_t)c); put(x0 - x, y0 + y, (uint32_t)c);`,
-            `      put(x0 + x, y0 - y, (uint32_t)c); put(x0 - x, y0 - y, (uint32_t)c);`,
-            `      put(x0 + y, y0 + x, (uint32_t)c); put(x0 - y, y0 + x, (uint32_t)c);`,
-            `      put(x0 + y, y0 - x, (uint32_t)c); put(x0 - y, y0 - x, (uint32_t)c);`,
+            `      put(x0 + x, y0 + y, static_cast<uint32_t>(c)); put(x0 - x, y0 + y, static_cast<uint32_t>(c));`,
+            `      put(x0 + x, y0 - y, static_cast<uint32_t>(c)); put(x0 - x, y0 - y, static_cast<uint32_t>(c));`,
+            `      put(x0 + y, y0 + x, static_cast<uint32_t>(c)); put(x0 - y, y0 + x, static_cast<uint32_t>(c));`,
+            `      put(x0 + y, y0 - x, static_cast<uint32_t>(c)); put(x0 - y, y0 - x, static_cast<uint32_t>(c));`,
             `    }`,
             `  }`,
             `  void fillCircle(int16_t x0, int16_t y0, int16_t r, UI_COLOR_T c) {`,
@@ -183,12 +183,12 @@ export const sdlAdapter = (display) => {
             `  void drawRGBBitmap(int16_t x, int16_t y, const UI_COLOR_T* b, int16_t bw, int16_t bh) {`,
             `    for (int16_t j = 0; j < bh; j++)`,
             `      for (int16_t i = 0; i < bw; i++) {`,
-            `        put(x + i, y + j, (uint32_t)b[(size_t)j * bw + i]);`,
+            `        put(x + i, y + j, static_cast<uint32_t>(b[static_cast<size_t>(j) * bw + i]));`,
             `      }`,
             `  }`,
             `  void setCursor(int16_t x, int16_t y) { cx = x; cy = y; }`,
-            `  void setTextColor(UI_COLOR_T c) { fg = (uint32_t)c; bg = fg; }`,
-            `  void setTextColorBg(UI_COLOR_T c, UI_COLOR_T b) { fg = (uint32_t)c; bg = (uint32_t)b; }`,
+            `  void setTextColor(UI_COLOR_T c) { fg = static_cast<uint32_t>(c); bg = fg; }`,
+            `  void setTextColorBg(UI_COLOR_T c, UI_COLOR_T b) { fg = static_cast<uint32_t>(c); bg = static_cast<uint32_t>(b); }`,
             `  void setTextSize(uint8_t s) { textSize = s; }`,
             `  void setTextWrap(bool wp) { wrap = wp; }`,
             `  // print() uses the 5x8 glcd font (same bytes as Adafruit_GFX / the`,
@@ -206,7 +206,7 @@ export const sdlAdapter = (display) => {
             ``,
             `void SdlGfxCanvas::drawChar(int16_t x, int16_t y, unsigned char ch, uint32_t fgc, uint32_t bgc, uint8_t size) {`,
             `  if (ch >= 176 && ch < 255) ch++;`,
-            `  const uint8_t* glyph = &__sdl_glcdfont[(size_t)ch * 5];`,
+            `  const uint8_t* glyph = &__sdl_glcdfont[static_cast<size_t>(ch) * 5];`,
             `  for (int8_t i = 0; i < 5; i++) {`,
             `    uint8_t line = glyph[i];`,
             `    for (int8_t j = 0; j < 8; j++, line >>= 1) {`,
@@ -229,7 +229,7 @@ export const sdlAdapter = (display) => {
             `    if (*s == '\\n') { cx = 0; cy += 8 * textSize; s++; continue; }`,
             `    if (*s == '\\r') { s++; continue; }`,
             `    if (wrap && cx + 6 * textSize > w_) { cx = 0; cy += 8 * textSize; }`,
-            `    drawChar(cx, cy, (unsigned char)*s, fg, bg, textSize);`,
+            `    drawChar(cx, cy, static_cast<unsigned char>(*s), fg, bg, textSize);`,
             `    cx += 6 * textSize;`,
             `    s++;`,
             `  }`,
@@ -247,10 +247,10 @@ export const sdlAdapter = (display) => {
             `    // ARGB8888, so set opaque alpha (0xFF) per pixel at present time.`,
             `    static uint32_t* _presentBuf = nullptr;`,
             `    static size_t _presentBufLen = 0;`,
-            `    size_t n = (size_t)w_ * h_;`,
+            `    size_t n = static_cast<size_t>(w_) * h_;`,
             `    if (!_presentBuf || _presentBufLen < n) { delete[] _presentBuf; _presentBuf = new uint32_t[n]; _presentBufLen = n; }`,
             `    for (size_t i = 0; i < n; i++) _presentBuf[i] = 0xFF000000u | buf[i];`,
-            `    SDL_UpdateTexture(tex, nullptr, _presentBuf, w_ * (int)sizeof(uint32_t));`,
+            `    SDL_UpdateTexture(tex, nullptr, _presentBuf, w_ * static_cast<int>(sizeof(uint32_t)));`,
             `    SDL_RenderClear(ren);`,
             `    SDL_RenderCopy(ren, tex, nullptr, nullptr);`,
             `    SDL_RenderPresent(ren);`,
@@ -316,10 +316,10 @@ export const sdlAdapter = (display) => {
             `}`,
             `static inline void display_writePixels(uint32_t* pixels, uint32_t count) {`,
             `  if (!pixels || __sdl_addr_w <= 0 || __sdl_addr_h <= 0) return;`,
-            `  uint32_t max = (uint32_t)__sdl_addr_w * (uint32_t)__sdl_addr_h;`,
+            `  uint32_t max = static_cast<uint32_t>(__sdl_addr_w) * static_cast<uint32_t>(__sdl_addr_h);`,
             `  for (uint32_t i = 0; i < count && __sdl_write_pos < max; i++, __sdl_write_pos++) {`,
-            `    int16_t dx = (int16_t)(__sdl_addr_x + (__sdl_write_pos % (uint32_t)__sdl_addr_w));`,
-            `    int16_t dy = (int16_t)(__sdl_addr_y + (__sdl_write_pos / (uint32_t)__sdl_addr_w));`,
+            `    int16_t dx = static_cast<int16_t>(__sdl_addr_x + (__sdl_write_pos % static_cast<uint32_t>(__sdl_addr_w)));`,
+            `    int16_t dy = static_cast<int16_t>(__sdl_addr_y + (__sdl_write_pos / static_cast<uint32_t>(__sdl_addr_w)));`,
             `    __tc_display.put(dx, dy, pixels[i]);`,
             `  }`,
             `}`,
@@ -366,8 +366,15 @@ function glcdfontBytes() {
     }
     return lines;
 }
-// Canonical Adafruit GFX 5x7 glcdfont. Public domain.
-// Source: Adafruit_GFX library glcdfont.c.
+// Adafruit GFX 5x7 glcdfont — the 'classic' fixed-space bitmap font shipped
+// with Adafruit_GFX since 1.0. BSD-3-Clause as part of the Adafruit_GFX
+// library (the file carries no per-file license statement; an earlier
+// revision of this comment claimed "public domain" but that could not be
+// verified). See packages/cuttlefish/src/api/shared/glcdfont.ts for the
+// canonical attribution header; this array is the same bytes, retained
+// here to keep the SDL preview self-contained.
+// Source: Adafruit_GFX library glcdfont.c
+//   Upstream: https://github.com/adafruit/Adafruit-GFX-Library/blob/master/glcdfont.c
 const GLCDFONT_BYTES = [
     0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x5b, 0x4f, 0x5b, 0x3e, 0x3e, 0x6b, 0x4f, 0x6b, 0x3e, 0x1c,
     0x3e, 0x7c, 0x3e, 0x1c, 0x18, 0x3c, 0x7e, 0x3c, 0x18, 0x1c, 0x57, 0x7d, 0x57, 0x1c, 0x1c, 0x5e,

package/dist/api/shared/display-profile.d.ts

@@ -1,5 +1,5 @@
 import type { DisplayCapabilities } from "./display-capabilities.js";
-export type TouchLibrary = "XPT2046_Touchscreen" | "Adafruit_TouchScreen" | "Adafruit_STMPE610" | "FT6336U" | "sdl";
+export type TouchLibrary = "XPT2046_Touchscreen" | "Adafruit_TouchScreen" | "Adafruit_STMPE610" | "FT6336U" | "GT911" | "CST816S" | "sdl";
 export interface TouchProfile {
     /**
      * Either a built-in library name OR a path to a custom TypeScript adapter
@@ -37,6 +37,10 @@ export interface TouchProfile {
     /** Reset pin for touch controllers requiring a hardware-reset sequence
      *  before begin() (FT6336U on boards with a reset GPIO tied to the chip). */
     resetPin?: number;
+    /** I2C SDA pin (Zephyr: used to configure the I2C bus pinctrl in the DT overlay). */
+    sda?: number;
+    /** I2C SCL pin (Zephyr: used to configure the I2C bus pinctrl in the DT overlay). */
+    scl?: number;
     /** Raw ADC calibration — maps touch controller raw values to display pixels. */
     calibration: {
         xMin: number;
@@ -75,6 +79,13 @@ export interface DisplayProfile {
     /** Optional explicit display inversion override. Some controller libraries
      *  use panel-specific defaults that do not match every module. */
     invertDisplay?: boolean;
+    /**
+     * Experimental dirty-rectangle synchronization using the controller's
+     * GET_SCANLINE (0x45) readback command. This is opt-in: many ST7796S
+     * modules expose SDO but return unreliable data or stop scanning when 0x45
+     * is read, so a missing/unsafe readback path must not affect normal drawing.
+     */
+    scanlineSync?: boolean;
     touch?: TouchProfile;
     /** Enable antialiased rendering for circles, lines, rounded corners, and text
      *  unless a node opts out with font-smoothing:none.
@@ -105,8 +116,10 @@ export interface ResolvedDisplay extends DisplayProfile {
     _mountBus: string;
     _mountAddress: number;
     _mountReset: number;
-    /** Arduino FQBN (e.g. "esp32:esp32:esp32s3:PSRAM=opi"), used to derive PSRAM
-     *  availability for the scroll-canvas-memory budget. Optional. */
+    /** Framework build target string (e.g. an Arduino FQBN like
+     *  "esp32:esp32:esp32s3:PSRAM=opi" or an IDF target). Carried through for
+     *  framework-side toolchain/compile use; cuttlefish itself does not parse it.
+     *  Optional. */
     _buildTarget?: string;
 }
 export interface DisplayConfig {
@@ -122,7 +135,13 @@ export interface DisplayConfig {
     displayClass?: "tft" | "eink" | "oled";
     capabilities?: DisplayCapabilities;
     rotation?: number;
+    /** Arduino framework: GPIO pin driving the panel backlight (set high at init). */
     backlight?: number;
+    /** Zephyr framework: GPIO pin driving the panel backlight. When set, the
+     *  framework emits a gpio-leds DT node + `backlight` alias so the display
+     *  adapter drives it high at init. Omit when the backlight is hardwired to
+     *  power (e.g. tied to 3.3V) — no node or alias is emitted in that case. */
+    backlightPin?: number;
     spiFrequency?: number;
     spiPins?: {
         mosi: number;
@@ -133,6 +152,12 @@ export interface DisplayConfig {
     colorOrder?: "rgb" | "bgr";
     /** Optional explicit display inversion override. */
     invertDisplay?: boolean;
+    /**
+     * Opt in to experimental GET_SCANLINE (0x45) dirty-rectangle synchronization
+     * on adapters that have a verified controller readback path. Disabled by
+     * default because some ST7796S modules misbehave when this command is read.
+     */
+    scanlineSync?: boolean;
     touch?: TouchProfile | false;
     cs?: number;
     dc?: number;
@@ -201,9 +226,6 @@ export interface ScrollConfig {
     /** Emit per-frame scroll/canvas telemetry over Serial (UI_SCROLL_DEBUG). Off by
      *  default — enable temporarily to diagnose scroll/canvas draw skips on-device. */
     debug?: boolean;
-    /** Max RGB565 scroll viewport canvas size (w×h×2 bytes) assumed to fit in heap
-     *  for Mode B smooth scrolling on the target. Default ~88 KB (ESP32 no PSRAM). */
-    scrollCanvasBudgetBytes?: number;
 }
 /** Fully-resolved scroll config — every field populated, ready for emit. */
 export interface ResolvedScrollConfig {
@@ -216,22 +238,7 @@ export interface ResolvedScrollConfig {
     inputSmoothing: number;
     overrideProbes: boolean;
     debug: boolean;
-    scrollCanvasBudgetBytes: number;
 }
-/** Default RGB565 scroll viewport canvas budget (~88 KB, ESP32-class SRAM). */
-export declare const DEFAULT_SCROLL_CANVAS_BUDGET_BYTES = 88000;
-/** PSRAM scroll canvas budget (~2 MB). ESP32-S3 with OPI/QSPI PSRAM exposes
- *  ~8 MB external RAM; a full-width scroll viewport canvas (e.g. 460×266×2 ≈
- *  239 KB) is trivial there, so the transpile-time scroll-canvas-memory
- *  diagnostic should use a PSRAM-appropriate budget rather than the no-PSRAM
- *  SRAM default — otherwise every PSRAM target emits stale "exceeds budget"
- *  warnings for canvases the runtime allocates without issue. */
-export declare const PSRAM_SCROLL_CANVAS_BUDGET_BYTES = 2000000;
-/** Detect PSRAM from an Arduino FQBN buildTarget (e.g. "esp32:esp32:esp32s3:PSRAM=opi").
- *  Returns true for any PSRAM=<value> option whose value indicates PSRAM is
- *  enabled (opi, io, qspi, enabled, true). Returns false when absent or set
- *  to a disabled-looking value (disabled, false, none). */
-export declare function buildTargetHasPsram(buildTarget: string | undefined): boolean;
 /**
  * Resolve scroll config from a display profile. Declared overrides win;
  * otherwise derive the input tier from the touch library (resistive chips →
@@ -241,8 +248,6 @@ export declare function buildTargetHasPsram(buildTarget: string | undefined): bo
 export declare function resolveScrollConfig(display: {
     touch?: TouchProfile | false;
     scroll?: ScrollConfig;
-}, ctx?: {
-    buildTarget?: string;
 }): ResolvedScrollConfig;
 export declare function resolveDisplayProfile(config: DisplayConfig, registry: Map<string, DisplayProfile>): {
     profile: DisplayProfile;
@@ -261,5 +266,22 @@ export interface TouchAdapterCodegen {
     /** C++ static inline shim functions: touch_init, touch_isTouched, touch_readRaw. */
     functions: string;
 }
-/** Generate C++ code for a built-in touch library adapter. */
-export declare function generateTouchAdapter(touch: TouchProfile): TouchAdapterCodegen;
+/** Generate C++ code for a built-in touch library adapter.
+ *
+ *  Strategy-owned touch adapters take precedence: when the strategy's
+ *  `providesTouchAdapter()` returns true and `resolveTouchAdapter` returns
+ *  non-null, that codegen wins. The Arduino-ecosystem libraries
+ *  (XPT2046_Touchscreen, Adafruit_TouchScreen, Adafruit_STMPE610, FT6336U)
+ *  are strategy-owned — they live in @typecad/framework-arduino
+ *  (src/displays/touch-adapters-codegen.ts) and ArduinoStrategy dispatches to
+ *  them. Cuttlefish keeps only the framework-agnostic `sdl` path here.
+ *
+ *  Passing `undefined` for the strategy (or a strategy whose
+ *  resolveTouchAdapter returns undefined for the given library) falls through
+ *  to the `sdl` branch below; any other library without a strategy-provided
+ *  adapter throws.
+ */
+export declare function generateTouchAdapter(touch: TouchProfile, strategy?: {
+    providesTouchAdapter?(): boolean;
+    resolveTouchAdapter?(touch: TouchProfile): TouchAdapterCodegen | undefined;
+}): TouchAdapterCodegen;