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

package/dist/ir/board-resolver.d.ts

@@ -6,31 +6,26 @@ export type { BoardConstants };
  */
 export declare function getDefaultBoardConstants(): BoardConstants;
 /**
- * Parse a TypeScript board-definition source file and return a flat map of
- * all compile-time constant scalar values exported as a `BoardDefinition`.
- *
- * Properties whose values are arrays, spread elements, or other non-literal
- * expressions are silently skipped (no partial constant maps for board pins
- * etc. are needed by the emitter).
- *
- * @param defFilePath  Absolute path to the board definition `index.ts`.
+ * Locate the project-local generated board module by walking up from a
+ * source file. A project carries `.cuttlefish/board.ts` + `board.json`
+ * (generated by the framework's board generator — see boardgen in
+ * framework-zephyr) instead of a board package.
  */
-export declare function resolveBoardConstants(defFilePath: string): BoardConstants;
+export declare function findGeneratedBoard(fromFile: string): {
+    boardTs: string;
+    boardJson: string;
+} | undefined;
 /**
- * Given a source file path and a relative import module specifier, check
- * whether the import resolves to a TypeCAD board-definition package
- * (path pattern: /code/board-*\/index.ts).
- *
- * Returns the absolute path to the board index.ts on match, otherwise
- * undefined.
+ * Read a generated board.json manifest into BoardConstants. The manifest is
+ * `{ version, identifier, soc, tier, pinNames, constants: {dot-path → value} }`
+ * — the `constants` object IS the flat map.
  */
-export declare function tryResolveBoardDefFile(fromFile: string, moduleSpecifier: string, boardPackage?: string): string | undefined;
+export declare function readGeneratedBoardConstants(boardJsonPath: string): BoardConstants;
 /**
- * Resolve the framework-specific build target (e.g. Arduino FQBN) from the
- * board package's manifest.
- *
- * @param boardPackage  Board package identifier or path.
- * @param configPath    Path to the project config file (for relative resolution).
- * @param framework     Target framework name (default: 'arduino').
+ * Given a source file path and an import module specifier, return the path
+ * of the generated board.json manifest the specifier refers to, or
+ * undefined. Only two specifiers name board data: the virtual
+ * `@typecad/board` module and (defensively) the config's own board target
+ * string. Relative-path board imports are gone with the board packages.
  */
-export declare function resolveBoardBuildTarget(boardPackage: string, configPath: string, framework?: string): string | undefined;
+export declare function tryResolveBoardDefFile(fromFile: string, moduleSpecifier: string, boardTarget?: string): string | undefined;

package/dist/ir/board-resolver.js

@@ -1,17 +1,20 @@
 // ---------------------------------------------------------------------------
 // Board constant resolver
 //
-// Parses a TypeScript board-definition file (e.g. code/board-arduino-uno/index.ts)
-// using the TypeScript compiler API and extracts all compile-time scalar values
-// from the exported `BoardDefinition` object into a flat dot-path map.
+// Board data comes from the project-local generated board module: boardgen
+// (in framework-zephyr) materializes `.cuttlefish/board.ts` + `board.json`
+// above the user's sources, and `board.json` carries the flat dot-path
+// constant map read here. The legacy @typecad/board-* / @typecad/mcu-*
+// packages and their TypeScript BoardDefinition manifests are gone, so there
+// is no AST path — the JSON manifest is the only board source.
 //
 // The result is stored in `ProgramIR.boardConstants` and used by the C++
-// emitter to fold `Board.definition.*` property accesses into inline literals
-// – without maintaining a separate hard-coded copy of the manifest.
+// emitter to fold board constant lookups (`board("pins.led")` and friends)
+// into inline literals — without maintaining a separate hard-coded copy of
+// the manifest.
 // ---------------------------------------------------------------------------
 import path from "node:path";
 import fs from "node:fs";
-import ts from "typescript";
 /**
  * Returns a set of default board constants (standard Arduino Uno-like)
  * used as a fallback when no specific board manifest is loaded.
@@ -19,419 +22,58 @@ import ts from "typescript";
 export function getDefaultBoardConstants() {
     const result = new Map();
     result.set("pins.analogOffset", 14);
-    result.set("peripherals.aliases.UART0", "Serial");
-    result.set("peripherals.aliases.I2C0", "Wire");
-    result.set("peripherals.aliases.SPI0", "SPI");
+    result.set("peripherals.aliases.UART0", "UART0");
+    result.set("peripherals.aliases.I2C0", "I2C0");
+    result.set("peripherals.aliases.SPI0", "SPI0");
     return result;
 }
 /**
- * Parse a TypeScript board-definition source file and return a flat map of
- * all compile-time constant scalar values exported as a `BoardDefinition`.
- *
- * Properties whose values are arrays, spread elements, or other non-literal
- * expressions are silently skipped (no partial constant maps for board pins
- * etc. are needed by the emitter).
- *
- * @param defFilePath  Absolute path to the board definition `index.ts`.
+ * Locate the project-local generated board module by walking up from a
+ * source file. A project carries `.cuttlefish/board.ts` + `board.json`
+ * (generated by the framework's board generator — see boardgen in
+ * framework-zephyr) instead of a board package.
  */
-export function resolveBoardConstants(defFilePath) {
-    const result = new Map();
-    // Build a minimal TypeScript program just to get a parsed AST with type
-    // information for the target file.  We don't need emit or diagnostics.
-    const program = ts.createProgram([defFilePath], {
-        noEmit: true,
-        skipLibCheck: true,
-        strict: false,
-        target: ts.ScriptTarget.ES2020,
-    });
-    // The source file may be keyed with either Windows or POSIX separators.
-    const sourceFile = program.getSourceFile(defFilePath) ??
-        program.getSourceFile(defFilePath.replace(/\\/g, "/"));
-    if (!sourceFile)
-        return result;
-    // Find exported variable declarations — both object literals (board/MCU defs)
-    // and arrays of objects (peripheral instance lists).
-    ts.forEachChild(sourceFile, (node) => {
-        if (!ts.isVariableStatement(node))
-            return;
-        const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-        if (!isExported)
-            return;
-        for (const decl of node.declarationList.declarations) {
-            if (!ts.isIdentifier(decl.name))
-                continue;
-            const varName = decl.name.text;
-            const init = decl.initializer;
-            // Object literal — walk normally (board/MCU definitions)
-            let walkInit = init;
-            // Unwrap `as const` / type assertions
-            while (walkInit && ts.isAsExpression(walkInit))
-                walkInit = walkInit.expression;
-            if (walkInit && ts.isObjectLiteralExpression(walkInit)) {
-                // Peripheral capability objects (e.g. PWM_CAPABILITIES → peripherals.pwm.*)
-                // are namespaced so HAL lookups like board("peripherals.pwm.resolution")
-                // resolve. Other object literals (board/MCU definitions) walk with no prefix.
-                if (varName.endsWith("_CAPABILITIES")) {
-                    const baseName = varName.replace("_CAPABILITIES", "").toLowerCase();
-                    walkObjectLiteral(walkInit, `peripherals.${baseName}`, result);
-                }
-                else {
-                    walkObjectLiteral(walkInit, "", result);
-                }
-            }
-            // Array of objects — walk for peripheral instance data
-            // (e.g., ADC_INSTANCES → peripherals.adc.0.*)
-            if (walkInit && ts.isArrayLiteralExpression(walkInit)) {
-                if (varName.endsWith("_INSTANCES")) {
-                    const baseName = varName.replace("_INSTANCES", "").toLowerCase();
-                    const prefix = `peripherals.${baseName}`;
-                    walkArrayLiteral(walkInit, prefix, result);
-                }
-            }
-        }
-    });
-    // After parsing the board file, check for MCU imports and merge pin data.
-    // Board definitions often use `...MCU.pins` spread which the AST walker
-    // cannot handle, but the MCU file has static pin data we can parse.
-    resolveAndMergeMCUConstants(defFilePath, result);
-    return result;
-}
-/**
- * Detect MCU package imports in a board definition file, resolve the MCU
- * definition file, parse its pin/peripheral constants, and merge them into
- * the board constants. This handles the common pattern where board definitions
- * use spread operators (`...ATmega328P.pins`) that the AST walker can't parse.
- */
-function resolveAndMergeMCUConstants(boardFilePath, boardConstants) {
-    // Only proceed if the board file didn't produce pin.all entries on its own
-    let hasPinData = false;
-    for (const key of boardConstants.keys()) {
-        if (key.startsWith("pins.all.")) {
-            hasPinData = true;
-            break;
-        }
-    }
-    if (hasPinData)
-        return;
-    // Parse the board file to find MCU imports
-    const sourceText = fs.readFileSync(boardFilePath, "utf-8");
-    const sourceFile = ts.createSourceFile(boardFilePath, sourceText, ts.ScriptTarget.Latest, true);
-    let mcuSpecifier;
-    for (const stmt of sourceFile.statements) {
-        if (!ts.isImportDeclaration(stmt))
-            continue;
-        const spec = stmt.moduleSpecifier;
-        if (!ts.isStringLiteral(spec))
-            continue;
-        if (spec.text.startsWith("@typecad/mcu-")) {
-            mcuSpecifier = spec.text;
-            break;
-        }
-    }
-    if (!mcuSpecifier)
-        return;
-    // Resolve the MCU package file path
-    const parts = mcuSpecifier.split("/");
-    const pkgName = parts[1]; // e.g. "mcu-atmega328p"
-    const mcuFileNames = ["mcu.ts", "index.ts"];
-    let dir = path.dirname(boardFilePath);
-    while (true) {
-        for (const mcuFileName of mcuFileNames) {
-            const nmCandidate = path.join(dir, "node_modules", "@typecad", pkgName, "src", mcuFileName);
-            if (fs.existsSync(nmCandidate)) {
-                mergeMCUConstants(nmCandidate, boardConstants);
-                return;
-            }
-            const pkgCandidate = path.join(dir, "packages", pkgName, "src", mcuFileName);
-            if (fs.existsSync(pkgCandidate)) {
-                mergeMCUConstants(pkgCandidate, boardConstants);
-                return;
-            }
+export function findGeneratedBoard(fromFile) {
+    let dir = path.dirname(path.resolve(fromFile));
+    for (let i = 0; i < 8; i++) {
+        const boardJson = path.join(dir, ".cuttlefish", "board.json");
+        const boardTs = path.join(dir, ".cuttlefish", "board.ts");
+        if (fs.existsSync(boardJson) && fs.existsSync(boardTs)) {
+            return { boardTs, boardJson };
         }
         const parent = path.dirname(dir);
         if (parent === dir)
             break;
         dir = parent;
     }
-}
-/**
- * Parse an MCU definition file and merge its pin data into the board constants.
- */
-function mergeMCUConstants(mcuFilePath, boardConstants) {
-    const mcuConstants = resolveBoardConstants(mcuFilePath);
-    // Merge MCU pin data and peripheral constants into board constants.
-    // Don't overwrite existing board-specific values
-    for (const [key, value] of mcuConstants.entries()) {
-        if (key.startsWith("pins.") || key.startsWith("peripherals.")) {
-            if (!boardConstants.has(key)) {
-                boardConstants.set(key, value);
-            }
-        }
-    }
-    // Copy architecture if the MCU has it and the board doesn't
-    if (mcuConstants.has("architecture") && !boardConstants.has("architecture")) {
-        boardConstants.set("architecture", mcuConstants.get("architecture"));
-    }
-    // Also parse the MCU peripherals file for ADC/PWM/Timer data that the MCU
-    // definition references via import (e.g., `peripherals: MCU_PERIPHERALS`).
-    const mcuDir = path.dirname(mcuFilePath);
-    const periphFile = path.join(mcuDir, "peripherals.ts");
-    if (fs.existsSync(periphFile)) {
-        const periphConstants = resolveBoardConstants(periphFile);
-        for (const [key, value] of periphConstants.entries()) {
-            if (!boardConstants.has(key)) {
-                boardConstants.set(key, value);
-            }
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/**
- * Recursively walk an `ObjectLiteralExpression`, adding scalar leaf values
- * to `out` keyed by their dot-separated path.
- *
- * @param obj     Current object literal to visit.
- * @param prefix  Dot-path accumulated so far (empty string at top level).
- * @param out     Accumulator map.
- */
-function walkObjectLiteral(obj, prefix, out) {
-    for (const prop of obj.properties) {
-        // Only handle plain  `key: value`  assignments.
-        // Shorthand, spread, methods, and getters are ignored.
-        if (!ts.isPropertyAssignment(prop))
-            continue;
-        const keyNode = prop.name;
-        const key = ts.isIdentifier(keyNode) || ts.isStringLiteral(keyNode) || ts.isNumericLiteral(keyNode)
-            ? keyNode.text
-            : undefined;
-        if (!key)
-            continue;
-        const fullPath = prefix ? `${prefix}.${key}` : key;
-        const init = prop.initializer;
-        const scalar = resolveScalar(init);
-        if (scalar !== undefined) {
-            out.set(fullPath, scalar);
-        }
-        else if (ts.isObjectLiteralExpression(init)) {
-            // Recurse into nested objects (e.g. `memory: { flash: 32_768, ... }`).
-            walkObjectLiteral(init, fullPath, out);
-        }
-        else if (ts.isArrayLiteralExpression(init)) {
-            // Capture string arrays (e.g. `pins.unsafe: ['D0', 'D1']`)
-            const arrValues = [];
-            for (const elem of init.elements) {
-                if (ts.isStringLiteral(elem)) {
-                    arrValues.push(elem.text);
-                }
-            }
-            if (arrValues.length > 0) {
-                out.set(fullPath, arrValues.join(','));
-            }
-            else {
-                walkArrayLiteral(init, fullPath, out);
-            }
-        }
-        // Encode peripheral pin maps in a compact parseable format.
-        // pins.i2c = { 0: { sda: 'A4', scl: 'A5' } } -> "0:sda=A4,scl=A5"
-        // pins.spi = { 0: { mosi: 'D11', miso: 'D12', sck: 'D13', cs: 'D10' } } -> "0:mosi=D11,miso=D12,sck=D13,cs=D10"
-        // pins.uart = { 0: { tx: 'D1', rx: 'D0' } } -> "0:tx=D1,rx=D0"
-        if (ts.isObjectLiteralExpression(init)) {
-            const encoded = tryEncodePeripheralPinMap(key, init);
-            if (encoded) {
-                out.set(fullPath, encoded);
-            }
-        }
-        // Other complex expressions are silently ignored.
-    }
-}
-function walkArrayLiteral(arr, prefix, out) {
-    arr.elements.forEach((elem, index) => {
-        const fullPath = `${prefix}.${index}`;
-        const scalar = resolveScalar(elem);
-        if (scalar !== undefined) {
-            out.set(fullPath, scalar);
-            return;
-        }
-        if (ts.isObjectLiteralExpression(elem)) {
-            walkObjectLiteral(elem, fullPath, out);
-            return;
-        }
-        if (ts.isArrayLiteralExpression(elem)) {
-            const arrValues = [];
-            for (const nested of elem.elements) {
-                if (ts.isStringLiteral(nested)) {
-                    arrValues.push(nested.text);
-                }
-            }
-            if (arrValues.length > 0) {
-                out.set(fullPath, arrValues.join(','));
-            }
-        }
-    });
-}
-/**
- * Try to evaluate a simple literal expression to a scalar JS value.
- * Returns `undefined` for anything that is not a plain, directly readable
- * literal (string, number, boolean, negative-number).
- */
-function resolveScalar(expr) {
-    // Strip `as const` / `as T` type assertions — recurse on the inner expression.
-    if (ts.isAsExpression(expr))
-        return resolveScalar(expr.expression);
-    // String literal
-    if (ts.isStringLiteral(expr))
-        return expr.text;
-    // Numeric literal — TypeScript preserves underscore separators in `.text`
-    // (e.g.  32_768), so we strip them before converting.
-    if (ts.isNumericLiteral(expr)) {
-        return Number(expr.text.replace(/_/g, ""));
-    }
-    // Boolean keywords
-    if (expr.kind === ts.SyntaxKind.TrueKeyword)
-        return true;
-    if (expr.kind === ts.SyntaxKind.FalseKeyword)
-        return false;
-    // Negative numeric literals:  -32768  or  -1_024
-    if (ts.isPrefixUnaryExpression(expr) &&
-        expr.operator === ts.SyntaxKind.MinusToken &&
-        ts.isNumericLiteral(expr.operand)) {
-        return -Number(expr.operand.text.replace(/_/g, ""));
-    }
     return undefined;
 }
-// ---------------------------------------------------------------------------
-// Peripheral pin map encoding
-// ---------------------------------------------------------------------------
 /**
- * Try to encode a peripheral pin map object into a compact string format.
- * Handles pins.i2c, pins.spi, pins.uart structures.
- *
- * Input:  { 0: { sda: 'A4', scl: 'A5' } }
- * Output: "0:sda=A4,scl=A5"
- *
- * Input:  { 0: { mosi: 'D11', miso: 'D12', sck: 'D13', cs: 'D10' } }
- * Output: "0:mosi=D11,miso=D12,sck=D13,cs=D10"
+ * Read a generated board.json manifest into BoardConstants. The manifest is
+ * `{ version, identifier, soc, tier, pinNames, constants: {dot-path → value} }`
+ * — the `constants` object IS the flat map.
  */
-function tryEncodePeripheralPinMap(key, obj) {
-    // Only encode known peripheral pin structures
-    if (key !== 'i2c' && key !== 'spi' && key !== 'uart')
-        return undefined;
-    const instances = [];
-    for (const prop of obj.properties) {
-        if (!ts.isPropertyAssignment(prop))
-            continue;
-        const keyNode = prop.name;
-        if (!ts.isIdentifier(keyNode) && !ts.isStringLiteral(keyNode) && !ts.isNumericLiteral(keyNode))
-            continue;
-        const instanceKey = keyNode.text;
-        const value = prop.initializer;
-        if (!ts.isObjectLiteralExpression(value))
-            continue;
-        // Parse the inner object { sda: 'A4', scl: 'A5' } etc.
-        const fields = [];
-        for (const field of value.properties) {
-            if (!ts.isPropertyAssignment(field))
-                continue;
-            const fieldKey = field.name;
-            if (!ts.isIdentifier(fieldKey) && !ts.isStringLiteral(fieldKey) && !ts.isNumericLiteral(fieldKey))
-                continue;
-            const fieldValue = field.initializer;
-            if (!ts.isStringLiteral(fieldValue))
-                continue;
-            fields.push(`${fieldKey.text}=${fieldValue.text}`);
-        }
-        if (fields.length > 0) {
-            instances.push(`${instanceKey}:${fields.join(',')}`);
-        }
-    }
-    if (instances.length > 0) {
-        return instances.join(';');
+export function readGeneratedBoardConstants(boardJsonPath) {
+    const manifest = JSON.parse(fs.readFileSync(boardJsonPath, "utf-8"));
+    const result = new Map();
+    for (const [k, v] of Object.entries(manifest.constants ?? {})) {
+        result.set(k, v);
     }
-    return undefined;
+    return result;
 }
 /**
- * Given a source file path and a relative import module specifier, check
- * whether the import resolves to a TypeCAD board-definition package
- * (path pattern: /code/board-*\/index.ts).
- *
- * Returns the absolute path to the board index.ts on match, otherwise
- * undefined.
+ * Given a source file path and an import module specifier, return the path
+ * of the generated board.json manifest the specifier refers to, or
+ * undefined. Only two specifiers name board data: the virtual
+ * `@typecad/board` module and (defensively) the config's own board target
+ * string. Relative-path board imports are gone with the board packages.
  */
-export function tryResolveBoardDefFile(fromFile, moduleSpecifier, boardPackage) {
-    // Handle the "@typecad/board" virtual import — rewrite to the concrete board
-    // package so the rest of the resolution logic works unchanged.
-    // (Case-insensitive so the documented mixed-case form resolves identically.)
-    let effectiveSpecifier = moduleSpecifier;
-    if (moduleSpecifier.toLowerCase() === "@typecad/board" && boardPackage) {
-        effectiveSpecifier = boardPackage;
-    }
-    // Handle relative imports (e.g. "../code/board-arduino-uno/pins")
-    if (effectiveSpecifier.startsWith(".")) {
-        const dir = path.dirname(fromFile);
-        const base = path.resolve(dir, moduleSpecifier);
-        // Candidates: bare path, +.ts, or /index.ts
-        const candidates = [
-            base,
-            `${base}.ts`,
-            path.join(base, "index.ts"),
-        ];
-        for (const candidate of candidates) {
-            if (!fs.existsSync(candidate))
-                continue;
-            const normalized = candidate.replace(/\\/g, "/");
-            if (/[\\/]board-/.test(normalized)) {
-                // Always redirect to index.ts in the board package root so we parse the
-                // BoardDefinition manifest regardless of which file was actually imported
-                // (e.g. board.ts, pins.ts, etc.).
-                const boardDir = path.dirname(candidate);
-                const indexTs = path.join(boardDir, "index.ts");
-                return fs.existsSync(indexTs) ? indexTs : candidate;
-            }
-        }
-        return undefined;
-    }
-    // Handle npm-scoped board package imports (e.g. "@typecad/board-esp32-devkit")
-    if (effectiveSpecifier.startsWith("@typecad/board-")) {
-        const parts = effectiveSpecifier.split("/");
-        const pkgName = parts[1]; // "board-esp32-devkit"
-        // Walk up from the importing file's directory to find node_modules OR a packages directory (monorepo)
-        let dir = path.dirname(fromFile);
-        while (true) {
-            // 1. Try node_modules
-            const nmCandidate = path.join(dir, "node_modules", "@typecad", pkgName, "src", "index.ts");
-            if (fs.existsSync(nmCandidate))
-                return nmCandidate;
-            // 2. Try packages/ directory (monorepo layout)
-            const pkgCandidate = path.join(dir, "packages", pkgName, "src", "index.ts");
-            if (fs.existsSync(pkgCandidate))
-                return pkgCandidate;
-            // 3. Try sibling packages directory (if fromFile is inside a package)
-            const siblingPkgCandidate = path.join(path.dirname(dir), "packages", pkgName, "src", "index.ts");
-            if (fs.existsSync(siblingPkgCandidate))
-                return siblingPkgCandidate;
-            const parent = path.dirname(dir);
-            if (parent === dir)
-                break; // reached filesystem root
-            dir = parent;
-        }
+export function tryResolveBoardDefFile(fromFile, moduleSpecifier, boardTarget) {
+    const isVirtualBoardSpecifier = moduleSpecifier.toLowerCase() === "@typecad/board";
+    if (isVirtualBoardSpecifier || moduleSpecifier === boardTarget) {
+        const generated = findGeneratedBoard(fromFile);
+        if (generated)
+            return generated.boardJson;
     }
     return undefined;
 }
-/**
- * Resolve the framework-specific build target (e.g. Arduino FQBN) from the
- * board package's manifest.
- *
- * @param boardPackage  Board package identifier or path.
- * @param configPath    Path to the project config file (for relative resolution).
- * @param framework     Target framework name (default: 'arduino').
- */
-export function resolveBoardBuildTarget(boardPackage, configPath, framework = "arduino") {
-    const defFile = tryResolveBoardDefFile(configPath, boardPackage);
-    if (!defFile)
-        return undefined;
-    const constants = resolveBoardConstants(defFile);
-    const target = constants.get(`build.frameworks.${framework}`);
-    return typeof target === "string" ? target : undefined;
-}

package/dist/ir/build-ir-state.d.ts

@@ -165,4 +165,7 @@ export declare const TYPED_ARRAY_ELEMENT_MAP: Record<string, string>;
 export declare function getCurrentBoardConstants(): BoardConstants;
 export declare function setCurrentBoardConstants(v: BoardConstants | undefined): void;
 export declare function resetBuildState(): void;
+export declare function markHalOpResolved(opName: string): void;
+export declare function getTranspileResolvedHalOps(): ReadonlySet<string>;
+export declare function resetTranspileResolvedHalOps(): void;
 export declare function resetFunctionScopeState(): void;

package/dist/ir/build-ir-state.js

@@ -217,6 +217,14 @@ export function setCurrentBoardConstants(v) {
     const ctx = getContext();
     ctx._currentBoardConstants = v;
     if (v) {
+        // Framework strategies that resolve per-program chip data (framework-zephyr's
+        // prepareChip) must see the board constants at IR-build time: HAL method
+        // bodies lower to C++ text during the build, before the emitter's
+        // prepareChip call (emit/emitters/setup.ts) ever runs — without this, the
+        // lowering resolves every op against the NO_BOARD_CHIP defaults.
+        // Mirrors that duck-typed call.
+        ctx.activeStrategy
+            ?.prepareChip?.({ boardConstants: v }, undefined);
         // Populate peripheral aliases (e.g. UART0 -> Serial, I2C0 -> Wire)
         for (const [key, value] of v.entries()) {
             if (key.startsWith("peripherals.aliases.")) {
@@ -262,6 +270,19 @@ export function setCurrentBoardConstants(v) {
                 }
             }
         }
+        // Board-module pin aliases (pins.aliases.<NAME> → pin name): the
+        // generated board module exports LED/BUTTON (and silkscreen labels) as
+        // aliases of datasheet-named pins. Map them through to numbers so
+        // resolveHALReceiver treats them as Pin constants.
+        for (const [key, value] of v.entries()) {
+            const aliasMatch = key.match(/^pins\.aliases\.([A-Za-z_][A-Za-z0-9_]*)$/);
+            if (aliasMatch && typeof value === 'string') {
+                const num = mcuPinForwardMap.get(value);
+                if (num !== undefined) {
+                    pinAliasMap.set(aliasMatch[1], num);
+                }
+            }
+        }
     }
 }
 // 6. State management hooks
@@ -300,6 +321,27 @@ export function resetBuildState() {
     activeFunctionReturnTypes.clear();
     getContext()._currentBoardConstants = undefined;
 }
+// ── Transpile-resolved HAL ops ──────────────────────────────────────────────
+// HAL ops the transpiler resolves to C++ TEXT while inlining one HAL method
+// inside another (e.g. `sense.readMillivolts()` in the argument of
+// `USB0.writeLine(...)`) never appear as hal-op/hal-expr IR nodes, so the
+// statement walk in program-analysis can't see them. routeHALOp and
+// resolveHALExprToText record every op they successfully resolve here, and
+// analyzeProgram merges these names into the peripheral usage flags.
+// Deliberately NOT cleared by
+// resetBuildState (per-file): the ops resolve while building whichever file
+// inlines them, and analyzeProgram runs later, at emit. resetTranspileResolvedHalOps
+// clears it once per transpile run.
+const transpileResolvedHalOps = new Set();
+export function markHalOpResolved(opName) {
+    transpileResolvedHalOps.add(opName);
+}
+export function getTranspileResolvedHalOps() {
+    return transpileResolvedHalOps;
+}
+export function resetTranspileResolvedHalOps() {
+    transpileResolvedHalOps.clear();
+}
 export function resetFunctionScopeState() {
     activeCArrayVars.clear();
     activeArrayLiteralVars.clear();

package/dist/ir/build-ir.d.ts

@@ -1,2 +1,2 @@
 import { ClassIR, ProgramIR } from "../api/index.js";
-export declare function buildProgramIR(fileName: string, sourceText: string, boardPackage?: string, prebuiltClassMap?: Map<string, ClassIR>): ProgramIR;
+export declare function buildProgramIR(fileName: string, sourceText: string, boardTarget?: string, prebuiltClassMap?: Map<string, ClassIR>): ProgramIR;