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

package/dist/ir/transformers/ui-callback-lowering.js

@@ -8,7 +8,6 @@
 // UI-specific behaviour that still happens here:
 //   - signal.set(value) → assign          (already in callToStatement)
 //   - signal() → identifier               (already in expressionToIR)
-//   - console.* → platform transform      (already at emit via StatementRenderer)
 //   - CSS color string literals → rgb int (resolveColorIR walk on the IR)
 //   - canvas ctx.* → ui_display_*         (ambient canvas ctx + rewriteCanvasCall)
 // ---------------------------------------------------------------------------
@@ -246,15 +245,7 @@ export function renameIdentifiersInStatements(statements, from, to) {
     return statements.map(renameStmt);
 }
 // ── Console-in-callback tracking (legacy string-bake leftover) ─────────────
-let _loweredConsoleInCallback = false;
-export function noteConsoleInCallback() {
-    _loweredConsoleInCallback = true;
-}
-export function loweredConsoleInCallback() {
-    return _loweredConsoleInCallback;
-}
 export function resetCallbackLoweringState() {
-    _loweredConsoleInCallback = false;
     endCanvasAmbient();
 }
 // ── Ambient canvas context ─────────────────────────────────────────────────
@@ -304,21 +295,6 @@ function callbackTypeMaps() {
  * go through lowerStatementList instead.
  */
 export function lowerCallbackExpr(expr, sourceText, diagnostics) {
-    if (ts.isCallExpression(expr) &&
-        ts.isPropertyAccessExpression(expr.expression) &&
-        ts.isIdentifier(expr.expression.expression) &&
-        expr.expression.expression.text === "console") {
-        const method = expr.expression.name.text;
-        const renderedArgs = expr.arguments
-            .map((arg) => renderExprAsText(expressionToIR(arg, sourceText, diagnostics)))
-            .join(" << ");
-        _loweredConsoleInCallback = true;
-        const strategy = getContext().activeStrategy;
-        if (strategy) {
-            return strategy.transformConsoleCall(method, renderedArgs, false).replace(/;$/, "");
-        }
-        return `std::cout << ${renderedArgs} << std::endl`;
-    }
     if (ts.isCallExpression(expr) &&
         ts.isPropertyAccessExpression(expr.expression) &&
         expr.expression.name.text === "set" &&

package/dist/ir/transformers/variables.js

@@ -8,18 +8,13 @@ import { renderExprAsText } from "../render-expr.js";
 import { expressionToIR } from "../expression-to-ir.js";
 import { buildInlineForLoop } from "./array-methods.js";
 import { isKnownHALClass, getCtorIncludes, getHALCtorFieldMap, registerFloatVariable, resolveHALReceiver, isHALSingleton, } from "../hal-resolver.js";
-import { httpFactoryVerb, httpUrlArgText } from "../hal/hal-parser.js";
+import { requestCtorFields, halClassRegistry } 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;
+function replaceHalReadBufferPlaceholder(_op, _varName) {
+    // i2c/spi read_buffer ops were removed with the legacy Wire/SPI surfaces.
+    return _op;
 }
 export function assignmentOperatorToString(kind) {
     switch (kind) {
@@ -445,10 +440,8 @@ export function variableStatementToIR(statement, fileName, sourceText, diagnosti
                                     fieldValues.set("_bus", arg.text);
                                 else if (className === "SPIBus")
                                     fieldValues.set("_bus", arg.text);
-                                else if (className === "SerialPort")
+                                else if (className === "UART")
                                     fieldValues.set("_port", arg.text);
-                                else if (className === "EEPROMClass")
-                                    fieldValues.set("_name", arg.text);
                             }
                             else if (ts.isNumericLiteral(arg)) {
                                 if (className === "Pin")
@@ -460,15 +453,273 @@ 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);
+                    // new Sensor(SENSOR.<part>, I2C1.device(0x44)) — the generic
+                    // DT-bound peripheral. The part token is kept as text (property
+                    // access text like 'SENSOR.sensirion_sht3xd'); the bus + address
+                    // come from the I2CTarget the second arg resolves to. The lowering
+                    // resolves the token against the generated catalog.
+                    if (className === "Sensor" && ctorArgs && ctorArgs.length >= 2) {
+                        const dev = resolveSensorDeviceArg(ctorArgs[1]);
+                        if (dev) {
+                            fieldValues.set("_part", ctorArgs[0].getText());
+                            fieldValues.set("_bus", dev.bus);
+                            fieldValues.set("_kind", dev.kind);
+                            fieldValues.set("_port", dev.port);
+                        }
+                        else {
+                            diagnostics.push(makeDiagnostic(sourceText, declaration.pos, `new Sensor(...) second argument must be an I2C device (e.g. I2C1.device(0x44), possibly via a const) — got '${ctorArgs[1].getText()}'.`, "error", "HAL_SENSOR_CTOR"));
+                        }
+                        // opts object literal: numeric properties pass through, pin
+                        // identifiers resolve to their number (alert?: PA5). Absent
+                        // properties fall back to the class-field initializer defaults
+                        // (_spiHz = 1000000 etc.) so `this._spiHz` in an inlined method
+                        // body always resolves.
+                        const sensorDefaults = halClassRegistry.get("Sensor")?.fieldDefaults;
+                        if (sensorDefaults) {
+                            for (const [name, val] of sensorDefaults) {
+                                if (!fieldValues.has(name))
+                                    fieldValues.set(name, val);
+                            }
+                        }
+                        if (ctorArgs.length >= 3 && ts.isObjectLiteralExpression(ctorArgs[2])) {
+                            for (const prop of ctorArgs[2].properties) {
+                                if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+                                    continue;
+                                const name = prop.name.text;
+                                if (ts.isNumericLiteral(prop.initializer)) {
+                                    fieldValues.set(`_${name}`, prop.initializer.text);
+                                }
+                                else if (ts.isIdentifier(prop.initializer)) {
+                                    const inst = halInstances.get(prop.initializer.text);
+                                    fieldValues.set(`_${name}`, inst?.fieldValues.get("_pin") ?? inst?.fieldValues.get("pin") ?? prop.initializer.text);
+                                }
+                            }
+                        }
+                    }
+                    // new Request(method, url, opts?) — shared capture (also serves
+                    // bare `new Request(...).send()` receivers via resolveHALReceiver).
+                    if (className === "Request") {
+                        const reqFields = requestCtorFields(ctorArgs, ctorArgs?.[0]?.getSourceFile());
+                        if (reqFields)
+                            for (const [k, v] of reqFields)
+                                fieldValues.set(k, v);
+                    }
+                    // Thin Zephyr-shaped peripherals (GPIO/PWM/ADC/DAC/
+                    // Watchdog/Counter — hal/gpio-pin.ts and siblings). Same discipline
+                    // as Sensor: construction facts become instance fields. Pin args
+                    // keep their identifier/text form (resolved to numbers later);
+                    // flag/gain token EXPRESSIONS keep their source text — the lowering
+                    // maps token names to C macros; numeric opts props pass through as
+                    // numbers (numeric separators stripped for C++).
+                    const thinPinFirst = { GPIO: true, PWM: true, ADC: true, DAC: true };
+                    if (thinPinFirst[className] && ctorArgs && ctorArgs.length >= 1) {
+                        const pinArg = ctorArgs[0];
+                        if (ts.isIdentifier(pinArg)) {
+                            // resolveHALReceiver seeds board-module pin constants (LED,
+                            // BUTTON, datasheet names) into halInstances on first lookup —
+                            // a plain halInstances.get() would miss them.
+                            const inst = halInstances.get(pinArg.text) ?? resolveHALReceiver(pinArg);
+                            fieldValues.set("_pin", inst?.fieldValues.get("_pin") ?? inst?.fieldValues.get("pin") ?? pinArg.text);
+                        }
+                        else {
+                            fieldValues.set("_pin", pinArg.getText());
+                        }
+                    }
+                    if (className === "GPIO" && ctorArgs && ctorArgs.length >= 2) {
+                        // "GPIO.OUTPUT | GPIO.PULL_UP" — the token text is the IR carrier.
+                        fieldValues.set("_flags", ctorArgs[1].getText());
+                    }
+                    const thinOptsCtor = { PWM: true, ADC: true, DAC: true, Counter: true };
+                    if (thinOptsCtor[className] && ctorArgs && ctorArgs.length >= 2 && ts.isObjectLiteralExpression(ctorArgs[1])) {
+                        for (const prop of ctorArgs[1].properties) {
+                            if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+                                continue;
+                            const name = prop.name.text;
+                            if (ts.isNumericLiteral(prop.initializer)) {
+                                fieldValues.set(`_${name}`, prop.initializer.text.replace(/_/g, ""));
+                            }
+                            else {
+                                // Token (ADC.GAIN_1_4) or runtime expression text.
+                                fieldValues.set(`_${name}`, prop.initializer.getText());
+                            }
+                        }
+                    }
+                    if (className === "Watchdog" && ctorArgs && ctorArgs.length >= 1 && ts.isNumericLiteral(ctorArgs[0])) {
+                        fieldValues.set("_timeoutMs", ctorArgs[0].text.replace(/_/g, ""));
+                    }
+                    // Thin File/Mqtt: the path / broker-uri + client-id facts.
+                    if (className === "File" && ctorArgs && ctorArgs.length >= 1 && ts.isStringLiteral(ctorArgs[0])) {
+                        fieldValues.set("_path", ctorArgs[0].text);
+                    }
+                    if (className === "Mqtt" && ctorArgs && ctorArgs.length >= 1 && ts.isStringLiteral(ctorArgs[0])) {
+                        fieldValues.set("_uri", ctorArgs[0].text);
+                        const mopts = ctorArgs[1];
+                        if (mopts && ts.isObjectLiteralExpression(mopts)) {
+                            for (const prop of mopts.properties) {
+                                if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)
+                                    && prop.name.text === "clientId" && ts.isStringLiteral(prop.initializer)) {
+                                    fieldValues.set("_clientId", prop.initializer.text);
+                                }
+                            }
+                        }
+                    }
+                    // Thin Store: the namespace is the construction fact (plain text —
+                    // the plugin case quotes it when composing the settings key).
+                    if (className === "Store" && ctorArgs && ctorArgs.length >= 1 && ts.isStringLiteral(ctorArgs[0])) {
+                        fieldValues.set("_ns", ctorArgs[0].text);
+                    }
+                    // Thin BLE: the advertised name is the construction fact.
+                    if (className === "BLE" && ctorArgs && ctorArgs.length >= 1 && ts.isStringLiteral(ctorArgs[0])) {
+                        fieldValues.set("_name", JSON.stringify(ctorArgs[0].text));
+                    }
+                    if (className === "Counter" && ctorArgs && ctorArgs.length >= 1 && ts.isNumericLiteral(ctorArgs[0])) {
+                        fieldValues.set("_instance", ctorArgs[0].text.replace(/_/g, ""));
+                    }
+                    // Thin WiFi station: first arg is the ssid literal; the opts carry
+                    // the link facts. Nested ipv4 facts flatten to _ipAddr/_gateway/
+                    // _netmask. Computed defaults (security ternary, timeoutMs ??) are
+                    // applied by the wifiJoin plugin case, not here.
+                    if (className === "WiFi" && ctorArgs && ctorArgs.length >= 1) {
+                        if (ts.isStringLiteral(ctorArgs[0])) {
+                            fieldValues.set("_ssid", JSON.stringify(ctorArgs[0].text));
+                        }
+                        else {
+                            fieldValues.set("_ssid", ctorArgs[0].getText());
+                        }
+                        const wopts = ctorArgs[1];
+                        if (wopts && ts.isObjectLiteralExpression(wopts)) {
+                            for (const prop of wopts.properties) {
+                                if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+                                    continue;
+                                const name = prop.name.text;
+                                if (name === "ipv4" && ts.isObjectLiteralExpression(prop.initializer)) {
+                                    for (const ip of prop.initializer.properties) {
+                                        if (!ts.isPropertyAssignment(ip) || !ts.isIdentifier(ip.name))
+                                            continue;
+                                        const ipName = ip.name.text;
+                                        const key = ipName === "addr" ? "_ipAddr" : `_${ipName}`;
+                                        if (ts.isStringLiteral(ip.initializer)) {
+                                            fieldValues.set(key, JSON.stringify(ip.initializer.text));
+                                        }
+                                        else {
+                                            fieldValues.set(key, ip.initializer.getText());
+                                        }
+                                    }
+                                }
+                                else if (name !== "powerSave") {
+                                    if (ts.isStringLiteral(prop.initializer)) {
+                                        fieldValues.set(`_${name}`, JSON.stringify(prop.initializer.text));
+                                    }
+                                    else if (ts.isNumericLiteral(prop.initializer)) {
+                                        fieldValues.set(`_${name}`, prop.initializer.text.replace(/_/g, ""));
+                                    }
+                                    else {
+                                        fieldValues.set(`_${name}`, prop.initializer.getText());
+                                    }
+                                }
+                                else {
+                                    // powerSave: WiFi.PS_OFF token → ps=1 flag (0 = default on).
+                                    const txt = prop.initializer.getText();
+                                    fieldValues.set("_ps", txt.includes("PS_OFF") ? "1" : "0");
+                                }
+                            }
+                        }
+                    }
+                    if (className === "Thread" && ctorArgs && ctorArgs.length >= 1 && ts.isNumericLiteral(ctorArgs[0])) {
+                        fieldValues.set("_index", ctorArgs[0].text.replace(/_/g, ""));
+                        // stackKb → bytes here (the class-body arithmetic is erased).
+                        const kbArg = ctorArgs.length >= 2 && ts.isObjectLiteralExpression(ctorArgs[1])
+                            ? ctorArgs[1].properties.find((p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === "stackKb")
+                            : undefined;
+                        const kb = kbArg && ts.isPropertyAssignment(kbArg) && ts.isNumericLiteral(kbArg.initializer)
+                            ? parseInt(kbArg.initializer.text.replace(/_/g, ""), 10) : 2;
+                        fieldValues.set("_stackBytes", String((isNaN(kb) ? 2 : kb) * 1024));
+                    }
+                    // Tier-2 thin buses. The first arg is the board's bus/port instance
+                    // export (I2C0/SPI0/UART1) — kept as text, which the lowerings'
+                    // parseControllerIndex reads; SPITarget adds the cs pin (identifier
+                    // or property access, resolved later like every pin arg); opts carry
+                    // the wire facts (hz/mode/baud).
+                    const thinBusFirst = { I2CTarget: true, SPITarget: true, UART: true };
+                    if (thinBusFirst[className] && ctorArgs && ctorArgs.length >= 1) {
+                        const busArg = ctorArgs[0];
+                        if (ts.isIdentifier(busArg)) {
+                            const inst = halInstances.get(busArg.text);
+                            fieldValues.set("_bus", inst?.fieldValues.get("_bus") ?? busArg.text);
+                            fieldValues.set("_port", inst?.fieldValues.get("_port") ?? inst?.fieldValues.get("_bus") ?? busArg.text);
+                        }
+                        else if (ts.isStringLiteral(busArg)) {
+                            fieldValues.set("_bus", busArg.text);
+                            fieldValues.set("_port", busArg.text);
+                        }
+                        else {
+                            fieldValues.set("_bus", busArg.getText());
+                            fieldValues.set("_port", busArg.getText());
+                        }
+                    }
+                    if (className === "SPITarget" && ctorArgs && ctorArgs.length >= 2) {
+                        const csArg = ctorArgs[1];
+                        if (ts.isIdentifier(csArg)) {
+                            const inst = halInstances.get(csArg.text);
+                            fieldValues.set("_cs", inst?.fieldValues.get("_pin") ?? inst?.fieldValues.get("pin") ?? csArg.text);
+                        }
+                        else {
+                            fieldValues.set("_cs", csArg.getText());
+                        }
+                    }
+                    if (className === "I2CTarget" && ctorArgs && ctorArgs.length >= 2 && ts.isNumericLiteral(ctorArgs[1])) {
+                        fieldValues.set("_address", ctorArgs[1].text);
+                    }
+                    const thinBusOpts = { I2CTarget: true, SPITarget: true, UART: true, Thread: true };
+                    if (thinBusOpts[className] && ctorArgs && ctorArgs.length >= 2) {
+                        // I2CTarget/UART: (bus, opts?); SPITarget: (bus, cs, opts?).
+                        const optsArg = ctorArgs.length === 2 ? ctorArgs[1] : ctorArgs[2];
+                        if (optsArg && ts.isObjectLiteralExpression(optsArg)) {
+                            for (const prop of optsArg.properties) {
+                                if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+                                    continue;
+                                const name = prop.name.text;
+                                if (ts.isNumericLiteral(prop.initializer)) {
+                                    fieldValues.set(`_${name}`, prop.initializer.text.replace(/_/g, ""));
+                                }
+                                else {
+                                    fieldValues.set(`_${name}`, prop.initializer.getText());
+                                }
+                            }
+                        }
+                    }
+                    // Thin-class field DEFAULTS (the singleton __default_fields channel
+                    // does not reach constructed instances). Fill only absent fields —
+                    // an omitted opts object must resolve to these sentinels, not leak
+                    // `this->_gain` text into the ops (string args pass through raw).
+                    const thinFieldDefaults = {
+                        ADC: { _gain: "", _reference: "" },
+                        I2CTarget: { _hz: "0" },
+                        SPITarget: { _hz: "1000000", _mode: "0" },
+                        UART: { _baud: "115200", _rxBufferBytes: "64" },
+                        DAC: { _resolution: "0" },
+                    };
+                    // WiFi absent-fact sentinels: fields whose class initializer is
+                    // `opts.x?.y` render as raw `this->_x` when the fact was omitted.
+                    // "undefined" is what dropUndefined() strips at the plugin case,
+                    // so the op omits the fact entirely.
+                    if (className === "WiFi") {
+                        const wifiDefaults = {
+                            _psk: "undefined", _ipAddr: "undefined", _gateway: "undefined",
+                            _netmask: "undefined", _timeoutMs: "15000", _channel: "0",
+                            _band: "0", _ps: "0",
+                        };
+                        for (const [k, v] of Object.entries(wifiDefaults)) {
+                            if (!fieldValues.has(k))
+                                fieldValues.set(k, v);
+                        }
+                    }
+                    const thinDefs = thinFieldDefaults[className];
+                    if (thinDefs) {
+                        for (const [k, v] of Object.entries(thinDefs)) {
+                            if (!fieldValues.has(k))
+                                fieldValues.set(k, v);
+                        }
                     }
                     if (ctorArgs) {
                         // Resolve a Pin-identifier ctor arg to its _pin number, for any HAL
@@ -503,8 +754,8 @@ export function variableStatementToIR(statement, fileName, sourceText, diagnosti
                 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
+                    // (`return new Uint8Array(count)` in buffer-returning device
+                    // methods). 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
@@ -568,9 +819,16 @@ export function variableStatementToIR(statement, fileName, sourceText, diagnosti
                         const instance = resolveHALReceiver(receiver);
                         const fieldValues = new Map(instance?.fieldValues || []);
                         // For device() factory calls, copy the address/cs from the call arg
-                        // so I2CDevice/SPIDevice methods can resolve this._address / this._cs.
-                        if (result.returnClassName === "I2CDevice" || result.returnClassName === "SPIDevice") {
-                            const fieldName = result.returnClassName === "SPIDevice" ? "_cs" : "_address";
+                        // so I2CTarget/SPITarget methods can resolve this._address / this._cs.
+                        if (result.returnClassName === "I2CTarget" || result.returnClassName === "SPITarget") {
+                            const isSpiTarget = result.returnClassName === "SPITarget";
+                            const fieldName = isSpiTarget ? "_cs" : "_address";
+                            // The targets' __default_fields channel does not reach factory
+                            // results; carry the wire defaults so this._hz / this._mode
+                            // resolve in the inlined method bodies.
+                            fieldValues.set("_hz", isSpiTarget ? "1000000" : "0");
+                            if (isSpiTarget)
+                                fieldValues.set("_mode", "0");
                             const firstArg = init.arguments?.[0];
                             if (firstArg) {
                                 if (ts.isNumericLiteral(firstArg))
@@ -585,19 +843,6 @@ 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,
@@ -634,11 +879,16 @@ export function variableStatementToIR(statement, fileName, sourceText, diagnosti
                         }
                     }
                     if (result.returnValue && result.returnValue !== "this") {
+                        const lastOp = result.halOps[result.halOps.length - 1];
+                        // A double-returning HAL op makes the captured var floating
+                        // (sensor.get → val1 + val2/1e6): the snprintf specifier picker
+                        // reads floatVariables and must pick %g, not %d.
+                        if (lastOp && lastOp.operation === "sensor.get")
+                            registerFloatVariable(varName);
                         if (isHalOpReturn) {
-                            const lastOp = result.halOps[result.halOps.length - 1];
                             lowered.push({
                                 kind: "var_decl",
-                                sourceSpan: makeSourceSpan(declaration, fileName, sourceText),
+                                sourceSpan: makeSourceSpan(declaration.initializer, fileName, sourceText),
                                 leadingComments: commentsAssigned ? [] : statementComments.leadingComments,
                                 trailingComments: [],
                                 name: varName,
@@ -703,11 +953,20 @@ export function variableStatementToIR(statement, fileName, sourceText, diagnosti
                 }
             }
         }
+        // A typed-array buffer declared `const` stays writable storage: HAL fills
+        // write through it (e.g. spi.transceive's rx buffer), so the emitted C
+        // array must not be const — mirroring the __TYPED_ARRAY__ return branch.
+        // Keeping the source storage would split the definition (`uint8_t id[]`,
+        // the array renderer drops the qualifier) from the split-mode extern
+        // (`extern const uint8_t id[]`) — a conflicting declaration.
+        let effectiveStorage = storage;
         if (actualInitializer && ts.isNewExpression(actualInitializer)) {
             const ctorText = actualInitializer.expression && ts.isIdentifier(actualInitializer.expression)
                 ? actualInitializer.expression.text : "";
             if (TYPED_ARRAY_ELEMENT_MAP[ctorText] && ts.isIdentifier(declaration.name)) {
                 activeCArrayVars.add(declaration.name.text);
+                if (effectiveStorage === "const")
+                    effectiveStorage = "let";
             }
         }
         let lambdaInitializer;
@@ -742,7 +1001,7 @@ export function variableStatementToIR(statement, fileName, sourceText, diagnosti
             leadingComments: commentsAssigned ? [] : statementComments.leadingComments,
             trailingComments: commentsAssigned ? [] : statementComments.trailingComments,
             name: declaration.name.text,
-            storage,
+            storage: effectiveStorage,
             cppType: "auto",
             isVolatile,
             initializer: lambdaInitializer ?? (actualInitializer
@@ -1161,3 +1420,40 @@ export function collectPointerVars(statements) {
     }
     return pointerVars;
 }
+/**
+ * Resolve the second `new Sensor(part, <dev>)` argument to an I2C bus name +
+ * 7-bit address. Accepts the inline factory form `I2C1.device(0x44)` and an
+ * identifier previously bound to one (`const dev = I2C1.device(0x44)`). The
+ * general receiver resolution carries the bus fields through `device()`'s
+ * I2CTarget return type; the inline form's address is taken from the call's
+ * numeric argument (the general path does not extract call args).
+ */
+function resolveSensorDeviceArg(arg) {
+    const inst = resolveHALReceiver(arg);
+    const portField = inst?.className === "SPITarget" ? "_cs" : "_address";
+    if (inst && (inst.className === "I2CTarget" || inst.className === "SPITarget") && inst.fieldValues.has("_bus") && inst.fieldValues.has(portField)) {
+        return { bus: inst.fieldValues.get("_bus"), port: inst.fieldValues.get(portField), kind: inst.className === "SPITarget" ? "spi" : "i2c" };
+    }
+    // Inline bus.device(<port>) call: the general receiver path carries the bus
+    // fields through device()'s return type but drops the argument — take the
+    // port from the call's numeric literal.
+    if (ts.isCallExpression(arg) && ts.isPropertyAccessExpression(arg.expression) && arg.expression.name.text === "device") {
+        const args = arg.arguments ?? [];
+        const numericArg = args.find((a) => ts.isNumericLiteral(a));
+        // SPI CS arrives as a pin identifier (SPI0.device(PA4)) — resolve it to
+        // its number the same way the device() chain path does.
+        const pinArg = args.find((a) => ts.isIdentifier(a));
+        const pinInst = pinArg && ts.isIdentifier(pinArg) ? halInstances.get(pinArg.text) : undefined;
+        const portText = numericArg && ts.isNumericLiteral(numericArg)
+            ? numericArg.text
+            : (pinInst?.fieldValues.get("_pin") ?? pinInst?.fieldValues.get("pin"));
+        if (inst && inst.fieldValues.has("_bus") && portText !== undefined) {
+            // The bus kind follows the receiver's resolved class when it round-
+            // tripped; otherwise infer from the bus alias (SPI/SPI<n> vs Wire).
+            const busName = inst.fieldValues.get("_bus");
+            const kind = inst.className === "SPITarget" || /^SPI/.test(busName) ? "spi" : "i2c";
+            return { bus: busName, port: portText, kind };
+        }
+    }
+    return null;
+}

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

@@ -3,7 +3,8 @@
 //
 // Validates that try/catch and throw statements are not used on architectures
 // that do not support C++ exceptions. The platform strategy determines which
-// architectures have exceptions disabled (e.g. AVR-GCC with -fno-exceptions).
+// architectures have exceptions disabled (e.g. Zephyr with
+// CONFIG_CPP_EXCEPTIONS=n).
 // ---------------------------------------------------------------------------
 /**
  * Validate that try/catch and throw statements are not used on
@@ -34,7 +35,7 @@ export function validateTryCatch(program, boardConstants, strategy) {
                 severity: 'error',
                 code: 'try-catch-unsupported',
                 message: `try/catch is not supported on ${arch.toUpperCase()} targets. ` +
-                    `AVR-GCC disables C++ exceptions (-fno-exceptions) and the generated ` +
+                    `C++ exceptions are disabled (-fno-exceptions) on this target and the generated ` +
                     `code will not compile. Use return-code error checking instead.`,
                 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,
@@ -53,7 +54,7 @@ export function validateTryCatch(program, boardConstants, strategy) {
                 severity: 'error',
                 code: 'try-catch-unsupported',
                 message: `throw is not supported on ${arch.toUpperCase()} targets. ` +
-                    `AVR-GCC disables C++ exceptions (-fno-exceptions). ` +
+                    `C++ exceptions are disabled (-fno-exceptions) on this target. ` +
                     `Use return codes or error flags instead.`,
                 hint: `return null;  // or return an error code`,
                 line: stmt.sourceSpan?.startLine,

package/dist/ir/type-resolution.js

@@ -38,7 +38,7 @@ const BUS_INTERFACE_TYPE_NAMES = new Set([
     "I2CAddress", "SPITransferOptions",
 ]);
 const STRATEGY_TYPE_NAMES = new Set([
-    "NativeStrategy", "ArduinoStrategy", "BoardStrategy",
+    "NativeStrategy", "ZephyrStrategy", "BoardStrategy",
     "RuntimePolyfillIR", "PeripheralUsage",
 ]);
 const BOARD_CONSTANT_TYPE_NAMES = new Set([
@@ -50,7 +50,8 @@ const OWNERSHIP_WRAPPER_TYPE_NAMES = new Set([
 ]);
 /** Safety wrapper types: like ownership wrappers (phantom TS types that carry
  *  a type parameter), but instead of stripping the wrapper, the C++ keeps it
- *  as a template instantiation: SafeVariable<number> → SafeVariable<int32_t>.
+ *  as a template instantiation: SafeVariable<number> → SafeVariable<double>,
+ *  SafeInt<number> → SafeInt<int32_t> (integer-only by contract).
  *  The C++ template definition is provided by the safety polyfill. */
 const SAFE_WRAPPER_TYPE_NAMES = new Set([
     "SafeVariable",
@@ -158,10 +159,20 @@ export function typeNodeToCppType(node, typeAliases, typeParametersInScope) {
         // SafeVariable<T> is a safety wrapper: unlike ownership wrappers (which
         // strip the wrapper name entirely), SafeVariable keeps the wrapper name
         // in the C++ type because the polyfill provides a template definition.
-        // SafeVariable<number> → SafeVariable<int> (the template is emitted by
-        // the safety polyfill's helperStructs).
+        // SafeVariable<number> → SafeVariable<double> (the keyword's general
+        // mapping; the polyfill ships float/double specializations).
         if (SAFE_WRAPPER_TYPE_NAMES.has(wrapperName)) {
             const innerTypeNode = node.typeArguments?.[0];
+            // SafeInt is signed-integer-only by contract — its polyfill carries a
+            // static_assert rejecting floating-point T. The TS `number` keyword
+            // (and SafeInt's implicit `T = number` default) therefore resolves to
+            // int32_t, NOT the general number→double mapping. An explicit float /
+            // double annotation still passes through so the static_assert fires as
+            // designed.
+            if (wrapperName === "SafeInt" &&
+                (innerTypeNode === undefined || innerTypeNode.kind === ts.SyntaxKind.NumberKeyword)) {
+                return "SafeInt<int32_t>";
+            }
             const innerCppType = typeNodeToCppType(innerTypeNode, typeAliases, typeParametersInScope);
             return `${wrapperName}<${innerCppType}>`;
         }

package/dist/ir/validation-orchestrator.js

@@ -1,7 +1,6 @@
 import { resolveStrategy } from "../platform/registry.js";
 import { hasLoadedFramework, getLoadedFramework } from "../framework-registry.js";
 import { analyzeInterruptSafety, inferVolatileForIsrSharedVars, detectReentrancyRisk } from "./interrupt-analysis.js";
-import { analyzeWorkerIsolation } from "./worker-analysis.js";
 import { validateADCRange } from "./adc-range-validation.js";
 import { createEmptyPeripheralUsage } from "./peripheral-usage.js";
 import { validatePeripherals } from "./peripheral-validation.js";
@@ -11,8 +10,6 @@ import { validatePinAliasConflicts } from "./pin-alias-conflict.js";
 import { validatePinModeConfig } from "./pin-mode-validation.js";
 import { validateUnsafePins } from "./pin-safety.js";
 import { validatePulldownSupport } from "./pulldown-validation.js";
-import { validatePWMTimerSharing } from "./pwm-timer-sharing.js";
-import { validateTimer0PWMTimingConflict } from "./timer0-pwm-timing-conflict.js";
 import { validateTryCatch } from "./try-catch-validation.js";
 import { validateMemoryBudget } from "./memory-budget-validation.js";
 import { validateBlockingDelayInLoop } from "./timing-validation.js";
@@ -29,16 +26,10 @@ export function runProgramValidations(program, strategy) {
     diagnostics.push(...validateUnsafePins(peripheralUsage, program.boardConstants, program.fileName));
     diagnostics.push(...analyzeResources(program, resolvedStrategy));
     diagnostics.push(...validatePinAliasConflicts(peripheralUsage, program.boardConstants, program.fileName));
-    diagnostics.push(...validatePWMTimerSharing(peripheralUsage, program.boardConstants, program.fileName));
-    diagnostics.push(...validateTimer0PWMTimingConflict(peripheralUsage, program.boardConstants, program.fileName));
     diagnostics.push(...validatePulldownSupport(peripheralUsage, program.boardConstants, program.fileName));
     diagnostics.push(...analyzeInterruptSafety(program, peripheralUsage, resolvedStrategy.isrUnsafeOperations?.()));
     inferVolatileForIsrSharedVars(program, diagnostics);
     detectReentrancyRisk(program, diagnostics);
-    // Worker isolation: bus access in workers is a hard error; worker-shared
-    // globals get volatile promotion (info) or a data-race warning. Only fires
-    // when worker.submit ops are present, so non-worker programs are unaffected.
-    analyzeWorkerIsolation(program, diagnostics);
     diagnostics.push(...validateADCRange(program, program.boardConstants));
     diagnostics.push(...validateUnitSuspicion(program));
     diagnostics.push(...validatePinModeConfig(program));

package/dist/libdef/cpp-to-decl.d.ts

@@ -32,12 +32,3 @@ export declare function generateDeclsForDirectory(dir: string, recursive?: boole
  * a later step for the directory-scan path.
  */
 export declare function generateDecl(filePath: string, outputPath?: string): string | null;
-import { type ComponentScanRoots } from "./component-discovery.js";
-/**
- * Generate .d.ts declarations for every declared component's headers,
- * picking the C or C++ emitter per header based on whether it declares classes.
- *
- * Returns the list of created/updated .d.ts paths (headers that produced no
- * declarations are skipped).
- */
-export declare function generateComponentDeclsForProject(projectDir: string, roots: ComponentScanRoots): string[];