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

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

@@ -12,6 +12,7 @@ import { tryLowerRegisterRead } from "./transformers/register-assignment.js";
 import { tryLowerArrayAndStringMethods } from "./transformers/array-methods.js";
 import { collectReturns, inferExprCppType, typeNodeToCppType } from "./type-resolution.js";
 import { parseCppType, elementOf, renderCppType, bareType, parsedIsPointer, parsedIsVector, parsedIsMap, parsedIsSet, parsedIsTuple, parsedIsStdString, parsedElementString, parsedBareString, isContainer } from "../api/shared/cpp-type-ir.js";
+import { hasSafetyHook, requireSafetyHook } from "../safety-hook.js";
 function resolveExprCppType(expr) {
     if (ts.isNonNullExpression(expr) || ts.isParenthesizedExpression(expr)) {
         return resolveExprCppType(expr.expression);
@@ -184,6 +185,143 @@ function resolveCallReturnTypeForNullGuard(call, sourceText) {
     }
     return undefined;
 }
+/** The SafeReadResult/SafeWriteResult chain methods whose lambda args must
+ *  render inline (preserving closure captures). Detected on the TS chain to
+ *  decide whether to take the structured-receiver path. */
+const SAFETY_RESULT_CHAIN_METHODS = new Set(["ok", "fail", "fault", "always"]);
+/** Detect `safe.<read|write>(...).<ok|fail|fault|always>(handler)...` chains
+ *  and build them as nested method-call IR nodes with a STRUCTURED receiverExpr
+ *  (not a flattened callee string). This preserves inner lambda args so the
+ *  emit pipeline can render them inline via renderLambda.
+ *
+ *  Returns null when the expression is not a safe.* call chained with at least
+ *  one result method (terminal safe.read/safe.write are handled by the
+ *  statement/var-decl interceptors; non-safe chains use the generic path). */
+function tryResolveSafetyChain(expr, sourceText, diagnostics, pointerVars) {
+    if (!hasSafetyHook())
+        return null;
+    const chain = [];
+    let cur = expr;
+    while (ts.isCallExpression(cur) && ts.isPropertyAccessExpression(cur.expression)) {
+        chain.push({ methodName: cur.expression.name.text, callNode: cur });
+        cur = cur.expression.expression;
+    }
+    // After the loop, `cur` is the innermost receiver. For a safe.* chain, the
+    // last-pushed chain element is the safe.read/safe.write root (its
+    // callNode.expression.expression is the identifier `safe`). Identify it.
+    if (chain.length === 0)
+        return null;
+    const root = chain[chain.length - 1];
+    const rootCall = root.callNode;
+    // rootCall.expression is `safe.read` (PropertyAccess); rootCall.expression.expression
+    // must be the identifier `safe` for this to be a safe.* root.
+    // The root method is read/write; the links above it (chain[0..length-2]) must
+    // include at least one result-chain method (ok/fail/fault/always).
+    const resultLinks = chain.slice(0, chain.length - 1);
+    const hasChainMethod = resultLinks.some((link) => SAFETY_RESULT_CHAIN_METHODS.has(link.methodName));
+    if (!hasChainMethod)
+        return null;
+    // Resolve the safe.<method>(...) root to a hal-expr (the same way variables.ts
+    // does for `const r = safe.read(pin)`). This becomes the innermost receiver.
+    const rootPropAccess = rootCall.expression;
+    const safeMethod = rootPropAccess.name.text;
+    const argValues = rootCall.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))
+            return a.text;
+        return a.getText();
+    });
+    const op = requireSafetyHook().resolveSemanticCall?.(`safe.${safeMethod}`, argValues);
+    // If the hook couldn't resolve the pin (halInstances not yet populated for
+    // this identifier at this point in IR building), fall back to rendering the
+    // root verbatim. The chain structure (with inline lambdas) is still correct;
+    // only the root's HAL resolution is deferred. This happens for multi-link
+    // chains where the resolver runs before the pin's HAL instance is registered.
+    let receiver;
+    if (op) {
+        receiver = { kind: "hal-expr", operation: op };
+    }
+    else {
+        // Best-effort: resolve the pin number directly from halInstances (the hook's
+        // resolvePinArg does the same lookup, but calling it directly here avoids the
+        // hook's early-return on unresolved pins).
+        const pinArg = argValues[0];
+        let pinNum;
+        if (typeof pinArg === "string") {
+            const inst = halInstances.get(pinArg);
+            if (inst) {
+                const pv = inst.fieldValues.get("_pin") ?? inst.fieldValues.get("pin");
+                if (pv !== undefined)
+                    pinNum = Number(pv);
+            }
+        }
+        else if (typeof pinArg === "number") {
+            pinNum = pinArg;
+        }
+        if (pinNum !== undefined) {
+            // Build the op manually now that we have the pin.
+            const fallbackOp = safeMethod === "read"
+                ? { operation: "safety.read_safe", pin: pinNum }
+                : { operation: "safety.write_verify", pin: pinNum, value: argValues[1] ?? 0 };
+            receiver = { kind: "hal-expr", operation: fallbackOp };
+        }
+        else {
+            // Last resort: verbatim text. The chain renders but the root won't have
+            // resolved to __tc_safety::read_safe — acceptable degradation.
+            receiver = { kind: "raw", value: rootCall.getText() };
+        }
+    }
+    // The root renders as __tc_safety::read_safe(pin) — render it to text so the
+    // callee string (used for non-receiverExpr consumers like type inference) is
+    // correct.
+    const rootText = renderExprAsText(receiver);
+    // Build nested method-call nodes bottom-up over the RESULT links only
+    // (chain[0..length-2], excluding the root at chain[length-1]). chain[0] is the
+    // outermost call (e.g. .fail); we build from the innermost result link outward.
+    for (let i = resultLinks.length - 1; i >= 0; i--) {
+        const link = resultLinks[i];
+        // Render this link's args as IR (lambdas become lambda IR nodes that
+        // renderLambda handles at emit time).
+        const argIRs = link.callNode.arguments.map((a) => expressionToIR(a, sourceText, diagnostics, pointerVars));
+        // Set concrete param types on lambda args so renderLambda emits
+        // `const SafeReadResult& r` instead of `auto r`. Generic lambdas (auto
+        // params) require C++14; AVR's gnu++11 doesn't support them. The chain
+        // knows the result type from the root (read -> SafeReadResult,
+        // write -> SafeWriteResult).
+        const resultType = safeMethod === "read" ? "SafeReadResult" : "SafeWriteResult";
+        for (const argIR of argIRs) {
+            if (argIR.kind === "lambda" && argIR.params) {
+                for (const p of argIR.params) {
+                    if (!p.cppType || p.cppType === "auto") {
+                        p.cppType = `const ${resultType}&`;
+                    }
+                }
+            }
+        }
+        // Build a callee string for backward-compat with consumers that read
+        // method-call.callee. The receiver text is rootText for the innermost link,
+        // or the prior receiver's rendered text for outer links.
+        const priorCallee = i === resultLinks.length - 1
+            ? rootText
+            : renderExprAsText(receiver);
+        const callee = `${priorCallee}.${escapeCppKeyword(link.methodName, new Set())}`;
+        receiver = {
+            kind: "method-call",
+            callee,
+            args: argIRs,
+            methodName: link.methodName,
+            receiverExpr: receiver,
+        };
+    }
+    return receiver;
+}
 export function expressionToIR(expr, sourceText, diagnostics, pointerVars = new Map()) {
     function emitUnsupportedExpression(message) {
         diagnostics.push(makeDiagnostic(sourceText, expr.pos, message, "error", "TS2CPP_UNSUPPORTED_EXPR"));
@@ -264,15 +402,52 @@ export function expressionToIR(expr, sourceText, diagnostics, pointerVars = new
             return `(sizeof(${safeText}) / sizeof(${safeText}[0]))`;
         }
         if (ts.isCallExpression(receiverNode)) {
-            const returnType = ts.isPropertyAccessExpression(receiverNode.expression) && ts.isIdentifier(receiverNode.expression.expression)
-                ? getCurrentIrTypeScope()?.locals.get(receiverNode.expression.expression.text)
-                : undefined;
-            if (returnType === "std::string")
-                return `static_cast<long long>(${safeText}.length())`;
+            // Case B: a HAL buffer-returning method (I2CDevice.readBytes /
+            // SPIDevice.readRegister) used INLINE as a sub-expression — e.g.
+            // `dev.readBytes(0,6).length`. These methods lower to STATEMENTS (a fill
+            // loop), not a single C++ expression, so by the time we get here the
+            // receiver text is already a leaked `for (...) __buf[__i] = Wire.read()`
+            // statement spliced where an expression is required. The buffer also has
+            // no caller-side name to sizeof. Only the var-init form is supported
+            // (`const data = dev.readBytes(...)`); emit a clear diagnostic so the
+            // user gets an actionable error instead of inscrutable broken C++.
+            if (/\bfor\s*\(/.test(safeText) || /__buf|__spi_buf/.test(safeText)) {
+                const calleeName = ts.isPropertyAccessExpression(receiverNode.expression)
+                    ? receiverNode.expression.name.text : "call";
+                diagnostics.push(makeDiagnostic(sourceText, receiverNode.getStart(), `\`${calleeName}(...)\` returns a buffer and cannot be queried inline. Capture it into a variable first (e.g. \`const data = ${calleeName}(...)\`), then use \`data.length\`.`, "error", "TC_BUFFER_INLINE_LENGTH"));
+                return `0 /* ${calleeName}() result must be captured into a variable to use .length */`;
+            }
+            // Resolve the call's RETURN type (not the receiver object's type, which
+            // the previous code incorrectly did). Method calls resolve via the class
+            // registry; free-function calls resolve by scanning the source AST for
+            // the declared return type.
+            const returnType = resolveExprCppType(receiverNode)
+                ?? resolveCallReturnTypeForNullGuard(receiverNode, sourceText);
+            if (returnType) {
+                const parsed = parseCppType(returnType);
+                // std::string → .length(); any STL container (vector/map/set) → .size().
+                if (parsedIsStdString(returnType)) {
+                    return `static_cast<long long>(${safeText}.length())`;
+                }
+                if (parsedIsVector(returnType) || parsedIsMap(returnType) || parsedIsSet(returnType) || isContainer(parsed)) {
+                    return `static_cast<long long>(${safeText}.size())`;
+                }
+                // A raw pointer / decayed-array return (e.g. uint8_t*) carries no size
+                // at the call site — sizeof would yield sizeof(pointer). This is
+                // genuinely un-sizeable inline; surface it rather than emit wrong code.
+                if (parsedIsPointer(returnType) || /\]\s*$/.test(returnType)) {
+                    const calleeName = ts.isPropertyAccessExpression(receiverNode.expression)
+                        ? receiverNode.expression.name.text
+                        : (ts.isIdentifier(receiverNode.expression) ? receiverNode.expression.text : "call");
+                    diagnostics.push(makeDiagnostic(sourceText, receiverNode.getStart(), `Cannot use \`.length\` on \`${calleeName}()\` which returns a pointer (${returnType}); the size is not available at the call site. Capture the buffer into a variable first.`, "error", "TC_LENGTH_ON_POINTER_RETURN"));
+                    return `0 /* .length unavailable on ${returnType} return */`;
+                }
+            }
             // Cast .size() to long long to match the loop-counter type (TS number ->
             // long long). Without this, `i < vec.size()` compares long long vs
             // size_t (unsigned) and g++ -Wall warns -Wsign-compare on every
-            // indexed loop over an array.
+            // indexed loop over an array. (Fallback for unresolvable return types —
+            // historically every call-result .length landed here.)
             return `static_cast<long long>(${safeText}.size())`;
         }
         // Resolve by concrete cppType first so std::string vars render member calls
@@ -916,6 +1091,32 @@ export function expressionToIR(expr, sourceText, diagnostics, pointerVars = new
         };
     }
     if (ts.isCallExpression(expr)) {
+        // ---- safe.read/safe.write chained with .ok/.fail/.fault/.always ----
+        // Method chains like `safe.read(pin).ok(r => {...}).fail(r => {...})` cannot
+        // use the generic method-call builder because it flattens the receiver into
+        // a callee STRING (expression-to-ir.ts ~line 1475), destroying inner lambda
+        // args (they become `/* __lambda__ */` placeholders baked into the callee
+        // text). This resolver detects a safe.* call followed by a chain of fluent
+        // result methods and builds it bottom-up as nested method-call nodes with a
+        // STRUCTURED receiverExpr, so the emit pipeline renders each lambda arg
+        // inline via renderLambda (preserving closure captures).
+        const safetyChain = tryResolveSafetyChain(expr, sourceText, diagnostics, pointerVars);
+        if (safetyChain)
+            return safetyChain;
+        // ---- rawCppExpr() — compile-time C++ injection in expression context ----
+        // Mirrors the statement-position rawCpp()/__EMIT__ path, but emits the raw
+        // text as an expression (e.g. for IDF macros like WIFI_INIT_CONFIG_DEFAULT()
+        // that produce struct values). The type parameter is a TS hint only — the
+        // transpiler emits the raw text verbatim.
+        if (ts.isIdentifier(expr.expression) && expr.expression.text === "rawCppExpr") {
+            const arg = expr.arguments[0];
+            if (arg && ts.isStringLiteral(arg)) {
+                return { kind: "raw", value: arg.text };
+            }
+            if (arg && ts.isNoSubstitutionTemplateLiteral(arg)) {
+                return { kind: "raw", value: arg.text };
+            }
+        }
         // ---- board() / boardResolve() — compile-time board constant lookup ----
         if (ts.isIdentifier(expr.expression) && (expr.expression.text === "board" || expr.expression.text === "boardResolve")) {
             const pathArg = expr.arguments[0];

package/dist/ir/feature-registry.js

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

package/dist/ir/function-builder.js

@@ -163,6 +163,7 @@ export function functionDeclarationToIR(node, fileName, sourceText, diagnostics,
         const elementType = restParam.cppType.replace(/^(?:const\s+)?std::vector<(.+)>&?$/, "$1");
         restParamFunctions.set(node.name.text, elementType);
     }
+    const fnDecorators = extractAsilFromComments(node, sourceText);
     return {
         originalName: node.name.text,
         isAsync,
@@ -174,8 +175,29 @@ export function functionDeclarationToIR(node, fileName, sourceText, diagnostics,
         ...(fnTypeParams && fnTypeParams.length > 0 ? { typeParameters: fnTypeParams } : {}),
         ...(isGenerator ? { isGenerator: true } : {}),
         ...(isExported ? { isExported: true } : {}),
+        ...(fnDecorators && fnDecorators.length > 0 ? { decorators: fnDecorators } : {}),
     };
 }
+/** Extract ASIL annotations from leading comments (e.g. `// @asilD`).
+ *
+ *  Uses comment-based annotations instead of TypeScript decorators because
+ *  TS decorators on function declarations produce TS1206 errors in the VS Code
+ *  language server and the @typescript-eslint/parser (both reject decorators
+ *  on functions — only class/method/property decorators are supported).
+ *  Comment annotations are valid TypeScript in any context, any editor, and
+ *  any toolchain — no false-positive errors. */
+function extractAsilFromComments(node, sourceText) {
+    const comments = extractNodeComments(node, sourceText);
+    const names = [];
+    for (const comment of comments.leadingComments) {
+        // Match `// @asilD`, `// @asilC`, `// @asilB`, `// @asilA`, `// @asilQM`
+        const match = comment.match(/@(asil[DCBAQM])/i);
+        if (match) {
+            names.push(match[1]);
+        }
+    }
+    return names.length > 0 ? names : undefined;
+}
 export function variableAsFunctionToIR(node, fileName, sourceText, diagnostics, functionReturnTypes, typeAliasNodes, boilerplates, pointerVars = new Map(), lowerStatementList) {
     const functionExpressionDeclarations = node.declarationList.declarations.filter((declaration) => {
         if (!ts.isIdentifier(declaration.name) || !declaration.initializer) {

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

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

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

@@ -5,6 +5,7 @@ import { renderExprAsText } from "../render-expr.js";
 import { escapeCppKeyword } from "../../utils/strings.js";
 import { halClassRegistry, halGlobalFunctions } from "./hal-parser.js";
 import { tryResolveSemanticCall, tryResolveBoardResolveArg, tryResolveCompoundSemanticReturn, resolveConcatPath } from "./hal-plugins.js";
+import { cppTypeForHalOp } from "../../emit/utils/hal-op-cpp-type.js";
 /** Escape C++ keywords in resolved text, but only when the text looks like a
  *  variable reference (not a literal like "false", "true", "42", or a string). */
 export function maybeEscapeResolvedText(text) {
@@ -54,16 +55,16 @@ function prefixOperatorText(operator) {
  * keeps `this` out of the emitted free function. Returns null if the method
  * is not a recognized inlinable getter.
  */
-function inlineThisGetterCall(methodName, pin) {
+function inlineThisGetterCall(methodName, pin, strategy) {
     switch (methodName) {
         case "read":
-            return `digitalRead(${pin})`;
+            return strategy?.readDigitalPin?.(pin) ?? `digitalRead(${pin})`;
         case "readAnalog":
-            return `analogRead(${pin})`;
+            return strategy?.readAnalogPin?.(pin) ?? `analogRead(${pin})`;
         case "isHigh":
-            return `digitalRead(${pin})`;
+            return strategy?.readDigitalPin?.(pin) ?? `digitalRead(${pin})`;
         case "isLow":
-            return `(!digitalRead(${pin}))`;
+            return strategy?.readDigitalPin ? `(!${strategy.readDigitalPin(pin)})` : `(!digitalRead(${pin}))`;
         default:
             return null;
     }
@@ -199,7 +200,7 @@ export function resolveExpressionText(expr, instance, paramNames, callArgTexts,
                 const methodName = expr.expression.name.text;
                 const pin = instance.fieldValues.get("_pin") ?? instance.fieldValues.get("pin");
                 if (pin !== undefined) {
-                    const inlined = inlineThisGetterCall(methodName, pin);
+                    const inlined = inlineThisGetterCall(methodName, pin, getContext().activeStrategy);
                     if (inlined !== null)
                         return inlined;
                 }
@@ -275,9 +276,22 @@ export function resolveExpressionText(expr, instance, paramNames, callArgTexts,
     }
     return expr.getText ? expr.getText() : null;
 }
+/** Semantic HAL helpers whose callbacks run in true ISR context (need IRAM_ATTR).
+ *  WiFi event handlers, timers, setInterval, etc. use callback() too but run in
+ *  a task / event loop — marking those as ISRs puts printf in IRAM and, on
+ *  ESP-IDF, trips -Werror=attributes when IRAM_ATTR's __COUNTER__ disagrees
+ *  between forward declaration and definition. */
+const ISR_CALLBACK_SEMANTIC_FNS = new Set([
+    "interruptAttach",
+]);
+/** True when a HAL semantic call name wraps a GPIO/hardware ISR callback. */
+export function semanticCallUsesIsrCallback(fnName) {
+    return ISR_CALLBACK_SEMANTIC_FNS.has(fnName);
+}
 /** Scan an expression AST for callback() calls, extract callback IR from callArgs,
- *  register them, and patch callArgTexts with placeholder names. */
-export function extractAndRegisterCallbacks(expr, paramNames, callArgs, callArgTexts) {
+ *  register them, and patch callArgTexts with placeholder names.
+ *  @param isInterruptHandler — only true for GPIO interrupt attach paths. */
+export function extractAndRegisterCallbacks(expr, paramNames, callArgs, callArgTexts, isInterruptHandler = false) {
     function scan(node) {
         if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "callback") {
             const cbArg = node.arguments[0];
@@ -292,6 +306,8 @@ export function extractAndRegisterCallbacks(expr, paramNames, callArgs, callArgT
                                 kind: "callback",
                                 params: callbackIR.params.map((p) => p.name),
                                 statements: callbackIR.body,
+                                ...(callbackIR.returnType && callbackIR.returnType !== "void" ? { returnType: callbackIR.returnType } : {}),
+                                ...(callbackIR.params ? { typedParams: callbackIR.params.map((p) => ({ name: p.name, cppType: p.cppType })).filter((p) => p.cppType && p.cppType !== "void") } : {}),
                                 sourceSpan: callbackIR.body[0]?.sourceSpan ?? {
                                     filePath: "",
                                     startLine: 0,
@@ -301,10 +317,12 @@ export function extractAndRegisterCallbacks(expr, paramNames, callArgs, callArgT
                                     startOffset: 0,
                                     endOffset: 0,
                                 },
-                                isInterruptHandler: true,
+                                ...(isInterruptHandler ? { isInterruptHandler: true } : {}),
                             }
                             : callbackIR;
-                        normalized.isInterruptHandler = true;
+                        if (isInterruptHandler) {
+                            normalized.isInterruptHandler = true;
+                        }
                         registeredCallbacks.push({ placeholderName: placeholder, callbackIR: normalized });
                         callArgTexts[paramIdx] = placeholder;
                     }
@@ -399,8 +417,9 @@ export function processHALMethodBody(instance, methodName, callArgs) {
             if (ts.isIdentifier(call.expression)) {
                 // Extract callbacks from semantic call arguments and patch callArgTexts
                 // with placeholder names before resolving (mirrors the emit() path).
+                const isIsr = semanticCallUsesIsrCallback(call.expression.text);
                 for (const arg of call.arguments) {
-                    extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts);
+                    extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts, isIsr);
                 }
                 const semanticOp = tryResolveSemanticCall(call.expression.text, call.arguments, instance, paramNames, callArgTexts, paramDefaults, callArgs);
                 if (semanticOp) {
@@ -468,8 +487,9 @@ export function processHALMethodBody(instance, methodName, callArgs) {
                 actualRetExpr = actualRetExpr.expression;
             }
             if (ts.isCallExpression(actualRetExpr) && ts.isIdentifier(actualRetExpr.expression)) {
+                const isIsr = semanticCallUsesIsrCallback(actualRetExpr.expression.text);
                 for (const arg of actualRetExpr.arguments) {
-                    extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts);
+                    extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts, isIsr);
                 }
                 const semanticOp = tryResolveSemanticCall(actualRetExpr.expression.text, actualRetExpr.arguments, instance, paramNames, callArgTexts, paramDefaults, callArgs);
                 if (semanticOp) {
@@ -594,8 +614,9 @@ export function processStatementList(stmts, instance, paramNames, callArgTexts,
                 }
                 else {
                     // R3: Try semantic HAL function call
+                    const isIsr = semanticCallUsesIsrCallback(call.expression.text);
                     for (const arg of call.arguments) {
-                        extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts);
+                        extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts, isIsr);
                     }
                     const semanticOp = tryResolveSemanticCall(call.expression.text, call.arguments, instance, paramNames, callArgTexts, paramDefaults, callArgs);
                     if (semanticOp) {
@@ -612,6 +633,10 @@ export function resetHALResolver() {
     floatVariables.clear();
     getContext().callbackPlaceholderCounter = 0;
     getContext().snprintfCounter = 0;
+    // Reset the BLE characteristic counter so each file's GATT table starts at
+    // index 0. Without this, a second transpile in one process would continue
+    // from the previous file's counter and emit offset indices.
+    getContext().bleCharCounter = 0;
 }
 /** Resolve a hal-expr IR node to its C++ text using the active strategy. */
 export function setActiveStrategy(strategy) {
@@ -696,14 +721,21 @@ export function buildSnprintfFromConcat(expr) {
             else if (part.kind === "template_string" && part.expression.kind === "hal-expr") {
                 // HAL expression inside template literal — resolve via strategy
                 const resolved = resolveHALExprToText(part.expression);
-                if (resolved !== null) {
-                    formatString += "%d";
-                    args.push(resolved);
-                    estimatedLength += 12;
+                const argText = resolved !== null ? resolved : text;
+                const cppType = cppTypeForHalOp(part.expression.operation.operation);
+                if (cppType === "const char*" || (cppType !== undefined && /char\s*\*$/.test(cppType))) {
+                    formatString += "%s";
+                    args.push(argText);
+                    estimatedLength += 32;
+                }
+                else if (cppType === "bool") {
+                    formatString += "%s";
+                    args.push(`(${argText} ? "true" : "false")`);
+                    estimatedLength += 5;
                 }
                 else {
                     formatString += "%d";
-                    args.push(text);
+                    args.push(argText);
                     estimatedLength += 12;
                 }
             }

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

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

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

@@ -210,6 +210,30 @@ export function loadHALModules(force = false) {
 export function getCtorIncludes(className) {
     return halCtorIncludes.get(className) ?? [];
 }
+/** Map an HttpClass factory method name to its HTTP verb, or null. */
+export function httpFactoryVerb(methodName) {
+    switch (methodName) {
+        case "get": return "GET";
+        case "post": return "POST";
+        case "put": return "PUT";
+        case "del": return "DELETE";
+        case "head": return "HEAD";
+        case "patch": return "PATCH";
+        default: return null;
+    }
+}
+/** Render an Http factory URL argument as C++ expression text (string
+ *  literals quoted, identifiers/member accesses verbatim), or null when the
+ *  argument shape can't be resolved at compile time. */
+export function httpUrlArgText(arg) {
+    if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg))
+        return JSON.stringify(arg.text);
+    if (ts.isIdentifier(arg))
+        return arg.text;
+    if (ts.isPropertyAccessExpression(arg))
+        return arg.getText();
+    return null;
+}
 /** Resolve a call receiver to a tracked HAL instance. */
 export function resolveHALReceiver(receiver) {
     const result = (() => {
@@ -336,6 +360,58 @@ export function resolveHALReceiver(receiver) {
                         return { className: "ToneChain", fieldValues };
                     }
                 }
+                // Specialized handling for Http factory chaining
+                // (Http.get(url).header(...).send()): the factory records the HTTP
+                // verb and URL into the HttpRequest instance so send() can resolve
+                // this._method / this._url.
+                if (innerInstance.className === "HttpClass") {
+                    const verb = httpFactoryVerb(methodName);
+                    if (verb && receiver.arguments.length > 0) {
+                        const urlText = httpUrlArgText(receiver.arguments[0]);
+                        if (urlText) {
+                            return {
+                                className: "HttpRequest",
+                                fieldValues: new Map([["_method", verb], ["_url", urlText]]),
+                            };
+                        }
+                    }
+                }
+                // Specialized handling for BLE factory chaining
+                // (Ble.server(name).characteristic(uuid,type,perms).onRead(handler)):
+                // server() creates a BleServer. The characteristic index is taken from a
+                // per-file counter (bleCharCounter on CompilationContext) that persists
+                // across separate server() calls so a multi-characteristic server — the
+                // common ble-demo pattern of one Ble.server(name).characteristic(...) per
+                // char — gets unique sequential indices (0,1,2,…) instead of every char
+                // landing on slot 0 and clobbering the previous on_read/on_write handler.
+                // characteristic() reads the current counter for the add_char call and
+                // posts-increments it so the next characteristic gets the next slot.
+                // onRead/onWrite/onNotify carry _lastChar (the slot characteristic() just
+                // reserved). The counter resets per file in hal-emitter.ts.
+                if (innerInstance.className === "BleClass" && methodName === "server" && receiver.arguments.length > 0) {
+                    const nameText = httpUrlArgText(receiver.arguments[0]);
+                    if (nameText) {
+                        return {
+                            className: "BleServer",
+                            fieldValues: new Map([["_name", nameText], ["_charCount", "0"], ["_lastChar", "0"], ["_svcCount", "1"]]),
+                        };
+                    }
+                }
+                if (innerInstance.className === "BleServer" && methodName === "characteristic") {
+                    // characteristic(uuid, type, perms) returns this (BleServer). The
+                    // characteristic index is assigned centrally in the bleAddChar plugin
+                    // (hal-plugins.ts) from a per-file counter — see the note there for
+                    // why this can't be done via instance fieldValues (resolveHALReceiver
+                    // re-resolves the receiver for each chain level and would drop a
+                    // value stamped here).
+                    return innerInstance;
+                }
+                if (innerInstance.className === "BleServer" && methodName === "service") {
+                    // service() returns this (BleServer); advance the service counter.
+                    const svc = Number(innerInstance.fieldValues.get("_svcCount") ?? "1") + 1;
+                    innerInstance.fieldValues.set("_svcCount", String(svc));
+                    return innerInstance;
+                }
                 // General fallback: if the method is known to return another HAL class, carry over fields
                 const classEntry = halClassRegistry.get(innerInstance.className);
                 const methodEntry = classEntry?.methods.get(methodName);
@@ -345,6 +421,11 @@ export function resolveHALReceiver(receiver) {
                         return { className: returnClassName, fieldValues: new Map(innerInstance.fieldValues) };
                     }
                 }
+                // Fluent `this`-returning methods (e.g. HttpRequest.header/timeout):
+                // the chain result is the same instance, so keep resolving through it.
+                if (methodEntry && methodEntry.methodNode.type && methodEntry.methodNode.type.kind === ts.SyntaxKind.ThisType) {
+                    return innerInstance;
+                }
             }
         }
         // Inline new expression: new Pin(x).method()