@typecad/cuttlefish 0.1.0-alpha.2 → 1.0.0-alpha.10

package/dist/ir/timing-validation.js

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

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

@@ -4,6 +4,7 @@ import { getCurrentIrTypeScope } from "../symbol-types.js";
 import { extractNodeComments, makeSourceSpan } 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";
 import { lowerCallbackStatements, resolveCallbackArg, getCanvasAmbientCtx, getCanvasAmbientDiagnostics, getCanvasAmbientSourceText, } from "./ui-callback-lowering.js";
 import { rewriteCanvasCall } from "./canvas-lowering.js";
 import { callbackContextLabel, unsupportedStatementHint } from "./callback-context-registry.js";
@@ -127,6 +128,64 @@ function lowerPreludeCallback(cbArg, fileName, sourceText, diagnostics, label, p
         sourceSpan,
     };
 }
+/** Detect `safe.<method>(...)` calls in statement position and lower them to
+ *  a hal-op statement via the safety hook's resolveSemanticCall. Mirrors the
+ *  UI call resolver pattern. Returns null when:
+ *  - the safety engine is not loaded (hasSafetyHook() === false), or
+ *  - the call is not a `safe.<method>(...)` shape, or
+ *  - the hook declines to lower it (returns undefined).
+ *
+ *  Expression-position safe.* calls (e.g. `const r = safe.read(pin)`) are
+ *  handled separately in the variable-declaration transformer. */
+function tryResolveSafetyCallStatement(call, fileName, sourceText) {
+    if (!hasSafetyHook())
+        return null;
+    // Shape: safe.<method>(args...) — PropertyAccessExpression on identifier "safe".
+    if (!ts.isPropertyAccessExpression(call.expression))
+        return null;
+    if (!ts.isIdentifier(call.expression.expression))
+        return null;
+    if (call.expression.expression.text !== "safe")
+        return null;
+    const method = call.expression.name.text;
+    // Extract simple literal/identifier arg values; non-literal args are passed
+    // as their rendered text so the hook can decide. The hook consumes
+    // safe.read (pin), safe.write (pin, value), and safe.pinMode (pin, mode).
+    // For safe.write, the value may be a property access (r.value), arithmetic
+    // expression, or variable — rendered to its C++ text form.
+    const argValues = call.arguments.map((a) => {
+        if (ts.isNumericLiteral(a))
+            return Number(a.text);
+        if (ts.isStringLiteral(a))
+            return a.text;
+        if (a.kind === ts.SyntaxKind.TrueKeyword)
+            return true;
+        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;
+        }
+        // Property access (e.g. r.value), arithmetic, or other expression:
+        // render to the C++ expression text so the op can emit it inline.
+        return a.getText();
+    });
+    const op = requireSafetyHook().resolveSemanticCall?.(`safe.${method}`, argValues);
+    if (!op)
+        return null;
+    return {
+        kind: "hal-op",
+        operation: op,
+        returns_value: false,
+        sourceSpan: makeSourceSpan(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) ────────
@@ -448,6 +507,52 @@ export function callToStatement(statementNode, call, fileName, sourceText, diagn
     const uiResolved = tryResolveUICall(call, fileName, sourceText, diagnostics);
     if (uiResolved)
         return uiResolved;
+    // ---- safe.* — @typecad/safety authoring calls (statement position) ---
+    // Handles statement-position safe.* calls like safe.pinMode(pin, mode).
+    // The expression-position form (const r = safe.read(pin)) is handled in
+    // the variable-declaration transformer. Both produce hal-op IR nodes that
+    // routeHALOp() later dispatches to the safety hook.
+    const safetyResolved = tryResolveSafetyCallStatement(call, fileName, sourceText);
+    if (safetyResolved)
+        return safetyResolved;
+    // ---- safe.read/safe.write chained with .ok/.fail/.fault/.always (statement) ----
+    // A statement like `safe.read(pin).ok(r => {...}).fail(r => {...})` is a
+    // method chain on a safe.* result. The terminal safe.* interceptor above
+    // returns null for it (the shape isn't `safe.<method>` — it's `.fail` on a
+    // chain). Delegate to expressionToIR, which has tryResolveSafetyChain to
+    // build the structured nested method-call IR that preserves lambda args,
+    // then render to text for a __RAW_STMT__ statement.
+    if (hasSafetyHook() && ts.isPropertyAccessExpression(call.expression)) {
+        let walk = call;
+        let isSafeChain = false;
+        while (ts.isCallExpression(walk) && ts.isPropertyAccessExpression(walk.expression)) {
+            walk = walk.expression.expression;
+            if (ts.isCallExpression(walk) &&
+                ts.isPropertyAccessExpression(walk.expression) &&
+                ts.isIdentifier(walk.expression.expression) &&
+                walk.expression.expression.text === "safe") {
+                isSafeChain = true;
+                break;
+            }
+        }
+        if (isSafeChain) {
+            // Build the structured chain IR via expressionToIR (the chain resolver
+            // produces nested method-call nodes with receiverExpr so lambdas survive).
+            // Carry it as the arg of a __EXPR_STMT__ call statement; the statement
+            // renderer renders it via the EMIT-TIME expression renderer (which has
+            // renderLambda for inline [&](){...} lambdas), NOT via the build-time
+            // renderExprAsText (which flattens lambdas to /* __lambda__ */).
+            const exprIR = expressionToIR(call, sourceText, diagnostics, pointerVars);
+            return {
+                kind: "call",
+                sourceSpan: makeSourceSpan(call, fileName, sourceText),
+                leadingComments: comments.leadingComments,
+                trailingComments: comments.trailingComments,
+                callee: "__EXPR_STMT__",
+                args: [exprIR],
+            };
+        }
+    }
     // Handle super() calls in constructors - transform to super_call IR for class emitter
     if (call.expression.kind === ts.SyntaxKind.SuperKeyword) {
         return {

package/dist/ir/transformers/expressions.js

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

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

@@ -270,5 +270,26 @@ export function tryResolveHALExpression(call, sourceText, diagnostics, pointerVa
             }
         }
     }
+    // Namespace method fallbacks (Pulse, Shift, Random) in expression context.
+    // Value-returning namespace methods (e.g. Random.upTo/between/int) lower to
+    // HAL ops; surface the last op as a hal-expr so the strategy lowers it to the
+    // platform PRNG (Arduino random(), ESP-IDF esp_random()). Without this, an
+    // inline `if (Random.upTo(5) > 2)` would fall through to a 0 placeholder.
+    if (ts.isIdentifier(receiver)) {
+        const ns = receiver.text;
+        const nsResult = resolveNamespaceMethodCall(ns, method, argIRs);
+        if (nsResult) {
+            if (nsResult.halOps.length > 0) {
+                const lastOp = nsResult.halOps[nsResult.halOps.length - 1];
+                return {
+                    ir: { kind: "hal-expr", operation: lastOp },
+                    sideEffects: nsResult.emitLines,
+                };
+            }
+            if (nsResult.returnValue && nsResult.returnValue !== "__hal_op_return__") {
+                return { ir: { kind: "raw", value: nsResult.returnValue }, sideEffects: nsResult.emitLines };
+            }
+        }
+    }
     return null;
 }

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

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

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

@@ -81,29 +81,34 @@ 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()).
+        // 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.
         if (method === "seed") {
-            return { emitLines: [`randomSeed(${argText(0)});`], halOps: [] };
+            return { emitLines: [], halOps: [{ operation: "random.seed", seed: argText(0) }] };
         }
         if (method === "number") {
             const min = argText(0);
             const max = argText(1);
-            return {
-                emitLines: [],
-                halOps: [],
-                returnValue: max ? `random(${min}, ${max})` : `random(${min})`,
-            };
+            if (max) {
+                return { emitLines: [], halOps: [{ operation: "random.range", min, max }], returnValue: "__hal_op_return__" };
+            }
+            // Single-arg form: Random.number(max) → [0, max-1]
+            return { emitLines: [], halOps: [{ operation: "random.range", min: "0", max: min }], returnValue: "__hal_op_return__" };
         }
-        // Current class API: Random.upTo(max) → random(max)
+        // Random.upTo(max) → [0, max-1]
         if (method === "upTo") {
-            return { emitLines: [], halOps: [], returnValue: `random(${argText(0)})` };
+            return { emitLines: [], halOps: [{ operation: "random.range", min: "0", max: argText(0) }], returnValue: "__hal_op_return__" };
         }
-        // Random.between(min, max) → random(min, max)
+        // Random.between(min, max) → [min, max-1]
         if (method === "between") {
-            return { emitLines: [], halOps: [], returnValue: `random(${argText(0)}, ${argText(1)})` };
+            return { emitLines: [], halOps: [{ operation: "random.range", min: argText(0), max: argText(1) }], returnValue: "__hal_op_return__" };
         }
-        // Random.int() → random(2147483647)
+        // Random.int() → non-negative 31-bit integer
         if (method === "int") {
-            return { emitLines: [], halOps: [], returnValue: `random(2147483647)` };
+            return { emitLines: [], halOps: [{ operation: "random.int" }], returnValue: "__hal_op_return__" };
         }
     }
     return null;

package/dist/ir/transformers/ui-reactive.js

@@ -30,9 +30,9 @@ function propEnum(property) {
 export function emitBindingEntry(spec) {
     // Text bindings wire to textFn (void fill-style); color bindings wire to fn.
     if (spec.property === "text") {
-        return `  { .node=${spec.nodeIndex}, .prop=${propEnum(spec.property)}, .fn=nullptr, .textFn=${spec.fnName} },`;
+        return `  { .node=${spec.nodeIndex}, .prop=${propEnum(spec.property)}, .fn=nullptr, .textFn=${spec.fnName}, .lastValue=0, .initialized=0 },`;
     }
-    return `  { .node=${spec.nodeIndex}, .prop=${propEnum(spec.property)}, .fn=${spec.fnName}, .textFn=nullptr },`;
+    return `  { .node=${spec.nodeIndex}, .prop=${propEnum(spec.property)}, .fn=${spec.fnName}, .textFn=nullptr, .lastValue=0, .initialized=0 },`;
 }
 /** Emit a full binding table from a list of specs. */
 export function emitBindingTable(specs) {

package/dist/ir/transformers/variables.js

@@ -7,13 +7,18 @@ import { getCurrentIrTypeScope, setScopeLocalType } from "../symbol-types.js";
 import { renderExprAsText } from "../render-expr.js";
 import { expressionToIR } from "../expression-to-ir.js";
 import { buildInlineForLoop } from "./array-methods.js";
-import { isKnownHALClass, getCtorIncludes, registerFloatVariable, resolveHALReceiver, isHALSingleton, } from "../hal-resolver.js";
+import { isKnownHALClass, getCtorIncludes, getHALCtorFieldMap, registerFloatVariable, resolveHALReceiver, isHALSingleton, } from "../hal-resolver.js";
+import { httpFactoryVerb, httpUrlArgText } from "../hal/hal-parser.js";
 import { resolveHALCallForVarInit } from "./hal-call-resolver.js";
 import { recordSignal } from "./ui-call-resolver.js";
+import { hasSafetyHook, requireSafetyHook } from "../../safety-hook.js";
 function replaceHalReadBufferPlaceholder(op, varName) {
     if (op.operation === "i2c.read_buffer" && op.buffer === "__HAL_READ_BUF__") {
         return { ...op, buffer: varName };
     }
+    if (op.operation === "spi.read_buffer" && op.buffer === "__HAL_READ_BUF__") {
+        return { ...op, buffer: varName };
+    }
     return op;
 }
 export function assignmentOperatorToString(kind) {
@@ -371,6 +376,56 @@ export function variableStatementToIR(statement, fileName, sourceText, diagnosti
                 localVariableTypes.set(varName, cppType);
                 continue;
             }
+            // ── safe.<method>(...) — @typecad/safety call as initializer.
+            // Handles expression-position safe.* calls like `const r = safe.read(pin)`.
+            // The statement-position form (safe.pinMode(...)) is handled in the
+            // call-statement transformer. Both produce hal-op IR nodes that
+            // routeHALOp() later dispatches to the safety hook.
+            if (hasSafetyHook() &&
+                ts.isCallExpression(declaration.initializer) &&
+                ts.isPropertyAccessExpression(declaration.initializer.expression) &&
+                ts.isIdentifier(declaration.initializer.expression.expression) &&
+                declaration.initializer.expression.expression.text === "safe") {
+                const method = declaration.initializer.expression.name.text;
+                const argValues = declaration.initializer.arguments.map((a) => {
+                    if (ts.isNumericLiteral(a))
+                        return Number(a.text);
+                    if (ts.isStringLiteral(a))
+                        return a.text;
+                    if (a.kind === ts.SyntaxKind.TrueKeyword)
+                        return true;
+                    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 undefined;
+                });
+                const op = requireSafetyHook().resolveSemanticCall?.(`safe.${method}`, argValues);
+                if (op) {
+                    // Emit a var_decl initialized by a hal-expr carrying the safety op.
+                    // routeHALOp() resolves it to the C++ expression at emit time.
+                    const initExpr = { kind: "hal-expr", operation: op };
+                    lowered.push({
+                        kind: "var_decl",
+                        name: varName,
+                        storage,
+                        cppType: "auto",
+                        initializer: initExpr,
+                        sourceSpan: makeSourceSpan(declaration, fileName, sourceText),
+                    });
+                    // auto-deduced to SafeReadResult on the C++ side.
+                    localVariableTypes.set(varName, "auto");
+                    continue;
+                }
+            }
             if (ts.isNewExpression(declaration.initializer) && ts.isIdentifier(declaration.initializer.expression)) {
                 const className = declaration.initializer.expression.text;
                 const ctorArgs = declaration.initializer.arguments;
@@ -405,9 +460,26 @@ export function variableStatementToIR(statement, fileName, sourceText, diagnosti
                             }
                         }
                     }
+                    // new HttpRequest(method, url) — positional ctor fields. The URL is
+                    // stored as C++ expression text (quoted literal or identifier).
+                    if (className === "HttpRequest" && ctorArgs && ctorArgs.length >= 2) {
+                        const methodArg = ctorArgs[0];
+                        if (ts.isStringLiteral(methodArg))
+                            fieldValues.set("_method", methodArg.text.toUpperCase());
+                        const urlText = httpUrlArgText(ctorArgs[1]);
+                        if (urlText)
+                            fieldValues.set("_url", urlText);
+                    }
                     if (ctorArgs) {
+                        // Resolve a Pin-identifier ctor arg to its _pin number, for any HAL
+                        // class whose first constructor field is _pin (Pin itself, plus
+                        // pin-bearing wrappers like RmtChannel). Mirrors the Pin branch
+                        // above but keyed off the class's registered ctor field map so new
+                        // pin-keyed classes work without a per-class branch here.
+                        const ctorFieldMap = getHALCtorFieldMap(className);
+                        const firstFieldIsPin = ctorFieldMap && Array.from(ctorFieldMap.keys())[0] === "_pin";
                         for (const arg of ctorArgs) {
-                            if (ts.isIdentifier(arg) && className === "Pin") {
+                            if (ts.isIdentifier(arg) && (className === "Pin" || firstFieldIsPin)) {
                                 const existing = halInstances.get(arg.text);
                                 if (existing && existing.fieldValues.has("_pin")) {
                                     fieldValues.set("_pin", existing.fieldValues.get("_pin"));
@@ -430,6 +502,45 @@ export function variableStatementToIR(statement, fileName, sourceText, diagnosti
                 const isSingletonReceiver = ts.isIdentifier(receiver) && isHALSingleton(receiver.text);
                 if (result && (!isOwnershipMethod || isSingletonReceiver)) {
                     const isHalOpReturn = result.returnValue === "__hal_op_return__";
+                    // A __TYPED_ARRAY__ return comes ONLY from a HAL method body
+                    // (`return new Uint8Array(count)` in e.g. I2CDevice.readBytes /
+                    // SPIDevice.readRegister). The method's side-effect HAL ops (the
+                    // i2c.read_buffer / spi.read_buffer fill loops) write INTO this buffer
+                    // via the __HAL_READ_BUF__ placeholder (rewritten to `varName`). So the
+                    // buffer var_decl MUST precede the fill ops in emitted order — at top
+                    // level the var_decl is hoisted to file scope which masks this, but a
+                    // function-local `const data = ...readBytes()` would otherwise emit the
+                    // fill loop referencing `data` before its declaration. Detect the typed
+                    // array up front so we can emit its declaration first.
+                    const isTypedArrayReturn = typeof result.returnValue === "string" && result.returnValue.startsWith("__TYPED_ARRAY__:");
+                    if (isTypedArrayReturn && typeof result.returnValue === "string") {
+                        const parts = result.returnValue.split(":");
+                        const elementType = parts[1];
+                        const size = parts[2];
+                        // Force non-const storage (the buffer is written by the fill op) and
+                        // synthesize a zero-init array initializer so the var_decl renderer
+                        // emits `T data[] = { 0, 0, ... }` — a bare `const T data[N];` that
+                        // is later written would fail to compile (assignment to const).
+                        // Mirrors plain `new Uint8Array(N)` (expression-to-ir.ts).
+                        const count = parseInt(size, 10);
+                        const initElements = !isNaN(count) && count > 0 && count <= 256
+                            ? Array(count).fill(0).map(() => ({ kind: "number", value: 0 }))
+                            : [];
+                        lowered.push({
+                            kind: "var_decl",
+                            sourceSpan: makeSourceSpan(declaration, fileName, sourceText),
+                            leadingComments: commentsAssigned ? [] : statementComments.leadingComments,
+                            trailingComments: [],
+                            name: varName,
+                            storage: "let",
+                            cppType: `${elementType}[${size}]`,
+                            initializer: initElements.length > 0
+                                ? { kind: "array", elements: initElements, elementType }
+                                : undefined,
+                        });
+                        activeCArrayVars.add(varName);
+                        commentsAssigned = true;
+                    }
                     if (result.halOps && result.halOps.length > 0) {
                         const sideEffectOps = isHalOpReturn ? result.halOps.slice(0, -1) : result.halOps;
                         const halStmts = sideEffectOps.map(op => ({
@@ -474,6 +585,19 @@ export function variableStatementToIR(statement, fileName, sourceText, diagnosti
                                 }
                             }
                         }
+                        // For Http factory calls (const req = Http.get(url)), record the
+                        // HTTP verb + URL so req.send() can resolve this._method/this._url.
+                        if (result.returnClassName === "HttpRequest") {
+                            const verb = httpFactoryVerb(init.expression.name.text);
+                            if (verb)
+                                fieldValues.set("_method", verb);
+                            const urlArg = init.arguments?.[0];
+                            if (urlArg) {
+                                const urlText = httpUrlArgText(urlArg);
+                                if (urlText)
+                                    fieldValues.set("_url", urlText);
+                            }
+                        }
                         halInstances.set(varName, {
                             className: result.returnClassName,
                             fieldValues,
@@ -527,24 +651,18 @@ export function variableStatementToIR(statement, fileName, sourceText, diagnosti
                             if (/\b\d+\.\d+\b/.test(result.returnValue)) {
                                 registerFloatVariable(varName);
                             }
+                            // __TYPED_ARRAY__ returns are handled above (declared BEFORE the
+                            // fill ops). Everything else is a scalar/value return captured
+                            // after the side-effect ops.
                             const isTypedArray = result.returnValue.startsWith("__TYPED_ARRAY__:");
-                            if (isTypedArray) {
-                                const parts = result.returnValue.split(":");
-                                const elementType = parts[1];
-                                const size = parts[2];
-                                lowered.push({
-                                    kind: "var_decl",
-                                    sourceSpan: makeSourceSpan(declaration, fileName, sourceText),
-                                    leadingComments: commentsAssigned ? [] : statementComments.leadingComments,
-                                    trailingComments: [],
-                                    name: varName,
-                                    storage,
-                                    cppType: `${elementType}[${size}]`,
-                                    initializer: undefined,
-                                });
-                                activeCArrayVars.add(varName);
-                            }
-                            else {
+                            // A factory returning a compile-time HAL instance (e.g.
+                            // `const req = Http.get(url)` → returnValue `new HttpRequest(...)`)
+                            // is fully tracked via halInstances — every later method call on
+                            // the variable resolves at compile time. Emitting the raw
+                            // `new HttpRequest(...)` would reference a class that doesn't
+                            // exist in the C++ output.
+                            const isHalInstanceReturn = !!result.returnClassName && /^new\s/.test(result.returnValue.trim());
+                            if (!isTypedArray && !isHalInstanceReturn) {
                                 lowered.push({
                                     kind: "var_decl",
                                     sourceSpan: makeSourceSpan(declaration, fileName, sourceText),

package/dist/ir/try-catch-validation.js

@@ -39,6 +39,7 @@ export function validateTryCatch(program, boardConstants, strategy) {
                 hint: `function readSensor(): number | null {\n  const data = sensor.read();\n  if (!data) return null;  // error path\n  return data.value;       // success path\n}`,
                 line: stmt.sourceSpan?.startLine,
                 column: stmt.sourceSpan?.startColumn,
+                filePath: stmt.sourceSpan?.filePath,
                 source: 'try-catch-validation',
             });
             // Still recurse into nested blocks to find other try/catch
@@ -57,6 +58,7 @@ export function validateTryCatch(program, boardConstants, strategy) {
                 hint: `return null;  // or return an error code`,
                 line: stmt.sourceSpan?.startLine,
                 column: stmt.sourceSpan?.startColumn,
+                filePath: stmt.sourceSpan?.filePath,
                 source: 'try-catch-validation',
             });
             return;