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

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

@@ -0,0 +1,32 @@
+/** VS Code extension identifiers (publisher.name) of the bundled extensions. */
+export declare const TYPECAD_UI_EXTENSION_ID = "typecad.typecad-ui";
+export declare const TYPECAD_DEBUG_EXTENSION_ID = "typecad.vscode-typecad-debug";
+/**
+ * Source location of an unpacked bundled extension inside the cuttlefish
+ * package. Resolved from this module's location so it works from both src/
+ * (dev and tests importing source) and dist/ (the published CLI) — assets/
+ * sits at the package root either way.
+ */
+export declare function bundledExtensionSourceDir(dir: string): string;
+/** Kept for compatibility with the original single-extension helper. */
+export declare function typecadUiExtensionSourceDir(): string;
+/** Content of .vscode/extensions.json — auto-installs the workspace-bundled extensions. */
+export declare function generateExtensionsJson(): string;
+export declare const WATCH_TASK_LABEL = "cuttlefish: watch build";
+/** The watch task entry written to .vscode/tasks.json. */
+export declare function watchBuildTask(): Record<string, unknown>;
+/**
+ * Content of .vscode/tasks.json containing the watch task. Kept separate from
+ * the merge logic so tests can assert the shape without a filesystem.
+ */
+export declare function generateTasksJson(existingTasks?: ReadonlyArray<Record<string, unknown>>): string;
+/**
+ * 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). `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, hideNpm?: boolean): string[];

package/dist/create/editor-integration.js

@@ -0,0 +1,257 @@
+// ---------------------------------------------------------------------------
+// editor-integration.ts — create-time editor scaffolding for .ui highlighting
+//
+// Cuttlefish projects keep their UI in .ui single-file components (TS script +
+// CSS style + Svelte-style markup), which no editor knows out of the box. The
+// package ships grammar-only VS Code extensions under
+// assets/editor-extensions/ and `cuttlefish create` copies them into the new
+// project's .vscode/extensions/ folder:
+//
+//   typecad-ui     — .ui syntax highlighting, snippets, file icons, markdown
+//                    ```ui fence highlighting (grammar-only, no code).
+//   typecad-debug  — the built TypeCAD Debug extension (breakpoint syncing +
+//                    F5 commands), so debugging works with zero install.
+//
+// VS Code (1.89+, trusted workspaces) detects workspace-bundled extensions and
+// installs them scoped to that workspace. The companion .vscode/extensions.json
+// carries forceInstall entries (microsoft/vscode#299830) so VS Code builds with
+// that feature skip the approval prompt; older builds show a one-time install
+// prompt instead.
+//
+// A .vscode/tasks.json watch task is also written: it runs the project's
+// `cuttlefish build --watch` dev script with NO_COLOR=1 and parses the
+// transpiler/ESLint diagnostic lines into Problems-panel squiggles. The task
+// merges by label (never clobbers user edits or the framework debug writer's
+// tasks, which merge the same way).
+//
+// Everything here is best-effort like the debug-artifact generation: a missing
+// or unreadable asset tree warns and skips rather than failing `cuttlefish
+// create`, because a project without editor integration still builds fine.
+// ---------------------------------------------------------------------------
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** VS Code extension identifiers (publisher.name) of the bundled extensions. */
+export const TYPECAD_UI_EXTENSION_ID = 'typecad.typecad-ui';
+export const TYPECAD_DEBUG_EXTENSION_ID = 'typecad.vscode-typecad-debug';
+/** Extensions to bundle, as { asset folder name → extension id } pairs. */
+const BUNDLED_EXTENSIONS = [
+    { dir: 'typecad-ui', id: TYPECAD_UI_EXTENSION_ID },
+    { dir: 'typecad-debug', id: TYPECAD_DEBUG_EXTENSION_ID },
+];
+const ASSETS_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'assets', 'editor-extensions');
+/**
+ * Source location of an unpacked bundled extension inside the cuttlefish
+ * package. Resolved from this module's location so it works from both src/
+ * (dev and tests importing source) and dist/ (the published CLI) — assets/
+ * sits at the package root either way.
+ */
+export function bundledExtensionSourceDir(dir) {
+    return path.join(ASSETS_ROOT, dir);
+}
+/** Kept for compatibility with the original single-extension helper. */
+export function typecadUiExtensionSourceDir() {
+    return bundledExtensionSourceDir('typecad-ui');
+}
+/** Content of .vscode/extensions.json — auto-installs the workspace-bundled extensions. */
+export function generateExtensionsJson() {
+    return `${JSON.stringify({ forceInstall: BUNDLED_EXTENSIONS.map(e => e.id) }, null, 2)}\n`;
+}
+// -- watch task + problem matchers ------------------------------------------------
+/**
+ * Problem matchers for cuttlefish's two diagnostic line formats:
+ *   transpiler:  "<file> error|warning [code] (line,column): message"
+ *   eslint gate: "error <file>(line,column) [rule]: message"
+ * NO_COLOR=1 is set on the task so chalk stays off and the lines stay greppable.
+ */
+const PROBLEM_MATCHERS = [
+    {
+        owner: 'cuttlefish-transpiler',
+        severity: 'error',
+        fileLocation: ['relative', '${workspaceFolder}'],
+        pattern: {
+            regexp: '^\\s*(.*?)\\s+(error|warning)(?:\\s+\\[[^\\]]*\\])?\\s*\\((\\d+),(\\d+)\\):\\s+(.*)$',
+            file: 1,
+            severity: 2,
+            line: 3,
+            column: 4,
+            message: 5,
+        },
+        background: {
+            beginsPattern: 'Transpiling',
+            endsPattern: 'Watching for changes',
+        },
+    },
+    {
+        owner: 'cuttlefish-eslint',
+        severity: 'error',
+        fileLocation: ['relative', '${workspaceFolder}'],
+        pattern: {
+            regexp: '^\\s*error\\s+(.*?)\\((\\d+),(\\d+)\\)\\s+\\[[^\\]]*\\]:\\s+(.*)$',
+            file: 1,
+            line: 2,
+            column: 3,
+            message: 4,
+        },
+        background: {
+            beginsPattern: 'Transpiling',
+            endsPattern: 'Watching for changes',
+        },
+    },
+];
+export const WATCH_TASK_LABEL = 'cuttlefish: watch build';
+/** The watch task entry written to .vscode/tasks.json. */
+export function watchBuildTask() {
+    return {
+        label: WATCH_TASK_LABEL,
+        command: 'npm run dev',
+        type: 'shell',
+        isBackground: true,
+        group: 'build',
+        options: { env: { NO_COLOR: '1' } },
+        problemMatcher: PROBLEM_MATCHERS,
+    };
+}
+/**
+ * Content of .vscode/tasks.json containing the watch task. Kept separate from
+ * the merge logic so tests can assert the shape without a filesystem.
+ */
+export function generateTasksJson(existingTasks = []) {
+    const tasks = [...existingTasks];
+    const idx = tasks.findIndex(t => t.label === WATCH_TASK_LABEL);
+    const task = watchBuildTask();
+    if (idx >= 0)
+        tasks[idx] = task;
+    else
+        tasks.push(task);
+    return `${JSON.stringify({ version: '2.0.0', tasks }, null, 2)}\n`;
+}
+/**
+ * Read-merge-write .vscode/tasks.json with the watch task (by label), so user
+ * edits and the framework debug writer's tasks survive. Mirrors the Zephyr
+ * debug-config merge semantics.
+ */
+function writeTasksJson(vscodeDir) {
+    const tasksPath = path.join(vscodeDir, 'tasks.json');
+    let existing = [];
+    if (fs.existsSync(tasksPath)) {
+        try {
+            const doc = JSON.parse(fs.readFileSync(tasksPath, 'utf-8'));
+            const tasks = doc.tasks;
+            if (Array.isArray(tasks)) {
+                existing = tasks.filter((t) => !!t && typeof t === 'object');
+            }
+        }
+        catch {
+            // malformed — start fresh
+        }
+    }
+    fs.writeFileSync(tasksPath, generateTasksJson(existing), 'utf-8');
+    return tasksPath;
+}
+// -- install -----------------------------------------------------------------
+/** All files under `dir`, as paths relative to `dir`. */
+function listFilesRecursive(dir) {
+    const out = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+            for (const nested of listFilesRecursive(path.join(dir, entry.name))) {
+                out.push(path.join(entry.name, nested));
+            }
+        }
+        else {
+            out.push(entry.name);
+        }
+    }
+    return out;
+}
+/**
+ * Whether <outDir> has an `npm run dev` script for the watch task to drive.
+ * The task is skipped when it doesn't (e.g. the monorepo root or hand-made
+ * projects), because a task referencing a missing script just errors on run.
+ */
+function hasDevScript(outDir) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(outDir, 'package.json'), 'utf-8'));
+        const scripts = pkg.scripts;
+        return typeof scripts?.dev === 'string';
+    }
+    catch {
+        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). `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, hideNpm = false) {
+    const vscodeDir = path.join(outDir, '.vscode');
+    const extensionRoot = path.join(vscodeDir, 'extensions');
+    const root = assetsRoot ?? ASSETS_ROOT;
+    const written = [];
+    let copiedAny = false;
+    for (const ext of BUNDLED_EXTENSIONS) {
+        const src = path.join(root, ext.dir);
+        if (!fs.existsSync(path.join(src, 'package.json'))) {
+            console.warn(`! Editor integration: ${ext.dir} extension assets not found at ${src} — skipped`);
+            continue;
+        }
+        const dest = path.join(extensionRoot, ext.dir);
+        fs.mkdirSync(dest, { recursive: true });
+        fs.cpSync(src, dest, { recursive: true });
+        for (const rel of listFilesRecursive(dest))
+            written.push(path.join(dest, rel));
+        copiedAny = true;
+    }
+    if (!copiedAny)
+        return [];
+    const extensionsJsonPath = path.join(vscodeDir, 'extensions.json');
+    fs.writeFileSync(extensionsJsonPath, generateExtensionsJson(), 'utf-8');
+    written.push(extensionsJsonPath);
+    if (hasDevScript(outDir)) {
+        written.push(writeTasksJson(vscodeDir));
+    }
+    if (hideNpm) {
+        written.push(writeNpmHiddenSettings(vscodeDir));
+    }
+    return written;
+}

package/dist/create/eslint-rules-template.d.ts

@@ -1,2 +1,2 @@
-import type { InitProjectOptions } from "./init-templates.js";
-export declare function generateEslintRules(_options: InitProjectOptions): string;
+import type { CreateProjectOptions } from "./templates.js";
+export declare function generateEslintRules(_options: CreateProjectOptions): string;

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,28 @@ 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[];
 export interface FrameworkTargetProfile {
     /** Framework-specific build target (FQBN for Arduino, board id for Zephyr). */
     buildTarget?: string;
@@ -36,23 +68,31 @@ 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.
  */
 export declare function frameworksForTarget(target: BoardLike): FrameworkCatalogEntry[];
+/**
+ * Whether `frameworkId` is actually offered for `target`: compatible with the
+ * 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 native` on an embedded board).
+ */
+export declare function frameworkCompatibleWithTarget(target: BoardLike, frameworkId: string): boolean;
 export type PackageManager = "npm" | "pnpm" | "yarn";
 /**
  * Detect the package manager for a directory. Priority:

package/dist/create/framework-catalog.js

@@ -7,74 +7,77 @@
 // 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, esp32s3
+ *   - 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"],
-    esp32c6: ["arduino"],
-    rp2040: ["arduino"],
-    rp2350: ["arduino"],
-    samd: ["arduino"],
-    stm32: ["arduino"],
+    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"],
     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",
-    // xiao_ble isn't currently a KNOWN_TARGETS entry, but keep the descriptor
-    // correct for completeness: 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 }));
+}
 /**
  * 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) {
@@ -82,14 +85,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.
  */
@@ -105,6 +109,16 @@ export function frameworksForTarget(target) {
     // any id that has no catalog entry (defensive — keeps the prompt clean).
     return FRAMEWORK_CATALOG.filter((entry) => ids.includes(entry.id));
 }
+/**
+ * Whether `frameworkId` is actually offered for `target`: compatible with the
+ * 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 native` on an embedded board).
+ */
+export function frameworkCompatibleWithTarget(target, frameworkId) {
+    return frameworksForTarget(target).some((f) => f.id === frameworkId && f.installable);
+}
 /**
  * Detect the package manager for a directory. Priority:
  *   1. package.json#packageManager field (the strongest signal, Corepack-style)