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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typecad/cuttlefish",
-  "version": "1.0.0-alpha.6",
+  "version": "1.0.0-alpha.8",
   "description": "TypeScript to C++ transpiler — native, Arduino, and bare-metal targets",
   "type": "module",
   "main": "./dist/transpile.js",
@@ -29,10 +29,22 @@
       "types": "./dist/ui-hook.d.ts",
       "default": "./dist/ui-hook.js"
     },
+    "./safety-hook-types": {
+      "types": "./dist/safety-hook.d.ts",
+      "default": "./dist/safety-hook.js"
+    },
+    "./build-ir-state": {
+      "types": "./dist/ir/build-ir-state.d.ts",
+      "default": "./dist/ir/build-ir-state.js"
+    },
     "./config-loader": {
       "types": "./dist/config-loader.d.ts",
       "default": "./dist/config-loader.js"
     },
+    "./utils/ui": {
+      "types": "./dist/utils/ui.d.ts",
+      "default": "./dist/utils/ui.js"
+    },
     "./stores/display-profile-store": {
       "types": "./dist/stores/display-profile-store.d.ts",
       "default": "./dist/stores/display-profile-store.js"
@@ -49,6 +61,10 @@
       "types": "./dist/emit/route-hal-op.d.ts",
       "default": "./dist/emit/route-hal-op.js"
     },
+    "./lib/component-decls": {
+      "types": "./dist/libdef/component-decls.d.ts",
+      "default": "./dist/libdef/component-decls.js"
+    },
     "./ir/transformers/ui-lowering": {
       "types": "./dist/ir/transformers/ui-lowering.d.ts",
       "default": "./dist/ir/transformers/ui-lowering.js"
@@ -80,19 +96,22 @@
   "dependencies": {
     "chalk": "^4.1.2",
     "typescript": "^5.7.3",
-    "zod": "^3.24.0",
-    "@typecad/arduino-cli": "1.0.0-alpha.6"
+    "zod": "^3.24.0"
   },
   "peerDependencies": {
-    "@typecad/ui": "1.0.0-alpha.6"
+    "@typecad/ui": "1.0.0-alpha.8",
+    "@typecad/safety": "1.0.0-alpha.8"
   },
   "peerDependenciesMeta": {
     "@typecad/ui": {
       "optional": true
+    },
+    "@typecad/safety": {
+      "optional": true
     }
   },
   "optionalDependencies": {
-    "@typecad/framework-native": "1.0.0-alpha.6"
+    "@typecad/framework-native": "1.0.0-alpha.8"
   },
   "devDependencies": {
     "@types/node": "^22.10.7"

package/dist/api/shared/display-adapters/eink-mono.d.ts

@@ -1,2 +0,0 @@
-import type { DisplayAdapterGenerator } from "../display-adapter.js";
-export declare const einkMonoAdapter: DisplayAdapterGenerator;

package/dist/api/shared/display-adapters/eink-mono.js

@@ -1,53 +0,0 @@
-// ---------------------------------------------------------------------------
-// eink-mono display adapter — 1-bit B&W e-ink panels (SSD1680-class, e.g. the
-// common 296×128 / 250×122 breakouts). Deferred refresh: no fillScreen on init
-// (a full clear flashes), and a partial-refresh entry point the runtime's dirty-
-// rect union calls once per frame.
-//
-// Library note: targets Adafruit_EPD (Adafruit_SSD168x). The exact partial-
-// refresh method name varies by library (Adafruit_EPD: refreshPartial / GxEPD:
-// updateWindow). Verify against the target library before flashing — the shim
-// shape is correct; the method call is library-specific. TODO Phase 5.
-// ---------------------------------------------------------------------------
-export const einkMonoAdapter = (display) => {
-    const cs = display._mountCs;
-    const dc = display._mountDc;
-    const rst = display._mountRst;
-    const rotation = display.rotation ?? 0;
-    const w = display.width;
-    const h = display.height;
-    return {
-        includes: [
-            "#include <Adafruit_GFX.h>",
-            "#include <Adafruit_EPD.h>",
-        ].join("\n"),
-        // busy pin = -1 (unused); SRCS+D/C+RST+CS wiring. Adafruit_SSD168x(width, height, dc, rst, cs, busy).
-        declaration: `Adafruit_SSD168x __tc_display(${w}, ${h}, ${dc}, ${rst}, ${cs}, -1);`,
-        functions: [
-            "// --- Display adapter: eink-mono (SSD1680-class, 1-bit, deferred refresh) ---",
-            "static inline void display_init() {",
-            "  __tc_display.begin();",
-            `  __tc_display.setRotation(${rotation});`,
-            "  // No full-screen clear here — e-ink flashes on a full clear. The runtime",
-            "  // marks all nodes dirty (UI_REFRESH_DEFERRED) and the first flush repaints",
-            "  // via partial refresh instead.",
-            "}",
-            "",
-            "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() {}",
-            "static inline void display_endWrite() {}",
-            "static inline void display_setAddrWindow(int16_t x, int16_t y, int16_t w, int16_t h) { (void)x; (void)y; (void)w; (void)h; }",
-            // Partial refresh: push just the dirty region. The runtime draws into the
-            // EPD's built-in GFX buffer (the display IS the backing store for 1-bit),
-            // then calls this with the unioned dirty rect. TODO Phase 5: verify the
-            // exact partial-refresh API for the target EPD library.
-            "static inline void display_partial_refresh(int16_t x, int16_t y, int16_t w, int16_t h) {",
-            "  __tc_display.refreshPartial(x, y, (uint16_t)w, (uint16_t)h);",
-            "}",
-            // drawPixel goes through GFX into the EPD buffer; partial_refresh publishes it.
-            "static inline void display_fillScreen(uint32_t color) { __tc_display.fillScreen(color ? EPD_WHITE : EPD_BLACK); }",
-        ].join("\n"),
-    };
-};

package/dist/api/shared/display-adapters/ssd1309.d.ts

@@ -1,2 +0,0 @@
-import type { DisplayAdapterGenerator } from "../display-adapter.js";
-export declare const ssd1309Adapter: DisplayAdapterGenerator;

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

@@ -1,136 +0,0 @@
-// ---------------------------------------------------------------------------
-// SSD1309 OLED display adapter — 1-bit monochrome OLED panels over I2C.
-//
-// Targets the Adafruit_SSD1306 library (which supports SSD1309 via the same
-// API). The SSD1306 is a page-buffered Adafruit_GFX subclass: draw into its
-// buffer via drawPixel/fillRect, then call display() to flush over I2C.
-// Colors are 1-bit (SSD1306_WHITE / SSD1306_BLACK). The runtime's
-// UI_NATIVE_MONO snap converts 565 → black/white at the draw choke points.
-//
-// The SSD1306 IS the backing store (its internal buffer), so this adapter
-// follows the e-ink deferred-refresh pattern: the runtime draws dirty rects
-// into the buffer, then display_partial_refresh() flushes. The SSD1306 has
-// no true partial refresh — display() flushes the full page buffer — but
-// the dirty-rect tracking still minimizes draw calls into the buffer.
-//
-// I2C wiring: SDA/SCL (Wire bus) + reset pin + I2C address (default 0x3C).
-// ---------------------------------------------------------------------------
-export const ssd1309Adapter = (display) => {
-    const w = display.width;
-    const h = display.height;
-    const reset = display._mountReset;
-    const address = display._mountAddress;
-    const rotation = display.rotation ?? 0;
-    return {
-        includes: [
-            `#define CuttlefishDisplayTarget Adafruit_GFX`,
-            `#define CuttlefishCanvas16 GFXcanvas16`,
-            `#define SSD1306_NO_SPLASH`,
-            `#include <Adafruit_GFX.h>`,
-            `#include <Adafruit_SSD1306.h>`,
-            `#include <Wire.h>`,
-        ].join("\n"),
-        // I2C constructor: Adafruit_SSD1306(width, height, &Wire, resetPin)
-        declaration: `Adafruit_SSD1306 __tc_display(${w}, ${h}, &Wire, ${reset});`,
-        functions: [
-            `// --- Display adapter: SSD1309 OLED (1-bit mono, I2C, page-buffered) ---`,
-            `static inline void display_init() {`,
-            `  // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally.`,
-            `  __tc_display.begin(SSD1306_SWITCHCAPVCC, 0x${address.toString(16)});`,
-            `  __tc_display.setRotation(${rotation});`,
-            `  __tc_display.clearDisplay();`,
-            `  __tc_display.display();`,
-            `}`,
-            ``,
-            `static inline void display_fillScreen(uint32_t color) {`,
-            `  __tc_display.fillScreen(color ? SSD1306_WHITE : SSD1306_BLACK);`,
-            `}`,
-            `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() {}`,
-            `static inline void display_endWrite() {}`,
-            `static int16_t __ssd1309_addr_x = 0;`,
-            `static int16_t __ssd1309_addr_y = 0;`,
-            `static int16_t __ssd1309_addr_w = 0;`,
-            `static int16_t __ssd1309_addr_h = 0;`,
-            `static uint32_t __ssd1309_addr_cursor = 0;`,
-            `static inline void display_setAddrWindow(int16_t x, int16_t y, int16_t w, int16_t h) {`,
-            `  __ssd1309_addr_x = x;`,
-            `  __ssd1309_addr_y = y;`,
-            `  __ssd1309_addr_w = w;`,
-            `  __ssd1309_addr_h = h;`,
-            `  __ssd1309_addr_cursor = 0;`,
-            `}`,
-            `static inline void display_writePixels(UI_COLOR_T* pixels, uint32_t count) {`,
-            `  // SSD1306 is page-buffered — write into the GFX buffer via drawPixel.`,
-            `  if (__ssd1309_addr_w <= 0 || __ssd1309_addr_h <= 0) return;`,
-            `  uint32_t windowPixels = (uint32_t)__ssd1309_addr_w * (uint32_t)__ssd1309_addr_h;`,
-            `  for (uint32_t i = 0; i < count; i++) {`,
-            `    if (__ssd1309_addr_cursor >= windowPixels) break;`,
-            `    uint32_t pos = __ssd1309_addr_cursor++;`,
-            `    int16_t px = (int16_t)(__ssd1309_addr_x + (int16_t)(pos % (uint32_t)__ssd1309_addr_w));`,
-            `    int16_t py = (int16_t)(__ssd1309_addr_y + (int16_t)(pos / (uint32_t)__ssd1309_addr_w));`,
-            `    __tc_display.drawPixel(px, py, pixels[i] ? SSD1306_WHITE : SSD1306_BLACK);`,
-            `  }`,
-            `}`,
-            ``,
-            `// The SSD1306 has no true partial refresh — display() flushes the full`,
-            `// page buffer. The runtime's dirty-rect tracking still minimizes the draw`,
-            `// calls INTO the buffer (only dirty nodes are redrawn); this just publishes`,
-            `// the result. Called once per frame after the dirty-rect union is drawn.`,
-            `static inline void display_partial_refresh(int16_t x, int16_t y, int16_t w, int16_t h) {`,
-            `  (void)x; (void)y; (void)w; (void)h;`,
-            `  __tc_display.display();`,
-            `}`,
-            // ── Canvas (offscreen GFXcanvas16 for AA text / scroll compositing) ──
-            `static inline uint16_t ssd_mono(uint16_t c);`,
-            `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* c) { return c->width(); }`,
-            `static inline int16_t display_canvasHeight(CuttlefishCanvas16* c) { return c->height(); }`,
-            `static inline uint16_t* display_canvasBuffer(CuttlefishCanvas16* c) { return c->getBuffer(); }`,
-            `static inline uint16_t display_canvasGetPixel(CuttlefishCanvas16* c, int16_t x, int16_t y) { return c->getPixel(x, y); }`,
-            `static inline void display_canvasFillScreen(CuttlefishCanvas16* c, UI_COLOR_T color) { c->fillScreen(ssd_mono((uint16_t)color)); }`,
-            `static inline void display_canvasFillRect(CuttlefishCanvas16* c, int16_t x, int16_t y, int16_t w, int16_t h, UI_COLOR_T color) { c->fillRect(x, y, w, h, ssd_mono((uint16_t)color)); }`,
-            // ── Color conversion: runtime uses 0xffff/0x0000 (565 mono snap), but the
-            //    SSD1306's drawPixel switch only accepts 0/1/2. Convert any nonzero to 1. ──
-            `static inline uint16_t ssd_mono(uint16_t c) { return c ? SSD1306_WHITE : SSD1306_BLACK; }`,
-            // ── Target-polymorphic draw (panel + canvas share CuttlefishDisplayTarget*) ──
-            `static inline void display_targetDrawPixel(CuttlefishDisplayTarget* t, int16_t x, int16_t y, UI_COLOR_T color) { t->drawPixel(x, y, ssd_mono((uint16_t)color)); }`,
-            `static inline int16_t display_targetWidth(CuttlefishDisplayTarget* t) { return t->width(); }`,
-            `static inline int16_t display_targetHeight(CuttlefishDisplayTarget* t) { return t->height(); }`,
-            `static inline void display_targetDrawRGBBitmap(CuttlefishDisplayTarget* t, int16_t x, int16_t y, const UI_COLOR_T* b, int16_t w, int16_t h) {`,
-            `  if (!b || w <= 0 || h <= 0) return;`,
-            `  for (int16_t yy = 0; yy < h; yy++) {`,
-            `    for (int16_t xx = 0; xx < w; xx++) {`,
-            `      t->drawPixel((int16_t)(x + xx), (int16_t)(y + yy), ssd_mono((uint16_t)b[(int32_t)yy * w + xx]));`,
-            `    }`,
-            `  }`,
-            `}`,
-            `static inline void display_targetFillRect(CuttlefishDisplayTarget* t, int16_t x, int16_t y, int16_t w, int16_t h, UI_COLOR_T color) { t->fillRect(x, y, w, h, ssd_mono((uint16_t)color)); }`,
-            `static inline void display_targetDrawFastHLine(CuttlefishDisplayTarget* t, int16_t x, int16_t y, int16_t w, UI_COLOR_T color) { t->drawFastHLine(x, y, w, ssd_mono((uint16_t)color)); }`,
-            `static inline void display_targetDrawFastVLine(CuttlefishDisplayTarget* t, int16_t x, int16_t y, int16_t h, UI_COLOR_T color) { t->drawFastVLine(x, y, h, ssd_mono((uint16_t)color)); }`,
-            `static inline void display_targetFillRoundRect(CuttlefishDisplayTarget* t, int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, UI_COLOR_T color) { t->fillRoundRect(x, y, w, h, r, ssd_mono((uint16_t)color)); }`,
-            `static inline void display_targetDrawRect(CuttlefishDisplayTarget* t, int16_t x, int16_t y, int16_t w, int16_t h, UI_COLOR_T color) { t->drawRect(x, y, w, h, ssd_mono((uint16_t)color)); }`,
-            `static inline void display_targetDrawRoundRect(CuttlefishDisplayTarget* t, int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, UI_COLOR_T color) { t->drawRoundRect(x, y, w, h, r, ssd_mono((uint16_t)color)); }`,
-            `static inline void display_targetDrawLine(CuttlefishDisplayTarget* t, int16_t x0, int16_t y0, int16_t x1, int16_t y1, UI_COLOR_T color) { t->drawLine(x0, y0, x1, y1, ssd_mono((uint16_t)color)); }`,
-            `static inline void display_targetFillCircle(CuttlefishDisplayTarget* t, int16_t x, int16_t y, int16_t r, UI_COLOR_T color) { t->fillCircle(x, y, r, ssd_mono((uint16_t)color)); }`,
-            `static inline void display_targetDrawCircle(CuttlefishDisplayTarget* t, int16_t x, int16_t y, int16_t r, UI_COLOR_T color) { t->drawCircle(x, y, r, ssd_mono((uint16_t)color)); }`,
-            `static inline void display_targetSetCursor(CuttlefishDisplayTarget* t, int16_t x, int16_t y) { t->setCursor(x, y); }`,
-            `static inline void display_targetSetTextColor(CuttlefishDisplayTarget* t, UI_COLOR_T fg) { t->setTextColor(ssd_mono((uint16_t)fg)); }`,
-            `static inline void display_targetSetTextColorBg(CuttlefishDisplayTarget* t, UI_COLOR_T fg, UI_COLOR_T bg) { t->setTextColor(ssd_mono((uint16_t)fg), ssd_mono((uint16_t)bg)); }`,
-            `static inline void display_targetSetTextSize(CuttlefishDisplayTarget* t, uint8_t s) { t->setTextSize(s); }`,
-            `static inline void display_targetSetTextWrap(CuttlefishDisplayTarget* t, bool w) { t->setTextWrap(w); }`,
-            `static inline void display_targetPrint(CuttlefishDisplayTarget* t, const char* s) { t->print(s); }`,
-        ].join("\n"),
-    };
-};

package/dist/api/shared/display-adapters/st7796.d.ts

@@ -1,2 +0,0 @@
-import type { DisplayAdapterGenerator } from "../display-adapter.js";
-export declare const st7796Adapter: DisplayAdapterGenerator;

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

@@ -1,132 +0,0 @@
-// ---------------------------------------------------------------------------
-// ST7796S display adapter — targets the Adafruit_ST7735_and_ST7789_Library
-// fork that exposes the Adafruit_ST7796S class (320×480 SPI TFT).
-//
-// Color mode: RGB565 only. The Adafruit_ST7796S init sequence hardcodes
-// ST77XX_COLMOD = 0x55 (16-bit/pixel). RGB666/18-bit would require patching
-// the library's init array (0x55 → 0x66) AND overriding Adafruit_SPITFT's
-// 565-native writePixels — out of scope for v1. Requesting rgb666 throws.
-//
-// Init API: Adafruit_ST7796S requires init(w,h,rowOff,colOff,colorOrder) to
-// send the panel init sequence. begin(freq) alone would skip it (blank panel).
-// SPI frequency handling: init() runs the panel command sequence and initializes
-// Adafruit_SPITFT. If the profile requests a frequency, update the transaction
-// settings with setSPISpeed() after init; do not call initSPI() a second time.
-// ---------------------------------------------------------------------------
-export const st7796Adapter = (display) => {
-    const cs = display._mountCs;
-    const dc = display._mountDc;
-    const rst = display._mountRst;
-    const rotation = display.rotation ?? 1;
-    const spiFreq = display.spiFrequency;
-    const invertDisplay = display.invertDisplay;
-    const colorOrder = display.colorOrder === "bgr" ? "ST7796S_BGR" : "ST7796S_RGB";
-    if (display.colorFormat === "rgb666" || display.colorFormat === "rgb888") {
-        throw new Error(`RGB666/RGB888 is not supported by the Adafruit_ST7796S library: ` +
-            `its init sequence hardcodes COLMOD=0x55 (RGB565). Use colorFormat: "rgb565". ` +
-            `True 18-bit support requires patching the library init array and overriding ` +
-            `Adafruit_SPITFT's 565-native writePixels — tracked as a follow-up.`);
-    }
-    const includes = [
-        "#define CuttlefishDisplayTarget Adafruit_GFX",
-        "#define CuttlefishCanvas16 GFXcanvas16",
-        "#include <Adafruit_GFX.h>",
-        "#include <Adafruit_ST7796S.h>",
-    ].join("\n");
-    const inversionLines = invertDisplay === undefined
-        ? []
-        : [
-            `  __tc_display.startWrite();`,
-            `  __tc_display.writeCommand(${invertDisplay ? "ST77XX_INVON" : "ST77XX_INVOFF"});`,
-            `  __tc_display.endWrite();`,
-        ];
-    return {
-        includes,
-        declaration: `Adafruit_ST7796S __tc_display = Adafruit_ST7796S(${cs}, ${dc}, ${rst});`,
-        functions: [
-            `// --- Display adapter: ST7796S (RGB565) ---`,
-            `static inline void display_init() {`,
-            `  __tc_display.init(320, 480, 0, 0, ${colorOrder});`,
-            spiFreq ? `  __tc_display.setSPISpeed(${spiFreq});` : ``,
-            ...inversionLines,
-            `  __tc_display.setRotation(${rotation});`,
-            `  __tc_display.fillScreen(0x0000);`,
-            `}`,
-            ``,
-            `static inline void display_fillScreen(UI_COLOR_T color) { __tc_display.fillScreen((uint16_t)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"),
-    };
-};

package/dist/licenses.d.ts

@@ -1,185 +0,0 @@
-export type CopyleftRisk = "permissive" | "weak-copyleft" | "strong-copyleft" | "unknown";
-export type LicenseSource = "library.properties" | "license-file" | "source-header" | "none";
-export interface LibraryLicenseEntry {
-    name: string;
-    version: string | undefined;
-    /** install_dir as reported by arduino-cli lib list. */
-    path: string;
-    /** Normalized SPDX ID (e.g. "BSD-3-Clause"); undefined if not determined. */
-    spdx: string | undefined;
-    risk: CopyleftRisk;
-    source: LicenseSource;
-}
-export type ScanOutcome = {
-    ok: true;
-    libraries: LibraryLicenseEntry[];
-} | {
-    ok: false;
-    reason: "arduino-cli-not-found" | "arduino-cli-unresponsive" | "no-libraries";
-    message: string;
-};
-/**
- * Headers the project needs. `source` is "ino" when read from the generated
- * .ino (authoritative) or "config" when derived from cuttlefish.config.ts
- * (partial: display/touch only).
- */
-export type ProjectHeaders = {
-    ok: true;
-    headers: string[];
-    source: "ino" | "config";
-    inoPath?: string;
-} | {
-    ok: false;
-    reason: "no-config" | "no-entry" | "unreadable-ino";
-    message: string;
-};
-/**
- * Minimal view of ResolvedCuttlefishConfig that resolveProjectHeaders needs.
- * Kept structural so we don't import the full config type (avoids a cycle).
- */
-interface ProjectConfig {
-    configPath: string;
-    entry?: string;
-    outputOutDir?: string;
-    /** FQBN, e.g. 'arduino:avr:uno'. Used to resolve the board core for core-bundled libs. */
-    buildTarget?: string;
-    display?: {
-        profile?: string;
-        driver?: string;
-        touch?: {
-            library?: string;
-        };
-    } | null;
-}
-/** Classify a header as a compiler-toolchain C-library header. */
-export declare function isToolchainHeader(header: string): boolean;
-/**
- * Result of resolving the project's board core directory.
- */
-export type ProjectCore = {
-    ok: true;
-    coreDir: string;
-} | {
-    ok: false;
-    reason: "no-fqbn" | "no-core";
-    message: string;
-};
-/**
- * Resolve the project's board-core directory from its FQBN, via
- * `arduino-cli config dump` (for the packages data dir) and the on-disk
- * `<data>/packages/<packager>/hardware/<arch>/<version>/` layout. Returns the
- * highest-versioned core dir. Never throws.
- *
- * `runConfigDump` is an injected seam (returns the `config dump` stdout, or ""
- * on failure) so the function is unit-testable without spawning.
- */
-export declare function resolveProjectCore(fqbn: string | undefined, runConfigDump: () => string, readdir: (d: string) => string[]): ProjectCore;
-/**
- * Resolve the project's library headers. Prefers the generated .ino
- * (authoritative); falls back to display/touch headers derived from config
- * (partial picture, no transpile required).
- */
-export declare function resolveProjectHeaders(config: ProjectConfig | undefined, readFile: (p: string) => string | undefined): ProjectHeaders;
-/**
- * One project header, joined to its owning library or flagged not-installed.
- */
-export type ProjectLibrary = {
-    kind: "resolved";
-    lib: LibraryLicenseEntry;
-} | {
-    kind: "core";
-    header: string;
-} | {
-    kind: "not-installed";
-    header: string;
-};
-/**
- * Build a header-basename -> bundled-library map from a board core's bundled
- * libraries. Scans `<coreDir>/libraries/<Lib>/src/` for .h files (e.g. Wire.h,
- * SPI.h). Each header maps to a synthetic RawArduinoLibrary so the existing
- * resolveLibraryLicense can read its license from the bundled lib's header
- * notice or library.properties.
- */
-export declare function buildCoreHeaderIndex(coreDir: string, readdir: (d: string) => string[]): Map<string, RawArduinoLibrary>;
-/**
- * Join each project header to its owning library or classify it. Pipeline:
- *   1. user library (arduino-cli lib list)  -> resolved (license)
- *   2. core library (project's own core)    -> resolved (license, e.g. LGPL-2.1)
- *   3. toolchain header (avr/*, util/*)     -> core (gray, no license)
- *   4. else                                  -> not-installed
- *
- * `coreDir` is optional; when absent, step 2 is skipped.
- */
-export declare function joinHeadersToLibraries(headers: string[], libs: RawArduinoLibrary[], readdir: (d: string) => string[], readFile: (p: string) => string | undefined, coreDir?: string): ProjectLibrary[];
-/**
- * Resolve a raw license input (either the short `library.properties` `license=`
- * value, the full text of a LICENSE file, or a source-file header comment) to a
- * canonical SPDX ID.
- *
- * Matching priority:
- *   1. SPDX-License-Identifier: <id> marker (authoritative when present)
- *   2. exact alias match (suits the short properties value)
- *   3. substring markers match, ALL markers required (suits full LICENSE text)
- *   4. shortMarkers match, ANY one sufficient (suits sparse header comments
- *      like Adafruit's "BSD license, all text here must be included")
- *
- * Returns the SPDX ID string, or undefined if nothing matched.
- */
-export declare function identifySpdx(input: string): string | undefined;
-/**
- * Classify the copyleft risk of a known SPDX ID. Returns "unknown" for
- * unrecognized ids.
- */
-export declare function classifyRisk(spdx: string): CopyleftRisk;
-/** Raw library entry as it appears in `arduino-cli lib list --format json`. */
-export interface RawArduinoLibrary {
-    name: string;
-    version?: string;
-    install_dir?: string;
-}
-/**
- * Options for `scanLicenses`. Production calls omit this object entirely; tests
- * inject `fakeLibList` and `fakeReadFile` to avoid spawning and disk I/O.
- */
-export interface ScanOptions {
-    /** Override the `arduino-cli lib list` call. Return null to simulate spawn failure. */
-    fakeLibList?: () => RawArduinoLibrary[] | null;
-    /** Override disk reads of library.properties and LICENSE files. */
-    fakeReadFile?: (p: string) => string | undefined;
-    /** Override directory listings. */
-    fakeReaddir?: (d: string) => string[];
-}
-/**
- * Normalize either JSON shape (wrapped or bare array) to a flat library list.
- * Exported for direct unit testing of the dual-shape parsing.
- */
-export declare function coerceLibList(parsed: unknown): RawArduinoLibrary[];
-/**
- * Module-level runner override used by presenter tests so `scanLicenses()`
- * (with no args) does not spawn. Mirrors __setArduinoCliRunnerForTest.
- */
-export interface LicensesRunner {
-    listLibraries: () => RawArduinoLibrary[] | null;
-    readFile: (p: string) => string | undefined;
-    readdir: (d: string) => string[];
-}
-/** @internal Test-only override of the default runner. */
-export declare function __setLicensesRunnerForTest(runner: LicensesRunner | undefined): void;
-/**
- * Scan installed Arduino libraries and resolve each one's license. Never throws.
- */
-export declare function scanLicenses(options?: ScanOptions): ScanOutcome;
-/** @internal Test-only override of the project config (normally loaded via loadCuttlefishConfig). */
-export declare function __setProjectConfigForTest(config: ProjectConfig | undefined): void;
-/** @internal Test-only override of `arduino-cli config dump` stdout. */
-export declare function __setConfigDumpForTest(fn: (() => string) | undefined): void;
-/**
- * `cuttlefish licenses` presenter. `all === false` (default, project scope)
- * resolves this project's libraries from the generated .ino (or config
- * fallback), joins each to an installed library, and reports only those.
- * `all === true` reports every installed library (the original behavior).
- * Warns on unknown licenses; flags NOT INSTALLED headers in project scope; sets
- * process.exitCode under --strict. Never calls process.exit().
- */
-export declare function runLicensesPresenter(strict: boolean, all: boolean): void;
-export {};