@typecad/cuttlefish 0.1.0-alpha.2 → 1.0.0-alpha.11

package/dist/ir/program-analysis.js

@@ -38,6 +38,20 @@ function analyzeExpression(expr, result, strategy) {
                     }
                 }
             }
+            // Timer polyfill sizing — Timing.setInterval/Timing.setTimeout in
+            // expression position (e.g. `const id = Timing.setInterval(...)`) lower to
+            // a raw expression whose value contains `__tc_setInterval(...)`. The
+            // callee-based counter in the "call" case only fires for bare timer
+            // calls; without this the timer_methods polyfill is gated off and the
+            // link fails: "'__tc_setInterval' was not declared in this scope".
+            {
+                const intervals = expr.value.match(/__tc_setInterval\s*\(/g);
+                if (intervals)
+                    result.timerCallCount += intervals.length;
+                const timeouts = expr.value.match(/__tc_setTimeout\s*\(/g);
+                if (timeouts)
+                    result.timerCallCount += timeouts.length;
+            }
             if (/\bString\s*\(/.test(expr.value)) {
                 result.usesStringConversion = true;
             }
@@ -63,6 +77,24 @@ function analyzeExpression(expr, result, strategy) {
             if (expr.value.includes('__tc_str_ptr')) {
                 result.usesStrPtr = true;
             }
+            if (/std::chrono|steady_clock/.test(expr.value)) {
+                result.usesChrono = true;
+            }
+            if (/std::set\s*</.test(expr.value)) {
+                result.usesSet = true;
+            }
+            if (/std::(sort|find|transform|copy|fill|remove|count|reverse|accumulate)\s*\(/.test(expr.value)) {
+                result.usesAlgorithm = true;
+            }
+            if (/\b(printf|fprintf|sprintf|snprintf)\s*\(/.test(expr.value)) {
+                result.usesCstdio = true;
+            }
+            if (/\bdigitalRead\s*\(/.test(expr.value)) {
+                result.usesDigitalRead = true;
+            }
+            if (/cuttlefish_halt\s*\(/.test(expr.value)) {
+                result.usesHalt = true;
+            }
             break;
         case "method-call":
             if (strategy.isConsoleCall(expr.callee)) {
@@ -102,6 +134,30 @@ function analyzeExpression(expr, result, strategy) {
             if (expr.callee.startsWith("WDT.") || expr.callee === "WDT") {
                 result.usesWDT = true;
             }
+            // Native AVR peripheral usage from namespace-prefixed method calls
+            // (Serial.* / SPI.* / Wire.* / EEPROM.*). The HAL resolver lowers these
+            // to structured hal-ops (detected in analyzeStatement) OR to bare
+            // lowered calls; these checks cover the pre-lowering and direct forms.
+            if (expr.callee.startsWith("Serial.") || expr.callee === "Serial") {
+                result.usesUart = true;
+            }
+            if (expr.callee.startsWith("SPI.") || expr.callee === "SPI") {
+                result.usesSPI = true;
+            }
+            if (expr.callee.startsWith("Wire.") || expr.callee === "Wire") {
+                result.usesI2C = true;
+            }
+            if (expr.callee.startsWith("EEPROM.") || expr.callee === "EEPROM") {
+                result.usesEEPROM = true;
+            }
+            // map()/constrain() Arduino-API calls appear as method-call exprs
+            // (callee "map"/"constrain"). framework-avr lowers these to _native_map/
+            // _native_constrain via symbol aliases, so the helpers are dead code
+            // unless the program actually calls them.
+            if (expr.callee === "map")
+                result.usesMap = true;
+            if (expr.callee === "constrain")
+                result.usesConstrain = true;
             // Count setInterval/setTimeout call sites (post-rename callee names) so
             // __tc_TimerRuntime::MAX_TIMERS can be sized to the observed count.
             if (expr.callee === "__tc_setInterval" || expr.callee === "__tc_setTimeout"
@@ -192,6 +248,108 @@ function analyzeExpression(expr, result, strategy) {
                 analyzeExpression(expr.expression, result, strategy);
             }
             break;
+        case "hal-expr":
+            // Value-position HAL ops (e.g. `const v = D32.readAnalog()` lowers to an
+            // adc.read hal-expr initializer; `const ip = WiFi.localIP()` to a wifi
+            // hal-expr) never pass through the statement-level hal-op detection
+            // below, so mirror the FULL peripheral-flag detection here. Without this,
+            // a value-returning HAL op used in a var-init or expression context fails
+            // to set its analysis flag — the framework then drops the matching init
+            // block + forced includes (e.g. __tc_adc_read was emitted but the
+            // CUTTLEFISH_ADC init block and adc_oneshot.h include were not). Keep this
+            // list in sync with the hal-op statement case at the bottom of this file.
+            if (expr.operation && typeof expr.operation.operation === "string") {
+                const opName = expr.operation.operation;
+                if (opName.startsWith("display.")) {
+                    result.usesGPIO = true;
+                    result.usesDisplay = true;
+                }
+                if (opName.startsWith("gpio."))
+                    result.usesGPIO = true;
+                if (opName === "gpio.read")
+                    result.usesDigitalRead = true;
+                if (opName.startsWith("pwm."))
+                    result.usesPWM = true;
+                if (opName.startsWith("rmt."))
+                    result.usesRmt = true;
+                if (opName.startsWith("adc."))
+                    result.usesADC = true;
+                if (opName.startsWith("dac."))
+                    result.usesDAC = true;
+                if (opName.startsWith("power."))
+                    result.usesPower = true;
+                if (opName.startsWith("wdt."))
+                    result.usesWdt = true;
+                // Safety HAL ops (@typecad/safety) — map each op to the
+                // __tc_safety_* polyfill helper it triggers, so the mode-table and
+                // voter polyfills survive tree-shaking when actually used. Matches
+                // the resolveSafetyOp output naming. Cast through string because the
+                // HALOpIR operation union is closed and doesn't include safety.* ops
+                // (those are owned by the optional @typecad/safety package).
+                const safetyOpName = opName;
+                if (safetyOpName === "safety.record_pin_mode") {
+                    result.usedPolyfillHelpers.add("__tc_safety_record_pin_mode");
+                }
+                if (safetyOpName === "safety.read_safe") {
+                    result.usedPolyfillHelpers.add("__tc_safety_read_safe");
+                }
+                if (safetyOpName === "safety.write_verify") {
+                    result.usedPolyfillHelpers.add("__tc_safety_write_verify");
+                }
+                if (opName.startsWith("interrupt."))
+                    result.usesInterrupts = true;
+                if (opName.startsWith("pulse."))
+                    result.usesPulse = true;
+                if (opName.startsWith("shift."))
+                    result.usesShift = true;
+                if (opName.startsWith("tone."))
+                    result.usesTone = true;
+                if (opName.startsWith("i2c."))
+                    result.usesI2C = true;
+                if (opName.startsWith("spi."))
+                    result.usesSPI = true;
+                if (opName.startsWith("uart."))
+                    result.usesUart = true;
+                if (opName.startsWith("wifi.")) {
+                    result.usesWifi = true;
+                    if (opName === "wifi.connect" || opName === "wifi.connect_start" || opName === "wifi.disconnect") {
+                        result.usesWifiConnect = true;
+                        if (opName === "wifi.connect")
+                            result.usesWifiConnectBlocking = true;
+                    }
+                    else if (opName.startsWith("wifi.scan"))
+                        result.usesWifiScan = true;
+                    else if (opName === "wifi.status" || opName === "wifi.local_ip" || opName === "wifi.rssi" || opName === "wifi.mac")
+                        result.usesWifiQuery = true;
+                    else if (opName === "wifi.set_hostname")
+                        result.usesWifiConfig = true;
+                }
+                if (opName.startsWith("http."))
+                    result.usesHttp = true;
+                if (opName.startsWith("ble."))
+                    result.usesBle = true;
+                if (opName.startsWith("preferences."))
+                    result.usesPreferences = true;
+                if (opName.startsWith("random."))
+                    result.usesRandom = true;
+                if (opName.startsWith("fs."))
+                    result.usesFS = true;
+                if (opName.startsWith("mdns."))
+                    result.usesMdns = true;
+                if (opName.startsWith("mqtt."))
+                    result.usesMqtt = true;
+                if (opName.startsWith("ota."))
+                    result.usesOta = true;
+                if (opName.startsWith("temp."))
+                    result.usesTemp = true;
+                if (opName.startsWith("hwtimer."))
+                    result.usesHwtimer = true;
+                if (opName.startsWith("capacitive."))
+                    result.usesCapacitive = true;
+                if (opName.startsWith("worker."))
+                    result.usesWorker = true;
+            }
+            break;
     }
 }
 /**
@@ -218,6 +376,11 @@ function analyzeStatement(statement, result, strategy) {
             if (statement.callee === "millis" || statement.callee === "delay") {
                 result.usesMillis = true;
             }
+            // Awaited HAL wait markers become async state-machine poll states that
+            // arm deadlines via currentTimeMillis().
+            if (statement.callee === "__WIFI_WAIT__" || statement.callee === "__HTTP_WAIT__" || statement.callee === "__HAL_WAIT__") {
+                result.usesMillis = true;
+            }
             // Namespace-qualified polyfill entry points used as bare call statements
             // (e.g. `Timing.delay(5);`). The expression-level analyzer (case
             // "method-call") already checks these prefixes, but a statement-form call
@@ -234,6 +397,47 @@ function analyzeStatement(statement, result, strategy) {
             if (statement.callee.startsWith("WDT.") || statement.callee === "WDT") {
                 result.usesWDT = true;
             }
+            // Native AVR peripheral usage from statement-form calls. tone()/noTone()
+            // are bare Arduino-API calls; console.* / Serial.* drive UART; the
+            // namespace prefixes mirror the method-call checks above.
+            if (statement.callee === "tone" || statement.callee === "noTone") {
+                result.usesTone = true;
+            }
+            // console.* is NOT UART: on ESP-IDF it lowers to printf, on Arduino to
+            // Serial via hasConsoleCalls. Only real UART HAL / Serial peripheral
+            // usage should gate the uart shim (avoids unused __tc_uart*_init).
+            if (statement.callee.startsWith("_uart_")) {
+                result.usesUart = true;
+            }
+            if (statement.callee.startsWith("Serial.") || statement.callee === "Serial") {
+                result.usesUart = true;
+            }
+            if (statement.callee.startsWith("SPI.") || statement.callee === "SPI") {
+                result.usesSPI = true;
+            }
+            if (statement.callee.startsWith("Wire.") || statement.callee === "Wire") {
+                result.usesI2C = true;
+            }
+            if (statement.callee.startsWith("EEPROM.") || statement.callee === "EEPROM") {
+                result.usesEEPROM = true;
+            }
+            // Statement-form map()/constrain() mirror the method-call checks above.
+            if (statement.callee === "map")
+                result.usesMap = true;
+            if (statement.callee === "constrain")
+                result.usesConstrain = true;
+            // Statement-form setInterval/setTimeout mirror the expression-level
+            // timer-count (analyzeExpression). A top-level `setInterval(...)` call
+            // stays a `call` statement (never becomes a method-call expression — see
+            // the comment above re: Timing./Num./WDT.), so without this mirror the
+            // timer polyfill gate (timerCallCount) stays 0 and __tc_setInterval is
+            // emitted as a call but never defined (demo: "'__tc_setInterval' was not
+            // declared in this scope"). The arrow-callback hoister renames the callee
+            // to __tc_setInterval/__tc_setTimeout, so check both pre- and post-rename.
+            if (statement.callee === "setInterval" || statement.callee === "setTimeout"
+                || statement.callee === "__tc_setInterval" || statement.callee === "__tc_setTimeout") {
+                result.timerCallCount++;
+            }
             // The HAL resolver lowers WDT.*/Timing.* namespace calls to bare AVR
             // library functions (WDT.reset() → wdt_reset(), Timing.delay() → delay(),
             // Timing.millis() → millis()). When that happens the `WDT.`/`Timing.`
@@ -261,6 +465,27 @@ function analyzeStatement(statement, result, strategy) {
                     }
                 }
             }
+            // Timer polyfill sizing for __EMIT__ statements (callee "__EMIT__"):
+            // Timing.setInterval/Timing.setTimeout can lower to an __EMIT__ call whose
+            // single string arg is the raw C++ payload, e.g.
+            // `return __tc_setInterval(<cb>, 500)`. The callee-based timer counter
+            // above only fires for bare setInterval/__tc_setInterval calls, so without
+            // this the timer_methods polyfill is gated off and the link fails:
+            // "'__tc_setInterval' was not declared in this scope". Count call sites
+            // embedded in the raw payload. (The hal-op raw-code path has a parallel
+            // counter below.)
+            if (statement.callee === "__EMIT__") {
+                for (const arg of statement.args) {
+                    if (arg && arg.kind === "string" && typeof arg.value === "string") {
+                        const matches = arg.value.match(/__tc_setInterval\s*\(/g);
+                        if (matches)
+                            result.timerCallCount += matches.length;
+                        const timeouts = arg.value.match(/__tc_setTimeout\s*\(/g);
+                        if (timeouts)
+                            result.timerCallCount += timeouts.length;
+                    }
+                }
+            }
             for (const arg of statement.args) {
                 analyzeExpression(arg, result, strategy);
             }
@@ -357,6 +582,122 @@ function analyzeStatement(statement, result, strategy) {
             }
             break;
         case "hal-op":
+            // Structured HAL ops carry a typed operation name (e.g. "spi.begin",
+            // "i2c.read_byte", "tone.play", "uart.write") rather than raw code.
+            // Detect peripheral usage here so framework-avr's driver shims can be
+            // gated on actual use. Without this, SPI0.begin() → spi.begin hal-op
+            // would be invisible (no raw code to scan) and the SPI driver would
+            // always be emitted. Same blind spot the wdt.* fix below the raw-code
+            // block addresses for the watchdog.
+            if (statement.operation && typeof statement.operation.operation === "string") {
+                const opName = statement.operation.operation;
+                if (opName.startsWith("spi."))
+                    result.usesSPI = true;
+                if (opName.startsWith("i2c."))
+                    result.usesI2C = true;
+                if (opName.startsWith("tone."))
+                    result.usesTone = true;
+                if (opName.startsWith("uart."))
+                    result.usesUart = true;
+                // Display HAL ops (display.init from ui.mount, display.flush per frame)
+                // always imply GPIO usage (CS/DC/RST pins). Native SPI/I2C display
+                // adapters emit their own transport #includes (driver/spi_master.h,
+                // driver/i2c_master.h) — we don't force usesSPI/usesI2C here because
+                // that would pull headers even for non-display SPI/I2C code, and the
+                // display's transport type can't be determined from the op alone.
+                if (opName.startsWith("display.")) {
+                    result.usesGPIO = true;
+                    result.usesDisplay = true;
+                }
+                // ESP32 peripheral usage — framework-esp32 gates IDF driver blocks
+                // and forced includes on these. No-op for other frameworks (their
+                // shimLines emit no CUTTLEFISH_* blocks with these marker names).
+                if (opName.startsWith("gpio."))
+                    result.usesGPIO = true;
+                if (opName === "gpio.read")
+                    result.usesDigitalRead = true;
+                if (opName.startsWith("pwm."))
+                    result.usesPWM = true;
+                if (opName.startsWith("rmt."))
+                    result.usesRmt = true;
+                if (opName.startsWith("adc."))
+                    result.usesADC = true;
+                if (opName.startsWith("dac."))
+                    result.usesDAC = true;
+                if (opName.startsWith("power."))
+                    result.usesPower = true;
+                if (opName.startsWith("wdt."))
+                    result.usesWdt = true;
+                // Safety HAL ops (@typecad/safety) — map each op to the
+                // __tc_safety_* polyfill helper it triggers, so the mode-table and
+                // voter polyfills survive tree-shaking when actually used. Matches
+                // the resolveSafetyOp output naming. Cast through string because the
+                // HALOpIR operation union is closed and doesn't include safety.* ops
+                // (those are owned by the optional @typecad/safety package).
+                const safetyOpName = opName;
+                if (safetyOpName === "safety.record_pin_mode") {
+                    result.usedPolyfillHelpers.add("__tc_safety_record_pin_mode");
+                }
+                if (safetyOpName === "safety.read_safe") {
+                    result.usedPolyfillHelpers.add("__tc_safety_read_safe");
+                }
+                if (safetyOpName === "safety.write_verify") {
+                    result.usedPolyfillHelpers.add("__tc_safety_write_verify");
+                }
+                if (opName.startsWith("interrupt."))
+                    result.usesInterrupts = true;
+                if (opName.startsWith("pulse."))
+                    result.usesPulse = true;
+                if (opName.startsWith("shift."))
+                    result.usesShift = true;
+                if (opName.startsWith("wifi.")) {
+                    result.usesWifi = true;
+                    if (opName === "wifi.connect" || opName === "wifi.connect_start" || opName === "wifi.disconnect") {
+                        result.usesWifiConnect = true;
+                        if (opName === "wifi.connect")
+                            result.usesWifiConnectBlocking = true;
+                    }
+                    else if (opName.startsWith("wifi.scan"))
+                        result.usesWifiScan = true;
+                    else if (opName === "wifi.status" || opName === "wifi.local_ip" || opName === "wifi.rssi" || opName === "wifi.mac")
+                        result.usesWifiQuery = true;
+                    else if (opName === "wifi.set_hostname")
+                        result.usesWifiConfig = true;
+                }
+                if (opName.startsWith("http."))
+                    result.usesHttp = true;
+                if (opName.startsWith("ble."))
+                    result.usesBle = true;
+                if (opName.startsWith("preferences."))
+                    result.usesPreferences = true;
+                if (opName.startsWith("random."))
+                    result.usesRandom = true;
+                if (opName.startsWith("fs."))
+                    result.usesFS = true;
+                if (opName.startsWith("mdns."))
+                    result.usesMdns = true;
+                if (opName.startsWith("mqtt."))
+                    result.usesMqtt = true;
+                if (opName.startsWith("ota."))
+                    result.usesOta = true;
+                if (opName.startsWith("temp."))
+                    result.usesTemp = true;
+                if (opName.startsWith("hwtimer."))
+                    result.usesHwtimer = true;
+                if (opName.startsWith("capacitive."))
+                    result.usesCapacitive = true;
+                if (opName.startsWith("worker."))
+                    result.usesWorker = true;
+                // Timing HAL ops (timing.delay/millis/micros) carry a typed operation
+                // name, not raw code, so the regex scans below miss them. Mirror the
+                // raw-code timing detection here so usesMillis/usesTiming (and thus
+                // usesNativeTiming) fire for `delay()`/`millis()` on AVR.
+                if (opName === "timing.delay" || opName === "timing.delay_microseconds"
+                    || opName === "timing.millis" || opName === "timing.micros") {
+                    result.usesTiming = true;
+                    result.usesMillis = true;
+                }
+            }
             // Scan raw C++ code in HAL ops for polyfill helper usage
             if (statement.operation && statement.operation.operation === "raw" && typeof statement.operation.code === "string") {
                 const code = statement.operation.code;
@@ -384,6 +725,38 @@ function analyzeStatement(statement, result, strategy) {
                     result.usesTiming = true;
                     result.usesMillis = true;
                 }
+                // Timer polyfill sizing — `Timing.setInterval(...)` / `Timing.setTimeout(...)`
+                // are resolved by the HAL method resolver, which reads TimingClass's
+                // rawCpp body and emits a raw hal-op whose code is e.g.
+                // `return __tc_setInterval(<cb>, 500)`. The callee-based counter below
+                // (statement.callee === "__tc_setInterval") never fires for these — the
+                // statement is a hal-op, not a bare timer call — so without counting
+                // here the timer_methods polyfill is gated off (timerCallCount == 0)
+                // and the link fails: "'__tc_setInterval' was not declared in this
+                // scope". Count each __tc_setInterval/__tc_setTimeout call site in the
+                // raw code. The optional `return ` prefix is emitted by value-returning
+                // HAL methods (statement context), so match with or without it.
+                const intervalSites = code.match(/__tc_setInterval\s*\(/g);
+                if (intervalSites)
+                    result.timerCallCount += intervalSites.length;
+                const timeoutSites = code.match(/__tc_setTimeout\s*\(/g);
+                if (timeoutSites)
+                    result.timerCallCount += timeoutSites.length;
+                // Native AVR peripheral usage inside raw hal-op code (e.g. the
+                // EEPROM namespace lowers to `EEPROM.write(...)` in a raw hal-op;
+                // Serial/SPI/Wire may appear as lowered library calls too).
+                if (/\bEEPROM\b/.test(code) || /\beeprom_(read|write|update)_byte\b/.test(code)) {
+                    result.usesEEPROM = true;
+                }
+                if (/\bSerial\b/.test(code)) {
+                    result.usesUart = true;
+                }
+                if (/\bSPI\b/.test(code)) {
+                    result.usesSPI = true;
+                }
+                if (/\bWire\b/.test(code)) {
+                    result.usesI2C = true;
+                }
             }
             break;
         case "update":
@@ -431,10 +804,53 @@ export function analyzeProgram(program, strategy) {
         usesTiming: false,
         usesWDT: false,
         usesStrPtr: false,
+        usesUart: false,
+        usesSPI: false,
+        usesI2C: false,
+        usesEEPROM: false,
+        usesTone: false,
+        usesMap: false,
+        usesConstrain: false,
+        usesNativeTiming: false,
         hasSerialBegin: false,
         hasGenerators: false,
         usesStdMap: false,
         timerCallCount: 0,
+        usesGPIO: false,
+        usesPWM: false,
+        usesRmt: false,
+        usesADC: false,
+        usesDAC: false,
+        usesPower: false,
+        usesWdt: false,
+        usesInterrupts: false,
+        usesPulse: false,
+        usesShift: false,
+        usesWifi: false,
+        usesWifiConnect: false,
+        usesWifiConnectBlocking: false,
+        usesWifiQuery: false,
+        usesWifiScan: false,
+        usesWifiConfig: false,
+        usesHttp: false,
+        usesBle: false,
+        usesPreferences: false,
+        usesRandom: false,
+        usesFS: false,
+        usesMdns: false,
+        usesMqtt: false,
+        usesOta: false,
+        usesTemp: false,
+        usesHwtimer: false,
+        usesCapacitive: false,
+        usesWorker: false,
+        usesChrono: false,
+        usesSet: false,
+        usesAlgorithm: false,
+        usesCstdio: false,
+        usesDigitalRead: false,
+        usesDisplay: false,
+        usesHalt: false,
     };
     // Analyze type aliases
     for (const typeAlias of program.typeAliases) {
@@ -585,5 +1001,18 @@ export function analyzeProgram(program, strategy) {
     if (loweredConsoleInCallback()) {
         result.hasConsoleCalls = true;
     }
+    // Derive the comprehensive native-timing gate for the AVR millis() Timer0
+    // ISR. The ISR is needed whenever the program touches the soft clock
+    // directly (millis/delay/micros) OR has a hidden consumer: setInterval/
+    // setTimeout (the scheduler polls millis), or async functions (the runtime
+    // polls millis). The per-frame UI tick is injected by the emitter, not
+    // present in user source — the setup emitter ORs entryHasUI() in at the
+    // consume site. Without this gate, every AVR program pulled in the Timer0
+    // ISR even when it never uses timing.
+    const hasAsync = program.functions.some(fn => fn.isAsync);
+    result.usesNativeTiming = result.usesMillis
+        || result.usesTiming
+        || result.timerCallCount > 0
+        || hasAsync;
     return result;
 }

package/dist/ir/pulldown-validation.d.ts

@@ -4,4 +4,4 @@ import type { BoardConstants } from './board-resolver.js';
 /**
  * Validate that pins used with inputPullDown() support pulldown on this board.
  */
-export declare function validatePulldownSupport(usage: PeripheralUsage, boardConstants: BoardConstants | undefined): Diagnostic[];
+export declare function validatePulldownSupport(usage: PeripheralUsage, boardConstants: BoardConstants | undefined, filePath: string): Diagnostic[];

package/dist/ir/pulldown-validation.js

@@ -7,7 +7,7 @@
 /**
  * Validate that pins used with inputPullDown() support pulldown on this board.
  */
-export function validatePulldownSupport(usage, boardConstants) {
+export function validatePulldownSupport(usage, boardConstants, filePath) {
     const diagnostics = [];
     if (usage.inputPulldownPins.size === 0) {
         return diagnostics;
@@ -22,6 +22,7 @@ export function validatePulldownSupport(usage, boardConstants) {
             diagnostics.push({
                 code: 'pulldown-not-supported',
                 message: `${pinName ?? `pin ${pinNumber}`} does not support hardware pulldown${arch ? ` on ${arch.toUpperCase()} boards` : ''}. Use ${pinName ?? 'pin'}.asInput() or ${pinName ?? 'pin'}.inputPullUp() instead.`,
+                filePath,
                 source: 'pulldown-validation',
                 severity: 'error',
             });

package/dist/ir/pwm-timer-sharing.d.ts

@@ -1,4 +1,4 @@
 import type { Diagnostic } from '../types.js';
 import type { BoardConstants } from './board-resolver.js';
 import type { PeripheralUsage } from './peripheral-usage.js';
-export declare function validatePWMTimerSharing(usage: PeripheralUsage, boardConstants: BoardConstants | undefined): Diagnostic[];
+export declare function validatePWMTimerSharing(usage: PeripheralUsage, boardConstants: BoardConstants | undefined, filePath: string): Diagnostic[];

package/dist/ir/pwm-timer-sharing.js

@@ -52,7 +52,7 @@ function getPwmTimerPins(boardConstants) {
     }
     return Array.from(pinsByIndex.values()).filter(pin => pin.timerId.length > 0);
 }
-export function validatePWMTimerSharing(usage, boardConstants) {
+export function validatePWMTimerSharing(usage, boardConstants, filePath) {
     if (usage.pwmPinsUsed.size < 2 || !boardConstants) {
         return [];
     }
@@ -85,6 +85,7 @@ export function validatePWMTimerSharing(usage, boardConstants) {
         diagnostics.push({
             severity: 'info',
             code: 'pwm-timer-sharing',
+            filePath,
             source: 'pwm-timer-sharing',
             message: `${references.join(', ')} share ${timerId}${boardLabel}. Duty cycle can differ per pin, but timer-wide PWM settings are shared across that group. Prefer pins on different timer groups if you need independent PWM timing behavior.`,
         });

package/dist/ir/render-expr.js

@@ -85,6 +85,17 @@ export function renderExprAsText(expr) {
         case "lambda":
             return `/* __lambda__ */`;
         case "method-call": {
+            // Structured-receiver path: when the method-call IR carries a receiverExpr
+            // (set by the safe.read().ok().fail() chain builder), render the receiver
+            // recursively so nested lambda args are NOT flattened into the callee
+            // string as /* __lambda__ */ placeholders. The flat callee path below
+            // destroys lambdas; this preserves them.
+            const receiverExpr = expr.receiverExpr;
+            const methodName = expr.methodName;
+            if (receiverExpr !== undefined && methodName !== undefined) {
+                const argsText = expr.args.map(a => renderExprAsText(a)).join(", ");
+                return `${renderExprAsText(receiverExpr)}.${methodName}(${argsText})`;
+            }
             const argsText = expr.args.map(a => renderExprAsText(a)).join(", ");
             return `${expr.callee}(${argsText})`;
         }

package/dist/ir/resource-analysis.js

@@ -34,6 +34,7 @@ export function analyzeResources(program, strategy) {
                     diagnostics.push({
                         severity: 'warning',
                         message: `${pinRef} is configured as ${peripheralName} ${func.role.toUpperCase()}. Using it as GPIO may interfere with communication.\n   → ${suggestion}`,
+                        filePath: program.fileName,
                         code: 'peripheral-pin-conflict',
                         source: 'resource-analysis',
                     });
@@ -58,6 +59,7 @@ export function analyzeResources(program, strategy) {
                             severity: 'error',
                             message: `Hardware Conflict: Pin '${pinName}' is required by both ${peripheralName} and ${other}.`,
                             hint: `Move one of the peripherals to different pins if your board supports remapping, or avoid using both simultaneously.`,
+                            filePath: program.fileName,
                             code: 'peripheral-peripheral-conflict',
                             source: 'resource-analysis',
                         });

package/dist/ir/timer0-pwm-timing-conflict.d.ts

@@ -1,4 +1,4 @@
 import type { Diagnostic } from '../types.js';
 import type { BoardConstants } from './board-resolver.js';
 import type { PeripheralUsage } from './peripheral-usage.js';
-export declare function validateTimer0PWMTimingConflict(usage: PeripheralUsage, boardConstants: BoardConstants | undefined): Diagnostic[];
+export declare function validateTimer0PWMTimingConflict(usage: PeripheralUsage, boardConstants: BoardConstants | undefined, filePath: string): Diagnostic[];

package/dist/ir/timer0-pwm-timing-conflict.js

@@ -43,7 +43,7 @@ function getTimer0PwmPins(boardConstants) {
     }
     return timer0Pins;
 }
-export function validateTimer0PWMTimingConflict(usage, boardConstants) {
+export function validateTimer0PWMTimingConflict(usage, boardConstants, filePath) {
     if (!usage.timer0 || usage.pwmPinsUsed.size === 0) {
         return [];
     }
@@ -65,6 +65,7 @@ export function validateTimer0PWMTimingConflict(usage, boardConstants) {
     return [{
             severity: 'info',
             code: 'timer0-pwm-timing-conflict',
+            filePath,
             source: 'timer0-pwm-timing-conflict',
             message: `${pinReferences.join(', ')} use Timer0 PWM${boardLabel}, and your program also relies on Timer0-backed timing APIs such as delay(), millis(), or micros(). This coupling is common on AVR boards, so prefer non-Timer0 PWM pins when you want PWM behavior isolated from core timing.`,
         }];

package/dist/ir/timing-validation.d.ts

@@ -1,7 +1,12 @@
 import type { ProgramIR } from '../api/index.js';
 import type { Diagnostic } from '../types.js';
+import type { PlatformStrategy } from '../api/shared/index.js';
 /**
  * Detect blocking delay() calls inside loop()'s body. Emits a warning for
  * each, explaining the cooperative-async alternative.
+ *
+ * On RTOS targets (ESP-IDF), timing.delay lowers to vTaskDelay which yields
+ * the CPU — it does NOT freeze the async queue or UI. Only delayMicroseconds
+ * (busy-wait) triggers the warning.
  */
-export declare function validateBlockingDelayInLoop(program: ProgramIR): Diagnostic[];
+export declare function validateBlockingDelayInLoop(program: ProgramIR, strategy?: PlatformStrategy): Diagnostic[];