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

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

@@ -25,43 +25,13 @@ const RESISTIVE_TOUCH_LIBS = new Set([
     "XPT2046_Touchscreen",
     "Adafruit_TouchScreen",
 ]);
-/** Default RGB565 scroll viewport canvas budget (~88 KB, ESP32-class SRAM). */
-export 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 const PSRAM_SCROLL_CANVAS_BUDGET_BYTES = 2_000_000;
-/** 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 function buildTargetHasPsram(buildTarget) {
-    if (!buildTarget)
-        return false;
-    const opts = buildTarget.split(":");
-    for (const opt of opts) {
-        const eq = opt.indexOf("=");
-        if (eq < 0)
-            continue;
-        const key = opt.slice(0, eq).trim().toLowerCase();
-        const val = opt.slice(eq + 1).trim().toLowerCase();
-        if (key !== "psram")
-            continue;
-        // Any explicit PSRAM option except an explicit disabled value means PSRAM.
-        return !["disabled", "false", "none", "no", "0"].includes(val);
-    }
-    return false;
-}
 /**
  * Resolve scroll config from a display profile. Declared overrides win;
  * otherwise derive the input tier from the touch library (resistive chips →
  * "resistive", any other touch → "capacitive", no touch → "none") and assume a
  * full render tier (ESP32-class SRAM can fit a viewport canvas).
  */
-export function resolveScrollConfig(display, ctx) {
+export function resolveScrollConfig(display) {
     const s = display.scroll ?? {};
     const lib = display.touch && typeof display.touch === "object"
         ? display.touch.library
@@ -71,14 +41,6 @@ export function resolveScrollConfig(display, ctx) {
         : display.touch
             ? "capacitive"
             : "none";
-    // PSRAM-aware canvas budget: an explicit override always wins; otherwise use
-    // the PSRAM budget when the build target opts into PSRAM (so the scroll-canvas-
-    // memory diagnostic doesn't emit stale warnings for canvases the runtime
-    // allocates in external RAM without issue), else the no-PSRAM SRAM default.
-    const psramBudget = buildTargetHasPsram(ctx?.buildTarget);
-    const budgetDefault = psramBudget
-        ? PSRAM_SCROLL_CANVAS_BUDGET_BYTES
-        : DEFAULT_SCROLL_CANVAS_BUDGET_BYTES;
     return {
         inputTier: s.inputTier ?? derivedInput,
         renderTier: s.renderTier ?? "full",
@@ -89,7 +51,6 @@ export function resolveScrollConfig(display, ctx) {
         inputSmoothing: s.inputSmoothing ?? 0.3,
         overrideProbes: s.overrideProbes ?? true,
         debug: s.debug ?? false,
-        scrollCanvasBudgetBytes: s.scrollCanvasBudgetBytes ?? budgetDefault,
     };
 }
 export function resolveDisplayProfile(config, registry) {
@@ -151,6 +112,8 @@ export function resolveDisplayProfile(config, registry) {
         base.colorOrder = config.colorOrder;
     if (config.invertDisplay !== undefined)
         base.invertDisplay = config.invertDisplay;
+    if (config.scanlineSync !== undefined)
+        base.scanlineSync = config.scanlineSync;
     if (config.touch === false)
         base.touch = undefined;
     else if (config.touch !== undefined)
@@ -176,125 +139,26 @@ export function resolveDisplayProfile(config, registry) {
         reset: config.reset ?? -1,
     };
 }
-/** Generate C++ code for a built-in touch library adapter. */
-export function generateTouchAdapter(touch) {
-    const cs = touch.cs ?? 0;
-    const irq = touch.irq;
-    if (touch.library === "XPT2046_Touchscreen") {
-        return {
-            includes: ["#include <XPT2046_Touchscreen.h>"],
-            declaration: `XPT2046_Touchscreen __tc_touch(${cs}${irq ? `, ${irq}` : ""});`,
-            functions: [
-                `static inline void touch_init() { __tc_touch.begin(); }`,
-                `static inline bool touch_isTouched() { return __tc_touch.touched(); }`,
-                `static inline void touch_readRaw(int16_t* x, int16_t* y, int16_t* z) {`,
-                `  TS_Point __tp = __tc_touch.getPoint();`,
-                `  if (x) *x = (int16_t)__tp.x;`,
-                `  if (y) *y = (int16_t)__tp.y;`,
-                `  if (z) *z = (int16_t)__tp.z;`,
-                `}`,
-            ].join("\n"),
-        };
-    }
-    if (touch.library === "Adafruit_TouchScreen" && touch.analogPins) {
-        const a = touch.analogPins;
-        return {
-            includes: ["#include <TouchScreen.h>"],
-            declaration: `TouchScreen __tc_touch = TouchScreen(${a.xp}, ${a.yp}, ${a.xm}, ${a.ym}, ${a.rx});`,
-            functions: [
-                `static inline void touch_init() {}`,
-                `static inline bool touch_isTouched() { return __tc_touch.isTouching(); }`,
-                `static inline void touch_readRaw(int16_t* x, int16_t* y, int16_t* z) {`,
-                `  TS_Point __tp = __tc_touch.getPoint();`,
-                `  if (x) *x = (int16_t)__tp.x;`,
-                `  if (y) *y = (int16_t)__tp.y;`,
-                `  if (z) *z = (int16_t)__tp.z;`,
-                `}`,
-            ].join("\n"),
-        };
-    }
-    if (touch.library === "Adafruit_STMPE610") {
-        return {
-            includes: ["#include <Adafruit_STMPE610.h>"],
-            declaration: `Adafruit_STMPE610 __tc_touch(${cs});`,
-            functions: [
-                `static inline void touch_init() { __tc_touch.begin(); }`,
-                `static inline bool touch_isTouched() { return __tc_touch.touched() && !__tc_touch.bufferEmpty(); }`,
-                `static inline void touch_readRaw(int16_t* x, int16_t* y, int16_t* z) {`,
-                `  TS_Point __tp = __tc_touch.getPoint();`,
-                `  if (x) *x = (int16_t)__tp.x;`,
-                `  if (y) *y = (int16_t)__tp.y;`,
-                `  if (z) *z = (int16_t)__tp.z;`,
-                `}`,
-            ].join("\n"),
-        };
-    }
-    if (touch.library === "FT6336U") {
-        const addr = touch.i2cAddress ?? 0x38;
-        // I2C addresses are conventional in hex in Arduino code.
-        const addrHex = "0x" + addr.toString(16).toUpperCase();
-        const i2cFrequency = touch.i2cFrequency ?? 400000;
-        const reset = touch.resetPin;
-        const resetLines = reset
-            ? [
-                `  pinMode(${reset}, OUTPUT);`,
-                `  digitalWrite(${reset}, LOW);`,
-                `  delay(10);`,
-                `  digitalWrite(${reset}, HIGH);`,
-                `  delay(500);`,
-            ].join("\n")
-            : ``;
-        return {
-            includes: ["#include <Wire.h>", "#include <RAK14014_FT6336U.h>"],
-            declaration: [
-                `FT6336U __tc_touch(${addrHex});`,
-                `static int16_t __tc_touch_cached_x = 0;`,
-                `static int16_t __tc_touch_cached_y = 0;`,
-                `static int16_t __tc_touch_cached_z = 0;`,
-                `static uint8_t __tc_touch_cached_valid = 0;`,
-            ].join("\n"),
-            functions: [
-                `static inline uint8_t __tc_ft6336u_read_block(uint8_t reg, uint8_t* buf, uint8_t len) {`,
-                `  Wire.beginTransmission(${addrHex});`,
-                `  Wire.write(reg);`,
-                `  if (Wire.endTransmission(false) != 0) return 0;`,
-                `  uint8_t got = Wire.requestFrom((uint8_t)${addrHex}, len);`,
-                `  if (got < len) return 0;`,
-                `  for (uint8_t i = 0; i < len; i++) {`,
-                `    if (!Wire.available()) return 0;`,
-                `    buf[i] = Wire.read();`,
-                `  }`,
-                `  return 1;`,
-                `}`,
-                `static inline void touch_init() {`,
-                resetLines,
-                `  __tc_touch.begin(Wire, ${addrHex});`,
-                `  Wire.setClock(${i2cFrequency});`,
-                `}`,
-                `static inline bool touch_isTouched() {`,
-                `  uint8_t buf[5] = {0, 0, 0, 0, 0};`,
-                `  __tc_touch_cached_valid = 0;`,
-                `  __tc_touch_cached_z = 0;`,
-                `  if (!__tc_ft6336u_read_block(0x02, buf, 5)) return false;`,
-                `  uint8_t count = buf[0] & 0x0F;`,
-                `  if (count == 0) return false;`,
-                `  __tc_touch_cached_x = (int16_t)(((uint16_t)(buf[1] & 0x0F) << 8) | buf[2]);`,
-                `  __tc_touch_cached_y = (int16_t)(((uint16_t)(buf[3] & 0x0F) << 8) | buf[4]);`,
-                `  __tc_touch_cached_z = 255;`,
-                `  __tc_touch_cached_valid = 1;`,
-                `  return true;`,
-                `}`,
-                `static inline void touch_readRaw(int16_t* x, int16_t* y, int16_t* z) {`,
-                `  if (!__tc_touch_cached_valid) {`,
-                `    (void)touch_isTouched();`,
-                `  }`,
-                `  if (x) *x = __tc_touch_cached_x;`,
-                `  if (y) *y = __tc_touch_cached_y;`,
-                `  if (z) *z = __tc_touch_cached_z;`,
-                `  __tc_touch_cached_valid = 0;`,
-                `}`,
-            ].join("\n"),
-        };
+/** 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 function generateTouchAdapter(touch, strategy) {
+    if (strategy?.providesTouchAdapter?.() && strategy.resolveTouchAdapter) {
+        const code = strategy.resolveTouchAdapter(touch);
+        if (code)
+            return code;
     }
     if (touch.library === "sdl") {
         return {
@@ -325,14 +189,17 @@ export function generateTouchAdapter(touch) {
                 `  int __ww = 0, __wh = 0; SDL_GetWindowSize(__tc_display.win, &__ww, &__wh);`,
                 `  if (__ww <= 0) __ww = display_width();`,
                 `  if (__wh <= 0) __wh = display_height();`,
-                `  if (x) *x = (int16_t)((int32_t)__sdl_mouse_x * display_width() / __ww);`,
-                `  if (y) *y = (int16_t)((int32_t)__sdl_mouse_y * display_height() / __wh);`,
+                `  if (x) *x = static_cast<int16_t>(static_cast<int32_t>(__sdl_mouse_x) * display_width() / __ww);`,
+                `  if (y) *y = static_cast<int16_t>(static_cast<int32_t>(__sdl_mouse_y) * display_height() / __wh);`,
                 `  if (z) *z = 200;   // constant > default minPressure (10)`,
                 `}`,
             ].join("\n"),
         };
     }
-    throw new Error(`Unknown touch library "${touch.library}". ` +
-        `Use { adapter: './path' } for custom touch adapters, or one of: ` +
-        `XPT2046_Touchscreen, Adafruit_TouchScreen, Adafruit_STMPE610, FT6336U, sdl.`);
+    throw new Error(`No touch adapter for library "${touch.library}". ` +
+        `The built-in Arduino touch libraries (XPT2046_Touchscreen, Adafruit_TouchScreen, ` +
+        `Adafruit_STMPE610, FT6336U) are provided by @typecad/framework-arduino — pass the ` +
+        `ArduinoStrategy (or another framework strategy that provides touch adapters) so its ` +
+        `resolveTouchAdapter can dispatch to them. Otherwise use the framework-agnostic ` +
+        `"sdl" library, or { adapter: './path' } for a custom touch adapter.`);
 }

package/dist/api/shared/framework-manifest-registry.d.ts

@@ -0,0 +1,9 @@
+import type { FrameworkManifest } from './framework-manifest.js';
+export declare const KNOWN_FRAMEWORK_PACKAGES: readonly ["@typecad/framework-arduino", "@typecad/framework-zephyr"];
+export type KnownFrameworkPackage = typeof KNOWN_FRAMEWORK_PACKAGES[number];
+/**
+ * Loads a framework's manifest via its `./framework.manifest` subpath export.
+ * Throws if the package does not export that subpath or the export has no
+ * default value.
+ */
+export declare function loadFrameworkManifest(packageName: string): Promise<FrameworkManifest>;

package/dist/api/shared/framework-manifest-registry.js

@@ -0,0 +1,27 @@
+// ---------------------------------------------------------------------------
+// Framework manifest discovery
+//
+// KNOWN_FRAMEWORK_PACKAGES is the authoritative list of framework packages
+// that ship a framework.manifest (i.e. participate in the manifest validation
+// system). It names real packages by their npm scope+name so the manifest
+// validator and coverage tooling can iterate them — it is not framework-
+// specific knowledge. Add a new framework here when it ships a manifest.
+// loadFrameworkManifest uses the "./framework.manifest" subpath export each
+// framework declares in its package.json.
+// ---------------------------------------------------------------------------
+export const KNOWN_FRAMEWORK_PACKAGES = [
+    '@typecad/framework-arduino',
+    '@typecad/framework-zephyr',
+];
+/**
+ * Loads a framework's manifest via its `./framework.manifest` subpath export.
+ * Throws if the package does not export that subpath or the export has no
+ * default value.
+ */
+export async function loadFrameworkManifest(packageName) {
+    const mod = await import(/* @vite-ignore */ `${packageName}/framework.manifest`);
+    if (!mod.default) {
+        throw new Error(`Package ${packageName} does not export a default manifest from "./framework.manifest".`);
+    }
+    return mod.default;
+}