@typecad/framework-zephyr 1.0.0-alpha.14 → 1.0.0-alpha.16

package/dist/chips/board-overrides.d.ts

@@ -0,0 +1,7 @@
+export interface BoardOverride {
+    /** LED pin name for boards whose user LED is not a gpio-leds node (the
+     *  ESP32-S3 DevKitC's addressable RGB on GPIO48 — driven as plain GPIO,
+     *  same as the deleted board package did). */
+    readonly led?: string;
+}
+export declare const BOARD_OVERRIDES: Readonly<Record<string, BoardOverride>>;

package/dist/chips/board-overrides.js

@@ -0,0 +1,11 @@
+// ---------------------------------------------------------------------------
+// board-overrides.ts — curated board-level facts the devicetree cannot
+// express. The honest residue of the board-package deletion: things a board
+// vendor documents in a datasheet but never encodes in DTS.
+//
+// Keyed by the bare board id (the first segment of the qualified target, so
+// every variant/qualifier of the board inherits the override).
+// ----------------------------------------------------------------------------
+export const BOARD_OVERRIDES = {
+    esp32s3_devkitc: { led: 'GPIO48' },
+};

package/dist/chips/esp32s3.js

@@ -51,4 +51,53 @@ export const ESP32S3_DEVKITC = {
     // WiFi: the ESP32-S3 has a 2.4GHz radio; conn_mgr + the esp32 wifi driver
     // (CONFIG_WIFI_ESP32) provide connectivity. Omitted on radioless targets.
     wifi: { supported: true },
+    // User buses, mirroring the devkit's verified facts (the
+    // board-constants path is authoritative in real builds; this registry
+    // entry is the fallback when board constants are absent — e.g. the
+    // transpile test harness). uart1 (not uart0 — the console) with the
+    // pinctrl group + current-speed the esp32-uart binding requires; i2c0;
+    // spi2/spi3.
+    i2c: { controllers: [{ nodeLabel: 'i2c0' }] },
+    spi: { controllers: [{ nodeLabel: 'spi2' }, { nodeLabel: 'spi3' }] },
+    uart: {
+        controllers: [
+            {
+                nodeLabel: 'uart1',
+                pinctrlRef: 'uart1_default',
+                props: ['current-speed = <115200>;'],
+            },
+        ],
+    },
+    // USB CDC-ACM over the S3's native USB-OTG (D-/D+ on the dedicated GPIO19/20
+    // pads, no GPIO matrix). The board DTS already aliases the DWC2 controller
+    // node and enables it (`zephyr_udc0: &usb_otg { status = "okay"; }` —
+    // esp32s3_devkitc_procpu.dts), and the UDC DWC2 driver is DT-default-on, so
+    // declaring it here is all usb.* needs: the overlay composes one CDC-ACM
+    // instance child and the kconfig resolver enables the "next" USB stack.
+    // Console stays on uart0 (the devkit's USB-serial bridge) unless
+    // `console.output: 'usb'` rebinds zephyr,console to the CDC port.
+    usb: { controller: 'zephyr_udc0', cdcInstances: 1, vid: '0x2FE3', pid: '0x0006' },
+    // PWM: the LEDC controller (ledc0 in esp32s3_common.dtsi) — 8 channels, each
+    // routable to nearly any pad through the GPIO matrix, so this is a matrix
+    // (channels assigned to the driven pins at build time), not a static spec
+    // list. Pin selection excludes: GPIO0 (boot strap / BOOT button), GPIO19/20
+    // (USB D-/D+), GPIO26–32 (SPI flash/PSRAM), GPIO33–37 (octal PSRAM on OPI
+    // modules), GPIO43/44 (uart0 console pads). The driver
+    // (CONFIG_PWM_LED_ESP32, DT-default-on) requires a pinctrl group routing
+    // each used channel (LEDC_CH<ch>_GPIO<pin> pinmux tokens, all 8×46 pairs in
+    // esp32s3-pinctrl.h) plus per-channel child nodes (reg + timer) — both
+    // emitted by the overlay generator (dt-config/overlay.ts emitPwmNodes).
+    pwm: {
+        specs: [],
+        matrix: {
+            controller: 'ledc0',
+            channelCount: 8,
+            pins: [
+                1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+                21,
+                38, 39, 40, 41, 42,
+                45, 46, 47, 48,
+            ],
+        },
+    },
 };

package/dist/chips/index.d.ts

@@ -1,15 +1,9 @@
 import type { ZephyrChipDescriptor } from './types.js';
-import { XIAO_BLE } from './xiao-ble.js';
-import { ESP32S3_DEVKITC } from './esp32s3.js';
-import { ESP32_DEVKITC } from './esp32.js';
-export { XIAO_BLE, ESP32S3_DEVKITC, ESP32_DEVKITC };
-export type { ZephyrChipDescriptor, ZephyrGpioDtSpec } from './types.js';
-export declare function setActiveChip(d: ZephyrChipDescriptor): void;
-export declare function getActiveChip(): ZephyrChipDescriptor;
 /**
- * Resolve a chip descriptor from the Zephyr board target string
- * (frameworkData.buildTarget / frameworkData.target). Accepts the bare board
- * id ('xiao_ble', 'esp32s3_devkitc', 'esp32_devkitc') or a board/qualifier
- * path ('esp32s3_devkitc/esp32s3/procpu', 'esp32_devkitc/esp32/procpu').
+ * The no-board fallback: no controllers, no buses, no silicon facts. The
+ * lowering treats it as "unsupported operation" per subsystem, which is the
+ * honest answer when no board resolved.
  */
-export declare function chipForTarget(target?: string): ZephyrChipDescriptor;
+export declare const NO_BOARD_CHIP: ZephyrChipDescriptor;
+export declare function setActiveChip(d: ZephyrChipDescriptor): void;
+export declare function getActiveChip(): ZephyrChipDescriptor;

package/dist/chips/index.js

@@ -1,45 +1,29 @@
 // ---------------------------------------------------------------------------
-// Chip descriptor registry — maps Zephyr board target → ZephyrChipDescriptor
+// Chip descriptor cache — the mechanism the strategy's lowering reads.
 //
-// Mirrors framework-esp32/src/chips/index.ts: a module-level activeChip,
-// setActiveChip/getActiveChip, and chipForTarget resolving from
-// frameworkData.buildTarget. The strategy calls setActiveChip during profile
-// resolution so the lowering reads a single cached descriptor.
+// There is no curated descriptor registry: every board's chip view is
+// reconstructed from its generated board manifest via resolveChipFromBoard
+// (src/chips/resolve.ts). This module only caches that resolved descriptor
+// for the process lifetime (setActiveChip during profile resolution, the
+// lowering reads getActiveChip) and provides the empty fallback for
+// contexts with no board at all.
 // ---------------------------------------------------------------------------
-import { XIAO_BLE } from './xiao-ble.js';
-import { ESP32S3_DEVKITC } from './esp32s3.js';
-import { ESP32_DEVKITC } from './esp32.js';
-export { XIAO_BLE, ESP32S3_DEVKITC, ESP32_DEVKITC };
 /**
- * Default chip used when no buildTarget is supplied. The XIAO nRF52840 is the
- * canonical MVP target; subsequent board additions extend the switch below.
+ * The no-board fallback: no controllers, no buses, no silicon facts. The
+ * lowering treats it as "unsupported operation" per subsystem, which is the
+ * honest answer when no board resolved.
  */
-const DEFAULT_CHIP = XIAO_BLE;
-let activeChip = DEFAULT_CHIP;
+export const NO_BOARD_CHIP = {
+    id: 'no-board',
+    soc: '',
+    gpioController: 'gpio0',
+    gpio: { dtSpecs: [] },
+    probeMethods: [],
+};
+let activeChip = NO_BOARD_CHIP;
 export function setActiveChip(d) {
     activeChip = d;
 }
 export function getActiveChip() {
     return activeChip;
 }
-/**
- * Resolve a chip descriptor from the Zephyr board target string
- * (frameworkData.buildTarget / frameworkData.target). Accepts the bare board
- * id ('xiao_ble', 'esp32s3_devkitc', 'esp32_devkitc') or a board/qualifier
- * path ('esp32s3_devkitc/esp32s3/procpu', 'esp32_devkitc/esp32/procpu').
- */
-export function chipForTarget(target) {
-    const t = (target ?? '').trim().toLowerCase();
-    const boardId = t.split('/')[0];
-    switch (boardId) {
-        case 'xiao_ble':
-            return XIAO_BLE;
-        case 'esp32s3_devkitc':
-            return ESP32S3_DEVKITC;
-        case 'esp32_devkitc':
-            return ESP32_DEVKITC;
-        case '':
-        default:
-            return DEFAULT_CHIP;
-    }
-}

package/dist/chips/resolve.d.ts

@@ -1,9 +1,23 @@
 import type { BoardConstants } from '@typecad/cuttlefish/api/shared';
-import type { ZephyrChipDescriptor } from './types.js';
+import type { ZephyrChipDescriptor, ZephyrPwmSpec } from './types.js';
 /**
  * Try to derive a ZephyrChipDescriptor from board/MCU package constants.
  *
  * Returns null when no zephyr info is available in the board constants
- * (the caller should fall back to the hardcoded chipForTarget registry).
+ * (the caller should treat the board as unresolved — NO_BOARD_CHIP).
  */
 export declare function resolveChipFromBoard(bc: BoardConstants | undefined): ZephyrChipDescriptor | null;
+/**
+ * Board-level PWM specs from the generated board manifest (zephyr.pwm.specs.*
+ * — the pwm-leds facts boardgen emits on virtual pins 8192+). The active
+ * chip's spec table is silicon-curated; these JOIN it (see mergeBoardPwmSpecs)
+ * so a board's own devicetree-aliased PWM LED is addressable without curation.
+ */
+export declare function boardPwmSpecsFromConstants(bc: BoardConstants | undefined): ZephyrPwmSpec[];
+/**
+ * Merge board-level PWM specs into a chip descriptor. Collision rule: a
+ * board spec whose pin OR dtSpec already exists in the chip's table is
+ * dropped (the curated entry wins — e.g. the XIAO's hand-tuned pwm-led0
+ * spec). Returns the chip unchanged when nothing joins.
+ */
+export declare function mergeBoardPwmSpecs(chip: ZephyrChipDescriptor, boardSpecs: readonly ZephyrPwmSpec[]): ZephyrChipDescriptor;

package/dist/chips/resolve.js

@@ -7,9 +7,9 @@
 // (from the MCU package's zephyr field) with board-level overrides (from the
 // board package's zephyr field).
 //
-// When a board package carries Zephyr config, this path replaces the
-// hardcoded chip descriptor registry. When it doesn't (legacy), chipForTarget
-// still works as the fallback.
+// This is the ONE resolution path: every board's chip view reconstructs
+// from its generated manifest — there is no curated registry to fall back
+// to.
 // ---------------------------------------------------------------------------
 /** Collect an indexed array of objects reconstructed from flat dot-path keys. */
 function collectIndexed(bc, prefix, build) {
@@ -34,23 +34,64 @@ function collectIndexed(bc, prefix, build) {
 function collectBusControllers(bc, prefix) {
     return collectIndexed(bc, prefix, (m, i) => {
         const nodeLabel = m.get(`${prefix}.${i}.nodeLabel`);
-        return nodeLabel ? { nodeLabel } : null;
+        if (!nodeLabel)
+            return null;
+        // Optional pinctrl synthesis data (nested object; string arrays arrive
+        // comma-joined from the board-constants flattener).
+        const splitCsv = (v) => typeof v === 'string' && v.length > 0
+            ? v.split(',').map((s) => s.trim()).filter(Boolean)
+            : undefined;
+        const include = m.get(`${prefix}.${i}.pinctrl.include`);
+        const pinmux = splitCsv(m.get(`${prefix}.${i}.pinctrl.pinmux`));
+        const inputPinmux = splitCsv(m.get(`${prefix}.${i}.pinctrl.inputPinmux`));
+        const defines = splitCsv(m.get(`${prefix}.${i}.pinctrl.defines`));
+        const pinctrlRef = m.get(`${prefix}.${i}.pinctrlRef`);
+        const props = splitCsv(m.get(`${prefix}.${i}.props`));
+        return {
+            nodeLabel,
+            ...(include && pinmux
+                ? {
+                    pinctrl: {
+                        include,
+                        pinmux,
+                        ...(inputPinmux ? { inputPinmux } : {}),
+                        ...(defines ? { defines } : {}),
+                    },
+                }
+                : {}),
+            ...(pinctrlRef ? { pinctrlRef } : {}),
+            ...(props ? { props } : {}),
+        };
     });
 }
 /**
  * Try to derive a ZephyrChipDescriptor from board/MCU package constants.
  *
  * Returns null when no zephyr info is available in the board constants
- * (the caller should fall back to the hardcoded chipForTarget registry).
+ * (the caller should treat the board as unresolved — NO_BOARD_CHIP).
  */
 export function resolveChipFromBoard(bc) {
     if (!bc)
         return null;
     const boardTarget = bc.get('build.frameworks.zephyr');
-    if (!boardTarget)
+    // MCU-silicon entry: an MCU-only config (no board package) carries the
+    // chip facts under zephyr.* without any build.frameworks target (the
+    // build target comes from frameworkData instead — a custom board name).
+    const socsRaw = bc.get('zephyr.socs');
+    if (!boardTarget && !socsRaw)
         return null;
+    const socs = typeof socsRaw === 'string' && socsRaw.length > 0
+        ? socsRaw.split(',').map((s) => s.trim()).filter(Boolean)
+        : [];
+    // Chip identity: the board target when a board resolved it, else the SoC
+    // (an MCU-only chip — its "board" is the generated custom board).
+    const id = boardTarget ?? socs[0] ?? 'custom';
     const zGpioController = bc.get('zephyr.gpioController');
-    const soc = bc.get('mcu.id') ?? '';
+    // The soc name: MCU packages key it under mcu.id; generated board
+    // manifests carry it as the second segment of the qualified target.
+    const soc = bc.get('mcu.id')
+        ?? (socs.length > 0 ? socs[0] : undefined)
+        ?? (boardTarget && boardTarget.includes('/') ? boardTarget.split('/')[1] : '');
     // ── Build mutable sub-objects, then construct the final descriptor ──────
     const gc = collectIndexed(bc, 'zephyr.gpioControllers', (m, i) => {
         const nodelabel = m.get(`zephyr.gpioControllers.${i}.nodelabel`);
@@ -85,6 +126,7 @@ export function resolveChipFromBoard(bc) {
         const channel = m.get(`zephyr.pwm.specs.${i}.channel`);
         const periodNs = m.get(`zephyr.pwm.specs.${i}.periodNs`);
         const polarity = m.get(`zephyr.pwm.specs.${i}.polarity`);
+        const pinctrl = m.get(`zephyr.pwm.specs.${i}.pinctrl`);
         // Board-shipped alias form (dtSpec) or synthesized form (controller +
         // channel → overlay-generated alias) — at least one, else drop the entry.
         if (pin == null || !(dtSpec || (controller && channel != null)))
@@ -96,9 +138,20 @@ export function resolveChipFromBoard(bc) {
             ...(channel != null ? { channel } : {}),
             ...(periodNs != null ? { periodNs } : {}),
             ...(polarity ? { polarity } : {}),
+            ...(pinctrl ? { pinctrl } : {}),
         };
     });
     const adcNodeLabel = bc.get('zephyr.adc.nodeLabel');
+    // PWM timer input clock — feeds the overlay's 16-bit prescaler derivation.
+    const pwmClockHz = bc.get('zephyr.pwm.clockHz');
+    // PWM matrix (ESP32 LEDC): any listed pin can carry any channel; channels
+    // are assigned to the driven pins at build time (dt-config/overlay.ts).
+    const matrixController = bc.get('zephyr.pwm.matrix.controller');
+    const matrixChannelCount = bc.get('zephyr.pwm.matrix.channelCount');
+    const matrixPins = collectIndexed(bc, 'zephyr.pwm.matrix.pins', (m, i) => m.get(`zephyr.pwm.matrix.pins.${i}`) ?? null);
+    const pwmMatrix = matrixController && matrixChannelCount
+        ? { controller: matrixController, channelCount: matrixChannelCount, pins: matrixPins }
+        : undefined;
     const adcResolution = bc.get('zephyr.adc.resolution');
     const adcVref = bc.get('zephyr.adc.vrefMv');
     const adcGain = bc.get('zephyr.adc.gain');
@@ -107,20 +160,139 @@ export function resolveChipFromBoard(bc) {
         const pin = m.get(`zephyr.adc.channels.${i}.pin`);
         const channel = m.get(`zephyr.adc.channels.${i}.channel`);
         const pinctrl = m.get(`zephyr.adc.channels.${i}.pinctrl`);
+        const controller = m.get(`zephyr.adc.channels.${i}.controller`);
+        if (pin != null && channel != null) {
+            return { pin, channel, ...(pinctrl ? { pinctrl } : {}), ...(controller ? { controller } : {}) };
+        }
+        return null;
+    });
+    const dacDevice = bc.get('zephyr.dac.device');
+    const dacChannels = collectIndexed(bc, 'zephyr.dac.channels', (m, i) => {
+        const pin = m.get(`zephyr.dac.channels.${i}.pin`);
+        const channel = m.get(`zephyr.dac.channels.${i}.channel`);
+        const resolution = m.get(`zephyr.dac.channels.${i}.resolution`);
         if (pin != null && channel != null) {
-            return { pin, channel, ...(pinctrl ? { pinctrl } : {}) };
+            return { pin, channel, resolution: resolution ?? 12 };
         }
         return null;
     });
     const wdtNodeLabel = bc.get('zephyr.wdt.nodeLabel');
+    // Hardware counters (Zephyr counter devices): nodeLabel always; the child
+    // form carries the timer parent the overlay attaches the (label-less)
+    // counter child to.
+    const hwtimerControllers = collectIndexed(bc, 'zephyr.hwtimer.controllers', (m, i) => {
+        const nodeLabel = m.get(`zephyr.hwtimer.controllers.${i}.nodeLabel`);
+        const counterParent = m.get(`zephyr.hwtimer.controllers.${i}.counterParent`);
+        if (!nodeLabel)
+            return null;
+        return { nodeLabel, ...(counterParent ? { counterParent } : {}) };
+    });
+    // Storage partition synthesis (boards whose DTS ships no storage_partition
+    // — see ZephyrChipDescriptor.storage).
+    const storageOffset = bc.get('zephyr.storage.offset');
+    const storageSize = bc.get('zephyr.storage.size');
+    const storagePreexisting = bc.get('zephyr.storage.preexisting');
+    // USB device (CDC-ACM): zephyr.usb.controller + zephyr.usb.cdcInstances
+    // (+ optional vid/pid for the device descriptor).
+    const usbController = bc.get('zephyr.usb.controller');
+    const usbCdcInstances = bc.get('zephyr.usb.cdcInstances');
+    const usbVid = bc.get('zephyr.usb.vid');
+    const usbPid = bc.get('zephyr.usb.pid');
+    // Optional 1200-baud touch-to-reset data (BOSSA-bootloader boards).
+    const trFlag = bc.get('zephyr.usb.touchReset.flagAddress');
+    const trMagic = bc.get('zephyr.usb.touchReset.magic');
+    const trVid = bc.get('zephyr.usb.touchReset.bootloaderVid');
+    const trPid = bc.get('zephyr.usb.touchReset.bootloaderPid');
+    const probeMethods = collectIndexed(bc, 'zephyr.probeMethods', (m, i) => {
+        const id = m.get(`zephyr.probeMethods.${i}.id`);
+        const runner = m.get(`zephyr.probeMethods.${i}.runner`);
+        if (!id || !runner)
+            return null;
+        const argsRaw = m.get(`zephyr.probeMethods.${i}.args`);
+        const description = m.get(`zephyr.probeMethods.${i}.description`);
+        const debugRaw = m.get(`zephyr.probeMethods.${i}.debug`);
+        const debugInterface = m.get(`zephyr.probeMethods.${i}.debugInterface`);
+        const debugDevice = m.get(`zephyr.probeMethods.${i}.debugDevice`);
+        const debugCfgRaw = m.get(`zephyr.probeMethods.${i}.debugCfg`);
+        const debugCfgSourceRaw = m.get(`zephyr.probeMethods.${i}.debugCfgSource`);
+        // Args are comma-joined (west flags never carry commas); cfg lines are
+        // newline-joined (tcl legally contains commas).
+        const split = (v) => typeof v === 'string' && v.length > 0 ? v.split(',') : undefined;
+        const splitLines = (v) => typeof v === 'string' && v.length > 0 ? v.split('\n') : undefined;
+        const args = split(argsRaw);
+        return {
+            id,
+            runner,
+            ...(args ? { args } : {}),
+            ...(description ? { description } : {}),
+            ...(debugRaw !== undefined ? { debug: debugRaw } : {}),
+            ...(debugInterface ? { debugInterface: debugInterface } : {}),
+            ...(debugDevice ? { debugDevice } : {}),
+            ...(split(debugCfgRaw) ? { debugCfg: splitLines(debugCfgRaw) } : {}),
+            ...(split(debugCfgSourceRaw) ? { debugCfgSource: splitLines(debugCfgSourceRaw) } : {}),
+        };
+    });
     const wifiSupported = bc.get('zephyr.wifi.supported');
+    // ── Custom-board generator inputs (MCU silicon) ─────────────────────────
+    // Only complete when the MCU package carried a default console + clock
+    // plan — without those there is nothing to generate a board from.
+    const consoleNodeLabel = bc.get('zephyr.console.nodeLabel');
+    const consoleTx = bc.get('zephyr.console.tx');
+    const consoleRx = bc.get('zephyr.console.rx');
+    const consoleSpeed = bc.get('zephyr.console.speed');
+    const hseMHz = bc.get('zephyr.clocks.hseMHz');
+    const pllDivM = bc.get('zephyr.clocks.pll.divM');
+    const pllMulN = bc.get('zephyr.clocks.pll.mulN');
+    const pllDivP = bc.get('zephyr.clocks.pll.divP');
+    const pllDivQ = bc.get('zephyr.clocks.pll.divQ');
+    const sysMHz = bc.get('zephyr.clocks.sysMHz');
+    const dtsIncludesRaw = bc.get('zephyr.dtsIncludes');
+    const usbNode = bc.get('zephyr.usb.usbNode');
+    const usbPinctrlRaw = bc.get('zephyr.usb.pinctrl');
+    const usbPinctrl = typeof usbPinctrlRaw === 'string' && usbPinctrlRaw.length > 0
+        ? usbPinctrlRaw.split(',').map((s) => s.trim()).filter(Boolean)
+        : undefined;
+    const cbAdcNodeLabel = bc.get('zephyr.adcNode.nodeLabel');
+    const cbAdcClockSource = bc.get('zephyr.adcNode.clockSource');
+    const cbAdcPrescaler = bc.get('zephyr.adcNode.prescaler');
+    const cbAdcPinctrl = bc.get('zephyr.adcNode.pinctrl');
+    const customBoard = socs.length > 0 &&
+        consoleNodeLabel && consoleTx && consoleRx &&
+        hseMHz != null && pllDivM != null && pllMulN != null && pllDivP != null &&
+        pllDivQ != null && sysMHz != null
+        ? {
+            socs,
+            dtsIncludes: typeof dtsIncludesRaw === 'string' && dtsIncludesRaw.length > 0
+                ? dtsIncludesRaw.split(',').map((s) => s.trim()).filter(Boolean)
+                : [],
+            console: {
+                nodeLabel: consoleNodeLabel,
+                tx: consoleTx,
+                rx: consoleRx,
+                speed: consoleSpeed ?? 115200,
+            },
+            clocks: {
+                hseMHz,
+                pll: { divM: pllDivM, mulN: pllMulN, divP: pllDivP, divQ: pllDivQ },
+                sysMHz,
+                ahbPrescaler: bc.get('zephyr.clocks.ahbPrescaler') ?? 1,
+                apb1Prescaler: bc.get('zephyr.clocks.apb1Prescaler') ?? 1,
+                apb2Prescaler: bc.get('zephyr.clocks.apb2Prescaler') ?? 1,
+            },
+            ...(usbNode ? { usbNode } : {}),
+            ...(usbPinctrl ? { usbPinctrl } : {}),
+            ...(cbAdcNodeLabel && cbAdcClockSource && cbAdcPrescaler != null && cbAdcPinctrl
+                ? { adcNode: { nodeLabel: cbAdcNodeLabel, clockSource: cbAdcClockSource, prescaler: cbAdcPrescaler, pinctrl: cbAdcPinctrl } }
+                : {}),
+        }
+        : undefined;
     // ── Construct the final readonly descriptor ─────────────────────────────
     const gpio = {
         dtSpecs,
         ...(intPins.length > 0 ? { interruptPins: intPins } : {}),
     };
     return {
-        id: boardTarget,
+        id,
         soc,
         gpioController: zGpioController ?? 'gpio0',
         ...(gc.length > 0 ? { gpioControllers: gc } : {}),
@@ -128,7 +300,15 @@ export function resolveChipFromBoard(bc) {
         ...(i2cControllers.length > 0 ? { i2c: { controllers: i2cControllers } } : {}),
         ...(spiControllers.length > 0 ? { spi: { controllers: spiControllers } } : {}),
         ...(uartControllers.length > 0 ? { uart: { controllers: uartControllers } } : {}),
-        ...(pwmSpecs.length > 0 ? { pwm: { specs: pwmSpecs } } : {}),
+        ...(pwmSpecs.length > 0 || pwmMatrix
+            ? {
+                pwm: {
+                    specs: pwmSpecs,
+                    ...(pwmMatrix ? { matrix: pwmMatrix } : {}),
+                    ...(pwmClockHz ? { clockHz: pwmClockHz } : {}),
+                },
+            }
+            : {}),
         ...(adcNodeLabel || adcResolution != null || adcVref != null || adcChannels.length > 0
             ? {
                 adc: {
@@ -141,7 +321,84 @@ export function resolveChipFromBoard(bc) {
                 },
             }
             : {}),
+        ...(dacDevice && dacChannels.length > 0 ? { dac: { device: dacDevice, channels: dacChannels } } : {}),
         ...(wdtNodeLabel ? { wdt: { nodeLabel: wdtNodeLabel } } : {}),
+        ...(hwtimerControllers.length > 0 ? { hwtimer: { controllers: hwtimerControllers } } : {}),
+        ...(storageOffset != null && storageSize != null
+            ? { storage: { offset: storageOffset, size: storageSize, ...(storagePreexisting ? { preexisting: true } : {}) } }
+            : {}),
+        ...(usbController && usbCdcInstances && usbCdcInstances > 0
+            ? {
+                usb: {
+                    controller: usbController,
+                    cdcInstances: usbCdcInstances,
+                    ...(usbVid ? { vid: usbVid } : {}),
+                    ...(usbPid ? { pid: usbPid } : {}),
+                    ...(trFlag != null && trMagic != null
+                        ? {
+                            touchReset: {
+                                flagAddress: trFlag,
+                                magic: trMagic,
+                                ...(trVid ? { bootloaderVid: trVid } : {}),
+                                ...(trPid ? { bootloaderPid: trPid } : {}),
+                            },
+                        }
+                        : {}),
+                },
+            }
+            : {}),
         ...(wifiSupported ? { wifi: { supported: true } } : {}),
+        ...(probeMethods.length > 0 ? { probeMethods } : {}),
+        ...(customBoard ? { customBoard } : {}),
+    };
+}
+/**
+ * Board-level PWM specs from the generated board manifest (zephyr.pwm.specs.*
+ * — the pwm-leds facts boardgen emits on virtual pins 8192+). The active
+ * chip's spec table is silicon-curated; these JOIN it (see mergeBoardPwmSpecs)
+ * so a board's own devicetree-aliased PWM LED is addressable without curation.
+ */
+export function boardPwmSpecsFromConstants(bc) {
+    if (!bc)
+        return [];
+    const specs = [];
+    for (let i = 0; i < 256; i++) {
+        const pin = bc.get(`zephyr.pwm.specs.${i}.pin`);
+        if (pin == null)
+            break;
+        const dtSpec = bc.get(`zephyr.pwm.specs.${i}.dtSpec`);
+        const controller = bc.get(`zephyr.pwm.specs.${i}.controller`);
+        const channel = bc.get(`zephyr.pwm.specs.${i}.channel`);
+        if (!(dtSpec || (controller && channel != null)))
+            continue;
+        specs.push({
+            pin,
+            ...(dtSpec ? { dtSpec } : {}),
+            ...(controller ? { controller } : {}),
+            ...(channel != null ? { channel } : {}),
+        });
+    }
+    return specs;
+}
+/**
+ * Merge board-level PWM specs into a chip descriptor. Collision rule: a
+ * board spec whose pin OR dtSpec already exists in the chip's table is
+ * dropped (the curated entry wins — e.g. the XIAO's hand-tuned pwm-led0
+ * spec). Returns the chip unchanged when nothing joins.
+ */
+export function mergeBoardPwmSpecs(chip, boardSpecs) {
+    if (boardSpecs.length === 0)
+        return chip;
+    const existing = chip.pwm?.specs ?? [];
+    const joining = boardSpecs.filter((s) => !existing.some((e) => e.pin === s.pin || (s.dtSpec != null && e.dtSpec === s.dtSpec)));
+    if (joining.length === 0)
+        return chip;
+    return {
+        ...chip,
+        pwm: {
+            specs: [...existing, ...joining],
+            ...(chip.pwm?.matrix ? { matrix: chip.pwm.matrix } : {}),
+            ...(chip.pwm?.clockHz ? { clockHz: chip.pwm.clockHz } : {}),
+        },
     };
 }

package/dist/chips/soc/.d.ts

@@ -0,0 +1,2 @@
+import type { ZephyrChipDescriptor } from '../types.js';
+export declare const _SOC: ZephyrChipDescriptor;