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

package/dist/create/index.d.ts

@@ -1,17 +1,12 @@
-export { scaffoldProject, normalizeProjectName, KNOWN_TARGETS, KNOWN_BOARDS, registerKnownTarget, printInitNextSteps } from './init-scaffold.js';
-export type { KnownTarget, KnownBoard, ScaffoldProjectResult } from './init-scaffold.js';
-export { FRAMEWORK_CATALOG, frameworksForTarget, frameworkCatalogEntry, detectPackageManager, frameworkTargetProfile } from './framework-catalog.js';
-export type { FrameworkCatalogEntry, BoardLike, PackageManager, FrameworkTargetProfile, TargetProfileInput } from './framework-catalog.js';
+export { scaffoldProject, normalizeProjectName, KNOWN_TARGETS, printCreateNextSteps } from './scaffold.js';
+export type { KnownTarget, ScaffoldProjectResult } from './scaffold.js';
+export { FRAMEWORK_CATALOG, frameworksForTarget, frameworkCompatibleWithTarget, frameworkCatalogEntry, detectPackageManager, frameworkTargetProfile, probeMethodsForBoard } from './framework-catalog.js';
+export type { FrameworkCatalogEntry, BoardLike, PackageManager, FrameworkTargetProfile, TargetProfileInput, CatalogProbeMethod } from './framework-catalog.js';
 export { installProjectDependencies, __setProjectInstallRunnerForTest } from './install-deps.js';
 export type { ProjectInstallResult } from './install-deps.js';
-export { generateProjectPackageJson, generateProjectTsconfig, generateProjectConfig, generateProjectEnvDts, generateStarterSketch, generateStarterTest, generateStarterSim, generateGitignore, generateEslintConfig, } from './init-templates.js';
-export type { InitProjectOptions } from './init-templates.js';
-export { runInitWizard } from './init-wizard.js';
+export { generateProjectPackageJson, generateProjectTsconfig, generateProjectConfig, generateProjectEnvDts, generateStarterProgram, generateStarterTest, generateStarterSim, generateGitignore, generateEditorconfig, generateEslintConfig, } from './templates.js';
+export type { CreateProjectOptions } from './templates.js';
+export { runCreateWizard } from './wizard.js';
 export { generateFrameworkDebugArtifacts } from './debug-artifacts.js';
 export type { FrameworkDebugArtifactsOptions, FrameworkModuleLoader } from './debug-artifacts.js';
-export { scaffoldBoardPackages } from './board-codegen.js';
-export type { ScaffoldBoardResult } from './board-codegen.js';
-export { generateFrameworkChecklist } from './board-checklist.js';
-export { parseBoardSpec, safeParseBoardSpec, stripJsonc, BoardSpecSchema } from './board-spec.js';
-export type { BoardSpec } from './board-spec.js';
-export * as BoardGenerators from './board-generators.js';
+export { generateExtensionsJson, generateTasksJson, watchBuildTask, writeEditorIntegration, bundledExtensionSourceDir, typecadUiExtensionSourceDir, TYPECAD_UI_EXTENSION_ID, TYPECAD_DEBUG_EXTENSION_ID, WATCH_TASK_LABEL, } from './editor-integration.js';

package/dist/create/index.js

@@ -1,11 +1,7 @@
-export { scaffoldProject, normalizeProjectName, KNOWN_TARGETS, KNOWN_BOARDS, registerKnownTarget, printInitNextSteps } from './init-scaffold.js';
-export { FRAMEWORK_CATALOG, frameworksForTarget, frameworkCatalogEntry, detectPackageManager, frameworkTargetProfile } from './framework-catalog.js';
+export { scaffoldProject, normalizeProjectName, KNOWN_TARGETS, printCreateNextSteps } from './scaffold.js';
+export { FRAMEWORK_CATALOG, frameworksForTarget, frameworkCompatibleWithTarget, frameworkCatalogEntry, detectPackageManager, frameworkTargetProfile, probeMethodsForBoard } from './framework-catalog.js';
 export { installProjectDependencies, __setProjectInstallRunnerForTest } from './install-deps.js';
-export { generateProjectPackageJson, generateProjectTsconfig, generateProjectConfig, generateProjectEnvDts, generateStarterSketch, generateStarterTest, generateStarterSim, generateGitignore, generateEslintConfig, } from './init-templates.js';
-export { runInitWizard } from './init-wizard.js';
+export { generateProjectPackageJson, generateProjectTsconfig, generateProjectConfig, generateProjectEnvDts, generateStarterProgram, generateStarterTest, generateStarterSim, generateGitignore, generateEditorconfig, generateEslintConfig, } from './templates.js';
+export { runCreateWizard } from './wizard.js';
 export { generateFrameworkDebugArtifacts } from './debug-artifacts.js';
-// Board codegen tool (`cuttlefish board add`)
-export { scaffoldBoardPackages } from './board-codegen.js';
-export { generateFrameworkChecklist } from './board-checklist.js';
-export { parseBoardSpec, safeParseBoardSpec, stripJsonc, BoardSpecSchema } from './board-spec.js';
-export * as BoardGenerators from './board-generators.js';
+export { generateExtensionsJson, generateTasksJson, watchBuildTask, writeEditorIntegration, bundledExtensionSourceDir, typecadUiExtensionSourceDir, TYPECAD_UI_EXTENSION_ID, TYPECAD_DEBUG_EXTENSION_ID, WATCH_TASK_LABEL, } from './editor-integration.js';

package/dist/create/mcu-target.d.ts

@@ -0,0 +1,39 @@
+import { type KnownMcu, type KnownTarget } from './scaffold.js';
+/** An MCU catalog entry shaped for the create flow (KnownTarget-compatible:
+ *  no board target, soc set, plus the silicon extras). */
+export interface McuCreateTarget extends KnownTarget {
+    isNative: false;
+    board?: undefined;
+    /** Zephyr SoC name — the curated soc descriptor key. */
+    soc: string;
+    /** Datasheet port pin for the starter program. */
+    starterPin: string;
+}
+/** Look up an MCU catalog entry by id (e.g. 'stm32f411'). */
+export declare function findKnownMcu(id: string): KnownMcu | undefined;
+/** Convert a catalog entry into the create-flow target shape. */
+export declare function mcuAsTarget(mcu: KnownMcu): McuCreateTarget;
+/** True when the MCU package carries silicon Zephyr data (socs) — the
+ *  precondition for both generated custom boards and the board snapshot. */
+export declare function mcuSupportsZephyr(mcu: McuCreateTarget): boolean;
+/** A snapshot board plus its default qualified `west build -b` target. */
+export interface McuZephyrBoard {
+    name: string;
+    vendor: string;
+    soc: string;
+    /** Qualified target (e.g. 'blackpill_f411ce/stm32f411xe',
+     *  'esp32s3_devkitc/esp32s3/procpu'). */
+    target: string;
+}
+/** Every catalog board variant whose SoC matches the bare-silicon soc. */
+export declare function zephyrBoardsForMcu(mcu: McuCreateTarget): McuZephyrBoard[];
+/** Look one board up by its (bare) name — for the non-interactive
+ *  `--zephyr-board <name>` flag. Undefined when the board is not in the
+ *  snapshot under one of the MCU's SoCs. */
+export declare function findZephyrBoardForMcu(mcu: McuCreateTarget, name: string): McuZephyrBoard | undefined;
+/**
+ * Sanitize a raw name into a legal Zephyr board name — the same rules
+ * framework-zephyr's generator applies (lowercase `[a-z0-9_]`), duplicated
+ * here because create runs before the framework package is installed.
+ */
+export declare function sanitizeBoardName(raw: string): string;

package/dist/create/mcu-target.js

@@ -0,0 +1,80 @@
+// ---------------------------------------------------------------------------
+// MCU-only create-target resolution
+//
+// Shared logic for `cuttlefish create --mcu <id>` and the wizard's bare-MCU
+// entries: framework narrowing (Zephyr needs the package's silicon zephyr
+// block), the Zephyr board decision (generated custom board vs any upstream
+// board whose SoC matches, from the exhaustive snapshot), and the default
+// qualified `west build -b` target.
+// ---------------------------------------------------------------------------
+import { KNOWN_MCUS } from './scaffold.js';
+import { activeBoardCatalog } from './active-board-catalog.js';
+/** Look up an MCU catalog entry by id (e.g. 'stm32f411'). */
+export function findKnownMcu(id) {
+    return KNOWN_MCUS.find((m) => m.id === id);
+}
+/** Convert a catalog entry into the create-flow target shape. */
+export function mcuAsTarget(mcu) {
+    return {
+        id: mcu.id,
+        displayName: mcu.displayName,
+        isNative: false,
+        architecture: mcu.architecture,
+        soc: mcu.soc,
+        starterPin: mcu.starterPin,
+    };
+}
+/** True when the MCU package carries silicon Zephyr data (socs) — the
+ *  precondition for both generated custom boards and the board snapshot. */
+export function mcuSupportsZephyr(mcu) {
+    return true;
+}
+// ── Zephyr board snapshot ────────────────────────────────────────────────────
+/**
+ * CPU-cluster qualifier defaults for multi-variant SoCs — Zephyr rejects the
+ * bare board name when a board ships multiple variants with no default, and
+ * the application core / M33 cluster is the one firmware targets (mirrors the
+ * qualified forms in framework-catalog's ZEPHYR_BOARD_IDS).
+ */
+const SOC_CLUSTER_QUALIFIER = {
+    esp32: 'procpu',
+    esp32s3: 'procpu',
+    esp32c6: 'hpcore',
+    rp2350a: 'm33',
+    rp2350b: 'm33',
+};
+/** Every catalog board variant whose SoC matches the bare-silicon soc. */
+export function zephyrBoardsForMcu(mcu) {
+    const results = [];
+    for (const [identifier, entry] of Object.entries(activeBoardCatalog())) {
+        const soc = identifier.split('/')[1];
+        if (soc !== mcu.soc)
+            continue;
+        results.push({
+            name: entry.name,
+            vendor: entry.vendor,
+            soc,
+            target: identifier,
+        });
+    }
+    return results.sort((a, b) => a.name.localeCompare(b.name));
+}
+/** Look one board up by its (bare) name — for the non-interactive
+ *  `--zephyr-board <name>` flag. Undefined when the board is not in the
+ *  snapshot under one of the MCU's SoCs. */
+export function findZephyrBoardForMcu(mcu, name) {
+    return zephyrBoardsForMcu(mcu).find((b) => b.name === name);
+}
+// ── Custom-board naming ──────────────────────────────────────────────────────
+/**
+ * Sanitize a raw name into a legal Zephyr board name — the same rules
+ * framework-zephyr's generator applies (lowercase `[a-z0-9_]`), duplicated
+ * here because create runs before the framework package is installed.
+ */
+export function sanitizeBoardName(raw) {
+    const cleaned = raw
+        .toLowerCase()
+        .replace(/[^a-z0-9_]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+    return cleaned.length > 0 ? cleaned : 'custom_board';
+}

package/dist/create/pack-targets.d.ts

@@ -0,0 +1,19 @@
+import type { BoardDataEntry } from '../board-catalog/types.js';
+import type { KnownTarget } from './scaffold.js';
+export declare function architectureFromSoc(soc: string): string;
+/** Look up a pack entry by qualified identifier or bare board name.
+ *  Bare names with multiple variants return the first (deterministic —
+ *  the pack is keyed in directory-walk order). */
+export declare function findPackBoard(idOrTarget: string): {
+    identifier: string;
+    name: string;
+    vendor: string;
+    soc: string;
+    probeMethods?: BoardDataEntry['probeMethods'];
+} | undefined;
+/** Build a create-flow KnownTarget from a pack entry. */
+export declare function packBoardAsTarget(entry: {
+    identifier: string;
+    name: string;
+    soc: string;
+}): KnownTarget;

package/dist/create/pack-targets.js

@@ -0,0 +1,56 @@
+// ---------------------------------------------------------------------------
+// pack-targets.ts — any-board target resolution off the generated catalog.
+//
+// The curated KNOWN_TARGETS list covers the nine hardware-validated boards;
+// the board data pack carries every Zephyr board variant (1,300+). This
+// module turns a pack entry into the same KnownTarget shape the create flow
+// consumes, so `cuttlefish create --target <any-zephyr-board>` works with no
+// per-board catalog entry. The soc's prefix derives an architecture id for
+// framework narrowing (the fallback maps unknowns to zephyr anyway).
+// ---------------------------------------------------------------------------
+import { activeBoardCatalog, findBoardInCatalog } from '../board-catalog/index.js';
+/** A coarse architecture id derived from a Zephyr soc name. Used only for
+ *  framework narrowing and display — every value here resolves through
+ *  FALLBACK_FRAMEWORKS to zephyr, which is correct for every pack board;
+ *  the known families just display nicely. */
+const SOC_FAMILIES = [
+    [/^esp32/, 'esp32'],
+    [/^nrf5/, 'nrf52'],
+    [/^nrf9/, 'nrf91'],
+    [/^stm32/, 'stm32'],
+    [/^stm32mp/, 'stm32mp1'],
+    [/^rp2/, 'rp2040'],
+    [/^samd/, 'samd'],
+    [/^mcimx|^imx/, 'imx'],
+];
+export function architectureFromSoc(soc) {
+    for (const [re, family] of SOC_FAMILIES) {
+        if (re.test(soc))
+            return family;
+    }
+    return soc;
+}
+/** Look up a pack entry by qualified identifier or bare board name.
+ *  Bare names with multiple variants return the first (deterministic —
+ *  the pack is keyed in directory-walk order). */
+export function findPackBoard(idOrTarget) {
+    const data = activeBoardCatalog();
+    const raw = idOrTarget.trim();
+    const entry = findBoardInCatalog(data, raw);
+    if (entry) {
+        return { identifier: entry.identifier, name: entry.name, vendor: entry.vendor, soc: entry.identifier.split('/')[1], probeMethods: entry.probeMethods };
+    }
+    return undefined;
+}
+/** Build a create-flow KnownTarget from a pack entry. */
+export function packBoardAsTarget(entry) {
+    return {
+        id: entry.identifier.split('/')[0],
+        displayName: entry.name,
+        isNative: false,
+        architecture: architectureFromSoc(entry.soc),
+        board: entry.identifier,
+        buildTarget: entry.identifier,
+        soc: entry.soc,
+    };
+}

package/dist/create/{init-scaffold.d.ts → scaffold.d.ts}

@@ -1,11 +1,13 @@
 import type { ArchitectureIdentifier } from "../api/index.js";
-import type { InitProjectOptions } from "./init-templates.js";
+import type { CreateProjectOptions } from "./templates.js";
 export interface KnownTarget {
     id: string;
     displayName: string;
     isNative: boolean;
     architecture?: ArchitectureIdentifier;
-    boardPackage?: string;
+    /** Qualified Zephyr board target — the config's board: value and the
+     *  boardgen input (materialized to .cuttlefish/board.ts at create). */
+    board?: string;
     /** Framework package + id. Optional on embedded targets: the scaffold wizard
      *  fills these in by discovering installed @typecad/framework-* packages, so
      *  KNOWN_TARGETS board entries do not hardcode a framework. Native targets
@@ -13,25 +15,20 @@ export interface KnownTarget {
     frameworkPackage?: string;
     framework?: string;
     buildTarget?: string;
-    mcu?: string;
+    soc?: string;
     /** Framework-specific config (becomes frameworkData in cuttlefish.config.ts).
      *  Carries framework-specific target/options data for the selected framework. */
     frameworkData?: Record<string, unknown>;
 }
-export declare function registerKnownTarget(target: KnownTarget): void;
 export declare const KNOWN_TARGETS: ReadonlyArray<KnownTarget>;
-/** @deprecated Use KNOWN_TARGETS */
-export declare const KNOWN_BOARDS: KnownTarget[];
-/** @deprecated Use KnownTarget */
-export type KnownBoard = KnownTarget;
 export declare function normalizeProjectName(name: string): string;
 export interface ScaffoldProjectResult {
     createdFiles: string[];
     outDir: string;
-    options: InitProjectOptions;
+    options: CreateProjectOptions;
 }
-export declare function scaffoldProject(options: InitProjectOptions, outDir?: string): ScaffoldProjectResult;
-export declare function printInitNextSteps(options: InitProjectOptions, outDir: string, opts?: {
+export declare function scaffoldProject(options: CreateProjectOptions, outDir?: string): ScaffoldProjectResult;
+export declare function printCreateNextSteps(options: CreateProjectOptions, outDir: string, opts?: {
     installed?: boolean;
     debugProfile?: boolean;
 }): void;

package/dist/create/{init-scaffold.js → scaffold.js}

@@ -1,8 +1,9 @@
 import path from "node:path";
 import fs from "node:fs";
 import chalk from "chalk";
-import { generateProjectPackageJson, generateProjectTsconfig, generateProjectConfig, generateProjectEnvDts, generateStarterSketch, generateStarterTest, generateStarterSim, generateGitignore, generateBoardForwardingFile, generateEslintConfig, } from "./init-templates.js";
+import { generateProjectPackageJson, generateProjectTsconfig, generateProjectConfig, generateProjectEnvDts, generateStarterProgram, generateStarterTest, generateStarterSim, generateGitignore, generateEditorconfig, generateEslintConfig, } from "./templates.js";
 import { generateEslintRules } from "./eslint-rules-template.js";
+import { writeEditorIntegration } from "./editor-integration.js";
 const _knownTargets = [
     {
         id: 'native',
@@ -11,82 +12,10 @@ const _knownTargets = [
         frameworkPackage: '@typecad/framework-native',
         framework: 'native',
     },
-    {
-        id: 'arduino-uno',
-        displayName: 'Arduino Uno',
-        isNative: false,
-        architecture: 'avr',
-        boardPackage: '@typecad/board-arduino-uno',
-        buildTarget: 'arduino:avr:uno',
-        mcu: 'atmega328p',
-    },
-    {
-        id: 'esp32-devkit',
-        displayName: 'ESP32 DevKit',
-        isNative: false,
-        architecture: 'esp32',
-        boardPackage: '@typecad/board-esp32-devkit',
-        buildTarget: 'esp32:esp32:esp32',
-        mcu: 'esp32',
-    },
-    {
-        id: 'esp32s3',
-        displayName: 'ESP32-S3',
-        isNative: false,
-        architecture: 'esp32s3',
-        boardPackage: '@typecad/board-esp32s3',
-        buildTarget: 'esp32:esp32:esp32s3',
-        mcu: 'esp32s3',
-    },
-    {
-        id: 'esp32c3',
-        displayName: 'ESP32-C3',
-        isNative: false,
-        architecture: 'esp32c3',
-        boardPackage: '@typecad/board-esp32c3',
-        buildTarget: 'esp32:esp32:esp32c3',
-        mcu: 'esp32c3',
-    },
-    {
-        id: 'esp32c6',
-        displayName: 'ESP32-C6',
-        isNative: false,
-        architecture: 'esp32c6',
-        boardPackage: '@typecad/board-esp32c6',
-        buildTarget: 'esp32:esp32:esp32c6',
-        mcu: 'esp32c6',
-    },
-    {
-        id: 'rp2040',
-        displayName: 'RP2040 (Pico)',
-        isNative: false,
-        architecture: 'rp2040',
-        boardPackage: '@typecad/board-rp2040',
-        buildTarget: 'rp2040:rp2040:rpipico',
-        mcu: 'rp2040',
-    },
-    {
-        id: 'rp2350',
-        displayName: 'RP2350 (Pico 2)',
-        isNative: false,
-        architecture: 'rp2350',
-        boardPackage: '@typecad/board-rp2350',
-        buildTarget: 'rp2040:rp2040:rpipico2',
-        mcu: 'rp2350',
-    },
 ];
-export function registerKnownTarget(target) {
-    const existing = _knownTargets.findIndex(t => t.id === target.id);
-    if (existing >= 0) {
-        _knownTargets[existing] = target;
-    }
-    else {
-        _knownTargets.push(target);
-    }
-}
+// Bare-silicon (contract) targets were removed with the curated soc layer:
+// every embedded target resolves through the board catalog like any other.
 export const KNOWN_TARGETS = _knownTargets;
-/** @deprecated Use KNOWN_TARGETS */
-export const KNOWN_BOARDS = _knownTargets;
 export function normalizeProjectName(name) {
     return name
         .toLowerCase()
@@ -125,16 +54,23 @@ export function scaffoldProject(options, outDir) {
     writeFile('.cuttlefish/eslint.config.mjs', generateEslintConfig(options));
     writeFile('.cuttlefish/eslint-transpiler-rules.mjs', generateEslintRules(options));
     writeFile('.gitignore', generateGitignore(options));
-    if (options.boardPackage) {
-        const boardFilePath = path.join(cuttlefishDir, 'board.ts');
-        fs.writeFileSync(boardFilePath, generateBoardForwardingFile(options.boardPackage), 'utf-8');
-        createdFiles.push(boardFilePath);
+    writeFile('.editorconfig', generateEditorconfig(options));
+    // Editor integration: workspace-bundled VS Code extension for .ui syntax
+    // highlighting (best-effort — warns and skips if the assets are missing).
+    // hideNpm: end-user projects are not npm packages — hide VS Code's NPM
+    // Scripts view and npm task detection.
+    for (const file of writeEditorIntegration(resolvedOutDir, undefined, true))
+        createdFiles.push(file);
+    if (options.board) {
+        // Board-target projects materialize .cuttlefish/board.ts + board.json on
+        // the first build (config-loader → the framework's board generator);
+        // nothing to write here.
     }
-    if (options.includeSketch) {
+    if (options.includeStarter) {
         const entryName = 'main.ts';
-        const sketchPath = path.join(srcDir, entryName);
-        fs.writeFileSync(sketchPath, generateStarterSketch(options), 'utf-8');
-        createdFiles.push(sketchPath);
+        const entryPath = path.join(srcDir, entryName);
+        fs.writeFileSync(entryPath, generateStarterProgram(options), 'utf-8');
+        createdFiles.push(entryPath);
     }
     // Embedded projects get a starter hardware test (@typecad/expect / cuttlefish-test).
     // Native projects have no serial/board path, so they get no test setup.
@@ -156,7 +92,7 @@ export function scaffoldProject(options, outDir) {
     }
     return { createdFiles, outDir: resolvedOutDir, options };
 }
-export function printInitNextSteps(options, outDir, opts = {}) {
+export function printCreateNextSteps(options, outDir, opts = {}) {
     const relativeDir = path.relative(process.cwd(), outDir) || '.';
     console.log();
     console.log(chalk.cyan(`⤳ Cuttlefish`));
@@ -173,8 +109,10 @@ export function printInitNextSteps(options, outDir, opts = {}) {
         console.log(chalk.bold.white("To debug (VS Code):"));
         console.log(`  ${chalk.cyan("open the folder and press F5")} ${chalk.dim("(builds + flashes, then attaches GDB)")}`);
     }
+    console.log();
+    console.log(chalk.bold.white("To edit .ui files (VS Code):"));
+    console.log(`  ${chalk.cyan("open the folder and approve the workspace extension")} ${chalk.dim("(adds .ui syntax highlighting)")}`);
     if (!options.isNative) {
-        const portHint = process.platform === 'win32' ? 'COM4' : '/dev/ttyACM0';
         console.log();
         console.log(chalk.bold.white("To simulate without hardware:"));
         console.log(`  ${chalk.cyan("npm run simulate")}`);
@@ -184,7 +122,10 @@ export function printInitNextSteps(options, outDir, opts = {}) {
         console.log();
         console.log(chalk.bold.white("To run hardware tests:"));
         console.log(`  ${chalk.cyan("npm run test:hw")}`);
-        console.log();
-        console.log(chalk.dim(`Edit ${chalk.white("cuttlefish.config.ts")} to change the serial port from ${chalk.white(portHint)} to your port.`));
+        if (!options.port) {
+            const portHint = process.platform === 'win32' ? 'COM4' : '/dev/ttyACM0';
+            console.log();
+            console.log(chalk.dim(`No serial port was set — edit ${chalk.white("cuttlefish.config.ts")} to change ${chalk.white(portHint)} to your port (or pass --port on any command).`));
+        }
     }
 }

package/dist/create/templates.d.ts

@@ -0,0 +1,51 @@
+import type { ArchitectureIdentifier } from '../api/index.js';
+export interface CreateProjectOptions {
+    projectName: string;
+    targetId: string;
+    targetDisplayName: string;
+    isNative: boolean;
+    architecture?: ArchitectureIdentifier;
+    /** Qualified Zephyr board target (board-target projects). */
+    board?: string;
+    /** True when the board's devicetree declares an LED (pack fact — drives
+     *  the starter between an I/O skeleton and LED-blink). */
+    hasLed?: boolean;
+    frameworkPackage: string;
+    framework: string;
+    buildTarget?: string;
+    /** Zephyr SoC name (bare-silicon / contract projects). */
+    soc?: string;
+    baudRate?: number;
+    includeStarter: boolean;
+    toolchainType?: string;
+    /** Extra frameworkData fields (e.g. `{ target: 'esp32s3' }` for framework-esp32). */
+    frameworkData?: Record<string, unknown>;
+    /** Selected probe-method id (Zephyr boards with a probeMethods table);
+     *  emits the zephyr.probe section in the scaffolded config. */
+    probeMethod?: string;
+    /** Probe methods the board supports (wizard/catalog data) — used to write
+     *  the config comment listing the alternatives. */
+    probeMethods?: {
+        id: string;
+        description?: string;
+    }[];
+    /** Serial port picked at create time (test.port). Absent →
+     *  the platform hint placeholder. */
+    port?: string;
+    /** MCU-only Zephyr target: emit `zephyr.customBoard: true` so the framework
+     *  generates an out-of-tree board named after the build target. */
+    zephyrCustomBoard?: boolean;
+    /** Starter-program pin for MCU-only targets (a port name — bare silicon has
+     *  no board-level LED alias). */
+    starterPin?: string;
+}
+export declare function generateProjectPackageJson(options: CreateProjectOptions): string;
+export declare function generateProjectTsconfig(options: CreateProjectOptions): string;
+export declare function generateProjectConfig(options: CreateProjectOptions): string;
+export declare function generateProjectEnvDts(options: CreateProjectOptions): string;
+export declare function generateStarterProgram(options: CreateProjectOptions): string;
+export declare function generateStarterTest(_options: CreateProjectOptions): string;
+export declare function generateStarterSim(options: CreateProjectOptions): string;
+export declare function generateGitignore(_options: CreateProjectOptions): string;
+export declare function generateEditorconfig(_options: CreateProjectOptions): string;
+export declare function generateEslintConfig(_options: CreateProjectOptions): string;