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

package/dist/host/cli.js

@@ -20,6 +20,9 @@
 // ---------------------------------------------------------------------------
 import { loadConfig } from './config.js';
 import { run } from './runner.js';
+import { boardTestPins } from './test-pins.js';
+import { listUsbSerialPorts, matchUsbPorts, formatUsbIdentity } from './port-discovery.js';
+import { resolveProjectRoot } from './project-root.js';
 import path from 'node:path';
 function parseArgs(argv) {
     const result = { files: [] };
@@ -78,6 +81,9 @@ function parseArgs(argv) {
             case '-v':
                 result.verbose = true;
                 break;
+            case '--discover':
+                result.discover = true;
+                break;
             case '--dry-run':
                 result.dryRun = true;
                 break;
@@ -103,41 +109,44 @@ function parseArgs(argv) {
 // ---------------------------------------------------------------------------
 // Help text
 // ---------------------------------------------------------------------------
-const HELP = `
-\x1b[1m\x1b[36m cuttlefish-test\x1b[0m — Hardware test runner for TypeCAD
-
-\x1b[1mUsage:\x1b[0m
-  cuttlefish-test [options] [files...]
-
-\x1b[1mOptions:\x1b[0m
-  --port, -p <port>     Serial port (e.g. COM4, /dev/ttyACM0)
-  --board, -b <board>   Board package override
-  --build-target <id>   Framework-specific build target override
-  --baud <rate>         Serial baud rate (default: 115200)
-  --timeout, -t <ms>    Serial read timeout (default: 30000)
-  --include, -i <glob>  Test file pattern (repeatable)
-  --exclude, -x <glob>  Test file pattern to skip (repeatable)
-  --verbose, -v         Show debug serial output
-  --help, -h            Show this help
-
-\x1b[1mExamples:\x1b[0m
-  cuttlefish-test --port COM4
-  cuttlefish-test --port /dev/ttyACM0 tests/my-test.test.ts
-  cuttlefish-test -p COM4 -v
-
-\x1b[1mConfiguration:\x1b[0m
-  Add a \`test\` section to your cuttlefish.config.ts:
-
-    const config = {
-      board: '@typecad/board-arduino-uno',
-      test: {
-        buildTarget: 'arduino:avr:uno',
-        port: 'COM4',
-        include: ['tests/**/*.test.ts'],
-        baudRate: 115200,
-        timeout: 30000,
-      },
-    };
+const HELP = `
+\x1b[1m\x1b[36m cuttlefish-test\x1b[0m — Hardware test runner for TypeCAD
+
+\x1b[1mUsage:\x1b[0m
+  cuttlefish-test [options] [files...]
+
+\x1b[1mOptions:\x1b[0m
+  --port, -p <port>     Serial port (e.g. COM4, /dev/ttyACM0)
+  --board, -b <board>   Board package override
+  --build-target <id>   Framework-specific build target override
+  --baud <rate>         Serial baud rate (default: 115200)
+  --timeout, -t <ms>    Serial read timeout (default: 30000)
+  --include, -i <glob>  Test file pattern (repeatable)
+  --exclude, -x <glob>  Test file pattern to skip (repeatable)
+  --verbose, -v         Show debug serial output
+  --discover            List attached USB serial ports (VID:PID, serial,
+                        manufacturer) and which one the current config/board
+                        identity matches, then exit — test-box bring-up aid
+  --help, -h            Show this help
+
+\x1b[1mExamples:\x1b[0m
+  cuttlefish-test --port COM4
+  cuttlefish-test --port /dev/ttyACM0 tests/my-test.test.ts
+  cuttlefish-test -p COM4 -v
+
+\x1b[1mConfiguration:\x1b[0m
+  Add a \`test\` section to your cuttlefish.config.ts:
+
+    const config = {
+      board: 'xiao_ble/nrf52840',
+      test: {
+        buildTarget: 'blackpill/stm32f411ce',
+        port: 'COM4',
+        include: ['tests/**/*.test.ts'],
+        baudRate: 115200,
+        timeout: 30000,
+      },
+    };
 `.trim();
 // ---------------------------------------------------------------------------
 // Main
@@ -148,7 +157,11 @@ async function main() {
         console.log(HELP);
         process.exit(0);
     }
-    const projectRoot = process.cwd();
+    // npm exec / npm run reset the child cwd to the npm local prefix (the
+    // nearest package.json ancestor), stashing the real invocation dir in
+    // INIT_CWD — resolve through it so nested suite dirs work under npx.
+    // See host/project-root.ts for the full rationale.
+    const projectRoot = resolveProjectRoot();
     // Build config overrides from CLI args
     const overrides = {};
     if (args.port)
@@ -190,6 +203,37 @@ async function main() {
     // CLI mode flags (not config-file settings).
     config.dryRun = args.dryRun;
     config.bail = args.bail;
+    // --discover: list attached USB serial ports and annotate the match for
+    // the active board identity (config test.usb, else the board's
+    // test-pins.json usb block). Bring-up aid for multi-board test boxes.
+    if (args.discover) {
+        const ports = await listUsbSerialPorts();
+        const identity = config.test.usb ?? boardTestPins(config.board, config.projectRoot, config.configPath)?.usb;
+        const matches = identity ? matchUsbPorts(ports, identity) : [];
+        console.log('USB serial ports:');
+        if (ports.length === 0) {
+            console.log('  (none found)');
+        }
+        for (const p of ports) {
+            const isMatch = identity ? matchUsbPorts([p], identity).length > 0 : false;
+            const id = `${p.vid.toUpperCase()}:${p.pid.toUpperCase()}`;
+            const serial = p.serialNumber ? ` serial ${p.serialNumber}` : '';
+            const mfr = p.manufacturer ? ` [${p.manufacturer}]` : '';
+            console.log(`  ${p.path}  ${id}${serial}${mfr}${isMatch ? '  <-- matches this config' : ''}`);
+        }
+        console.log();
+        if (identity) {
+            console.log(matches.length === 1
+                ? `config identity ${formatUsbIdentity(identity)} -> ${matches[0].path}`
+                : `config identity ${formatUsbIdentity(identity)} -> no unique match (${matches.length} found)`);
+        }
+        else {
+            console.log('(no USB identity on this config or board — set test.usb or a test-pins.json usb block)');
+        }
+        // Exit 1 when an identity is set but has no unique match, so scripts
+        // can gate on discovery success.
+        process.exit(identity ? (matches.length === 1 ? 0 : 1) : 0);
+    }
     // Run tests
     const exitCode = await run(config);
     process.exit(exitCode);

package/dist/host/compiler.d.ts

@@ -1,7 +1,7 @@
 export interface CompileResult {
     success: boolean;
-    sketchDir: string;
-    sketchPath: string;
+    projectDir: string;
+    sourcePath: string;
     output: string;
     error?: string;
 }
@@ -11,17 +11,17 @@ export interface UploadResult {
     error?: string;
 }
 /**
- * Transpile preprocessed TypeScript source to a C++ Arduino sketch (or Zephyr
- * project). Writes the preprocessed source to a temp file, invokes the cuttlefish
- * transpiler, and returns the path to the generated .ino (Arduino) or .cpp
- * (Zephyr) entry file.
+ * Transpile preprocessed TypeScript source to a C++ Zephyr project. Writes
+ * the preprocessed source to a temp file, invokes the cuttlefish transpiler,
+ * and returns the path to the generated .cpp entry file.
  */
-export declare function transpileTestFile(preprocessedSource: string, originalFilePath: string, projectRoot: string, buildTarget: string, toolchainType?: 'arduino-cli' | 'west', configPath?: string): CompileResult;
+export declare function transpileTestFile(preprocessedSource: string, originalFilePath: string, projectRoot: string, buildTarget: string, configPath?: string): CompileResult;
 /**
- * Compile the sketch/project via the configured toolchain (arduino-cli or west).
+ * Compile the Zephyr project via `west build` (through the Zephyr Toolchain).
  */
-export declare function compileSketch(sketchDir: string, buildTarget: string, framework?: string, toolchainType?: 'arduino-cli' | 'west', zephyrConfig?: Record<string, unknown>): CompileResult;
+export declare function compileProgram(projectDir: string, buildTarget: string, zephyrConfig?: Record<string, unknown>): CompileResult;
 /**
- * Upload the compiled sketch/project to the board via the configured toolchain.
+ * Upload the compiled project to the board via `west flash` (through the
+ * Zephyr Toolchain).
  */
-export declare function uploadSketch(sketchDir: string, buildTarget: string, port: string, framework?: string, toolchainType?: 'arduino-cli' | 'west', zephyrConfig?: Record<string, unknown>): UploadResult;
+export declare function uploadProgram(projectDir: string, buildTarget: string, port: string, zephyrConfig?: Record<string, unknown>): UploadResult;

package/dist/host/compiler.js

@@ -1,34 +1,25 @@
 // ---------------------------------------------------------------------------
 // @typecad/expect — Compiler
 //
-// Wraps the cuttlefish transpiler + arduino-cli compile/upload cycle.
-// Takes preprocessed TypeScript source, transpiles to C++, compiles, uploads.
+// Wraps the cuttlefish transpiler + west compile/flash cycle. Takes
+// preprocessed TypeScript source, transpiles to C++, compiles, uploads.
 // ---------------------------------------------------------------------------
 import path from 'node:path';
 import fs from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { createRequire } from 'node:module';
 import { parseConfigAST } from './config.js';
-import { checkArduinoEnv } from '@typecad/arduino-cli';
 // createRequire lets us use require() in an ESM module for the optional
-// framework-zephyr dynamic import (avoids a hard dependency for Arduino users).
+// framework-zephyr dynamic import.
 const require = createRequire(import.meta.url);
-/** Format a check failure into the `error` field used by CompileResult/UploadResult. */
-function formatEnvFailure(failure) {
-    const lines = [...failure.messages];
-    if (failure.fixCommand)
-        lines.push(`  Fix: ${failure.fixCommand}`);
-    return lines.join('\n');
-}
 /**
- * Transpile preprocessed TypeScript source to a C++ Arduino sketch (or Zephyr
- * project). Writes the preprocessed source to a temp file, invokes the cuttlefish
- * transpiler, and returns the path to the generated .ino (Arduino) or .cpp
- * (Zephyr) entry file.
+ * Transpile preprocessed TypeScript source to a C++ Zephyr project. Writes
+ * the preprocessed source to a temp file, invokes the cuttlefish transpiler,
+ * and returns the path to the generated .cpp entry file.
  */
-export function transpileTestFile(preprocessedSource, originalFilePath, projectRoot, buildTarget, toolchainType = 'arduino-cli', configPath) {
+export function transpileTestFile(preprocessedSource, originalFilePath, projectRoot, buildTarget, configPath) {
     // Create a build directory for this test file. Per-file directories are
-    // used — arduino-cli compile has no incremental benefit from a shared dir.
+    // used — west builds have no incremental benefit from a shared dir.
     const baseName = path.basename(originalFilePath, '.test.ts').replace(/[^a-zA-Z0-9_]/g, '_');
     const buildDir = path.join(projectRoot, '.build', 'expect', baseName);
     try {
@@ -37,7 +28,7 @@ export function transpileTestFile(preprocessedSource, originalFilePath, projectR
         fs.mkdirSync(buildDir, { recursive: true });
     }
     catch {
-        return { success: false, sketchDir: buildDir, sketchPath: '', output: '', error: `Failed to create build dir: ${buildDir}` };
+        return { success: false, projectDir: buildDir, sourcePath: '', output: '', error: `Failed to create build dir: ${buildDir}` };
     }
     const rewrittenSource = rewriteRelativeImports(preprocessedSource, originalFilePath, buildDir);
     // Write the preprocessed source as a .ts file
@@ -51,7 +42,7 @@ export function transpileTestFile(preprocessedSource, originalFilePath, projectR
     // OR when an explicit configPath was passed. The latter matters because
     // direct-file mode discovers cuttlefish.config.ts from cwd (projectRoot),
     // which is the DEFAULT config — so a project with several target-specific
-    // configs (e.g. tests/hardware/cuttlefish.config.ts vs ble-demo.config.ts)
+    // configs (e.g. packages/hal/tests/network/cuttlefish.config.ts vs ble-demo.config.ts)
     // would always transpile against the default. Build mode writes a config
     // derived from the chosen configPath into the build dir, so the right
     // board/MCU/target is used.
@@ -59,99 +50,70 @@ export function transpileTestFile(preprocessedSource, originalFilePath, projectR
     if (useBuildMode) {
         writeBuildConfig(buildDir, projectRoot, path.basename(tsPath), buildTarget, configPath);
     }
-    const result = spawnSync(process.execPath, useBuildMode
-        ? [cuttlefishCmd, 'build', '--skip-type-check', '--force']
-        : [cuttlefishCmd, tsPath, '--skip-type-check', '--force'], {
+    const result = spawnSync(process.execPath, 
+    // Explicit heap headroom for the transpile child. The steady-state
+    // transpile peaks well under 1 GB, but Node's default old-space cap
+    // (~4 GB on large-RAM machines) has been hit transiently — a GC storm
+    // then kills the child with "JavaScript heap out of memory" and fails
+    // the whole test file. Dedicated headroom makes a spike recoverable.
+    [
+        '--max-old-space-size=6144',
+        cuttlefishCmd,
+        ...(useBuildMode
+            ? ['build', '--skip-type-check', '--force']
+            : [tsPath, '--skip-type-check', '--force']),
+    ], {
         encoding: 'utf8',
         cwd: useBuildMode ? buildDir : projectRoot,
-        timeout: 60000,
+        timeout: 120000,
         env: { ...process.env },
     });
     const transpileOutput = `${result.stdout ?? ''}\n${result.stderr ?? ''}`.trim();
     if (result.status !== 0) {
+        // Surface spawn-level errors (EMFILE/ENOENT from a degraded runner —
+        // e.g. after serial-handle leaks): spawnSync reports them on .error
+        // with a null status and EMPTY stdout/stderr, which previously masked
+        // the cause as a bare "Transpilation failed:".
+        const spawnErr = result.error ? ` (spawn error: ${result.error.message})` : '';
         return {
             success: false,
-            sketchDir: buildDir,
-            sketchPath: '',
+            projectDir: buildDir,
+            sourcePath: '',
             output: transpileOutput,
-            error: `Transpilation failed:\n${transpileOutput}`,
+            error: `Transpilation failed${spawnErr}:\n${transpileOutput}`,
         };
     }
-    // Find the generated entry file (.ino for Arduino, .cpp for Zephyr)
-    const outDir = findOutputDir(buildDir, baseName, projectRoot, toolchainType);
-    const entryPath = findEntryFile(outDir, toolchainType);
+    // Find the generated entry file (.cpp for Zephyr)
+    const outDir = findOutputDir(buildDir, baseName, projectRoot);
+    const entryPath = findEntryFile(outDir);
     if (!entryPath) {
-        const ext = toolchainType === 'west' ? '.cpp' : '.ino';
         return {
             success: false,
-            sketchDir: outDir,
-            sketchPath: '',
+            projectDir: outDir,
+            sourcePath: '',
             output: transpileOutput,
-            error: `No ${ext} file found in ${outDir} after transpilation`,
+            error: `No .cpp file found in ${outDir} after transpilation`,
         };
     }
     return {
         success: true,
-        sketchDir: path.dirname(entryPath),
-        sketchPath: entryPath,
+        projectDir: path.dirname(entryPath),
+        sourcePath: entryPath,
         output: transpileOutput,
     };
 }
 /**
- * Compile the sketch/project via the configured toolchain (arduino-cli or west).
+ * Compile the Zephyr project via `west build` (through the Zephyr Toolchain).
  */
-export function compileSketch(sketchDir, buildTarget, framework, toolchainType = 'arduino-cli', zephyrConfig) {
-    if (toolchainType === 'west') {
-        return compileWestProject(sketchDir, buildTarget, zephyrConfig);
-    }
-    return compileArduinoSketch(sketchDir, buildTarget);
-}
-/** Compile via arduino-cli. */
-function compileArduinoSketch(sketchDir, buildTarget) {
-    // Hard gate: verify arduino-cli + core before spawning.
-    {
-        const gate = checkArduinoEnv(buildTarget);
-        if (!gate.ok) {
-            const message = formatEnvFailure(gate);
-            return { success: false, sketchDir, sketchPath: '', output: message, error: message };
-        }
-    }
-    const result = spawnSync('arduino-cli', ['compile', '--fqbn', buildTarget, sketchDir], { encoding: 'utf8', timeout: 120000 });
-    const output = `${result.stdout ?? ''}\n${result.stderr ?? ''}`.trim();
-    return {
-        success: result.status === 0,
-        sketchDir,
-        sketchPath: '',
-        output,
-        error: result.status !== 0 ? `Compilation failed:\n${output}` : undefined,
-    };
+export function compileProgram(projectDir, buildTarget, zephyrConfig) {
+    return compileWestProject(projectDir, buildTarget, zephyrConfig);
 }
 /**
- * Upload the compiled sketch/project to the board via the configured toolchain.
+ * Upload the compiled project to the board via `west flash` (through the
+ * Zephyr Toolchain).
  */
-export function uploadSketch(sketchDir, buildTarget, port, framework, toolchainType = 'arduino-cli', zephyrConfig) {
-    if (toolchainType === 'west') {
-        return uploadWestProject(sketchDir, buildTarget, port, zephyrConfig);
-    }
-    return uploadArduinoSketch(sketchDir, buildTarget, port);
-}
-/** Upload via arduino-cli. */
-function uploadArduinoSketch(sketchDir, buildTarget, port) {
-    // Hard gate: verify arduino-cli + core before spawning.
-    {
-        const gate = checkArduinoEnv(buildTarget);
-        if (!gate.ok) {
-            const message = formatEnvFailure(gate);
-            return { success: false, output: message, error: message };
-        }
-    }
-    const result = spawnSync('arduino-cli', ['upload', '--fqbn', buildTarget, '--port', port, sketchDir], { encoding: 'utf8', timeout: 60000 });
-    const output = `${result.stdout ?? ''}\n${result.stderr ?? ''}`.trim();
-    return {
-        success: result.status === 0,
-        output,
-        error: result.status !== 0 ? `Upload failed:\n${output}` : undefined,
-    };
+export function uploadProgram(projectDir, buildTarget, port, zephyrConfig) {
+    return uploadWestProject(projectDir, buildTarget, port, zephyrConfig);
 }
 // ---------------------------------------------------------------------------
 // Zephyr (west) toolchain
@@ -159,25 +121,25 @@ function uploadArduinoSketch(sketchDir, buildTarget, port) {
 /**
  * Compile a Zephyr project via `west build`. The Zephyr Toolchain (from
  * @typecad/framework-zephyr) handles west discovery, ZEPHYR_BASE, scaffolding,
- * and the board target. We call it via dynamic import to avoid a hard
- * dependency on framework-zephyr (the Arduino path doesn't need it).
+ * and the board target. We call it via dynamic import so expect only gains
+ * the dependency when framework-zephyr is installed.
  */
-function compileWestProject(sketchDir, buildTarget, zephyrConfig) {
-    // sketchDir for Zephyr is the project root containing src/, app/, build/.
+function compileWestProject(projectDir, buildTarget, zephyrConfig) {
+    // projectDir for Zephyr is the project root containing src/, app/, build/.
     // The transpiler emits src/src.cpp; the west project root is the parent of src/.
-    const srcDir = path.join(sketchDir, 'src');
-    const projectRoot = fs.existsSync(srcDir) ? sketchDir : path.dirname(sketchDir);
+    const srcDir = path.join(projectDir, 'src');
+    const projectRoot = fs.existsSync(srcDir) ? projectDir : path.dirname(projectDir);
     const sourcePath = fs.existsSync(path.join(srcDir, 'src.cpp'))
         ? path.join(srcDir, 'src.cpp')
-        : path.join(sketchDir, 'src.cpp');
-    const outputDir = fs.existsSync(srcDir) ? srcDir : sketchDir;
+        : path.join(projectDir, 'src.cpp');
+    const outputDir = fs.existsSync(srcDir) ? srcDir : projectDir;
     try {
         // Dynamic import — framework-zephyr is an optional dependency (only present
         // for Zephyr projects). The Toolchain object has compile()/upload().
         const mod = require('@typecad/framework-zephyr');
         const Toolchain = mod.Toolchain;
         if (!Toolchain || typeof Toolchain.compile !== 'function') {
-            return { success: false, sketchDir, sketchPath: '', output: '', error: '@typecad/framework-zephyr did not export a usable Toolchain.compile().' };
+            return { success: false, projectDir, sourcePath: '', output: '', error: '@typecad/framework-zephyr did not export a usable Toolchain.compile().' };
         }
         const result = Toolchain.compile({
             outputDir,
@@ -187,27 +149,27 @@ function compileWestProject(sketchDir, buildTarget, zephyrConfig) {
         });
         return {
             success: result.success,
-            sketchDir: projectRoot,
-            sketchPath: sourcePath,
+            projectDir: projectRoot,
+            sourcePath: sourcePath,
             output: result.output,
             error: result.success ? undefined : `west build failed:\n${result.output}`,
         };
     }
     catch (e) {
-        return { success: false, sketchDir, sketchPath: '', output: '', error: `Failed to compile via west: ${e.message}` };
+        return { success: false, projectDir, sourcePath: '', output: '', error: `Failed to compile via west: ${e.message}` };
     }
 }
 /**
  * Upload (flash) a Zephyr project via `west flash`. For ESP32 boards, west
  * uses the esptool runner; for nRF boards, nrfjprog. The port is forwarded.
  */
-function uploadWestProject(sketchDir, buildTarget, port, zephyrConfig) {
-    const srcDir = path.join(sketchDir, 'src');
-    const projectRoot = fs.existsSync(srcDir) ? sketchDir : path.dirname(sketchDir);
+function uploadWestProject(projectDir, buildTarget, port, zephyrConfig) {
+    const srcDir = path.join(projectDir, 'src');
+    const projectRoot = fs.existsSync(srcDir) ? projectDir : path.dirname(projectDir);
     const sourcePath = fs.existsSync(path.join(srcDir, 'src.cpp'))
         ? path.join(srcDir, 'src.cpp')
-        : path.join(sketchDir, 'src.cpp');
-    const outputDir = fs.existsSync(srcDir) ? srcDir : sketchDir;
+        : path.join(projectDir, 'src.cpp');
+    const outputDir = fs.existsSync(srcDir) ? srcDir : projectDir;
     try {
         const mod = require('@typecad/framework-zephyr');
         const Toolchain = mod.Toolchain;
@@ -258,7 +220,7 @@ function resolveCuttlefishCmd(projectRoot) {
     // Fallback: assume it's on PATH
     return 'cuttlefish';
 }
-function findOutputDir(buildDir, baseName, projectRoot, toolchainType = 'arduino-cli') {
+function findOutputDir(buildDir, baseName, projectRoot) {
     // The cuttlefish transpiler writes output next to the source by default,
     // or to the configured outDir.  Check common locations.
     const candidates = [
@@ -270,59 +232,54 @@ function findOutputDir(buildDir, baseName, projectRoot, toolchainType = 'arduino
         path.join(projectRoot, '.build', 'expect', baseName, baseName),
     ];
     for (const c of candidates) {
-        if (fs.existsSync(c) && hasEntryFile(c, toolchainType))
+        if (fs.existsSync(c) && hasEntryFile(c))
             return c;
     }
     // Last resort: walk the buildDir tree recursively to find any entry file
-    const found = findEntryFileRecursive(buildDir, toolchainType);
+    const found = findEntryFileRecursive(buildDir);
     if (found)
         return path.dirname(found);
     return buildDir;
 }
-/** Check for a .ino (Arduino) or .cpp (Zephyr) entry file in a directory. */
-function hasEntryFile(dir, toolchainType = 'arduino-cli') {
+/** Check for a .cpp entry file in a directory. */
+function hasEntryFile(dir) {
     if (!fs.existsSync(dir))
         return false;
-    return fs.readdirSync(dir).some(f => isEntryFileName(f, toolchainType));
+    return fs.readdirSync(dir).some(f => isEntryFileName(f));
 }
-/** True if the filename is a valid entry file for the toolchain. */
-function isEntryFileName(name, toolchainType) {
-    if (toolchainType === 'west') {
-        return name.endsWith('.cpp') || name.endsWith('.cc');
-    }
-    return name.endsWith('.ino') || name.endsWith('.cc');
+/** True if the filename is a valid entry file (.cpp/.cc). */
+function isEntryFileName(name) {
+    return name.endsWith('.cpp') || name.endsWith('.cc');
 }
-/** Find the entry file (.ino for Arduino, .cpp for Zephyr) in a directory. */
-function findEntryFile(dir, toolchainType = 'arduino-cli') {
+/** Find the entry .cpp file in a directory (or its src/ subdirectory). */
+function findEntryFile(dir) {
     if (!fs.existsSync(dir))
         return undefined;
     for (const entry of fs.readdirSync(dir)) {
-        if (isEntryFileName(entry, toolchainType)) {
+        if (isEntryFileName(entry)) {
             return path.join(dir, entry);
         }
     }
-    // For Zephyr, the entry may be in a src/ subdirectory
-    if (toolchainType === 'west') {
-        const srcDir = path.join(dir, 'src');
-        if (fs.existsSync(srcDir)) {
-            for (const entry of fs.readdirSync(srcDir)) {
-                if (isEntryFileName(entry, toolchainType)) {
-                    return path.join(srcDir, entry);
-                }
+    // The entry may be in a src/ subdirectory
+    const srcDir = path.join(dir, 'src');
+    if (fs.existsSync(srcDir)) {
+        for (const entry of fs.readdirSync(srcDir)) {
+            if (isEntryFileName(entry)) {
+                return path.join(srcDir, entry);
             }
         }
     }
     return undefined;
 }
-function findEntryFileRecursive(dir, toolchainType = 'arduino-cli') {
+function findEntryFileRecursive(dir) {
     if (!fs.existsSync(dir))
         return undefined;
     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        if (isEntryFileName(entry.name, toolchainType)) {
+        if (isEntryFileName(entry.name)) {
             return path.join(dir, entry.name);
         }
         if (entry.isDirectory()) {
-            const result = findEntryFileRecursive(path.join(dir, entry.name), toolchainType);
+            const result = findEntryFileRecursive(path.join(dir, entry.name));
             if (result)
                 return result;
         }
@@ -379,11 +336,6 @@ function writeBuildConfig(buildDir, projectRoot, entryFileName, buildTarget, con
             lines.push(`    framework: '${baseValues.output?.framework}',`);
         lines.push(`    outDir: './out',`);
         lines.push('  },');
-        if (baseValues.console?.baudRate) {
-            lines.push('  console: {');
-            lines.push(`    baudRate: ${baseValues.console?.baudRate},`);
-            lines.push('  },');
-        }
         // Pass the zephyr section (kconfig, runner) through verbatim — the Zephyr
         // toolchain reads runner from it (e.g. zephyr.runner: 'uf2'). Serialize the
         // parsed object as a minimal object literal (string values only; sufficient
@@ -406,12 +358,12 @@ function writeBuildConfig(buildDir, projectRoot, entryFileName, buildTarget, con
         '',
         'const config: CuttlefishConfig = {',
         `  entry: './${entryFileName}',`,
-        `  target: 'avr',`,
+        `  framework: '@typecad/framework-zephyr',`,
         `  frameworkData: { buildTarget: '${buildTarget}' },`,
         '  output: {',
-        `    framework: 'arduino',`,
         `    outDir: './out',`,
         '  },',
+        '  toolchain: { type: \'west\' },',
         '};',
         '',
         'export default config;',

package/dist/host/config.d.ts

@@ -26,8 +26,5 @@ export interface RawConfig {
         framework?: string;
         outDir?: string;
     };
-    console?: {
-        baudRate?: number;
-    };
 }
 export declare function parseConfigAST(configPath: string): RawConfig;