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

package/dist/framework.manifest.d.ts

@@ -9,7 +9,7 @@ declare const _default: {
     entrypoint: {
         entrypointFunctionName: string;
         requiresLoopFunction: boolean;
-        sourceExtension: "cpp" | "ino" | "cc" | "h";
+        sourceExtension: "cpp" | "h" | "ino" | "cc";
         generateHeaderFile: boolean;
         overrideBaseName?: string | undefined;
         outputSubdirectory?: string | undefined;
@@ -22,7 +22,7 @@ declare const _default: {
     };
     hal: Record<string, {
         supported: boolean;
-        ops: Record<string, "unsupported" | "supported" | "polyfill" | "probe-inconclusive" | "stub">;
+        ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
         partialCoverage: boolean;
         unsupportedReason?: string | undefined;
     }>;
@@ -50,7 +50,7 @@ declare const _default: {
     };
     typeEmission: {
         normalizeCppType: boolean;
-        mathHeader: "<math.h>" | "none" | "<Arduino.h>";
+        mathHeader: "<cmath>" | "none" | "<math.h>" | "<Arduino.h>";
         needsStdString: boolean;
         needsStdVector: boolean;
         needsIostream: boolean;

package/dist/framework.manifest.js

@@ -2,7 +2,7 @@
 // Zephyr framework manifest
 //
 // Coverage reflects actual resolveHALOperation / lowerHalOp + resolveDisplayOp
-// behavior. GPIO, PWM, ADC, I2C, SPI, UART, interrupts, tone, power, pulse,
+// behavior. GPIO, PWM, ADC, I2C, SPI, UART, interrupts, pulse,
 // shift, WDT, BLE, timing, WiFi, HTTP/S, MQTT, board constants, and random
 // are lowered; display is lowered via the generic <zephyr/drivers/display.h>
 // GFX runtime. WiFi/HTTP/MQTT require an ESP32 target (nRF52840 has no radio).
@@ -34,27 +34,22 @@ export default defineFrameworkManifest({
         'GPIO is lowered through devicetree specs (gpio_pin_*_dt).',
     implementationMode: 'from-scratch',
     entrypoint: {
-        entrypointFunctionName: 'setup',
-        requiresLoopFunction: true,
+        // Zephyr is a main()-based RTOS: top-level statements lower straight into
+        // main() (no setup()/loop() pair, no bridge shim). Event-driven programs
+        // get their scheduler loop appended inside main() by the driver machinery.
+        entrypointFunctionName: 'main',
+        requiresLoopFunction: false,
         sourceExtension: 'cpp',
         overrideBaseName: 'main',
         outputSubdirectory: 'src',
         generateHeaderFile: true,
-        customBridgeShim: 'main',
     },
     profile: {
         // Informational list of supported board targets. The manifest validator
-        // never iterates this; chipForTarget (src/chips/index.ts) is the real
-        // resolver. ESP32-S3 + plain ESP32 added alongside the nRF52840 MVP target;
-        // rpi_pico / rpi_pico2 / esp32c3 / esp32c6 / blackpill_f411ce resolve via
-        // the board packages' zephyr chip data (resolveChipFromBoard), not the
-        // hardcoded chip registry.
-        targets: [
-            'xiao_ble', 'esp32s3_devkitc', 'esp32_devkitc',
-            'rpi_pico', 'rpi_pico2/rp2350a/m33',
-            'esp32c3_devkitm/esp32c3', 'esp32c6_devkitc/esp32c6/hpcore',
-            'blackpill_f411ce/stm32f411xe',
-        ],
+        // never iterates this. Every board in the catalog resolves the same way
+        // (resolveChipFromBoard over the generated manifest) — there is no
+        // curated target list.
+        targets: [],
         forcedIncludes: ['<zephyr/kernel.h>', '<zephyr/drivers/gpio.h>', '<cstdint>'],
         symbolAliases: {},
     },
@@ -67,26 +62,28 @@ export default defineFrameworkManifest({
                 'gpio.write': 'supported',
                 'gpio.read': 'supported',
                 'gpio.toggle': 'supported',
-                'gpio.set_mode': 'supported',
+                // Thin GPIO (hal/gpio-pin.ts): construction flags as tokens, applied
+                // once per pin ahead of first use.
+                'gpio.configure': 'supported',
+                'gpio.read_cfg': 'supported', // fused guarded configure + read
+                'gpio.shift_out': 'supported',
+                'gpio.shift_in': 'supported',
             },
         },
-        // ── Supported: Timing (delay/millis/delay_us/micros/free_heap; timers via polyfill) ─
+        // ── Supported: Timing (delay/millis/delay_us/micros; timers via polyfill) ─
         timing: {
             supported: true,
             partialCoverage: false,
             ops: {
-                'timing.delay': 'supported', // → k_msleep(ms)
-                'timing.delay_microseconds': 'supported', // → k_busy_wait(us)
-                'timing.millis': 'supported', // → k_uptime_get_32()
-                'timing.micros': 'supported', // → k_cycle_get_32 + cycles/sec
-                'timing.free_heap': 'supported', // → 0 (no portable query; see lowering)
                 // Timer ops are POLYFILL_BACKED_OPS → timer_methods. The validator skips
                 // the resolver probe (these legitimately return polyfill-helper calls,
                 // not direct lowering) and requires the polyfill be in polyfills.emitted.
-                'timing.set_interval': 'polyfill',
-                'timing.set_timeout': 'polyfill',
-                'timing.clear_interval': 'polyfill',
-                'timing.clear_timeout': 'polyfill',
+                // Time.* — the TS-flavored surface (hal/time.ts), preferred over the
+                // Arduino-named forms above for new code.
+                'timing.sleep': 'supported', // → k_msleep(ms) — Time.sleep
+                'timing.now': 'supported', // → k_uptime_get() — Time.now
+                'timing.now_us': 'supported', // → k_cyc_to_us_floor64 — Time.nowUs
+                'timing.busy_wait_us': 'supported', // → k_busy_wait(us) — Time.busyWaitUs
             },
         },
         // ── Supported: PWM (pwm_dt_spec via pwm-led0) ──────────────────────────
@@ -94,9 +91,11 @@ export default defineFrameworkManifest({
             supported: true,
             partialCoverage: false,
             ops: {
-                'pwm.write': 'supported',
-                'pwm.get_frequency': 'supported',
-                'pwm.get_resolution': 'supported',
+                // Thin PWM (hal/pwm-pin.ts): ns-true verbs; construction period
+                // applies once, setDuty is 0.0–1.0 sugar over one set_pulse call.
+                'pwm.set_pulse': 'supported',
+                'pwm.set_duty': 'supported',
+                'pwm.set_period': 'supported',
             },
         },
         // ── Supported: ADC (SAADC via adc_read + channel setup) ────────────────
@@ -104,11 +103,10 @@ export default defineFrameworkManifest({
             supported: true,
             partialCoverage: false,
             ops: {
-                'adc.read': 'supported',
-                'adc.get_resolution': 'supported',
-                'adc.set_reference': 'supported',
-                'adc.get_reference': 'supported',
-                'adc.read_voltage': 'supported',
+                // Thin ADC (hal/adc-pin.ts): construction gain/reference tokens,
+                // lazy inline channel setup.
+                'adc.read_raw': 'supported',
+                'adc.read_mv': 'supported',
             },
         },
         dac: {
@@ -118,77 +116,57 @@ export default defineFrameworkManifest({
             // (zephyr-dac-pin-unavailable).
             supported: true,
             partialCoverage: true,
-            ops: { 'dac.write': 'supported' },
+            ops: {
+                // Thin DAC (hal/dac-pin.ts): raw code, construction resolution.
+                'dac.write_value': 'supported',
+            },
         },
         interrupts: {
             supported: true,
             partialCoverage: true,
             unsupportedReason: undefined,
             ops: {
-                'interrupt.attach': 'supported',
                 'interrupt.detach': 'supported',
-            },
-        },
-        tone: {
-            supported: true,
-            partialCoverage: true,
-            ops: {
-                'tone.play': 'supported', // PWM-based square wave (blocking for duration)
-                'tone.stop': 'supported',
-            },
-        },
-        power: {
-            supported: true,
-            partialCoverage: true,
-            ops: {
-                'power.deep_sleep': 'supported', // k_sleep (deepest allowed state)
-                'power.light_sleep': 'supported', // pm_state_force SUSPEND_TO_IDLE
-                'power.set_cpu_frequency': 'supported', // comment (nRF clock API deferred)
-                'power.deep_sleep_pin': 'supported', // GPIO-interrupt wake + k_sleep
+                // Thin GPIO interrupts (hal/gpio-pin.ts onInterrupt): INT_* tokens,
+                // covering the level modes the legacy mode strings could not express.
+                'interrupt.attach_flags': 'supported',
             },
         },
         i2c: {
             supported: true,
             partialCoverage: false,
             ops: {
-                'i2c.begin': 'supported', 'i2c.end': 'supported', 'i2c.set_clock': 'supported',
-                'i2c.begin_transmission': 'supported', 'i2c.write': 'supported',
-                'i2c.write_bytes': 'supported', 'i2c.write_buffer': 'supported',
-                'i2c.read_buffer': 'supported', 'i2c.end_transmission': 'supported',
-                'i2c.request_from': 'supported', 'i2c.available': 'supported', 'i2c.read': 'supported',
-                'i2c.recover': 'supported',
+                // Thin I2C device (hal/i2c-target.ts): Zephyr register verbs.
+                'i2c.reg_write': 'supported',
+                'i2c.reg_read': 'supported',
+                'i2c.reg_update': 'supported',
+                'i2c.dev_write': 'supported',
             },
         },
         spi: {
             supported: true,
             partialCoverage: false,
             ops: {
-                'spi.begin': 'supported', 'spi.end': 'supported', 'spi.transfer': 'supported',
-                'spi.begin_transaction': 'supported', 'spi.end_transaction': 'supported',
-                'spi.set_mode': 'supported', 'spi.set_bit_order': 'supported',
-                'spi.cs_low': 'supported', 'spi.cs_high': 'supported', 'spi.read_buffer': 'supported',
+                // Thin SPI device (hal/spi-target.ts): spi_dt_spec against the DT
+                // child node the overlay emits per constructed target.
+                'spi.transceive': 'supported',
+                'spi.dev_write': 'supported',
+                'spi.reg_read': 'supported',
             },
         },
         uart: {
             supported: true,
             partialCoverage: true,
             ops: {
-                'uart.begin': 'supported', 'uart.end': 'supported', 'uart.print': 'supported',
-                'uart.println': 'supported', 'uart.printf': 'supported', 'uart.write': 'supported',
-                'uart.read': 'supported', 'uart.peek': 'supported', 'uart.available': 'supported',
-                'uart.flush': 'supported',
+                // Thin UART (hal/uart-port.ts): poll API with construction baud.
+                'uart.poll_write': 'supported',
+                // Interrupt-drained RX ring (hal/uart-port.ts).
+                'uart.rx_arm': 'supported',
+                'uart.rx_available': 'supported',
+                'uart.rx_peek': 'supported',
+                'uart.rx_read': 'supported',
             },
         },
-        pulse: {
-            supported: true,
-            partialCoverage: true,
-            ops: { 'pulse.in': 'supported', 'pulse.in_long': 'supported' },
-        },
-        shift: {
-            supported: true,
-            partialCoverage: false,
-            ops: { 'shift.out': 'supported', 'shift.in': 'supported' },
-        },
         board: {
             // Board constant resolution. Board.definition.<path> /
             // Pins.definition.<path> property accesses are folded by
@@ -206,9 +184,33 @@ export default defineFrameworkManifest({
             supported: true,
             partialCoverage: false,
             ops: {
-                'wdt.enable': 'supported',
-                'wdt.reset': 'supported',
                 'wdt.disable': 'supported',
+                // Thin Watchdog (hal/watchdog.ts): construction timeout in ms.
+                'wdt.setup': 'supported',
+                'wdt.feed': 'supported',
+            },
+        },
+        // Thin Counter (hal/counter.ts) — Zephyr's counter driver with Zephyr's
+        // verbs, over the same per-instance state as hwtimer.*. Chips without a
+        // declared free counter lower to a comment + profileDiagnostics flag.
+        counter: {
+            supported: true,
+            partialCoverage: true,
+            ops: {
+                'counter.on_alarm': 'supported',
+                'counter.start': 'supported',
+                'counter.stop': 'supported',
+            },
+        },
+        // Thin Thread (hal/thread.ts) — kernel threads. start(fn) is
+        // k_thread_create (K_NO_WAIT) over a per-slot stack sized by the
+        // construction stackKb; join is k_thread_join (K_FOREVER).
+        thread: {
+            supported: true,
+            partialCoverage: false,
+            ops: {
+                'thread.start': 'supported',
+                'thread.join': 'supported',
             },
         },
         // ── Partial: WiFi (STA connect + scan + config via conn_mgr/net_mgmt) ────
@@ -222,50 +224,32 @@ export default defineFrameworkManifest({
             // driver hook; credentials need a custom settings-subsystem layer; static IP
             // / auto-reconnect / tx-power aren't wifi-shaped or aren't exposed by the
             // esp32 Zephyr driver. See per-op reasons.
-            unsupportedReason: 'AP client enumeration/IP/per-station config, credential persistence, static IP, auto-reconnect, and tx-power have no Zephyr lowering (no driver/Kconfig hook).',
+            unsupportedReason: 'Per-station AP enumeration and credential persistence have no Zephyr lowering (no driver/Kconfig hook).',
             ops: {
-                // Connection (8) — net_mgmt connect/disconnect + L4 connectivity state.
-                'wifi.connect': 'supported', 'wifi.connect_start': 'supported',
-                'wifi.disconnect': 'supported', 'wifi.status': 'supported',
-                'wifi.is_connected': 'supported', 'wifi.local_ip': 'supported',
-                'wifi.rssi': 'supported', 'wifi.mac': 'supported',
-                // Waits (2) — block on the L4 connected flag (k_msleep poll).
-                'wifi.wait_connected': 'supported', 'wifi.wait_disconnected': 'supported',
+                // Station (8) — join carries the construction facts (credentials,
+                // security, band/channel, timeout, static IPv4, power-save);
+                // net_mgmt connect/disconnect + L4 connectivity state underneath.
+                'wifi.join': 'supported', 'wifi.connect_start': 'supported',
+                'wifi.disconnect': 'supported', 'wifi.is_connected': 'supported',
+                'wifi.local_ip': 'supported', 'wifi.rssi': 'supported',
+                'wifi.mac': 'supported',
                 // Scan (8) — net_mgmt NET_REQUEST_WIFI_SCAN + result pool.
-                'wifi.scan': 'supported', 'wifi.scan_start': 'supported',
+                // scan_start is the async split of scan (kick + poll scan_done);
+                // emitted synthetically by the async tier, no TS-facing method.
+                'wifi.scan': 'supported',
+                'wifi.scan_start': 'supported',
                 'wifi.scan_done': 'supported', 'wifi.scan_count': 'supported',
                 'wifi.scan_ssid': 'supported', 'wifi.scan_rssi': 'supported',
                 'wifi.scan_encryption': 'supported', 'wifi.scan_channel': 'supported',
-                // AP mode (2 of 7) — esp32 driver wires ap_enable/ap_disable. Only
-                // ssid/password/channel are honored; the rest of the AP surface has no
-                // driver hook (config_params isn't wired, max_clients hardcodes 5).
+                // AP mode (2) — esp32 driver wires ap_enable/ap_disable. Only
+                // ssid/psk/channel are honored (the thin WiFiAP facts carry exactly those).
                 'wifi.ap_start': 'supported', 'wifi.ap_stop': 'supported',
-                // Config (2) — hostname (best-effort no-op) + power save (real net_mgmt).
-                'wifi.set_hostname': 'supported', 'wifi.set_power_save': 'supported',
                 // on_event: 'disconnect' (NET_EVENT_L4_DISCONNECTED) + 'connect'
                 // (NET_EVENT_IPV4_ADDR_ADD) are lowered.
                 'wifi.on_event': 'supported',
-                // ── Genuinely unsupported (no Zephyr/driver hook) ───────────────────
+                // ── Genuinely unsupported (no driver hook) ─────────────────────────
                 // ap_client_count: no API to enumerate connected AP stations.
-                // ap_ip: set via net_if, not wifi net_mgmt.
-                // ap_set_channel: channel set at ap_start; driver doesn't wire ap_config_params.
-                // ap_set_hidden: esp32 ap_enable config has no ssid_hidden field.
-                // ap_set_max_clients: driver hardcodes max_connection to 5; config_params unwired.
-                // save_credentials/connect_saved/clear_credentials: no wifi-credentials API in
-                //   Zephyr (would need a custom settings-subsystem layer).
-                // set_static_ip: a net_if operation, not a wifi net_mgmt request.
-                // set_auto_reconnect: esp32 driver doesn't expose esp_wifi_set_auto_connect.
-                // set_tx_power: driver owns the radio; the PHY ceiling isn't a Zephyr Kconfig (zephyr#45580).
                 'wifi.ap_client_count': 'unsupported',
-                'wifi.ap_ip': 'unsupported',
-                'wifi.ap_set_channel': 'unsupported',
-                'wifi.ap_set_hidden': 'unsupported',
-                'wifi.ap_set_max_clients': 'unsupported',
-                'wifi.save_credentials': 'unsupported', 'wifi.connect_saved': 'unsupported',
-                'wifi.clear_credentials': 'unsupported',
-                'wifi.set_static_ip': 'unsupported',
-                'wifi.set_auto_reconnect': 'unsupported',
-                'wifi.set_tx_power': 'unsupported',
             },
         },
         http: {
@@ -277,7 +261,7 @@ export default defineFrameworkManifest({
             // a networked target (ESP32 WiFi); profileDiagnostics flags usage on a
             // radioless chip as 'zephyr-http-unavailable-on-target'.
             ops: {
-                'http.begin': 'supported', 'http.reset': 'supported',
+                'http.begin': 'supported',
                 'http.set_header': 'supported', 'http.set_timeout': 'supported',
                 'http.set_max_body': 'supported', 'http.set_body': 'supported',
                 'http.set_insecure': 'supported', 'http.set_ca_cert': 'supported',
@@ -313,25 +297,12 @@ export default defineFrameworkManifest({
             ops: Object.fromEntries(HAL_OPERATION_KINDS.filter((k) => k.startsWith('ble.')).map((k) => [k, 'supported'])),
         },
         // ── Supported: Worker offload (k_work system workqueue + k_sem) ──────────
-        // worker.* is lowered via lowerWorkerOp against the shared __tc_worker
-        // contract; the Zephyr backing (worker-backing.ts) supplies k_work + k_sem.
-        worker: {
-            supported: true,
-            partialCoverage: false,
-            ops: { 'worker.submit': 'supported', 'worker.done': 'supported' },
-        },
         // ── Honestly unsupported extended categories ─────────────────────────────
         // These have op-kinds in HAL_OPERATION_KINDS but no Zephyr lowering. Each
         // is declared unsupported (with a reason) so the coverage matrix is uniform
         // and the resolver's `return undefined` for these prefixes is honest. The
         // catchall schema (HalCoverageSchema) validates any declared extended
         // category; declaring them keeps the manifest a complete coverage record.
-        rmt: {
-            supported: false,
-            unsupportedReason: 'RMT (ESP32 infrared/transaction peripheral) has no Zephyr lowering.',
-            partialCoverage: false,
-            ops: unsupportedOps('rmt.'),
-        },
         snprintf: {
             supported: false,
             unsupportedReason: 'snprintf.emit is a raw escape hatch; the Zephyr resolver returns undefined (use rawCpp()).',
@@ -352,10 +323,8 @@ export default defineFrameworkManifest({
             supported: true,
             partialCoverage: false,
             ops: {
-                'preferences.begin': 'supported', 'preferences.end': 'supported',
                 'preferences.clear': 'supported', 'preferences.remove': 'supported',
                 'preferences.put_int': 'supported', 'preferences.get_int': 'supported',
-                'preferences.put_uint': 'supported', 'preferences.get_uint': 'supported',
                 'preferences.put_bool': 'supported', 'preferences.get_bool': 'supported',
                 'preferences.put_float': 'supported', 'preferences.get_float': 'supported',
                 'preferences.put_string': 'supported', 'preferences.get_string': 'supported',
@@ -382,16 +351,10 @@ export default defineFrameworkManifest({
             supported: true,
             partialCoverage: false,
             ops: {
-                'fs.begin': 'supported', 'fs.read_text': 'supported', 'fs.write_text': 'supported',
+                'fs.read_text': 'supported', 'fs.write_text': 'supported',
                 'fs.exists': 'supported', 'fs.remove': 'supported',
             },
         },
-        mdns: {
-            supported: false,
-            unsupportedReason: 'No mDNS lowering on Zephyr (requires networking stack).',
-            partialCoverage: false,
-            ops: unsupportedOps('mdns.'),
-        },
         mqtt: {
             supported: true,
             partialCoverage: false,
@@ -408,43 +371,19 @@ export default defineFrameworkManifest({
                 'mqtt.connected': 'supported', 'mqtt.disconnect': 'supported',
             },
         },
-        ota: {
-            supported: false,
-            unsupportedReason: 'No OTA lowering on Zephyr (Zephyr has MCUmgr; not wired).',
-            partialCoverage: false,
-            ops: unsupportedOps('ota.'),
-        },
-        temp: {
-            supported: false,
-            unsupportedReason: 'No on-chip temperature lowering on Zephyr (nRF52840 TEMP peripheral; not wired).',
-            partialCoverage: false,
-            ops: { 'temp.read': 'unsupported' },
-        },
-        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.
+        sensor: {
+            // DT-bound sensor parts — the generic catalog (hal/sensor.ts +
+            // sensor-catalog.generated.ts). fetch → sensor_sample_fetch,
+            // get → sensor_channel_get on a per-sensor device handle; the overlay
+            // generator emits the DT child node, and the driver's own Kconfig
+            // `default y` lights it up (only CONFIG_SENSOR is set, usage-gated).
             supported: true,
-            partialCoverage: true,
+            partialCoverage: false,
             ops: {
-                'hwtimer.set_frequency': 'supported', 'hwtimer.on_overflow': 'supported',
-                'hwtimer.start': 'supported', 'hwtimer.stop': 'supported',
+                'sensor.fetch': 'supported',
+                'sensor.get': 'supported',
             },
         },
-        capacitive: {
-            // FT6336U capacitive touch is handled via the strategy-owned touch adapter
-            // (src/display/touch-adapter.ts → touch_init/touch_isTouched/touch_readRaw),
-            // NOT via a HAL op lowering. The manifest marks it unsupported here (no
-            // resolveHALOperation path for capacitive.read); the touch adapter provides
-            // the integration. partialCoverage reflects that it works on targets with
-            // the FT6336U DT node (ESP32), not on the bare nRF52840.
-            supported: false,
-            unsupportedReason: 'Capacitive touch is handled via the strategy touch adapter (FT6336U I2C), not a HAL op. Requires the ft6336u DT node.',
-            partialCoverage: true,
-            ops: { 'capacitive.read': 'unsupported' },
-        },
         i2s: {
             supported: false,
             unsupportedReason: 'No I2S / digital audio lowering on Zephyr.',
@@ -458,8 +397,12 @@ export default defineFrameworkManifest({
             ops: unsupportedOps('twai.'),
         },
         usb: {
+            // CDC-ACM serial over the board's USB connector. BOARD-GATED: the
+            // lowering only fires when the board's manifest carries zephyr.usb.*
+            // (boardgen emits it from the board's own DTS) — the manifest probe
+            // runs with no board, so the honest declaration is unsupported here.
             supported: false,
-            unsupportedReason: 'No USB OTG / USB-Serial lowering on Zephyr (Zephyr USB device stack not wired).',
+            unsupportedReason: 'Board-gated: USB lowers only on boards whose DTS enables the USB device controller (boardgen emits zephyr.usb.* from the catalog).',
             partialCoverage: false,
             ops: unsupportedOps('usb.'),
         },
@@ -501,7 +444,6 @@ export default defineFrameworkManifest({
             { id: 'wiring_compat', domain: 'standard', notes: 'HIGH/LOW/digitalRead/etc. macros routing Wiring tokens (referenced unconditionally by the UI runtime header) to the __tc_gpio_* helpers' },
             { 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()' },
         ],
         suppressed: [],
@@ -518,7 +460,7 @@ export default defineFrameworkManifest({
     },
     typeEmission: {
         normalizeCppType: true,
-        mathHeader: '<math.h>',
+        mathHeader: '<cmath>',
         needsStdString: false,
         needsStdVector: false,
         needsIostream: false,
@@ -535,17 +477,11 @@ export default defineFrameworkManifest({
     },
     ambientTypes: ['Preferences'],
     conformance: {
-        // Hardware-test groups — each entry is backed by a tests/<group>.test.ts
-        // file in this package (validated by the manifest validator). Mirrors the
-        // framework-avr/framework-esp32 convention. These run on metal via
-        // `npm run test:hw` (cuttlefish-test transpiles → west build → flash).
-        hardwareTestGroups: [
-            '01-basics',
-            '30-timing',
-            '40-gpio',
-            '41-analog',
-            '42-timers',
-        ],
+        // Hardware-test groups moved to the shared HAL suite
+        // (packages/hal/tests — common/ + board/ via board test-pins.json), which
+        // runs on Zephyr targets through the hal board configs. The
+        // hal-resolution snapshots below stay.
+        hardwareTestGroups: [],
         // Per-op HAL-resolution suite — one tests/packages/framework-zephyr/
         // hal-resolution/<cat>.test.ts per category, snapshotting the exact C++
         // each op lowers to. Mirrors the framework-esp32 convention. These are
@@ -553,8 +489,9 @@ export default defineFrameworkManifest({
         // catches regressions like silent pull-resistor / interrupt no-ops.
         halResolutionTests: [
             'adc', 'ble', 'board', 'dac', 'fs', 'gpio', 'http', 'hwtimer', 'i2c',
-            'interrupts', 'mqtt', 'power', 'preferences', 'pulse', 'pwm', 'random',
-            'spi', 'timing', 'tone', 'uart', 'wdt', 'worker',
+            'interrupts', 'mqtt', 'preferences', 'pwm', 'random',
+            'spi', 'thin-buses', 'thin-classes', 'thread', 'timing',
+            'uart', 'usb', 'wdt', 'wifi',
         ],
     },
     // Declared compatibility range for the installed Zephyr RTOS. The framework's

package/dist/index.d.ts

@@ -1,8 +1,11 @@
 export { ZephyrStrategy as FrameworkStrategy } from './strategy.js';
 export { ZephyrStrategy } from './strategy.js';
 export { Toolchain } from './toolchain/index.js';
+export { bossacTouchReset } from './toolchain/bossac-touch.js';
 export { writeProjectDebugArtifacts } from './toolchain/debug-config.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 { setActiveChip, getActiveChip, NO_BOARD_CHIP, } from './chips/index.js';
 export type { ZephyrChipDescriptor, ZephyrGpioDtSpec, } from './chips/types.js';
+export { syncBoardCatalog, ensureFreshBoardCatalog, loadBoardCatalogOverlay, resetBoardCatalogOverlayCache, } from './sdk/board-catalog-sync.js';
+export type { BoardCatalogSyncReport, BoardCatalogEnsureResult, BoardCatalogOverlay, } from './sdk/board-catalog-sync.js';

package/dist/index.js

@@ -8,6 +8,7 @@
 export { ZephyrStrategy as FrameworkStrategy } from './strategy.js';
 export { ZephyrStrategy } from './strategy.js';
 export { Toolchain } from './toolchain/index.js';
+export { bossacTouchReset } from './toolchain/bossac-touch.js';
 // Create-time starter debug artifacts. The `cuttlefish create` flow reads this
 // optional named export off the loaded framework module (same loader pattern
 // as doctor/licenses) and calls it for freshly scaffolded projects, so F5 in
@@ -23,5 +24,10 @@ export { runDoctor as doctor } from './doctor.js';
 // 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';
+// Chip descriptor cache (the lowering's resolved-board view; no curated
+// registry — every board reconstructs from its generated manifest).
+export { setActiveChip, getActiveChip, NO_BOARD_CHIP, } from './chips/index.js';
+// Board catalog sync — regenerate the local board overlay from the user's
+// own Zephyr tree (`cuttlefish board sync`), so board add/change/remove
+// tracks `west update` instead of cuttlefish releases.
+export { syncBoardCatalog, ensureFreshBoardCatalog, loadBoardCatalogOverlay, resetBoardCatalogOverlayCache, } from './sdk/board-catalog-sync.js';

package/dist/lowering/adc.d.ts

@@ -1,7 +1,25 @@
 import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
 import type { ZephyrChipDescriptor } from '../chips/types.js';
-/** Resolve the SAADC channel index for a HAL pin number; -1 if unmapped. */
+/**
+ * Resolve the SAADC channel index for an adc.read argument; -1 if unmapped.
+ *
+ * The numeric argument serves two HAL forms: `InputPin.readAnalog()` passes
+ * a GPIO number, while the Arduino-compat `ADC.read(channel)` passes an ADC
+ * channel number. Pin-first resolution keeps readAnalog behavior unchanged;
+ * the channel fallback makes `ADC.read(n)` resolve on targets where channel
+ * n does not alias GPIO n (e.g. the XIAO's AIN2 = P0.28). Where a number
+ * matches both a mapped pin and another channel's index, the pin wins.
+ */
 export declare function adcChannelForPin(chip: ZephyrChipDescriptor, pin: number): number;
+/**
+ * Resolve the owning ADC controller's node label for an adc.read argument.
+ * Defaults to the descriptor's primary (`chip.adc.nodeLabel`) — channels on
+ * additional controllers (STM32 adc3-only routes, ESP32 adc2 pads) carry
+ * their controller explicitly, and their device handle is
+ * `__tc_adc_<label>_dev` (the primary keeps the unsuffixed `__tc_adc_dev`
+ * so single-controller output is unchanged).
+ */
+export declare function adcControllerForPin(chip: ZephyrChipDescriptor, pin: number): string;
 /**
  * Emit the per-channel ADC setup state. One block per channel in the chip
  * descriptor that the PROGRAM ACTUALLY READS (`usedPins`) — an unread
@@ -11,7 +29,7 @@ export declare function adcChannelForPin(chip: ZephyrChipDescriptor, pin: number
  * `static bool __tc_adc<N>_ready` so the first read configures it and
  * subsequent reads skip. Called from shimLines when the program uses ADC.
  */
-export declare function adcInitLines(chip: ZephyrChipDescriptor, usedPins?: ReadonlySet<number>): string[];
+export declare function adcInitLines(chip: ZephyrChipDescriptor, usedPins?: ReadonlySet<number>, overrideDevices?: ReadonlySet<string>): string[];
 /**
  * Resolve a HAL adc.* op to Zephyr C++.
  * Returns `{ code }` for statement ops, `{ expression }` for value-returning ops.