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

package/dist/ir/pulldown-validation.js

@@ -4,6 +4,7 @@
 // Checks that pins configured with inputPullDown() actually support
 // hardware pulldown on the target board. Emits a compile-time error if not.
 // ---------------------------------------------------------------------------
+import { pinEntryIndexForNumber } from './pin-capability-validation.js';
 /**
  * Validate that pins used with inputPullDown() support pulldown on this board.
  */
@@ -13,9 +14,14 @@ export function validatePulldownSupport(usage, boardConstants, filePath) {
         return diagnostics;
     }
     for (const pinNumber of usage.inputPulldownPins) {
-        // Check the pin's own pullDown capability from board definition
-        // undefined or false both mean pulldown is not supported on this pin
-        const supportsPullDown = boardConstants?.get(`pins.all.${pinNumber}.capabilities.pullDown`);
+        // Check the pin's own pullDown capability from board definition.
+        // undefined or false both mean pulldown is not supported on this pin.
+        // The entry is resolved by pin NUMBER — the pins.all array index diverges
+        // from the number on MCUs with unbonded pads (see pinEntryIndexForNumber).
+        const entryIdx = pinEntryIndexForNumber(pinNumber, boardConstants);
+        if (entryIdx < 0)
+            continue; // Unknown pin — the emitter's own resolution reports it.
+        const supportsPullDown = boardConstants?.get(`pins.all.${entryIdx}.capabilities.pullDown`);
         if (supportsPullDown !== true) {
             const pinName = getPinName(pinNumber, boardConstants);
             const arch = boardConstants?.get('architecture');
@@ -39,7 +45,8 @@ function getPinName(pinNumber, boardConstants) {
             return `A${pinNumber - 14}`;
         return `D${pinNumber}`;
     }
-    const name = boardConstants.get(`pins.all.${pinNumber}.name`);
+    const entryIdx = pinEntryIndexForNumber(pinNumber, boardConstants);
+    const name = entryIdx >= 0 ? boardConstants.get(`pins.all.${entryIdx}.name`) : undefined;
     if (typeof name === 'string')
         return name;
     // Fallback naming

package/dist/ir/resource-analysis.js

@@ -125,10 +125,22 @@ function isPinUsedAsGpio(pinName, pinNumber, usage) {
     return false;
 }
 function isPeripheralActive(type, instance, usage) {
+    // When the program's ops identify WHICH controller instances are used, only
+    // those instances claim pins. The old `usage.i2c || ...` disjunct claimed
+    // every instance's pins whenever the bus type appeared at all — on boards
+    // whose alternate-bus pin sets overlap another bus's (the blackpill's
+    // i2c-alt on PB3/PB4 shares pins with spi2), that manufactured phantom
+    // peripheral-peripheral conflicts. The bare-type fallback only applies when
+    // NO instance information was recorded (degenerate programs whose ops carry
+    // no instance), preserving the conservative claim where it's the only
+    // signal available.
     switch (type) {
-        case 'i2c': return usage.i2c || usage.i2cInstancesUsed.has(instance);
-        case 'spi': return usage.spi || usage.spiInstancesUsed.has(instance);
-        case 'uart': return usage.uart || usage.uartInstancesUsed.has(instance);
+        case 'i2c':
+            return usage.i2cInstancesUsed.size > 0 ? usage.i2cInstancesUsed.has(instance) : usage.i2c;
+        case 'spi':
+            return usage.spiInstancesUsed.size > 0 ? usage.spiInstancesUsed.has(instance) : usage.spi;
+        case 'uart':
+            return usage.uartInstancesUsed.size > 0 ? usage.uartInstancesUsed.has(instance) : usage.uart;
         default: return false;
     }
 }

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

@@ -3,7 +3,6 @@ import { isStringEnum } from "../api/shared/index.js";
 import { extractNodeComments, makeDiagnostic, makeSourceSpan } from "./ast-node-utils.js";
 import { isCompileTimeOnlyCallName, isCompileTimeOnlyClassName } from "./compile-time-only.js";
 import { TYPED_ARRAY_ELEMENT_MAP, hoistedNestedEnums, hoistedNestedInterfaces, hoistedNestedTypeAliases, nestedFunctionAliases, nestedClassAliases, mutableArrayVars, arrayLiteralSizes, activeEnumNames, activeStringEnumNames, resetFunctionScopeState } from "./build-ir-state.js";
-import { isPinFoldingEnabled, setPinFoldingEnabled, invalidatePinLevels } from "./pin-state-tracking.js";
 import { getCurrentIrTypeScope, bindIrTypeScopeLocals } from "./symbol-types.js";
 import { renderExprAsText } from "./render-expr.js";
 import { expressionToIR } from "./expression-to-ir.js";
@@ -184,9 +183,6 @@ export function lowerStatementList(statements, fileName, sourceText, diagnostics
     // top-level levels afterwards. "" and "<top-level>" are the top-level
     // markers; everything else names a function/method/lambda body.
     const isFunctionBodyCtx = functionNameForDiagnostics !== "" && functionNameForDiagnostics !== "<top-level>";
-    const prevPinFolding = isPinFoldingEnabled();
-    if (isFunctionBodyCtx)
-        setPinFoldingEnabled(false);
     // Phase 1: Pre-scan for nested function declarations — register aliases only.
     // This ensures sibling functions can reference each other.
     for (const statement of statements) {
@@ -356,8 +352,6 @@ export function lowerStatementList(statements, fileName, sourceText, diagnostics
         nestedClassAliases.delete(name);
     }
     if (isFunctionBodyCtx) {
-        setPinFoldingEnabled(prevPinFolding);
-        invalidatePinLevels();
     }
     return lowered;
 }

package/dist/ir/timing-validation.js

@@ -87,7 +87,7 @@ export function validateBlockingDelayInLoop(program, strategy) {
                     ? `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.`;
+                        `for the delay duration. This causes display tearing and makes the program 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, ` +

package/dist/ir/transformers/array-methods.js

@@ -229,9 +229,16 @@ export function tryLowerArrayAndStringMethods(expr, sourceText, diagnostics, poi
     //
     // Target gate: the __tc_* helpers are native/hosted-only (Arduino/embedded
     // lower arrays to StaticArray, caught by the mutableArrayVars branch above,
-    // and have no __tc_* polyfills). requiresLoopFunction() is false exactly on
-    // hosted targets — the same set that ran the old native normalizeRawExpression.
-    const isHostedTarget = !getContext().activeStrategy?.requiresLoopFunction();
+    // and have no __tc_* polyfills). Two signals compose: the target has no
+    // repeatedly-called loop() (requiresLoopFunction() false — the historical
+    // proxy for "hosted"), AND it actually carries std::vector (getStdLibSupport
+    // ().hasVector). The second signal matters because a main()-entry RTOS
+    // target (Zephyr) also reports requiresLoopFunction()=false but lowers
+    // arrays to __tc_StaticArray — without the hasVector conjunct it would
+    // wrongly take the std::vector/.push_back path.
+    const strat = getContext().activeStrategy;
+    const isHostedTarget = !strat?.requiresLoopFunction()
+        && (strat?.getStdLibSupport?.().hasVector ?? true);
     if (isHostedTarget && ts.isPropertyAccessExpression(expr.expression)) {
         const methodName = expr.expression.name.text;
         // `push` lowers to native push_back (matches the old
@@ -403,8 +410,7 @@ function resolveReceiverCppType(receiverNode) {
  *
  * When the element type is integral and the arg is a numeric-enum value, wrap
  * the rendered arg in `static_cast<int>(...)`. Demo #32 Finding A. Mirrors the
- * SUPPORT_MATRIX §1.7 enum↔integral family fixed at the assign/var_decl sites
- * in the emit layer.
+ * enum↔integral family fixed at the assign/var_decl sites in the emit layer.
  */
 function renderPushArgForElement(argNode, receiverNode, sourceText, diagnostics, pointerVars) {
     const rendered = renderExprAsText(expressionToIR(argNode, sourceText, diagnostics, pointerVars));

package/dist/ir/transformers/call-statement.js

@@ -1,7 +1,7 @@
 import ts from "typescript";
-import { requiredIncludes, mutableArrayVars, nestedClassAliases, hoistedNestedClasses, topLevelClassNames, topLevelClasses, activeEnumNames, hoistedNestedFunctions, getContext } from "../build-ir-state.js";
+import { requiredIncludes, mutableArrayVars, nestedClassAliases, hoistedNestedClasses, topLevelClassNames, topLevelClasses, activeEnumNames } from "../build-ir-state.js";
 import { getCurrentIrTypeScope } from "../symbol-types.js";
-import { extractNodeComments, makeSourceSpan } from "../ast-node-utils.js";
+import { extractNodeComments, makeSourceSpan, makeDiagnostic } from "../ast-node-utils.js";
 import { tryResolveHALMethod } from "./hal-call-resolver.js";
 import { tryResolveUICall, isSignalName, resolveUIModuleImport, recordPressBinding, uiPressBindings, resolveNodeIndex, resolveNodeTag, watchPinSpecs, recordWatchPin, recordClickHandler, clickHandlers, pushUnknownElementDiagnostic } from "./ui-call-resolver.js";
 import { hasSafetyHook, requireSafetyHook } from "../../safety-hook.js";
@@ -10,7 +10,6 @@ import { rewriteCanvasCall } from "./canvas-lowering.js";
 import { callbackContextLabel, unsupportedStatementHint } from "./callback-context-registry.js";
 import { tryLowerArrayAndStringMethods } from "./array-methods.js";
 import { expressionToIR } from "../expression-to-ir.js";
-import { lowerStatementList } from "../statement-to-ir.js";
 import { escapeCppKeyword } from "../../utils/strings.js";
 import { renderExprAsText, calleeToText } from "../render-expr.js";
 import { parseCppType, renderCppType, parsedIsPointer, parsedIsMap, parsedIsSet } from "../../api/shared/cpp-type-ir.js";
@@ -163,14 +162,7 @@ function tryResolveSafetyCallStatement(call, fileName, sourceText) {
         if (a.kind === ts.SyntaxKind.FalseKeyword)
             return false;
         if (ts.isIdentifier(a)) {
-            const name = a.text;
-            if (name === "INPUT")
-                return 0;
-            if (name === "OUTPUT")
-                return 1;
-            if (name === "INPUT_PULLUP")
-                return 2;
-            return name;
+            return a.text;
         }
         // Property access (e.g. r.value), arithmetic, or other expression:
         // render to the C++ expression text so the op can emit it inline.
@@ -188,16 +180,23 @@ function tryResolveSafetyCallStatement(call, fileName, sourceText) {
 }
 export function callToStatement(statementNode, call, fileName, sourceText, diagnostics, pointerVars = new Map()) {
     const comments = extractNodeComments(statementNode, sourceText);
-    // ── setInterval/setTimeout arrow-callback hoisting (BEFORE HAL) ────────
-    // The timer helpers are runtime utilities, never HAL methods, but the HAL
-    // resolver treats bare-identifier globals as pseudo-HAL calls and claims
-    // them — baking the arrow arg into a lambda placeholder before our hoist
-    // can run. Intercept timer calls with arrow callbacks FIRST, hoist the
-    // arrow to a named function, and short-circuit before HAL sees it.
-    if (ts.isIdentifier(call.expression) && TIMER_CALLEES.has(call.expression.text)) {
-        const hoisted = hoistTimerArrowArg(call, fileName, sourceText, diagnostics, pointerVars, comments);
-        if (hoisted)
-            return hoisted;
+    // ── console.* is not a supported API ────────────────────────────────────
+    // The TypeScript console carry-over (lowering to a platform print plus a
+    // config section routing it) is gone. Programs write to a serial console
+    // explicitly: USB0.writeLine(...) or UART0.writeLine(...). Sourced at IR
+    // build time so the diagnostic points at the user's statement and the
+    // real pipeline aborts before emit.
+    if (ts.isPropertyAccessExpression(call.expression) &&
+        ts.isIdentifier(call.expression.expression) &&
+        call.expression.expression.text === "console") {
+        diagnostics.push(makeDiagnostic(sourceText, call.getStart(), `console.${call.expression.name.text}() is not supported — write to a serial console instead: \`USB0.writeLine(...)\` (USB CDC) or \`UART0.writeLine(...)\` from the board module.`, "error", "console-unsupported"));
+        return {
+            kind: "block",
+            sourceSpan: makeSourceSpan(call, fileName, sourceText),
+            leadingComments: comments.leadingComments,
+            trailingComments: comments.trailingComments,
+            body: [],
+        };
     }
     // ── Ambient canvas ctx: rewrite ctx.method(...) while drawCanvas lowers ──
     {
@@ -783,8 +782,6 @@ export function callToStatement(statementNode, call, fileName, sourceText, diagn
     else {
         calleeText = calleeToText(call.expression);
     }
-    // Timer calls with arrow callbacks are intercepted before HAL (above);
-    // named-function callbacks fall through here unchanged.
     return {
         kind: "call",
         sourceSpan: makeSourceSpan(call, fileName, sourceText),
@@ -794,70 +791,6 @@ export function callToStatement(statementNode, call, fileName, sourceText, diagn
         args: call.arguments.map((arg) => expressionToIR(arg, sourceText, diagnostics, pointerVars)),
     };
 }
-// ── setInterval/setTimeout arrow-callback hoisting ──────────────────────────
-const TIMER_CALLEES = new Set(["setInterval", "setTimeout", "__tc_setInterval", "__tc_setTimeout"]);
-let timerCallbackCounter = 0;
-/**
- * Hoist an inline arrow/function-expression callback argument of a
- * setInterval/setTimeout call to a named free function, and return the
- * rewritten call with the function name replacing the arrow.
- *
- * Returns null if arg[0] isn't an inline arrow/function (named-function
- * callbacks pass through to the generic path unchanged).
- *
- * Called from the generic fallthrough at the end of callToStatement — NOT
- * as an early return — because top-level timer calls reach the fallthrough
- * path, not the early-interception points.
- */
-function hoistTimerArrowArg(call, fileName, sourceText, diagnostics, pointerVars, comments) {
-    const callbackArg = call.arguments[0];
-    if (!callbackArg || !(ts.isArrowFunction(callbackArg) || ts.isFunctionExpression(callbackArg))) {
-        return null;
-    }
-    const fnName = `__tc_timer_cb_${timerCallbackCounter++}`;
-    const scope = getCurrentIrTypeScope();
-    const localVariableTypes = new Map();
-    if (scope) {
-        for (const [k, v] of scope.globals)
-            localVariableTypes.set(k, v);
-    }
-    const functionReturnTypes = new Map([...(getContext().activeFunctionReturnTypes ?? new Map())]);
-    const bodyStatements = lowerStatementList(ts.isBlock(callbackArg.body) ? callbackArg.body.statements : [], fileName, sourceText, diagnostics, functionReturnTypes, localVariableTypes, fnName, undefined, pointerVars);
-    if (!ts.isBlock(callbackArg.body)) {
-        const exprText = renderExprAsText(expressionToIR(callbackArg.body, sourceText, diagnostics));
-        bodyStatements.push({
-            kind: "call",
-            sourceSpan: makeSourceSpan(callbackArg.body, fileName, sourceText),
-            callee: "__EMIT__",
-            args: [{ kind: "string", value: exprText }],
-        });
-    }
-    hoistedNestedFunctions.push({
-        originalName: fnName,
-        isAsync: false,
-        returnType: "void",
-        sourceSpan: makeSourceSpan(callbackArg, fileName, sourceText),
-        leadingComments: [],
-        trailingComments: [],
-        parameters: [],
-        statements: bodyStatements,
-    });
-    // Apply the polyfill helper rename (setInterval → __tc_setInterval) so the
-    // emitted call matches the runtime helper the framework provides.
-    const rawCallee = ts.isIdentifier(call.expression) ? call.expression.text : calleeToText(call.expression);
-    const calleeText = rawCallee === "setInterval" ? "__tc_setInterval"
-        : rawCallee === "setTimeout" ? "__tc_setTimeout"
-            : rawCallee;
-    const remainingArgs = call.arguments.slice(1).map((arg) => expressionToIR(arg, sourceText, diagnostics, pointerVars));
-    return {
-        kind: "call",
-        sourceSpan: makeSourceSpan(call, fileName, sourceText),
-        leadingComments: comments.leadingComments,
-        trailingComments: comments.trailingComments,
-        callee: calleeText,
-        args: [{ kind: "identifier", value: fnName }, ...remainingArgs],
-    };
-}
 // ── Helper: lower a callback expression to C++ text ─────────────────────────
 // (Moved to ui-callback-lowering.ts so onToggle and watchPin share one path,
 // including console.* → platform transform which lived in neither copy.)

package/dist/ir/transformers/callback-context-registry.d.ts

@@ -1,4 +1,4 @@
-export type CallbackContextId = "setInterval" | "ui-event-callback" | "ui-draw-canvas";
+export type CallbackContextId = "ui-event-callback" | "ui-draw-canvas";
 export interface CallbackContextCapabilities {
     id: CallbackContextId;
     /** Human label used in diagnostic messages, e.g. "UI event callback". */

package/dist/ir/transformers/callback-context-registry.js

@@ -1,22 +1,14 @@
 // ---------------------------------------------------------------------------
 // Declarative capability registry for UI callback contexts.
 //
-// UI callback bodies (setInterval, ui.bind/onClick/onToggle/watchPin,
-// ui.drawCanvas) each lower through lowerCallbackStatements →
-// lowerStatementList (the same pipeline setInterval uses). This registry is
-// the single declarative source of truth for diagnostics: each context lists
-// what it lowers, and unsupportedStatementHint() renders that list into the
-// hint text shown next to fatal "ui-callback-unsupported-statement"
-// diagnostics.
+// UI callback bodies (ui.bind/onClick/onToggle/watchPin, ui.drawCanvas)
+// each lower through lowerCallbackStatements → lowerStatementList. This
+// registry is the single declarative source of truth for diagnostics: each
+// context lists what it lowers, and unsupportedStatementHint() renders that
+// list into the hint text shown next to fatal "ui-callback-unsupported-
+// statement" diagnostics.
 // ---------------------------------------------------------------------------
 export const CALLBACK_CONTEXTS = {
-    setInterval: {
-        id: "setInterval",
-        label: "setInterval callback",
-        statements: ["const/let", "if/else", "for", "while", "do/while", "break/continue", "nested blocks"],
-        expressions: ["the full statement-to-IR expression pipeline — the same one top-level code uses"],
-        escapeHatch: "setInterval callbacks already route through the main statement-to-IR pipeline, so a failure here reflects a general transpiler limitation rather than a callback-context restriction",
-    },
     "ui-event-callback": {
         id: "ui-event-callback",
         label: "UI event callback",
@@ -27,7 +19,7 @@ export const CALLBACK_CONTEXTS = {
             "console.* calls",
             "any other expression via the standard expression pipeline (arithmetic, comparisons, ternaries, color literals, ...)",
         ],
-        escapeHatch: "move the logic to setInterval or a plain function",
+        escapeHatch: "move the logic to a Thread or a plain function",
     },
     "ui-draw-canvas": {
         id: "ui-draw-canvas",
@@ -36,7 +28,7 @@ export const CALLBACK_CONTEXTS = {
         expressions: [
             "ctx.*() draw calls (drawPixel, fillRect, rect, fillRoundRect, roundRect, line, hline, vline, fillCircle, circle, rgbBitmap, text, fillScreen)",
         ],
-        escapeHatch: "move non-drawing side effects (calls not on ctx, e.g. signal writes or console output) to setInterval",
+        escapeHatch: "move non-drawing side effects (calls not on ctx, e.g. signal writes or console output) to a Thread",
     },
 };
 /** Human-readable name for a context, used in diagnostic messages. */

package/dist/ir/transformers/control-flow.js

@@ -6,7 +6,6 @@ import { parseCppType, renderCppType, isPointer, parsedIsVector, parsedElementSt
 import { expressionToIR } from "../expression-to-ir.js";
 import { lowerStatementList, expressionStatementToIR } from "../statement-to-ir.js";
 import { assignmentOperatorToString, updateLocalTypeFromAssignment, extractForInKeys } from "./variables.js";
-import { snapshotPinLevels, restorePinLevels, mergePinLevels, invalidatePinLevels } from "../pin-state-tracking.js";
 // Monotonic counter for synthetic for...of destructure loop variables.
 let forOfDestructureCounter = 0;
 /**
@@ -187,7 +186,6 @@ export function lowerControlFlowStatement(statement, fileName, sourceText, diagn
     if (ts.isWhileStatement(statement)) {
         // Loop conditions/bodies may evaluate any number of times, so tracked
         // pin levels from before the loop are not valid inside it.
-        invalidatePinLevels();
         const comments = extractNodeComments(statement, sourceText);
         const bodyStatements = lowerStatementList(ts.isBlock(statement.statement) ? statement.statement.statements : [statement.statement], fileName, sourceText, diagnostics, functionReturnTypes, localVariableTypes, functionNameForDiagnostics, typeAliases, pointerVars);
         return [{
@@ -205,19 +203,15 @@ export function lowerControlFlowStatement(statement, fileName, sourceText, diagn
         // after the branches in this function but runs before them at runtime,
         // so the pre-branch state is restored before the condition is evaluated
         // and the merge is applied last.
-        const preBranchPinState = snapshotPinLevels();
         const comments = extractNodeComments(statement, sourceText);
         const thenStatements = lowerStatementList(ts.isBlock(statement.thenStatement) ? statement.thenStatement.statements : [statement.thenStatement], fileName, sourceText, diagnostics, functionReturnTypes, localVariableTypes, functionNameForDiagnostics, typeAliases, pointerVars);
-        const thenBranchPinState = snapshotPinLevels();
         // Restore the pre-branch state before lowering the else branch and the
         // condition — both run before the branches at runtime... the condition
         // before them, the else on the path where the then branch never ran.
-        restorePinLevels(preBranchPinState);
         let elseBranch;
         if (statement.elseStatement) {
             elseBranch = lowerStatementList(ts.isBlock(statement.elseStatement) ? statement.elseStatement.statements : [statement.elseStatement], fileName, sourceText, diagnostics, functionReturnTypes, localVariableTypes, functionNameForDiagnostics, typeAliases, pointerVars);
         }
-        const elseBranchPinState = snapshotPinLevels();
         // Evaluate the condition. If it's a bare identifier that resolves to a
         // HAL alias (e.g. `if (bus2)` where bus2 = I2C0.take()), the alias is a
         // compile-time non-null reference — constant-fold to `true` so the emit
@@ -229,10 +223,6 @@ export function lowerControlFlowStatement(statement, fileName, sourceText, diagn
         else {
             condition = expressionToIR(statement.expression, sourceText, diagnostics, pointerVars);
         }
-        // Join the branch-end states into the live state. With no else branch,
-        // elseBranchPinState equals the pre-branch state, so pins written by the
-        // then branch invalidate unless the write agrees with the prior level.
-        mergePinLevels(thenBranchPinState, elseBranchPinState);
         return [{
                 kind: "if",
                 sourceSpan: makeSourceSpan(statement, fileName, sourceText),
@@ -257,7 +247,6 @@ export function lowerControlFlowStatement(statement, fileName, sourceText, diagn
         }
         // Loop conditions/bodies may evaluate any number of times, so tracked
         // pin levels from before the loop are not valid inside it.
-        invalidatePinLevels();
         const condition = statement.condition
             ? expressionToIR(statement.condition, sourceText, diagnostics, pointerVars)
             : undefined;
@@ -387,7 +376,6 @@ export function lowerControlFlowStatement(statement, fileName, sourceText, diagn
     if (ts.isDoStatement(statement)) {
         // Loop bodies may run more than once; pre-loop pin levels are not valid
         // inside them.
-        invalidatePinLevels();
         const comments = extractNodeComments(statement, sourceText);
         const bodyStatements = lowerStatementList(ts.isBlock(statement.statement) ? statement.statement.statements : [statement.statement], fileName, sourceText, diagnostics, functionReturnTypes, localVariableTypes, functionNameForDiagnostics, typeAliases, pointerVars);
         return [{
@@ -403,7 +391,6 @@ export function lowerControlFlowStatement(statement, fileName, sourceText, diagn
     if (ts.isSwitchStatement(statement)) {
         // Exactly one case runs at runtime, but all are lowered here; pin levels
         // from case bodies must not leak past the switch.
-        invalidatePinLevels();
         const comments = extractNodeComments(statement, sourceText);
         const cases = [];
         for (const clause of statement.caseBlock.clauses) {

package/dist/ir/transformers/expressions.js

@@ -11,6 +11,14 @@ export function expressionStatementToIR(statement, fileName, sourceText, diagnos
     if (ts.isCallExpression(expr)) {
         return callToStatement(statement, expr, fileName, sourceText, diagnostics, pointerVars);
     }
+    // `void expr();` — the fire-and-forget idiom. Lower the inner call like a
+    // bare call statement (the raw (void)(...) form drops it entirely, which
+    // silently skipped the async-method kickoff: `void b.run();`). Free async
+    // function calls reaching here are still filtered at top level (their
+    // tasks auto-start), so the idiom keeps its meaning there.
+    if (ts.isVoidExpression(expr) && ts.isCallExpression(expr.expression)) {
+        return callToStatement(statement, expr.expression, fileName, sourceText, diagnostics, pointerVars);
+    }
     if (ts.isAwaitExpression(expr) && ts.isCallExpression(expr.expression)) {
         const callStmt = callToStatement(statement, expr.expression, fileName, sourceText, diagnostics, pointerVars);
         if (callStmt && callStmt.kind === "call") {
@@ -420,17 +428,10 @@ export function expressionStatementToIR(statement, fileName, sourceText, diagnos
  *  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",
+    "timing.sleep",
+    "wifi.join",
     "wifi.scan",
     "http.send",
-    "ble.until_connected",
-    // Worker offload: `await worker.submit(...)` rewrites to submit + poll
-    // worker.done — mirrors `await http.send(...)`. The start op is worker.submit
-    // (emitted by the previous state segment); the poll predicate is worker.done.
-    "worker.submit",
 ]);
 /**
  * Rewrite an awaited hal-op statement (or a block whose LAST statement is

package/dist/ir/transformers/hal-call-resolver.d.ts

@@ -4,8 +4,8 @@ import { PointerTracker } from "../build-ir-state.js";
 import { StatementIR, ExpressionIR, HALOpIR } from "../../api/index.js";
 /**
  * Resolve a HAL method call using the HAL resolver.
- * Handles all HAL classes: Pin, I2CBus, SPIBus, SerialPort, EEPROMClass, WDTClass,
- * plus device accessor patterns (I2CDevice, SPIDevice) and namespace methods (Pulse, Shift, Random).
+ * Handles all HAL classes: Pin, I2CBus, SPIBus, UART, WDTClass,
+ * plus device accessor patterns (I2CTarget, SPITarget) and namespace methods (Pulse, Shift, Random).
  */
 export declare function tryResolveHALMethod(call: ts.CallExpression, fileName: string, sourceText: string, diagnostics: Diagnostic[], pointerVars: PointerTracker): StatementIR | null;
 /**

package/dist/ir/transformers/hal-call-resolver.js

@@ -7,8 +7,8 @@ import { resolveNamespaceMethodCall } from "./namespace-methods.js";
 import { makeSourceSpan } from "../ast-node-utils.js";
 /**
  * Resolve a HAL method call using the HAL resolver.
- * Handles all HAL classes: Pin, I2CBus, SPIBus, SerialPort, EEPROMClass, WDTClass,
- * plus device accessor patterns (I2CDevice, SPIDevice) and namespace methods (Pulse, Shift, Random).
+ * Handles all HAL classes: Pin, I2CBus, SPIBus, UART, WDTClass,
+ * plus device accessor patterns (I2CTarget, SPITarget) and namespace methods (Pulse, Shift, Random).
  */
 export function tryResolveHALMethod(call, fileName, sourceText, diagnostics, pointerVars) {
     let method;
@@ -31,8 +31,8 @@ export function tryResolveHALMethod(call, fileName, sourceText, diagnostics, poi
     if (instance) {
         const result = processHALMethodBody(instance, method, argIRs);
         if (result) {
-            // Collect emit lines and halOps from chained inner calls: led.tone(440).for(400)
-            // The receiver of this call is itself a chained HAL call (led.tone(440)).
+            // Collect emit lines and halOps from chained inner calls: rgb.brightness(50).show()
+            // The receiver of this call is itself a chained HAL call (rgb.brightness(50)).
             // We need to process that inner call to collect its emit lines too.
             const chainedEmits = [];
             const chainedHalOps = [];
@@ -101,7 +101,7 @@ export function tryResolveHALMethod(call, fileName, sourceText, diagnostics, poi
     }
     const receiver = ts.isPropertyAccessExpression(call.expression) ? call.expression.expression : null;
     // Try device accessor pattern: <bus>.device(addr).method(args)
-    // This resolves I2CDevice and SPIDevice calls
+    // This resolves I2CTarget and SPITarget device()-factory calls
     if (receiver && ts.isCallExpression(receiver)) {
         const deviceCall = receiver;
         if (ts.isPropertyAccessExpression(deviceCall.expression) && deviceCall.expression.name.text === "device") {
@@ -112,12 +112,16 @@ export function tryResolveHALMethod(call, fileName, sourceText, diagnostics, poi
                 const deviceArgs = deviceCall.arguments;
                 if (deviceArgs && deviceArgs.length > 0) {
                     // Determine the device class based on bus class
-                    const deviceClassName = busInstance.className === "SPIBus" ? "SPIDevice" : "I2CDevice";
+                    const isSpiDevice = busInstance.className === "SPIBus";
+                    const deviceClassName = isSpiDevice ? "SPITarget" : "I2CTarget";
                     // Build field values for the device: _bus from bus instance, _address/_cs from device() arg
                     const deviceFieldValues = new Map();
                     const busField = busInstance.fieldValues.get("_bus");
                     if (busField)
                         deviceFieldValues.set("_bus", busField);
+                    deviceFieldValues.set("_hz", isSpiDevice ? "1000000" : "0");
+                    if (isSpiDevice)
+                        deviceFieldValues.set("_mode", "0");
                     const deviceArg = deviceArgs[0];
                     if (ts.isNumericLiteral(deviceArg)) {
                         const fieldName = busInstance.className === "SPIBus" ? "_cs" : "_address";
@@ -191,11 +195,15 @@ export function resolveHALCallForVarInit(call, sourceText, diagnostics, pointerV
             if (busInstance) {
                 const deviceArgs = deviceCall.arguments;
                 if (deviceArgs && deviceArgs.length > 0) {
-                    const deviceClassName = busInstance.className === "SPIBus" ? "SPIDevice" : "I2CDevice";
+                    const isSpiDevice = busInstance.className === "SPIBus";
+                    const deviceClassName = isSpiDevice ? "SPITarget" : "I2CTarget";
                     const deviceFieldValues = new Map();
                     const busField = busInstance.fieldValues.get("_bus");
                     if (busField)
                         deviceFieldValues.set("_bus", busField);
+                    deviceFieldValues.set("_hz", isSpiDevice ? "1000000" : "0");
+                    if (isSpiDevice)
+                        deviceFieldValues.set("_mode", "0");
                     const deviceArg = deviceArgs[0];
                     if (ts.isNumericLiteral(deviceArg)) {
                         const fieldName = busInstance.className === "SPIBus" ? "_cs" : "_address";
@@ -239,10 +247,15 @@ export function tryResolveHALExpression(call, sourceText, diagnostics, pointerVa
         if (result) {
             // Prefer hal-expr for semantic HAL operations
             if (result.halOps.length > 0) {
-                // Use the last halOp as the expression; preceding ones are side effects
+                // Use the last halOp as the expression; PRECEDING ones are its
+                // prefixOps — a method body's leading side effects (bus transaction
+                // begin/write/end, a pin configure) that must still run. The renderer
+                // wraps them with the value in a statement-expression. (They were
+                // historically dropped here — the "dead keypress" bug class.)
                 const lastOp = result.halOps[result.halOps.length - 1];
+                const prefixOps = result.halOps.slice(0, -1);
                 return {
-                    ir: { kind: "hal-expr", operation: lastOp },
+                    ir: { kind: "hal-expr", operation: lastOp, ...(prefixOps.length > 0 ? { prefixOps } : {}) },
                     sideEffects: result.emitLines,
                 };
             }
@@ -281,8 +294,9 @@ export function tryResolveHALExpression(call, sourceText, diagnostics, pointerVa
         if (nsResult) {
             if (nsResult.halOps.length > 0) {
                 const lastOp = nsResult.halOps[nsResult.halOps.length - 1];
+                const prefixOps = nsResult.halOps.slice(0, -1);
                 return {
-                    ir: { kind: "hal-expr", operation: lastOp },
+                    ir: { kind: "hal-expr", operation: lastOp, ...(prefixOps.length > 0 ? { prefixOps } : {}) },
                     sideEffects: nsResult.emitLines,
                 };
             }

package/dist/ir/transformers/hal-emit-helpers.d.ts

@@ -4,8 +4,8 @@ import { HALOpIR, StatementIR } from "../../api/index.js";
 import { PointerTracker } from "../build-ir-state.js";
 /**
  * Recursively collect emit lines from chained HAL method calls.
- * For an expression like led.tone(440).for(400), this collects
- * the emit lines from the inner led.tone(440) call.
+ * For an expression like rgb.brightness(50).show(), this collects
+ * the emit lines from the inner rgb.brightness(50) call.
  */
 export declare function collectChainedHALEmits(expr: ts.Expression, sourceText: string, diagnostics: Diagnostic[], pointerVars: PointerTracker, emitLines: string[], halOps?: HALOpIR[]): void;
 /** Convert emit lines to a StatementIR (single emit or block of emits). */

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

@@ -4,8 +4,8 @@ import { expressionToIR } from "../expression-to-ir.js";
 import { resolveHALReceiver, processHALMethodBody } from "../hal-resolver.js";
 /**
  * Recursively collect emit lines from chained HAL method calls.
- * For an expression like led.tone(440).for(400), this collects
- * the emit lines from the inner led.tone(440) call.
+ * For an expression like rgb.brightness(50).show(), this collects
+ * the emit lines from the inner rgb.brightness(50) call.
  */
 export function collectChainedHALEmits(expr, sourceText, diagnostics, pointerVars, emitLines, halOps = []) {
     // Chained call: led.tone(440).for(400) — the receiver is the inner call led.tone(440)

package/dist/ir/transformers/namespace-methods.js

@@ -82,7 +82,7 @@ export function resolveNamespaceMethodCall(ns, method, argIRs) {
     }
     if (ns === "Random") {
         // Random.* lowers to the random.* HAL op family, which frameworks lower to
-        // their platform PRNG (Arduino random()/randomSeed(), ESP-IDF esp_random()).
+        // their platform PRNG (e.g. Zephyr's sys_rand).
         // Previously these emitted bare `random()`/`randomSeed()` calls, which only
         // resolve to symbols on Arduino-core frameworks — on ESP-IDF they were
         // undefined and failed at C++ link time.

package/dist/ir/transformers/ui-callback-lowering.d.ts

@@ -15,8 +15,6 @@ export declare function resolveColorsInStatements(statements: StatementIR[]): St
 /** Recursively rename identifiers in a StatementIR tree (e.g. bindInput
  *  param → `text`, list tap param → `idx`). */
 export declare function renameIdentifiersInStatements(statements: StatementIR[], from: string, to: string): StatementIR[];
-export declare function noteConsoleInCallback(): void;
-export declare function loweredConsoleInCallback(): boolean;
 export declare function resetCallbackLoweringState(): void;
 export declare function beginCanvasAmbient(ctxName: string, diagnostics: Diagnostic[], sourceText: string): void;
 export declare function endCanvasAmbient(): void;