@typecad/cuttlefish 1.0.0-alpha.6 → 1.0.0-alpha.8

package/dist/ir/identifier-collector.js

@@ -423,6 +423,22 @@ function collectHALOpIdentifiers(op) {
             // handler is a resolved C++ function name (e.g. "myIsr" or a placeholder)
             identifiers.add(op.handler);
             break;
+        case "mqtt.on_message":
+            // handler is the user's onMessage callback name (callback() resolves it to
+            // a string). Without this the tree-shaker drops the function declaration —
+            // the mqtt.on_message op only carries the name, so the function has no
+            // other reference and looks unreachable. Same shape as interrupt.attach.
+            identifiers.add(op.handler);
+            break;
+        case "wifi.on_event":
+            identifiers.add(op.handler);
+            break;
+        case "ble.on_read":
+        case "ble.on_write":
+        case "ble.on_connect":
+        case "ble.on_disconnect":
+            identifiers.add(op.handler);
+            break;
         case "raw": {
             // Raw C++ code may reference user-defined identifiers
             const matches = op.code.match(/[A-Za-z_][A-Za-z0-9_]*/g);
@@ -435,5 +451,24 @@ function collectHALOpIdentifiers(op) {
         }
         // Other HAL ops have only numeric/literal fields — no identifier references
     }
+    // wifi.* / http.* / mqtt.* ops carry resolved C++ expression texts in their
+    // string fields (e.g. wifi.connect ssid: `WIFI_SSID` — a top-level const, or
+    // a quoted literal). Scan every string field for identifiers so referenced
+    // globals survive tree-shaking; quoted literals are skipped.
+    if (op.operation.startsWith("wifi.") || op.operation.startsWith("http.")
+        || op.operation.startsWith("mqtt.")) {
+        for (const value of Object.values(op)) {
+            if (typeof value !== "string" || value === op.operation)
+                continue;
+            if (/^".*"$/.test(value.trim()))
+                continue;
+            const matches = value.match(/[A-Za-z_][A-Za-z0-9_]*/g);
+            if (matches) {
+                for (const match of matches) {
+                    identifiers.add(match);
+                }
+            }
+        }
+    }
     return identifiers;
 }

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

@@ -1,4 +1,4 @@
-import type { ProgramIR } from '../api/index.js';
+import type { ProgramIR, StatementIR } from '../api/index.js';
 import type { PeripheralUsage } from './peripheral-usage.js';
 import type { Diagnostic } from '../types.js';
 export { walkNestedStatements as scanNestedStatements } from './utils/walk-ir.js';
@@ -24,6 +24,10 @@ export interface InterruptHandlerInfo {
  * @returns Array of diagnostics for interrupt-related issues
  */
 export declare function analyzeInterruptSafety(program: ProgramIR, usage: PeripheralUsage, isrUnsafeOps?: Map<string, IsrUnsafeOp>): Diagnostic[];
+/** Collect variable names assigned (written) within a statement body. */
+export declare function collectAssignedNames(stmts: readonly StatementIR[], names: Set<string>): void;
+/** Collect variable names read (referenced) within a statement body. */
+export declare function collectReadNames(stmts: readonly StatementIR[], names: Set<string>): void;
 /**
  * Infer `volatile` for global variables shared between ISR callbacks and main
  * code. Mutates the IR (sets isVolatile=true on qualifying var_decls) and

package/dist/ir/interrupt-analysis.js

@@ -7,21 +7,13 @@
 import { walkNestedStatements, walkExpressionsInExpression } from './utils/walk-ir.js';
 export { walkNestedStatements as scanNestedStatements } from './utils/walk-ir.js';
 /**
- * Default ISR-unsafe operations used when no platform-specific map is provided.
- * Platforms should supply their own list via PlatformStrategy.isrUnsafeOperations().
+ * Fallback ISR-unsafe operations used when no platform-specific map is provided.
+ * Empty by design — the Wiring-derived specifics (delay, Serial.*, I2C*, SPI*)
+ * live in ArduinoStrategy.isrUnsafeOperations(). A generic target has no known
+ * ISR-unsafe surface. The orchestrator passes the loaded framework's map; this
+ * default only applies when none is supplied.
  */
-const DEFAULT_ISR_UNSAFE_OPERATIONS = new Map([
-    ['delay', { reason: 'delay() blocks the CPU and should not be used in interrupt context', severity: 'warning' }],
-    ['delayMicroseconds', { reason: 'delayMicroseconds() blocks and should be avoided in ISRs', severity: 'warning' }],
-    ['Serial.print', { reason: 'Serial.print() may not work correctly in interrupt context', severity: 'info' }],
-    ['Serial.println', { reason: 'Serial.println() may not work correctly in interrupt context', severity: 'info' }],
-    ['Serial.write', { reason: 'Serial.write() may not work correctly in interrupt context', severity: 'info' }],
-    ['Serial.read', { reason: 'Serial.read() may not work correctly in interrupt context', severity: 'info' }],
-    ['I2C0', { reason: 'I2C operations can cause lockups in interrupt context', severity: 'warning' }],
-    ['I2C1', { reason: 'I2C operations can cause lockups in interrupt context', severity: 'warning' }],
-    ['SPI0', { reason: 'SPI operations may cause issues in interrupt context', severity: 'info' }],
-    ['SPI1', { reason: 'SPI operations may cause issues in interrupt context', severity: 'info' }],
-]);
+const DEFAULT_ISR_UNSAFE_OPERATIONS = new Map();
 /**
  * Analyze a program for interrupt handler issues.
  *
@@ -243,7 +235,7 @@ function scanExpressionForCallbacks(expr, callback, parentExpr) {
 // emission path already handles isVolatile (statement-renderer.ts).
 // ---------------------------------------------------------------------------
 /** Collect variable names assigned (written) within a statement body. */
-function collectAssignedNames(stmts, names) {
+export function collectAssignedNames(stmts, names) {
     for (const stmt of stmts) {
         const s = stmt;
         if (stmt.kind === 'assign') {
@@ -265,7 +257,7 @@ function collectAssignedNames(stmts, names) {
     }
 }
 /** Collect variable names read (referenced) within a statement body. */
-function collectReadNames(stmts, names) {
+export function collectReadNames(stmts, names) {
     for (const stmt of stmts) {
         walkExpressionsInStatement(stmt, (expr) => {
             if (expr.kind === 'identifier' && typeof expr.value === 'string') {

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

@@ -0,0 +1,4 @@
+import type { ProgramIR } from "../api/index.js";
+import type { Diagnostic } from "../types.js";
+import type { BoardConstants } from "./board-resolver.js";
+export declare function validateNetworkUsage(program: ProgramIR, boardConstants?: BoardConstants): Diagnostic[];

package/dist/ir/network-validation.js

@@ -0,0 +1,184 @@
+// ---------------------------------------------------------------------------
+// Network (WiFi / HTTP) Validation
+//
+// Board-aware, compile-time checks for the WiFi/HTTP HAL:
+//
+//   wifi-no-radio             (error)   wifi.*/http.* used on a board whose
+//                                       architecture has no WiFi radio (avr).
+//   http-without-wifi         (warning) http.* used but the program never
+//                                       brings a WiFi link up (connect /
+//                                       connectSaved / connectAsync / AP).
+//   wifi-blocking-in-loop     (warning) blocking WiFi.connect()/scan() or
+//                                       Http send inside loop() — stalls every
+//                                       iteration; use async/await instead.
+//   wifi-ap-password-short    (error)   WiFi.startAP() with a literal WPA2
+//                                       password shorter than 8 characters —
+//                                       esp_wifi rejects it at runtime.
+//   http-max-body-large       (warning) Http maxBody() above 64 KB — the
+//                                       response buffer is heap-allocated.
+//
+// Follows the ADC-validation convention: checks that need board data return
+// nothing when the data is missing (no MCU-name fallbacks).
+// ---------------------------------------------------------------------------
+import { walkProgramIR, walkNestedStatements } from "./utils/walk-ir.js";
+/** Architectures with no WiFi radio. Driven by the `architecture` board
+ *  constant (from the MCU package); absent data emits nothing. */
+const NO_RADIO_ARCHITECTURES = new Set(["avr"]);
+/** Ops that bring the WiFi link (STA or AP) up. */
+const LINK_UP_OPS = new Set([
+    "wifi.connect",
+    "wifi.connect_start",
+    "wifi.connect_saved",
+    "wifi.ap_start",
+]);
+/** Blocking waits that stall loop() for their full duration. */
+const BLOCKING_LOOP_OPS = new Set([
+    "wifi.connect",
+    "wifi.connect_saved",
+    "wifi.wait_connected",
+    "wifi.wait_disconnected",
+    "wifi.scan",
+    "http.send",
+]);
+/** Strip surrounding quotes from a resolved HAL string field; returns null
+ *  when the field is not a literal (identifier/expression — unknowable). */
+function literalString(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    const match = trimmed.match(/^"((?:[^"\\]|\\.)*)"$/);
+    return match ? match[1] : null;
+}
+function diagAt(stmt, partial) {
+    const s = stmt;
+    return {
+        ...partial,
+        line: s.sourceSpan?.startLine,
+        column: s.sourceSpan?.startColumn,
+        filePath: s.sourceSpan?.filePath,
+        source: "network-validation",
+    };
+}
+/** Pull every wifi./http. op out of a statement: hal-op statements, awaited
+ *  __WIFI_WAIT__/__HTTP_WAIT__ marker calls (hal-expr arg), and hal-expr
+ *  expressions in call args / initializers / conditions. */
+function collectNetworkOps(stmt, out) {
+    const s = stmt;
+    const record = (op) => {
+        const operation = op?.operation;
+        if (typeof operation === "string" && (operation.startsWith("wifi.") || operation.startsWith("http."))) {
+            out.push({ op: op, stmt });
+        }
+    };
+    if (stmt.kind === "hal-op")
+        record(s.operation);
+    const visitExpr = (expr) => {
+        if (!expr || typeof expr !== "object")
+            return;
+        const e = expr;
+        if (e.kind === "hal-expr")
+            record(e.operation);
+        for (const key of ["args", "elements", "parts"]) {
+            if (Array.isArray(e[key]))
+                for (const child of e[key])
+                    visitExpr(child);
+        }
+        for (const key of ["left", "right", "operand", "condition", "whenTrue", "whenFalse", "inner", "value", "expression"]) {
+            if (e[key] && typeof e[key] === "object")
+                visitExpr(e[key]);
+        }
+    };
+    for (const key of ["args", "value", "condition", "initializer", "expression"]) {
+        if (s[key]) {
+            if (Array.isArray(s[key]))
+                for (const child of s[key])
+                    visitExpr(child);
+            else
+                visitExpr(s[key]);
+        }
+    }
+}
+export function validateNetworkUsage(program, boardConstants) {
+    const diagnostics = [];
+    const constants = boardConstants ?? program.boardConstants;
+    // Collect every wifi./http. op in the program.
+    const allOps = [];
+    walkProgramIR(program, (stmt) => collectNetworkOps(stmt, allOps));
+    if (allOps.length === 0)
+        return diagnostics;
+    const wifiOps = allOps.filter(({ op }) => op.operation.startsWith("wifi."));
+    const httpOps = allOps.filter(({ op }) => op.operation.startsWith("http."));
+    // ── wifi-no-radio ────────────────────────────────────────────────────────
+    const architecture = constants?.get("architecture");
+    const archName = typeof architecture === "string" ? architecture.replace(/^["']|["']$/g, "").toLowerCase() : null;
+    if (archName && NO_RADIO_ARCHITECTURES.has(archName)) {
+        const first = allOps[0];
+        diagnostics.push(diagAt(first.stmt, {
+            severity: "error",
+            code: "wifi-no-radio",
+            message: `WiFi/HTTP APIs are used but the target board's architecture ('${archName}') has no WiFi radio.`,
+            hint: "Target a WiFi-capable board (e.g. @typecad/board-esp32-devkit) or remove the WiFi/HTTP calls.",
+        }));
+        // No point piling on the remaining checks for a board that can't radio.
+        return diagnostics;
+    }
+    // ── http-without-wifi ────────────────────────────────────────────────────
+    if (httpOps.length > 0 && !wifiOps.some(({ op }) => LINK_UP_OPS.has(op.operation))) {
+        diagnostics.push(diagAt(httpOps[0].stmt, {
+            severity: "warning",
+            code: "http-without-wifi",
+            message: "HTTP requests are made but the program never brings the WiFi link up — every request will fail at runtime.",
+            hint: "Call WiFi.connect(ssid, password) (or WiFi.connectSaved() / WiFi.startAP()) before sending HTTP requests.",
+        }));
+    }
+    // ── wifi-blocking-in-loop ────────────────────────────────────────────────
+    // Blocking hal-op statements inside loop()'s body stall every iteration.
+    // Awaited forms are rewritten to __WIFI_WAIT__/__HTTP_WAIT__ marker calls
+    // (kind "call"), so only genuine blocking hal-ops are flagged here.
+    const loopFn = program.functions.find((fn) => fn.originalName === "loop");
+    if (loopFn?.statements) {
+        const visit = (stmt) => {
+            if (stmt.kind === "hal-op" && BLOCKING_LOOP_OPS.has(stmt.operation?.operation)) {
+                const opName = stmt.operation.operation;
+                diagnostics.push(diagAt(stmt, {
+                    severity: "warning",
+                    code: "wifi-blocking-in-loop",
+                    message: `Blocking network operation '${opName}' inside loop() stalls every iteration until it completes (seconds for a connect/scan/request).`,
+                    hint: "Move the call into an async function and `await` it — the transpiler lowers awaited WiFi/HTTP calls to non-blocking start + poll states.",
+                }));
+            }
+            walkNestedStatements(stmt, visit);
+        };
+        for (const stmt of loopFn.statements)
+            visit(stmt);
+    }
+    // ── wifi-ap-password-short ───────────────────────────────────────────────
+    for (const { op, stmt } of wifiOps) {
+        if (op.operation !== "wifi.ap_start")
+            continue;
+        const password = literalString(op.password);
+        if (password !== null && password.length > 0 && password.length < 8) {
+            diagnostics.push(diagAt(stmt, {
+                severity: "error",
+                code: "wifi-ap-password-short",
+                message: `WiFi.startAP() password is ${password.length} characters — WPA2 requires at least 8, and esp_wifi rejects shorter ones at runtime.`,
+                hint: "Use a password of 8+ characters, or omit the password entirely for an open access point.",
+            }));
+        }
+    }
+    // ── http-max-body-large ──────────────────────────────────────────────────
+    for (const { op, stmt } of httpOps) {
+        if (op.operation !== "http.set_max_body")
+            continue;
+        const bytes = Number(String(op.bytes).trim());
+        if (Number.isFinite(bytes) && bytes > 65536) {
+            diagnostics.push(diagAt(stmt, {
+                severity: "warning",
+                code: "http-max-body-large",
+                message: `Http maxBody(${bytes}) heap-allocates a ${Math.round(bytes / 1024)} KB response buffer — large buffers risk allocation failure under fragmentation.`,
+                hint: "Keep the response cap at or below 64 KB, or process large payloads in chunks server-side.",
+            }));
+        }
+    }
+    return diagnostics;
+}

package/dist/ir/ownership-analysis.js

@@ -765,6 +765,12 @@ function analyzeExpression(expr, scope, diagnostics, fallbackSpan) {
             analyzeExpression(expr.inner, scope, diagnostics, span);
             break;
         }
+        case 'call': {
+            for (const arg of expr.args) {
+                analyzeExpression(arg, scope, diagnostics, span);
+            }
+            break;
+        }
         case 'number':
         case 'string':
         case 'boolean':
@@ -983,7 +989,20 @@ function validateConstSuggestions(program, diagnostics) {
                 // keep the binding non-const so push_back/splice/etc. compile. The
                 // callee is the lowered C++ name, e.g. "arr.push_back".
                 if (stmt.kind === 'call' && typeof stmt.callee === 'string') {
-                    const callee = stmt.callee;
+                    // Value-arg array methods (.push/.pop/.fill/...) are lowered in
+                    // call-statement.ts to a fully-formed raw C++ expression wrapped as
+                    // `__RAW_STMT__<receiver>.<method>(<args>)` (e.g. `__RAW_STMT__arr.push_back(1)`).
+                    // Strip the wrapper — and the trailing `(args)` when present — before
+                    // splitting, otherwise the dot parse yields a receiver of
+                    // `__RAW_STMT__arr` and a method of `push_back(1)` and the demotion
+                    // below never fires, leaving a non-compiling `const std::vector` +
+                    // push_back. Mirrors the __RAW_STMT__ handling in program-analysis.ts.
+                    const rawCallee = stmt.callee;
+                    const unwrapped = rawCallee.startsWith('__RAW_STMT__')
+                        ? rawCallee.slice('__RAW_STMT__'.length)
+                        : rawCallee;
+                    const parenIdx = unwrapped.indexOf('(');
+                    const callee = parenIdx > 0 ? unwrapped.slice(0, parenIdx) : unwrapped;
                     const dot = callee.lastIndexOf('.');
                     if (dot > 0) {
                         const receiver = callee.slice(0, dot);

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

@@ -77,6 +77,35 @@ function findPinsWithCapability(capability, boardConstants) {
     }
     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
 // ---------------------------------------------------------------------------
@@ -88,6 +117,13 @@ 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))
+        return;
     const pin = operation.pin;
     if (typeof pin !== 'number' || pin < 0)
         return;
@@ -250,6 +286,7 @@ function scanExpression(expr, boardConstants, parentLine, parentCol, parentFileP
         case 'identifier':
         case 'raw':
         case 'tuple-access':
+        case 'call':
             break;
         default:
             assertNever(expr);

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

@@ -4,7 +4,7 @@ import type { Diagnostic } from '../types.js';
  * Validate that GPIO I/O operations are preceded by mode configuration.
  *
  * - Read without prior mode → **warning** (undefined behavior on floating pin)
- * - Write without prior mode → **info** (Arduino implicitly sets OUTPUT, but
- *   explicit configuration is recommended)
+ * - Write without prior mode → **info** (Wiring-derived frameworks implicitly
+ *   set OUTPUT, but explicit configuration is recommended)
  */
 export declare function validatePinModeConfig(program: ProgramIR): Diagnostic[];

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

@@ -5,6 +5,7 @@
 // configuration. Generates warnings for reads and info for writes.
 // ---------------------------------------------------------------------------
 import { scanNestedStatements } from './interrupt-analysis.js';
+import { hasLoadedFramework, getLoadedFramework } from '../framework-registry.js';
 /** Methods that configure pin mode. */
 const MODE_SET_METHODS = new Set([
     'inputPullUp', 'inputPullDown', 'outputOpenDrain',
@@ -14,7 +15,7 @@ const MODE_SET_METHODS = new Set([
 const READ_METHODS = new Set([
     'read', 'isHigh', 'isLow', 'readAnalog', 'readVoltage',
 ]);
-/** Write operations that implicitly set OUTPUT mode on Arduino. */
+/** Write operations that implicitly set OUTPUT mode on Wiring-derived frameworks. */
 const WRITE_METHODS = new Set([
     'write', 'high', 'low', 'toggle', 'pulse', 'pwm', 'tone',
 ]);
@@ -26,8 +27,8 @@ const PIN_RECEIVER_KINDS = new Set([
  * Validate that GPIO I/O operations are preceded by mode configuration.
  *
  * - Read without prior mode → **warning** (undefined behavior on floating pin)
- * - Write without prior mode → **info** (Arduino implicitly sets OUTPUT, but
- *   explicit configuration is recommended)
+ * - Write without prior mode → **info** (Wiring-derived frameworks implicitly
+ *   set OUTPUT, but explicit configuration is recommended)
  */
 export function validatePinModeConfig(program) {
     const diagnostics = [];
@@ -65,7 +66,7 @@ export function validatePinModeConfig(program) {
             diagnostics.push({
                 severity: 'info',
                 message: `Pin '${receiver}' written via '${method}()' without explicit mode configuration. ` +
-                    `Arduino implicitly sets OUTPUT, but explicit ${receiver}.asOutput() is recommended.`,
+                    `The target framework implicitly sets OUTPUT, but explicit ${receiver}.asOutput() is recommended.`,
                 filePath: program.fileName,
                 code: 'pin-mode-not-set',
                 source: 'pin-mode-validation',
@@ -112,7 +113,7 @@ export function validatePinModeConfig(program) {
             diagnostics.push({
                 severity: 'info',
                 message: `Pin ${op.pin} written without explicit mode configuration. ` +
-                    `Arduino implicitly sets OUTPUT, but explicit asOutput() is recommended.`,
+                    `The target framework implicitly sets OUTPUT, but explicit asOutput() is recommended.`,
                 filePath: program.fileName,
                 code: 'pin-mode-not-set',
                 source: 'pin-mode-validation',
@@ -148,21 +149,51 @@ export function validatePinModeConfig(program) {
         // Raw nodes: after full HAL resolution, some pin ops land as their C++ text
         // (e.g. `digitalRead(2)`, `digitalWrite(2, 1)`) rather than structured
         // hal-expr nodes. Extract the pin number and apply the same mode check.
-        // This mirrors how peripheral-usage.ts detects gpio via emitted text.
+        // Detect GPIO ops in lowered raw C++ text. Build the read/write name
+        // patterns from the loaded framework's HAL vocabulary (halCallNames),
+        // classifying names containing "Read" as reads and "Write" as writes (the
+        // Wiring-derived convention). Seed with digitalRead/digitalWrite as the
+        // canonical Wiring forms so the validator works even when no framework is
+        // loaded. Non-Wiring frameworks that emit other call forms register them
+        // via halCallNames; this loop picks them up.
         if (e.kind === 'raw' && typeof e.value === 'string') {
-            const readMatch = e.value.match(/digitalRead\((\d+)\)/);
-            const writeMatch = e.value.match(/digitalWrite\((\d+)/);
-            const toggleMatch = e.value.match(/digitalWrite\((\d+),\s*digitalRead/);
-            const pin = readMatch ? parseInt(readMatch[1], 10)
-                : writeMatch ? parseInt(writeMatch[1], 10)
-                    : null;
-            if (pin !== null) {
-                const op = toggleMatch
-                    ? { operation: 'gpio.toggle', pin }
-                    : readMatch ? { operation: 'gpio.read', pin }
-                        : { operation: 'gpio.write', pin };
-                checkGpioHalOp(op);
+            const frameworkHalNames = hasLoadedFramework()
+                ? getLoadedFramework().strategy.halCallNames?.()
+                : undefined;
+            const halNames = frameworkHalNames ?? new Set(['digitalRead', 'digitalWrite']);
+            const readNames = [...halNames].filter(n => /read/i.test(n));
+            const writeNames = [...halNames].filter(n => /write/i.test(n));
+            let pin = null;
+            let op = null;
+            for (const rn of readNames) {
+                const esc = rn.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                const m = e.value.match(new RegExp(`${esc}\\((\\d+)\\)`));
+                if (m) {
+                    pin = parseInt(m[1], 10);
+                    op = { operation: 'gpio.read', pin };
+                    break;
+                }
+            }
+            if (!op) {
+                for (const wn of writeNames) {
+                    const esc = wn.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                    const m = e.value.match(new RegExp(`${esc}\\((\\d+)`));
+                    if (m) {
+                        pin = parseInt(m[1], 10);
+                        op = { operation: 'gpio.write', pin };
+                        break;
+                    }
+                }
+            }
+            // toggle: a write call whose second arg is a read call on the same pin.
+            if (!op) {
+                const tm = e.value.match(/\((\d+),\s*\w*[Rr]ead/);
+                if (tm) {
+                    op = { operation: 'gpio.toggle', pin: parseInt(tm[1], 10) };
+                }
             }
+            if (op)
+                checkGpioHalOp(op);
         }
         // Recurse into nested expressions
         if (e.args && Array.isArray(e.args)) {

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

@@ -52,6 +52,71 @@ 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;
+    /** Fine-grained WiFi sub-feature tracking — gates individual shim sub-blocks
+     *  so that unused static helper functions don't trigger -Wunused-function. */
+    usesWifiConnect: boolean;
+    usesWifiConnectBlocking: boolean;
+    usesWifiQuery: boolean;
+    usesWifiScan: boolean;
+    usesWifiConfig: 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;
+    /** Random usage — frameworks gate their PRNG runtime/include on this
+     *  (e.g. framework-esp32 includes <esp_random.h>). Detected from random.* ops. */
+    usesRandom: boolean;
+    /** FS (filesystem) usage — frameworks gate their VFS/SD runtime shim on this.
+     *  Detected from fs.* ops. */
+    usesFS: boolean;
+    /** mDNS usage — frameworks gate the esp_mdns runtime/include on this. */
+    usesMdns: boolean;
+    /** MQTT usage — frameworks gate the esp_mqtt runtime/include on this. */
+    usesMqtt: boolean;
+    /** OTA usage — frameworks gate the esp_https_ota runtime/include on this. */
+    usesOta: boolean;
+    /** Temperature (die temp) usage. Detected from temp.* ops. */
+    usesTemp: boolean;
+    /** Hardware timer (GPTimer) usage. Detected from hwtimer.* ops. */
+    usesHwtimer: boolean;
+    /** Capacitive touch pins usage. Detected from capacitive.* ops. */
+    usesCapacitive: boolean;
+    /** Worker offload usage. Detected from worker.* ops. Frameworks gate the
+     *  worker_runtime polyfill (and its per-framework backing) on this. */
+    usesWorker: boolean;
+    /** Native/desktop: std::chrono / steady_clock usage (gates <chrono>). */
+    usesChrono: boolean;
+    /** Native/desktop: std::set usage (gates <set>). */
+    usesSet: boolean;
+    /** Native/desktop: std::algorithm usage (std::sort/find/transform etc., gates <algorithm>). */
+    usesAlgorithm: boolean;
+    /** Native/desktop: cstdio usage (printf/fprintf/snprintf, gates <cstdio>). */
+    usesCstdio: boolean;
+    /** digitalRead() in lowered raw text or gpio.read hal-op (gates the native digitalRead shim). */
+    usesDigitalRead: boolean;
+    /** display.* hal-op present, or a UI is mounted (replaces ad-hoc programUsesDisplay walks). */
+    usesDisplay: boolean;
+    /** cuttlefish_halt() in lowered raw text (gates the cuttlefish_halt macro polyfill). */
+    usesHalt: boolean;
 }
 /**
  * Analyze a program IR in a single pass to detect all features.