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

package/dist/lowering/adc.js

@@ -18,19 +18,30 @@ export function adcChannelForPin(chip, pin) {
 }
 /**
  * Emit the per-channel ADC setup state. One block per channel in the chip
- * descriptor, each guarded by a `static bool __tc_adc<N>_ready` so the first
- * read configures it and subsequent reads skip. Called from shimLines when
- * the program uses ADC.
+ * descriptor that the PROGRAM ACTUALLY READS (`usedPins`) — an unread
+ * channel's `static` setup function would trip -Wunused-function in the
+ * single generated TU. When `usedPins` is omitted (probe paths with no
+ * program), every descriptor channel is emitted. Each block is guarded by a
+ * `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 function adcInitLines(chip) {
+export function adcInitLines(chip, usedPins) {
     const dev = `DEVICE_DT_GET(DT_NODELABEL(${chip.adc?.nodeLabel ?? 'adc'}))`;
     const res = chip.adc?.resolution ?? 12;
     const vref = chip.adc?.vrefMv ?? 3000;
+    // Gain/reference are SoC-specific: the nRF SAADC scheme (gain 1/4 against
+    // the 0.6V internal ref, vref-mv 3000 = VDD) is the default; the STM32
+    // driver requires exactly ADC_GAIN_1 + ADC_REF_INTERNAL (Zephyr maps
+    // "internal" to the VREF+ pad) with vref-mv = VDDA. The descriptor carries
+    // the SoC's pair so the emitted channel setup validates in the driver.
+    const gain = chip.adc?.gain ?? 'ADC_GAIN_1_4';
+    const reference = chip.adc?.reference ?? 'ADC_REF_INTERNAL';
+    const channels = (chip.adc?.channels ?? []).filter((c) => !usedPins || usedPins.has(c.pin));
     const lines = ['// CUTTLEFISH_ADC_BEGIN'];
     lines.push(`static const struct device* __tc_adc_dev = ${dev};`);
-    for (const c of chip.adc?.channels ?? []) {
+    for (const c of channels) {
         const n = c.channel;
-        lines.push(`static bool __tc_adc${n}_ready = false;`, `static void __tc_adc${n}_setup(void) {`, `    if (__tc_adc${n}_ready) return;`, `    const struct adc_channel_cfg cfg = {`, `        .gain = ADC_GAIN_1_4,`, `        .reference = ADC_REF_INTERNAL,`, `        .acquisition_time = ADC_ACQ_TIME_DEFAULT,`, `        .channel_id = ${n},`, `        .differential = 0,`, `    };`, `    adc_channel_setup(__tc_adc_dev, &cfg);`, `    __tc_adc${n}_ready = true;`, `}`);
+        lines.push(`static bool __tc_adc${n}_ready = false;`, `static void __tc_adc${n}_setup(void) {`, `    if (__tc_adc${n}_ready) return;`, `    const struct adc_channel_cfg cfg = {`, `        .gain = ${gain},`, `        .reference = ${reference},`, `        .acquisition_time = ADC_ACQ_TIME_DEFAULT,`, `        .channel_id = ${n},`, `        .differential = 0,`, `    };`, `    adc_channel_setup(__tc_adc_dev, &cfg);`, `    __tc_adc${n}_ready = true;`, `}`);
     }
     lines.push(`#define __TC_ADC_VREF_MV ${vref}`);
     lines.push(`#define __TC_ADC_RESOLUTION ${res}`);
@@ -45,6 +56,8 @@ export function lowerAdc(op, chip) {
     const o = op;
     const res = chip.adc?.resolution ?? 12;
     const vref = chip.adc?.vrefMv ?? 3000;
+    const gain = chip.adc?.gain ?? 'ADC_GAIN_1_4';
+    const reference = chip.adc?.reference ?? 'ADC_REF_INTERNAL';
     switch (op.operation) {
         case 'adc.read': {
             const ch = adcChannelForPin(chip, o.pin);
@@ -55,10 +68,11 @@ export function lowerAdc(op, chip) {
         }
         case 'adc.read_voltage': {
             const ch = adcChannelForPin(chip, o.pin);
-            // Read raw, convert to millivolts via adc_raw_to_millivolts (gain 1/4,
-            // internal ref). Returns mV as int.
+            // Read raw, convert to millivolts via adc_raw_to_millivolts with the
+            // descriptor's gain (raw_to_millivolts divides out the gain the channel
+            // was set up with). Returns mV as int.
             return {
-                expression: `({ __tc_adc${ch}_setup(); int16_t __b = 0; struct adc_sequence __s = { .channels = BIT(${ch}), .buffer = &__b, .buffer_size = sizeof(__b), .resolution = ${res} }; adc_read(__tc_adc_dev, &__s); int32_t __v = __b; adc_raw_to_millivolts(${vref}, ADC_GAIN_1_4, ${res}, &__v); __v; })`,
+                expression: `({ __tc_adc${ch}_setup(); int16_t __b = 0; struct adc_sequence __s = { .channels = BIT(${ch}), .buffer = &__b, .buffer_size = sizeof(__b), .resolution = ${res} }; adc_read(__tc_adc_dev, &__s); int32_t __v = __b; adc_raw_to_millivolts(${vref}, ${gain}, ${res}, &__v); __v; })`,
             };
         }
         case 'adc.get_resolution':
@@ -66,9 +80,9 @@ export function lowerAdc(op, chip) {
         case 'adc.set_reference':
             // Zephyr configures the reference at channel-setup time; runtime switching
             // would require re-setup. Record the intent as a no-op statement.
-            return { code: `/* adc.set_reference(${o.reference}): configured at channel setup (ADC_REF_INTERNAL) */` };
+            return { code: `/* adc.set_reference(${o.reference}): configured at channel setup (${reference}) */` };
         case 'adc.get_reference':
-            return { expression: `0 /* DEFAULT (ADC_REF_INTERNAL) */` };
+            return { expression: `0 /* DEFAULT (${reference}) */` };
         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/dist/lowering/gpio.js

@@ -14,7 +14,7 @@
 //     The manifest validator's probe (which sends {operation, pin:0} with no
 //     port) hits this path, so it must return a lowered result, not undefined.
 // ---------------------------------------------------------------------------
-import { controllerNodelabelForPin } from '../chips/controllers.js';
+import { controllerNodelabelForPin, controllerRawPinForPin } from '../chips/controllers.js';
 /** The C identifier emitted for a pin's gpio_dt_spec variable. */
 export function dtSpecVarName(dtSpec) {
     return `__tc_dt_${dtSpec}`;
@@ -99,19 +99,22 @@ function lowerGpioRaw(op, chip) {
     const o = op;
     const pin = o.pin;
     // Resolve the owning controller by pin range (ESP32-S3 splits GPIO across
-    // gpio0/gpio1). For single-controller SoCs this is just chip.gpioController.
+    // gpio0/gpio1; STM32 across gpioa/gpiob/gpioc). For single-controller SoCs
+    // this is just chip.gpioController. The raw API takes the PORT-RELATIVE
+    // index (STM32 gpiob is 0-15), not the global HAL pin number.
     const controller = `DEVICE_DT_GET(DT_NODELABEL(${controllerNodelabelForPin(chip, pin)}))`;
+    const rawPin = controllerRawPinForPin(chip, pin);
     switch (op.operation) {
         case 'gpio.set_mode': {
-            return { code: `gpio_pin_configure(${controller}, ${pin}, ${flagsForMode(o.mode)});` };
+            return { code: `gpio_pin_configure(${controller}, ${rawPin}, ${flagsForMode(o.mode)});` };
         }
         case 'gpio.write': {
             const v = o.value;
             const rhs = typeof v === 'string' ? `((${v}) ? 1 : 0)` : v ? 1 : 0;
-            return { code: `gpio_pin_set_raw(${controller}, ${pin}, ${rhs});` };
+            return { code: `gpio_pin_set_raw(${controller}, ${rawPin}, ${rhs});` };
         }
         case 'gpio.read':
-            return { expression: `gpio_pin_get_raw(${controller}, ${pin})` };
+            return { expression: `gpio_pin_get_raw(${controller}, ${rawPin})` };
         case 'gpio.toggle':
             // Native atomic toggle — never read-modify-write. gpio_pin_get_raw on
             // a direction-only output reads the input latch, which is undefined on
@@ -119,7 +122,7 @@ function lowerGpioRaw(op, chip) {
             // gpio_pin_toggle is the driver-level atomic toggle, and for pins
             // configured without GPIO_ACTIVE_LOW the logical level equals the
             // physical one, so it matches the get_raw/set_raw used elsewhere.
-            return { code: `gpio_pin_toggle(${controller}, ${pin});` };
+            return { code: `gpio_pin_toggle(${controller}, ${rawPin});` };
         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/dist/lowering/mqtt.js

@@ -290,7 +290,15 @@ export function mqttInitLines() {
         `    (void)k_thread_create(&__tc_mqtt.poll_thread, __tc_mqtt_stack,`,
         `                          K_THREAD_STACK_SIZEOF(__tc_mqtt_stack),`,
         `                          __tc_mqtt_poll_thread, nullptr, nullptr, nullptr,`,
-        `                          5, 0, K_NO_WAIT);`,
+        `                          5, 0, K_FOREVER);`,
+        `#ifdef CONFIG_SMP`,
+        `    // On SMP targets park the poll thread on the app core so the network`,
+        `    // stack never competes with the main/UI thread for core 0. k_thread_cpu_pin`,
+        `    // is SMP-only; the pin happens before k_thread_start (which is why the`,
+        `    // thread is created K_FOREVER). Compiles away on !SMP builds.`,
+        `    (void)k_thread_cpu_pin(&__tc_mqtt.poll_thread, 1);`,
+        `#endif`,
+        `    k_thread_start(&__tc_mqtt.poll_thread);`,
         `}`,
         ``,
         `static inline void __tc_mqtt_set_on_message(__tc_mqtt_msg_cb_t fn) {`,

package/dist/lowering/pulse.js

@@ -7,7 +7,7 @@
 // implementations (no hardware pulse capture on nRF for the HAL surface); they
 // are correct but not high-precision.
 // ---------------------------------------------------------------------------
-import { controllerNodelabelForPin } from '../chips/controllers.js';
+import { controllerNodelabelForPin, controllerRawPinForPin } from '../chips/controllers.js';
 /** `DEVICE_DT_GET(DT_NODELABEL(<owning-controller>))` for a HAL pin. */
 function devForPin(chip, pin) {
     return `DEVICE_DT_GET(DT_NODELABEL(${controllerNodelabelForPin(chip, pin)}))`;
@@ -23,9 +23,9 @@ export function lowerPulseOrShift(op, chip) {
             // 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 pin = controllerRawPinForPin(chip, o.pin);
             const want = o.value;
-            const dev = devForPin(chip, pin);
+            const dev = devForPin(chip, o.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; })`,
@@ -36,9 +36,9 @@ export function lowerPulseOrShift(op, chip) {
             // 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 pin = controllerRawPinForPin(chip, o.pin);
             const want = o.value;
-            const dev = devForPin(chip, pin);
+            const dev = devForPin(chip, o.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; })`,
@@ -57,7 +57,7 @@ export function lowerPulseOrShift(op, chip) {
             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); }`,
+                code: `for (int __i = ${init}; ${test}; ${step}) { gpio_pin_set_raw(${dataDev}, ${controllerRawPinForPin(chip, dataPin)}, (${o.value} >> __i) & 1); gpio_pin_set_raw(${clockDev}, ${controllerRawPinForPin(chip, clockPin)}, 1); k_busy_wait(1); gpio_pin_set_raw(${clockDev}, ${controllerRawPinForPin(chip, clockPin)}, 0); }`,
             };
         }
         case 'shift.in': {
@@ -72,7 +72,7 @@ export function lowerPulseOrShift(op, chip) {
             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; })`,
+                expression: `({ uint8_t __v = 0; for (int __i = ${init}; ${test}; ${step}) { gpio_pin_set_raw(${clockDev}, ${controllerRawPinForPin(chip, clockPin)}, 1); k_busy_wait(1); int bit = gpio_pin_get_raw(${dataDev}, ${controllerRawPinForPin(chip, dataPin)}); gpio_pin_set_raw(${clockDev}, ${controllerRawPinForPin(chip, clockPin)}, 0); ${accum}; } __v; })`,
             };
         }
         default:

package/dist/lowering/pwm.d.ts

@@ -1,10 +1,28 @@
 import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
-import type { ZephyrChipDescriptor } from '../chips/types.js';
+import type { ZephyrChipDescriptor, ZephyrPwmSpec } from '../chips/types.js';
+/**
+ * The DT alias a PWM spec is addressed by. Board-shipped specs carry their
+ * alias in `dtSpec`; synthesized specs (controller + channel) get a
+ * `tc-pwm<pin>` alias that the overlay generator creates in
+ * <board>.overlay — both sides derive the name from the pin so they agree.
+ */
+export declare function pwmDtAlias(spec: ZephyrPwmSpec): string;
+/**
+ * The C macro token for a spec's alias. Zephyr's devicetree macros replace
+ * dashes in alias names with underscores (`pwm-led0` in DTS is
+ * DT_ALIAS(pwm_led0) in C) — the dashed spelling is a subtraction
+ * expression and fails to compile (caught by the blackpill E2E west build).
+ */
+export declare function pwmDtAliasToken(spec: ZephyrPwmSpec): string;
 /**
  * Emit the per-channel PWM spec declarations. One per spec in the chip
- * descriptor. Called from shimLines when the program uses PWM.
+ * descriptor that the PROGRAM ACTUALLY DRIVES (`usedPins`) — a spec for an
+ * untouched pin is unused code in the emitted TU (and would need a dead DT
+ * alias in the overlay). When `usedPins` is omitted (probe paths with no
+ * program), every spec is emitted. Called from shimLines when the program
+ * uses PWM.
  */
-export declare function pwmInitLines(chip: ZephyrChipDescriptor): string[];
+export declare function pwmInitLines(chip: ZephyrChipDescriptor, usedPins?: ReadonlySet<number>): string[];
 /**
  * Resolve a HAL pwm.* op to Zephyr C++.
  * Returns `{ code }` for statement ops, `{ expression }` for value-returning ops.

package/dist/lowering/pwm.js

@@ -6,22 +6,46 @@
 // `pwm_set_pulse_dt` / `pwm_set_dt`. Duty is scaled from the Arduino-style
 // 0–255 (or 0–1023) range to nanoseconds against the spec's period.
 // ---------------------------------------------------------------------------
+/**
+ * The DT alias a PWM spec is addressed by. Board-shipped specs carry their
+ * alias in `dtSpec`; synthesized specs (controller + channel) get a
+ * `tc-pwm<pin>` alias that the overlay generator creates in
+ * <board>.overlay — both sides derive the name from the pin so they agree.
+ */
+export function pwmDtAlias(spec) {
+    return spec.dtSpec ?? `tc-pwm${spec.pin}`;
+}
+/**
+ * The C macro token for a spec's alias. Zephyr's devicetree macros replace
+ * dashes in alias names with underscores (`pwm-led0` in DTS is
+ * DT_ALIAS(pwm_led0) in C) — the dashed spelling is a subtraction
+ * expression and fails to compile (caught by the blackpill E2E west build).
+ */
+export function pwmDtAliasToken(spec) {
+    return pwmDtAlias(spec).replace(/-/g, '_');
+}
 /** Look up a PWM spec by HAL pin number. */
 function findPwmSpec(chip, pin) {
     return chip.pwm?.specs.find((s) => s.pin === pin);
 }
 /** The C variable name emitted for a PWM channel's spec. */
 function pwmVarName(spec) {
-    return `__tc_pwm_${spec.dtSpec.replace(/-/g, '_')}`;
+    return `__tc_pwm_${pwmDtAliasToken(spec)}`;
 }
 /**
  * Emit the per-channel PWM spec declarations. One per spec in the chip
- * descriptor. Called from shimLines when the program uses PWM.
+ * descriptor that the PROGRAM ACTUALLY DRIVES (`usedPins`) — a spec for an
+ * untouched pin is unused code in the emitted TU (and would need a dead DT
+ * alias in the overlay). When `usedPins` is omitted (probe paths with no
+ * program), every spec is emitted. Called from shimLines when the program
+ * uses PWM.
  */
-export function pwmInitLines(chip) {
+export function pwmInitLines(chip, usedPins) {
     const lines = ['// CUTTLEFISH_PWM_BEGIN'];
     for (const spec of chip.pwm?.specs ?? []) {
-        lines.push(`static const struct pwm_dt_spec ${pwmVarName(spec)} = PWM_DT_SPEC_GET(DT_ALIAS(${spec.dtSpec}));`);
+        if (usedPins && !usedPins.has(spec.pin))
+            continue;
+        lines.push(`static const struct pwm_dt_spec ${pwmVarName(spec)} = PWM_DT_SPEC_GET(DT_ALIAS(${pwmDtAliasToken(spec)}));`);
     }
     lines.push('// CUTTLEFISH_PWM_END');
     return lines;

package/dist/lowering/spi.js

@@ -12,7 +12,7 @@
 // DEVICE_DT_GET(DT_NODELABEL(spi2)) and call spi_transceive directly.
 // ---------------------------------------------------------------------------
 import { parseControllerIndex } from './util.js';
-import { controllerNodelabelForPin } from '../chips/controllers.js';
+import { controllerNodelabelForPin, controllerRawPinForPin } from '../chips/controllers.js';
 /** The C variable prefix for a controller's state. */
 function prefix(idx) {
     return `__tc_spi${idx}`;
@@ -103,7 +103,7 @@ export function lowerSpi(op, chip) {
             const val = op.operation === 'spi.cs_low' ? 0 : 1;
             const gpioController = controllerNodelabelForPin(chip, o.pin);
             return {
-                code: `gpio_pin_set_raw(DEVICE_DT_GET(DT_NODELABEL(${gpioController})), ${o.pin}, ${val});`,
+                code: `gpio_pin_set_raw(DEVICE_DT_GET(DT_NODELABEL(${gpioController})), ${controllerRawPinForPin(chip, o.pin)}, ${val});`,
             };
         }
         default:

package/dist/lowering/tone.js

@@ -11,6 +11,7 @@
 // matching the synchronous Arduino tone() semantics. For non-blocking tone,
 // a workqueue would be needed (deferred).
 // ---------------------------------------------------------------------------
+import { pwmDtAliasToken } from './pwm.js';
 /**
  * Resolve a HAL tone.* op to Zephyr C++ via PWM.
  * Returns `{ code }` for statement ops, `{ expression }` for value-returning ops.
@@ -26,7 +27,7 @@ export function lowerTone(op, chip) {
             if (!spec) {
                 return { code: `/* tone.play(${o.frequency}): no PWM spec in chip descriptor */` };
             }
-            const v = `__tc_pwm_${spec.dtSpec.replace(/-/g, '_')}`;
+            const v = `__tc_pwm_${pwmDtAliasToken(spec)}`;
             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);`;
@@ -40,7 +41,7 @@ export function lowerTone(op, chip) {
             const spec = chip.pwm?.specs[0];
             if (!spec)
                 return { code: `/* tone.stop: no PWM spec */` };
-            const v = `__tc_pwm_${spec.dtSpec.replace(/-/g, '_')}`;
+            const v = `__tc_pwm_${pwmDtAliasToken(spec)}`;
             return { code: `pwm_set_pulse_dt(&${v}, 0);` };
         }
         default:

package/dist/lowering/wifi.js

@@ -122,6 +122,29 @@ export function wifiInitLines() {
         `    }`,
         `    __tc_wifi.inited = true;`,
         `}`,
+        ``,
+        `// ── blocking-wait pump ───────────────────────────────────────────────────`,
+        `// Blocking wifi waits hold the main thread, which suspends the loop()-driven`,
+        `// ui_tick — a 15s association would freeze the display for its whole`,
+        `// duration. Each wait slice sleeps 20ms and, in the entry TU of a UI build`,
+        `// (the only TU carrying the ui_tick definition), pumps one frame so`,
+        `// animations and touch stay live during the wait. Constraint: do NOT call`,
+        `// blocking wifi waits from inside UI event handlers — that re-enters`,
+        `// ui_tick mid-tick; use wifi.connect_start + wifi.is_connected there.`,
+        `#ifdef CUTTLEFISH_ENTRY_UI_TU`,
+        `static void ui_tick(uint16_t deltaMs);   // defined by the UI runtime header`,
+        `#endif`,
+        `static void __tc_wifi_wait_slice(uint32_t slice_ms) {`,
+        `    k_msleep(slice_ms);`,
+        `#ifdef CUTTLEFISH_ENTRY_UI_TU`,
+        `    static uint32_t last_ms = 0U;`,
+        `    uint32_t now_ms = k_uptime_get_32();`,
+        `    uint32_t delta = (last_ms != 0U) ? (now_ms - last_ms) : 0U;`,
+        `    if (delta > 250U) delta = 250U;   // same clamp as the loop() tick injection`,
+        `    last_ms = now_ms;`,
+        `    ui_tick(static_cast<uint16_t>(delta));`,
+        `#endif`,
+        `}`,
         `// CUTTLEFISH_WIFI_CORE_END`,
         ``,
         `// ── connect / disconnect (net_mgmt — conn_mgr monitor supplies L4 events) ─`,
@@ -176,8 +199,9 @@ export function wifiInitLines() {
         `static void __tc_wifi_connect(const char* ssid, const char* password, int32_t timeout_ms) {`,
         `    __tc_wifi_connect_start(ssid, password);`,
         `    // Block until the L4 handler signals connectivity or the deadline passes.`,
+        `    // 20ms slices let __tc_wifi_wait_slice pump the UI between polls.`,
         `    int32_t waited = 0;`,
-        `    while (!__tc_wifi.connected && waited < timeout_ms) { k_msleep(100); waited += 100; }`,
+        `    while (!__tc_wifi.connected && waited < timeout_ms) { __tc_wifi_wait_slice(20); waited += 20; }`,
         `    printk("tc-wifi: connect %s after %dms\\n", __tc_wifi.connected ? "ok" : "timeout", waited);`,
         `}`,
         `// CUTTLEFISH_WIFI_CONNECT_BLOCKING_END`,
@@ -241,7 +265,7 @@ export function wifiInitLines() {
         ``,
         `static void __tc_wifi_scan_blocking(void) {`,
         `    __tc_wifi_scan_start();`,
-        `    while (__tc_wifi.scanning) { k_msleep(100); }`,
+        `    while (__tc_wifi.scanning) { __tc_wifi_wait_slice(20); }`,
         `}`,
         ``,
         `static const char* __tc_wifi_scan_ssid(int32_t i) {`,
@@ -309,13 +333,12 @@ export function wifiInitLines() {
         `static void __tc_wifi_wait_connected(int32_t timeout_ms) {`,
         `    __tc_wifi_ensure_init();`,
         `    int32_t waited = 0;`,
-        `    while (!__tc_wifi.connected && waited < timeout_ms) { k_msleep(100); waited += 100; }`,
+        `    while (!__tc_wifi.connected && waited < timeout_ms) { __tc_wifi_wait_slice(20); waited += 20; }`,
         `}`,
-        ``,
         `static void __tc_wifi_wait_disconnected(void) {`,
         `    __tc_wifi_ensure_init();`,
         `    // No timeout in the HAL surface — block until the L4 handler clears the flag.`,
-        `    while (__tc_wifi.connected) { k_msleep(100); }`,
+        `    while (__tc_wifi.connected) { __tc_wifi_wait_slice(20); }`,
         `}`,
         ``,
         `// ── AP mode (NET_REQUEST_WIFI_AP_ENABLE / DISABLE) ──────────────────────`,

package/dist/strategy.js

@@ -21,6 +21,58 @@ import { entryHasUI } from '@typecad/cuttlefish/ui-hook';
 import { chipForTarget, setActiveChip } from './chips/index.js';
 import { resolveChipFromBoard } from './chips/resolve.js';
 import { emitGpioDevDispatcher } from './chips/controllers.js';
+/**
+ * Deep-walk the program IR and collect the HAL pin numbers the program
+ * actually touches for a peripheral family ('adc' | 'pwm') — the same walk
+ * profileDiagnostics does. Emit paths gate per-channel state on these sets
+ * so nothing unused reaches the single generated TU (-Wunused-function
+ * hygiene: every emitted function/variable is referenced). `undefined`
+ * (no program — probe paths) means "no information": callers emit every
+ * descriptor channel, preserving probe behavior.
+ *
+ * `pwm` also covers tone.* — the tone lowering drives the descriptor's
+ * first PWM spec regardless of pin, so any tone op marks it used.
+ */
+function collectUsedPins(program, kind, chip) {
+    if (!program)
+        return undefined;
+    const pins = new Set();
+    let usesTone = false;
+    const visit = (node) => {
+        if (!node || typeof node !== 'object')
+            return;
+        const n = node;
+        const op = n.operation;
+        if (op && typeof op === 'object') {
+            const o = op;
+            const name = o.operation;
+            const pin = o.pin;
+            if (typeof name === 'string' && typeof pin === 'number') {
+                if (kind === 'adc' && (name === 'adc.read' || name === 'adc.read_voltage'))
+                    pins.add(pin);
+                if (kind === 'pwm' && name.startsWith('pwm.'))
+                    pins.add(pin);
+            }
+            if (kind === 'pwm' && typeof name === 'string' && name.startsWith('tone.'))
+                usesTone = true;
+        }
+        for (const v of Object.values(n)) {
+            if (Array.isArray(v)) {
+                for (const item of v)
+                    visit(item);
+            }
+            else if (v && typeof v === 'object')
+                visit(v);
+        }
+    };
+    visit(program);
+    if (kind === 'pwm' && usesTone) {
+        const first = chip?.pwm?.specs[0];
+        if (first)
+            pins.add(first.pin);
+    }
+    return pins;
+}
 import { lowerHalOp } from './lowering/index.js';
 import { buildZephyrWorkerBacking } from './lowering/worker-backing.js';
 import { adcInitLines } from './lowering/adc.js';
@@ -407,9 +459,9 @@ export class ZephyrStrategy {
                 guardBody.push(...uartInitLines(chip, i));
         }
         if (uses('usesADC') && chip.adc)
-            guardBody.push(...adcInitLines(chip));
+            guardBody.push(...adcInitLines(chip, collectUsedPins(program, 'adc')));
         if (uses('usesPWM') && chip.pwm)
-            guardBody.push(...pwmInitLines(chip));
+            guardBody.push(...pwmInitLines(chip, collectUsedPins(program, 'pwm', chip)));
         if (uses('usesDAC') && chip.dac)
             guardBody.push(...dacInitLines(chip));
         if (uses('usesHwtimer') && chip.hwtimer)
@@ -521,12 +573,12 @@ export class ZephyrStrategy {
         // still compile-time-resolved per branch, so it is always statically valid.
         if (this.needsGpioReadShim(program, ctx)) {
             lines.push(...emitGpioDevDispatcher(chip));
-            lines.push('inline int __tc_gpio_read(int pin) { return gpio_pin_get_raw(__tc_gpio_dev(static_cast<uint32_t>(pin)), static_cast<gpio_pin_t>(pin)); }');
+            lines.push('inline int __tc_gpio_read(int pin) { return gpio_pin_get_raw(__tc_gpio_dev(static_cast<uint32_t>(pin)), __tc_gpio_pin(static_cast<uint32_t>(pin))); }');
         }
         // __tc_gpio_write / __tc_delay_us are only referenced via @typecad/safety
         // lowering, so they stay gated on it.
         if (program && programUsesSafety(program)) {
-            lines.push('inline void __tc_gpio_write(uint32_t pin, uint32_t value) { gpio_pin_set_raw(__tc_gpio_dev(pin), pin, value); }', '#ifndef __TC_DELAY_US_DEFINED', '#define __TC_DELAY_US_DEFINED', 'inline void __tc_delay_us(uint32_t us) { k_busy_wait(us); }', '#endif');
+            lines.push('inline void __tc_gpio_write(uint32_t pin, uint32_t value) { gpio_pin_set_raw(__tc_gpio_dev(pin), __tc_gpio_pin(pin), value); }', '#ifndef __TC_DELAY_US_DEFINED', '#define __TC_DELAY_US_DEFINED', 'inline void __tc_delay_us(uint32_t us) { k_busy_wait(us); }', '#endif');
         }
         return lines;
     }

package/dist/toolchain/debug-config.js

@@ -431,7 +431,7 @@ export function writeDebugConfig(o) {
  * the CLI resolves output.outDir against the ENTRY's directory (cli.ts), so
  * the emitted app root — and therefore the ELF, build dir, and .cuttlefish/
  * debug artifacts — always lands at `src/out`. Keep in sync with
- * generateProjectConfig in @typecad/cuttlefish create/init-templates.ts.
+ * generateProjectConfig in @typecad/cuttlefish create/templates.ts.
  */
 const STARTER_SKETCH_REL = 'src/out';
 /**

package/dist/toolchain/index.d.ts

@@ -26,7 +26,7 @@ export declare function projectRootFromOptions(o: ToolchainOptions): string;
  * Exported (pure) so the runner-selection contract is unit-testable without
  * spawning west.
  */
-export declare function buildFlashArgs(buildDir: string, board: string, userRunner: string | undefined, port: string | undefined): string[];
+export declare function buildFlashArgs(buildDir: string, board: string, userRunner: string | undefined, port: string | undefined, runnerArgs?: readonly string[]): string[];
 /**
  * Classify a `west flash` result as success/failure.
  *