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

package/dist/utils/cli.js

@@ -17,7 +17,7 @@ export function printHelp() {
     console.log(`  cuttlefish board add <spec.jsonc> [--force]   Generate board + MCU packages from a chip spec`);
     console.log(`  cuttlefish gen-decls <input.cpp|--all <directory>>`);
     console.log(`  cuttlefish map-error <mapFile> [options]`);
-    console.log(`  cuttlefish doctor                              Check that arduino-cli is installed and the board's core is present`);
+    console.log(`  cuttlefish doctor                              Check the active framework's environment (e.g. toolchain + board core)`);
     console.log(`  cuttlefish licenses [--all] [--strict]          Scan this project's Arduino libraries for SPDX licenses (--all: every installed library)`);
     console.log();
     console.log(chalk.gray(`Transpilation is always performed first. Use --compile, --upload, and`));
@@ -39,6 +39,16 @@ export function printHelp() {
     console.log(`  --emit-maps <bool>      Emit source maps: "true" or "false" (default: true)`);
     console.log(`                          Source maps enable mapping C++ errors back to TypeScript`);
     console.log();
+    console.log(`  --autosar[=<mode>]      AUTOSAR C++14 compliance mode for emitted code:`);
+    console.log(`                            off     no enforcement (default)`);
+    console.log(`                            warn    emit AUTOSAR_* diagnostics + sidecar, build still succeeds`);
+    console.log(`                            strict  abort emit on unrecorded required violations`);
+    console.log(`                          A sidecar <name>.autosar-deviations.json is written next to the`);
+    console.log(`                          emitted artifact in warn/strict modes. See COMPLIANCE.md.`);
+    console.log();
+    console.log(`  --autosar-arxml         Also write <name>.autosar-deviations.arxml (Artop/DaVinci).`);
+    console.log(`                          No-op unless --autosar is warn or strict.`);
+    console.log();
     console.log(chalk.cyan(`BUILD COMMANDS`) + chalk.gray(` (chain in order: --compile → --upload → --monitor)`));
     console.log();
     console.log(`  --compile               Compile the generated output using the framework toolchain.`);
@@ -104,6 +114,12 @@ export function printHelp() {
     console.log(`  --diagnostics           Generate diagnostics.md and diagnostics.json reports`);
     console.log(`                          Includes IR graph, heap analysis, and task analysis`);
     console.log();
+    console.log(`  --debug                 Inject Serial.println instrumentation at breakpoints.`);
+    console.log(`                          Reads .cuttlefish/breakpoints.json (written by the`);
+    console.log(`                          TypeCAD Debug VS Code extension). At each breakpoint the`);
+    console.log(`                          firmware prints the location, original line, and in-scope`);
+    console.log(`                          variables, then halts — press ENTER over serial to continue.`);
+    console.log();
     console.log(`  --help, -h              Show this help message`);
     console.log();
     console.log(chalk.cyan(`PROJECT CREATION`));
@@ -211,7 +227,11 @@ function parsePipelineCommand(argv, command, inputFile) {
     const emitMapsFlag = readFirstFlagValue(argv, ["--emit-maps"]);
     const buildTarget = readFirstFlagValue(argv, ["--build-target"]);
     const port = readFirstFlagValue(argv, ["--port"]);
-    const baud = readNumberFlag(argv, ["--baud"], 9600) ?? 9600;
+    // Default to undefined (NOT 9600) so the build/upload/monitor flow's
+    // `options.baud ?? config.console.baudRate` falls through to the configured
+    // baud. Hardcoding 9600 here shadowed config.console.baudRate whenever --baud
+    // was absent (the monitor then opened the port at 9600, ignoring the config).
+    const baud = readNumberFlag(argv, ["--baud"]);
     const frameworkFlag = readFirstFlagValue(argv, ["--framework"]);
     const compile = readBooleanFlag(argv, ["--compile"]);
     const upload = readBooleanFlag(argv, ["--upload"]);
@@ -231,6 +251,32 @@ function parsePipelineCommand(argv, command, inputFile) {
     const keepUnusedTypes = readBooleanFlag(argv, ["--keep-unused-types"]);
     const keepUnusedVariables = readBooleanFlag(argv, ["--keep-unused-variables"]);
     const entryPoints = readRepeatedFlag(argv, "--entry-point");
+    // AUTOSAR C++14 compliance mode for emitted code. Accepts both
+    // `--autosar=strict` (= syntax) and `--autosar strict` (space syntax),
+    // plus the bare `--autosar` (treated as "strict"). Defaults to undefined,
+    // which the emitter treats as "off".
+    let autosar;
+    const autosarFlagIdx = argv.findIndex((a) => a === "--autosar" || a.startsWith("--autosar="));
+    if (autosarFlagIdx !== -1) {
+        const raw = argv[autosarFlagIdx];
+        if (raw === "--autosar") {
+            // Bare flag → strict. (No following value consumed.)
+            autosar = "strict";
+        }
+        else {
+            // --autosar=<mode>
+            const value = raw.slice("--autosar=".length);
+            if (value === "strict" || value === "warn" || value === "off") {
+                autosar = value;
+            }
+            else {
+                throw new Error(`--autosar must be one of: strict, warn, off (got: ${value})`);
+            }
+        }
+    }
+    // --autosar-arxml: also write the .autosar-deviations.arxml sidecar
+    // (Artop/DaVinci tooling). No-op unless --autosar is warn or strict.
+    const autosarArxml = readBooleanFlag(argv, ["--autosar-arxml"]);
     const emitMode = emitFlag === "cpp" || emitFlag === "split" ? emitFlag : "split";
     const emitMaps = emitMapsFlag === undefined ? true : emitMapsFlag !== "false";
     // Accept any target string — the framework package registers its own strategy id.
@@ -281,6 +327,8 @@ function parsePipelineCommand(argv, command, inputFile) {
         expect,
         expectFile,
         frameworkPackage: frameworkFlag,
+        autosar,
+        autosarArxml,
     };
 }
 export function parseCommandLine(argv) {
@@ -339,7 +387,7 @@ export function parseCommandLine(argv) {
             port: port ? String(port) : undefined,
         };
     }
-    // doctor subcommand — verify arduino-cli + board core presence
+    // doctor subcommand — verify the active framework's environment
     if (firstArg === "doctor") {
         return {
             command: "doctor",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typecad/cuttlefish",
-  "version": "1.0.0-alpha.7",
+  "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"
@@ -84,19 +96,22 @@
   "dependencies": {
     "chalk": "^4.1.2",
     "typescript": "^5.7.3",
-    "zod": "^3.24.0",
-    "@typecad/arduino-cli": "1.0.0-alpha.7"
+    "zod": "^3.24.0"
   },
   "peerDependencies": {
-    "@typecad/ui": "1.0.0-alpha.7"
+    "@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.7"
+    "@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/libdef/idf-discovery.d.ts

@@ -1,7 +0,0 @@
-/**
- * Discover an ESP-IDF install root by checking $IDF_PATH first, then
- * well-known install locations. Returns the absolute path if found and
- * the `components/` subdir exists (the only thing gen-decls needs), or
- * undefined otherwise.
- */
-export declare function discoverIdfRootForGenDecls(): string | undefined;

package/dist/libdef/idf-discovery.js

@@ -1,59 +0,0 @@
-// Minimal IDF discovery for the gen-decls pre-transpile pass.
-//
-// We can't import framework-esp32's discovery from cuttlefish (it would
-// create a package dependency from core → framework). This module mirrors
-// the cheapest strategies from framework-esp32/src/toolchain/discover.ts:
-// $IDF_PATH env var, well-known install locations, and a version-dir scan
-// under <sysdrive>/esp/ (where the Espressif Windows installer puts
-// `v6.0.2/esp-idf`, etc.). It is good enough to find an IDF install on a
-// developer machine so the .d.ts cache can be populated before type-checking.
-//
-// For richer discovery (EIM manifest, PATH search) the framework-esp32
-// compile path performs its own discovery at compile time and regenerates
-// the cache — this minimal version is only for the pre-transpile pass.
-import { existsSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-const IS_WIN = process.platform === 'win32';
-function wellKnownPaths() {
-    const paths = [];
-    if (IS_WIN) {
-        const sysDrive = process.env.SystemDrive ?? 'C:';
-        paths.push(join(`${sysDrive}\\esp`, 'esp-idf'), join(`${sysDrive}\\Espressif`, 'esp-idf'));
-        // Versioned subdir scan: <sysdrive>/esp/v*/esp-idf (Windows installer layout).
-        const espRoot = `${sysDrive}\\esp`;
-        if (existsSync(espRoot)) {
-            try {
-                for (const entry of readdirSync(espRoot)) {
-                    if (/^v/i.test(entry)) {
-                        paths.push(join(espRoot, entry, 'esp-idf'));
-                    }
-                }
-            }
-            catch {
-                // readdir failed; skip.
-            }
-        }
-    }
-    else {
-        const home = process.env.HOME ?? process.env.USERPROFILE ?? '';
-        paths.push(join(home, 'esp', 'esp-idf'), join(home, '.espressif', 'esp-idf'), '/opt/esp/esp-idf');
-    }
-    return paths;
-}
-/**
- * Discover an ESP-IDF install root by checking $IDF_PATH first, then
- * well-known install locations. Returns the absolute path if found and
- * the `components/` subdir exists (the only thing gen-decls needs), or
- * undefined otherwise.
- */
-export function discoverIdfRootForGenDecls() {
-    const candidates = [
-        process.env.IDF_PATH,
-        ...wellKnownPaths(),
-    ].filter((p) => typeof p === 'string' && p.length > 0);
-    for (const p of candidates) {
-        if (existsSync(join(p, 'components')))
-            return p;
-    }
-    return undefined;
-}