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

package/dist/emit/utils/async-state-machine.js

@@ -4,6 +4,7 @@
  * Extracted from cpp-emitter.ts
  */
 import { escapeCppStringLiteral } from "../../utils/strings.js";
+import { routeHALOp } from "../route-hal-op.js";
 /**
  * Converts a string to PascalCase.
  * Used for generating class names from function names.
@@ -53,6 +54,20 @@ export function generateAsyncTaskClass(fnName, fnStatements, strategy, knownFunc
             segments.push({ preStatements: currentPre, awaitedCallee: stmt.callee, awaitedArgs: stmt.args });
             currentPre = [];
         }
+        else if (
+        // Chained HAL calls (e.g. `await Http.get(url).send()`) resolve to a
+        // block of hal-ops whose LAST statement is the awaited wait marker.
+        // Flatten it so the split sees the marker; the leading ops (begin,
+        // setters) run as pre-statements of the same segment.
+        stmt.kind === "block" &&
+            stmt.body.length > 0 &&
+            stmt.body[stmt.body.length - 1].kind === "call" &&
+            stmt.body[stmt.body.length - 1].isAwaited) {
+            const last = stmt.body[stmt.body.length - 1];
+            currentPre.push(...stmt.body.slice(0, -1));
+            segments.push({ preStatements: currentPre, awaitedCallee: last.callee, awaitedArgs: last.args });
+            currentPre = [];
+        }
         else {
             currentPre.push(stmt);
         }
@@ -101,16 +116,74 @@ export function generateAsyncTaskClass(fnName, fnStatements, strategy, knownFunc
             tapMembers.set(member, i);
         }
     }
+    // Collect net-wait (WiFi/HTTP/HAL) markers: awaited hal-ops rewritten to
+    // __WIFI_WAIT__/__HTTP_WAIT__/__HAL_WAIT__ calls carrying the op as a
+    // hal-expr arg. The strategy lowers the op to start code + poll condition.
+    const netInfoMap = new Map();
+    for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        if ((seg.awaitedCallee === "__WIFI_WAIT__" || seg.awaitedCallee === "__HTTP_WAIT__" || seg.awaitedCallee === "__BLE_WAIT__" || seg.awaitedCallee === "__HAL_WAIT__") &&
+            seg.awaitedArgs[0]?.kind === "hal-expr") {
+            const op = seg.awaitedArgs[0].operation;
+            netInfoMap.set(i, netWaitInfo(op, strategy));
+        }
+    }
+    // ── Render each state ──────────────────────────────────────────────────
+    // Decomposition: a state's ENTRY condition comes from the await that ended
+    // the PREVIOUS segment (edge / tap / net poll / timed deadline); once the
+    // condition fires, the segment body runs and the await ending THIS segment
+    // is armed (pin snapshot / tap snapshot / net start op / deadline).
+    // Lines that arm the await ending segment i and advance the state.
+    const armNextLines = (i, pad) => {
+        const seg = segments[i];
+        const lines = [];
+        if (seg.awaitedCallee === undefined) {
+            lines.push(`${pad}_state = ${isCyclic ? "STATE_0" : "STATE_DONE"};`);
+            return lines;
+        }
+        const edge = edgeInfoMap.get(i);
+        const tap = tapInfoMap.get(i);
+        const net = netInfoMap.get(i);
+        if (edge) {
+            lines.push(`${pad}_edgePrev_p${edge.pin} = digitalRead(${edge.pin});`);
+            if (edge.timeout !== null) {
+                lines.push(`${pad}_waitUntil = ${strategy.currentTimeMillis()} + ${edge.timeout};`);
+            }
+        }
+        else if (tap) {
+            lines.push(`${pad}_tapPrev_${i} = __ui_tap_seq;`);
+        }
+        else if (net) {
+            for (const startLine of net.startLines)
+                lines.push(`${pad}${startLine}`);
+            if (net.timeoutExpr !== null) {
+                lines.push(`${pad}_waitUntil = ${strategy.currentTimeMillis()} + ${net.timeoutExpr};`);
+            }
+        }
+        else {
+            // Plain timed wait (await delay(ms)) — arm its deadline.
+            const ms = seg.awaitedArgs[0] ? renderExpression(seg.awaitedArgs[0], strategy) : "0";
+            lines.push(`${pad}_waitUntil = ${strategy.currentTimeMillis()} + ${ms};`);
+        }
+        lines.push(`${pad}_state = STATE_${i + 1};`);
+        return lines;
+    };
     const caseLines = [];
     for (let i = 0; i < segments.length; i++) {
         const seg = segments[i];
         const stateName = `STATE_${i}`;
-        const isTerminal = seg.awaitedCallee === undefined;
         const body = [];
-        const edgeSetup = edgeInfoMap.get(i);
         const edgePoll = i > 0 ? edgeInfoMap.get(i - 1) : undefined;
-        const tapSetup = tapInfoMap.get(i);
         const tapPoll = i > 0 ? tapInfoMap.get(i - 1) : undefined;
+        const netPoll = i > 0 ? netInfoMap.get(i - 1) : undefined;
+        // Segment body + arming of the next await, at the given indent.
+        const runSegment = (pad) => {
+            const lines = [];
+            for (const stmt of seg.preStatements)
+                lines.push(`${pad}${renderStmt(stmt)}`);
+            lines.push(...armNextLines(i, pad));
+            return lines;
+        };
         if (edgePoll) {
             // Poll state: check pin transition via digitalRead
             const prevVar = `_edgePrev_p${edgePoll.pin}`;
@@ -124,53 +197,12 @@ export function generateAsyncTaskClass(fnName, fnStatements, strategy, knownFunc
             body.push(`          int _cur = digitalRead(${edgePoll.pin});`);
             body.push(`          if (${fullCond}) {`);
             body.push(`            ${prevVar} = _cur;`);
-            for (const stmt of seg.preStatements)
-                body.push(`            ${renderStmt(stmt)}`);
-            if (edgeSetup) {
-                // Next await is also edge detection — set up its pin tracking
-                body.push(`            _edgePrev_p${edgeSetup.pin} = digitalRead(${edgeSetup.pin});`);
-                if (edgeSetup.timeout !== null) {
-                    body.push(`            _waitUntil = ${strategy.currentTimeMillis()} + ${edgeSetup.timeout};`);
-                }
-                body.push(`            _state = STATE_${i + 1};`);
-            }
-            else if (!isTerminal) {
-                const ms = seg.awaitedArgs[0] ? renderExpression(seg.awaitedArgs[0], strategy) : "0";
-                body.push(`            _waitUntil = ${strategy.currentTimeMillis()} + ${ms};`);
-                body.push(`            _state = STATE_${i + 1};`);
-            }
-            else {
-                body.push(`            _state = ${isCyclic ? "STATE_0" : "STATE_DONE"};`);
-            }
+            body.push(...runSegment(`            `));
             body.push(`          } else {`);
             body.push(`            ${prevVar} = _cur;`);
             body.push(`          }`);
             body.push(`        }`);
         }
-        else if (edgeSetup) {
-            // Setup state: capture initial pin state before polling
-            const prevVar = `_edgePrev_p${edgeSetup.pin}`;
-            if (i === 0) {
-                for (const stmt of seg.preStatements)
-                    body.push(`        ${renderStmt(stmt)}`);
-                body.push(`        ${prevVar} = digitalRead(${edgeSetup.pin});`);
-                if (edgeSetup.timeout !== null) {
-                    body.push(`        _waitUntil = ${strategy.currentTimeMillis()} + ${edgeSetup.timeout};`);
-                }
-                body.push(`        _state = STATE_${i + 1};`);
-            }
-            else {
-                body.push(`        if (${strategy.currentTimeMillis()} >= _waitUntil) {`);
-                for (const stmt of seg.preStatements)
-                    body.push(`          ${renderStmt(stmt)}`);
-                body.push(`          ${prevVar} = digitalRead(${edgeSetup.pin});`);
-                if (edgeSetup.timeout !== null) {
-                    body.push(`          _waitUntil = ${strategy.currentTimeMillis()} + ${edgeSetup.timeout};`);
-                }
-                body.push(`          _state = STATE_${i + 1};`);
-                body.push(`        }`);
-            }
-        }
         else if (tapPoll) {
             // Tap-poll state: a previous segment ended with `await ui.onTap()`.
             // Wait until __ui_tap_seq bumps from the captured snapshot. A per-node
@@ -181,81 +213,31 @@ export function generateAsyncTaskClass(fnName, fnStatements, strategy, knownFunc
                 ? `__ui_tap_seq != ${prevVar}`
                 : `(__ui_tap_seq != ${prevVar}) && (__ui_tap_node == ${nodeFilter})`;
             body.push(`        if (${cond}) {`);
-            for (const stmt of seg.preStatements)
-                body.push(`          ${renderStmt(stmt)}`);
-            // What does the NEXT await (ending this segment) look like? Re-derive
-            // from the maps via a fresh lookup so TS doesn't narrow edgeSetup away.
-            const nextEdge = edgeInfoMap.get(i) ?? null;
-            if (tapSetup) {
-                // Next await is also a tap — capture its snapshot now.
-                body.push(`          _tapPrev_${i} = __ui_tap_seq;`);
-                body.push(`          _state = STATE_${i + 1};`);
-            }
-            else if (nextEdge) {
-                body.push(`          _edgePrev_p${nextEdge.pin} = digitalRead(${nextEdge.pin});`);
-                if (nextEdge.timeout !== null) {
-                    body.push(`          _waitUntil = ${strategy.currentTimeMillis()} + ${nextEdge.timeout};`);
-                }
-                body.push(`          _state = STATE_${i + 1};`);
-            }
-            else if (!isTerminal) {
-                // Next await is a normal timed wait (delay) — arm its deadline.
-                const ms = seg.awaitedArgs[0] ? renderExpression(seg.awaitedArgs[0], strategy) : "0";
-                body.push(`          _waitUntil = ${strategy.currentTimeMillis()} + ${ms};`);
-                body.push(`          _state = STATE_${i + 1};`);
-            }
-            else {
-                body.push(`          _state = ${isCyclic ? "STATE_0" : "STATE_DONE"};`);
-            }
+            body.push(...runSegment(`          `));
             body.push(`        }`);
         }
-        else if (tapSetup && !edgePoll) {
-            // Tap-setup state: this segment ends with `await ui.onTap()`. Capture the
-            // current tap counter so the poll state can detect the NEXT bump.
-            // (edgePoll takes precedence when the previous await was an edge.)
-            if (i === 0) {
-                for (const stmt of seg.preStatements)
-                    body.push(`        ${renderStmt(stmt)}`);
-                body.push(`        _tapPrev_${i} = __ui_tap_seq;`);
-                body.push(`        _state = STATE_${i + 1};`);
-            }
-            else {
-                body.push(`        if (${strategy.currentTimeMillis()} >= _waitUntil) {`);
-                for (const stmt of seg.preStatements)
-                    body.push(`          ${renderStmt(stmt)}`);
-                body.push(`          _tapPrev_${i} = __ui_tap_seq;`);
-                body.push(`          _state = STATE_${i + 1};`);
-                body.push(`        }`);
-            }
+        else if (netPoll) {
+            // Net-poll state: a previous segment ended with an awaited WiFi/HTTP
+            // op. Wait until its poll condition fires (or its deadline expires).
+            const deadline = `${strategy.currentTimeMillis()} >= _waitUntil`;
+            const cond = netPoll.pollCond === null
+                ? deadline
+                : netPoll.timeoutExpr !== null
+                    ? `(${netPoll.pollCond}) || ${deadline}`
+                    : netPoll.pollCond;
+            body.push(`        if (${cond}) {`);
+            body.push(...runSegment(`          `));
+            body.push(`        }`);
+        }
+        else if (i === 0) {
+            // First state runs immediately.
+            body.push(...runSegment(`        `));
         }
         else {
-            // Normal timed-wait state
-            if (i === 0) {
-                for (const stmt of seg.preStatements)
-                    body.push(`        ${renderStmt(stmt)}`);
-                if (!isTerminal) {
-                    const ms = seg.awaitedArgs[0] ? renderExpression(seg.awaitedArgs[0], strategy) : "0";
-                    body.push(`        _waitUntil = ${strategy.currentTimeMillis()} + ${ms};`);
-                    body.push(`        _state = STATE_${i + 1};`);
-                }
-                else {
-                    body.push(`        _state = ${isCyclic ? "STATE_0" : "STATE_DONE"};`);
-                }
-            }
-            else {
-                body.push(`        if (${strategy.currentTimeMillis()} >= _waitUntil) {`);
-                for (const stmt of seg.preStatements)
-                    body.push(`          ${renderStmt(stmt)}`);
-                if (!isTerminal) {
-                    const ms = seg.awaitedArgs[0] ? renderExpression(seg.awaitedArgs[0], strategy) : "0";
-                    body.push(`          _waitUntil = ${strategy.currentTimeMillis()} + ${ms};`);
-                    body.push(`          _state = STATE_${i + 1};`);
-                }
-                else {
-                    body.push(`          _state = ${isCyclic ? "STATE_0" : "STATE_DONE"};`);
-                }
-                body.push(`        }`);
-            }
+            // Previous await was a plain timed wait — poll its deadline.
+            body.push(`        if (${strategy.currentTimeMillis()} >= _waitUntil) {`);
+            body.push(...runSegment(`          `));
+            body.push(`        }`);
         }
         caseLines.push(`      case ${stateName}:`, `        {`, ...body, `        }`, `        break;`);
     }
@@ -331,6 +313,93 @@ function renderExpression(expr, strategy) {
             return "/* complex expr */";
     }
 }
+/** Numeric-or-rendered HAL field → C++ text. */
+function ms(v) {
+    return String(v);
+}
+/** True when a timeout field is the literal 0 (wait forever, no deadline). */
+function isZeroTimeout(v) {
+    return v === undefined || v === null || String(v).trim() === "0";
+}
+/**
+ * Map an awaitable HAL op to its start statements + poll condition, lowering
+ * the start op and poll predicate through the platform strategy. Keep the set
+ * of handled ops in sync with AWAITABLE_HAL_OPS in ir/transformers/expressions.ts.
+ *
+ * Falls back to running the blocking form as the "start" with an immediate
+ * completion when the strategy can't lower the split ops.
+ */
+function netWaitInfo(op, strategy) {
+    const o = op;
+    const route = (routedOp) => routeHALOp(routedOp, strategy);
+    const expr = (operation) => route({ operation })?.expression ?? null;
+    switch (op.operation) {
+        case "timing.delay":
+            return { startLines: [], pollCond: null, timeoutExpr: ms(o.ms) };
+        case "wifi.connect": {
+            const start = route({ operation: "wifi.connect_start", ssid: o.ssid, password: o.password });
+            const poll = expr("wifi.is_connected");
+            if (start?.code && poll) {
+                return {
+                    startLines: [start.code],
+                    pollCond: poll,
+                    timeoutExpr: isZeroTimeout(o.timeoutMs) ? null : ms(o.timeoutMs),
+                };
+            }
+            break;
+        }
+        case "wifi.wait_connected": {
+            const poll = expr("wifi.is_connected");
+            if (poll) {
+                return {
+                    startLines: [],
+                    pollCond: poll,
+                    timeoutExpr: isZeroTimeout(o.timeoutMs) ? null : ms(o.timeoutMs),
+                };
+            }
+            break;
+        }
+        case "wifi.wait_disconnected": {
+            const poll = expr("wifi.is_connected");
+            if (poll) {
+                return { startLines: [], pollCond: `!${poll}`, timeoutExpr: null };
+            }
+            break;
+        }
+        case "wifi.scan": {
+            const start = route({ operation: "wifi.scan_start" });
+            const poll = expr("wifi.scan_done");
+            if (start?.code && poll) {
+                return { startLines: [start.code], pollCond: poll, timeoutExpr: null };
+            }
+            break;
+        }
+        case "http.send": {
+            const start = route({ operation: "http.send_start" });
+            const poll = expr("http.done");
+            if (start?.code && poll) {
+                return { startLines: [start.code], pollCond: poll, timeoutExpr: null };
+            }
+            break;
+        }
+        case "ble.until_connected": {
+            const start = route({ operation: "ble.until_connected_start" });
+            const poll = expr("ble.is_connected");
+            if (start?.code && poll) {
+                return {
+                    startLines: [start.code],
+                    pollCond: poll,
+                    timeoutExpr: isZeroTimeout(o.timeoutMs) ? null : ms(o.timeoutMs),
+                };
+            }
+            break;
+        }
+    }
+    // Fallback: run the blocking form immediately and complete on the next tick.
+    const blocking = routeHALOp(op, strategy);
+    const line = blocking?.code ?? (blocking?.expression ? `${blocking.expression};` : `/* unhandled awaited hal-op: ${op.operation} */`);
+    return { startLines: [line], pollCond: null, timeoutExpr: "0" };
+}
 function parseEdgeMarker(argText) {
     const match = argText.match(/^__EDGE_(RISING|FALLING)__([a-zA-Z0-9_]+)__T(.*)$/);
     if (!match)

package/dist/emit/utils/hal-op-cpp-type.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Best-effort C++ return type for a HAL expression op.
+ * Used by snprintf format inference and expression type inference so
+ * string-returning ops (e.g. wifi.scan_ssid → const char*) use %s, not %d.
+ */
+export declare function cppTypeForHalOp(operation: string): string | undefined;

package/dist/emit/utils/hal-op-cpp-type.js

@@ -0,0 +1,40 @@
+/**
+ * Best-effort C++ return type for a HAL expression op.
+ * Used by snprintf format inference and expression type inference so
+ * string-returning ops (e.g. wifi.scan_ssid → const char*) use %s, not %d.
+ */
+export function cppTypeForHalOp(operation) {
+    switch (operation) {
+        case "wifi.local_ip":
+        case "wifi.mac":
+        case "wifi.ap_ip":
+        case "wifi.scan_ssid":
+        case "http.body":
+        case "http.response_header":
+            return "const char*";
+        case "wifi.is_connected":
+        case "wifi.connect":
+        case "wifi.wait_connected":
+        case "wifi.scan_done":
+        case "wifi.ap_start":
+        case "wifi.connect_saved":
+        case "http.ok":
+        case "http.done":
+            return "bool";
+        case "wifi.status":
+        case "wifi.rssi":
+        case "wifi.scan":
+        case "wifi.scan_count":
+        case "wifi.scan_rssi":
+        case "wifi.scan_encryption":
+        case "wifi.scan_channel":
+        case "wifi.ap_client_count":
+        case "http.status":
+        case "http.content_length":
+            return "int";
+        case "http.send":
+            return "bool";
+        default:
+            return undefined;
+    }
+}

package/dist/ir/build-ir.js

@@ -144,7 +144,11 @@ export function buildProgramIR(fileName, sourceText, boardPackage, prebuiltClass
     const parentStrategy = getContext().activeStrategy;
     return contextStorage.run(new CompilationContext(), () => {
         getContext().activeStrategy = parentStrategy;
-        loadHALModules(true); // Parse HAL source files (force reload to pick up changes)
+        // Ensure HAL modules are loaded. transpile.ts warms the HAL registry once
+        // per transpile run (before the per-file IR build), so this is normally a
+        // cheap no-op. The non-forced call is a safety net for direct/test callers
+        // of buildProgramIR that didn't warm the registry first.
+        loadHALModules();
         const normalizedSourceText = normalizeEntrypointSyntax(sourceText);
         const source = parseSource(fileName, normalizedSourceText);
         const diagnostics = [];

package/dist/ir/expression-to-ir.js

@@ -953,6 +953,20 @@ export function expressionToIR(expr, sourceText, diagnostics, pointerVars = new
         };
     }
     if (ts.isCallExpression(expr)) {
+        // ---- rawCppExpr() — compile-time C++ injection in expression context ----
+        // Mirrors the statement-position rawCpp()/__EMIT__ path, but emits the raw
+        // text as an expression (e.g. for IDF macros like WIFI_INIT_CONFIG_DEFAULT()
+        // that produce struct values). The type parameter is a TS hint only — the
+        // transpiler emits the raw text verbatim.
+        if (ts.isIdentifier(expr.expression) && expr.expression.text === "rawCppExpr") {
+            const arg = expr.arguments[0];
+            if (arg && ts.isStringLiteral(arg)) {
+                return { kind: "raw", value: arg.text };
+            }
+            if (arg && ts.isNoSubstitutionTemplateLiteral(arg)) {
+                return { kind: "raw", value: arg.text };
+            }
+        }
         // ---- board() / boardResolve() — compile-time board constant lookup ----
         if (ts.isIdentifier(expr.expression) && (expr.expression.text === "board" || expr.expression.text === "boardResolve")) {
             const pathArg = expr.arguments[0];

package/dist/ir/feature-registry.js

@@ -198,11 +198,13 @@ function kindBasedLintRules() {
 // `no-restricted-syntax` selector for real-time editor warnings. Kept here so
 // that all editor-time selectors live in one place.
 //
-// NOTE on async/generator/yield severity: these are flagged as `"error"` by
-// ESLint (matching the prior hand-maintained config) but the transpiler only
-// emits a `TS2CPP_ASYNC_STUB` *warning* at build time and emits stub code.
-// The severity mismatch is intentional and documented here — it is not a bug
-// this refactor introduces or should silently "fix".
+// NOTE on async/await: the transpiler fully supports these — each `async`
+// function is lowered to a cooperative state-machine task driven from
+// `loop()` (see `emit/utils/async-state-machine.ts` and the
+// `async-runtime-static.ts` microtask pump). `await expr` lowers to the task
+// yielding between segments, so blocking waits become polls. They are
+// therefore intentionally NOT linted here. Generators/yield and
+// `for await...of` still have no lowering and remain flagged.
 const CONTEXT_LINT_RULES = [
     {
         selector: "ForOfStatement[await=true]",
@@ -244,26 +246,6 @@ const CONTEXT_LINT_RULES = [
         message: "[transpiler] .then() on a Promise is not supported (no promise runtime). Use synchronous return values or callbacks.",
         source: "context",
     },
-    {
-        selector: "FunctionDeclaration[async=true]",
-        message: "[transpiler] async functions are recognized for parse-compatibility but cannot produce correct embedded behavior (no event loop). Use a synchronous function.",
-        source: "context",
-    },
-    {
-        selector: "FunctionExpression[async=true]",
-        message: "[transpiler] async function expressions are recognized for parse-compatibility but cannot produce correct embedded behavior (no event loop). Use a synchronous function.",
-        source: "context",
-    },
-    {
-        selector: "ArrowFunctionExpression[async=true]",
-        message: "[transpiler] async arrow functions are recognized for parse-compatibility but cannot produce correct embedded behavior (no event loop). Use a synchronous arrow function.",
-        source: "context",
-    },
-    {
-        selector: "AwaitExpression",
-        message: "[transpiler] await is stripped to an inline expression — semantics are approximate and there is no event loop on bare metal. Avoid in firmware.",
-        source: "context",
-    },
     {
         selector: "FunctionDeclaration[generator=true]",
         message: "[transpiler] generator functions (function*) have no coroutine runtime on bare metal and are effectively unusable. Avoid.",

package/dist/ir/hal/hal-emitter.d.ts

@@ -19,9 +19,12 @@ export declare function maybeEscapeResolvedText(text: string): string;
 export declare function stripCStrAfterStringLiteral(followingLiteralText: string, resolvedValue: string): string;
 /** Resolve an arbitrary expression to its text form, with this/param substitution. */
 export declare function resolveExpressionText(expr: ts.Expression, instance: HALInstance, paramNames: string[], callArgTexts: string[], paramDefaults?: Map<string, string>): string | null;
+/** True when a HAL semantic call name wraps a GPIO/hardware ISR callback. */
+export declare function semanticCallUsesIsrCallback(fnName: string): boolean;
 /** Scan an expression AST for callback() calls, extract callback IR from callArgs,
- *  register them, and patch callArgTexts with placeholder names. */
-export declare function extractAndRegisterCallbacks(expr: ts.Expression, paramNames: string[], callArgs: ExpressionIR[], callArgTexts: string[]): void;
+ *  register them, and patch callArgTexts with placeholder names.
+ *  @param isInterruptHandler — only true for GPIO interrupt attach paths. */
+export declare function extractAndRegisterCallbacks(expr: ts.Expression, paramNames: string[], callArgs: ExpressionIR[], callArgTexts: string[], isInterruptHandler?: boolean): void;
 /** Process a HAL method body, resolving emit()/include()/semantic calls.
  *  Returns { emitLines, halOps, returnValue, returnClassName } or null if unresolvable.
  *

package/dist/ir/hal/hal-emitter.js

@@ -5,6 +5,7 @@ import { renderExprAsText } from "../render-expr.js";
 import { escapeCppKeyword } from "../../utils/strings.js";
 import { halClassRegistry, halGlobalFunctions } from "./hal-parser.js";
 import { tryResolveSemanticCall, tryResolveBoardResolveArg, tryResolveCompoundSemanticReturn, resolveConcatPath } from "./hal-plugins.js";
+import { cppTypeForHalOp } from "../../emit/utils/hal-op-cpp-type.js";
 /** Escape C++ keywords in resolved text, but only when the text looks like a
  *  variable reference (not a literal like "false", "true", "42", or a string). */
 export function maybeEscapeResolvedText(text) {
@@ -275,9 +276,22 @@ export function resolveExpressionText(expr, instance, paramNames, callArgTexts,
     }
     return expr.getText ? expr.getText() : null;
 }
+/** Semantic HAL helpers whose callbacks run in true ISR context (need IRAM_ATTR).
+ *  WiFi event handlers, timers, setInterval, etc. use callback() too but run in
+ *  a task / event loop — marking those as ISRs puts printf in IRAM and, on
+ *  ESP-IDF, trips -Werror=attributes when IRAM_ATTR's __COUNTER__ disagrees
+ *  between forward declaration and definition. */
+const ISR_CALLBACK_SEMANTIC_FNS = new Set([
+    "interruptAttach",
+]);
+/** True when a HAL semantic call name wraps a GPIO/hardware ISR callback. */
+export function semanticCallUsesIsrCallback(fnName) {
+    return ISR_CALLBACK_SEMANTIC_FNS.has(fnName);
+}
 /** Scan an expression AST for callback() calls, extract callback IR from callArgs,
- *  register them, and patch callArgTexts with placeholder names. */
-export function extractAndRegisterCallbacks(expr, paramNames, callArgs, callArgTexts) {
+ *  register them, and patch callArgTexts with placeholder names.
+ *  @param isInterruptHandler — only true for GPIO interrupt attach paths. */
+export function extractAndRegisterCallbacks(expr, paramNames, callArgs, callArgTexts, isInterruptHandler = false) {
     function scan(node) {
         if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "callback") {
             const cbArg = node.arguments[0];
@@ -292,6 +306,8 @@ export function extractAndRegisterCallbacks(expr, paramNames, callArgs, callArgT
                                 kind: "callback",
                                 params: callbackIR.params.map((p) => p.name),
                                 statements: callbackIR.body,
+                                ...(callbackIR.returnType && callbackIR.returnType !== "void" ? { returnType: callbackIR.returnType } : {}),
+                                ...(callbackIR.params ? { typedParams: callbackIR.params.map((p) => ({ name: p.name, cppType: p.cppType })).filter((p) => p.cppType && p.cppType !== "void") } : {}),
                                 sourceSpan: callbackIR.body[0]?.sourceSpan ?? {
                                     filePath: "",
                                     startLine: 0,
@@ -301,10 +317,12 @@ export function extractAndRegisterCallbacks(expr, paramNames, callArgs, callArgT
                                     startOffset: 0,
                                     endOffset: 0,
                                 },
-                                isInterruptHandler: true,
+                                ...(isInterruptHandler ? { isInterruptHandler: true } : {}),
                             }
                             : callbackIR;
-                        normalized.isInterruptHandler = true;
+                        if (isInterruptHandler) {
+                            normalized.isInterruptHandler = true;
+                        }
                         registeredCallbacks.push({ placeholderName: placeholder, callbackIR: normalized });
                         callArgTexts[paramIdx] = placeholder;
                     }
@@ -399,8 +417,9 @@ export function processHALMethodBody(instance, methodName, callArgs) {
             if (ts.isIdentifier(call.expression)) {
                 // Extract callbacks from semantic call arguments and patch callArgTexts
                 // with placeholder names before resolving (mirrors the emit() path).
+                const isIsr = semanticCallUsesIsrCallback(call.expression.text);
                 for (const arg of call.arguments) {
-                    extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts);
+                    extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts, isIsr);
                 }
                 const semanticOp = tryResolveSemanticCall(call.expression.text, call.arguments, instance, paramNames, callArgTexts, paramDefaults, callArgs);
                 if (semanticOp) {
@@ -468,8 +487,9 @@ export function processHALMethodBody(instance, methodName, callArgs) {
                 actualRetExpr = actualRetExpr.expression;
             }
             if (ts.isCallExpression(actualRetExpr) && ts.isIdentifier(actualRetExpr.expression)) {
+                const isIsr = semanticCallUsesIsrCallback(actualRetExpr.expression.text);
                 for (const arg of actualRetExpr.arguments) {
-                    extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts);
+                    extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts, isIsr);
                 }
                 const semanticOp = tryResolveSemanticCall(actualRetExpr.expression.text, actualRetExpr.arguments, instance, paramNames, callArgTexts, paramDefaults, callArgs);
                 if (semanticOp) {
@@ -594,8 +614,9 @@ export function processStatementList(stmts, instance, paramNames, callArgTexts,
                 }
                 else {
                     // R3: Try semantic HAL function call
+                    const isIsr = semanticCallUsesIsrCallback(call.expression.text);
                     for (const arg of call.arguments) {
-                        extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts);
+                        extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts, isIsr);
                     }
                     const semanticOp = tryResolveSemanticCall(call.expression.text, call.arguments, instance, paramNames, callArgTexts, paramDefaults, callArgs);
                     if (semanticOp) {
@@ -696,14 +717,21 @@ export function buildSnprintfFromConcat(expr) {
             else if (part.kind === "template_string" && part.expression.kind === "hal-expr") {
                 // HAL expression inside template literal — resolve via strategy
                 const resolved = resolveHALExprToText(part.expression);
-                if (resolved !== null) {
-                    formatString += "%d";
-                    args.push(resolved);
-                    estimatedLength += 12;
+                const argText = resolved !== null ? resolved : text;
+                const cppType = cppTypeForHalOp(part.expression.operation.operation);
+                if (cppType === "const char*" || (cppType !== undefined && /char\s*\*$/.test(cppType))) {
+                    formatString += "%s";
+                    args.push(argText);
+                    estimatedLength += 32;
+                }
+                else if (cppType === "bool") {
+                    formatString += "%s";
+                    args.push(`(${argText} ? "true" : "false")`);
+                    estimatedLength += 5;
                 }
                 else {
                     formatString += "%d";
-                    args.push(text);
+                    args.push(argText);
                     estimatedLength += 12;
                 }
             }

package/dist/ir/hal/hal-parser.d.ts

@@ -50,6 +50,12 @@ export declare function extractMethods(cls: ts.ClassDeclaration): Map<string, HA
 export declare function loadHALModules(force?: boolean): void;
 /** Get constructor includes for a HAL class. */
 export declare function getCtorIncludes(className: string): string[];
+/** Map an HttpClass factory method name to its HTTP verb, or null. */
+export declare function httpFactoryVerb(methodName: string): string | null;
+/** Render an Http factory URL argument as C++ expression text (string
+ *  literals quoted, identifiers/member accesses verbatim), or null when the
+ *  argument shape can't be resolved at compile time. */
+export declare function httpUrlArgText(arg: ts.Expression): string | null;
 /** Resolve a call receiver to a tracked HAL instance. */
 export declare function resolveHALReceiver(receiver: ts.Expression): HALInstance | null;
 /** Build field values from constructor arguments using the field mapping.