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

package/dist/lowering/http.js

@@ -62,7 +62,8 @@ export function httpInitLines() {
         `    const char* body;        // request body (user-owned)`,
         `    int32_t body_len;`,
         `    bool insecure;`,
-        `    const char* ca_cert;     // PEM, user-owned; nullptr = no pinned CA`,
+        `    const uint8_t* ca_der;    // DER, user-owned; nullptr = no pinned CA`,
+        `    size_t ca_der_len;`,
         `    const char* hdr_name[__TC_HTTP_MAX_HEADERS];`,
         `    const char* hdr_value[__TC_HTTP_MAX_HEADERS];`,
         `    int32_t hdr_count;`,
@@ -199,17 +200,23 @@ export function httpInitLines() {
         `            // Register the pinned CA as the active sec tag. tls_credential_add`,
         `            // is idempotent-enough for the single-slot model: a duplicate tag`,
         `            // is an error we ignore, and the most recently added cert wins.`,
-        `            if (__tc_http.ca_cert != nullptr) {`,
-        `                (void)tls_credential_add(__TC_HTTP_SEC_TAG,`,
+        `            if (__tc_http.ca_der != nullptr) {`,
+        `                int cred_rc = tls_credential_add(__TC_HTTP_SEC_TAG,`,
         `                                         TLS_CREDENTIAL_CA_CERTIFICATE,`,
-        `                                         __tc_http.ca_cert, strlen(__tc_http.ca_cert) + 1U);`,
+        `                                         __tc_http.ca_der, __tc_http.ca_der_len);`,
         `                sec_tag_t tags[1] = { __TC_HTTP_SEC_TAG };`,
         `                (void)zsock_setsockopt(sock_tls, SOL_TLS, TLS_SEC_TAG_LIST, tags, sizeof(tags));`,
+        `                (void)cred_rc;`,
         `            }`,
         `            // Hostname SNI + verification. insecure() disables verification;`,
         `            // the default (no caCert, no insecure) leaves verification required`,
         `            // with no sec tag, so the handshake fails safely until a CA is set.`,
-        `            (void)zsock_setsockopt(sock_tls, SOL_TLS, TLS_HOSTNAME, __tc_http.host, strlen(__tc_http.host) + 1U);`,
+        `            // mbedtls does not match IP literals against SAN entries —`,
+        `            // skip the hostname check for IP hosts (chain-only verify).`,
+        `            bool host_is_ip = true; for (const char* p3 = __tc_http.host; *p3 != 0; p3++) { if (!((*p3 >= '0' && *p3 <= '9') || *p3 == '.')) { host_is_ip = false; break; } }`,
+        `            if (!host_is_ip) {`,
+        `                (void)zsock_setsockopt(sock_tls, SOL_TLS, TLS_HOSTNAME, __tc_http.host, strlen(__tc_http.host) + 1U);`,
+        `            }`,
         `            int32_t verify = __tc_http.insecure ? TLS_PEER_VERIFY_NONE : TLS_PEER_VERIFY_REQUIRED;`,
         `            (void)zsock_setsockopt(sock_tls, SOL_TLS, TLS_PEER_VERIFY, &verify, sizeof(verify));`,
         `        }`,
@@ -245,7 +252,8 @@ export function httpInitLines() {
         `    __tc_http.body = nullptr;`,
         `    __tc_http.body_len = 0;`,
         `    __tc_http.insecure = false;`,
-        `    __tc_http.ca_cert = nullptr;`,
+        `    __tc_http.ca_der = nullptr;`,
+        `    __tc_http.ca_der_len = 0;`,
         `    __tc_http.hdr_count = 0;`,
         `    __tc_http.status = 0;`,
         `    __tc_http.done = false;`,
@@ -293,7 +301,7 @@ export function httpInitLines() {
         ``,
         `static inline void __tc_http_set_insecure(void) { __tc_http.insecure = true; }`,
         ``,
-        `static inline void __tc_http_set_ca_cert(const char* pem) { __tc_http.ca_cert = pem; }`,
+        `static inline void __tc_http_set_ca_cert_der(const uint8_t* der, size_t len) { __tc_http.ca_der = der; __tc_http.ca_der_len = len; }`,
         ``,
         `// ── perform (the shared blocking core) ──────────────────────────────────`,
         `// Parse url → open socket → build http_request → http_client_req → close.`,
@@ -441,12 +449,12 @@ const METHOD_MAP = {
 export function lowerHttp(op) {
     const o = op;
     switch (op.operation) {
-        case 'http.reset':
-            return { code: `__tc_http_reset();` };
         case 'http.begin': {
             const methodName = String(o.method).replace(/^["']|["']$/g, '').toUpperCase();
             const method = METHOD_MAP[methodName] ?? 'HTTP_GET';
-            return { code: `__tc_http_begin(${method}, ${s(o.url)});` };
+            // Fresh shim state per request — the reset used to ride the deleted
+            // factory op (http.reset); construction now owns it.
+            return { code: `__tc_http_reset(); __tc_http_begin(${method}, ${s(o.url)});` };
         }
         case 'http.set_header':
             return { code: `__tc_http_set_header(${s(o.name)}, ${s(o.value)});` };
@@ -455,11 +463,28 @@ export function lowerHttp(op) {
         case 'http.set_max_body':
             return { code: `__tc_http_set_max_body(${s(o.bytes)});` };
         case 'http.set_body':
-            return { code: `__tc_http_set_body(${s(o.data)}, ${o.json ? 'true' : 'false'});` };
+            // '' is the no-body sentinel — the op always emits from send(); elide.
+            return { code: o.data === '""' || o.data === '' ? '' : `__tc_http_set_body(${s(o.data)}, ${o.json ? 'true' : 'false'});` };
         case 'http.set_insecure':
-            return { code: `__tc_http_set_insecure();` };
-        case 'http.set_ca_cert':
-            return { code: `__tc_http_set_ca_cert(${s(o.pem)});` };
+            return { code: o.insecure ? `__tc_http_set_insecure();` : '' };
+        case 'http.set_ca_cert': {
+            // This tree's tf-psa-crypto mbedTLS has no PEM parser (MBEDTLS_PEM_C is
+            // not settable) — decode the PEM literal to DER here and emit a static
+            // byte array. tls_credential_add takes the DER directly (crt_is_pem is
+            // false → mbedtls_x509_crt_parse_der_nocopy on the verify path).
+            const pem = String(o.pem).replace(/^"|"$/g, '').replace(/\\n/g, '\n');
+            if (pem.replace(/\s+/g, '') === '') {
+                // No-CA sentinel (Request always emits the op; opts.caCert defaults
+                // to '') — elide silently so plain-HTTP requests carry no comment.
+                return { code: '' };
+            }
+            const b64 = pem.replace(/-----[A-Z ]+-----/g, '').replace(/\s+/g, '');
+            const der = Buffer.from(b64, 'base64');
+            if (der.length < 100)
+                return { code: `// tc-http: caCert PEM failed to decode` };
+            const hex = [...der].map((b) => `0x${b.toString(16).padStart(2, '0')}`).join(', ');
+            return { code: `{ static const uint8_t __tc_ca_der[] = { ${hex} }; __tc_http_set_ca_cert_der(__tc_ca_der, sizeof(__tc_ca_der)); }` };
+        }
         case 'http.send':
             return { expression: `__tc_http_send()` };
         case 'http.send_start':

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;