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

package/dist/ir/build-ir.js

@@ -5,11 +5,10 @@ import { parseSource } from "../ast/parse.js";
 import { isStringEnum } from "../api/shared/index.js";
 import { makeDiagnostic } from "./ast-node-utils.js";
 import { buildFunctionReturnTypeMap } from "./type-resolution.js";
-import { resolveBoardConstants, tryResolveBoardDefFile } from "./board-resolver.js";
+import { tryResolveBoardDefFile, findGeneratedBoard, readGeneratedBoardConstants } from "./board-resolver.js";
 import { analyzePeripheralUsage, createEmptyPeripheralUsage } from "./peripheral-usage.js";
 import { runProgramValidations } from "./validation-orchestrator.js";
-import { registerFieldMap, hoistedNestedFunctions, hoistedNestedClasses, hoistedNestedEnums, hoistedNestedInterfaces, hoistedNestedTypeAliases, activeNamespaceNames, activeEnumNames, activeStringEnumNames, peripheralAliasMap, pinAliasMap, mcuPinReverseMap, topLevelClassNames, topLevelInterfaceNames, classTypeNames, topLevelClasses, requiredIncludes, resetBuildState, getCurrentBoardConstants, setCurrentBoardConstants, contextStorage, CompilationContext, registeredCallbacks, getContext, discriminatedUnionVariantNames, restParamFunctions, topLevelAliasReceivers } from "./build-ir-state.js";
-import { pinShadowVarName, takeShadowDeclarations, resetPinStateTracking, markShadowUpdatingOps } from "./pin-state-tracking.js";
+import { registerFieldMap, hoistedNestedFunctions, hoistedNestedClasses, hoistedNestedEnums, hoistedNestedInterfaces, hoistedNestedTypeAliases, activeNamespaceNames, activeEnumNames, activeStringEnumNames, peripheralAliasMap, pinAliasMap, mcuPinForwardMap, mcuPinReverseMap, topLevelClassNames, topLevelInterfaceNames, classTypeNames, topLevelClasses, requiredIncludes, resetBuildState, getCurrentBoardConstants, setCurrentBoardConstants, contextStorage, CompilationContext, registeredCallbacks, getContext, discriminatedUnionVariantNames, restParamFunctions, topLevelAliasReceivers } from "./build-ir-state.js";
 import { collectPointerVars, expressionStatementToIR, lowerStatement, variableStatementToIR, prescanArrayUsage, lowerStatementList } from "./statement-to-ir.js";
 import { registerUIModuleImport, registerElementValue } from "./transformers/ui-call-resolver.js";
 import { requireUIHook } from "../ui-hook.js";
@@ -141,7 +140,7 @@ function resolveUIImportPath(fromFile, moduleSpecifier) {
     catch { /* skip */ }
     return undefined;
 }
-export function buildProgramIR(fileName, sourceText, boardPackage, prebuiltClassMap) {
+export function buildProgramIR(fileName, sourceText, boardTarget, prebuiltClassMap) {
     const parentStrategy = getContext().activeStrategy;
     return contextStorage.run(new CompilationContext(), () => {
         getContext().activeStrategy = parentStrategy;
@@ -182,7 +181,6 @@ export function buildProgramIR(fileName, sourceText, boardPackage, prebuiltClass
         // Reset module-level state for this file
         resetBuildState();
         resetHALResolver();
-        resetPinStateTracking();
         registerFieldMap.clear();
         // Phase 0: Pre-scan for top-level classes and register them so type inference can resolve them.
         // Also register classes from other files in the transpile graph so that property accesses
@@ -299,7 +297,7 @@ export function buildProgramIR(fileName, sourceText, boardPackage, prebuiltClass
                 // lowered to IR, but `ui` itself must NOT be emitted as a C++ value
                 // (it would synthesize a bogus _ui_t struct). Drop it from the imports
                 // IR so the emit path never sees it as an imported value.
-                const isUiPackage = moduleSpecifier === '@typecad/ui' || moduleSpecifier === '@typecad/ui';
+                const isUiPackage = moduleSpecifier === '@typecad/ui';
                 const filteredImports = isUiPackage
                     ? namedImports.filter((n) => n !== 'ui')
                     : namedImports;
@@ -307,10 +305,10 @@ export function buildProgramIR(fileName, sourceText, boardPackage, prebuiltClass
             }
         }
         for (const imp of earlyImports) {
-            const boardFile = tryResolveBoardDefFile(fileName, imp.moduleSpecifier, boardPackage);
+            const boardFile = tryResolveBoardDefFile(fileName, imp.moduleSpecifier, boardTarget);
             if (boardFile) {
                 try {
-                    setCurrentBoardConstants(resolveBoardConstants(boardFile));
+                    setCurrentBoardConstants(readGeneratedBoardConstants(boardFile));
                 }
                 catch {
                     // Non-fatal
@@ -319,20 +317,21 @@ export function buildProgramIR(fileName, sourceText, boardPackage, prebuiltClass
             }
         }
         // If only the default board constants are loaded (4 keys from getDefaultBoardConstants),
-        // try the config's boardPackage directly. This covers the case where board()/boardResolve()
-        // is imported from @typecad/hal but no @typecad/board-* import is present in the user's code.
+        // load the generated board manifest directly — covers the case where board()/boardResolve()
+        // is imported from @typecad/hal but no @typecad/board import is present in the user's code.
         const currentBC = getCurrentBoardConstants();
-        if (currentBC && currentBC.size <= 4 && boardPackage) {
-            const boardFile = tryResolveBoardDefFile(fileName, boardPackage, boardPackage);
-            if (boardFile) {
+        if (currentBC && currentBC.size <= 4) {
+            const generated = findGeneratedBoard(fileName);
+            if (generated) {
                 try {
-                    setCurrentBoardConstants(resolveBoardConstants(boardFile));
+                    setCurrentBoardConstants(readGeneratedBoardConstants(generated.boardJson));
                 }
                 catch {
                     // Non-fatal
                 }
             }
         }
+        void boardTarget;
         // Phase 0c-bis: register UI module imports (name → .ui.html path) so
         // ui.mount(screen, ...) can resolve `screen` back to its source tree.
         // Only .ui.html specifiers are registered; their named imports are the UI
@@ -387,8 +386,7 @@ export function buildProgramIR(fileName, sourceText, boardPackage, prebuiltClass
             "asOutput", "asInput", "asInputPullUp", "asInputPullDown",
             "output", "inputPullUp", "inputPullDown",
             "device", // I2CBus.device(addr) / SPIBus.device(cs) → device instance
-            "tone", // OutputPin.tone(freq) → ToneChain
-            "begin", // I2CBus.begin() / SPIBus.begin() / SerialPort.begin() → same instance
+            "begin", // I2CBus.begin() / SPIBus.begin() → same instance
             "take", // Bus.take() → same instance (ownership is compile-time only)
         ]);
         for (const node of source.statements) {
@@ -402,7 +400,7 @@ export function buildProgramIR(fileName, sourceText, boardPackage, prebuiltClass
                     && HAL_ALIASING_METHODS.has(init.expression.name.text)
                     && ts.isIdentifier(init.expression.expression)) {
                     // Capture call arguments for factory methods like device(0x76) that
-                    // need the arg to construct the derived instance (I2CDevice._address).
+                    // need the arg to construct the derived instance (I2CTarget._address).
                     const argTexts = init.arguments.map(a => {
                         if (ts.isNumericLiteral(a))
                             return a.text;
@@ -445,20 +443,20 @@ export function buildProgramIR(fileName, sourceText, boardPackage, prebuiltClass
                         }
                     }
                 }
-                // Track HAL instances imported from board packages and framework HAL
-                // subpaths so the HAL resolver can resolve them to framework C++ names.
-                // The `@typecad/board` virtual import resolves to the board package, so it
-                // also registers pin aliases (LED, etc.). Case-insensitive on the scope.
+                // Track HAL instances imported from the board module (virtual
+                // `@typecad/board`, or a legacy `@typecad/board-*` package import from
+                // pre-boardgen projects, which resolves against the project's generated
+                // board constants) so the HAL resolver can resolve them to framework
+                // C++ names. Case-insensitive.
                 const lowerSpecifier = moduleSpecifier.toLowerCase();
                 const isHALSource = lowerSpecifier.startsWith('@typecad/board-')
-                    || lowerSpecifier === '@typecad/board'
-                    || /^@typecad\/framework-[a-z0-9-]+\/(arduino|hal|gpio)$/.test(lowerSpecifier);
+                    || lowerSpecifier === '@typecad/board';
                 // UI authoring namespace: `import { ui } from "@typecad/ui"`. The `ui`
                 // value is a compile-time construct (its calls are intercepted by
                 // tryResolveUICall); it must NOT be emitted as a C++ struct/value.
                 // Treat it like the HAL namespace imports (Pulse/Shift/Random): register
                 // as a namespace name and skip, so no struct is synthesized.
-                if (moduleSpecifier === '@typecad/ui' || moduleSpecifier === '@typecad/ui') {
+                if (moduleSpecifier === '@typecad/ui') {
                     for (const name of namedImports) {
                         if (name === 'ui') {
                             activeNamespaceNames.add(name);
@@ -497,10 +495,31 @@ export function buildProgramIR(fileName, sourceText, boardPackage, prebuiltClass
                             halInstances.set(name, { className: "Pin", fieldValues: fields });
                             continue;
                         }
-                        // A-pins: A0-A19 → Pin instance with board-specific offset and MCU port name (fallback)
+                        // A-pins: A0, A1, … → resolve through the board manifest's analog
+                        // pin list first (A-ordered on every board package: A<n> →
+                        // pins.analog[n] → the MCU port name → pin number). Only when the
+                        // list is absent (bare Arduino-style boards) fall back to the
+                        // analogOffset convention (A0 = 14) — on port-named boards that
+                        // fallback resolves A1 to a random GPIO (Black Pill PA15, a
+                        // non-analog pin, was the first to surface it via a capability
+                        // error).
                         const aMatch = name.match(/^A(\d+)$/);
                         if (aMatch) {
-                            const pinNum = String(analogOffset + parseInt(aMatch[1]));
+                            let pinNum;
+                            // The flattener stores the manifest's analog pin list as a
+                            // comma-joined string under `pins.analog`.
+                            const analogList = boardConstants.get("pins.analog");
+                            if (typeof analogList === "string") {
+                                const analogName = analogList.split(",")[parseInt(aMatch[1], 10)];
+                                if (analogName) {
+                                    const byName = mcuPinForwardMap.get(analogName);
+                                    if (byName !== undefined)
+                                        pinNum = String(byName);
+                                }
+                            }
+                            if (pinNum === undefined) {
+                                pinNum = String(analogOffset + parseInt(aMatch[1]));
+                            }
                             const fields = new Map([["_pin", pinNum]]);
                             const portName = mcuPinReverseMap.get(pinNum);
                             if (portName)
@@ -511,22 +530,36 @@ export function buildProgramIR(fileName, sourceText, boardPackage, prebuiltClass
                         // I2C buses: I2C0, I2C1, ...
                         const i2cMatch = name.match(/^I2C(\d+)$/);
                         if (i2cMatch) {
-                            const alias = peripheralAliasMap.get(name) ?? (i2cMatch[1] === '0' ? 'Wire' : `Wire${i2cMatch[1]}`);
+                            const alias = peripheralAliasMap.get(name) ?? `I2C${i2cMatch[1]}`;
                             halInstances.set(name, { className: "I2CBus", fieldValues: new Map([["_bus", alias]]) });
                             continue;
                         }
                         // SPI buses: SPI0, SPI1, ...
                         const spiMatch = name.match(/^SPI(\d+)$/);
                         if (spiMatch) {
-                            const alias = peripheralAliasMap.get(name) ?? (spiMatch[1] === '0' ? 'SPI' : `SPI${spiMatch[1]}`);
+                            const alias = peripheralAliasMap.get(name) ?? `SPI${spiMatch[1]}`;
                             halInstances.set(name, { className: "SPIBus", fieldValues: new Map([["_bus", alias]]) });
                             continue;
                         }
-                        // UART: UART0, UART1, ...
+                        // UART: UART0, UART1, ... — the FUNCTIONAL thin UART instance, so
+                        // the board singleton is directly usable (UART0.println(...)) with
+                        // the same fields a `new UART('UART0')` construction captures
+                        // (port + the class's baud/ring defaults; variables.ts merges those
+                        // only at construction, so the registration carries them).
                         const uartMatch = name.match(/^UART(\d+)$/);
                         if (uartMatch) {
-                            const alias = peripheralAliasMap.get(name) ?? (uartMatch[1] === '0' ? 'Serial' : `Serial${uartMatch[1]}`);
-                            halInstances.set(name, { className: "SerialPort", fieldValues: new Map([["_port", alias]]) });
+                            const alias = peripheralAliasMap.get(name) ?? `UART${uartMatch[1]}`;
+                            halInstances.set(name, {
+                                className: "UART",
+                                fieldValues: new Map([["_port", alias], ["_bus", alias], ["_baud", "115200"], ["_rxBufferBytes", "64"]]),
+                            });
+                            continue;
+                        }
+                        // USB CDC serial ports: USB0, USB1, ...
+                        const usbMatch = name.match(/^USB(\d+)$/);
+                        if (usbMatch) {
+                            const alias = peripheralAliasMap.get(name) ?? `USB${usbMatch[1]}`;
+                            halInstances.set(name, { className: "USBConsole", fieldValues: new Map([["_port", alias]]) });
                             continue;
                         }
                         // HAL namespace imports: Pulse, Shift, Random
@@ -814,20 +847,6 @@ export function buildProgramIR(fileName, sourceText, boardPackage, prebuiltClass
         // write/toggle ops, while this file's tracker state is still live (the
         // next file's build resets it, and emit runs after every file is built —
         // multi-file programs would lose the updates otherwise). Then consume the
-        // shadow declarations — pins whose reads lowered to the shadow variable
-        // form need a file-scope declaration.
-        markShadowUpdatingOps(program);
-        const shadowDecls = takeShadowDeclarations();
-        for (const { pin, initial } of shadowDecls) {
-            program.topLevelStatements.unshift({
-                kind: "var_decl",
-                sourceSpan: { filePath: fileName, startOffset: 0, endOffset: 0, startLine: 0, startColumn: 0, endLine: 0, endColumn: 0 },
-                name: pinShadowVarName(pin),
-                storage: "var",
-                cppType: "bool",
-                initializer: { kind: "boolean", value: initial },
-            });
-        }
         return program;
     });
 }

package/dist/ir/declaration-builders.js

@@ -256,6 +256,7 @@ export function classDeclarationToIR(node, fileName, sourceText, diagnostics, fu
                 visibility: methodVisibility,
                 isStatic,
                 isAbstract: isMethodAbstract,
+                isAsync: member.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false,
                 isOverride,
                 ...(member.typeParameters && member.typeParameters.length > 0
                     ? { typeParameters: member.typeParameters.map(tp => tp.name.text) }

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

@@ -1,7 +1,6 @@
 import ts from "typescript";
 import { makeDiagnostic, makeSourceSpan } from "./ast-node-utils.js";
 import { PIN_FACTORY_FUNCTIONS, CONSTANT_FOLD_FUNCTIONS, TYPED_ARRAY_ELEMENT_MAP, activeCArrayVars, activeArrayLiteralVars, activeStringVars, nestedFunctionAliases, nestedClassAliases, hoistedNestedClasses, mutableArrayVars, arrayLiteralSizes, filteredArrayLengthVars, activeNamespaceNames, activeEnumNames, activeStringEnumNames, topLevelClassNames, topLevelInterfaceNames, classTypeNames, topLevelClasses, getActiveExtendsClass, restParamFunctions, getContext, getCurrentBoardConstants } from "./build-ir-state.js";
-import { isPinFoldingEnabled, setPinFoldingEnabled } from "./pin-state-tracking.js";
 import { getCurrentIrTypeScope } from "./symbol-types.js";
 import { renderExprAsText } from "./render-expr.js";
 import { lowerStatement, tryResolveHALExpression } from "./statement-to-ir.js";
@@ -414,8 +413,8 @@ export function expressionToIR(expr, sourceText, diagnostics, pointerVars = new
             return `(sizeof(${safeText}) / sizeof(${safeText}[0]))`;
         }
         if (ts.isCallExpression(receiverNode)) {
-            // Case B: a HAL buffer-returning method (I2CDevice.readBytes /
-            // SPIDevice.readRegister) used INLINE as a sub-expression — e.g.
+            // Case B: a HAL buffer-returning method (a device target's read
+            // verbs) 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()`
@@ -685,9 +684,9 @@ export function expressionToIR(expr, sourceText, diagnostics, pointerVars = new
         // When the cast involves an `enum class` on one side and an integral type
         // on the other, emit a `static_cast<T>(...)` instead of erasing. C++ enum
         // class has NO implicit conversion, so the erased cast produces invalid
-        // C++. The SUPPORT_MATRIX handles this for specific sites (relational,
-        // index, Map key, storage boundary) but NOT for the general `as` cast —
-        // the user's explicit escape hatch (enum stress test Finding C).
+        // C++. This is handled for specific sites (relational, index, Map key,
+        // storage boundary) but NOT for the general `as` cast — the user's
+        // explicit escape hatch (enum stress test Finding C).
         const targetTypeName = expr.type && ts.isTypeReferenceNode(expr.type) && ts.isIdentifier(expr.type.typeName)
             ? expr.type.typeName.text : "";
         const isTargetEnum = targetTypeName && activeEnumNames.has(targetTypeName) && !activeStringEnumNames.has(targetTypeName);
@@ -1103,6 +1102,17 @@ export function expressionToIR(expr, sourceText, diagnostics, pointerVars = new
         };
     }
     if (ts.isCallExpression(expr)) {
+        // ---- console.* is not a supported API (value position) ----
+        // Statement-position console calls are rejected in callToStatement; this
+        // covers value-position uses (e.g. `const line = console.readLine()`).
+        // Same rationale: the TypeScript console carry-over is gone — programs
+        // write to a serial console explicitly via the board module.
+        if (ts.isPropertyAccessExpression(expr.expression) &&
+            ts.isIdentifier(expr.expression.expression) &&
+            expr.expression.expression.text === "console") {
+            diagnostics.push(makeDiagnostic(sourceText, expr.pos, `console.${expr.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: "raw", value: "0 /* console.* is not supported */" };
+        }
         // ---- 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
@@ -1657,7 +1667,7 @@ export function expressionToIR(expr, sourceText, diagnostics, pointerVars = new
             // with '*' (a class-pointer struct field, e.g. FloorState.monster), the
             // method call must use ->. Without this, `dungeon.monster.bounty()`
             // emits `.` and fails g++ ("request for member 'bounty' ... pointer
-            // type"). See SUPPORT_MATRIX §4.5 (demo #4 fix).
+            // type"). (demo #4 fix.)
             isPointer: calleeText.includes("->")
                 || (ts.isCallExpression(expr)
                     && ts.isPropertyAccessExpression(expr.expression)
@@ -2199,8 +2209,6 @@ export function expressionToIR(expr, sourceText, diagnostics, pointerVars = new
         const isBlock = ts.isBlock(body);
         // Lambda bodies run at an unmodeled time (callbacks), so pin-state
         // constant folding must be off inside them.
-        const prevPinFolding = isPinFoldingEnabled();
-        setPinFoldingEnabled(false);
         const bodyStmts = isBlock
             ? body.statements.map(stmt => {
                 const lowered = lowerStatement(stmt, "", sourceText, diagnostics, new Map(), new Map(), "<lambda>", new Map(), pointerVars);
@@ -2212,7 +2220,6 @@ export function expressionToIR(expr, sourceText, diagnostics, pointerVars = new
                     sourceSpan: makeSourceSpan(body, "", sourceText),
                     value: expressionToIR(body, sourceText, diagnostics, pointerVars),
                 }];
-        setPinFoldingEnabled(prevPinFolding);
         // Infer return type: use explicit annotation, or infer from body. Thread
         // the lambda's own param types into the inference so a body like
         // `(n) => n.capacity` can resolve `n` and deduce the return type.

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

@@ -55,8 +55,6 @@ export declare function resolveHALExprToText(expr: Extract<import("../../api/sha
     kind: "hal-expr";
 }>): string | null;
 export declare function registerFloatVariable(name: string): void;
-/** Build snprintf prelude lines from a string_concat expression.
- *  Returns { lines, bufferName } or null if the expression can't be formatted. */
 export declare function buildSnprintfFromConcat(expr: Extract<ExpressionIR, {
     kind: "string_concat";
 }>): {

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

@@ -1,11 +1,10 @@
 import ts from "typescript";
-import { requiredIncludes, registeredCallbacks, activeStringVars, TYPED_ARRAY_ELEMENT_MAP, getContext, floatVariables, halInstances, getCurrentBoardConstants } from "../build-ir-state.js";
+import { requiredIncludes, registeredCallbacks, activeStringVars, TYPED_ARRAY_ELEMENT_MAP, getContext, floatVariables, halInstances, getCurrentBoardConstants, markHalOpResolved } from "../build-ir-state.js";
 import { getCurrentIrTypeScope } from "../symbol-types.js";
 import { renderExprAsText } from "../render-expr.js";
-import { escapeCppKeyword } from "../../utils/strings.js";
+import { escapeCppKeyword, escapeCppStringLiteral } from "../../utils/strings.js";
 import { halClassRegistry, halGlobalFunctions } from "./hal-parser.js";
 import { tryResolveSemanticCall, tryResolveBoardResolveArg, tryResolveCompoundSemanticReturn, resolveConcatPath } from "./hal-plugins.js";
-import { resolveTrackedRead, pinShadowVarName } from "../pin-state-tracking.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). */
@@ -65,16 +64,6 @@ function inlineThisGetterCall(methodName, pin, strategy) {
             // lower to the tracked level (constant when statically known, shadow
             // variable otherwise) instead of a hardware read. Reading back a
             // direction-only output is not portable (e.g. Zephyr).
-            const pinNum = Number.parseInt(pin, 10);
-            if (Number.isFinite(pinNum)) {
-                const tracked = resolveTrackedRead(pinNum);
-                if (tracked !== null) {
-                    const levelText = tracked === "shadow"
-                        ? pinShadowVarName(pinNum)
-                        : (tracked === "high" ? "true" : "false");
-                    return methodName === "isLow" ? `(!${levelText})` : levelText;
-                }
-            }
             if (methodName === "read")
                 return strategy?.readDigitalPin?.(pin) ?? `digitalRead(${pin})`;
             if (methodName === "isHigh")
@@ -150,8 +139,12 @@ export function resolveExpressionText(expr, instance, paramNames, callArgTexts,
     }
     if (ts.isNumericLiteral(expr))
         return expr.text;
+    // Escape the DECODED text back to a valid C++ literal — expr.text holds
+    // real control chars (a "\n" argument decodes to a newline), and a raw
+    // newline inside a C string literal is an unterminated literal that
+    // corrupts the rest of the file. Same helper every other renderer uses.
     if (ts.isStringLiteral(expr))
-        return expr.text;
+        return `"${escapeCppStringLiteral(expr.text)}"`;
     // Call expression (e.g., digitalRead(this._pin), board("path"))
     if (ts.isCallExpression(expr)) {
         // callback(param) → return the patched placeholder text
@@ -300,7 +293,7 @@ export function resolveExpressionText(expr, instance, paramNames, callArgTexts,
  *  ESP-IDF, trips -Werror=attributes when IRAM_ATTR's __COUNTER__ disagrees
  *  between forward declaration and definition. */
 const ISR_CALLBACK_SEMANTIC_FNS = new Set([
-    "interruptAttach",
+    "interruptAttachFlags",
 ]);
 /** True when a HAL semantic call name wraps a GPIO/hardware ISR callback. */
 export function semanticCallUsesIsrCallback(fnName) {
@@ -665,10 +658,16 @@ export function resolveHALExprToText(expr) {
     if (!strategy?.resolveHALOperation)
         return null;
     const resolved = strategy.resolveHALOperation(expr.operation);
-    if (resolved?.expression)
-        return resolved.expression;
-    if (resolved?.code)
-        return resolved.code.replace(/;\s*$/, "");
+    if (resolved) {
+        // The op may never exist as an IR node (its text is baked into the
+        // calling method's emit lines), so record it for program-analysis's
+        // peripheral usage flags.
+        markHalOpResolved(expr.operation.operation);
+        if (resolved.expression)
+            return resolved.expression;
+        if (resolved.code)
+            return resolved.code.replace(/;\s*$/, "");
+    }
     return null;
 }
 export function registerFloatVariable(name) {
@@ -676,6 +675,20 @@ export function registerFloatVariable(name) {
 }
 /** Build snprintf prelude lines from a string_concat expression.
  *  Returns { lines, bufferName } or null if the expression can't be formatted. */
+/** True when a binary IR expression touches a known float variable on either
+ *  side (recursively) — its rendered C++ is double-valued. */
+function binaryTouchesFloatVar(expr) {
+    for (const side of [expr.left, expr.right]) {
+        if (!side || typeof side !== "object")
+            continue;
+        const s = side;
+        if (s.kind === "identifier" && typeof s.value === "string" && floatVariables.has(s.value))
+            return true;
+        if (s.kind === "binary" && binaryTouchesFloatVar(s))
+            return true;
+    }
+    return false;
+}
 export function buildSnprintfFromConcat(expr) {
     let formatString = "";
     const args = [];
@@ -685,18 +698,21 @@ export function buildSnprintfFromConcat(expr) {
     for (const part of expr.parts) {
         const text = renderExprAsText(part);
         if (part.kind === "string") {
-            formatString += text.slice(1, -1).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+            // Escape % → %% first (a bare % in the format string starts a
+            // conversion — a literal '%RH' becomes the unknown-conversion 'R'),
+            // then the C-literal escapes.
+            formatString += text.slice(1, -1).replace(/%/g, "%%").replace(/\\/g, "\\\\").replace(/"/g, '\\"');
             estimatedLength += part.value.length;
         }
         else if (part.kind === "number") {
             const isFloat = part.cppType === "float" || part.cppType === "double" || !Number.isInteger(part.value);
             if (isFloat) {
-                requiredIncludes.add("<stdlib.h>");
-                const floatBuf = `__cuttlefish_float_${getContext().snprintfCounter++}`;
-                prelude.push(`char ${floatBuf}[16];`);
-                prelude.push(`dtostrf(${text}, 0, 1, ${floatBuf});`);
-                formatString += "%s";
-                args.push(floatBuf);
+                // %g formats the double literal directly — portable (Zephyr's
+                // cbprintf turns on FP support when it sees a float specifier);
+                // dtostrf is AVR-only and fails to compile elsewhere (same reasoning
+                // as the float-VARIABLE branch below).
+                formatString += "%g";
+                args.push(text);
                 estimatedLength += 16;
             }
             else {
@@ -710,15 +726,32 @@ export function buildSnprintfFromConcat(expr) {
             const isStringVar = part.kind === "template_string"
                 && part.expression.kind === "identifier"
                 && (activeStringVars.has(part.expression.value) || getCurrentIrTypeScope()?.locals.get(part.expression.value) === "std::string" || getCurrentIrTypeScope()?.globals.get(part.expression.value) === "std::string");
-            // Check for float variable reference: template_string wrapping an identifier
+            // Check for float variable reference: template_string wrapping an identifier.
+            // A var initialized from a double-returning HAL op (sensor.get) records
+            // as a float var; one declared `: number` from such an initializer also
+            // lands in the IR scope's float types.
             const isFloatVar = part.kind === "template_string"
                 && part.expression.kind === "identifier"
                 && floatVariables.has(part.expression.value);
+            // Inline double-returning HAL call (template_string wrapping a call):
+            // the lowerings' deterministic shape for a double return is
+            // `static_cast<double>(...)` — Time.now()/sensor.get()/millivolt reads.
+            // Formatting that with the %d default is a -Wformat warning at best and
+            // wrong output at worst; %g matches the float-variable branch.
+            const isDoubleCall = part.kind === "template_string"
+                && /^static_cast<double>\(/.test(text);
             if (isStringVar) {
                 formatString += "%s";
                 const varName = part.expression.value;
                 const varType = getCurrentIrTypeScope()?.locals.get(varName) || getCurrentIrTypeScope()?.globals.get(varName) || "";
-                const cleanType = varType.replace(/\bconst\b\s*/g, "").trim();
+                // Normalize through the ACTIVE strategy before the char* check — the
+                // IR scope carries the pre-normalization type ("std::string") while
+                // the declaration renderer emitted the strategy's mapping of it
+                // (Zephyr: std::string → const char*). Without this, a string-literal
+                // variable declares as const char* but its snprintf arg gains a
+                // .c_str() that const char* does not have.
+                const normalizedType = getContext().activeStrategy?.normalizeCppType(varType) ?? varType;
+                const cleanType = normalizedType.replace(/\bconst\b\s*/g, "").trim();
                 if (cleanType && cleanType !== "char*" && cleanType !== "const char*") {
                     args.push(`${text}.c_str()`);
                 }
@@ -728,12 +761,18 @@ export function buildSnprintfFromConcat(expr) {
                 estimatedLength += 32;
             }
             else if (isFloatVar) {
-                requiredIncludes.add("<stdlib.h>");
-                const floatBuf = `__cuttlefish_float_${getContext().snprintfCounter++}`;
-                prelude.push(`char ${floatBuf}[16];`);
-                prelude.push(`dtostrf(${text}, 0, 1, ${floatBuf});`);
-                formatString += "%s";
-                args.push(floatBuf);
+                // %g formats the double expression directly — portable (Zephyr's
+                // cbprintf turns on FP support when it sees a float specifier);
+                // dtostrf is AVR-only and fails to compile elsewhere.
+                formatString += "%g";
+                args.push(text);
+                estimatedLength += 16;
+            }
+            else if (isDoubleCall) {
+                // Inline double-returning HAL call (`${Time.now()}`) — the rendered
+                // text IS the double expression; %g, never the %d default.
+                formatString += "%g";
+                args.push(text);
                 estimatedLength += 16;
             }
             else if (part.kind === "template_string" && part.expression.kind === "hal-expr") {
@@ -751,6 +790,12 @@ export function buildSnprintfFromConcat(expr) {
                     args.push(`(${argText} ? "true" : "false")`);
                     estimatedLength += 5;
                 }
+                else if (cppType === "float" || cppType === "double") {
+                    // %g formats the double expression directly — no AVR-only dtostrf.
+                    formatString += "%g";
+                    args.push(argText);
+                    estimatedLength += 12;
+                }
                 else {
                     formatString += "%d";
                     args.push(argText);
@@ -760,15 +805,21 @@ export function buildSnprintfFromConcat(expr) {
             else {
                 const numVal = Number(text);
                 if (!isNaN(numVal) && !Number.isInteger(numVal)) {
-                    requiredIncludes.add("<stdlib.h>");
-                    const floatBuf = `__cuttlefish_float_${getContext().snprintfCounter++}`;
-                    const precision = text.includes(".") ? text.split(".")[1].length : 1;
-                    prelude.push(`char ${floatBuf}[16];`);
-                    prelude.push(`dtostrf(${text}, 0, ${precision}, ${floatBuf});`);
-                    formatString += "%s";
-                    args.push(floatBuf);
+                    // A float literal (or float-valued expression) — %g directly; the
+                    // AVR dtostrf detour fails to compile on every other framework.
+                    formatString += "%g";
+                    args.push(text);
                     estimatedLength += 16;
                 }
+                else if (part.kind === "template_string"
+                    && part.expression.kind === "binary"
+                    && binaryTouchesFloatVar(part.expression)) {
+                    // Arithmetic on a double var (`tenths / 10`) is double-valued: %g,
+                    // not %d — the rendered text is already the C++ expression.
+                    formatString += "%g";
+                    args.push(text);
+                    estimatedLength += 12;
+                }
                 else {
                     formatString += "%d";
                     args.push(text);

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

@@ -16,6 +16,10 @@ export interface HALMethodEntry {
 export interface HALClassEntry {
     ctorFieldMap: Map<string, string>;
     ctorDefaults: Map<string, string>;
+    /** Class-field initializer literals ("_spiHz" → "1000000") — the defaults
+     *  a method body reads when construction didn't set the field. Seeded into
+     *  instance fieldValues so `this._spiHz` in an inlined method resolves. */
+    fieldDefaults: Map<string, string>;
     methods: Map<string, HALMethodEntry>;
 }
 export declare const halClassRegistry: Map<string, HALClassEntry>;
@@ -50,11 +54,7 @@ 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 requestCtorFields(ctorArgs: readonly ts.Expression[] | undefined, sourceFile?: ts.SourceFile): Map<string, string> | null;
 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;