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

package/dist/ir/peripheral-ownership.js

@@ -32,6 +32,7 @@ export function validatePeripheralOwnership(program) {
                             severity: 'error',
                             message: `Double-take: '${bus}' is already owned.`,
                             hint: `Call '${bus}.release()' before taking it again.`,
+                            filePath: span.filePath,
                             line: span.startLine,
                             column: span.startColumn,
                             code: 'hal-ownership-double-take',
@@ -79,6 +80,7 @@ export function validatePeripheralOwnership(program) {
                             severity: 'error',
                             message: `Double-take: '${bus}' is already owned.`,
                             hint: `Call '${bus}.release()' before taking it again.`,
+                            filePath: span.filePath,
                             line: span.startLine,
                             column: span.startColumn,
                             code: 'hal-ownership-double-take',
@@ -94,6 +96,7 @@ export function validatePeripheralOwnership(program) {
                             severity: 'warning',
                             message: `'${bus}.release()' called but bus was not taken.`,
                             hint: `Ensure you call '${bus}.take()' before releasing.`,
+                            filePath: span.filePath,
                             line: span.startLine,
                             column: span.startColumn,
                             code: 'hal-ownership-unowned-release',
@@ -108,6 +111,7 @@ export function validatePeripheralOwnership(program) {
                         severity: 'error',
                         message: `Unowned access: '${bus}' is used without being taken.`,
                         hint: `Call 'const bus = ${bus}.take();' and use the returned 'bus' object, or ensure '${bus}' is taken in the current scope.`,
+                        filePath: span.filePath,
                         line: span.startLine,
                         column: span.startColumn,
                         code: 'hal-ownership-unowned-access',
@@ -142,6 +146,7 @@ export function validatePeripheralOwnership(program) {
             severity: 'warning',
             message: `'${bus}' was taken but never released.`,
             hint: `Call '${bus}.release()' when finished with the bus.`,
+            filePath: busSpan.filePath,
             line: busSpan.startLine,
             column: busSpan.startColumn,
             code: 'hal-ownership-leak',

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

@@ -5,4 +5,4 @@ import { Diagnostic } from '../types.js';
  * Validate peripheral usage and return diagnostics.
  * This is the main entry point for peripheral validation.
  */
-export declare function validatePeripherals(usage: PeripheralUsage, boardConstants: BoardConstants | undefined): Diagnostic[];
+export declare function validatePeripherals(usage: PeripheralUsage, boardConstants: BoardConstants | undefined, filePath: string): Diagnostic[];

package/dist/ir/peripheral-validation.js

@@ -26,7 +26,7 @@ function getPeripheralCapacity(boardConstants) {
  * Validate peripheral usage against board capacity.
  * Returns an array of diagnostics for any invalid peripheral usage.
  */
-function validatePeripheralUsage(usage, capacity, boardName = 'this board') {
+function validatePeripheralUsage(usage, capacity, boardName, filePath) {
     const diagnostics = [];
     // Validate I2C instances
     for (const instance of usage.i2cInstancesUsed) {
@@ -36,6 +36,7 @@ function validatePeripheralUsage(usage, capacity, boardName = 'this board') {
                 severity: 'error',
                 message: `I2C${instance} is not available on ${boardName}. Available: ${availableName}`,
                 code: 'peripheral-not-available',
+                filePath,
                 source: 'peripheral-validation',
             });
         }
@@ -48,6 +49,7 @@ function validatePeripheralUsage(usage, capacity, boardName = 'this board') {
                 severity: 'error',
                 message: `SPI${instance} is not available on ${boardName}. Available: ${availableName}`,
                 code: 'peripheral-not-available',
+                filePath,
                 source: 'peripheral-validation',
             });
         }
@@ -60,6 +62,7 @@ function validatePeripheralUsage(usage, capacity, boardName = 'this board') {
                 severity: 'error',
                 message: `UART${instance} is not available on ${boardName}. Available: ${availableName}`,
                 code: 'peripheral-not-available',
+                filePath,
                 source: 'peripheral-validation',
             });
         }
@@ -70,8 +73,8 @@ function validatePeripheralUsage(usage, capacity, boardName = 'this board') {
  * Validate peripheral usage and return diagnostics.
  * This is the main entry point for peripheral validation.
  */
-export function validatePeripherals(usage, boardConstants) {
+export function validatePeripherals(usage, boardConstants, filePath) {
     const capacity = getPeripheralCapacity(boardConstants);
     const boardName = boardConstants?.get('name') ?? 'this board';
-    return validatePeripheralUsage(usage, capacity, boardName);
+    return validatePeripheralUsage(usage, capacity, boardName, filePath);
 }

package/dist/ir/pin-alias-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 validatePinAliasConflicts(usage: PeripheralUsage, boardConstants: BoardConstants | undefined): Diagnostic[];
+export declare function validatePinAliasConflicts(usage: PeripheralUsage, boardConstants: BoardConstants | undefined, filePath: string): Diagnostic[];

package/dist/ir/pin-alias-conflict.js

@@ -1,5 +1,5 @@
 import { findBoardPinByName } from './board-pin-utils.js';
-export function validatePinAliasConflicts(usage, boardConstants) {
+export function validatePinAliasConflicts(usage, boardConstants, filePath) {
     if (!boardConstants || usage.pinsUsed.size === 0) {
         return [];
     }
@@ -26,6 +26,7 @@ export function validatePinAliasConflicts(usage, boardConstants) {
         diagnostics.push({
             severity: 'warning',
             code: 'pin-alias-conflict',
+            filePath,
             source: 'pin-alias-conflict',
             message: `Pin '${canonicalPinName}' is referenced through multiple names${boardLabel}: ${orderedNames.join(', ')}. These names refer to the same physical pin. Pick one name to keep pin usage and diagnostics unambiguous.`,
         });

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;

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"
@@ -234,6 +258,32 @@ 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;
+            }
+            if (statement.callee.startsWith("console.") || 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 +407,33 @@ 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;
+                // 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 +461,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 (/\b(Serial|console)\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,6 +523,14 @@ 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,
@@ -585,5 +685,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[];

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.`,
         }];