@typecad/framework-zephyr 1.0.0-alpha.13 → 1.0.0-alpha.15

package/src/toolchain/west-spawn.ts

@@ -16,7 +16,8 @@
 // ---------------------------------------------------------------------------
 
 import type { SpawnSyncOptions } from 'node:child_process';
-import { dirname } from 'node:path';
+import { dirname, join } from 'node:path';
+import { existsSync } from 'node:fs';
 import { type WestInstall, discoverWest } from './west-discover.js';
 
 export interface WestInvocation {
@@ -57,8 +58,19 @@ export function buildEnv(install: WestInstall): NodeJS.ProcessEnv {
   if (install.zephyrBase && !env.ZEPHYR_BASE) {
     env.ZEPHYR_BASE = install.zephyrBase;
   }
-  const bin = venvBinDir(install);
-  if (bin) {
+  // SWD flashing (`zephyr.runner: 'openocd'`): west's openocd runner resolves
+  // a bare `openocd` from PATH. The Zephyr SDK ships it under
+  // hosttools/openocd/bin (the SDK's own setup.cmd puts that dir on PATH for
+  // activated terminals) — do the same for spawned west processes so ST-Link
+  // flashing works without activation. $ZEPHYR_SDK_INSTALL_DIR (set by an
+  // activated env) wins over the discovered install dir.
+  const sdkRoot = env.ZEPHYR_SDK_INSTALL_DIR || install.sdkInstallDir;
+  const openocdBin = sdkRoot ? join(sdkRoot, 'hosttools', 'openocd', 'bin') : undefined;
+  const prepend = [
+    openocdBin !== undefined && existsSync(openocdBin) ? openocdBin : undefined,
+    venvBinDir(install),
+  ].filter((d): d is string => d !== undefined);
+  if (prepend.length > 0) {
     const sep = process.platform === 'win32' ? ';' : ':';
     // On Windows the PATH environment variable may be cased as `Path` (the
     // registry-native form, the only one populated when node is launched from
@@ -66,9 +78,9 @@ export function buildEnv(install: WestInstall): NodeJS.ProcessEnv {
     // casing can leave the other stale/empty, which under PowerShell would drop
     // the user's real PATH (cmake, ninja, …) — breaking `west` configure. Read
     // whichever casing is populated and write that same casing back, preserving
-    // the full existing value with the venv dir prepended.
+    // the full existing value with the discovered dirs prepended.
     const existing = env.Path ?? env.PATH ?? '';
-    const updated = bin + sep + existing;
+    const updated = prepend.join(sep) + sep + existing;
     if (env.Path !== undefined || (env.PATH === undefined && process.platform === 'win32')) {
       env.Path = updated;
     } else {

package/src/async/timer-polyfill.ts

@@ -1,107 +0,0 @@
-// ---------------------------------------------------------------------------
-// Timer methods polyfill — Zephyr k_timer + k_work (heap-free)
-//
-// setInterval / setTimeout / clearInterval / clearTimeout backed by a fixed
-// pool of k_timer + k_work pairs. The timer's expiry function (ISR context)
-// submits a k_work item to the system workqueue; the work handler runs the
-// user callback in thread context. This split keeps the ISR cheap and lets the
-// callback run on a real thread (so it can do real work — but must not block,
-// since the system workqueue is shared).
-//
-// EMIT BOUNDARY: emitted bytes land in user firmware. Covered by the TypeCAD
-// Runtime Exception (RUNTIME_EXCEPTION.md at the repo root).
-// ---------------------------------------------------------------------------
-
-import type { RuntimePolyfillIR } from '@typecad/cuttlefish/api/shared';
-
-const MIN_TIMERS = 1;
-const MAX_TIMERS_CAP = 16;
-
-export interface TimerPolyfillIR extends RuntimePolyfillIR {
-  /** The clamped pool size the C++ was generated with. */
-  maxTimers: number;
-}
-
-/**
- * Build the timer_methods polyfill IR. `requestedTimers` is sized from
- * ctx.analysis.timerCallCount; it is clamped to [1, 16].
- */
-export function buildTimerPolyfill(requestedTimers: number): TimerPolyfillIR {
-  const maxTimers = Math.min(MAX_TIMERS_CAP, Math.max(MIN_TIMERS, requestedTimers));
-
-  const helperStructs = [`
-// cuttlefish timer runtime — k_timer + k_work pool (heap-free).
-struct __tc_TimerSlot {
-    struct k_timer timer;
-    struct k_work work;
-    void (*callback)(void);
-    bool active;
-};
-
-static struct __tc_TimerSlot __tc_timer_slots[${maxTimers}];
-
-static void __tc_timer_work_handler(struct k_work* w) {
-    // Runs on the system workqueue thread (NOT ISR). Find the owning slot by
-    // address and invoke the callback. Must not block.
-    for (int32_t i = 0; i < ${maxTimers}; i++) {
-        if (&__tc_timer_slots[i].work == w) {
-            if (__tc_timer_slots[i].callback != nullptr) { __tc_timer_slots[i].callback(); }
-            return;
-        }
-    }
-}
-
-static void __tc_timer_expiry_fn(struct k_timer* t) {
-    // ISR context: submit the work item, do NOT run the callback here.
-    for (int32_t i = 0; i < ${maxTimers}; i++) {
-        if (&__tc_timer_slots[i].timer == t) {
-            (void)k_work_submit(&__tc_timer_slots[i].work);
-            return;
-        }
-    }
-}
-
-static int32_t __tc_timer_add(void (*cb)(void), int32_t ms, bool repeat) {
-    for (int32_t i = 0; i < ${maxTimers}; i++) {
-        if (!__tc_timer_slots[i].active) {
-            __tc_timer_slots[i].callback = cb;
-            __tc_timer_slots[i].active = true;
-            k_timer_init(&__tc_timer_slots[i].timer, __tc_timer_expiry_fn, nullptr);
-            k_work_init(&__tc_timer_slots[i].work, __tc_timer_work_handler);
-            k_timer_start(&__tc_timer_slots[i].timer, K_MSEC(ms), repeat ? K_MSEC(ms) : K_FOREVER);
-            return i + 1;  // 1-based id (Arduino parity)
-        }
-    }
-    return 0;  // pool full
-}
-
-static void __tc_timer_clear(int32_t id) {
-    if (id > 0 && id <= ${maxTimers}) {
-        int32_t i = id - 1;
-        k_timer_stop(&__tc_timer_slots[i].timer);
-        __tc_timer_slots[i].active = false;
-        __tc_timer_slots[i].callback = nullptr;
-    }
-}
-`];
-
-  const helperFunctions = [`
-int32_t __tc_setInterval(void (*cb)(), int32_t ms) { return __tc_timer_add(cb, ms, true); }
-int32_t __tc_setTimeout(void (*cb)(), int32_t ms) { return __tc_timer_add(cb, ms, false); }
-void __tc_clearInterval(int32_t id) { __tc_timer_clear(id); }
-void __tc_clearTimeout(int32_t id) { __tc_timer_clear(id); }
-`];
-
-  return {
-    kind: 'polyfill',
-    id: 'timer_methods',
-    domain: 'embedded',
-    requiredIncludes: [],
-    forwardDeclarations: [],
-    helperStructs,
-    helperFunctions,
-    shimMacros: [],
-    dependencies: [],
-    maxTimers,
-  };
-}

package/src/chips/esp32.ts

@@ -1,74 +0,0 @@
-// ---------------------------------------------------------------------------
-// Espressif ESP32 (esp32_devkitc) — Zephyr board descriptor
-//
-// Board target: `esp32_devkitc` (mainline Zephyr,
-// boards/espressif/esp32_devkitc). Programmed over USB via the esptool runner
-// (see toolchain/index.ts), the same flash path as the ESP32-S3.
-//
-// GPIO is split across TWO devicetree controllers — `gpio0` (pins 0–31) and
-// `gpio1` (pins 32–39) — so this descriptor lists both in `gpioControllers`.
-// The lowering routes each HAL pin to its owning controller at runtime; see
-// chips/controllers.ts. (Same shape as the S3, but the ESP32's highest GPIO is
-// 39, not 48 — `gpio1` has ngpios=8, not 17.)
-//
-// Minimal-by-design: the only DT facts carried here are the ones a compile-time
-// DT macro cannot reach — the runtime pin→controller split, plus the `sw0`
-// alias for the BOOT button (used by the devicetree-spec GPIO path). Every other
-// DT fact (UART/I2C/SPI/`wdt` nodelabels) is resolved by Zephyr's own
-// devicetree via emitted DT_NODELABEL macros, not hand-copied here.
-//
-// Verified against the Zephyr board DTS:
-//   boards/espressif/esp32_devkitc/esp32_devkitc_procpu.dts
-//   aliases { sw0 = &button0; } → button_0: pin 0 on gpio0, active-low + pull-up
-//   &gpio0/&gpio1 { status = "okay" }   (esp32_devkitc_procpu.dts:64-70)
-//   &wifi { status = "okay" }            (esp32_devkitc_procpu.dts:143-145)
-// GPIO controller coverage:
-//   dts/xtensa/espressif/esp32/esp32_common.dtsi:314-337
-//   gpio0: ngpios = <32>  (pins 0–31)
-//   gpio1: ngpios = <8>   (pins 32–39)
-//
-// Note: GPIO 34–39 are input-only pads on ESP32 silicon (not modeled here —
-// the DT does not encode output restrictions per pin; an output config on those
-// pins fails at runtime against the raw controller, which is the expected
-// silicon-accurate behavior).
-// ---------------------------------------------------------------------------
-
-import type { ZephyrChipDescriptor } from './types.js';
-
-export const ESP32_DEVKITC: ZephyrChipDescriptor = {
-  id: 'esp32_devkitc',
-  soc: 'esp32',
-  gpioController: 'gpio0',
-  gpioControllers: [
-    { nodelabel: 'gpio0', minPin: 0, maxPin: 31 },
-    { nodelabel: 'gpio1', minPin: 32, maxPin: 39 },
-  ],
-  gpio: {
-    // The BOOT button (GPIO0) is the board's only DT-aliased GPIO. Listed so a
-    // program reading/interrupting pin 0 goes through the polarity-correct
-    // devicetree-spec path (GPIO_ACTIVE_LOW honored by the DT flags).
-    dtSpecs: [
-      { pin: 0, dtSpec: 'sw0' },  // BOOT button (GPIO0)
-    ],
-    interruptPins: [
-      { pin: 0, dtSpec: 'sw0' },  // BOOT button (GPIO0)
-    ],
-  },
-  // WiFi: the ESP32 has a 2.4GHz radio; conn_mgr + the esp32 wifi driver
-  // (CONFIG_WIFI_ESP32) provide connectivity. WIFI_ESP32 depends on !SMP, and
-  // 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/src/chips/esp32s3.ts

@@ -1,57 +0,0 @@
-// ---------------------------------------------------------------------------
-// Espressif ESP32-S3 (esp32s3_devkitc) — Zephyr board descriptor
-//
-// Board target: `esp32s3_devkitc` (mainline Zephyr,
-// boards/espressif/esp32s3_devkitc). Programmed over USB via the esptool
-// runner (see toolchain/index.ts), unlike the J-Link/nrfjprog path used for
-// the XIAO nRF52840.
-//
-// GPIO is split across TWO devicetree controllers — `gpio0` (pins 0–31) and
-// `gpio1` (pins 32–48) — so this descriptor lists both in `gpioControllers`.
-// The lowering routes each HAL pin to its owning controller at runtime; see
-// chips/controllers.ts.
-//
-// Minimal-by-design: the only DT facts carried here are the ones a
-// compile-time DT macro cannot reach — the runtime pin→controller split, plus
-// the `sw0` alias for the BOOT button (used by the devicetree-spec GPIO path).
-// Every other DT fact (UART/I2C/SPI/`wdt` nodelabels) is resolved by Zephyr's
-// own devicetree via emitted DT_NODELABEL macros, not hand-copied here.
-//
-// Verified against the Zephyr board DTS:
-//   boards/espressif/esp32s3_devkitc/esp32s3_devkitc_procpu.dts
-//   aliases { sw0 = &button0; } → button_0: pin 0 on gpio0, active-low + pull-up
-//   (the DevKitC board DTS defines no led0 alias — the onboard RGB is a WS2812
-//   on GPIO38, not a plain GPIO LED, so it is intentionally NOT listed here.)
-// ---------------------------------------------------------------------------
-
-import type { ZephyrChipDescriptor } from './types.js';
-
-export const ESP32S3_DEVKITC: ZephyrChipDescriptor = {
-  id: 'esp32s3_devkitc',
-  soc: 'esp32s3',
-  gpioController: 'gpio0',
-  gpioControllers: [
-    { nodelabel: 'gpio0', minPin: 0, maxPin: 31 },
-    { nodelabel: 'gpio1', minPin: 32, maxPin: 48 },
-  ],
-  gpio: {
-    // The BOOT button (GPIO0) is the board's only DT-aliased GPIO. Listed so a
-    // program reading/interrupting pin 0 goes through the polarity-correct
-    // devicetree-spec path (GPIO_ACTIVE_LOW honored by the DT flags). Every
-    // other GPIO pin uses the raw-controller path against its owning controller.
-    dtSpecs: [
-      { pin: 0, dtSpec: 'sw0' },  // BOOT button (GPIO0)
-    ],
-    interruptPins: [
-      { pin: 0, dtSpec: 'sw0' },  // BOOT button (GPIO0)
-    ],
-  },
-  // UART/I2C/SPI/`wdt` are intentionally omitted: their devicetree nodelabels
-  // (uart0/uart1/uart2, i2c0/i2c1, spi2/spi3, wdt0) are resolved by Zephyr's
-  // devicetree at compile time and don't need to be carried as data here. ADC is
-  // omitted as well — added when a demo needs analog reads, with the verified
-  // ESP32-S3 ADC1/ADC2 pin→channel map.
-  // 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 },
-};

package/src/chips/xiao-ble.ts

@@ -1,70 +0,0 @@
-// ---------------------------------------------------------------------------
-// Seeed Studio XIAO nRF52840 — Zephyr board descriptor
-//
-// Board target: `xiao_ble` (mainline Zephyr, boards/seeed/xiao_ble).
-// The onboard user LED is active-low and exposed as the DT alias `led0`.
-// ---------------------------------------------------------------------------
-
-import type { ZephyrChipDescriptor } from './types.js';
-
-export const XIAO_BLE: ZephyrChipDescriptor = {
-  id: 'xiao_ble',
-  soc: 'nrf52840',
-  gpioController: 'gpio0',
-  gpio: {
-    dtSpecs: [
-      // Onboard RGB LEDs — active-low (GPIO_ACTIVE_LOW in xiao_ble_common.dtsi).
-      // Verified against the board's `aliases { led0 = &led0; led1 = &led1; led2 = &led2; }`.
-      { pin: 26, dtSpec: 'led0' },  // Red   (P0.26)
-      { pin: 30, dtSpec: 'led1' },  // Green (P0.30)
-      { pin: 6, dtSpec: 'led2' },   // Blue  (P0.06)
-    ],
-    // The XIAO nRF52840 has a user button on P0.04, but mainline Zephyr's
-    // xiao_ble board (verified against Zephyr 4.3.99) does NOT expose it as a
-    // DT `sw0` alias — there is no gpio-keys node in xiao_ble.dts. Emitting
-    // GPIO_DT_SPEC_GET(DT_ALIAS(sw0), gpios) therefore fails to compile
-    // ('DT_N_ALIAS_sw0_... was not declared'). Until a button node + alias is
-    // added (via an overlay or an upstream board update), interruptPins stays
-    // empty: attachInterrupt on this board lowers to the no-DT-spec comment
-    // fallback rather than a hard compile error.
-    interruptPins: [],
-  },
-  // The XIAO connector wiring (from seeed_xiao_connector.dtsi + xiao_ble-pinctrl.dtsi):
-  //   xiao_i2c     → i2c1  (SDA P0.04/D4, SCL P0.05/D5)
-  //   xiao_spi     → spi2  (SCK P1.13/D8, MOSI P1.15/D10, MISO P1.14/D9)
-  //   xiao_serial  → uart0 (TX P1.11/D6, RX P1.12/D7)
-  // The board DTS leaves i2c0/spi0/spi1 disabled (shared instances).
-  i2c: {
-    controllers: [{ nodeLabel: 'i2c1' }],
-  },
-  spi: {
-    controllers: [{ nodeLabel: 'spi2' }],
-  },
-  uart: {
-    controllers: [{ nodeLabel: 'uart0' }],
-  },
-  pwm: {
-    // pwm-led0 drives the board PWM LED (PWM_OUT0 on P0.17, inverted).
-    specs: [{ pin: 17, dtSpec: 'pwm-led0' }],
-  },
-  adc: {
-    // SAADC node is `adc`; no pre-declared channels. XIAO D0–D3 = AIN0–AIN3
-    // (P0.02/P0.03/P0.28/P0.29). Internal VREF ~0.6V with VDD/4 gain ⇒ 3000mV.
-    nodeLabel: 'adc',
-    resolution: 12,
-    vrefMv: 3000,
-    channels: [
-      { pin: 2, channel: 0 },   // P0.02 / D0 / AIN0
-      { pin: 3, channel: 1 },   // P0.03 / D1 / AIN1
-      { pin: 28, channel: 2 },  // P0.28 / D2 / AIN2
-      { pin: 29, channel: 3 },  // P0.29 / D3 / AIN3
-    ],
-  },
-  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/src/lowering/power.ts

@@ -1,70 +0,0 @@
-// ---------------------------------------------------------------------------
-// Power lowering — Zephyr power management
-//
-// Zephyr enters low-power states from the idle thread per policy. The app-facing
-// controls are pm_state_force (override policy to force a state on next idle)
-// and k_sleep (block the calling thread, allowing the system to idle into a
-// low-power state). "Deep sleep" maps to k_sleep (the SoC picks its deepest
-// allowed state); "light sleep" best-effort forces SUSPEND_TO_IDLE.
-//
-// deep_sleep_pin configures the wake GPIO as an interrupt source then k_sleeps
-// (the interrupt wakes the SoC). CPU frequency is SoC-specific (nRF52 has a
-// fixed 64 MHz HFXO with no portable dynamic scaling) and stays a documented
-// no-op. deep_sleep_pin targets gpio0 (single-controller nRF52840 case);
-// multi-controller SoC routing is a documented follow-on.
-// ---------------------------------------------------------------------------
-
-import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
-
-/**
- * Resolve a HAL power.* op to Zephyr C++.
- * Returns `{ code }` for statement ops, `{ expression }` for value-returning ops.
- */
-export function lowerPower(op: HALOpIR): { code?: string; expression?: string } {
-  const o = op as any;
-
-  switch (op.operation) {
-    case 'power.deep_sleep':
-      // Block for the requested duration; the idle thread + PM policy will enter
-      // the deepest state the SoC allows during the sleep.
-      return { code: `k_sleep(K_MSEC(${o.ms}));` };
-    case 'power.light_sleep':
-      // Best-effort: force a shallow suspend on the next idle. pm_state_force
-      // requires a pm_state_info; SUSPEND_TO_IDLE is a common shallow state.
-      return { code: `pm_state_force(0, &(const struct pm_state_info){ .state = PM_STATE_SUSPEND_TO_IDLE, .substate_id = 0 });` };
-    case 'power.set_cpu_frequency':
-      // nRF52 has a fixed 64 MHz HFXO; no portable dynamic scaling from C++.
-      // Documented no-op (best-effort), matching Arduino's approach.
-      return { code: `/* power.set_cpu_frequency(${o.mhz}): nRF52 fixed 64 MHz HFXO — no portable scaling */` };
-    case 'power.deep_sleep_pin': {
-      // Configure the pin as a GPIO wake source (level interrupt), then k_sleep
-      // until the interrupt fires. A static gpio_callback + a no-op handler (the
-      // wake just needs the interrupt enabled; the handler does nothing). level:
-      // 1=high, 0=low. Targets gpio0 (single-controller nRF52840); multi-
-      // controller SoC routing is a documented follow-on.
-      const pin = o.pin;
-      const level = o.level;
-      const flags = level ? 'GPIO_INT_LEVEL_HIGH' : 'GPIO_INT_LEVEL_LOW';
-      return {
-        code: [
-          '{',
-          `    static struct gpio_callback __tc_wake_cb;`,
-          `    const struct device* __dev = DEVICE_DT_GET(DT_NODELABEL(gpio0));`,
-          `    gpio_pin_configure(__dev, ${pin}, GPIO_INPUT);`,
-          `    gpio_init_callback(&__tc_wake_cb, [](const struct device*, struct gpio_callback*, gpio_port_pins_t) { (void)0; }, BIT(${pin}));`,
-          `    gpio_add_callback(__dev, &__tc_wake_cb);`,
-          `    gpio_pin_interrupt_configure(__dev, ${pin}, ${flags});`,
-          `    k_sleep(K_FOREVER);`,
-          `    gpio_pin_interrupt_configure(__dev, ${pin}, GPIO_INT_DISABLE);`,
-          `    gpio_remove_callback(__dev, &__tc_wake_cb);`,
-          '}',
-        ].join(' '),
-      };
-    }
-    default:
-      throw new Error(
-        `framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +
-          `Open an issue or use rawCpp() to emit it manually.`,
-      );
-  }
-}

package/src/lowering/pulse.ts

@@ -1,93 +0,0 @@
-// ---------------------------------------------------------------------------
-// Pulse + shift lowering — bit-bang via GPIO + timing
-//
-// pulse.in measures the duration of a pulse (HIGH or LOW) on a GPIO pin by
-// edge-polling with k_uptime_get. shift.out/in bit-bang a byte through a data
-// + clock pin pair using gpio_pin_set + k_busy_wait. These are software
-// implementations (no hardware pulse capture on nRF for the HAL surface); they
-// are correct but not high-precision.
-// ---------------------------------------------------------------------------
-
-import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
-import type { ZephyrChipDescriptor } from '../chips/types.js';
-import { controllerNodelabelForPin } from '../chips/controllers.js';
-
-/** `DEVICE_DT_GET(DT_NODELABEL(<owning-controller>))` for a HAL pin. */
-function devForPin(chip: ZephyrChipDescriptor, pin: number): string {
-  return `DEVICE_DT_GET(DT_NODELABEL(${controllerNodelabelForPin(chip, pin)}))`;
-}
-
-/** Resolve a HAL pulse.* or shift.* op to Zephyr C++ (bit-bang). */
-export function lowerPulseOrShift(
-  op: HALOpIR,
-  chip: ZephyrChipDescriptor,
-): { code?: string; expression?: string } {
-  const o = op as any;
-
-  switch (op.operation) {
-    case 'pulse.in': {
-      // Wait for the pin to reach `value`, then measure until it changes.
-      // Edge-poll with k_uptime_get() (ms granularity — coarse but correct,
-      // and 64-bit so it cannot wrap mid-measurement over ~49 days). The wait
-      // for the start edge is bounded by the timeout; the measurement of the
-      // pulse itself is intentionally unbounded (that IS the pulse length).
-      // Returns -1 (0) if the start edge never arrives within the timeout.
-      const pin = o.pin;
-      const want = o.value;
-      const dev = devForPin(chip, pin);
-      const timeout = o.timeout ?? 1_000_000; // default 1s in us
-      return {
-        expression: `({ int64_t __max = static_cast<int64_t>(${timeout} / 1000); int64_t __t0 = k_uptime_get(); bool __ok = true; while (gpio_pin_get_raw(${dev}, ${pin}) != ${want}) { if ((k_uptime_get() - __t0) > __max) { __ok = false; break; } } int32_t __ret = 0; if (__ok) { int64_t __start = k_uptime_get(); while (gpio_pin_get_raw(${dev}, ${pin}) == ${want}) { } __ret = static_cast<int32_t>((k_uptime_get() - __start) * 1000); } __ret; })`,
-      };
-    }
-    case 'pulse.in_long': {
-      // Same as pulse.in but for long pulses. Previously this spun forever
-      // with NO timeout (the comment claimed "no overflow concern" but the
-      // real risk was hanging the thread on a stuck pin). Apply the same
-      // timeout-bounded start-edge wait as pulse.in (bug Q5).
-      const pin = o.pin;
-      const want = o.value;
-      const dev = devForPin(chip, pin);
-      const timeout = o.timeout ?? 3_000_000; // default 3s in us (long pulses)
-      return {
-        expression: `({ int64_t __max = static_cast<int64_t>(${timeout} / 1000); int64_t __t0 = k_uptime_get(); bool __ok = true; while (gpio_pin_get_raw(${dev}, ${pin}) != ${want}) { if ((k_uptime_get() - __t0) > __max) { __ok = false; break; } } int32_t __ret = 0; if (__ok) { int64_t __start = k_uptime_get(); while (gpio_pin_get_raw(${dev}, ${pin}) == ${want}) { } __ret = static_cast<int32_t>((k_uptime_get() - __start) * 1000); } __ret; })`,
-      };
-    }
-    case 'shift.out': {
-      // Bit-bang `value` (MSB or LSB first) via dataPin + clockPin. The two
-      // pins may sit on different GPIO controllers on multi-controller SoCs
-      // (ESP32-S3), so each is resolved to its own owning controller.
-      const dataPin = o.dataPin;
-      const clockPin = o.clockPin;
-      const dataDev = devForPin(chip, dataPin);
-      const clockDev = devForPin(chip, clockPin);
-      const msbFirst = o.bitOrder === 'msb';
-      const init = msbFirst ? '7' : '0';
-      const test = msbFirst ? '(__i >= 0)' : '(__i < 8)';
-      const step = msbFirst ? '__i--' : '__i++';
-      return {
-        code: `for (int __i = ${init}; ${test}; ${step}) { gpio_pin_set_raw(${dataDev}, ${dataPin}, (${o.value} >> __i) & 1); gpio_pin_set_raw(${clockDev}, ${clockPin}, 1); k_busy_wait(1); gpio_pin_set_raw(${clockDev}, ${clockPin}, 0); }`,
-      };
-    }
-    case 'shift.in': {
-      // Read 8 bits (MSB or LSB first) from dataPin, clocking on clockPin.
-      const dataPin = o.dataPin;
-      const clockPin = o.clockPin;
-      const dataDev = devForPin(chip, dataPin);
-      const clockDev = devForPin(chip, clockPin);
-      const msbFirst = o.bitOrder === 'msb';
-      const init = msbFirst ? '7' : '0';
-      const test = msbFirst ? '(__i >= 0)' : '(__i < 8)';
-      const step = msbFirst ? '__i--' : '__i++';
-      const accum = msbFirst ? '__v = (__v << 1)' : '__v |= (bit << __i)';
-      return {
-        expression: `({ uint8_t __v = 0; for (int __i = ${init}; ${test}; ${step}) { gpio_pin_set_raw(${clockDev}, ${clockPin}, 1); k_busy_wait(1); int bit = gpio_pin_get_raw(${dataDev}, ${dataPin}); gpio_pin_set_raw(${clockDev}, ${clockPin}, 0); ${accum}; } __v; })`,
-      };
-    }
-    default:
-      throw new Error(
-        `framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +
-          `Open an issue or use rawCpp() to emit it manually.`,
-      );
-  }
-}

package/src/lowering/tone.ts

@@ -1,60 +0,0 @@
-// ---------------------------------------------------------------------------
-// Tone lowering — PWM-based square-wave generation
-//
-// tone is a convenience wrapper around PWM: a square wave at `frequency` Hz with
-// a 50% duty cycle. The lowering maps frequency → period (ns) and sets the PWM
-// channel to a 50% pulse. stop turns the output off (0% duty). The PWM spec is
-// resolved from the chip descriptor (pwm-led0 on the XIAO).
-//
-// An optional duration is honored by scheduling a stop via k_sleep in a detached
-// fashion — but the simple lowering is blocking (k_msleep(duration) then stop),
-// matching the synchronous Arduino tone() semantics. For non-blocking tone,
-// a workqueue would be needed (deferred).
-// ---------------------------------------------------------------------------
-
-import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
-import type { ZephyrChipDescriptor } from '../chips/types.js';
-import { lowerPwm } from './pwm.js';
-
-/**
- * Resolve a HAL tone.* op to Zephyr C++ via PWM.
- * Returns `{ code }` for statement ops, `{ expression }` for value-returning ops.
- */
-export function lowerTone(
-  op: HALOpIR,
-  chip: ZephyrChipDescriptor,
-): { code?: string; expression?: string } {
-  const o = op as any;
-
-  switch (op.operation) {
-    case 'tone.play': {
-      // period_ns = 1e9 / freq; pulse_ns = period / 2 (50% duty).
-      // Build a fake pwm.write would need the spec var directly; emit the
-      // pwm_set_dt call against the same spec var the PWM lowering uses.
-      const spec = chip.pwm?.specs[0];
-      if (!spec) {
-        return { code: `/* tone.play(${o.frequency}): no PWM spec in chip descriptor */` };
-      }
-      const v = `__tc_pwm_${spec.dtSpec.replace(/-/g, '_')}`;
-      const freq = o.frequency;
-      const duration = o.duration;
-      const setTone = `uint32_t __period = (${freq} > 0) ? (1000000000ULL / static_cast<uint64_t>(${freq})) : 0; pwm_set_dt(&${v}, __period, __period / 2);`;
-      if (duration !== undefined) {
-        // Blocking tone for the requested duration, then stop.
-        return { code: `${setTone} k_msleep(${duration}); pwm_set_pulse_dt(&${v}, 0);` };
-      }
-      return { code: setTone };
-    }
-    case 'tone.stop': {
-      const spec = chip.pwm?.specs[0];
-      if (!spec) return { code: `/* tone.stop: no PWM spec */` };
-      const v = `__tc_pwm_${spec.dtSpec.replace(/-/g, '_')}`;
-      return { code: `pwm_set_pulse_dt(&${v}, 0);` };
-    }
-    default:
-      throw new Error(
-        `framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +
-          `Open an issue or use rawCpp() to emit it manually.`,
-      );
-  }
-}