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

package/dist/ir/heap-analysis.js

@@ -6,36 +6,7 @@
 // optimizations and runtime behavior.
 // ---------------------------------------------------------------------------
 import { parseCppType, renderCppType, bareType } from "../api/shared/cpp-type-ir.js";
-/** Type sizes for common C++ types on AVR (8-bit) and ESP32 (32-bit) */
-const AVR_TYPE_SIZES = {
-    bool: 1,
-    char: 1,
-    "unsigned char": 1,
-    "signed char": 1,
-    uint8_t: 1,
-    int8_t: 1,
-    byte: 1,
-    short: 2,
-    "unsigned short": 2,
-    int16_t: 2,
-    uint16_t: 2,
-    int: 2,
-    "unsigned int": 2,
-    int32_t: 4,
-    uint32_t: 4,
-    long: 4,
-    "unsigned long": 4,
-    int64_t: 8,
-    uint64_t: 8,
-    float: 4,
-    double: 4,
-    "long long": 8,
-    size_t: 2,
-    ptrdiff_t: 2,
-    pointer: 2,
-    "char*": 2,
-    "const char*": 2,
-};
+/** Type sizes for common C++ types on 32-bit targets */
 const ESP32_TYPE_SIZES = {
     bool: 1,
     char: 1,
@@ -69,14 +40,6 @@ const ESP32_TYPE_SIZES = {
  * Determine the type size table based on the target architecture.
  */
 function getTypeSizes(architecture) {
-    const arch = (architecture ?? "").toLowerCase();
-    if (arch === "avr" || arch === "atmega328p" || arch === "atmega2560") {
-        return AVR_TYPE_SIZES;
-    }
-    if (arch === "esp32" || arch === "esp32s3" || arch === "esp32c3" || arch === "esp32c6" || arch === "xtensa" || arch === "riscv32") {
-        return ESP32_TYPE_SIZES;
-    }
-    // Default to ESP32 sizes (more conservative for 32-bit targets)
     return ESP32_TYPE_SIZES;
 }
 /**
@@ -335,9 +298,7 @@ export function analyzeHeapUsage(program, architecture, callGraphNodes) {
     // Add notes about approximations
     notes.push("Heap estimate is static only — dynamic allocations (malloc/new) are not tracked.");
     notes.push("String literals may be deduplicated by the compiler/linker.");
-    notes.push(architecture === "avr"
-        ? "AVR sizes: int=2 bytes, pointer=2 bytes, float=4 bytes."
-        : `Default sizes: int=${typeSizes.int ?? "?"} bytes, pointer=${typeSizes.pointer ?? "?"} bytes, float=${typeSizes.float ?? "?"} bytes.`);
+    notes.push(`Default sizes: int=${typeSizes.int ?? "?"} bytes, pointer=${typeSizes.pointer ?? "?"} bytes, float=${typeSizes.float ?? "?"} bytes.`);
     return {
         globalVariables,
         structSizes,

package/dist/ir/identifier-collector.js

@@ -252,14 +252,20 @@ export function collectStatementIdentifiers(statement) {
                 }
             }
             break;
-        case "assign":
+        case "assign": {
             identifiers.add(statement.target);
+            // An element-access target (`buf[i] = x`) references the base array;
+            // extract it so the buffer's var_decl survives tree-shaking (the raw
+            // `buf[i]` string never matches a declaration named `buf`).
+            addElementAccessBase(statement.target, identifiers);
             for (const id of collectExpressionIdentifiers(statement.value)) {
                 identifiers.add(id);
             }
             break;
+        }
         case "update":
             identifiers.add(statement.target);
+            addElementAccessBase(statement.target, identifiers);
             break;
         case "return":
             if (statement.value) {
@@ -414,12 +420,18 @@ export function collectStatementIdentifiers(statement) {
 /**
  * Extract identifier names from a HAL operation's string fields.
  * This ensures the call graph tracks function references embedded in
- * semantic HAL ops (e.g. the handler name in interrupt.attach).
+ * semantic HAL ops (e.g. the handler name in interrupt.attach_flags).
  */
+/** Record the base identifier of an element-access lvalue (`buf[i]` → `buf`). */
+function addElementAccessBase(target, identifiers) {
+    const base = /^([A-Za-z_][A-Za-z0-9_]*)\s*\[/.exec(target);
+    if (base)
+        identifiers.add(base[1]);
+}
 function collectHALOpIdentifiers(op) {
     const identifiers = new Set();
     switch (op.operation) {
-        case "interrupt.attach":
+        case "interrupt.attach_flags":
             // handler is a resolved C++ function name (e.g. "myIsr" or a placeholder)
             identifiers.add(op.handler);
             break;
@@ -427,7 +439,7 @@ function collectHALOpIdentifiers(op) {
             // handler is the user's onMessage callback name (callback() resolves it to
             // a string). Without this the tree-shaker drops the function declaration —
             // the mqtt.on_message op only carries the name, so the function has no
-            // other reference and looks unreachable. Same shape as interrupt.attach.
+            // other reference and looks unreachable. Same shape as interrupt.attach_flags.
             identifiers.add(op.handler);
             break;
         case "wifi.on_event":
@@ -451,22 +463,22 @@ function collectHALOpIdentifiers(op) {
         }
         // Other HAL ops have only numeric/literal fields — no identifier references
     }
-    // wifi.* / http.* / mqtt.* ops carry resolved C++ expression texts in their
-    // string fields (e.g. wifi.connect ssid: `WIFI_SSID` — a top-level const, or
-    // a quoted literal). Scan every string field for identifiers so referenced
-    // globals survive tree-shaking; quoted literals are skipped.
-    if (op.operation.startsWith("wifi.") || op.operation.startsWith("http.")
-        || op.operation.startsWith("mqtt.")) {
-        for (const value of Object.values(op)) {
-            if (typeof value !== "string" || value === op.operation)
-                continue;
-            if (/^".*"$/.test(value.trim()))
-                continue;
-            const matches = value.match(/[A-Za-z_][A-Za-z0-9_]*/g);
-            if (matches) {
-                for (const match of matches) {
-                    identifiers.add(match);
-                }
+    // HAL ops can carry resolved C++ expression texts in their string fields —
+    // not just wifi/http/mqtt (e.g. wifi.connect ssid: `WIFI_SSID`, a top-level
+    // const) but also peripheral lowerings that inline a user buffer into the
+    // emitted code (spi.transceive rx: `static_cast<const void*>(id)`). Scan
+    // every string field of every op for identifiers so referenced variables
+    // survive tree-shaking; quoted literals are skipped. Over-matching is safe
+    // (the reachability set just keeps a name no var_decl uses).
+    for (const value of Object.values(op)) {
+        if (typeof value !== "string" || value === op.operation)
+            continue;
+        if (/^".*"$/.test(value.trim()))
+            continue;
+        const matches = value.match(/[A-Za-z_][A-Za-z0-9_]*/g);
+        if (matches) {
+            for (const match of matches) {
+                identifiers.add(match);
             }
         }
     }

package/dist/ir/network-validation.js

@@ -11,7 +11,7 @@
 //   wifi-blocking-in-loop     (warning) blocking WiFi.connect()/scan() or
 //                                       Http send inside loop() — stalls every
 //                                       iteration; use async/await instead.
-//   wifi-ap-password-short    (error)   WiFi.startAP() with a literal WPA2
+//   wifi-ap-password-short    (error)   WiFiAP with a literal WPA2
 //                                       password shorter than 8 characters —
 //                                       esp_wifi rejects it at runtime.
 //   http-max-body-large       (warning) Http maxBody() above 64 KB — the
@@ -23,20 +23,16 @@
 import { walkProgramIR, walkNestedStatements } from "./utils/walk-ir.js";
 /** Architectures with no WiFi radio. Driven by the `architecture` board
  *  constant (from the MCU package); absent data emits nothing. */
-const NO_RADIO_ARCHITECTURES = new Set(["avr"]);
+const NO_RADIO_ARCHITECTURES = new Set();
 /** Ops that bring the WiFi link (STA or AP) up. */
 const LINK_UP_OPS = new Set([
-    "wifi.connect",
+    "wifi.join",
     "wifi.connect_start",
-    "wifi.connect_saved",
     "wifi.ap_start",
 ]);
 /** Blocking waits that stall loop() for their full duration. */
 const BLOCKING_LOOP_OPS = new Set([
-    "wifi.connect",
-    "wifi.connect_saved",
-    "wifi.wait_connected",
-    "wifi.wait_disconnected",
+    "wifi.join",
     "wifi.scan",
     "http.send",
 ]);
@@ -117,7 +113,7 @@ export function validateNetworkUsage(program, boardConstants) {
             severity: "error",
             code: "wifi-no-radio",
             message: `WiFi/HTTP APIs are used but the target board's architecture ('${archName}') has no WiFi radio.`,
-            hint: "Target a WiFi-capable board (e.g. @typecad/board-esp32-devkit) or remove the WiFi/HTTP calls.",
+            hint: "Target a WiFi-capable board (e.g. esp32_devkitc/esp32/procpu) or remove the WiFi/HTTP calls.",
         }));
         // No point piling on the remaining checks for a board that can't radio.
         return diagnostics;
@@ -128,7 +124,7 @@ export function validateNetworkUsage(program, boardConstants) {
             severity: "warning",
             code: "http-without-wifi",
             message: "HTTP requests are made but the program never brings the WiFi link up — every request will fail at runtime.",
-            hint: "Call WiFi.connect(ssid, password) (or WiFi.connectSaved() / WiFi.startAP()) before sending HTTP requests.",
+            hint: "Join a network first — new WiFi(ssid, { psk}).join() (or a WiFiAP) — before sending HTTP requests.",
         }));
     }
     // ── wifi-blocking-in-loop ────────────────────────────────────────────────
@@ -161,7 +157,7 @@ export function validateNetworkUsage(program, boardConstants) {
             diagnostics.push(diagAt(stmt, {
                 severity: "error",
                 code: "wifi-ap-password-short",
-                message: `WiFi.startAP() password is ${password.length} characters — WPA2 requires at least 8, and esp_wifi rejects shorter ones at runtime.`,
+                message: `WiFiAP password is ${password.length} characters — WPA2 requires at least 8, and the driver rejects shorter ones at runtime.`,
                 hint: "Use a password of 8+ characters, or omit the password entirely for an open access point.",
             }));
         }

package/dist/ir/ownership-analysis.js

@@ -811,6 +811,18 @@ function validateConstSuggestions(program, diagnostics) {
         // Set.add() -> insert, Map/Set.delete() -> erase (demo #15 fix C)
         'insert', 'erase',
     ]);
+    // Safety wrapper types (SafeVariable/SafeInt) mutate only through method
+    // calls — the C++ members are non-const by design. Kept separate from
+    // MUTATING_METHODS because these names ('set', 'add', ...) are matched
+    // ONLY against receivers whose declared cppType is a safety wrapper, so
+    // unrelated user classes with same-named methods are unaffected.
+    const SAFETY_WRAPPER_MUTATING_METHODS = new Set([
+        // SafeVariable<T>
+        'set',
+        // SafeInt<T> mutating chain
+        'add', 'sub', 'mul', 'divide', 'mod', 'negate', 'absValue', 'reset',
+    ]);
+    const isSafetyWrapperCppType = (cppType) => typeof cppType === 'string' && (cppType.startsWith('SafeInt') || cppType.startsWith('SafeVariable'));
     // Every lexical statement body in the program. Demotion (const-content-
     // mutated) and the suggest-const global-assignment scan must reach class
     // methods, getters, setters, constructors, and namespace-scoped functions —
@@ -852,6 +864,14 @@ function validateConstSuggestions(program, diagnostics) {
     };
     for (const ns of program.namespaces)
         collectNamespaceBodies(ns);
+    // Callbacks registered out-of-band (interrupt handlers, Thread.start,
+    // watchPin / drawCanvas bodies) carry their statements on the callback
+    // expression rather than in a function body. A top-level `let` mutated
+    // only inside one must not be const-suggested — the emitted `const`
+    // makes g++ reject the assignment.
+    for (const rc of program.registeredCallbacks ?? []) {
+        allStatementBodies.push(rc.callbackIR.statements);
+    }
     // Collect every plain-identifier assignment / update target across the whole
     // program. A `let` declared in one scope may be reassigned by a *different*
     // function that closes over it (e.g. a top-level `let counter` reassigned in
@@ -1031,6 +1051,32 @@ function validateConstSuggestions(program, diagnostics) {
                                 });
                             }
                         }
+                        // Safety wrapper mutation: match on the LEADING identifier of the
+                        // callee — chained calls arrive as partially-rendered callees
+                        // (e.g. `count.add(5).mul`) whose receiver segment is not a bare
+                        // identifier — and gate on the receiver's declared safety cppType
+                        // so same-named methods on non-safety types are untouched.
+                        if (SAFETY_WRAPPER_MUTATING_METHODS.has(method)) {
+                            const baseDot = callee.indexOf('.');
+                            const base = baseDot > 0 ? callee.slice(0, baseDot) : receiver;
+                            const letEntry = letVars.get(base);
+                            if (letEntry && isSafetyWrapperCppType(letEntry.stmt.cppType)) {
+                                letEntry.everAssigned = true;
+                            }
+                            const constEntry = constVars.get(base);
+                            if (constEntry && constEntry.stmt.storage === 'const' && isSafetyWrapperCppType(constEntry.stmt.cppType)) {
+                                constEntry.stmt.storage = 'let';
+                                diagnostics.push({
+                                    severity: 'info',
+                                    message: `'${base}' is declared 'const' but is mutated via .${method}() — demoted to non-const in C++ so the mutation compiles.`,
+                                    line: constEntry.span.startLine,
+                                    column: constEntry.span.startColumn,
+                                    filePath: constEntry.span.filePath,
+                                    code: 'ownership-const-content-mutated',
+                                    source: 'ownership-analysis',
+                                });
+                            }
+                        }
                     }
                 }
                 // Recurse into nested statements (shares this scope's maps — a nested
@@ -1045,24 +1091,40 @@ function validateConstSuggestions(program, diagnostics) {
         // Promote `let` bindings that are never reassigned (in this scope or any
         // other) to `const` in the emitted C++. The transpiler's whole-program
         // reassignment analysis proves the binding is never written after init —
-        // information avr-gcc cannot recover across translation units. Emitting
+        // information the compiler cannot recover across translation units. Emitting
         // `const` lets the compiler place the value in flash/ROM and enables
         // constant folding. The inverse demotion (const→let when a member is
         // mutated) already mutates `.storage` the same way (see above), so the
         // emit path already handles both directions.
         for (const entry of letVars.values()) {
-            if (!entry.everAssigned && !globallyAssignedNames.has(entry.name)) {
-                entry.stmt.storage = 'const';
-                diagnostics.push({
-                    severity: 'info',
-                    message: `'${entry.name}' is never reassigned — emitted as \`const\` so the C++ compiler can place it in ROM and fold it.`,
-                    line: entry.span.startLine,
-                    column: entry.span.startColumn,
-                    filePath: entry.span.filePath,
-                    code: 'ownership-suggest-const',
-                    source: 'ownership-analysis',
-                });
-            }
+            if (entry.everAssigned || globallyAssignedNames.has(entry.name))
+                continue;
+            // Safety wrapper declarations mutate exclusively through method calls
+            // (.set/.add/...), and chained mutating calls render as callee text the
+            // reassignment walk cannot fully parse — non-mutation cannot be proven
+            // for these types, so they are never promoted (a promoted `const
+            // SafeVariable` / `const SafeInt` rejects every mutating member in g++).
+            if (isSafetyWrapperCppType(entry.stmt.cppType))
+                continue;
+            // A typed-array buffer (`const id = new Uint8Array(N)`, forced to let at
+            // IR build) lowers with a pointer cppType + array initializer. HAL fills
+            // write through it opaquely — the lowered C++ embeds the buffer name in
+            // hal-op text (e.g. spi.transceive's rx), which the reassignment walk
+            // above cannot see. Promoting it to const would make the HAL fill
+            // undefined behavior and disagree with the array-shaped definition.
+            const bufferInit = entry.stmt.initializer;
+            if (bufferInit?.kind === 'array' && /\*\s*$/.test(entry.stmt.cppType ?? ''))
+                continue;
+            entry.stmt.storage = 'const';
+            diagnostics.push({
+                severity: 'info',
+                message: `'${entry.name}' is never reassigned — emitted as \`const\` so the C++ compiler can place it in ROM and fold it.`,
+                line: entry.span.startLine,
+                column: entry.span.startColumn,
+                filePath: entry.span.filePath,
+                code: 'ownership-suggest-const',
+                source: 'ownership-analysis',
+            });
         }
     };
     for (const body of allStatementBodies)

package/dist/ir/peripheral-usage.d.ts

@@ -9,8 +9,6 @@ export interface PeripheralUsage {
     pwm: boolean;
     /** External interrupts are used (attachInterrupt on D2, D3) */
     externalInterrupts: boolean;
-    /** Timer0-based timing is used (millis, micros) */
-    timer0: boolean;
     /** I2C bus is used */
     i2c: boolean;
     /** SPI bus is used */
@@ -31,6 +29,14 @@ export interface PeripheralUsage {
     inputPulldownPins: Set<number>;
     /** Specific I2C bus instances used (0 for I2C0, 1 for I2C1, etc.) */
     i2cInstancesUsed: Set<number>;
+    /** DT-bound sensor parts used (generic catalog, hal/sensor.ts) */
+    sensor: boolean;
+    /** Distinct sensors used: `${part}|${busInstance}|${address}` keys — feeds
+     *  the framework's per-sensor DT node + device-handle emission. */
+    sensorPartsUsed: Set<string>;
+    /** Distinct thin SPI targets used: `${bus}|${cs}|${hz}|${mode}` keys —
+     *  feeds the per-target DT child node + spi_dt_spec emission. */
+    spiTargetsUsed: Set<string>;
     /** Specific SPI bus instances used (0 for SPI0, 1 for SPI1, etc.) */
     spiInstancesUsed: Set<number>;
     /** Specific UART instances used (0 for UART0/Serial, 1 for UART1/Serial1, etc.) */