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

package/dist/lowering/hwtimer.d.ts

@@ -13,3 +13,7 @@ export declare function lowerHwtimer(op: HALOpIR, chip: ZephyrChipDescriptor): {
     code?: string;
     expression?: string;
 };
+export declare function lowerCounter(op: HALOpIR, chip: ZephyrChipDescriptor): {
+    code?: string;
+    expression?: string;
+};

package/dist/lowering/hwtimer.js

@@ -26,6 +26,10 @@ function hzVar(instance) {
 function cbVar(instance) {
     return `__tc_hw_cb_${instance}`;
 }
+/** The trampoline matching counter_top_callback_t: (dev, user_data). */
+function trampVar(instance) {
+    return `__tc_hw_tramp_${instance}`;
+}
 /**
  * Emit the per-instance counter device handles + frequency/callback state.
  * Called from shimLines when the program uses hardware timers.
@@ -36,7 +40,7 @@ export function hwtimerInitLines(chip) {
         return [];
     const lines = ['// CUTTLEFISH_HWTIMER_BEGIN'];
     controllers.forEach((c, i) => {
-        lines.push(`static const struct device* ${devVar(i)} = DEVICE_DT_GET(DT_NODELABEL(${c.nodeLabel}));`, `static uint32_t ${hzVar(i)} = 1;`, `static counter_top_callback_t ${cbVar(i)} = NULL;`);
+        lines.push(`static const struct device* ${devVar(i)} = DEVICE_DT_GET(DT_NODELABEL(${c.nodeLabel}));`, `static uint32_t ${hzVar(i)} = 1;`, `static void (*${cbVar(i)})(void) = NULL;`, `static void ${trampVar(i)}(const struct device* dev, void* user_data) {`, `    (void)dev; (void)user_data;`, `    if (${cbVar(i)}) { ${cbVar(i)}(); }`, `}`);
     });
     lines.push('// CUTTLEFISH_HWTIMER_END');
     return lines;
@@ -57,25 +61,46 @@ export function lowerHwtimer(op, chip) {
         return { code: `/* hwtimer instance ${o.instance}: out of range on ${chip.id} */` };
     }
     switch (op.operation) {
-        case 'hwtimer.set_frequency':
-            return { code: `${hzVar(instance)} = ${o.hz};` };
-        case 'hwtimer.on_overflow':
+        default:
+            throw new Error(`framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +
+                `Open an issue or use rawCpp() to emit it manually.`);
+    }
+}
+export function lowerCounter(op, chip) {
+    const o = op;
+    const controllers = chip.hwtimer?.controllers ?? [];
+    if (controllers.length === 0) {
+        return { code: `/* ${op.operation}: no counter device on ${chip.id} */` };
+    }
+    const instance = typeof o.instance === 'number' ? o.instance : parseInt(String(o.instance), 10);
+    if (isNaN(instance) || instance < 0 || instance >= controllers.length) {
+        return { code: `/* counter instance ${o.instance}: out of range on ${chip.id} (${controllers.length} declared) */` };
+    }
+    switch (op.operation) {
+        case 'counter.on_alarm':
             return { code: `${cbVar(instance)} = (${o.handler});` };
-        case 'hwtimer.start':
-            // Arm the top value (counter_freq / desired_hz) + the overflow callback,
-            // then start the counter. Doing both here handles any call order — the
-            // HAL typical sequence (setFrequency → onOverflow → start) and permutations.
+        case 'counter.start': {
+            // Apply the construction hz as the top value, arm the alarm callback,
+            // start. hz rides the op, so no ordering constraint exists. The API
+            // is counter_set_top_value(dev, const counter_top_cfg*) with a
+            // (dev, user_data) callback — the trampoline in hwtimerInitLines
+            // adapts the user's void() handler.
             return {
                 code: [
                     `{`,
+                    `  ${hzVar(instance)} = ${o.hz};`,
                     `  uint32_t __f = counter_get_frequency(${devVar(instance)});`,
                     `  uint32_t __top = __f ? (__f / ${hzVar(instance)}) : 0U;`,
-                    `  if (__top > 0U) { (void)counter_set_top_value(${devVar(instance)}, __top, ${cbVar(instance)}, NULL); }`,
+                    `  if (__top > 0U) {`,
+                    `    struct counter_top_cfg __cfg = { .ticks = __top, .callback = ${trampVar(instance)}, .user_data = NULL, .flags = 0U };`,
+                    `    (void)counter_set_top_value(${devVar(instance)}, &__cfg);`,
+                    `  }`,
                     `  (void)counter_start(${devVar(instance)});`,
                     `}`,
                 ].join(' '),
             };
-        case 'hwtimer.stop':
+        }
+        case 'counter.stop':
             return { code: `(void)counter_stop(${devVar(instance)});` };
         default:
             throw new Error(`framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +

package/dist/lowering/i2c.js

@@ -11,8 +11,6 @@
 // The device handle resolves at compile time via DEVICE_DT_GET(DT_NODELABEL(...)).
 // ---------------------------------------------------------------------------
 import { parseControllerIndex } from './util.js';
-const TXBUF_SIZE = 32;
-const RXBUF_SIZE = 32;
 /** The C variable prefix for a controller's state. */
 function prefix(idx) {
     return `__tc_i2c${idx}`;
@@ -29,12 +27,6 @@ export function i2cInitLines(chip, controllerIndex) {
     return [
         '// CUTTLEFISH_I2C_BEGIN',
         `static const struct device* ${p}_dev = DEVICE_DT_GET(DT_NODELABEL(${ctrl.nodeLabel}));`,
-        `static uint16_t ${p}_addr = 0xFFFF;`,
-        `static uint8_t ${p}_txbuf[${TXBUF_SIZE}];`,
-        `static size_t ${p}_txlen = 0;`,
-        `static uint8_t ${p}_rxbuf[${RXBUF_SIZE}];`,
-        `static size_t ${p}_rxlen = 0;`,
-        `static size_t ${p}_rxpos = 0;`,
         '// CUTTLEFISH_I2C_END',
     ];
 }
@@ -48,6 +40,26 @@ function speedForHz(hz) {
         return 'I2C_SPEED_FAST_PLUS';
     return 'I2C_SPEED_HIGH';
 }
+/**
+ * The (void) comma expression begin/end lower to — a no-op that references
+ * the controller's whole state block (device + transaction buffers) so a
+ * program calling only begin() stays -Werror clean (-Wunused-variable).
+ */
+function i2cKeepAlive(p) {
+    return `(void)${p}_dev;`;
+}
+/** The thin-device bus-speed preamble: apply the construction hz once
+ *  (i2c_configure with Zephyr's I2C_SPEED_SET tier mapping), or '' when the
+ *  target constructed without hz. Guarded per controller, so the cost after
+ *  the first op is one bool test. */
+function i2cSpeedGuard(p, hz) {
+    const n = typeof hz === 'number' ? hz : parseInt(String(hz ?? 0), 10);
+    if (!n || isNaN(n))
+        return '';
+    const speed = speedForHz(n);
+    const done = `${p}_spd_done`;
+    return `{ static bool ${done} = false; if (!${done}) { (void)i2c_configure(${p}_dev, I2C_SPEED_SET(${speed})); ${done} = true; } } `;
+}
 /**
  * Resolve a HAL i2c.* op to Zephyr C++.
  * Returns `{ code }` for statement ops, `{ expression }` for value-returning ops.
@@ -57,56 +69,36 @@ export function lowerI2c(op, chip) {
     const idx = parseControllerIndex(o.bus);
     const p = prefix(idx);
     switch (op.operation) {
-        case 'i2c.begin':
-            // Zephyr resolves the device at compile time; begin is a no-op (device
-            // ready check is folded into the driver calls).
-            return { code: `(void)${p}_dev;` };
-        case 'i2c.end':
-            return { code: `(void)${p}_dev;` };
-        case 'i2c.set_clock': {
-            const hz = typeof o.hz === 'number' ? o.hz : parseInt(String(o.hz), 10);
-            const speed = isNaN(hz) ? 'I2C_SPEED_STANDARD' : speedForHz(hz || 100000);
-            return { code: `i2c_configure(${p}_dev, I2C_SPEED_SET(${speed}));` };
+        // ── Thin I2C device (hal/i2c-target.ts) — Zephyr register verbs ──────
+        // One call per op against the controller device handle; the optional
+        // construction hz applies once via a guarded i2c_configure (the same
+        // call i2c.set_clock lowers to).
+        case 'i2c.reg_write': {
+            const pre = i2cSpeedGuard(p, o.hz);
+            return { code: `${pre} i2c_reg_write_byte(${p}_dev, static_cast<uint16_t>(${o.address}), static_cast<uint8_t>(${o.reg}), static_cast<uint8_t>(${o.value}));` };
         }
-        case 'i2c.begin_transmission':
-            // Record the target address + reset the pending write buffer.
-            return { code: `${p}_addr = static_cast<uint16_t>(${o.address}); ${p}_txlen = 0;` };
-        case 'i2c.write':
-            // Append one byte (clamped to capacity).
-            return { code: `if (${p}_txlen < ${TXBUF_SIZE}) { ${p}_txbuf[${p}_txlen++] = static_cast<uint8_t>(${o.data}); }` };
-        case 'i2c.write_bytes': {
-            const bytes = o.bytes ?? [];
-            const stmts = bytes.map((b) => `if (${p}_txlen < ${TXBUF_SIZE}) { ${p}_txbuf[${p}_txlen++] = static_cast<uint8_t>(${b}); }`);
-            return { code: stmts.join(' ') };
-        }
-        case 'i2c.write_buffer': {
-            // Copy from a user buffer (its name is o.data), clamped to capacity.
-            return {
-                code: `for (size_t __i = 0; __i < sizeof(${o.data}) && ${p}_txlen < ${TXBUF_SIZE}; __i++) { ${p}_txbuf[${p}_txlen++] = reinterpret_cast<const uint8_t*>(${o.data})[__i]; }`,
-            };
+        case 'i2c.reg_read': {
+            const pre = i2cSpeedGuard(p, o.hz);
+            return { expression: `({ ${pre} uint8_t __v = 0; (void)i2c_reg_read_byte(${p}_dev, static_cast<uint16_t>(${o.address}), static_cast<uint8_t>(${o.reg}), &__v); __v; })` };
         }
-        case 'i2c.end_transmission':
-            // Flush the accumulated txbuf to the cached address.
-            return { code: `i2c_write(${p}_dev, ${p}_txbuf, ${p}_txlen, ${p}_addr);` };
-        case 'i2c.request_from': {
-            const qty = o.quantity;
-            return {
-                code: `i2c_read(${p}_dev, ${p}_rxbuf, static_cast<uint32_t>(${qty}), static_cast<uint16_t>(${o.address})); ${p}_rxlen = ${qty}; ${p}_rxpos = 0;`,
-            };
+        case 'i2c.reg_update': {
+            const pre = i2cSpeedGuard(p, o.hz);
+            return { code: `${pre} (void)i2c_reg_update_byte(${p}_dev, static_cast<uint16_t>(${o.address}), static_cast<uint8_t>(${o.reg}), static_cast<uint8_t>(${o.mask}), static_cast<uint8_t>(${o.value}));` };
         }
-        case 'i2c.available':
-            return { expression: `(${p}_rxlen - ${p}_rxpos)` };
-        case 'i2c.read':
-            return { expression: `(${p}_rxpos < ${p}_rxlen ? ${p}_rxbuf[${p}_rxpos++] : -1)` };
-        case 'i2c.read_buffer': {
-            // Read straight into the user's buffer (o.buffer), count bytes.
-            const count = o.count;
-            return {
-                code: `i2c_read(${p}_dev, reinterpret_cast<uint8_t*>(${o.buffer}), static_cast<uint32_t>(${count}), ${p}_addr);`,
-            };
+        case 'i2c.dev_write': {
+            const pre = i2cSpeedGuard(p, o.hz);
+            const bytes = o.bytes ?? [];
+            // Identifier-shaped only — a single-byte literal array arrives as
+            // numeric text ("159") and must take the literal path.
+            const isBuffer = bytes.length === 1 && typeof bytes[0] === 'string' && /^[A-Za-z_][A-Za-z0-9_]*$/.test(bytes[0]);
+            if (isBuffer) {
+                const name = bytes[0];
+                // A named user buffer: i2c_write against its storage directly.
+                return { code: `${pre} (void)i2c_write(${p}_dev, reinterpret_cast<const uint8_t*>(${name}), sizeof(${name}), static_cast<uint16_t>(${o.address}));` };
+            }
+            const arr = `static const uint8_t __tc_i2cw[] = { ${bytes.join(', ')} };`;
+            return { code: `${pre} ${arr} (void)i2c_write(${p}_dev, __tc_i2cw, sizeof(__tc_i2cw), static_cast<uint16_t>(${o.address}));` };
         }
-        case 'i2c.recover':
-            return { code: `i2c_recover_bus(${p}_dev);` };
         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/index.d.ts

@@ -6,11 +6,9 @@ import { lowerPwm } from './pwm.js';
 import { lowerI2c } from './i2c.js';
 import { lowerSpi } from './spi.js';
 import { lowerUart } from './uart.js';
+import { lowerUsb } from './usb.js';
 import { lowerInterrupt } from './interrupts.js';
 import { lowerWdt } from './wdt.js';
-import { lowerPower } from './power.js';
-import { lowerTone } from './tone.js';
-import { lowerPulseOrShift } from './pulse.js';
 import { lowerBle } from './ble.js';
 import { lowerWifi } from './wifi.js';
 import { lowerHttp } from './http.js';
@@ -20,8 +18,10 @@ import { lowerBoard } from './board.js';
 import { lowerRandom } from './random.js';
 import { lowerDac } from './dac.js';
 import { lowerFs } from './fs.js';
-import { lowerHwtimer } from './hwtimer.js';
-export { lowerGpio, lowerTiming, lowerAdc, lowerPwm, lowerI2c, lowerSpi, lowerUart, lowerInterrupt, lowerWdt, lowerPower, lowerTone, lowerPulseOrShift, lowerBle, lowerWifi, lowerHttp, lowerMqtt, lowerPreferences, lowerBoard, lowerRandom, lowerDac, lowerFs, lowerHwtimer, };
+import { lowerSensor } from './sensor.js';
+import { lowerHwtimer, lowerCounter } from './hwtimer.js';
+import { lowerThread } from './thread.js';
+export { lowerGpio, lowerTiming, lowerAdc, lowerPwm, lowerI2c, lowerSpi, lowerUart, lowerUsb, lowerInterrupt, lowerWdt, lowerBle, lowerWifi, lowerHttp, lowerMqtt, lowerPreferences, lowerBoard, lowerRandom, lowerDac, lowerFs, lowerHwtimer, lowerCounter, lowerSensor, lowerThread, };
 /**
  * Lower a HAL op to Zephyr C++. Returns undefined for unsupported categories
  * (mirrors lowerHalOp in framework-esp32/src/lowering/index.ts).

package/dist/lowering/index.js

@@ -23,13 +23,10 @@ import { lowerPwm } from './pwm.js';
 import { lowerI2c } from './i2c.js';
 import { lowerSpi } from './spi.js';
 import { lowerUart } from './uart.js';
+import { lowerUsb } from './usb.js';
 import { lowerInterrupt } from './interrupts.js';
 import { lowerWdt } from './wdt.js';
-import { lowerPower } from './power.js';
-import { lowerTone } from './tone.js';
-import { lowerPulseOrShift } from './pulse.js';
 import { lowerBle } from './ble.js';
-import { lowerWorker } from './worker.js';
 import { lowerWifi } from './wifi.js';
 import { lowerHttp } from './http.js';
 import { lowerMqtt } from './mqtt.js';
@@ -38,8 +35,10 @@ import { lowerBoard } from './board.js';
 import { lowerRandom } from './random.js';
 import { lowerDac } from './dac.js';
 import { lowerFs } from './fs.js';
-import { lowerHwtimer } from './hwtimer.js';
-export { lowerGpio, lowerTiming, lowerAdc, lowerPwm, lowerI2c, lowerSpi, lowerUart, lowerInterrupt, lowerWdt, lowerPower, lowerTone, lowerPulseOrShift, lowerBle, lowerWifi, lowerHttp, lowerMqtt, lowerPreferences, lowerBoard, lowerRandom, lowerDac, lowerFs, lowerHwtimer, };
+import { lowerSensor } from './sensor.js';
+import { lowerHwtimer, lowerCounter } from './hwtimer.js';
+import { lowerThread } from './thread.js';
+export { lowerGpio, lowerTiming, lowerAdc, lowerPwm, lowerI2c, lowerSpi, lowerUart, lowerUsb, lowerInterrupt, lowerWdt, lowerBle, lowerWifi, lowerHttp, lowerMqtt, lowerPreferences, lowerBoard, lowerRandom, lowerDac, lowerFs, lowerHwtimer, lowerCounter, lowerSensor, lowerThread, };
 /**
  * Lower a HAL op to Zephyr C++. Returns undefined for unsupported categories
  * (mirrors lowerHalOp in framework-esp32/src/lowering/index.ts).
@@ -62,23 +61,19 @@ export function lowerHalOp(op) {
         return lowerSpi(op, chip);
     if (op.operation.startsWith('uart.'))
         return lowerUart(op);
+    if (op.operation.startsWith('usb.'))
+        return lowerUsb(op, chip);
     if (op.operation.startsWith('interrupt.'))
         return lowerInterrupt(op, chip);
     if (op.operation.startsWith('wdt.'))
-        return lowerWdt(op);
+        return lowerWdt(op, chip);
     if (op.operation.startsWith('hwtimer.'))
         return lowerHwtimer(op, chip);
-    if (op.operation.startsWith('power.'))
-        return lowerPower(op);
-    if (op.operation.startsWith('tone.'))
-        return lowerTone(op, chip);
-    // pulse.* and shift.* share a bit-bang lowering module.
-    if (op.operation.startsWith('pulse.') || op.operation.startsWith('shift.'))
-        return lowerPulseOrShift(op, chip);
+    if (op.operation.startsWith('counter.'))
+        return lowerCounter(op, chip);
+    // (legacy pulse/shift bit-bang module removed)
     if (op.operation.startsWith('ble.'))
         return lowerBle(op);
-    if (op.operation.startsWith('worker.'))
-        return lowerWorker(op);
     if (op.operation.startsWith('wifi.'))
         return lowerWifi(op);
     if (op.operation.startsWith('http.'))
@@ -95,6 +90,10 @@ export function lowerHalOp(op) {
         return lowerBoard(op);
     if (op.operation.startsWith('random.'))
         return lowerRandom(op);
+    if (op.operation.startsWith('sensor.'))
+        return lowerSensor(op);
+    if (op.operation.startsWith('thread.'))
+        return lowerThread(op);
     // raw / snprintf.emit / display.* / ... — not lowered by this
     // framework. Return undefined so the transpiler falls back and the manifest
     // validator confirms the unsupported declaration.

package/dist/lowering/interrupts.d.ts

@@ -1,19 +1,36 @@
 import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
 import type { ZephyrChipDescriptor } from '../chips/types.js';
+/** Map thin-GPIO INT token text to the GPIO_INT_* macro. */
+export declare function gpioIntTokenToMacro(intFlags: string): string;
 /**
  * Emit the per-pin interrupt callback state + trampolines. Called from shimLines
  * when the program uses interrupts. The trampoline calls a user function via a
  * function-pointer static, set at attach time.
+ *
+ * Two paths:
+ *  - descriptor `gpio.interruptPins` (buttons with DT specs): callback state
+ *    against the DT spec, polarity-correct via gpio_*_dt.
+ *  - `usedPins` (any other pin the program attaches to): raw-controller state —
+ *    GPIO.onInterrupt() works on EVERY GPIO, not just DT-aliased buttons. Each
+ *    such pin gets its own callback struct + trampoline addressed by the owning
+ *    controller (STM32 splits gpioa/gpiob/gpioc) and port-relative bit.
+ */
+export declare function interruptInitLines(chip: ZephyrChipDescriptor, usedPins?: ReadonlySet<number>): string[];
+/**
+ * Collect the pin numbers the program attaches interrupts to (any GPIO — not
+ * just descriptor-listed buttons). Feeds interruptInitLines' raw-path state.
  */
-export declare function interruptInitLines(chip: ZephyrChipDescriptor): string[];
+export declare function collectInterruptPins(program: unknown): Set<number>;
 /**
  * Resolve a HAL interrupt.* op to Zephyr C++.
  * Returns `{ code }` for statement ops, `{ expression }` for value-returning ops.
  *
- * Note: attach requires the pin to be in the descriptor's interruptPins. If a
- * program attaches to an unlisted pin, we fall back to a diagnostic comment
- * (the probe uses an unknown pin, so the manifest marks these 'supported' via
- * the comment lowering — the probe sees a non-undefined return).
+ * Two paths: pins listed in the descriptor's gpio.interruptPins (DT-aliased
+ * buttons) go through the polarity-correct gpio_*_dt chain; every other GPIO
+ * attaches through the raw-controller chain (any GPIO is interrupt-capable on
+ * the supported SoCs — the descriptor list exists for DT specs, not as a
+ * capability gate). The manifest probe's synthetic op keeps the comment
+ * fallback (no program ⇒ no shim state was emitted for the raw path).
  */
 export declare function lowerInterrupt(op: HALOpIR, chip: ZephyrChipDescriptor): {
     code?: string;

package/dist/lowering/interrupts.js

@@ -5,11 +5,13 @@
 // `struct gpio_callback` per pin, registered with gpio_add_callback, with a
 // trampoline that calls the user's C handler. The descriptor's gpio.interruptPins
 // lists the pins with DT specs (buttons). The user's handler is a free C
-// function; the trampoline calls it with no args (Arduino attachInterrupt style).
+// function; the trampoline calls it with no args.
 //
 // Each interrupt pin gets a static callback struct + a trampoline in shimLines.
 // attach enables + adds the callback; detach disables + removes it.
 // ---------------------------------------------------------------------------
+import { controllerNodelabelForPin, controllerRawPinForPin, controllerRangeForPin } from '../chips/controllers.js';
+import { ZEPHYR_GPIO_INTS } from '@typecad/hal';
 /** Look up an interrupt pin spec by HAL pin number. */
 function findIntPin(chip, pin) {
     return chip.gpio.interruptPins?.find((p) => p.pin === pin);
@@ -18,62 +20,142 @@ function findIntPin(chip, pin) {
 function dtSpecVar(dtSpec) {
     return `__tc_int_${dtSpec.replace(/-/g, '_')}`;
 }
-/** Map a HAL interrupt mode string to Zephyr GPIO_INT_* flags. */
-function modeToFlags(mode) {
-    switch (mode.toLowerCase()) {
-        case 'rising': return 'GPIO_INT_EDGE_RISING';
-        case 'falling': return 'GPIO_INT_EDGE_FALLING';
-        case 'change': return 'GPIO_INT_EDGE_BOTH';
-        case 'high': return 'GPIO_INT_LEVEL_HIGH';
-        case 'low': return 'GPIO_INT_LEVEL_LOW';
-        default: return 'GPIO_INT_EDGE_BOTH';
+// ── Thin GPIO interrupts (hal/gpio-pin.ts onInterrupt) — INT_* tokens ─────
+//
+// The name set comes from the GENERATED Zephyr token table (parsed from the
+// pinned tree's drivers/gpio.h).
+const GPIO_INT_TOKENS = Object.fromEntries(ZEPHYR_GPIO_INTS.map((f) => [`GPIO.${f}`, `GPIO_${f}`]));
+/** Map thin-GPIO INT token text to the GPIO_INT_* macro. */
+export function gpioIntTokenToMacro(intFlags) {
+    const token = String(intFlags ?? '').trim();
+    const m = GPIO_INT_TOKENS[token];
+    if (!m) {
+        throw new Error(`GPIO interrupt flag '${token}' is not a known GPIO.INT_* token — valid: ${Object.keys(GPIO_INT_TOKENS).join(', ')}.`);
     }
+    return m;
 }
 /**
  * Emit the per-pin interrupt callback state + trampolines. Called from shimLines
  * when the program uses interrupts. The trampoline calls a user function via a
  * function-pointer static, set at attach time.
+ *
+ * Two paths:
+ *  - descriptor `gpio.interruptPins` (buttons with DT specs): callback state
+ *    against the DT spec, polarity-correct via gpio_*_dt.
+ *  - `usedPins` (any other pin the program attaches to): raw-controller state —
+ *    GPIO.onInterrupt() works on EVERY GPIO, not just DT-aliased buttons. Each
+ *    such pin gets its own callback struct + trampoline addressed by the owning
+ *    controller (STM32 splits gpioa/gpiob/gpioc) and port-relative bit.
  */
-export function interruptInitLines(chip) {
+export function interruptInitLines(chip, usedPins) {
     const pins = chip.gpio.interruptPins ?? [];
-    if (pins.length === 0)
-        return [];
     const lines = ['// CUTTLEFISH_INT_BEGIN'];
     for (const pin of pins) {
         const v = dtSpecVar(pin.dtSpec);
         lines.push(`static const struct gpio_dt_spec ${v} = GPIO_DT_SPEC_GET(DT_ALIAS(${pin.dtSpec}), gpios);`, `static struct gpio_callback ${v}_cb;`, `static void (*${v}_handler)(void) = NULL;`, `static void ${v}_tramp(const struct device* port, struct gpio_callback* cb, gpio_port_pins_t pins_v) {`, `    (void)port; (void)cb; (void)pins_v;`, `    if (${v}_handler) { ${v}_handler(); }`, `}`);
     }
+    if (usedPins) {
+        for (const pin of usedPins) {
+            if (pins.some((p) => p.pin === pin))
+                continue;
+            const v = `__tc_int_raw${pin}`;
+            lines.push(`static const struct device* ${v}_dev = DEVICE_DT_GET(DT_NODELABEL(${controllerNodelabelForPin(chip, pin)}));`, `static struct gpio_callback ${v}_cb;`, `static void (*${v}_handler)(void) = NULL;`, `static void ${v}_tramp(const struct device* port, struct gpio_callback* cb, gpio_port_pins_t pins_v) {`, `    (void)port; (void)cb; (void)pins_v;`, `    if (${v}_handler) { ${v}_handler(); }`, `}`);
+        }
+    }
     lines.push('// CUTTLEFISH_INT_END');
     return lines;
 }
+/**
+ * Collect the pin numbers the program attaches interrupts to (any GPIO — not
+ * just descriptor-listed buttons). Feeds interruptInitLines' raw-path state.
+ */
+export function collectInterruptPins(program) {
+    const pins = new Set();
+    const visit = (node) => {
+        if (!node || typeof node !== 'object')
+            return;
+        const n = node;
+        const op = n.operation;
+        if (op && typeof op === 'object') {
+            const o = op;
+            if (o.operation === 'interrupt.attach_flags' && typeof o.pin === 'number') {
+                pins.add(o.pin);
+            }
+        }
+        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);
+    return pins;
+}
 /**
  * Resolve a HAL interrupt.* op to Zephyr C++.
  * Returns `{ code }` for statement ops, `{ expression }` for value-returning ops.
  *
- * Note: attach requires the pin to be in the descriptor's interruptPins. If a
- * program attaches to an unlisted pin, we fall back to a diagnostic comment
- * (the probe uses an unknown pin, so the manifest marks these 'supported' via
- * the comment lowering — the probe sees a non-undefined return).
+ * Two paths: pins listed in the descriptor's gpio.interruptPins (DT-aliased
+ * buttons) go through the polarity-correct gpio_*_dt chain; every other GPIO
+ * attaches through the raw-controller chain (any GPIO is interrupt-capable on
+ * the supported SoCs — the descriptor list exists for DT specs, not as a
+ * capability gate). The manifest probe's synthetic op keeps the comment
+ * fallback (no program ⇒ no shim state was emitted for the raw path).
  */
 export function lowerInterrupt(op, chip) {
     const o = op;
     const pin = findIntPin(chip, o.pin);
     if (!pin) {
+        // Raw-controller path — state comes from interruptInitLines' usedPins.
+        // Only for pins a declared controller range covers: an out-of-range number
+        // (e.g. pin 99 on a 34-pin SoC) keeps the diagnostic comment. Single-
+        // controller chips declare no ranges, so every number is taken as real and
+        // the driver rejects invalid bits at runtime (Arduino-like behavior).
+        const knownPin = typeof o.pin === 'number' && Number.isInteger(o.pin)
+            && (!chip.gpioControllers || chip.gpioControllers.length === 0
+                || controllerRangeForPin(chip, o.pin) !== undefined);
+        if (knownPin) {
+            const v = `__tc_int_raw${o.pin}`;
+            const raw = controllerRawPinForPin(chip, o.pin);
+            if (op.operation === 'interrupt.attach_flags') {
+                // Thin GPIO: INT_* tokens instead of mode strings. The pin's
+                // input/pull configuration already came from the construction flags
+                // (the class emits gpio.configure ahead of this op) — no INPUT
+                // override here, unlike the legacy raw path above.
+                const flags = gpioIntTokenToMacro(o.intFlags);
+                return {
+                    code: [
+                        `${v}_handler = (${o.handler});`,
+                        `gpio_init_callback(&${v}_cb, ${v}_tramp, BIT(${raw}));`,
+                        `gpio_pin_interrupt_configure(${v}_dev, ${raw}, ${flags});`,
+                        `gpio_add_callback(${v}_dev, &${v}_cb);`,
+                    ].join(' '),
+                };
+            }
+            if (op.operation === 'interrupt.detach') {
+                return {
+                    code: `gpio_pin_interrupt_configure(${v}_dev, ${raw}, GPIO_INT_DISABLE); gpio_remove_callback(${v}_dev, &${v}_cb); ${v}_handler = NULL;`,
+                };
+            }
+        }
         // Fallback (also covers the manifest probe): a diagnostic comment so the
         // resolver returns non-undefined. Real attach needs a descriptor entry.
-        if (op.operation === 'interrupt.attach') {
-            return { code: `/* interrupt.attach(pin ${o.pin}): no DT spec — add to chip descriptor gpio.interruptPins */` };
+        if (op.operation === 'interrupt.attach_flags') {
+            return { code: `/* interrupt.attach_flags(pin ${o.pin}): no DT spec — add to chip descriptor gpio.interruptPins */` };
         }
         return { code: `/* interrupt.detach(pin ${o.pin}): no DT spec */` };
     }
     const v = dtSpecVar(pin.dtSpec);
     switch (op.operation) {
-        case 'interrupt.attach': {
-            const flags = modeToFlags(o.mode);
+        case 'interrupt.attach_flags': {
+            // Thin GPIO: INT_* tokens; construction flags already configured the pin.
+            const flags = gpioIntTokenToMacro(o.intFlags);
             return {
                 code: [
                     `${v}_handler = (${o.handler});`,
-                    `gpio_pin_configure_dt(&${v}, GPIO_INPUT);`,
                     `gpio_init_callback(&${v}_cb, ${v}_tramp, BIT(${v}.pin));`,
                     `gpio_pin_interrupt_configure_dt(&${v}, ${flags});`,
                     `gpio_add_callback(${v}.port, &${v}_cb);`,

package/dist/lowering/mqtt.js

@@ -3,11 +3,11 @@
 //
 // Zephyr's MQTT library is event-driven but has no internal task: the app
 // must call mqtt_input() when the socket is readable and mqtt_live()
-// periodically for keepalive. The generated firmware is setup()/loop(),
-// and the user's loop() is not ours to edit — so the connect shim spawns a
+// periodically for keepalive. The generated firmware is main()-based and
+// the user's main() is not ours to edit — so the connect shim spawns a
 // dedicated k_thread that runs the poll loop (poll() → mqtt_input/mqtt_live)
 // until disconnect. This mirrors a "managed client" model (like ESP-IDF's
-// esp_mqtt internal task) and keeps the user's loop() untouched.
+// esp_mqtt internal task) and keeps the user's main() untouched.
 //
 // mqtt_connect() does no DNS — the broker is a resolved sockaddr — so the
 // shim getaddrinfo-resolves the broker host itself (like the HTTP shim).
@@ -266,8 +266,6 @@ export function mqttInitLines() {
         `        (void)mqtt_abort(&__tc_mqtt.client);`,
         `        return;`,
         `    }`,
-        `    printk("tc-mqtt: connecting to %s:%u\\n", __tc_mqtt.host,`,
-        `           static_cast<unsigned int>(__tc_mqtt.port));`,
         `    // Drive input locally until CONNACK arrives (poll thread hasn't started).`,
         `    // mqtt_connect opened the socket; poll it for the connect-ack. Cap the wait`,
         `    // so a silent broker doesn't hang setup forever.`,

package/dist/lowering/power.js

@@ -28,10 +28,6 @@ export function lowerPower(op) {
             // 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