@typecad/cuttlefish 1.0.0-alpha.3 → 1.0.0-alpha.7

package/dist/ir/pin-capability-validation.js

@@ -80,7 +80,7 @@ function findPinsWithCapability(capability, boardConstants) {
 // ---------------------------------------------------------------------------
 // Capability check for a single HAL operation
 // ---------------------------------------------------------------------------
-function checkCapability(operation, sourceLine, sourceCol, boardConstants, diagnostics) {
+function checkCapability(operation, sourceLine, sourceCol, filePath, boardConstants, diagnostics) {
     // Only operations with a pin field are capability-checked.
     const op = operation.operation;
     if (!('pin' in operation))
@@ -145,48 +145,49 @@ function checkCapability(operation, sourceLine, sourceCol, boardConstants, diagn
         hint,
         line: sourceLine,
         column: sourceCol,
+        filePath,
         source: 'pin-capability-validation',
     });
 }
 // ---------------------------------------------------------------------------
 // IR tree scanner
 // ---------------------------------------------------------------------------
-function scanExpression(expr, boardConstants, parentLine, parentCol, diagnostics) {
+function scanExpression(expr, boardConstants, parentLine, parentCol, parentFilePath, diagnostics) {
     if (!expr || typeof expr !== 'object')
         return;
     switch (expr.kind) {
         case 'binary': {
-            scanExpression(expr.left, boardConstants, parentLine, parentCol, diagnostics);
-            scanExpression(expr.right, boardConstants, parentLine, parentCol, diagnostics);
+            scanExpression(expr.left, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
+            scanExpression(expr.right, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
             break;
         }
         case 'ternary': {
-            scanExpression(expr.condition, boardConstants, parentLine, parentCol, diagnostics);
-            scanExpression(expr.whenTrue, boardConstants, parentLine, parentCol, diagnostics);
-            scanExpression(expr.whenFalse, boardConstants, parentLine, parentCol, diagnostics);
+            scanExpression(expr.condition, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
+            scanExpression(expr.whenTrue, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
+            scanExpression(expr.whenFalse, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
             break;
         }
         case 'property-access': {
-            scanExpression(expr.object, boardConstants, parentLine, parentCol, diagnostics);
+            scanExpression(expr.object, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
             break;
         }
         case 'unary': {
-            scanExpression(expr.operand, boardConstants, parentLine, parentCol, diagnostics);
+            scanExpression(expr.operand, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
             break;
         }
         case 'paren': {
-            scanExpression(expr.inner, boardConstants, parentLine, parentCol, diagnostics);
+            scanExpression(expr.inner, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
             break;
         }
         case 'array': {
             for (const el of expr.elements) {
-                scanExpression(el, boardConstants, parentLine, parentCol, diagnostics);
+                scanExpression(el, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
             }
             break;
         }
         case 'object': {
             for (const field of expr.fields) {
-                scanExpression(field.value, boardConstants, parentLine, parentCol, diagnostics);
+                scanExpression(field.value, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
             }
             break;
         }
@@ -204,43 +205,43 @@ function scanExpression(expr, boardConstants, parentLine, parentCol, diagnostics
         }
         case 'method-call': {
             for (const arg of expr.args) {
-                scanExpression(arg, boardConstants, parentLine, parentCol, diagnostics);
+                scanExpression(arg, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
             }
             break;
         }
         case 'element-access': {
-            scanExpression(expr.object, boardConstants, parentLine, parentCol, diagnostics);
-            scanExpression(expr.index, boardConstants, parentLine, parentCol, diagnostics);
+            scanExpression(expr.object, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
+            scanExpression(expr.index, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
             break;
         }
         case 'string_concat': {
             for (const part of expr.parts) {
-                scanExpression(part, boardConstants, parentLine, parentCol, diagnostics);
+                scanExpression(part, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
             }
             break;
         }
         case 'template_string': {
-            scanExpression(expr.expression, boardConstants, parentLine, parentCol, diagnostics);
+            scanExpression(expr.expression, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
             break;
         }
         case 'spread_array': {
-            scanExpression(expr.spreadExpr, boardConstants, parentLine, parentCol, diagnostics);
+            scanExpression(expr.spreadExpr, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
             for (const el of expr.additionalElements) {
-                scanExpression(el, boardConstants, parentLine, parentCol, diagnostics);
+                scanExpression(el, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
             }
             break;
         }
         case 'instanceof': {
-            scanExpression(expr.object, boardConstants, parentLine, parentCol, diagnostics);
+            scanExpression(expr.object, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
             break;
         }
         case 'await': {
-            scanExpression(expr.value, boardConstants, parentLine, parentCol, diagnostics);
+            scanExpression(expr.value, boardConstants, parentLine, parentCol, parentFilePath, diagnostics);
             break;
         }
         case 'hal-expr': {
             // Expression-form HAL operation (e.g. adc.read used as a value).
-            checkCapability(expr.operation, parentLine, parentCol, boardConstants, diagnostics);
+            checkCapability(expr.operation, parentLine, parentCol, parentFilePath, boardConstants, diagnostics);
             break;
         }
         case 'number':
@@ -259,20 +260,21 @@ function scanStatement(stmt, boardConstants, diagnostics) {
         return;
     const line = stmt.sourceSpan?.startLine;
     const col = stmt.sourceSpan?.startColumn;
+    const filePath = stmt.sourceSpan?.filePath;
     switch (stmt.kind) {
         case 'var_decl': {
             if (stmt.initializer)
-                scanExpression(stmt.initializer, boardConstants, line, col, diagnostics);
+                scanExpression(stmt.initializer, boardConstants, line, col, filePath, diagnostics);
             break;
         }
         case 'assign': {
             if (stmt.value)
-                scanExpression(stmt.value, boardConstants, line, col, diagnostics);
+                scanExpression(stmt.value, boardConstants, line, col, filePath, diagnostics);
             break;
         }
         case 'if': {
             if (stmt.condition)
-                scanExpression(stmt.condition, boardConstants, line, col, diagnostics);
+                scanExpression(stmt.condition, boardConstants, line, col, filePath, diagnostics);
             for (const s of stmt.thenBranch)
                 scanStatement(s, boardConstants, diagnostics);
             if (stmt.elseBranch)
@@ -283,14 +285,14 @@ function scanStatement(stmt, boardConstants, diagnostics) {
         case 'while':
         case 'do_while': {
             if (stmt.condition)
-                scanExpression(stmt.condition, boardConstants, line, col, diagnostics);
+                scanExpression(stmt.condition, boardConstants, line, col, filePath, diagnostics);
             for (const s of stmt.body)
                 scanStatement(s, boardConstants, diagnostics);
             break;
         }
         case 'for': {
             if (stmt.condition)
-                scanExpression(stmt.condition, boardConstants, line, col, diagnostics);
+                scanExpression(stmt.condition, boardConstants, line, col, filePath, diagnostics);
             if (stmt.initializer)
                 scanStatement(stmt.initializer, boardConstants, diagnostics);
             if (stmt.increment)
@@ -309,23 +311,23 @@ function scanStatement(stmt, boardConstants, diagnostics) {
         }
         case 'return': {
             if (stmt.value)
-                scanExpression(stmt.value, boardConstants, line, col, diagnostics);
+                scanExpression(stmt.value, boardConstants, line, col, filePath, diagnostics);
             break;
         }
         case 'call': {
             for (const arg of stmt.args) {
-                scanExpression(arg, boardConstants, line, col, diagnostics);
+                scanExpression(arg, boardConstants, line, col, filePath, diagnostics);
             }
             break;
         }
         case 'hal-op': {
             // Statement-form HAL operation — the primary capability check target.
-            checkCapability(stmt.operation, line, col, boardConstants, diagnostics);
+            checkCapability(stmt.operation, line, col, filePath, boardConstants, diagnostics);
             break;
         }
         case 'switch': {
             if (stmt.expression)
-                scanExpression(stmt.expression, boardConstants, line, col, diagnostics);
+                scanExpression(stmt.expression, boardConstants, line, col, filePath, diagnostics);
             for (const c of stmt.cases) {
                 for (const s of c.body)
                     scanStatement(s, boardConstants, diagnostics);
@@ -355,7 +357,7 @@ function scanStatement(stmt, boardConstants, diagnostics) {
         }
         case 'throw': {
             if (stmt.value)
-                scanExpression(stmt.value, boardConstants, line, col, diagnostics);
+                scanExpression(stmt.value, boardConstants, line, col, filePath, diagnostics);
             break;
         }
         case 'update':

package/dist/ir/pin-mode-validation.js

@@ -43,6 +43,7 @@ export function validatePinModeConfig(program) {
                 message: `Analog pin '${receiver}' used as digital output. ` +
                     `Analog input capability (ADC) is lost while pin is in OUTPUT mode. ` +
                     `Call ${receiver}.asInput() to restore analog reading.`,
+                filePath: program.fileName,
                 code: 'analog-pin-as-output',
                 source: 'pin-mode-validation',
             });
@@ -55,6 +56,7 @@ export function validatePinModeConfig(program) {
                 severity: 'warning',
                 message: `Pin '${receiver}' read via '${method}()' without prior mode configuration. ` +
                     `Call ${receiver}.asInput() or ${receiver}.inputPullUp() first.`,
+                filePath: program.fileName,
                 code: 'pin-mode-not-set',
                 source: 'pin-mode-validation',
             });
@@ -64,6 +66,7 @@ export function validatePinModeConfig(program) {
                 severity: 'info',
                 message: `Pin '${receiver}' written via '${method}()' without explicit mode configuration. ` +
                     `Arduino implicitly sets OUTPUT, but explicit ${receiver}.asOutput() is recommended.`,
+                filePath: program.fileName,
                 code: 'pin-mode-not-set',
                 source: 'pin-mode-validation',
             });
@@ -100,6 +103,7 @@ export function validatePinModeConfig(program) {
                 severity: 'warning',
                 message: `Pin ${op.pin} read without prior mode configuration. ` +
                     `Call asInput() or inputPullUp() first — reading a floating pin is undefined behavior.`,
+                filePath: program.fileName,
                 code: 'pin-mode-not-set',
                 source: 'pin-mode-validation',
             });
@@ -109,6 +113,7 @@ export function validatePinModeConfig(program) {
                 severity: 'info',
                 message: `Pin ${op.pin} written without explicit mode configuration. ` +
                     `Arduino implicitly sets OUTPUT, but explicit asOutput() is recommended.`,
+                filePath: program.fileName,
                 code: 'pin-mode-not-set',
                 source: 'pin-mode-validation',
             });

package/dist/ir/pin-safety.d.ts

@@ -8,4 +8,4 @@ import type { Diagnostic } from '../types.js';
  * @param boardConstants - Board constants containing pins.unsafe array
  * @returns Array of diagnostic warnings for unsafe pin usage
  */
-export declare function validateUnsafePins(usage: PeripheralUsage, boardConstants: BoardConstants | undefined): Diagnostic[];
+export declare function validateUnsafePins(usage: PeripheralUsage, boardConstants: BoardConstants | undefined, filePath: string): Diagnostic[];

package/dist/ir/pin-safety.js

@@ -30,7 +30,7 @@ function buildUnsafePinMessage(pinName, boardConstants) {
  * @param boardConstants - Board constants containing pins.unsafe array
  * @returns Array of diagnostic warnings for unsafe pin usage
  */
-export function validateUnsafePins(usage, boardConstants) {
+export function validateUnsafePins(usage, boardConstants, filePath) {
     const diagnostics = [];
     if (!boardConstants)
         return diagnostics;
@@ -50,6 +50,7 @@ export function validateUnsafePins(usage, boardConstants) {
                 severity: 'warning',
                 message: buildUnsafePinMessage(pinName, boardConstants),
                 code: 'unsafe-pin-usage',
+                filePath,
                 source: 'pin-safety',
             });
         }

package/dist/ir/program-analysis.d.ts

@@ -29,6 +29,22 @@ export interface ProgramAnalysisResult {
     usesTiming: boolean;
     usesWDT: boolean;
     usesStrPtr: boolean;
+    usesUart: boolean;
+    usesSPI: boolean;
+    usesI2C: boolean;
+    usesEEPROM: boolean;
+    usesTone: boolean;
+    /** map()/constrain() Arduino-API calls. framework-avr gates its native
+     *  _native_map/_native_constrain helpers on these (they're dead code
+     *  otherwise — no other internal caller references them). */
+    usesMap: boolean;
+    usesConstrain: boolean;
+    /** Comprehensive timing gate for the native millis() Timer0 ISR on AVR.
+     *  True when the program directly uses millis/delay/micros, OR has hidden
+     *  consumers of the soft clock: setInterval/setTimeout (timerCallCount),
+     *  async functions (the runtime polls millis), or a mounted UI (per-frame
+     *  tick injected by the emitter, not present in user source). */
+    usesNativeTiming: boolean;
     hasSerialBegin: boolean;
     hasGenerators: boolean;
     usesStdMap: boolean;
@@ -36,6 +52,29 @@ export interface ProgramAnalysisResult {
      *  __tc_TimerRuntime::MAX_TIMERS to the observed count (floor 1) rather than
      *  a blind constant, so a one-timer program links one slot, not eight. */
     timerCallCount: number;
+    /** ESP32 peripheral usage — framework-esp32 gates its IDF driver blocks and
+     *  forced includes on these. Detected from HAL-op operation names, the same
+     *  way usesUart/usesSPI/usesI2C are. Other frameworks have no CUTTLEFISH_*
+     *  blocks with these marker names so the setup.ts filters are no-ops there. */
+    usesGPIO: boolean;
+    usesPWM: boolean;
+    usesRmt: boolean;
+    usesADC: boolean;
+    usesDAC: boolean;
+    usesPower: boolean;
+    usesWdt: boolean;
+    usesInterrupts: boolean;
+    usesPulse: boolean;
+    usesShift: boolean;
+    /** WiFi / HTTP / BLE usage — framework-esp32 gates the __tc_wifi/__tc_http/
+     *  __tc_ble runtime shims and their esp_wifi/esp_http_client/nimble includes
+     *  on these. Detected from wifi.* / http.* / ble.* HAL-op operation names. */
+    usesWifi: boolean;
+    usesHttp: boolean;
+    usesBle: boolean;
+    /** Preferences (NVS) usage — framework-esp32 gates the __tc_prefs runtime shim
+     *  and its nvs_flash/nvs includes on this. Detected from preferences.* ops. */
+    usesPreferences: boolean;
 }
 /**
  * Analyze a program IR in a single pass to detect all features.

package/dist/ir/program-analysis.js

@@ -102,6 +102,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 +216,23 @@ function analyzeExpression(expr, result, strategy) {
                 analyzeExpression(expr.expression, result, strategy);
             }
             break;
+        case "hal-expr":
+            // Value-position HAL ops (e.g. `const ip = WiFi.localIP()` lowers to a
+            // hal-expr initializer) never pass through the statement-level hal-op
+            // detection above, so mirror the wifi./http. flag detection here. These
+            // gate the framework-esp32 __tc_wifi/__tc_http runtime shims.
+            if (expr.operation && typeof expr.operation.operation === "string") {
+                const opName = expr.operation.operation;
+                if (opName.startsWith("wifi."))
+                    result.usesWifi = true;
+                if (opName.startsWith("http."))
+                    result.usesHttp = true;
+                if (opName.startsWith("ble."))
+                    result.usesBle = true;
+                if (opName.startsWith("preferences."))
+                    result.usesPreferences = true;
+            }
+            break;
     }
 }
 /**
@@ -218,6 +259,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 +280,35 @@ 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;
             // 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.`
@@ -357,6 +432,73 @@ 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;
+                }
+                // 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.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;
+                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.startsWith("http."))
+                    result.usesHttp = true;
+                if (opName.startsWith("ble."))
+                    result.usesBle = true;
+                if (opName.startsWith("preferences."))
+                    result.usesPreferences = 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 +526,21 @@ function analyzeStatement(statement, result, strategy) {
                     result.usesTiming = true;
                     result.usesMillis = true;
                 }
+                // 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 +588,32 @@ 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,
+        usesHttp: false,
+        usesBle: false,
+        usesPreferences: false,
     };
     // Analyze type aliases
     for (const typeAlias of program.typeAliases) {
@@ -585,5 +764,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/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[];