@typecad/cuttlefish 1.0.0-alpha.14 → 1.0.0-alpha.16

package/dist/create/board-search.d.ts

@@ -0,0 +1,23 @@
+/** The discriminator union the wizard switches on. */
+export type TargetPick = {
+    kind: 'native';
+} | {
+    kind: 'mcu';
+    id: string;
+} | {
+    kind: 'board';
+    entry: {
+        identifier: string;
+        name: string;
+        soc: string;
+    };
+};
+export declare function pickTarget(): Promise<TargetPick | undefined>;
+/** Back-compat alias for the board-only picker (still used by tests/tools
+ *  that want boards only). */
+export declare function pickBoard(): Promise<{
+    identifier: string;
+    name: string;
+    soc: string;
+    curated: boolean;
+} | undefined>;

package/dist/create/board-search.js

@@ -0,0 +1,88 @@
+// ---------------------------------------------------------------------------
+// board-search.ts — the create-wizard target picker: one filterable select.
+//
+// Everything the wizard can target rides a single searchable list:
+//   - Native Desktop (the one non-embedded target)
+//   - Bare silicon (soc entries — contract/custom-PCB projects)
+//   - Every Zephyr board variant from the generated catalog (1,300+;
+//     the curated nine sit wherever their names sort — no badge, the
+//     picker is a flat search surface)
+//
+// Typing "esp32" narrows to the espressif variants; typing "nrf52" to the
+// Nordic ones; arrows + enter pick. Uses inquirer-select-pro's filter mode.
+// ---------------------------------------------------------------------------
+import { select } from 'inquirer-select-pro';
+import { activeBoardCatalog } from '../board-catalog/index.js';
+import { KNOWN_TARGETS } from './scaffold.js';
+/** Flat option list: native first, then bare silicon, then every board
+ *  variant (alphabetical by the pack's directory-walk order). */
+function targetOptions() {
+    const native = KNOWN_TARGETS
+        .filter((t) => t.isNative)
+        .map((t) => ({ name: `${t.displayName} (Windows/Linux executable)`, value: `native:${t.id}` }));
+    const boards = Object.values(activeBoardCatalog()).map((b) => ({
+        name: `${b.name} (${b.identifier})`,
+        value: b.identifier,
+    }));
+    return [...native, ...boards];
+}
+/** Resolve a picked value back to its discriminated form. */
+function resolvePick(value) {
+    if (value.startsWith('native:'))
+        return { kind: 'native' };
+    // Board: value IS the qualified identifier.
+    const entry = activeBoardCatalog()[value];
+    if (!entry)
+        return undefined;
+    return { kind: 'board', entry: { identifier: entry.identifier, name: entry.name, soc: value.split('/')[1] } };
+}
+/**
+ * Build a filterable options loader for `inquirer-select-pro`. The select
+ * only enables its filter input when `options` is a *function* (a static
+ * array disables filtering entirely), so we wrap the flat list in a
+ * case-insensitive substring matcher.
+ */
+function filterableTargetOptions() {
+    const all = targetOptions();
+    return (input) => {
+        const query = (input ?? '').trim().toLowerCase();
+        if (!query)
+            return all;
+        return all.filter((o) => o.name.toLowerCase().includes(query));
+    };
+}
+export async function pickTarget() {
+    const value = await select({
+        message: 'Target (type to filter — e.g. "esp32", "nucleo", "native"):',
+        multiple: false,
+        options: filterableTargetOptions(),
+        filter: true,
+        pageSize: 15,
+    });
+    if (value === undefined || value === null)
+        return undefined;
+    return resolvePick(value);
+}
+/** Back-compat alias for the board-only picker (still used by tests/tools
+ *  that want boards only). */
+export async function pickBoard() {
+    const boards = Object.values(activeBoardCatalog()).map((b) => ({ name: `${b.name} (${b.identifier})`, value: b.identifier }));
+    const value = await select({
+        message: 'Board (type to filter — e.g. "esp32", "nucleo_f411"):',
+        multiple: false,
+        options: (input) => {
+            const query = (input ?? '').trim().toLowerCase();
+            if (!query)
+                return boards;
+            return boards.filter((b) => b.name.toLowerCase().includes(query));
+        },
+        filter: true,
+        pageSize: 15,
+    });
+    if (value === undefined || value === null)
+        return undefined;
+    const entry = activeBoardCatalog()[value];
+    if (!entry)
+        return undefined;
+    return { identifier: entry.identifier, name: entry.name, soc: value.split('/')[1], curated: false };
+}

package/dist/create/editor-integration.d.ts

@@ -25,6 +25,8 @@ export declare function generateTasksJson(existingTasks?: ReadonlyArray<Record<s
  * companion .vscode/extensions.json and — when the project has a `dev` watch
  * script — the .vscode/tasks.json watch task. Returns the absolute paths
  * written, or [] when the extension assets are missing (warns, never throws).
- * `assetsRoot` overrides the bundled-asset location (tests).
+ * `assetsRoot` overrides the bundled-asset location (tests). `hideNpm` (used by
+ * `cuttlefish create` for end-user projects) also writes settings.json keys
+ * that hide VS Code's NPM Scripts view and npm task detection.
  */
-export declare function writeEditorIntegration(outDir: string, assetsRoot?: string): string[];
+export declare function writeEditorIntegration(outDir: string, assetsRoot?: string, hideNpm?: boolean): string[];

package/dist/create/editor-integration.js

@@ -180,14 +180,50 @@ function hasDevScript(outDir) {
         return false;
     }
 }
+/**
+ * Settings that hide VS Code's web-dev npm surface in end-user projects. The
+ * scaffolded package.json is build tooling, not an npm package the user
+ * develops — without these, VS Code shows the NPM Scripts explorer view,
+ * auto-detected npm tasks, and Debug codelenses over the scripts.
+ */
+const END_USER_NPM_SETTINGS = {
+    'npm.autoDetect': 'off',
+    'npm.exclude': '**/package.json',
+    'debug.javascript.codelens.npmScripts': 'never',
+};
+/**
+ * Read-merge-write .vscode/settings.json with the npm-hiding settings. Merge-
+ * safe because the framework debug writer may also contribute settings
+ * (e.g. cortex-debug paths) — those must survive.
+ */
+function writeNpmHiddenSettings(vscodeDir) {
+    const settingsPath = path.join(vscodeDir, 'settings.json');
+    let doc = {};
+    if (fs.existsSync(settingsPath)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                doc = parsed;
+            }
+        }
+        catch {
+            // malformed — start fresh
+        }
+    }
+    Object.assign(doc, END_USER_NPM_SETTINGS);
+    fs.writeFileSync(settingsPath, `${JSON.stringify(doc, null, 2)}\n`, 'utf-8');
+    return settingsPath;
+}
 /**
  * Copy the bundled extensions into <outDir>/.vscode/extensions/, then write the
  * companion .vscode/extensions.json and — when the project has a `dev` watch
  * script — the .vscode/tasks.json watch task. Returns the absolute paths
  * written, or [] when the extension assets are missing (warns, never throws).
- * `assetsRoot` overrides the bundled-asset location (tests).
+ * `assetsRoot` overrides the bundled-asset location (tests). `hideNpm` (used by
+ * `cuttlefish create` for end-user projects) also writes settings.json keys
+ * that hide VS Code's NPM Scripts view and npm task detection.
  */
-export function writeEditorIntegration(outDir, assetsRoot) {
+export function writeEditorIntegration(outDir, assetsRoot, hideNpm = false) {
     const vscodeDir = path.join(outDir, '.vscode');
     const extensionRoot = path.join(vscodeDir, 'extensions');
     const root = assetsRoot ?? ASSETS_ROOT;
@@ -214,5 +250,8 @@ export function writeEditorIntegration(outDir, assetsRoot) {
     if (hasDevScript(outDir)) {
         written.push(writeTasksJson(vscodeDir));
     }
+    if (hideNpm) {
+        written.push(writeNpmHiddenSettings(vscodeDir));
+    }
     return written;
 }

package/dist/create/framework-catalog.d.ts

@@ -12,13 +12,23 @@ export interface FrameworkCatalogEntry {
      * be offered (it would fail at the package-manager step).
      */
     installable: boolean;
+    /**
+     * True when the framework ships inside @typecad/cuttlefish (no separate npm
+     * package): the scaffold must not add it to project dependencies, and the
+     * loader (framework-package.ts) resolves it internally instead of via
+     * require.resolve. The config string stays the package name for continuity.
+     */
+    builtin?: boolean;
 }
 /**
- * The installable frameworks. Kept aligned with the packages/ directory:
- * framework-arduino, framework-native, framework-zephyr all ship real packages.
- * esp-idf is intentionally absent (no published package in this repo).
+ * The usable frameworks. zephyr ships as a real package; native is built
+ * into @typecad/cuttlefish (formerly a separate package, now resolved
+ * internally). esp-idf is intentionally absent (no published package).
  */
 export declare const FRAMEWORK_CATALOG: readonly FrameworkCatalogEntry[];
+/** True iff the framework package ships inside @typecad/cuttlefish and needs
+ *  no separate npm dependency in scaffolded projects. */
+export declare function isBuiltinFramework(packageName: string): boolean;
 /** Structural shape we need from a board/target. Keeps this module decoupled
  *  from the KnownTarget type (and trivially testable with literals). */
 export interface BoardLike {
@@ -27,6 +37,44 @@ export interface BoardLike {
 }
 /** Look up a catalog entry by framework id (e.g. "arduino"). */
 export declare function frameworkCatalogEntry(id: string): FrameworkCatalogEntry | undefined;
+/**
+ * Zephyr build targets come straight from the board catalog (the pack or a
+ * local `cuttlefish board sync` overlay) — every catalog board carries its
+ * own qualified `west build -b` target. There is no curated id→target map.
+ */
+/**
+ * Probe method a board offers, for `cuttlefish create`'s wizard (which runs
+ * BEFORE the framework is installed, so it reads the board data pack — the
+ * same table boardgen emits into the generated board module for tier-3
+ * boards, extracted from each board's own board.cmake runners).
+ */
+export interface CatalogProbeMethod {
+    id: string;
+    description: string;
+}
+/**
+ * The probe methods a board offers, from the board data pack. Accepts a
+ * qualified Zephyr target ('blackpill_f401ce/stm32f401xe'), a bare board id,
+ * or undefined. Empty when the board ships no runner table — then no probe
+ * question is asked and no zephyr.probe section is scaffolded.
+ */
+export declare function probeMethodsForBoard(boardId: string | undefined): CatalogProbeMethod[];
+/**
+ * Pre-baked zephyr.runnerArgs the selected probe method needs to flash
+ * reliably — sourced from the method's captured debugCfg (the board's
+ * support/openocd.cfg, verbatim), so the scaffold bakes in facts, not board
+ * names.
+ *
+ * The one quirk today: a cfg that drives OpenOCD resets through the SRST pin
+ * (`reset_config srst…`) while the probe's NRST line may not reach the target
+ * — hobby boards like the WeAct BlackPill break no NRST out at all, so
+ * `reset init` asserts a pin that reaches nothing and dies with "timed out
+ * while waiting for target halted". Core-domain resets (SYSRESETREQ) are
+ * pin-independent. Boards declaring `connect_assert_srst` are excluded: that
+ * strategy only works with NRST wired, so the pin is provably connected there
+ * and connect-under-reset is worth keeping.
+ */
+export declare function probeRunnerQuirks(boardId: string | undefined, methodId: string | undefined): string[];
 export interface FrameworkTargetProfile {
     /** Framework-specific build target (FQBN for Arduino, board id for Zephyr). */
     buildTarget?: string;
@@ -36,19 +84,19 @@ export interface FrameworkTargetProfile {
 export interface TargetProfileInput {
     id: string;
     isNative?: boolean;
-    /** The board's Arduino FQBN, as currently stored on KnownTarget. */
+    /** The board's default build target, as currently stored on KnownTarget. */
     buildTarget?: string;
 }
 /**
  * Resolve the framework-specific buildTarget + toolchain type for a
- * (board, framework) pair. Arduino reuses the board's FQBN; Zephyr maps to the
- * Zephyr board id; native returns an empty profile (the native config writes
- * neither field).
+ * (board, framework) pair. Zephyr maps the board id to its Zephyr board
+ * target; native returns an empty profile (the native config writes neither
+ * field); any unlisted framework falls back to the board's stored target.
  */
 export declare function frameworkTargetProfile(target: TargetProfileInput, frameworkId: string): FrameworkTargetProfile;
 /**
  * The framework ids compatible with a board. Native boards map to ["native"];
- * embedded boards map via ARCHITECTURE_FRAMEWORKS (falling back to arduino for
+ * embedded boards map via ARCHITECTURE_FRAMEWORKS (falling back to zephyr for
  * unknown architectures). Order is preserved as the catalog order so the most
  * common framework is offered first in the prompt.
  */
@@ -58,7 +106,7 @@ export declare function frameworksForTarget(target: BoardLike): FrameworkCatalog
  * board's architecture AND installable. Auto-picking narrows via
  * frameworksForTarget, but an explicit `--framework` bypasses that narrowing —
  * callers accepting one must reject anything this returns false for (e.g.
- * `--framework arduino` on the Zephyr-only xiao-nrf52840).
+ * `--framework native` on an embedded board).
  */
 export declare function frameworkCompatibleWithTarget(target: BoardLike, frameworkId: string): boolean;
 export type PackageManager = "npm" | "pnpm" | "yarn";

package/dist/create/framework-catalog.js

@@ -7,87 +7,105 @@
 // detectPackageManager) so it unit-tests cleanly.
 import path from "node:path";
 import fs from "node:fs";
+import { findPackBoard } from "./pack-targets.js";
 /**
- * The installable frameworks. Kept aligned with the packages/ directory:
- * framework-arduino, framework-native, framework-zephyr all ship real packages.
- * esp-idf is intentionally absent (no published package in this repo).
+ * The usable frameworks. zephyr ships as a real package; native is built
+ * into @typecad/cuttlefish (formerly a separate package, now resolved
+ * internally). esp-idf is intentionally absent (no published package).
  */
 export const FRAMEWORK_CATALOG = [
-    { id: "arduino", packageName: "@typecad/framework-arduino", label: "Arduino (digitalWrite, Wire, SPI)", installable: true },
     { id: "zephyr", packageName: "@typecad/framework-zephyr", label: "Zephyr RTOS", installable: true },
-    { id: "native", packageName: "@typecad/framework-native", label: "Native (Windows/Linux executable)", installable: true },
+    { id: "native", packageName: "@typecad/framework-native", label: "Native (Windows/Linux executable)", installable: true, builtin: true },
 ];
+/** True iff the framework package ships inside @typecad/cuttlefish and needs
+ *  no separate npm dependency in scaffolded projects. */
+export function isBuiltinFramework(packageName) {
+    return FRAMEWORK_CATALOG.some((f) => f.packageName === packageName && f.builtin === true);
+}
 /**
  * Architecture → compatible framework ids. Derived from each framework
  * package's framework.manifest.ts `profile.targets`:
- *   - arduino: avr, esp32 family, rp2040/rp2350, samd, stm32
- *   - zephyr:  nrf52 (xiao_ble), esp32 family (esp32, esp32s3, esp32c3, esp32c6)
+ *   - zephyr:  nrf52 (xiao_ble), esp32 family (esp32, esp32s3, esp32c3, esp32c6),
+ *              rp2040/rp2350 (rpi_pico, rpi_pico2), stm32f411 (blackpill),
+ *              samd21 (nano_33_iot)
  *   - native:  desktop only
- * Unknown embedded architectures fall back to [arduino] (the broadest core).
+ * Unknown embedded architectures fall back to [zephyr].
  */
 const ARCHITECTURE_FRAMEWORKS = {
-    avr: ["arduino"],
-    esp32: ["arduino", "zephyr"],
-    esp32s2: ["arduino"],
-    esp32s3: ["arduino", "zephyr"],
-    esp32c3: ["arduino", "zephyr"],
-    esp32c6: ["arduino", "zephyr"],
-    rp2040: ["arduino"],
-    rp2350: ["arduino"],
-    samd: ["arduino"],
-    // Per-chip key (esp32c3/c6 style). The generic 'stm32' entry stays
-    // ["arduino"] for future STM32duino support; the F411 Black Pill is
-    // Zephyr-only today.
+    esp32: ["zephyr"],
+    esp32s3: ["zephyr"],
+    esp32c3: ["zephyr"],
+    esp32c6: ["zephyr"],
+    rp2040: ["zephyr"],
+    rp2350: ["zephyr"],
+    // Per-chip key (stm32f411 style) — the Black Pill's generic 'stm32' family
+    // has no other supported silicon today.
+    samd21: ["zephyr"],
     stm32f411: ["zephyr"],
-    stm32: ["arduino"],
     nrf52: ["zephyr"],
 };
-const FALLBACK_FRAMEWORKS = ["arduino"];
+const FALLBACK_FRAMEWORKS = ["zephyr"];
 /** Look up a catalog entry by framework id (e.g. "arduino"). */
 export function frameworkCatalogEntry(id) {
     return FRAMEWORK_CATALOG.find((f) => f.id === id);
 }
 // ── framework-specific build target + toolchain ─────────────────────────────
-// A board's buildTarget string is NOT framework-independent: Arduino uses an
-// FQBN (e.g. 'esp32:esp32:esp32s3') while Zephyr uses a board id for
-// `west build -b` (e.g. 'esp32s3_devkitc'). The scaffold must pick the right
-// one for the chosen framework, and the matching toolchain backend
-// ('arduino-cli' vs 'west'). Source for Zephyr board ids: framework-zephyr's
+// A board's buildTarget string is framework-specific: Zephyr uses a board id
+// for `west build -b` (e.g. 'esp32s3_devkitc/esp32s3/procpu'). The scaffold
+// must pick the right one for the chosen framework, and the matching
+// toolchain backend ('west'). Source for Zephyr board ids: framework-zephyr's
 // chip registry (src/chips/index.ts) + the demo configs.
 const FRAMEWORK_TOOLCHAIN = {
-    arduino: "arduino-cli",
     zephyr: "west",
     // native has no toolchain (the native config path writes neither field).
 };
 /**
- * Zephyr board target for each cuttlefish board id that supports Zephyr. These
- * are the full qualified targets passed to `west build -b <target>` (framework-
- * zephyr's chipForTarget splits on '/' and takes the board id, so the qualified
- * form resolves correctly there too). Zephyr 4.3+ REQUIRES the qualifier for
- * multi-core ESP32 boards — the bare id (e.g. 'esp32s3_devkitc') is rejected
- * with "Board qualifiers ... not found". procpu is the main application core.
+ * The probe methods a board offers, from the board data pack. Accepts a
+ * qualified Zephyr target ('blackpill_f401ce/stm32f401xe'), a bare board id,
+ * or undefined. Empty when the board ships no runner table — then no probe
+ * question is asked and no zephyr.probe section is scaffolded.
  */
-const ZEPHYR_BOARD_IDS = {
-    "esp32-devkit": "esp32_devkitc/esp32/procpu",
-    esp32s3: "esp32s3_devkitc/esp32s3/procpu",
-    // Single-variant RISC-V board — the bare id is also accepted, but the
-    // qualified form is kept for consistency (verified against Zephyr 4.3
-    // boards/espressif/esp32c3_devkitm).
-    esp32c3: "esp32c3_devkitm/esp32c3",
-    // hpcore/lpcore cpucluster variants — the qualified form is required (the
-    // bare id is rejected); hpcore is the application core.
-    esp32c6: "esp32c6_devkitc/esp32c6/hpcore",
-    // First STM32 target — WeAct Black Pill V2.0 (STM32F411CEU6). Single
-    // variant; qualified for consistency with every other catalog target.
-    "blackpill-f411ce": "blackpill_f411ce/stm32f411xe",
-    // nRF52840 (single core), base (non-sense) variant.
-    "xiao-nrf52840": "xiao_ble/nrf52840",
-};
+export function probeMethodsForBoard(boardId) {
+    if (!boardId)
+        return [];
+    const entry = findPackBoard(boardId);
+    if (!entry?.probeMethods)
+        return [];
+    return entry.probeMethods.map((m) => ({ id: m.id, description: m.description }));
+}
+/**
+ * Pre-baked zephyr.runnerArgs the selected probe method needs to flash
+ * reliably — sourced from the method's captured debugCfg (the board's
+ * support/openocd.cfg, verbatim), so the scaffold bakes in facts, not board
+ * names.
+ *
+ * The one quirk today: a cfg that drives OpenOCD resets through the SRST pin
+ * (`reset_config srst…`) while the probe's NRST line may not reach the target
+ * — hobby boards like the WeAct BlackPill break no NRST out at all, so
+ * `reset init` asserts a pin that reaches nothing and dies with "timed out
+ * while waiting for target halted". Core-domain resets (SYSRESETREQ) are
+ * pin-independent. Boards declaring `connect_assert_srst` are excluded: that
+ * strategy only works with NRST wired, so the pin is provably connected there
+ * and connect-under-reset is worth keeping.
+ */
+export function probeRunnerQuirks(boardId, methodId) {
+    if (!boardId || !methodId)
+        return [];
+    const method = findPackBoard(boardId)?.probeMethods?.find((m) => m.id === methodId);
+    // Only the openocd runner consumes the board cfg's reset_config — other
+    // runners (jlink, dfu-util, …) carry their own reset strategy.
+    if (!method || method.runner !== 'openocd')
+        return [];
+    const cfg = method.debugCfg ?? [];
+    const srst = cfg.some((line) => /reset_config\s+srst/.test(line));
+    const connectAssert = cfg.some((line) => /connect_assert_srst/.test(line));
+    return srst && !connectAssert ? ['--cmd-pre-init=reset_config none'] : [];
+}
 /**
  * Resolve the framework-specific buildTarget + toolchain type for a
- * (board, framework) pair. Arduino reuses the board's FQBN; Zephyr maps to the
- * Zephyr board id; native returns an empty profile (the native config writes
- * neither field).
+ * (board, framework) pair. Zephyr maps the board id to its Zephyr board
+ * target; native returns an empty profile (the native config writes neither
+ * field); any unlisted framework falls back to the board's stored target.
  */
 export function frameworkTargetProfile(target, frameworkId) {
     if (target.isNative) {
@@ -95,14 +113,15 @@ export function frameworkTargetProfile(target, frameworkId) {
     }
     const toolchainType = FRAMEWORK_TOOLCHAIN[frameworkId];
     if (frameworkId === "zephyr") {
-        return { buildTarget: ZEPHYR_BOARD_IDS[target.id], toolchainType };
+        // The target input's buildTarget IS the qualified catalog identifier.
+        return { buildTarget: target.buildTarget, toolchainType };
     }
-    // Arduino (and any unlisted framework) → use the board's FQBN.
+    // Unlisted framework → pass the board's stored build target through.
     return { buildTarget: target.buildTarget, toolchainType };
 }
 /**
  * The framework ids compatible with a board. Native boards map to ["native"];
- * embedded boards map via ARCHITECTURE_FRAMEWORKS (falling back to arduino for
+ * embedded boards map via ARCHITECTURE_FRAMEWORKS (falling back to zephyr for
  * unknown architectures). Order is preserved as the catalog order so the most
  * common framework is offered first in the prompt.
  */
@@ -123,7 +142,7 @@ export function frameworksForTarget(target) {
  * board's architecture AND installable. Auto-picking narrows via
  * frameworksForTarget, but an explicit `--framework` bypasses that narrowing —
  * callers accepting one must reject anything this returns false for (e.g.
- * `--framework arduino` on the Zephyr-only xiao-nrf52840).
+ * `--framework native` on an embedded board).
  */
 export function frameworkCompatibleWithTarget(target, frameworkId) {
     return frameworksForTarget(target).some((f) => f.id === frameworkId && f.installable);

package/dist/create/index.d.ts

@@ -1,18 +1,12 @@
-export { scaffoldProject, normalizeProjectName, KNOWN_TARGETS, KNOWN_BOARDS, registerKnownTarget, printCreateNextSteps } from './scaffold.js';
-export type { KnownTarget, KnownBoard, ScaffoldProjectResult } from './scaffold.js';
-export { FRAMEWORK_CATALOG, frameworksForTarget, frameworkCompatibleWithTarget, 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, probeRunnerQuirks } 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, generateEditorconfig, generateEslintConfig, } from './templates.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 { generateExtensionsJson, generateTasksJson, watchBuildTask, writeEditorIntegration, bundledExtensionSourceDir, typecadUiExtensionSourceDir, TYPECAD_UI_EXTENSION_ID, TYPECAD_DEBUG_EXTENSION_ID, WATCH_TASK_LABEL, } from './editor-integration.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';

package/dist/create/index.js

@@ -1,12 +1,7 @@
-export { scaffoldProject, normalizeProjectName, KNOWN_TARGETS, KNOWN_BOARDS, registerKnownTarget, printCreateNextSteps } from './scaffold.js';
-export { FRAMEWORK_CATALOG, frameworksForTarget, frameworkCompatibleWithTarget, 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, probeRunnerQuirks } from './framework-catalog.js';
 export { installProjectDependencies, __setProjectInstallRunnerForTest } from './install-deps.js';
-export { generateProjectPackageJson, generateProjectTsconfig, generateProjectConfig, generateProjectEnvDts, generateStarterSketch, generateStarterTest, generateStarterSim, generateGitignore, generateEditorconfig, generateEslintConfig, } from './templates.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';
 export { generateExtensionsJson, generateTasksJson, watchBuildTask, writeEditorIntegration, bundledExtensionSourceDir, typecadUiExtensionSourceDir, TYPECAD_UI_EXTENSION_ID, TYPECAD_DEBUG_EXTENSION_ID, WATCH_TASK_LABEL, } from './editor-integration.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';

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';
+}