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

package/dist/cli.js

@@ -2,18 +2,21 @@
 import path from "node:path";
 import fs from "node:fs";
 import { parseCommandLine, printHelp } from "./utils/cli.js";
-import { scaffoldProject, printInitNextSteps, KNOWN_TARGETS } from "./create/index.js";
+import { scaffoldProject, printInitNextSteps, KNOWN_TARGETS, frameworksForTarget, frameworkCatalogEntry, FRAMEWORK_CATALOG, frameworkTargetProfile } from "./create/index.js";
 import { runInitWizard } from "./create/index.js";
+import { installProjectDependencies } from "./create/install-deps.js";
 import { generateLibraryDefinitions, transpileFile } from "./transpile.js";
-import { generateDecl, generateDeclsForDirectory } from "./libdef/cpp-to-decl.js";
+import { generateDecl, generateDeclsForDirectory, generateComponentDeclsForProject } from "./libdef/cpp-to-decl.js";
 import { mapCppLocationToTs, readSourceMap, resolveMapPath } from "./mapping/source-map.js";
 import { compileSource, uploadFirmware, monitorDevice } from "./platform/toolchain.js";
 import { resolveStrategy } from "./platform/registry.js";
 import { loadFrameworkPackage } from "./framework-package.js";
 import { getLoadedFramework, hasLoadedFramework } from "./framework-registry.js";
 import { loadCuttlefishConfig, generateVirtualTypeDeclaration } from "./config-loader.js";
+import { generateContractBoard } from "./contract/index.js";
 import { requireUIHook, hasUIHook } from "./ui-hook.js";
 import { loadUIEngine } from "./ui/ui-bridge.js";
+import { loadSafetyEngine } from "./safety/safety-bridge.js";
 import { runWatch, discoverWatchDirs } from "./watch.js";
 import { runExpectTests, assertTypeScriptInput, printDiagnostics, printMappedCompileErrors } from "./cli-utils.js";
 import { runPreviewServer } from "./preview/server.js";
@@ -31,6 +34,27 @@ function displayConfigForTranspile(config) {
     }
     return display;
 }
+/**
+ * Apply the PSRAM config to the Arduino build: append the `PSRAM={opi|quad}`
+ * menu option to the FQBN (so the Arduino core's psramFound()/ps_malloc work
+ * at runtime — they're gated on the board menu option, not just the define)
+ * and add `-DBOARD_HAS_PSRAM` to the defines (so the framework's PSRAM canvas
+ * allocator is compiled in). No-op when psram is unset or the target isn't an
+ * Arduino FQBN (the PSRAM= option is Arduino-core-specific).
+ */
+function applyPsramToArduinoBuild(buildTarget, defines, psram) {
+    if (!psram || !buildTarget || !buildTarget.includes(':')) {
+        return { buildTarget, defines: defines ?? {} };
+    }
+    // Arduino FQBN config options follow the board:option as `key=value` pairs.
+    // Append PSRAM= if not already present (don't clobber an explicit override).
+    const psramOpt = `PSRAM=${psram}`;
+    const adjustedTarget = buildTarget.includes('PSRAM=') ? buildTarget : `${buildTarget}:${psramOpt}`;
+    const adjustedDefines = { ...(defines ?? {}) };
+    if (!('BOARD_HAS_PSRAM' in adjustedDefines))
+        adjustedDefines.BOARD_HAS_PSRAM = '';
+    return { buildTarget: adjustedTarget, defines: adjustedDefines };
+}
 async function handleCreate(options) {
     const targetId = options.target ?? options.board;
     const hasTarget = !!targetId;
@@ -40,15 +64,35 @@ async function handleCreate(options) {
             const available = KNOWN_TARGETS.map(t => `  - ${t.id} (${t.displayName})`).join("\n");
             throw new Error(`Unknown target '${targetId}'. Available targets:\n${available}`);
         }
-        const framework = options.framework ?? target.framework;
-        const frameworkPackage = target.isNative
-            ? target.frameworkPackage
-            : framework === 'avr'
-                ? '@typecad/framework-avr'
-                : framework === 'arduino'
-                    ? '@typecad/framework-arduino'
-                    : `@typecad/framework-${framework}`;
+        // Resolve the framework. --framework wins; otherwise narrow via the catalog
+        // for the chosen board and auto-pick when exactly one is compatible.
+        let frameworkId;
+        let frameworkPackage;
+        if (options.framework) {
+            const requested = frameworkCatalogEntry(options.framework);
+            if (!requested) {
+                const available = FRAMEWORK_CATALOG.filter(f => f.installable).map(f => f.id).join(", ");
+                throw new Error(`Unknown framework '${options.framework}'. Available: ${available}`);
+            }
+            frameworkId = requested.id;
+            frameworkPackage = requested.packageName;
+        }
+        else {
+            const compatible = frameworksForTarget(target).filter(f => f.installable);
+            if (compatible.length === 1) {
+                frameworkId = compatible[0].id;
+                frameworkPackage = compatible[0].packageName;
+            }
+            else {
+                const list = compatible.map(f => f.id).join(", ");
+                throw new Error(`Target '${target.id}' is compatible with multiple frameworks (${list}). ` +
+                    `Pass --framework <id> to choose one.`);
+            }
+        }
         const projectName = options.projectName || 'my-project';
+        // Framework-specific build target + toolchain (Zephyr board id + 'west' vs
+        // the Arduino FQBN + 'arduino-cli').
+        const profile = frameworkTargetProfile(target, frameworkId);
         const result = scaffoldProject({
             projectName,
             targetId: target.id,
@@ -57,18 +101,17 @@ async function handleCreate(options) {
             architecture: target.architecture,
             boardPackage: target.boardPackage,
             frameworkPackage,
-            framework,
-            buildTarget: target.buildTarget,
+            framework: frameworkId,
+            buildTarget: profile.buildTarget ?? target.buildTarget,
+            ...(profile.toolchainType ? { toolchainType: profile.toolchainType } : {}),
             mcu: target.mcu,
             baudRate: target.isNative ? undefined : (options.baud ?? 9600),
             includeSketch: !options.noSketch,
+            ...(target.frameworkData
+                ? { frameworkData: target.frameworkData }
+                : {}),
         }, options.outDir);
-        console.log(`\n${chalk.green("✓")} Created project files:`);
-        for (const file of result.createdFiles) {
-            const relative = path.relative(process.cwd(), file);
-            console.log(`  ${chalk.dim(relative || file)}`);
-        }
-        printInitNextSteps(result.options, result.outDir);
+        finalizeCreate(result, options);
     }
     else {
         const wizardResult = await runInitWizard({
@@ -83,13 +126,37 @@ async function handleCreate(options) {
             return;
         }
         const result = scaffoldProject(wizardResult, options.outDir);
-        console.log(`\n${chalk.green("✓")} Created project files:`);
-        for (const file of result.createdFiles) {
-            const relative = path.relative(process.cwd(), file);
-            console.log(`  ${chalk.dim(relative || file)}`);
+        finalizeCreate(result, options);
+    }
+}
+/**
+ * Shared tail of `cuttlefish create`: list the created files, install the new
+ * project's dependencies (so it's ready to build with no extra step — skipped
+ * via --no-install), and print the next-steps. A failed install is non-fatal:
+ * the scaffold itself is valid, so we warn and point at the manual command
+ * rather than undoing anything.
+ */
+function finalizeCreate(result, options) {
+    console.log(`\n${chalk.green("✓")} Created project files:`);
+    for (const file of result.createdFiles) {
+        const relative = path.relative(process.cwd(), file);
+        console.log(`  ${chalk.dim(relative || file)}`);
+    }
+    let installed = false;
+    if (!options.noInstall) {
+        try {
+            const { pm } = installProjectDependencies({ projectDir: result.outDir });
+            installed = true;
+            console.log(`\n${chalk.green("✓")} Installed dependencies via ${pm}.`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const relativeDir = path.relative(process.cwd(), result.outDir) || '.';
+            console.log(`\n${chalk.yellow("!")} Could not install dependencies automatically: ${message}`);
+            console.log(chalk.dim(`  Run '${chalk.white("npm install")}' manually in ${relativeDir} when ready.`));
         }
-        printInitNextSteps(result.options, result.outDir);
     }
+    printInitNextSteps(result.options, result.outDir, { installed });
 }
 async function handleBoardAdd(options) {
     const { scaffoldBoardPackages, parseBoardSpec, generateFrameworkChecklist } = await import("./create/index.js");
@@ -154,6 +221,38 @@ async function main() {
             }
             return;
         }
+        if (options.command === "doctor" || options.command === "licenses") {
+            // These commands run standalone (often before a build), so the framework
+            // isn't loaded yet. Load it from the config's framework field so the
+            // framework-supplied doctor/licenses handlers are available.
+            if (!hasLoadedFramework()) {
+                const config = loadCuttlefishConfig(process.cwd());
+                if (config?.framework) {
+                    try {
+                        loadFrameworkPackage(config.framework, process.cwd());
+                    }
+                    catch {
+                        // Framework package not resolvable — fall through to the
+                        // no-support message below rather than crashing the command.
+                    }
+                }
+            }
+            const fw = hasLoadedFramework() ? getLoadedFramework() : undefined;
+            if (options.command === "doctor") {
+                if (!fw?.doctor) {
+                    ui.printInfo("This framework provides no doctor support.");
+                    return;
+                }
+                fw.doctor();
+                return;
+            }
+            if (!fw?.licenses) {
+                ui.printInfo("This framework provides no licenses support.");
+                return;
+            }
+            fw.licenses(options.strict ?? false, options.all ?? false);
+            return;
+        }
         // ── Handle build command — entry point comes from config ──────────
         if (options.command === "build") {
             const buildConfig = loadCuttlefishConfig(process.cwd());
@@ -184,6 +283,37 @@ async function main() {
         // it intentionally has no inputFile (it scans scanDir instead), so the
         // generic "Missing input file path" check would otherwise block it.
         if (options.command === "gen-decls") {
+            // Check for --components flag (ESP-IDF components: managed + local).
+            // Runs before scanDir/single-file branches; components mode has no
+            // inputFile by design (it scans managed_components/ + components/).
+            const componentsDir = options.componentsDir;
+            if (componentsDir) {
+                ui.printHeader();
+                ui.printStep(`Generating component declarations for ${componentsDir}...`);
+                const config = loadCuttlefishConfig(componentsDir);
+                const frameworkConfig = (config?.frameworkConfig ?? {});
+                const componentsNode = frameworkConfig?.components ?? {};
+                const managedSpecs = Object.keys(componentsNode.managed ?? {});
+                // idf.py stores managed deps as <namespace>__<name> (slashes → __).
+                const managedNames = managedSpecs.map((spec) => spec.replace("/", "__"));
+                const localPaths = (componentsNode.local ?? []).map((p) => path.isAbsolute(p) ? p : path.resolve(componentsDir, p));
+                const builtinNames = componentsNode.builtin ?? [];
+                const created = generateComponentDeclsForProject(componentsDir, {
+                    managed: managedNames,
+                    local: localPaths,
+                    builtin: [],
+                    idfRoot: undefined,
+                });
+                if (created.length === 0) {
+                    ui.printInfo("No component declaration files created.");
+                }
+                else {
+                    ui.printSuccess(`Created ${created.length} declaration file(s):`);
+                    for (const f of created)
+                        ui.printFileCreated(f);
+                }
+                return;
+            }
             // Check for --all flag (scan directory)
             const scanDir = options.scanDir;
             if (scanDir) {
@@ -255,8 +385,56 @@ async function main() {
         // ── Load cuttlefish.config.ts (config wins over CLI flags) ──────────
         const inputDir = path.dirname(path.resolve(options.inputFile));
         const config = loadCuttlefishConfig(inputDir);
+        // ── Contract-based board narrowing ──────────────────────────────────
+        // If the config names a TypeCAD contract (*.contract.json from typecad.net),
+        // generate the narrowed `.cuttlefish/board.ts` BEFORE env.d.ts is written
+        // (it emits `export * from './board.js'` for this case) and before the
+        // board package is resolved downstream. The generated board re-exports
+        // only the pins/peripherals the PCB actually wires.
+        if (config?.contract) {
+            await generateContractBoard(config);
+        }
+        // ── Pre-transpile: generate component .d.ts stubs ───────────────────
+        // The transpile type-check needs the .d.ts imports in main.ts to resolve.
+        // For ESP-IDF builtin/managed/local components, those .d.ts files are
+        // generated by gen-decls — so we must run it BEFORE type-checking, not
+        // only as part of --compile. The cache is written under the transpile
+        // output dir (the same path --compile uses), so user imports resolve
+        // identically in both flows.
+        if (config?.frameworkConfig) {
+            const fc = config.frameworkConfig;
+            const componentsNode = fc?.components ?? {};
+            const managedSpecs = Object.keys(componentsNode.managed ?? {});
+            const localPaths = (componentsNode.local ?? []).map((p) => path.isAbsolute(p) ? p : path.resolve(inputDir, p));
+            const builtinNames = componentsNode.builtin ?? [];
+            if (managedSpecs.length > 0 || localPaths.length > 0 || builtinNames.length > 0) {
+                // Resolve the transpile output dir — the cache lives under it so the
+                // framework's compile path and this pre-transpile pass agree on location.
+                // output.outDir in config is relative to the project root (inputDir);
+                // if absent, the transpile output goes alongside the entry file.
+                const outBase = config.outputOutDir
+                    ? path.resolve(inputDir, config.outputOutDir)
+                    : inputDir;
+                try {
+                    generateComponentDeclsForProject(outBase, {
+                        managed: managedSpecs.map((s) => s.replace('/', '__')),
+                        local: localPaths,
+                        builtin: [],
+                        idfRoot: undefined,
+                    });
+                }
+                catch {
+                    // Non-fatal: if gen-decls fails (e.g. component not yet fetched),
+                    // the type-checker will surface the missing-import errors with
+                    // clearer context than crashing here.
+                }
+            }
+        }
         // Load the UI engine (if @typecad/ui is installed) before any UI work.
         await loadUIEngine();
+        // Load the safety engine (if @typecad/safety is installed) before any
+        // safety work.
+        await loadSafetyEngine();
         let effectivePlatformContext = options.platformContext;
         let effectiveTarget = options.target;
         let effectiveOutDir = options.outDir;
@@ -277,9 +455,16 @@ async function main() {
             }
             let configBuildTarget = config.buildTarget;
             if (configBuildTarget) {
+                // Reconstruct frameworkData from buildTarget so the toolchain sees the
+                // full frameworkData, not just buildTarget.
                 effectivePlatformContext = {
                     architecture: configBuildTarget.split(":")?.[1]?.toLowerCase(),
-                    frameworkData: { buildTarget: configBuildTarget },
+                    frameworkData: {
+                        buildTarget: configBuildTarget,
+                        // Thread the PSRAM type through to the framework so it can emit the
+                        // PSRAM-enabling Kconfig (Zephyr) / define + FQBN option (Arduino).
+                        ...(config.psram ? { psram: config.psram } : {}),
+                    },
                 };
             }
             if (config.outputOutDir && !options.outDir) {
@@ -358,15 +543,21 @@ async function main() {
                     diagnostics: options.diagnostics,
                     display: displayConfigForTranspile(config),
                     projectRoot: options.projectRoot,
+                    autosar: options.autosar,
+                    autosarArxml: options.autosarArxml,
                 });
                 printDiagnostics(result.diagnostics);
                 ui.printTasks(result.asyncTaskNames ?? [], result.usesTimers ?? false);
+                if (result.diagnosticsReportPath) {
+                    ui.printInfo(`Diagnostics report: ${result.diagnosticsReportPath}`);
+                }
                 if (result.diagnostics.length === 0) {
                     ui.printSuccess();
                     initialBuildOk = true;
                     // Initial compile + upload if flags are set
                     if (options.compile) {
-                        const buildTarget = effectivePlatformContext?.frameworkData?.buildTarget ?? options.platformContext?.frameworkData?.buildTarget;
+                        const baseBuildTarget = effectivePlatformContext?.frameworkData?.buildTarget ?? options.platformContext?.frameworkData?.buildTarget;
+                        const { buildTarget, defines: psramDefines } = applyPsramToArduinoBuild(baseBuildTarget, config?.outputDefines, config?.psram);
                         const watchOpts = {
                             outputDir: path.dirname(result.sourcePath),
                             sourcePath: result.sourcePath,
@@ -375,8 +566,12 @@ async function main() {
                             baud: options.baud ?? config?.console?.baudRate,
                             optimize: config?.outputOptimize,
                             extraFlags: config?.outputExtraFlags,
-                            defines: config?.outputDefines,
+                            defines: psramDefines,
+                            psram: config?.psram,
                             frameworkConfig: config?.frameworkConfig,
+                            zephyrConfig: config?.zephyrConfig,
+                            display: displayConfigForTranspile(config),
+                            debug: options.debug,
                         };
                         ui.printCompiling(buildTarget ?? "native");
                         const compileResult = compileSource(watchOpts);
@@ -448,16 +643,22 @@ async function main() {
                             diagnostics: options.diagnostics,
                             display: displayConfigForTranspile(config),
                             projectRoot: options.projectRoot,
+                            autosar: options.autosar,
+                            autosarArxml: options.autosarArxml,
                         });
                         printDiagnostics(rebuildResult.diagnostics);
                         ui.printTasks(rebuildResult.asyncTaskNames ?? [], rebuildResult.usesTimers ?? false);
+                        if (rebuildResult.diagnosticsReportPath) {
+                            ui.printInfo(`Diagnostics report: ${rebuildResult.diagnosticsReportPath}`);
+                        }
                         if (rebuildResult.diagnostics.length > 0) {
                             // Errors shown via printDiagnostics — skip compile/upload
                         }
                         else {
                             ui.printSuccess();
                             if (options.compile) {
-                                const buildTarget = effectivePlatformContext?.frameworkData?.buildTarget ?? options.platformContext?.frameworkData?.buildTarget;
+                                const baseBuildTarget = effectivePlatformContext?.frameworkData?.buildTarget ?? options.platformContext?.frameworkData?.buildTarget;
+                                const { buildTarget, defines: psramDefines } = applyPsramToArduinoBuild(baseBuildTarget, config?.outputDefines, config?.psram);
                                 const rebuildOpts = {
                                     outputDir: path.dirname(rebuildResult.sourcePath),
                                     sourcePath: rebuildResult.sourcePath,
@@ -466,8 +667,12 @@ async function main() {
                                     baud: options.baud ?? config?.console?.baudRate,
                                     optimize: config?.outputOptimize,
                                     extraFlags: config?.outputExtraFlags,
-                                    defines: config?.outputDefines,
+                                    defines: psramDefines,
+                                    psram: config?.psram,
                                     frameworkConfig: config?.frameworkConfig,
+                                    zephyrConfig: config?.zephyrConfig,
+                                    display: displayConfigForTranspile(config),
+                                    debug: options.debug,
                                 };
                                 ui.printCompiling(buildTarget ?? "native");
                                 const compileResult = compileSource(rebuildOpts);
@@ -532,9 +737,14 @@ async function main() {
                 diagnostics: options.diagnostics,
                 display: displayConfigForTranspile(config) ?? options.display,
                 projectRoot: options.projectRoot,
+                autosar: options.autosar,
+                autosarArxml: options.autosarArxml,
             });
             printDiagnostics(result.diagnostics);
             ui.printTasks(result.asyncTaskNames ?? [], result.usesTimers ?? false);
+            if (result.diagnosticsReportPath) {
+                ui.printInfo(`Diagnostics report: ${result.diagnosticsReportPath}`);
+            }
         }
         if (hasFatalDiagnostics(result)) {
             ui.printError("Transpilation failed. Fix the transpiler diagnostics above before compiling.");
@@ -555,7 +765,8 @@ async function main() {
             return;
         }
         // --compile (delegates to the active framework's toolchain)
-        const buildTarget = effectivePlatformContext?.frameworkData?.buildTarget ?? options.platformContext?.frameworkData?.buildTarget;
+        const baseBuildTarget = effectivePlatformContext?.frameworkData?.buildTarget ?? options.platformContext?.frameworkData?.buildTarget;
+        const { buildTarget, defines: psramDefines } = applyPsramToArduinoBuild(baseBuildTarget, config?.outputDefines, config?.psram);
         const toolchainOpts = {
             outputDir: path.dirname(result.sourcePath),
             sourcePath: result.sourcePath,
@@ -564,8 +775,12 @@ async function main() {
             baud: options.baud ?? config?.console?.baudRate,
             optimize: config?.outputOptimize,
             extraFlags: config?.outputExtraFlags,
-            defines: config?.outputDefines,
+            defines: psramDefines,
+            psram: config?.psram,
             frameworkConfig: config?.frameworkConfig,
+            zephyrConfig: config?.zephyrConfig,
+            display: displayConfigForTranspile(config),
+            debug: options.debug,
         };
         ui.printCompiling(buildTarget ?? "native");
         let compileResult;
@@ -616,8 +831,10 @@ async function main() {
             return;
         }
         if (options.monitor) {
-            // --monitor (blocks until Ctrl+C)
-            ui.printMonitoring(port, options.baud);
+            // --monitor (blocks until Ctrl+C). Show the resolved baud (config ?? --baud)
+            // in the banner — toolchainOpts.baud is built the same way, so what the
+            // user sees is what the framework monitor opens the port at.
+            ui.printMonitoring(port, toolchainOpts.baud ?? 115200);
             monitorDevice(toolchainOpts);
             return;
         }

package/dist/config-loader.d.ts

@@ -13,7 +13,7 @@ export interface ResolvedCuttlefishConfig {
     contract?: string;
     /** Build target identifier (e.g. FQBN for Arduino CLI). */
     buildTarget?: string;
-    /** Output framework (e.g. 'arduino', 'platformio'). */
+    /** Output framework (e.g. 'arduino'). */
     outputFramework?: string;
     /** Optimization level. */
     outputOptimize?: string;
@@ -21,9 +21,12 @@ export interface ResolvedCuttlefishConfig {
     outputOutDir?: string;
     /**
      * Framework package for code generation strategy.
-     * Can be '@typecad/framework-arduino', '@typecad/framework-avr', or a custom path.
+     * Can be '@typecad/framework-arduino', '@typecad/framework-zephyr',
+     * '@typecad/framework-native', or a custom path.
      */
     framework?: string;
+    /** ESP32 PSRAM type ('opi' | 'quad') when the target board has PSRAM. */
+    psram?: 'opi' | 'quad';
     /** Entry point TypeScript file (relative to config file directory). */
     entry?: string;
     /** Path to the config file that was loaded. */
@@ -39,6 +42,8 @@ export interface ResolvedCuttlefishConfig {
     outputDefines?: Record<string, string>;
     /** Framework-specific config (e.g. `native` section). */
     frameworkConfig?: Record<string, unknown>;
+    /** Zephyr-specific config (e.g. `zephyr` section). */
+    zephyrConfig?: Record<string, unknown>;
     /** Display profile config. */
     display?: import("./api/shared/display-profile.js").DisplayConfig;
 }

package/dist/config-loader.js

@@ -297,6 +297,9 @@ export function parseConfigFile(configPath) {
     const framework = flat.get("framework");
     if (typeof framework === "string")
         resolved.framework = framework;
+    const psram = flat.get("psram");
+    if (psram === "opi" || psram === "quad")
+        resolved.psram = psram;
     const outputFramework = flat.get("output.framework");
     if (typeof outputFramework === "string")
         resolved.outputFramework = outputFramework;
@@ -323,8 +326,20 @@ export function parseConfigFile(configPath) {
     if (outputDefines)
         resolved.outputDefines = outputDefines;
     const nativeSection = extractFrameworkSection(configObject, "native");
-    if (nativeSection)
+    if (nativeSection) {
         resolved.frameworkConfig = nativeSection;
+    }
+    // Parse zephyr-specific config section.
+    const zephyrKconfig = extractStringRecord(configObject, ["zephyr", "kconfig"]);
+    const zephyrCmakeArgs = extractStringArray(configObject, ["zephyr", "cmakeArgs"]);
+    const zephyrRunner = flat.get("zephyr.runner");
+    if (zephyrKconfig || zephyrCmakeArgs || typeof zephyrRunner === "string") {
+        resolved.zephyrConfig = {
+            ...(zephyrKconfig ? { kconfig: zephyrKconfig } : {}),
+            ...(zephyrCmakeArgs ? { cmakeArgs: zephyrCmakeArgs } : {}),
+            ...(typeof zephyrRunner === "string" ? { runner: zephyrRunner } : {}),
+        };
+    }
     // Parse display profile config (nested object with profile name, wiring, touch)
     const displaySection = extractFrameworkSection(configObject, "display");
     if (displaySection)
@@ -344,6 +359,8 @@ export function parseConfigFile(configPath) {
         structuredForValidation.entry = resolved.entry;
     if (resolved.framework)
         structuredForValidation.framework = resolved.framework;
+    if (resolved.psram)
+        structuredForValidation.psram = resolved.psram;
     if (resolved.outputFramework || resolved.outputOptimize || resolved.outputOutDir || resolved.outputExtraFlags || resolved.outputDefines) {
         structuredForValidation.output = {
             ...(resolved.outputFramework ? { framework: resolved.outputFramework } : {}),
@@ -355,6 +372,8 @@ export function parseConfigFile(configPath) {
     }
     if (resolved.console)
         structuredForValidation.console = resolved.console;
+    if (resolved.zephyrConfig)
+        structuredForValidation.zephyr = resolved.zephyrConfig;
     if (resolved.buildTarget) {
         structuredForValidation.frameworkData = { buildTarget: resolved.buildTarget };
     }
@@ -478,8 +497,9 @@ export function generateVirtualTypeDeclaration(config, platformDeclarations) {
     // `declare module` in cuttlefish-env.d.ts is treated as module augmentation
     // (because that file has `export {}`), which can't define a new module.
     //
-    // For contract-based configs, board.ts is generated by the board-codegen
-    // system, so don't overwrite it here.
+    // For contract-based configs, the narrowed board.ts is generated by the
+    // contract reader (`contract/board-generator.ts`, invoked from cli.ts before
+    // this function runs), so don't overwrite it with the generic re-export here.
     if (!config.contract && (config.board || config.mcu)) {
         const reExportSource = config.board ?? config.mcu;
         const boardTsPath = path.join(cuttlefishDir, "board.ts");