@typecad/cuttlefish 0.1.0-alpha.2 → 1.0.0-alpha.10

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/ir/heap-array-validation.d.ts

@@ -1,24 +0,0 @@
-import type { Diagnostic } from '../types.js';
-import type { BoardConstants } from './board-resolver.js';
-import type { StatementIR } from '../api/index.js';
-import type { PlatformStrategy } from '../api/shared/index.js';
-/**
- * @deprecated Heap allocation is now validated at emit time by the platform
- * strategy's `profileDiagnostics` (see framework-arduino `collectHeapAllocationDiagnostics`).
- * This build-time stub returns no diagnostics. Kept to preserve the
- * `validation-orchestrator.ts` import; remove that call site when convenient.
- */
-export declare function validateHeapArrayUsage(_program: {
-    topLevelStatements: StatementIR[];
-    functions: Array<{
-        statements: StatementIR[];
-    }>;
-    classes: Array<{
-        methods: Array<{
-            statements: StatementIR[];
-        }>;
-        constructor?: {
-            statements: StatementIR[];
-        };
-    }>;
-}, _boardConstants: BoardConstants | undefined, _strategy?: PlatformStrategy): Diagnostic[];

package/dist/ir/heap-array-validation.js

@@ -1,29 +0,0 @@
-// ---------------------------------------------------------------------------
-// Heap Allocation Validator (retired — moved to the emit-time profile gate)
-//
-// Heap allocation via `new` on no-heap architectures (AVR, etc.) is now
-// rejected by the Arduino strategy's `profileDiagnostics`
-// (`framework-arduino/src/strategy.ts` `collectHeapAllocationDiagnostics`).
-//
-// WHY THE MOVE: this build-time validator keyed off `boardConstants.architecture`,
-// which is only populated when an MCU/board `import` is present. Programs with
-// no such import silently bypassed it — so demo #33's `new Accumulator()`
-// passed while a HAL-importing demo's `new Blinker()` failed, for the same
-// source pattern. The profile-time gate derives `arch` from the FQBN
-// (`frameworkData.buildTarget`), so it fires regardless of import structure
-// (demo #34 Finding A). It also keys off the `newClassName` marker a user-class
-// `new` tags its raw IR node with (set in `expression-to-ir.ts`), making
-// detection structural rather than textual.
-//
-// The export is kept (returns `[]`) so `validation-orchestrator.ts`'s import
-// stays valid; the real work happens at emit time.
-// ---------------------------------------------------------------------------
-/**
- * @deprecated Heap allocation is now validated at emit time by the platform
- * strategy's `profileDiagnostics` (see framework-arduino `collectHeapAllocationDiagnostics`).
- * This build-time stub returns no diagnostics. Kept to preserve the
- * `validation-orchestrator.ts` import; remove that call site when convenient.
- */
-export function validateHeapArrayUsage(_program, _boardConstants, _strategy) {
-    return [];
-}