@typecad/cuttlefish 1.0.0-alpha.13 → 1.0.0-alpha.15

package/dist/ir/peripheral-usage.js

@@ -12,7 +12,6 @@ export function createEmptyPeripheralUsage() {
         adc: false,
         pwm: false,
         externalInterrupts: false,
-        timer0: false,
         i2c: false,
         spi: false,
         uart: false,
@@ -23,6 +22,9 @@ export function createEmptyPeripheralUsage() {
         inputPins: new Set(),
         inputPulldownPins: new Set(),
         i2cInstancesUsed: new Set(),
+        sensor: false,
+        sensorPartsUsed: new Set(),
+        spiTargetsUsed: new Set(),
         spiInstancesUsed: new Set(),
         uartInstancesUsed: new Set(),
         pinsUsed: new Set(),
@@ -68,25 +70,6 @@ export function analyzePeripheralUsage(program) {
     }
     return usage;
 }
-function markTimer0UsageFromText(text, usage) {
-    if (!text)
-        return;
-    const normalized = text.replace(/\s+/g, '');
-    if (normalized === 'delay' ||
-        normalized === 'millis' ||
-        normalized === 'micros' ||
-        normalized === 'Board.delay' ||
-        normalized === 'Board.millis' ||
-        normalized === 'Board.micros' ||
-        normalized.startsWith('delay(') ||
-        normalized.startsWith('millis(') ||
-        normalized.startsWith('micros(') ||
-        normalized.startsWith('Board.delay(') ||
-        normalized.startsWith('Board.millis(') ||
-        normalized.startsWith('Board.micros(')) {
-        usage.timer0 = true;
-    }
-}
 function analyzeStatements(statements, usage) {
     if (!statements || !Array.isArray(statements))
         return;
@@ -174,8 +157,6 @@ function analyzeEmitString(cpp, usage) {
         usage.uart = true;
         usage.uartInstancesUsed.add(uartMatch[1] ? parseInt(uartMatch[1], 10) : 0);
     }
-    // delay(), millis(), micros() — timer0
-    markTimer0UsageFromText(cpp, usage);
     // tone(N, ...) — also implies PWM output
     const toneMatch = cpp.match(/^tone\((\d+)/);
     if (toneMatch) {
@@ -240,7 +221,6 @@ function analyzeCalleeForPeripheralUsage(callee, usage) {
             usage.uartInstancesUsed.add(instance);
         }
     }
-    markTimer0UsageFromText(callee, usage);
 }
 /**
  * Extract the bus/UART instance number from a name like "Wire" → 0, "Wire1" → 1, "SPI" → 0, "Serial" → 0, "Serial1" → 1.
@@ -254,60 +234,65 @@ function extractBusInstance(busOrPort, prefix) {
  */
 function analyzeHALOp(op, usage) {
     switch (op.operation) {
-        // GPIO — pin mode configuration
-        case 'gpio.set_mode': {
-            trackPinNumberAsName(op.pin, usage);
-            const mode = op.mode.toLowerCase();
-            if (mode === 'output') {
-                usage.outputPins.add(op.pin);
-            }
-            else if (mode === 'input_pullup') {
-                usage.inputPullupPins.add(op.pin);
-            }
-            else if (mode === 'input_pulldown') {
-                usage.inputPulldownPins.add(op.pin);
-            }
-            else if (mode === 'input') {
-                usage.inputPins.add(op.pin);
-            }
-            break;
-        }
+        // GPIO
         case 'gpio.write':
         case 'gpio.read':
+        case 'gpio.read_cfg':
         case 'gpio.toggle': {
             trackPinNumberAsName(op.pin, usage);
             break;
         }
-        // PWM
-        case 'pwm.write': {
-            trackPinNumberAsName(op.pin, usage);
-            usage.pwm = true;
-            usage.pwmPinsUsed.add(op.pin);
+        case 'gpio.shift_out':
+        case 'gpio.shift_in': {
+            trackPinNumberAsName(op.dataPin, usage);
+            trackPinNumberAsName(op.clockPin, usage);
+            usage.outputPins.add(op.clockPin);
+            usage.outputPins.add(op.dataPin);
             break;
         }
-        case 'pwm.get_frequency':
-        case 'pwm.get_resolution': {
+        // Thin GPIO configure — flag-token text feeds the same mode sets the
+        // legacy mode-set ops do (diagnostics + conflict checks).
+        case 'gpio.configure': {
             trackPinNumberAsName(op.pin, usage);
+            const flags = String(op.flags ?? '');
+            if (flags.includes('GPIO.OUTPUT')) {
+                usage.outputPins.add(op.pin);
+            }
+            else {
+                if (flags.includes('GPIO.PULL_UP'))
+                    usage.inputPullupPins.add(op.pin);
+                else if (flags.includes('GPIO.PULL_DOWN'))
+                    usage.inputPulldownPins.add(op.pin);
+                else
+                    usage.inputPins.add(op.pin);
+            }
             break;
         }
-        // ADC
-        case 'adc.read':
-        case 'adc.read_voltage': {
-            usage.adc = true;
-            usage.adcChannelsUsed.add(op.pin);
+        // PWM
+        case 'pwm.set_pulse':
+        case 'pwm.set_duty':
+        case 'pwm.set_period': {
+            trackPinNumberAsName(op.pin, usage);
+            usage.pwm = true;
+            usage.pwmPinsUsed.add(op.pin);
             break;
         }
-        case 'adc.get_resolution':
-        case 'adc.set_reference':
-        case 'adc.get_reference':
+        // ADC
+        case 'adc.read_raw':
+        case 'adc.read_mv':
+            {
+                usage.adc = true;
+                usage.adcChannelsUsed.add(op.pin);
+                break;
+            }
             break;
         // DAC
-        case 'dac.write': {
+        case 'dac.write_value': {
             trackPinNumberAsName(op.pin, usage);
             break;
         }
         // Interrupts
-        case 'interrupt.attach': {
+        case 'interrupt.attach_flags': {
             trackPinNumberAsName(op.pin, usage);
             usage.externalInterrupts = true;
             usage.interruptPinsUsed.add(op.pin);
@@ -318,103 +303,48 @@ function analyzeHALOp(op, usage) {
             break;
         }
         // Tone
-        case 'tone.play': {
-            usage.pwm = true;
-            usage.pwmPinsUsed.add(op.pin);
-            break;
-        }
-        case 'tone.stop': {
-            trackPinNumberAsName(op.pin, usage);
-            break;
-        }
-        // Timing
-        case 'timing.delay':
-        case 'timing.delay_microseconds':
-        case 'timing.millis':
-        case 'timing.micros': {
-            usage.timer0 = true;
-            break;
-        }
-        case 'timing.free_heap':
-        case 'timing.set_interval':
-        case 'timing.set_timeout':
-        case 'timing.clear_interval':
-        case 'timing.clear_timeout':
-            break;
-        // I2C
-        case 'i2c.begin': {
-            usage.i2c = true;
-            usage.i2cInstancesUsed.add(extractBusInstance(op.bus, 'Wire'));
-            break;
-        }
-        case 'i2c.end':
-        case 'i2c.set_clock':
-        case 'i2c.begin_transmission':
-        case 'i2c.write':
-        case 'i2c.end_transmission':
-        case 'i2c.request_from':
-        case 'i2c.available':
-        case 'i2c.read':
-        case 'i2c.recover': {
-            usage.i2c = true;
-            usage.i2cInstancesUsed.add(extractBusInstance(op.bus, 'Wire'));
-            break;
-        }
-        // SPI
-        case 'spi.begin': {
-            usage.spi = true;
-            usage.spiInstancesUsed.add(extractBusInstance(op.bus, 'SPI'));
-            break;
-        }
-        case 'spi.end':
-        case 'spi.transfer':
-        case 'spi.begin_transaction':
-        case 'spi.end_transaction':
-        case 'spi.set_mode':
-        case 'spi.set_bit_order': {
+        // Tier-2 thin SPI (hal/spi-target.ts) — instances used, plus the distinct
+        // constructed targets (bus|cs|hz|mode) that feed the DT child nodes and
+        // per-target spi_dt_spec state.
+        case 'spi.transceive':
+        case 'spi.dev_write':
+        case 'spi.reg_read': {
             usage.spi = true;
             usage.spiInstancesUsed.add(extractBusInstance(op.bus, 'SPI'));
+            usage.spiTargetsUsed.add(`${String(op.bus)}|${op.cs}|${op.hz ?? 0}|${op.mode ?? 0}`);
             break;
         }
-        case 'spi.cs_low':
-        case 'spi.cs_high': {
-            trackPinNumberAsName(op.pin, usage);
-            break;
-        }
-        // UART
-        case 'uart.begin': {
-            usage.uart = true;
-            usage.uartInstancesUsed.add(extractBusInstance(op.port, 'Serial'));
+        // DT-bound sensor parts (generic catalog). A sensor rides the I2C bus, so
+        // each use marks the bus instance used too — the overlay enables exactly
+        // the controllers that carry constructed sensors.
+        case 'sensor.fetch':
+        case 'sensor.get': {
+            usage.sensor = true;
+            const kind = String(op.busKind ?? 'i2c');
+            const part = String(op.part ?? '');
+            const busInstance = kind === 'spi' ? extractBusInstance(op.bus, 'SPI') : extractBusInstance(op.bus, 'Wire');
+            // Instance-level claims only: the category booleans mean EVERY
+            // declared controller is in play to the resource-conflict checker
+            // (resource-analysis.ts), which would raise phantom pin conflicts
+            // between unused silicon instances.
+            if (kind === 'spi') {
+                usage.spiInstancesUsed.add(busInstance);
+            }
+            else {
+                usage.i2cInstancesUsed.add(busInstance);
+            }
+            usage.sensorPartsUsed.add(`${part}|${kind}${busInstance}|${op.port ?? 0}`);
             break;
         }
-        case 'uart.end':
-        case 'uart.print':
-        case 'uart.println':
-        case 'uart.printf':
-        case 'uart.write':
-        case 'uart.read':
-        case 'uart.peek':
-        case 'uart.available':
-        case 'uart.flush': {
+        // SPI
+        // Tier-2 thin UART (hal/uart-port.ts).
+        case 'uart.poll_write':
+        case 'uart.rx_arm':
+        case 'uart.rx_available':
+        case 'uart.rx_peek':
+        case 'uart.rx_read': {
             usage.uart = true;
-            usage.uartInstancesUsed.add(extractBusInstance(op.port, 'Serial'));
-            break;
-        }
-        // Pulse
-        case 'pulse.in':
-        case 'pulse.in_long': {
-            trackPinNumberAsName(op.pin, usage);
-            break;
-        }
-        // Shift
-        case 'shift.out': {
-            trackPinNumberAsName(op.dataPin, usage);
-            trackPinNumberAsName(op.clockPin, usage);
-            break;
-        }
-        case 'shift.in': {
-            trackPinNumberAsName(op.dataPin, usage);
-            trackPinNumberAsName(op.clockPin, usage);
+            usage.uartInstancesUsed.add(extractBusInstance(op.port, 'UART'));
             break;
         }
         // Board resolve, snprintf, raw — no peripheral tracking needed
@@ -551,7 +481,6 @@ function analyzeExpression(expr, usage) {
     try {
         switch (expr.kind) {
             case 'raw': {
-                markTimer0UsageFromText(expr.value, usage);
                 break;
             }
             case 'method-call': {

package/dist/ir/peripheral-validation.js

@@ -6,6 +6,13 @@
 // ---------------------------------------------------------------------------
 /**
  * Get peripheral capacity from board constants.
+ *
+ * The count comes from an explicit `peripherals.<bus>.count` key when the
+ * board carries one; otherwise it is derived from the flattened instance
+ * entries (`peripherals.<bus>.<N>.instance`, produced by the MCU package's
+ * *_INSTANCES arrays) so a board whose MCU declares two I2C controllers
+ * accepts I2C1 (the Arduino-pico and ESP32 cores both expose the second
+ * bus). Only when neither form is present does it fall back to 1.
  */
 function getPeripheralCapacity(boardConstants) {
     const defaultCapacity = {
@@ -16,10 +23,23 @@ function getPeripheralCapacity(boardConstants) {
     if (!boardConstants) {
         return defaultCapacity;
     }
+    const capacityFor = (bus) => {
+        const explicit = boardConstants.get(`peripherals.${bus}.count`);
+        if (typeof explicit === 'number')
+            return explicit;
+        let highest = -1;
+        for (let i = 0; i < 16; i++) {
+            const instance = boardConstants.get(`peripherals.${bus}.${i}.instance`);
+            if (instance === undefined)
+                break;
+            highest = i;
+        }
+        return highest >= 0 ? highest + 1 : 1;
+    };
     return {
-        i2c: boardConstants.get('peripherals.i2c.count') ?? 1,
-        spi: boardConstants.get('peripherals.spi.count') ?? 1,
-        uart: boardConstants.get('peripherals.uart.count') ?? 1,
+        i2c: capacityFor('i2c'),
+        spi: capacityFor('spi'),
+        uart: capacityFor('uart'),
     };
 }
 /**

package/dist/ir/pin-capability-validation.d.ts

@@ -1,5 +1,17 @@
 import type { ProgramIR } from '../api/index.js';
+import type { BoardConstants } from './board-resolver.js';
 import type { Diagnostic } from '../types.js';
+/**
+ * Resolve the `pins.all.<INDEX>` entry for a HAL pin NUMBER.
+ *
+ * The array is keyed by position, but pin numbers are sparse on MCUs with
+ * unbonded pads (STM32F411: PB11 doesn't exist, so PB12 = number 28 sits at
+ * array index 27) — keying `pins.all.${number}` reads the WRONG pin's entry
+ * for every pin past the first gap. Match by the entry's `number` field; the
+ * dense case (index === number) is checked first so the common path stays a
+ * single lookup. Returns -1 when no entry matches.
+ */
+export declare function pinEntryIndexForNumber(pinNumber: number, boardConstants: BoardConstants | undefined): number;
 /**
  * Validate that capability-specific methods are only called on pins that support them.
  */

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

@@ -15,16 +15,16 @@ function assertNever(x) {
 // ---------------------------------------------------------------------------
 /** Maps a HAL operation string to the board-definition capability flag it requires. */
 function operationToCapability(op) {
-    if (op === 'pwm.write' || op === 'pwm.get_frequency' || op === 'pwm.get_resolution' || op === 'tone.play') {
+    if (op === 'pwm.set_pulse' || op === 'pwm.set_duty' || op === 'pwm.set_period') {
         return 'pwm';
     }
-    if (op === 'adc.read' || op === 'adc.read_voltage' || op === 'adc.get_resolution') {
+    if (op === 'adc.read_raw' || op === 'adc.read_mv') {
         return 'analogInput';
     }
-    if (op === 'dac.write') {
+    if (op === 'dac.write_value') {
         return 'analogOutput';
     }
-    if (op === 'interrupt.attach') {
+    if (op === 'interrupt.attach_flags') {
         return 'interrupt';
     }
     // GPIO and timing ops are always available — no capability check needed.
@@ -33,11 +33,49 @@ function operationToCapability(op) {
 // ---------------------------------------------------------------------------
 // Board constant lookups
 // ---------------------------------------------------------------------------
+/**
+ * The number of `pins.all.*` entries the board declares (dense, from 0). The
+ * P3 full-SoC-port sweep can push well past the old 100/200 hard caps (the
+ * Teensy 4.1 sweeps 288 pads), so every scan bounds itself by the actual
+ * count instead of a magic limit.
+ */
+function pinCount(boardConstants) {
+    if (!boardConstants)
+        return 0;
+    let i = 0;
+    while (i < 4096 && boardConstants.get(`pins.all.${i}.name`) !== undefined)
+        i++;
+    return i;
+}
+/**
+ * Resolve the `pins.all.<INDEX>` entry for a HAL pin NUMBER.
+ *
+ * The array is keyed by position, but pin numbers are sparse on MCUs with
+ * unbonded pads (STM32F411: PB11 doesn't exist, so PB12 = number 28 sits at
+ * array index 27) — keying `pins.all.${number}` reads the WRONG pin's entry
+ * for every pin past the first gap. Match by the entry's `number` field; the
+ * dense case (index === number) is checked first so the common path stays a
+ * single lookup. Returns -1 when no entry matches.
+ */
+export function pinEntryIndexForNumber(pinNumber, boardConstants) {
+    if (!boardConstants)
+        return -1;
+    if (Number(boardConstants.get(`pins.all.${pinNumber}.number`)) === pinNumber)
+        return pinNumber;
+    for (let i = 0; i < pinCount(boardConstants); i++) {
+        if (boardConstants.get(`pins.all.${i}.name`) === undefined)
+            continue;
+        if (Number(boardConstants.get(`pins.all.${i}.number`)) === pinNumber)
+            return i;
+    }
+    return -1;
+}
 /** Find the human-readable name for a pin number (e.g. 14 → "PC0" or "A0"). */
 function getPinName(pinNumber, boardConstants) {
     if (!boardConstants)
         return `pin ${pinNumber}`;
-    const name = boardConstants.get(`pins.all.${pinNumber}.name`);
+    const idx = pinEntryIndexForNumber(pinNumber, boardConstants);
+    const name = idx >= 0 ? boardConstants.get(`pins.all.${idx}.name`) : undefined;
     return name ? String(name) : `pin ${pinNumber}`;
 }
 /** Find all pins on this board that support a given capability. */
@@ -45,67 +83,17 @@ function findPinsWithCapability(capability, boardConstants) {
     if (!boardConstants)
         return [];
     const result = [];
-    const funcTypeMap = {
-        pwm: 'pwm',
-        analogInput: 'adc',
-        analogOutput: 'dac',
-        interrupt: 'interrupt',
-    };
-    const funcType = funcTypeMap[capability];
-    for (let i = 0; i < 100; i++) {
+    for (let i = 0; i < pinCount(boardConstants); i++) {
         const name = boardConstants.get(`pins.all.${i}.name`);
         if (name === undefined)
             continue;
-        // Check capabilities flag first
         const capFlag = boardConstants.get(`pins.all.${i}.capabilities.${capability}`);
         if (capFlag === true || capFlag === 'true') {
             result.push(String(name));
-            continue;
-        }
-        // Fallback: check functions array
-        if (funcType) {
-            for (let j = 0; j < 10; j++) {
-                const type = boardConstants.get(`pins.all.${i}.functions.${j}.type`);
-                if (type === undefined)
-                    break;
-                if (String(type) === funcType) {
-                    result.push(String(name));
-                    break;
-                }
-            }
         }
     }
     return result;
 }
-/**
- * Does the board declare ANY per-pin `type:'pwm'` function entry anywhere?
- *
- * AVR-family boards (atmega328p, etc.) hardwire PWM to specific timer-output
- * pins, so their MCU descriptors list `{ type:'pwm', ... }` per pin and the
- * capability check correctly rejects PWM on non-timer pins. ESP32-family
- * boards route LEDC to ANY output GPIO via the GPIO matrix, so their MCU
- * descriptors carry zero `type:'pwm'` entries — PWM is a board-wide property
- * (the `pins.pwm` collection), not a per-pin function. On such boards the
- * per-pin capability check would false-positive on every pin, so the caller
- * skips it when this returns false. This distinguishes the two families
- * cleanly (AVR has entries, ESP32 has none) without special-casing arch names.
- */
-function boardHasAnyPwmFunctionEntries(boardConstants) {
-    if (!boardConstants)
-        return false;
-    for (let i = 0; i < 100; i++) {
-        if (boardConstants.get(`pins.all.${i}.name`) === undefined)
-            continue;
-        for (let j = 0; j < 10; j++) {
-            const type = boardConstants.get(`pins.all.${i}.functions.${j}.type`);
-            if (type === undefined)
-                break;
-            if (String(type) === 'pwm')
-                return true;
-        }
-    }
-    return false;
-}
 // ---------------------------------------------------------------------------
 // Capability check for a single HAL operation
 // ---------------------------------------------------------------------------
@@ -117,53 +105,29 @@ function checkCapability(operation, sourceLine, sourceCol, filePath, boardConsta
     const capability = operationToCapability(op);
     if (!capability)
         return; // GPIO/timing — always available.
-    // ESP32-family boards route PWM (LEDC) to any output GPIO via the GPIO
-    // matrix, so they carry zero per-pin `type:'pwm'` entries (unlike AVR,
-    // which hardwires PWM to timer-output pins). On such boards the per-pin PWM
-    // capability check would reject every pin; skip it and let the framework's
-    // LEDC driver handle routing. This does NOT weaken AVR, which has entries.
-    if (capability === 'pwm' && !boardHasAnyPwmFunctionEntries(boardConstants))
+    // Construction-time routing overrides (the escape hatch) let a user vouch
+    // for a pin the facts layer doesn't cover — skip the capability check so
+    // an explicit channel/device/controller/pinctrl override is never rejected
+    // by the per-pin flag.
+    const override = operation;
+    if ((override.channelOverride !== undefined && override.channelOverride !== -1)
+        || override.deviceOverride
+        || override.pinctrlOverride
+        || override.controllerOverride) {
         return;
+    }
     const pin = operation.pin;
     if (typeof pin !== 'number' || pin < 0)
         return;
-    // ADC channel reads (ADC.read(channel)) use channel numbers, not pin
-    // numbers — skip capability checking for adc ops where the "pin" is
-    // actually a channel index (0-7 range, below the first analog pin).
-    if (capability === 'analogInput' && op.startsWith('adc.') && pin < 14)
-        return;
-    // Check the pin's capability via the board definition.
-    // Try the capabilities flag first, then fall back to scanning the
-    // functions array (functions.N.type === capability prefix).
-    const capFlag = boardConstants?.get(`pins.all.${pin}.capabilities.${capability}`);
+    // Check the pin's capability via the board definition's per-pin flag.
+    // The entry is resolved by pin NUMBER — the array index diverges from the
+    // number on MCUs with unbonded pads (see pinEntryIndexForNumber).
+    const entryIdx = pinEntryIndexForNumber(pin, boardConstants);
+    if (entryIdx < 0)
+        return; // Unknown pin — the emitter's own resolution reports it.
+    const capFlag = boardConstants?.get(`pins.all.${entryIdx}.capabilities.${capability}`);
     if (capFlag === true || capFlag === 'true')
         return; // Capability confirmed.
-    // Fallback: scan the functions array for a matching type.
-    // PWM capability is indicated by functions[N].type === 'pwm',
-    // ADC by 'adc', interrupts by 'interrupt' (external), DAC by 'dac'.
-    const funcTypeMap = {
-        pwm: 'pwm',
-        analogInput: 'adc',
-        analogOutput: 'dac',
-        interrupt: 'interrupt',
-    };
-    const funcType = funcTypeMap[capability];
-    if (funcType) {
-        let hasCapabilityData = false;
-        for (let i = 0; i < 10; i++) {
-            const type = boardConstants?.get(`pins.all.${pin}.functions.${i}.type`);
-            if (type === undefined)
-                break;
-            hasCapabilityData = true;
-            if (String(type) === funcType)
-                return; // Capability confirmed via functions.
-        }
-        // If the pin has NO functions entries at all AND the capability we're
-        // checking is interrupt (which is stored in capabilities, not functions),
-        // we can't determine support — skip to avoid false positives.
-        if (!hasCapabilityData && capability === 'interrupt')
-            return;
-    }
     // Capability NOT supported — emit a diagnostic.
     const pinName = getPinName(pin, boardConstants);
     const validPins = findPinsWithCapability(capability, boardConstants);

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

@@ -17,7 +17,7 @@ const READ_METHODS = new Set([
 ]);
 /** Write operations that implicitly set OUTPUT mode on Wiring-derived frameworks. */
 const WRITE_METHODS = new Set([
-    'write', 'high', 'low', 'toggle', 'pulse', 'pwm', 'tone',
+    'write', 'high', 'low', 'toggle', 'pulse', 'pwm',
 ]);
 /** Receiver kinds that represent GPIO pins. */
 const PIN_RECEIVER_KINDS = new Set([
@@ -85,7 +85,7 @@ export function validatePinModeConfig(program) {
     const inferReceiverKind = (method) => {
         if (method === 'readAnalog' || method === 'readVoltage')
             return 'analog-input';
-        if (method === 'pwm' || method === 'tone')
+        if (method === 'pwm')
             return 'pwm';
         // Methods in the read/write/mode sets that aren't analog/pwm are digital.
         if (READ_METHODS.has(method) || WRITE_METHODS.has(method) || MODE_SET_METHODS.has(method))
@@ -99,11 +99,11 @@ export function validatePinModeConfig(program) {
         if (!op)
             return;
         const pinKey = `pin${op.pin}`;
-        if (op.operation === 'gpio.set_mode') {
+        if (op.operation === 'gpio.configure' || op.operation === 'gpio.read_cfg') {
             pinModeSet.add(pinKey);
             analogDrivenPins.delete(pinKey);
         }
-        else if (op.operation === 'pwm.write' || op.operation === 'tone.play') {
+        else if (op.operation === 'pwm.set_pulse' || op.operation === 'pwm.set_duty') {
             analogDrivenPins.add(pinKey);
         }
         else if (op.operation === 'gpio.write' || op.operation === 'gpio.toggle') {
@@ -270,7 +270,7 @@ export function validatePinModeConfig(program) {
     const checkStatement = (stmt) => {
         if (!stmt || typeof stmt !== 'object')
             return;
-        // HAL-op statements: track pin-mode state from gpio.set_mode and warn on
+        // HAL-op statements: track pin-mode state from gpio.configure and warn on
         // gpio.read/write/toggle without prior mode configuration. After HAL
         // resolution, pin method calls (D2.isHigh(), D2.high()) become these
         // structured ops — the method-call form no longer exists at validation time.