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

package/dist/emit/emitters/function-emitter-impl.js

@@ -128,7 +128,12 @@ export function emitCallbackFunctions(ctx) {
             appendSourceLine(ctx, `const unsigned long ${callback.name}_debounce = ${callback.debounceMs};`);
             appendSourceLine(ctx, "");
         }
-        appendSourceLine(ctx, `${strategy.isrFunctionAttribute?.() ?? ""}${renderCallbackSignature(callback)} {`);
+        // IRAM_ATTR only on true ISR definitions. ESP-IDF's IRAM_ATTR uses
+        // __COUNTER__, so putting it on both forward decl and definition assigns
+        // conflicting .iram1.N sections (-Werror=attributes). Non-ISR callbacks
+        // (WiFi events, timers) must not be IRAM-placed either — they call printf.
+        const isrAttr = callback.isInterruptHandler ? (strategy.isrFunctionAttribute?.() ?? "") : "";
+        appendSourceLine(ctx, `${isrAttr}${renderCallbackSignature(callback)} {`);
         if (callback.debounceMs !== undefined && callback.debounceMs > 0) {
             appendSourceLine(ctx, `  volatile unsigned long now = ${strategy.currentTimeMillis()};`);
             appendSourceLine(ctx, `  if (now - ${callback.name}_lastTime < ${callback.name}_debounce) return;`);
@@ -141,10 +146,11 @@ export function emitCallbackFunctions(ctx) {
         appendSourceLine(ctx, "}");
         appendSourceLine(ctx, "");
     }
-    // Split-mode ISR callback forward declarations in header
+    // Split-mode ISR callback forward declarations in header (no IRAM_ATTR —
+    // attribute belongs on the definition only; see comment above).
     if (effectiveEmitMode === "split") {
         for (const callback of ctx.callbackFunctions) {
-            appendHeaderLine(ctx, `${strategy.isrFunctionAttribute?.() ?? ""}${renderCallbackSignature(callback)};`);
+            appendHeaderLine(ctx, `${renderCallbackSignature(callback)};`);
         }
     }
 }
@@ -172,6 +178,10 @@ export function emitFunctions(ctx) {
     // exported functions (which ride along with their definition below).
     for (let fi = 0; fi < mappedFunctions.length; fi++) {
         const fn = mappedFunctions[fi];
+        // Async functions become cooperative *Task state machines (emitAsyncTaskClasses).
+        // Emitting an empty stub here triggers -Wunused-function with no value.
+        if (fn.isAsync && ctx.hasAsyncRuntime)
+            continue;
         const declarationParameterList = ctx.statementRenderer.renderParameters(fn.parameters, true);
         const definitionParameterList = ctx.statementRenderer.renderParameters(fn.parameters, false);
         const readonlyPrefix = fn.isReadonlyReturnType ? "const " : "";
@@ -246,65 +256,60 @@ export function emitFunctions(ctx) {
         if (hasPromiseRuntime && fn.name === asyncDriverFn) {
             appendSourceLine(ctx, "  cuttlefish_pump_microtasks();");
         }
-        if (fn.isAsync && ctx.hasAsyncRuntime) {
-            appendSourceLine(ctx, `  // driven as cooperative task in ${asyncDriverFn}()`);
-        }
-        else {
-            if (fn.typeParameterConstraints) {
-                for (const [param, expr] of fn.typeParameterConstraints) {
-                    appendSourceLine(ctx, `  static_assert(${expr}, "${param} constraint violated");`);
-                }
+        if (fn.typeParameterConstraints) {
+            for (const [param, expr] of fn.typeParameterConstraints) {
+                appendSourceLine(ctx, `  static_assert(${expr}, "${param} constraint violated");`);
             }
-            const functionScope = createChildEmissionScope(topLevelScope, fn.parameters);
-            ctx.cArrayVarNames = ctx.fnCArrayVarNames.get(String(fi)) ?? new Set();
-            const isLoopDriver = fn.name === asyncDriverFn;
-            const lastStmt = fn.statements.length > 0 ? fn.statements[fn.statements.length - 1] : null;
-            const lastIsReturn = lastStmt?.kind === "return";
-            const stmtsToEmit = (isLoopDriver && lastIsReturn)
-                ? fn.statements.slice(0, -1)
-                : fn.statements;
-            for (const statement of stmtsToEmit) {
-                appendRenderedStatement(ctx, statement, "  ", functionScope);
-            }
-            // Drive the UI runtime each frame. Fires only in the driver function when
-            // a UI is mounted (entryHasUI). Uses a separate gate from the async pump
-            // so a pure-UI program (no async/timers) still animates. When the strategy
-            // provides hostEventLoop, the per-frame work runs inside a while loop so a
-            // host target (SDL) can pump events and present between ticks. Emitted
-            // AFTER the function's init statements (ui_init/display_init/touch_init)
-            // so initialization precedes the loop.
-            if (entryHasUI() && fn.name === asyncDriverFn) {
-                const loop = strategy.hostEventLoop?.();
-                if (loop) {
-                    appendSourceLine(ctx, `  bool ${loop.flagName} = true;`);
-                    appendSourceLine(ctx, `  while (${loop.continueCondition}) {`);
-                    appendSourceLine(ctx, `    ${loop.preIteration}`);
-                }
-                appendSourceLine(ctx, `  uint32_t __tc_ui_now = (uint32_t)${strategy.currentTimeMillis()};`);
-                appendSourceLine(ctx, "  static uint32_t __tc_ui_last_tick = __tc_ui_now;");
-                appendSourceLine(ctx, "  uint32_t __tc_ui_delta = __tc_ui_now - __tc_ui_last_tick;");
-                appendSourceLine(ctx, "  __tc_ui_last_tick = __tc_ui_now;");
-                appendSourceLine(ctx, "  if (__tc_ui_delta > 250) __tc_ui_delta = 250;");
-                appendSourceLine(ctx, "  ui_tick((uint16_t)__tc_ui_delta);");
-                if (loop) {
-                    appendSourceLine(ctx, `    ${loop.postIteration}`);
-                    appendSourceLine(ctx, `  }`);
-                }
+        }
+        const functionScope = createChildEmissionScope(topLevelScope, fn.parameters);
+        ctx.cArrayVarNames = ctx.fnCArrayVarNames.get(String(fi)) ?? new Set();
+        const isLoopDriver = fn.name === asyncDriverFn;
+        const lastStmt = fn.statements.length > 0 ? fn.statements[fn.statements.length - 1] : null;
+        const lastIsReturn = lastStmt?.kind === "return";
+        const stmtsToEmit = (isLoopDriver && lastIsReturn)
+            ? fn.statements.slice(0, -1)
+            : fn.statements;
+        for (const statement of stmtsToEmit) {
+            appendRenderedStatement(ctx, statement, "  ", functionScope);
+        }
+        // Drive the UI runtime each frame. Fires only in the driver function when
+        // a UI is mounted (entryHasUI). Uses a separate gate from the async pump
+        // so a pure-UI program (no async/timers) still animates. When the strategy
+        // provides hostEventLoop, the per-frame work runs inside a while loop so a
+        // host target (SDL) can pump events and present between ticks. Emitted
+        // AFTER the function's init statements (ui_init/display_init/touch_init)
+        // so initialization precedes the loop.
+        if (entryHasUI() && fn.name === asyncDriverFn) {
+            const loop = strategy.hostEventLoop?.();
+            if (loop) {
+                appendSourceLine(ctx, `  bool ${loop.flagName} = true;`);
+                appendSourceLine(ctx, `  while (${loop.continueCondition}) {`);
+                appendSourceLine(ctx, `    ${loop.preIteration}`);
             }
-            if (isLoopDriver && (hasPromiseRuntime || asyncTaskClasses.length > 0 || usesTimers)) {
-                const taskNames = asyncTaskClasses.map(t => t.taskVarName);
-                const asyncConfig = strategy.getAsyncRuntimeConfig();
-                asyncConfig.hasPromiseRuntime = hasPromiseRuntime;
-                asyncConfig.hasTimers = usesTimers;
-                const injectionLines = strategy.asyncLoopInjection(taskNames, asyncConfig);
-                for (const line of injectionLines) {
-                    appendSourceLine(ctx, `  ${line}`);
-                }
+            appendSourceLine(ctx, `  uint32_t __tc_ui_now = (uint32_t)${strategy.currentTimeMillis()};`);
+            appendSourceLine(ctx, "  static uint32_t __tc_ui_last_tick = __tc_ui_now;");
+            appendSourceLine(ctx, "  uint32_t __tc_ui_delta = __tc_ui_now - __tc_ui_last_tick;");
+            appendSourceLine(ctx, "  __tc_ui_last_tick = __tc_ui_now;");
+            appendSourceLine(ctx, "  if (__tc_ui_delta > 250) __tc_ui_delta = 250;");
+            appendSourceLine(ctx, "  ui_tick((uint16_t)__tc_ui_delta);");
+            if (loop) {
+                appendSourceLine(ctx, `    ${loop.postIteration}`);
+                appendSourceLine(ctx, `  }`);
             }
-            if (isLoopDriver && lastIsReturn) {
-                appendRenderedStatement(ctx, lastStmt, "  ", functionScope);
+        }
+        if (isLoopDriver && (hasPromiseRuntime || asyncTaskClasses.length > 0 || usesTimers)) {
+            const taskNames = asyncTaskClasses.map(t => t.taskVarName);
+            const asyncConfig = strategy.getAsyncRuntimeConfig();
+            asyncConfig.hasPromiseRuntime = hasPromiseRuntime;
+            asyncConfig.hasTimers = usesTimers;
+            const injectionLines = strategy.asyncLoopInjection(taskNames, asyncConfig);
+            for (const line of injectionLines) {
+                appendSourceLine(ctx, `  ${line}`);
             }
         }
+        if (isLoopDriver && lastIsReturn) {
+            appendRenderedStatement(ctx, lastStmt, "  ", functionScope);
+        }
         appendSourceLine(ctx, "}");
         emitCommentLines(fn.trailingComments, "", (line) => appendSourceLine(ctx, line));
         appendSourceLine(ctx, "");
@@ -338,16 +343,21 @@ export function emitFunctions(ctx) {
 export function emitFunctionForwardDeclarations(ctx) {
     const { strategy, effectiveEmitMode } = ctx;
     const excludedNames = new Set(strategy.forwardDeclarationExclusions?.() ?? []);
-    // ISR callback forward declarations.
+    // Callback forward declarations (no IRAM_ATTR — ESP-IDF's attribute uses
+    // __COUNTER__, so decl+def would get conflicting .iram1.N sections).
     if (effectiveEmitMode !== "split") {
         for (const callback of ctx.callbackFunctions) {
-            appendSourceLine(ctx, `${strategy.isrFunctionAttribute?.() ?? ""}${renderCallbackSignature(callback)};`);
+            appendSourceLine(ctx, `${renderCallbackSignature(callback)};`);
         }
     }
     let emittedAnyFn = false;
     for (const fn of ctx.mappedFunctions) {
         if (excludedNames.has(fn.name))
             continue;
+        // Async functions become *Task classes; calls lower to `fooTask.run()`.
+        // Forward-declaring empty stubs triggers -Wunused-function.
+        if (fn.isAsync && ctx.hasAsyncRuntime)
+            continue;
         const isExported = fn.isExported === true;
         // A function is an entrypoint if it is the strategy's primary entrypoint
         // (e.g. `setup` on Arduino, `main` on native) OR one of the platform's

package/dist/emit/emitters/output-finalizer.d.ts

@@ -1,4 +1,10 @@
 import type { GeneratedOutputs } from "../../types.js";
 import type { EmitterContext } from "./emitter-context.js";
 export declare function emitPreamble(ctx: EmitterContext): void;
+/**
+ * Emit cooperative async state-machine classes. Must run AFTER top-level
+ * globals (emitTypeDeclarations) so identifiers like WIFI_SSID referenced
+ * from task bodies are already declared.
+ */
+export declare function emitAsyncTaskClasses(ctx: EmitterContext): void;
 export declare function finalizeOutput(ctx: EmitterContext): GeneratedOutputs;

package/dist/emit/emitters/output-finalizer.js

@@ -26,7 +26,7 @@ function polyfillDefinitionGuard(definition) {
     return null;
 }
 export function emitPreamble(ctx) {
-    const { strategy, effectiveEmitMode, program, shimLines, emittedPolyfills, asyncTaskClasses, includes, programAnalysis } = ctx;
+    const { strategy, effectiveEmitMode, program, shimLines, emittedPolyfills, includes, programAnalysis } = ctx;
     for (const include of dedupe(includes)) {
         appendSourceLineLocal(ctx, `#include ${include}`);
     }
@@ -73,16 +73,8 @@ export function emitPreamble(ctx) {
         }
         appendSourceLineLocal(ctx, "");
     }
-    if (asyncTaskClasses.length > 0) {
-        for (const { classDef, instanceDecl } of asyncTaskClasses) {
-            for (const line of classDef.split("\n")) {
-                appendSourceLineLocal(ctx, line);
-            }
-            appendSourceLineLocal(ctx, "");
-            appendSourceLineLocal(ctx, instanceDecl);
-            appendSourceLineLocal(ctx, "");
-        }
-    }
+    // Async task classes are emitted later (emitAsyncTaskClasses) AFTER top-level
+    // globals so references like WIFI_SSID inside the state machine compile.
     if (strategy.needsVectorOverload() && hasConsoleCalls(program, strategy) && (programAnalysis.usesVectorTypes || programAnalysis.hasArrayInObjectLiteral)) {
         appendSourceLineLocal(ctx, "template <typename T>");
         appendSourceLineLocal(ctx, "std::ostream& operator<<(std::ostream& os, const std::vector<T>& values)");
@@ -136,6 +128,24 @@ export function emitPreamble(ctx) {
         appendSourceLineLocal(ctx, "");
     }
 }
+/**
+ * Emit cooperative async state-machine classes. Must run AFTER top-level
+ * globals (emitTypeDeclarations) so identifiers like WIFI_SSID referenced
+ * from task bodies are already declared.
+ */
+export function emitAsyncTaskClasses(ctx) {
+    const { asyncTaskClasses } = ctx;
+    if (asyncTaskClasses.length === 0)
+        return;
+    for (const { classDef, instanceDecl } of asyncTaskClasses) {
+        for (const line of classDef.split("\n")) {
+            appendSourceLineLocal(ctx, line);
+        }
+        appendSourceLineLocal(ctx, "");
+        appendSourceLineLocal(ctx, instanceDecl);
+        appendSourceLineLocal(ctx, "");
+    }
+}
 export function finalizeOutput(ctx) {
     const { program, strategy, options, effectiveEmitMode, isNpmPackage, baseName, includes, shimLines, emittedPolyfills } = ctx;
     const outDir = options.outDir;

package/dist/emit/emitters/setup.js

@@ -327,6 +327,46 @@ export function buildEmitterContext(program, options) {
         if (!programAnalysis.usesTone) {
             shimLines = filterShimBlock(shimLines, '// CUTTLEFISH_TONE_BEGIN', '// CUTTLEFISH_TONE_END');
         }
+        // framework-esp32 native peripheral driver shims. Same defensive-backstop
+        // pattern as the UART/SPI/TWI/EEPROM/tone blocks above. framework-arduino's
+        // and framework-avr's shimLines contain none of these markers, so these
+        // filters are no-ops there.
+        if (!programAnalysis.usesGPIO) {
+            shimLines = filterShimBlock(shimLines, '// CUTTLEFISH_GPIO_BEGIN', '// CUTTLEFISH_GPIO_END');
+        }
+        if (!programAnalysis.usesPWM) {
+            shimLines = filterShimBlock(shimLines, '// CUTTLEFISH_PWM_BEGIN', '// CUTTLEFISH_PWM_END');
+        }
+        if (!programAnalysis.usesADC) {
+            shimLines = filterShimBlock(shimLines, '// CUTTLEFISH_ADC_BEGIN', '// CUTTLEFISH_ADC_END');
+        }
+        if (!programAnalysis.usesDAC) {
+            shimLines = filterShimBlock(shimLines, '// CUTTLEFISH_DAC_BEGIN', '// CUTTLEFISH_DAC_END');
+        }
+        if (!programAnalysis.usesPower) {
+            shimLines = filterShimBlock(shimLines, '// CUTTLEFISH_POWER_BEGIN', '// CUTTLEFISH_POWER_END');
+        }
+        if (!programAnalysis.usesWdt) {
+            shimLines = filterShimBlock(shimLines, '// CUTTLEFISH_WDT_BEGIN', '// CUTTLEFISH_WDT_END');
+        }
+        if (!programAnalysis.usesInterrupts) {
+            shimLines = filterShimBlock(shimLines, '// CUTTLEFISH_INTR_BEGIN', '// CUTTLEFISH_INTR_END');
+        }
+        if (!programAnalysis.usesPulse) {
+            shimLines = filterShimBlock(shimLines, '// CUTTLEFISH_PULSE_BEGIN', '// CUTTLEFISH_PULSE_END');
+        }
+        if (!programAnalysis.usesShift) {
+            shimLines = filterShimBlock(shimLines, '// CUTTLEFISH_SHIFT_BEGIN', '// CUTTLEFISH_SHIFT_END');
+        }
+        if (!programAnalysis.usesWifi) {
+            shimLines = filterShimBlock(shimLines, '// CUTTLEFISH_WIFI_BEGIN', '// CUTTLEFISH_WIFI_END');
+        }
+        if (!programAnalysis.usesHttp) {
+            shimLines = filterShimBlock(shimLines, '// CUTTLEFISH_HTTP_BEGIN', '// CUTTLEFISH_HTTP_END');
+        }
+        if (!programAnalysis.usesPreferences) {
+            shimLines = filterShimBlock(shimLines, '// CUTTLEFISH_PREFERENCES_BEGIN', '// CUTTLEFISH_PREFERENCES_END');
+        }
         profileDiagnostics = [...strategy.profileDiagnostics(program, options.platformContext)];
     }
     for (const imported of program.imports) {

package/dist/emit/emitters/top-level-prep.js

@@ -597,6 +597,8 @@ export function runTopLevelPreprocessing(ctx) {
             statements: callbackIR.statements ?? callbackIR.body ?? [],
             debounceMs: callbackIR.debounceMs,
             isInterruptHandler: callbackIR.isInterruptHandler,
+            ...(callbackIR.returnType ? { returnType: callbackIR.returnType } : {}),
+            ...(callbackIR.typedParams ? { typedParams: callbackIR.typedParams } : {}),
         });
         replacePlaceholderInAllStatements(filteredTopLevelExecutables, rc.placeholderName, callbackName);
         for (const fn of mappedFunctions) {

package/dist/emit/emitters/ui-emitter.js

@@ -34,7 +34,7 @@ import { getRadioGroups } from "../../ir/ui-element-auto-wire.js";
 // minPressure gate is skipped for them. Resistive controllers (XPT2046,
 // STMPE610, Adafruit_TouchScreen) keep the gate.
 // ---------------------------------------------------------------------------
-const CAPACITIVE_TOUCH_LIBS = new Set(["FT6336U", "sdl"]);
+const CAPACITIVE_TOUCH_LIBS = new Set(["FT6336U", "GT911", "CST816S", "sdl"]);
 /** Generate the ui_poll_touch() body, or null for the no-touch path. */
 export function generateTouchPollBody(input) {
     const { library, minPressure, calibration, profile } = input;
@@ -141,9 +141,14 @@ export function emitUIRuntime(ctx) {
     // display-adapter registry. Must precede the runtime header so the
     // adapter functions (__tc_display, display_init, etc.) are available.
     const profile = getDisplayProfile();
-    // 0. SPI-bus display drivers (ILI9341, ST7796, …) need the SPI library.
-    // Host render targets (sdl, native-preview) have no SPI bus, so skip it.
-    const spiDriver = profile?.driver !== "sdl" && profile?.driver !== "native-preview";
+    // 0. SPI-bus display drivers (ILI9341, ST7796, …) need the Arduino SPI
+    // library — but ONLY on the Adafruit path. Native adapters (AVR, ESP32)
+    // emit their own bus setup and would break on <SPI.h>. Host render targets
+    // (sdl, native-preview) have no SPI bus at all.
+    const nativeAdapter = ctx.strategy?.providesDisplayAdapter?.() ?? false;
+    const spiDriver = profile?.driver !== "sdl"
+        && profile?.driver !== "native-preview"
+        && !nativeAdapter;
     if (spiDriver && !ctx.includes.includes("<SPI.h>")) {
         ctx.includes.push("<SPI.h>");
     }
@@ -151,7 +156,7 @@ export function emitUIRuntime(ctx) {
     // buildEmitterContext (setup.ts), NOT here — emitPreamble runs before this
     // function, so a push here would be too late to land in the output.
     if (profile) {
-        const adapter = generateDisplayAdapter(profile);
+        const adapter = generateDisplayAdapter(profile, ctx.strategy);
         // Prepend includes to the very front — Arduino's auto-prototyper scans
         // the whole .ino and generates prototypes that reference GFXcanvas16
         // etc. before any #include, so the GFX header must come first.
@@ -164,6 +169,14 @@ export function emitUIRuntime(ctx) {
         ctx.sourceLines.push(is888
             ? "#define UI_COLOR_DEPTH 888\n#define UI_COLOR_T uint32_t\n#define UI_DIM_MASK 0x7F7F7Fu"
             : "#define UI_COLOR_DEPTH 565\n#define UI_COLOR_T uint16_t\n#define UI_DIM_MASK 0x7BEFu");
+        // Native display adapters (AVR, ESP32) instantiate CuttlefishGFX by value
+        // in their declaration block. The class MUST be defined before that —
+        // emit the cuttlefish-gfx slice here, between the color preamble and the
+        // adapter declaration. Arduino path (Adafruit) returns "" from the slice.
+        const nativeDisplayActive = ctx.strategy?.providesDisplayAdapter?.() ?? false;
+        if (nativeDisplayActive) {
+            ctx.sourceLines.push(ui.emitCuttlefishGfx(true));
+        }
         ctx.sourceLines.push(adapter.declaration);
         ctx.sourceLines.push(adapter.functions);
     }
@@ -173,7 +186,7 @@ export function emitUIRuntime(ctx) {
     if (profile.touch) {
         const t = profile.touch;
         if (t.library) {
-            touchAdapter = generateTouchAdapter(t);
+            touchAdapter = generateTouchAdapter(t, ctx.strategy);
             // Prepend includes to the front (Arduino auto-prototyper safety).
             ctx.sourceLines.unshift(touchAdapter.includes[0]);
             for (let i = 1; i < touchAdapter.includes.length; i++) {
@@ -252,13 +265,15 @@ export function emitUIRuntime(ctx) {
     //     header so its #ifndef guards adopt them. Source of truth:
     //     resolveScrollConfig(profile.scroll). Defaults derive from the declared
     //     touch hardware, so the demo (XPT2046) gets resistive+full with no config.
-    const scroll = resolveScrollConfig(profile, { buildTarget: profile._buildTarget });
+    const scroll = resolveScrollConfig(profile, { buildTarget: profile._buildTarget, psram: profile._psram });
     ctx.sourceLines.push(`#define UI_SCROLL_MAX_OVERSCROLL ${scroll.maxOverscroll}`, `#define UI_SCROLL_STIFFNESS_X10 ${Math.round(scroll.stiffness * 10)}`, `#define UI_SCROLL_EDGE_SNAP_PX ${scroll.edgeSnapPx}`, `#define UI_SCROLL_DRAG_SCALE_X10 ${Math.round(scroll.dragScale * 10)}`, `#define UI_SCROLL_INPUT_TIER_CAPACITIVE ${scroll.inputTier === "capacitive" ? 1 : 0}`, `#define UI_SCROLL_INPUT_TIER_RESISTIVE ${scroll.inputTier === "resistive" ? 1 : 0}`, `#define UI_SCROLL_INPUT_TIER_NONE ${scroll.inputTier === "none" ? 1 : 0}`, `#define UI_SCROLL_RENDER_TIER_FULL ${scroll.renderTier === "full" ? 1 : 0}`, `#define UI_SCROLL_RENDER_TIER_CONSTRAINED ${scroll.renderTier === "constrained" ? 1 : 0}`, `#define UI_SCROLL_CANVAS_BUDGET_BYTES ${scroll.scrollCanvasBudgetBytes}`, ...(scroll.debug ? [`#define UI_SCROLL_DEBUG 1`] : []));
     // Forward-declare __ui_kb_set_onchange before the runtime header: the
     // header's keyboard-open function calls it, but the definition is emitted
     // later (section 8b). On native (single TU) this must precede the header.
     ctx.sourceLines.push(`void __ui_kb_set_onchange();`);
-    ctx.sourceLines.push(emitRuntimeHeader());
+    ctx.sourceLines.push(emitRuntimeHeader({
+        nativeDisplayActive: ctx.strategy?.providesDisplayAdapter?.() ?? false,
+    }));
     // 1.5. Touch poll function (uses the adapter pattern). Body is generated by
     // generateTouchPollBody — extracted for unit-testability of the capacitive
     // vs resistive branch (FT6336U/SDL skip the minPressure gate).

package/dist/emit/expression-renderer.js

@@ -10,6 +10,7 @@ import { accessorGetterName } from "./utils/cpp-helpers.js";
 import { INTEGRAL_CPP_TYPE_RE } from "./utils/cpp-helpers.js";
 import { renderPeripheralProperty } from "../mapping/peripheral-names.js";
 import { parseCppType, renderCppType, bareType, parsedIsPointer, parsedIsVector, needsCStrForStringLike } from "../api/shared/cpp-type-ir.js";
+import { cppTypeForHalOp } from "./utils/hal-op-cpp-type.js";
 /**
  * Renders ExpressionIR nodes to C++ code strings.
  */
@@ -403,6 +404,8 @@ export class ExpressionRenderer {
             }
             case "unary":
                 return expr.operator === "!" ? "bool" : this.inferExpressionCppType(expr.operand, knownVariableTypes);
+            case "hal-expr":
+                return cppTypeForHalOp(expr.operation.operation);
             default:
                 return undefined;
         }
@@ -714,10 +717,16 @@ export class ExpressionRenderer {
             }
             case "hal-expr": {
                 const rendered = this.render(expr, exprTransformer);
-                // HAL expressions that resolve to string-like outputs use %s
                 if (rendered.startsWith('"') || this.stringVarNames?.has(rendered)) {
                     return { format: "%s", arg: rendered, estimatedLength: 32 };
                 }
+                const cppType = cppTypeForHalOp(expr.operation.operation);
+                if (cppType && this.isStringLikeCppType(cppType)) {
+                    return { format: "%s", arg: rendered, estimatedLength: 32 };
+                }
+                if (cppType === "bool") {
+                    return { format: "%s", arg: `(${rendered} ? "true" : "false")`, estimatedLength: 5 };
+                }
                 return { format: "%d", arg: rendered, estimatedLength: 12 };
             }
             case "method-call":

package/dist/emit/snprintf-helpers.js

@@ -8,6 +8,7 @@
 // Types are imported from @typecad/cuttlefish/api/shared.
 // ---------------------------------------------------------------------------
 import { escapeCppStringLiteral, escapeSnprintfFormatFragment } from "../utils/strings.js";
+import { cppTypeForHalOp } from "./utils/hal-op-cpp-type.js";
 import { parsedElementString, parsedIsStringLike } from "../api/shared/cpp-type-ir.js";
 // ---------------------------------------------------------------------------
 // Scope state management
@@ -369,6 +370,13 @@ export function inferSnprintfArg(expr, strategy, scopeState, renderExpression, p
             if (rendered.startsWith('"') || stringVarNames?.has(rendered)) {
                 return { format: "%s", arg: rendered, estimatedLength: 32, preludeLines: [] };
             }
+            const cppType = cppTypeForHalOp(expr.operation.operation);
+            if (cppType && strategy.isStringLikeType(cppType)) {
+                return { format: "%s", arg: rendered, estimatedLength: 32, preludeLines: [] };
+            }
+            if (cppType === "bool") {
+                return { format: "%s", arg: `(${rendered} ? "true" : "false")`, estimatedLength: 5, preludeLines: [] };
+            }
             return { format: "%d", arg: rendered, estimatedLength: 12, preludeLines: [] };
         }
         default:

package/dist/emit/statement-renderer.js

@@ -485,6 +485,19 @@ export class StatementRenderer {
             const rawStmt = statement.callee.slice('__RAW_STMT__'.length);
             return forHeader ? rawStmt : `${rawStmt.endsWith(';') ? rawStmt : rawStmt + ';'}`;
         }
+        // Awaited network markers (__WIFI_WAIT__/__HTTP_WAIT__) reaching the
+        // plain renderer means the await sits outside an async state machine
+        // (top-level await, or a position the state-machine splitter doesn't
+        // support). Fall back to the blocking form of the op they carry.
+        if ((statement.callee === "__WIFI_WAIT__" || statement.callee === "__HTTP_WAIT__" || statement.callee === "__BLE_WAIT__" || statement.callee === "__HAL_WAIT__")
+            && statement.args[0]?.kind === "hal-expr") {
+            const resolved = routeHALOp(statement.args[0].operation, this.strategy);
+            const code = resolved?.code ?? (resolved?.expression ? `${resolved.expression};` : undefined);
+            if (code) {
+                return forHeader ? code.replace(/;$/, "") : code;
+            }
+            return `/* unhandled awaited hal-op: ${statement.args[0].operation.operation} */`;
+        }
         // Handle emit() — compile-time C++ injection
         if (statement.callee === "__EMIT__") {
             const rawText = statement.args.map(arg => this.renderEmitArg(arg)).join("");