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

package/dist/ir/identifier-collector.js

@@ -435,5 +435,23 @@ function collectHALOpIdentifiers(op) {
         }
         // Other HAL ops have only numeric/literal fields — no identifier references
     }
+    // wifi.* / http.* 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.")) {
+        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/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

@@ -983,7 +983,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/program-analysis.d.ts

@@ -52,6 +52,29 @@ export interface ProgramAnalysisResult {
      *  __tc_TimerRuntime::MAX_TIMERS to the observed count (floor 1) rather than
      *  a blind constant, so a one-timer program links one slot, not eight. */
     timerCallCount: number;
+    /** ESP32 peripheral usage — framework-esp32 gates its IDF driver blocks and
+     *  forced includes on these. Detected from HAL-op operation names, the same
+     *  way usesUart/usesSPI/usesI2C are. Other frameworks have no CUTTLEFISH_*
+     *  blocks with these marker names so the setup.ts filters are no-ops there. */
+    usesGPIO: boolean;
+    usesPWM: boolean;
+    usesRmt: boolean;
+    usesADC: boolean;
+    usesDAC: boolean;
+    usesPower: boolean;
+    usesWdt: boolean;
+    usesInterrupts: boolean;
+    usesPulse: boolean;
+    usesShift: boolean;
+    /** WiFi / HTTP / BLE usage — framework-esp32 gates the __tc_wifi/__tc_http/
+     *  __tc_ble runtime shims and their esp_wifi/esp_http_client/nimble includes
+     *  on these. Detected from wifi.* / http.* / ble.* HAL-op operation names. */
+    usesWifi: boolean;
+    usesHttp: boolean;
+    usesBle: boolean;
+    /** Preferences (NVS) usage — framework-esp32 gates the __tc_prefs runtime shim
+     *  and its nvs_flash/nvs includes on this. Detected from preferences.* ops. */
+    usesPreferences: boolean;
 }
 /**
  * Analyze a program IR in a single pass to detect all features.

package/dist/ir/program-analysis.js

@@ -216,6 +216,23 @@ function analyzeExpression(expr, result, strategy) {
                 analyzeExpression(expr.expression, result, strategy);
             }
             break;
+        case "hal-expr":
+            // Value-position HAL ops (e.g. `const ip = WiFi.localIP()` lowers to a
+            // hal-expr initializer) never pass through the statement-level hal-op
+            // detection above, so mirror the wifi./http. flag detection here. These
+            // gate the framework-esp32 __tc_wifi/__tc_http runtime shims.
+            if (expr.operation && typeof expr.operation.operation === "string") {
+                const opName = expr.operation.operation;
+                if (opName.startsWith("wifi."))
+                    result.usesWifi = true;
+                if (opName.startsWith("http."))
+                    result.usesHttp = true;
+                if (opName.startsWith("ble."))
+                    result.usesBle = true;
+                if (opName.startsWith("preferences."))
+                    result.usesPreferences = true;
+            }
+            break;
     }
 }
 /**
@@ -242,6 +259,11 @@ function analyzeStatement(statement, result, strategy) {
             if (statement.callee === "millis" || statement.callee === "delay") {
                 result.usesMillis = true;
             }
+            // Awaited HAL wait markers become async state-machine poll states that
+            // arm deadlines via currentTimeMillis().
+            if (statement.callee === "__WIFI_WAIT__" || statement.callee === "__HTTP_WAIT__" || statement.callee === "__HAL_WAIT__") {
+                result.usesMillis = true;
+            }
             // Namespace-qualified polyfill entry points used as bare call statements
             // (e.g. `Timing.delay(5);`). The expression-level analyzer (case
             // "method-call") already checks these prefixes, but a statement-form call
@@ -264,7 +286,10 @@ function analyzeStatement(statement, result, strategy) {
             if (statement.callee === "tone" || statement.callee === "noTone") {
                 result.usesTone = true;
             }
-            if (statement.callee.startsWith("console.") || statement.callee.startsWith("_uart_")) {
+            // console.* is NOT UART: on ESP-IDF it lowers to printf, on Arduino to
+            // Serial via hasConsoleCalls. Only real UART HAL / Serial peripheral
+            // usage should gate the uart shim (avoids unused __tc_uart*_init).
+            if (statement.callee.startsWith("_uart_")) {
                 result.usesUart = true;
             }
             if (statement.callee.startsWith("Serial.") || statement.callee === "Serial") {
@@ -424,6 +449,46 @@ function analyzeStatement(statement, result, strategy) {
                     result.usesTone = true;
                 if (opName.startsWith("uart."))
                     result.usesUart = true;
+                // Display HAL ops (display.init from ui.mount, display.flush per frame)
+                // always imply GPIO usage (CS/DC/RST pins). Native SPI/I2C display
+                // adapters emit their own transport #includes (driver/spi_master.h,
+                // driver/i2c_master.h) — we don't force usesSPI/usesI2C here because
+                // that would pull headers even for non-display SPI/I2C code, and the
+                // display's transport type can't be determined from the op alone.
+                if (opName.startsWith("display.")) {
+                    result.usesGPIO = true;
+                }
+                // ESP32 peripheral usage — framework-esp32 gates IDF driver blocks
+                // and forced includes on these. No-op for other frameworks (their
+                // shimLines emit no CUTTLEFISH_* blocks with these marker names).
+                if (opName.startsWith("gpio."))
+                    result.usesGPIO = true;
+                if (opName.startsWith("pwm."))
+                    result.usesPWM = true;
+                if (opName.startsWith("rmt."))
+                    result.usesRmt = true;
+                if (opName.startsWith("adc."))
+                    result.usesADC = true;
+                if (opName.startsWith("dac."))
+                    result.usesDAC = true;
+                if (opName.startsWith("power."))
+                    result.usesPower = true;
+                if (opName.startsWith("wdt."))
+                    result.usesWdt = true;
+                if (opName.startsWith("interrupt."))
+                    result.usesInterrupts = true;
+                if (opName.startsWith("pulse."))
+                    result.usesPulse = true;
+                if (opName.startsWith("shift."))
+                    result.usesShift = true;
+                if (opName.startsWith("wifi."))
+                    result.usesWifi = true;
+                if (opName.startsWith("http."))
+                    result.usesHttp = true;
+                if (opName.startsWith("ble."))
+                    result.usesBle = true;
+                if (opName.startsWith("preferences."))
+                    result.usesPreferences = true;
                 // Timing HAL ops (timing.delay/millis/micros) carry a typed operation
                 // name, not raw code, so the regex scans below miss them. Mirror the
                 // raw-code timing detection here so usesMillis/usesTiming (and thus
@@ -467,7 +532,7 @@ function analyzeStatement(statement, result, strategy) {
                 if (/\bEEPROM\b/.test(code) || /\beeprom_(read|write|update)_byte\b/.test(code)) {
                     result.usesEEPROM = true;
                 }
-                if (/\b(Serial|console)\b/.test(code)) {
+                if (/\bSerial\b/.test(code)) {
                     result.usesUart = true;
                 }
                 if (/\bSPI\b/.test(code)) {
@@ -535,6 +600,20 @@ export function analyzeProgram(program, strategy) {
         hasGenerators: false,
         usesStdMap: false,
         timerCallCount: 0,
+        usesGPIO: false,
+        usesPWM: false,
+        usesRmt: false,
+        usesADC: false,
+        usesDAC: false,
+        usesPower: false,
+        usesWdt: false,
+        usesInterrupts: false,
+        usesPulse: false,
+        usesShift: false,
+        usesWifi: false,
+        usesHttp: false,
+        usesBle: false,
+        usesPreferences: false,
     };
     // Analyze type aliases
     for (const typeAlias of program.typeAliases) {

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

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

package/dist/ir/timing-validation.js

@@ -12,20 +12,43 @@
 // g++ sees only an ordinary function. This validator flags blocking delays in
 // loop()'s direct body so the user can replace them with the cooperative
 // Async.sleep() / millis()-comparison pattern.
+//
+// IMPORTANT: on RTOS targets (ESP-IDF / FreeRTOS), delay() lowers to
+// vTaskDelay which YIELDS the CPU — it does not freeze other tasks, UI
+// rendering, or the async queue. Only delayMicroseconds (esp_rom_delay_us)
+// is a true busy-wait. So for RTOS targets, only delay_microseconds triggers
+// the warning; delay is safe.
 // ---------------------------------------------------------------------------
-/** Check a single statement for a blocking delay call or hal-op. */
-function isBlockingDelay(stmt) {
+import { hasLoadedFramework, getLoadedFramework } from '../framework-registry.js';
+/** Check a single statement for a blocking delay call or hal-op.
+ *  On RTOS targets, timing.delay (vTaskDelay) is NOT blocking — only
+ *  timing.delay_microseconds (esp_rom_delay_us) is. */
+function isBlockingDelay(stmt, isRtos) {
     const s = stmt;
     // Direct call: delay(...) or delayMicroseconds(...)
     if (stmt.kind === 'call' && typeof s.callee === 'string') {
-        if (s.callee === 'delay' || s.callee === 'delayMicroseconds')
-            return true;
+        if (isRtos) {
+            // On RTOS targets, only delayMicroseconds is a busy-wait.
+            if (s.callee === 'delayMicroseconds')
+                return true;
+        }
+        else {
+            if (s.callee === 'delay' || s.callee === 'delayMicroseconds')
+                return true;
+        }
     }
     // Hal-op: after HAL resolution, delay() becomes timing.delay /
     // timing.delay_microseconds.
     if (stmt.kind === 'hal-op' && s.operation?.operation) {
-        if (s.operation.operation === 'timing.delay' || s.operation.operation === 'timing.delay_microseconds') {
-            return true;
+        if (isRtos) {
+            // On RTOS targets, only timing.delay_microseconds is blocking.
+            if (s.operation.operation === 'timing.delay_microseconds')
+                return true;
+        }
+        else {
+            if (s.operation.operation === 'timing.delay' || s.operation.operation === 'timing.delay_microseconds') {
+                return true;
+            }
         }
     }
     return false;
@@ -33,22 +56,37 @@ function isBlockingDelay(stmt) {
 /**
  * Detect blocking delay() calls inside loop()'s body. Emits a warning for
  * each, explaining the cooperative-async alternative.
+ *
+ * On RTOS targets (ESP-IDF), timing.delay lowers to vTaskDelay which yields
+ * the CPU — it does NOT freeze the async queue or UI. Only delayMicroseconds
+ * (busy-wait) triggers the warning.
  */
-export function validateBlockingDelayInLoop(program) {
+export function validateBlockingDelayInLoop(program, strategy) {
     const diagnostics = [];
+    // Detect RTOS targets where delay() yields rather than blocks.
+    // framework-esp32 uses FreeRTOS; vTaskDelay is a yielding delay.
+    const isRtos = strategy?.isRtosTarget?.() === true
+        || (hasLoadedFramework() && getLoadedFramework().strategy.isRtosTarget?.() === true);
     const loopFn = program.functions.find(fn => fn.originalName === 'loop');
     if (!loopFn || !loopFn.statements)
         return diagnostics;
     const visit = (stmts) => {
         for (const stmt of stmts) {
-            if (isBlockingDelay(stmt)) {
+            if (isBlockingDelay(stmt, isRtos)) {
                 const s = stmt;
+                const message = isRtos
+                    ? `Blocking delayMicroseconds() inside loop() is a busy-wait that wastes CPU cycles. ` +
+                        `On RTOS targets (ESP-IDF), prefer timing.delay() (vTaskDelay) which yields the CPU to other tasks.`
+                    : `Blocking delay() inside loop() freezes the async microtask queue and UI rendering ` +
+                        `for the delay duration. This causes display tearing and makes the sketch unresponsive.`;
+                const hint = isRtos
+                    ? `Replace delayMicroseconds with delay() if the timing permits, or accept the brief busy-wait if sub-millisecond precision is required.`
+                    : `Use the cooperative pattern instead: track elapsed time with millis() comparisons, ` +
+                        `or use Async.sleep(ms) / Async.yield() to let other tasks run between checks.`;
                 diagnostics.push({
                     severity: 'warning',
-                    message: `Blocking delay() inside loop() freezes the async microtask queue and UI rendering ` +
-                        `for the delay duration. This causes display tearing and makes the sketch unresponsive.`,
-                    hint: `Use the cooperative pattern instead: track elapsed time with millis() comparisons, ` +
-                        `or use Async.sleep(ms) / Async.yield() to let other tasks run between checks.`,
+                    message,
+                    hint,
                     line: stmt.sourceSpan?.startLine,
                     column: stmt.sourceSpan?.startColumn,
                     filePath: stmt.sourceSpan?.filePath,

package/dist/ir/transformers/expressions.js

@@ -16,6 +16,17 @@ export function expressionStatementToIR(statement, fileName, sourceText, diagnos
         if (callStmt && callStmt.kind === "call") {
             return { ...callStmt, isAwaited: true };
         }
+        // Awaited network HAL ops (WiFi.connect / WiFi.untilConnected / Http.send
+        // / ...) resolve to hal-op statements, which would otherwise lower to the
+        // BLOCKING shim call even inside an async state machine. Rewrite them to
+        // an awaited __WIFI_WAIT__/__HTTP_WAIT__ marker call carrying the original
+        // op; the async state-machine generator turns it into a start + poll state
+        // pair, and the statement renderer falls back to the blocking form when
+        // the marker is rendered outside a state machine (top-level await, awaits
+        // nested in unsupported positions).
+        const netMarker = awaitedNetMarker(callStmt);
+        if (netMarker)
+            return netMarker;
         return callStmt;
     }
     // ── Register bit-field write ────────────────────────────────────────
@@ -404,3 +415,50 @@ export function expressionStatementToIR(statement, fileName, sourceText, diagnos
     }
     return undefined;
 }
+/** HAL ops with a start/poll split available in the async state machine
+ *  (see async-state-machine.ts netWaitInfo — keep the two in sync).
+ *  timing.delay is included because `delay()` from @typecad/hal resolves to a
+ *  hal-op, dropping the isAwaited flag the state machine keys on. */
+const AWAITABLE_HAL_OPS = new Set([
+    "timing.delay",
+    "wifi.connect",
+    "wifi.wait_connected",
+    "wifi.wait_disconnected",
+    "wifi.scan",
+    "http.send",
+    "ble.until_connected",
+]);
+/**
+ * Rewrite an awaited hal-op statement (or a block whose LAST statement is
+ * one — chained HAL calls resolve to blocks of hal-ops) into an awaited
+ * `__WIFI_WAIT__` / `__HTTP_WAIT__` / `__HAL_WAIT__` marker call carrying the
+ * original op as a hal-expr argument. Returns undefined when the statement is
+ * not an awaitable HAL op.
+ */
+function awaitedNetMarker(stmt) {
+    if (!stmt)
+        return undefined;
+    if (stmt.kind === "hal-op" && AWAITABLE_HAL_OPS.has(stmt.operation.operation)) {
+        const opName = stmt.operation.operation;
+        const callee = opName.startsWith("http.") ? "__HTTP_WAIT__"
+            : opName.startsWith("wifi.") ? "__WIFI_WAIT__"
+                : opName.startsWith("ble.") ? "__BLE_WAIT__"
+                    : "__HAL_WAIT__";
+        return {
+            kind: "call",
+            sourceSpan: stmt.sourceSpan,
+            leadingComments: stmt.leadingComments,
+            trailingComments: stmt.trailingComments,
+            callee,
+            args: [{ kind: "hal-expr", operation: stmt.operation }],
+            isAwaited: true,
+        };
+    }
+    if (stmt.kind === "block" && stmt.body.length > 0) {
+        const last = awaitedNetMarker(stmt.body[stmt.body.length - 1]);
+        if (last) {
+            return { ...stmt, body: [...stmt.body.slice(0, -1), last] };
+        }
+    }
+    return undefined;
+}

package/dist/ir/transformers/hal-emit-helpers.js

@@ -27,7 +27,7 @@ export function collectChainedHALEmits(expr, sourceText, diagnostics, pointerVar
             }
         }
         // Continue recursion to collect deeper chain levels
-        if (ts.isCallExpression(innerReceiver) && ts.isPropertyAccessExpression(innerReceiver)) {
+        if (ts.isCallExpression(innerReceiver) && ts.isPropertyAccessExpression(innerReceiver.expression)) {
             collectChainedHALEmits(innerReceiver, sourceText, diagnostics, pointerVars, emitLines, halOps);
         }
     }

package/dist/ir/transformers/variables.js

@@ -7,7 +7,8 @@ import { getCurrentIrTypeScope, setScopeLocalType } from "../symbol-types.js";
 import { renderExprAsText } from "../render-expr.js";
 import { expressionToIR } from "../expression-to-ir.js";
 import { buildInlineForLoop } from "./array-methods.js";
-import { isKnownHALClass, getCtorIncludes, registerFloatVariable, resolveHALReceiver, isHALSingleton, } from "../hal-resolver.js";
+import { isKnownHALClass, getCtorIncludes, getHALCtorFieldMap, registerFloatVariable, resolveHALReceiver, isHALSingleton, } from "../hal-resolver.js";
+import { httpFactoryVerb, httpUrlArgText } from "../hal/hal-parser.js";
 import { resolveHALCallForVarInit } from "./hal-call-resolver.js";
 import { recordSignal } from "./ui-call-resolver.js";
 function replaceHalReadBufferPlaceholder(op, varName) {
@@ -408,9 +409,26 @@ export function variableStatementToIR(statement, fileName, sourceText, diagnosti
                             }
                         }
                     }
+                    // new HttpRequest(method, url) — positional ctor fields. The URL is
+                    // stored as C++ expression text (quoted literal or identifier).
+                    if (className === "HttpRequest" && ctorArgs && ctorArgs.length >= 2) {
+                        const methodArg = ctorArgs[0];
+                        if (ts.isStringLiteral(methodArg))
+                            fieldValues.set("_method", methodArg.text.toUpperCase());
+                        const urlText = httpUrlArgText(ctorArgs[1]);
+                        if (urlText)
+                            fieldValues.set("_url", urlText);
+                    }
                     if (ctorArgs) {
+                        // Resolve a Pin-identifier ctor arg to its _pin number, for any HAL
+                        // class whose first constructor field is _pin (Pin itself, plus
+                        // pin-bearing wrappers like RmtChannel). Mirrors the Pin branch
+                        // above but keyed off the class's registered ctor field map so new
+                        // pin-keyed classes work without a per-class branch here.
+                        const ctorFieldMap = getHALCtorFieldMap(className);
+                        const firstFieldIsPin = ctorFieldMap && Array.from(ctorFieldMap.keys())[0] === "_pin";
                         for (const arg of ctorArgs) {
-                            if (ts.isIdentifier(arg) && className === "Pin") {
+                            if (ts.isIdentifier(arg) && (className === "Pin" || firstFieldIsPin)) {
                                 const existing = halInstances.get(arg.text);
                                 if (existing && existing.fieldValues.has("_pin")) {
                                     fieldValues.set("_pin", existing.fieldValues.get("_pin"));
@@ -516,6 +534,19 @@ export function variableStatementToIR(statement, fileName, sourceText, diagnosti
                                 }
                             }
                         }
+                        // For Http factory calls (const req = Http.get(url)), record the
+                        // HTTP verb + URL so req.send() can resolve this._method/this._url.
+                        if (result.returnClassName === "HttpRequest") {
+                            const verb = httpFactoryVerb(init.expression.name.text);
+                            if (verb)
+                                fieldValues.set("_method", verb);
+                            const urlArg = init.arguments?.[0];
+                            if (urlArg) {
+                                const urlText = httpUrlArgText(urlArg);
+                                if (urlText)
+                                    fieldValues.set("_url", urlText);
+                            }
+                        }
                         halInstances.set(varName, {
                             className: result.returnClassName,
                             fieldValues,
@@ -573,7 +604,14 @@ export function variableStatementToIR(statement, fileName, sourceText, diagnosti
                             // fill ops). Everything else is a scalar/value return captured
                             // after the side-effect ops.
                             const isTypedArray = result.returnValue.startsWith("__TYPED_ARRAY__:");
-                            if (!isTypedArray) {
+                            // A factory returning a compile-time HAL instance (e.g.
+                            // `const req = Http.get(url)` → returnValue `new HttpRequest(...)`)
+                            // is fully tracked via halInstances — every later method call on
+                            // the variable resolves at compile time. Emitting the raw
+                            // `new HttpRequest(...)` would reference a class that doesn't
+                            // exist in the C++ output.
+                            const isHalInstanceReturn = !!result.returnClassName && /^new\s/.test(result.returnValue.trim());
+                            if (!isTypedArray && !isHalInstanceReturn) {
                                 lowered.push({
                                     kind: "var_decl",
                                     sourceSpan: makeSourceSpan(declaration, fileName, sourceText),