@typecad/framework-zephyr 1.0.0-alpha.10 → 1.0.0-alpha.11

package/dist/chips/esp32.js

@@ -56,4 +56,16 @@ export const ESP32_DEVKITC = {
     // the ESP32 is AMP (dual-image procpu/appcpu), not SMP, by default — so the
     // dependency is satisfied. Omitted on radioless targets.
     wifi: { supported: true },
+    // DAC: the ESP32 has two 8-bit DAC channels on GPIO25 (channel 1) and GPIO26
+    // (channel 2). The Zephyr esp32 DAC driver (drivers/dac/dac_esp32.c) exposes
+    // them via the `dac0` node; the lowering emits dac_channel_setup +
+    // dac_write_value against DEVICE_DT_GET(DT_NODELABEL(dac0)). The overlay
+    // enables the node when the program uses dac.*. ESP32-S3 has no DAC.
+    dac: {
+        device: 'dac0',
+        channels: [
+            { pin: 25, channel: 1, resolution: 8 },
+            { pin: 26, channel: 2, resolution: 8 },
+        ],
+    },
 };

package/dist/chips/types.d.ts

@@ -81,6 +81,18 @@ export interface ZephyrAdcChannel {
     /** SAADC channel index (AIN0–AIN7). */
     readonly channel: number;
 }
+/**
+ * A DAC channel: which DAC output a given HAL pin maps to. The lowering emits
+ * `dac_channel_setup` + `dac_write_value` against the DAC device node.
+ */
+export interface ZephyrDacChannel {
+    /** GPIO number (matches the HAL op `pin` field). */
+    readonly pin: number;
+    /** DAC channel index (ESP32: GPIO25 → 1, GPIO26 → 2). */
+    readonly channel: number;
+    /** DAC resolution in bits (ESP32 DAC is 8-bit). */
+    readonly resolution: number;
+}
 /**
  * Pure-data descriptor for a Zephyr board + its SoC's peripheral layout.
  */
@@ -139,10 +151,28 @@ export interface ZephyrChipDescriptor {
         /** ADC resolution in bits. */
         readonly resolution: number;
     };
+    /**
+     * DAC: the DAC device node label + the pin→channel map. Present only on chips
+     * with a DAC (ESP32 has 2 channels on GPIO25/26; ESP32-S3 and nRF52840 have
+     * none). Read by profileDiagnostics to flag dac.* usage on chips without it.
+     */
+    readonly dac?: {
+        readonly device: string;
+        readonly channels: readonly ZephyrDacChannel[];
+    };
     /** Watchdog node label, e.g. 'wdt0'. */
     readonly wdt?: {
         readonly nodeLabel: string;
     };
+    /**
+     * Hardware timers exposed as Zephyr counter devices. `instance` (the HAL
+     * hwtimer.* op's instance index) maps to `controllers[instance].nodeLabel`.
+     * Omit on chips whose counter nodes are kernel-owned or unavailable; the
+     * lowering then lowers to a comment and profileDiagnostics flags usage.
+     */
+    readonly hwtimer?: {
+        readonly controllers: readonly ZephyrBusController[];
+    };
     /**
      * WiFi capability marker. Present only on chips with a WiFi radio (ESP32-S3).
      * Read by profileDiagnostics to flag wifi.* usage on chips without a radio.

package/dist/chips/xiao-ble.js

@@ -58,4 +58,10 @@ export const XIAO_BLE = {
         ],
     },
     wdt: { nodeLabel: 'wdt0' },
+    // Hardware timer: nRF RTC1 is the free counter (RTC0 is kernel-owned by the
+    // softdevice/clock driver). The hwtimer lowering drives it as a Zephyr
+    // counter device (counter_start/stop + a top-value alarm for set_frequency).
+    // Verified against the nRF52840 SoC dtsi (rtc0/rtc1 nodes). The kernel uses
+    // RTC0 for the system tick; RTC1 is available for application use.
+    hwtimer: { controllers: [{ nodeLabel: 'rtc1' }] },
 };

package/dist/display/gfx.d.ts

@@ -10,8 +10,17 @@ export interface DisplayRuntimeResult {
     readonly fontTable: string;
 }
 /**
- * Build the display runtime C++ for a profile. The line buffer is one row
- * (width pixels × 2 bytes rgb565); fill_rect/draw_rect/draw_text compute into
- * it row-by-row and display_write each row. No full framebuffer.
+ * Build the display runtime C++ for a profile.
+ *
+ * Two rendering models, selected by `profile.colorFormat`:
+ *  - `'rgb565'` (TFT): a one-row line buffer (no full framebuffer — see
+ *    AGENTS.md rendering guardrails); fill_rect/draw_rect/draw_text stream
+ *    each row via display_write.
+ *  - `'mono'` (OLED, e.g. SSD1306): a full framebuffer — the standard model
+ *    for page-buffered monochrome panels (the AGENTS.md "no full framebuffer"
+ *    guardrail targets RGB SPI TFTs, not mono OLEDs). draw ops set bits;
+ *    display_flush pushes the whole framebuffer. The MONO01 packing is
+ *    horizontal, MSB-first (Zephyr convention): byte = (y*rowBytes)+(x>>3),
+ *    bit = 0x80>>(x&7).
  */
 export declare function buildDisplayRuntime(profile: ZephyrDisplayProfile): DisplayRuntimeResult;

package/dist/display/gfx.js

@@ -71,18 +71,23 @@ function fontTableCpp() {
     return lines.join('\n');
 }
 /**
- * Build the display runtime C++ for a profile. The line buffer is one row
- * (width pixels × 2 bytes rgb565); fill_rect/draw_rect/draw_text compute into
- * it row-by-row and display_write each row. No full framebuffer.
+ * Build the display runtime C++ for a profile.
+ *
+ * Two rendering models, selected by `profile.colorFormat`:
+ *  - `'rgb565'` (TFT): a one-row line buffer (no full framebuffer — see
+ *    AGENTS.md rendering guardrails); fill_rect/draw_rect/draw_text stream
+ *    each row via display_write.
+ *  - `'mono'` (OLED, e.g. SSD1306): a full framebuffer — the standard model
+ *    for page-buffered monochrome panels (the AGENTS.md "no full framebuffer"
+ *    guardrail targets RGB SPI TFTs, not mono OLEDs). draw ops set bits;
+ *    display_flush pushes the whole framebuffer. The MONO01 packing is
+ *    horizontal, MSB-first (Zephyr convention): byte = (y*rowBytes)+(x>>3),
+ *    bit = 0x80>>(x&7).
  */
 export function buildDisplayRuntime(profile) {
     const w = profile.width;
-    const stateLines = [
-        '// CUTTLEFISH_DISPLAY_BEGIN',
-        `static const struct device* __tc_display = DEVICE_DT_GET(DT_NODELABEL(${profile.dtLabel}));`,
-        `static uint16_t __tc_display_line[${w}];  // one-row line buffer (rgb565)`,
-        '// CUTTLEFISH_DISPLAY_END',
-    ];
+    const h = profile.height;
+    const isMono = profile.colorFormat === 'mono';
     // Backlight is optional: the overlay emits the DT alias only when a backlight
     // GPIO is configured. Guard with DT_HAS_ALIAS so this compiles whether or not
     // the alias exists (DT_NODE_HAS_STATUS(DT_ALIAS(...)) is version-dependent
@@ -90,7 +95,122 @@ export function buildDisplayRuntime(profile) {
     const blInit = profile.backlight
         ? `#if DT_HAS_ALIAS(${profile.backlight})\n    const struct device* __bl = DEVICE_DT_GET(DT_ALIAS(${profile.backlight}));\n    gpio_pin_configure(__bl, 0, GPIO_OUTPUT); gpio_pin_set(__bl, 0, 1);\n#endif`
         : '';
-    const helpers = `
+    const stateLines = isMono
+        ? [
+            '// CUTTLEFISH_DISPLAY_BEGIN',
+            `static const struct device* __tc_display = DEVICE_DT_GET(DT_NODELABEL(${profile.dtLabel}));`,
+            `// Mono framebuffer (Zephyr MONO01: horizontal, MSB-first). ${(w + 7) >> 3} bytes/row x ${h} rows.`,
+            `static uint8_t __tc_display_fb[((${w} * ${h}) + 7) / 8];`,
+            '// CUTTLEFISH_DISPLAY_END',
+        ]
+        : [
+            '// CUTTLEFISH_DISPLAY_BEGIN',
+            `static const struct device* __tc_display = DEVICE_DT_GET(DT_NODELABEL(${profile.dtLabel}));`,
+            `static uint16_t __tc_display_line[${w}];  // one-row line buffer (rgb565)`,
+            '// CUTTLEFISH_DISPLAY_END',
+        ];
+    const helpers = isMono
+        ? monoHelpers(w, h, blInit)
+        : rgb565Helpers(w, blInit);
+    const fontTable = fontTableCpp();
+    return {
+        includes: ['<zephyr/drivers/display.h>'],
+        stateLines,
+        helpers,
+        fontTable,
+    };
+}
+/**
+ * Mono (OLED) helpers: a full framebuffer + bit-packing. SSD1306-class panels
+ * are page-buffered, so draw ops set bits in the framebuffer and display_flush
+ * pushes the whole buffer. color != 0 ⇒ lit.
+ */
+function monoHelpers(w, h, blInit) {
+    const rowBytes = (w + 7) >> 3; // bytes per row (w is byte-aligned for 128-wide panels)
+    return `
+// MONO01 pixel packing: byte = (y * ${rowBytes}) + (x >> 3), bit = 0x80 >> (x & 7).
+static inline void __tc_set_pixel(uint16_t x, uint16_t y, uint8_t on) {
+    if ((x >= ${w}U) || (y >= ${h}U)) { return; }
+    uint16_t idx = static_cast<uint16_t>((static_cast<uint32_t>(y) * ${rowBytes}U) + (x >> 3));
+    uint8_t mask = static_cast<uint8_t>(0x80U >> (x & 7U));
+    if (on != 0U) {
+        __tc_display_fb[idx] = static_cast<uint8_t>(__tc_display_fb[idx] | mask);
+    } else {
+        __tc_display_fb[idx] = static_cast<uint8_t>(__tc_display_fb[idx] & static_cast<uint8_t>(~mask));
+    }
+}
+
+static inline void display_init(void) {
+    if (!device_is_ready(__tc_display)) { for (;;) { k_msleep(1000); } }
+${blInit}
+    for (uint16_t i = 0; i < static_cast<uint16_t>(sizeof(__tc_display_fb)); i++) { __tc_display_fb[i] = 0U; }
+    display_blanking_off(__tc_display);
+}
+
+static inline void display_fill_rect(uint16_t x, uint16_t y, uint16_t rw, uint16_t rh, uint16_t color) {
+    uint8_t on = (color != 0U) ? 1U : 0U;
+    for (uint16_t row = 0; row < rh; row++) {
+        for (uint16_t i = 0; i < rw; i++) {
+            __tc_set_pixel(static_cast<uint16_t>(x + i), static_cast<uint16_t>(y + row), on);
+        }
+    }
+}
+
+static inline void display_draw_rect(uint16_t x, uint16_t y, uint16_t rw, uint16_t rh, uint16_t color) {
+    uint8_t on = (color != 0U) ? 1U : 0U;
+    for (uint16_t i = 0; i < rw; i++) {
+        __tc_set_pixel(static_cast<uint16_t>(x + i), y, on);
+        __tc_set_pixel(static_cast<uint16_t>(x + i), static_cast<uint16_t>(y + rh - 1U), on);
+    }
+    for (uint16_t row = 1U; row < rh - 1U; row++) {
+        __tc_set_pixel(x, static_cast<uint16_t>(y + row), on);
+        __tc_set_pixel(static_cast<uint16_t>(x + rw - 1U), static_cast<uint16_t>(y + row), on);
+    }
+}
+
+static inline void display_draw_text(uint16_t x, uint16_t y, const char* text, uint16_t color) {
+    uint8_t on = (color != 0U) ? 1U : 0U;
+    uint16_t cx = x;
+    for (const char* p = text; *p != 0; p++) {
+        uint8_t uc = static_cast<uint8_t>(*p);
+        if (uc >= 128U) { uc = static_cast<uint8_t>(' '); }
+        const uint8_t* glyph = &__tc_font5x7[uc][0];
+        if (uc >= static_cast<uint8_t>('a') && uc <= static_cast<uint8_t>('z')) {
+            glyph = &__tc_font5x7[uc - 32U][0];
+        } else if (uc < static_cast<uint8_t>('0')
+                   || (uc > static_cast<uint8_t>('9') && uc < static_cast<uint8_t>('A'))
+                   || uc > static_cast<uint8_t>('Z')) {
+            glyph = &__tc_font5x7[static_cast<uint8_t>(' ')][0];
+        }
+        for (uint16_t col = 0; col < 5U; col++) {
+            uint8_t bits = glyph[col];
+            for (uint16_t row = 0; row < 7U; row++) {
+                if ((bits & static_cast<uint8_t>(1U << row)) != 0U) {
+                    __tc_set_pixel(static_cast<uint16_t>(cx + col), static_cast<uint16_t>(y + row), on);
+                }
+            }
+        }
+        cx = static_cast<uint16_t>(cx + 6U);
+    }
+}
+
+static inline void display_flush(void) {
+    struct display_buffer_descriptor __desc;
+    __desc.buf_size = sizeof(__tc_display_fb);   // ${rowBytes} * ${h} bytes
+    __desc.width = ${w}U;
+    __desc.height = ${h}U;
+    __desc.pitch = ${rowBytes}U;                  // bytes per row
+    __desc.frame_incomplete = false;
+    (void)display_write(__tc_display, 0, 0, &__desc, __tc_display_fb);
+}
+`;
+}
+/**
+ * RGB565 (TFT) helpers: a one-row line buffer; each op streams rows via
+ * display_write. No full framebuffer (AGENTS.md rendering guardrails).
+ */
+function rgb565Helpers(w, blInit) {
+    return `
 // Write a single row of \`rw\` rgb565 pixels at (x,y). Builds the
 // display_buffer_descriptor the Zephyr display_write API requires (rgb565 =
 // 2 bytes/pixel) and pushes the one-row line buffer.
@@ -161,11 +281,4 @@ static inline void display_flush(void) {
     // No-op: writes are immediate via display_write; there is no framebuffer to push.
 }
 `;
-    const fontTable = fontTableCpp();
-    return {
-        includes: ['<zephyr/drivers/display.h>'],
-        stateLines,
-        helpers,
-        fontTable,
-    };
 }

package/dist/display/profiles.js

@@ -36,6 +36,19 @@ export const ZEPHYR_DISPLAY_PROFILES = {
         rotation: 1,
         backlight: 'backlight',
     },
+    'ssd1306-zephyr': {
+        // Monochrome OLED (SSD1306-class, 128x64, 1bpp). Driven through Zephyr's
+        // generic display API (the ssd1306 driver + a DT display node). The GFX
+        // runtime (gfx.ts mono branch) keeps a full page-framebuffer and pushes it
+        // on display_flush — the standard model for page-buffered OLEDs. Direct
+        // display.* ops only (no @typecad/ui CuttlefishGFX rendering on mono).
+        driver: 'ssd1306-zephyr',
+        dtLabel: 'display0',
+        width: 128,
+        height: 64,
+        colorFormat: 'mono',
+        rotation: 0,
+    },
 };
 /** The default profile used when resolveDisplayOp is probed without a display.init. */
 export const DEFAULT_ZEPHYR_DISPLAY_PROFILE = ZEPHYR_DISPLAY_PROFILES['ili9341-zephyr'];

package/dist/display/ui-adapter.js

@@ -527,6 +527,12 @@ export const zephyrDisplayAdapterGenerator = (display) => {
     const profile = ZEPHYR_DISPLAY_PROFILES[display.driver];
     if (!profile)
         return undefined;
+    // The UI adapter is RGB565/SPI (TFT) only. Monochrome panels (OLED) use the
+    // direct display.* GFX runtime (gfx.ts mono branch) — there is no
+    // CuttlefishGFX UI rendering path for mono. Decline so cuttlefish does not
+    // emit an incompatible RGB565 adapter for a mono profile.
+    if (profile.colorFormat === 'mono')
+        return undefined;
     return zephyrUiDisplayAdapter(profile, {
         scanlineSync: display.scanlineSync,
         miso: display.spiPins?.miso,

package/dist/doctor.d.ts

@@ -1,6 +1,6 @@
 /**
- * Verify the installed Zephyr is reachable + inside the supported range, and
- * preview board-target normalization for the configured target. Sets
- * process.exitCode = 1 on an out-of-range Zephyr.
+ * Verify west is installed + responsive, the Zephyr RTOS is inside the supported
+ * range, and the configured board target exists in the checkout. Sets
+ * process.exitCode = 1 on failure. Thin presenter over checkZephyrEnv.
  */
 export declare function runDoctor(): void;

package/dist/doctor.js

@@ -1,48 +1,75 @@
 // ---------------------------------------------------------------------------
 // @typecad/framework-zephyr — Zephyr environment doctor
 //
-// `cuttlefish doctor` (Zephyr framework) — verify the installed Zephyr RTOS is
-// reachable and inside the framework's declared compat range, and preview how
-// the configured board target resolves for that version. Exits 0 if the
-// environment is OK, non-zero otherwise. Mirrors framework-arduino's doctor
-// shape (dispatched via the framework's `doctor` export).
+// `cuttlefish doctor` (Zephyr framework) — verify west (the Zephyr build tool)
+// is installed + responsive, the Zephyr RTOS is inside the framework's declared
+// compat range, and the configured board target exists in the checkout. Exits 0
+// if the environment is OK, non-zero otherwise. Mirrors framework-arduino's
+// doctor shape (dispatched via the framework's `doctor` export) and reuses
+// checkZephyrEnv so the detection logic can be shared with the build/test gates.
 // ---------------------------------------------------------------------------
 import * as ui from '@typecad/cuttlefish/utils/ui';
 import { loadCuttlefishConfig } from '@typecad/cuttlefish/config-loader';
-import { detectZephyrVersion, checkZephyrCompat, resolveBoardTarget } from './toolchain/compat.js';
+import { checkZephyrEnv } from './toolchain/env-check.js';
 /**
- * Verify the installed Zephyr is reachable + inside the supported range, and
- * preview board-target normalization for the configured target. Sets
- * process.exitCode = 1 on an out-of-range Zephyr.
+ * Verify west is installed + responsive, the Zephyr RTOS is inside the supported
+ * range, and the configured board target exists in the checkout. Sets
+ * process.exitCode = 1 on failure. Thin presenter over checkZephyrEnv.
  */
 export function runDoctor() {
     ui.printHeader();
     ui.printStep('Checking Zephyr environment...');
-    const base = process.env.ZEPHYR_BASE;
-    const version = detectZephyrVersion();
-    const result = checkZephyrCompat(version);
-    ui.printInfo(`ZEPHYR_BASE ..... ${base ?? '(not set)'}`);
-    ui.printInfo(`Zephyr version .. ${version ?? 'unknown (could not read ZEPHYR_BASE/VERSION)'}`);
-    ui.printInfo(`Supported range . ${result.range ?? '(none declared)'}`);
-    if (result.status === 'out-of-range') {
-        ui.printError(`Zephyr ${version} is OUTSIDE the supported range (${result.range}).`);
-        ui.printInfo("Set ZEPHYR_BASE to a compatible Zephyr checkout, or install one via '@typecad/zephyr-installer'.");
-        process.exitCode = 1;
-        return;
-    }
-    if (result.status === 'undetectable') {
+    const config = loadCuttlefishConfig(process.cwd());
+    const buildTarget = config?.buildTarget;
+    const result = checkZephyrEnv(buildTarget);
+    const c = result.check;
+    // west (the Zephyr build tool) — the analog of arduino-cli presence.
+    if (c.westFound) {
+        const ver = c.westVersion ?? 'found';
+        const src = c.westSource ? `  (${c.westSource})` : '';
+        ui.printInfo(`west ............. ${ver}  ✓${src}`);
+    }
+    else {
+        ui.printError('west ............. NOT FOUND');
+    }
+    // Zephyr RTOS version + declared compat range.
+    ui.printInfo(`ZEPHYR_BASE ...... ${c.zephyrBase ?? '(not set)'}`);
+    ui.printInfo(`Zephyr version .. ${c.zephyrVersion ?? 'unknown (could not read ZEPHYR_BASE/VERSION)'}`);
+    ui.printInfo(`Supported range . ${c.compatRange ?? '(none declared)'}`);
+    if (c.compatStatus === 'out-of-range') {
+        ui.printError(`Zephyr ${c.zephyrVersion} is OUTSIDE the supported range (${c.compatRange}).`);
+    }
+    else if (c.compatStatus === 'undetectable') {
         ui.printWarning('Could not detect the Zephyr version (is ZEPHYR_BASE set?) — compat check skipped.');
     }
     else {
         ui.printInfo('Zephyr compat ... OK');
     }
-    // Preview how the configured board target resolves for this Zephyr version
-    // (e.g. a stale bare id would be qualified at build time). The loader extracts
-    // frameworkData.buildTarget to a top-level field.
-    const config = loadCuttlefishConfig(process.cwd());
-    const buildTarget = config?.buildTarget;
+    // Board target — the analog of the Arduino core presence check.
     if (buildTarget) {
-        const resolved = resolveBoardTarget(buildTarget, version);
-        ui.printInfo(`Board target .... ${buildTarget}${resolved === buildTarget ? '' : ` → ${resolved}`}`);
+        const resolved = c.resolvedBoardTarget ?? buildTarget;
+        const arrow = resolved === buildTarget ? '' : ` → ${resolved}`;
+        if (c.boardTargetSupported === false) {
+            ui.printError(`Board target .... ${buildTarget}${arrow}  NOT found in this Zephyr checkout`);
+            ui.printInfo('  → check the board id, or run: west boards');
+        }
+        else if (c.boardTargetSupported === undefined) {
+            ui.printInfo(`Board target .... ${buildTarget}${arrow}`);
+            ui.printInfo('(could not verify board presence — no ZEPHYR_BASE boards/ tree found)');
+        }
+        else {
+            ui.printInfo(`Board target .... ${buildTarget}${arrow}`);
+        }
+    }
+    else {
+        ui.printInfo('(no buildTarget in cuttlefish.config.ts — skipping board check)');
+    }
+    // Exit code — mirrors framework-arduino's doctor.
+    if (result.ok) {
+        ui.printSuccess('Environment OK');
+        return; // exitCode stays unset => 0
     }
+    for (const line of result.messages)
+        ui.printInfo(line);
+    process.exitCode = 1;
 }

package/dist/dt-config/kconfig.d.ts

@@ -1,6 +1,9 @@
 export interface KconfigUsage {
     usesAdc?: boolean;
     usesPwm?: boolean;
+    usesDac?: boolean;
+    usesFS?: boolean;
+    usesHwtimer?: boolean;
     usesI2c?: boolean;
     usesSpi?: boolean;
     usesUart?: boolean;

package/dist/dt-config/kconfig.js

@@ -23,12 +23,17 @@ export function resolveKconfigFragments(usage, debug) {
         m.set('CONFIG_ADC', 'y');
     if (usage.usesPwm)
         m.set('CONFIG_PWM', 'y');
+    if (usage.usesDac)
+        m.set('CONFIG_DAC', 'y');
     if (usage.usesI2c)
         m.set('CONFIG_I2C', 'y');
     if (usage.usesSpi)
         m.set('CONFIG_SPI', 'y');
     if (usage.usesWdt)
         m.set('CONFIG_WATCHDOG', 'y');
+    // Hardware timers via the counter driver.
+    if (usage.usesHwtimer)
+        m.set('CONFIG_COUNTER', 'y');
     if (usage.usesDisplay) {
         m.set('CONFIG_DISPLAY', 'y');
         m.set('CONFIG_SPI', 'y');
@@ -237,6 +242,19 @@ export function resolveKconfigFragments(usage, debug) {
         m.set('CONFIG_SETTINGS', 'y');
         m.set('CONFIG_SETTINGS_ZMS', 'y');
     }
+    // Filesystem: littlefs on the storage partition. CONFIG_FILE_SYSTEM_LITTLEFS
+    // selects the littlefs backend but NOT FLASH/FLASH_MAP (the partition lookup
+    // needs them), so all three are set explicitly — same shape as the
+    // preferences/ZMS block. The overlay points the storage_partition at the FS
+    // (see dt-config/overlay.ts). NOTE: a program using BOTH fs.* and
+    // preferences.* shares the one storage_partition between littlefs and ZMS —
+    // dedicate separate partitions if both are needed (the manifest flags this).
+    if (usage.usesFS) {
+        m.set('CONFIG_FLASH', 'y');
+        m.set('CONFIG_FLASH_MAP', 'y');
+        m.set('CONFIG_FILE_SYSTEM', 'y');
+        m.set('CONFIG_FILE_SYSTEM_LITTLEFS', 'y');
+    }
     // usesUart: the board enables the console UART by default; the overlay (not
     // Kconfig) is where a UART node would be enabled, so no symbol here.
     // Random: <zephyr/random/random.h> sys_rand_get is backed by the random

package/dist/dt-config/overlay.js

@@ -41,6 +41,11 @@ export function generateOverlay(chip, usage, display, wiring, touch) {
         for (const c of chip.uart.controllers)
             block(c.nodeLabel);
     }
+    // DAC: enable the chip's DAC device node when the program uses dac.*. The
+    // lowering references DEVICE_DT_GET(DT_NODELABEL(<dac.device>)).
+    if (usage.usesDac && chip.dac) {
+        block(chip.dac.device);
+    }
     if (display) {
         // Emit a full display DT node definition. Boards like the ESP32 devkit
         // have no display node in their base DT, so a bare `&display0 { status }`

package/dist/framework.manifest.js

@@ -104,9 +104,13 @@ export default defineFrameworkManifest({
             },
         },
         dac: {
-            supported: false,
-            unsupportedReason: 'No DAC lowering implemented in the framework (not applicable on nRF52840; ESP32 variants with DAC not yet wired).',
-            ops: { 'dac.write': 'unsupported' },
+            // ESP32 DAC (2× 8-bit channels on GPIO25/26) via the Zephyr DAC driver
+            // (dac_channel_setup + dac_write_value). nRF52840 / ESP32-S3 have no DAC;
+            // usage there lowers to a comment and profileDiagnostics flags it
+            // (zephyr-dac-pin-unavailable).
+            supported: true,
+            partialCoverage: true,
+            ops: { 'dac.write': 'supported' },
         },
         interrupts: {
             supported: true,
@@ -278,7 +282,7 @@ export default defineFrameworkManifest({
             supported: true,
             partialCoverage: false,
             unsupportedReason: undefined,
-            drivers: ['ili9341-zephyr', 'st7796-zephyr'],
+            drivers: ['ili9341-zephyr', 'st7796-zephyr', 'ssd1306-zephyr'],
             colorFormat: 'rgb565',
             ops: {
                 'display.init': 'supported',
@@ -356,10 +360,17 @@ export default defineFrameworkManifest({
             },
         },
         fs: {
-            supported: false,
-            unsupportedReason: 'No filesystem lowering on Zephyr (Zephyr has its own FS API; not wired).',
+            // littlefs on the board's storage_partition, via <zephyr/fs/fs.h>. The
+            // shim mounts at /lfs lazily (formats on first use) and the HAL paths are
+            // treated as paths within the filesystem. Requires CONFIG_FILE_SYSTEM +
+            // CONFIG_FILE_SYSTEM_LITTLEFS (emitted by the scaffold when fs.* is used)
+            // and the storage_partition node.
+            supported: true,
             partialCoverage: false,
-            ops: unsupportedOps('fs.'),
+            ops: {
+                'fs.begin': 'supported', 'fs.read_text': 'supported', 'fs.write_text': 'supported',
+                'fs.exists': 'supported', 'fs.remove': 'supported',
+            },
         },
         mdns: {
             supported: false,
@@ -396,10 +407,17 @@ export default defineFrameworkManifest({
             ops: { 'temp.read': 'unsupported' },
         },
         hwtimer: {
-            supported: false,
-            unsupportedReason: 'No hardware-timer lowering on Zephyr (timers are handled via the k_timer polyfill, not hwtimer.*).',
-            partialCoverage: false,
-            ops: unsupportedOps('hwtimer.'),
+            // Hardware timers via the Zephyr counter driver (<zephyr/drivers/counter.h>).
+            // set_frequency → top value (counter_freq/hz) + on_overflow callback;
+            // start arms both; stop halts. A chip declares its free counters
+            // (e.g. nRF RTC1; RTC0 is kernel-owned). This is distinct from the JS
+            // setInterval/setTimeout k_timer polyfill, which is unaffected.
+            supported: true,
+            partialCoverage: true,
+            ops: {
+                'hwtimer.set_frequency': 'supported', 'hwtimer.on_overflow': 'supported',
+                'hwtimer.start': 'supported', 'hwtimer.stop': 'supported',
+            },
         },
         capacitive: {
             // FT6336U capacitive touch is handled via the strategy-owned touch adapter
@@ -466,6 +484,8 @@ export default defineFrameworkManifest({
     polyfills: {
         emitted: [
             { id: 'cuttlefish_halt', domain: 'standard', notes: 'Mapped to a k_msleep halt loop (exceptions disabled)' },
+            { id: 'string_methods', domain: 'embedded', notes: 'STL-free __tc_* string helpers (const char*, inline ASCII case conv, <cstring> only)' },
+            { id: 'static_array', domain: 'embedded', notes: 'STL-free __tc_StaticArray<T,N> wrapper for no-<vector> mutated/struct array literals' },
             { id: 'timer_methods', domain: 'embedded', notes: 'k_timer + k_work pool (system workqueue); callbacks run in thread context' },
             { id: 'async_runtime', domain: 'embedded', notes: 'Heap-free static Promise/microtask runtime (generateStaticAsyncRuntime), pumped in loop()' },
         ],
@@ -517,9 +537,9 @@ export default defineFrameworkManifest({
         // pure string-snapshot tests (no hardware); they are the safety net that
         // catches regressions like silent pull-resistor / interrupt no-ops.
         halResolutionTests: [
-            'adc', 'ble', 'board', 'dac', 'gpio', 'http', 'i2c', 'interrupts', 'mqtt',
-            'power', 'preferences', 'pulse', 'pwm', 'random', 'spi', 'timing', 'tone',
-            'uart', 'wdt', 'worker',
+            'adc', 'ble', 'board', 'dac', 'fs', 'gpio', 'http', 'hwtimer', 'i2c',
+            'interrupts', 'mqtt', 'power', 'preferences', 'pulse', 'pwm', 'random',
+            'spi', 'timing', 'tone', 'uart', 'wdt', 'worker',
         ],
     },
     // Declared compatibility range for the installed Zephyr RTOS. The framework's
@@ -533,4 +553,7 @@ export default defineFrameworkManifest({
     // `cuttlefish doctor` prints the detected Zephyr version + compat result and
     // previews how the configured board target resolves for that version.
     doctor: { available: true },
+    // `cuttlefish licenses` enumerates the Zephyr kernel + west manifest projects
+    // and resolves each one's SPDX license (mirrors framework-arduino).
+    licenses: { available: true },
 });

package/dist/index.d.ts

@@ -2,5 +2,6 @@ export { ZephyrStrategy as FrameworkStrategy } from './strategy.js';
 export { ZephyrStrategy } from './strategy.js';
 export { Toolchain } from './toolchain/index.js';
 export { runDoctor as doctor } from './doctor.js';
+export { runLicensesPresenter as licenses } from './licenses.js';
 export { chipForTarget, setActiveChip, getActiveChip, XIAO_BLE, } from './chips/index.js';
 export type { ZephyrChipDescriptor, ZephyrGpioDtSpec, } from './chips/types.js';

package/dist/index.js

@@ -13,5 +13,10 @@ export { Toolchain } from './toolchain/index.js';
 // under the dispatcher-facing alias `doctor` so the loader picks it up as
 // mod.doctor (see framework-package.ts).
 export { runDoctor as doctor } from './doctor.js';
+// `cuttlefish licenses` — enumerate the Zephyr kernel + west manifest projects
+// and resolve each one's SPDX license. Re-exported under the dispatcher-facing
+// alias `licenses` so the loader picks it up as mod.licenses (see
+// framework-package.ts). Mirrors framework-arduino's presenter.
+export { runLicensesPresenter as licenses } from './licenses.js';
 // Chip descriptor registry (for downstream tooling / additional boards).
 export { chipForTarget, setActiveChip, getActiveChip, XIAO_BLE, } from './chips/index.js';