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

package/dist/cli.js

@@ -2,8 +2,10 @@
 import path from "node:path";
 import fs from "node:fs";
 import { parseCommandLine, printHelp } from "./utils/cli.js";
-import { scaffoldProject, printInitNextSteps, KNOWN_TARGETS, frameworksForTarget, frameworkCatalogEntry, FRAMEWORK_CATALOG, frameworkTargetProfile } from "./create/index.js";
-import { runInitWizard } from "./create/index.js";
+import { runLibraryCommand } from "./library/cli.js";
+import { scaffoldProject, printCreateNextSteps, KNOWN_TARGETS, frameworksForTarget, frameworkCatalogEntry, frameworkCompatibleWithTarget, FRAMEWORK_CATALOG, frameworkTargetProfile } from "./create/index.js";
+import { generateFrameworkDebugArtifacts } from "./create/debug-artifacts.js";
+import { runCreateWizard } from "./create/index.js";
 import { installProjectDependencies } from "./create/install-deps.js";
 import { generateLibraryDefinitions, transpileFile } from "./transpile.js";
 import { generateDecl, generateDeclsForDirectory, generateComponentDeclsForProject } from "./libdef/cpp-to-decl.js";
@@ -64,8 +66,9 @@ async function handleCreate(options) {
             const available = KNOWN_TARGETS.map(t => `  - ${t.id} (${t.displayName})`).join("\n");
             throw new Error(`Unknown target '${targetId}'. Available targets:\n${available}`);
         }
-        // Resolve the framework. --framework wins; otherwise narrow via the catalog
-        // for the chosen board and auto-pick when exactly one is compatible.
+        // Resolve the framework. --framework wins (validated against the board's
+        // compatible set); otherwise narrow via the catalog for the chosen board
+        // and auto-pick when exactly one is compatible.
         let frameworkId;
         let frameworkPackage;
         if (options.framework) {
@@ -74,6 +77,11 @@ async function handleCreate(options) {
                 const available = FRAMEWORK_CATALOG.filter(f => f.installable).map(f => f.id).join(", ");
                 throw new Error(`Unknown framework '${options.framework}'. Available: ${available}`);
             }
+            if (!frameworkCompatibleWithTarget(target, requested.id)) {
+                const list = frameworksForTarget(target).filter(f => f.installable).map(f => f.id).join(", ");
+                throw new Error(`Framework '${requested.id}' is not compatible with target '${target.id}' (${target.displayName}). ` +
+                    `Compatible frameworks: ${list}`);
+            }
             frameworkId = requested.id;
             frameworkPackage = requested.packageName;
         }
@@ -114,7 +122,7 @@ async function handleCreate(options) {
         finalizeCreate(result, options);
     }
     else {
-        const wizardResult = await runInitWizard({
+        const wizardResult = await runCreateWizard({
             projectName: options.projectName,
             board: options.board,
             framework: options.framework,
@@ -156,7 +164,20 @@ function finalizeCreate(result, options) {
             console.log(chalk.dim(`  Run '${chalk.white("npm install")}' manually in ${relativeDir} when ready.`));
         }
     }
-    printInitNextSteps(result.options, result.outDir, { installed });
+    // Framework starter debug profile (e.g. Zephyr esp32s3): write .vscode/
+    // launch.json + tasks.json so F5 in VS Code works before the first build.
+    // Runs after the install step so the framework package resolves from the
+    // new project's node_modules; best-effort — the first --debug build writes
+    // the artifacts anyway.
+    const debugArtifacts = generateFrameworkDebugArtifacts({
+        frameworkPackage: result.options.frameworkPackage || undefined,
+        workspaceRoot: result.outDir,
+        buildTarget: result.options.buildTarget,
+    });
+    if (debugArtifacts.length > 0) {
+        console.log(`\n${chalk.green("✓")} Debug profile: ${debugArtifacts.map((f) => chalk.white(f)).join(", ")}`);
+    }
+    printCreateNextSteps(result.options, result.outDir, { installed, debugProfile: debugArtifacts.length > 0 });
 }
 async function handleBoardAdd(options) {
     const { scaffoldBoardPackages, parseBoardSpec, generateFrameworkChecklist } = await import("./create/index.js");
@@ -189,6 +210,10 @@ async function main() {
             await handleBoardAdd(options);
             return;
         }
+        if (options.command === "library") {
+            await runLibraryCommand(options);
+            return;
+        }
         if (options.command === "preview") {
             await runPreviewServer({
                 configPath: options.configPath,
@@ -570,7 +595,6 @@ async function main() {
                             buildTarget,
                             port: effectivePort,
                             baud: options.baud ?? config?.console?.baudRate,
-                            optimize: config?.outputOptimize,
                             extraFlags: config?.outputExtraFlags,
                             defines: psramDefines,
                             psram: config?.psram,
@@ -671,7 +695,6 @@ async function main() {
                                     buildTarget,
                                     port: effectivePort,
                                     baud: options.baud ?? config?.console?.baudRate,
-                                    optimize: config?.outputOptimize,
                                     extraFlags: config?.outputExtraFlags,
                                     defines: psramDefines,
                                     psram: config?.psram,
@@ -779,7 +802,6 @@ async function main() {
             buildTarget,
             port: effectivePort,
             baud: options.baud ?? config?.console?.baudRate,
-            optimize: config?.outputOptimize,
             extraFlags: config?.outputExtraFlags,
             defines: psramDefines,
             psram: config?.psram,

package/dist/config-loader.d.ts

@@ -15,8 +15,6 @@ export interface ResolvedCuttlefishConfig {
     buildTarget?: string;
     /** Output framework (e.g. 'arduino'). */
     outputFramework?: string;
-    /** Optimization level. */
-    outputOptimize?: string;
     /** Output directory. */
     outputOutDir?: string;
     /**

package/dist/config-loader.js

@@ -415,9 +415,15 @@ export function parseConfigFile(configPath) {
     const outputFramework = flat.get("output.framework");
     if (typeof outputFramework === "string")
         resolved.outputFramework = outputFramework;
-    const outputOptimize = flat.get("output.optimize");
-    if (typeof outputOptimize === "string")
-        resolved.outputOptimize = outputOptimize;
+    // `output.optimize` is removed: no framework ever consumed it (the only
+    // consumer, framework-esp32, is deleted). Warn-and-drop instead of failing
+    // strict validation, so existing configs keep building while telling the
+    // user to delete the key. Optimization is framework territory — e.g.
+    // `zephyr.kconfig` CONFIG_*_OPTIMIZATIONS symbols.
+    if (flat.has("output.optimize")) {
+        warn("'output.optimize' has no effect and is deprecated — remove it. " +
+            "Control optimization via the framework (e.g. zephyr.kconfig CONFIG_SIZE_OPTIMIZATIONS / CONFIG_SPEED_OPTIMIZATIONS).");
+    }
     const outputOutDir = flat.get("output.outDir");
     if (typeof outputOutDir === "string")
         resolved.outputOutDir = outputOutDir;
@@ -444,11 +450,13 @@ export function parseConfigFile(configPath) {
     // Parse zephyr-specific config section.
     const zephyrKconfig = extractStringRecord(configObject, ["zephyr", "kconfig"], warn);
     const zephyrCmakeArgs = extractStringArray(configObject, ["zephyr", "cmakeArgs"], warn);
+    const zephyrRunnerArgs = extractStringArray(configObject, ["zephyr", "runnerArgs"], warn);
     const zephyrRunner = flat.get("zephyr.runner");
-    if (zephyrKconfig || zephyrCmakeArgs || typeof zephyrRunner === "string") {
+    if (zephyrKconfig || zephyrCmakeArgs || zephyrRunnerArgs || typeof zephyrRunner === "string") {
         resolved.zephyrConfig = {
             ...(zephyrKconfig ? { kconfig: zephyrKconfig } : {}),
             ...(zephyrCmakeArgs ? { cmakeArgs: zephyrCmakeArgs } : {}),
+            ...(zephyrRunnerArgs ? { runnerArgs: zephyrRunnerArgs } : {}),
             ...(typeof zephyrRunner === "string" ? { runner: zephyrRunner } : {}),
         };
     }
@@ -478,10 +486,9 @@ export function parseConfigFile(configPath) {
     // PsramType enum and fails validation instead of vanishing.
     if (resolved.psram !== undefined)
         structuredForValidation.psram = resolved.psram;
-    if (resolved.outputFramework || resolved.outputOptimize || resolved.outputOutDir || resolved.outputExtraFlags || resolved.outputDefines) {
+    if (resolved.outputFramework || resolved.outputOutDir || resolved.outputExtraFlags || resolved.outputDefines) {
         structuredForValidation.output = {
             ...(resolved.outputFramework ? { framework: resolved.outputFramework } : {}),
-            ...(resolved.outputOptimize ? { optimize: resolved.outputOptimize } : {}),
             ...(resolved.outputOutDir ? { outDir: resolved.outputOutDir } : {}),
             ...(resolved.outputExtraFlags ? { extraFlags: resolved.outputExtraFlags } : {}),
             ...(resolved.outputDefines ? { defines: resolved.outputDefines } : {}),

package/dist/config-schema.d.ts

@@ -4,264 +4,51 @@ import { z } from 'zod';
  *
  * `target` and `board` are required. Everything else is optional.
  */
-export declare const CuttlefishConfigSchema: z.ZodEffects<z.ZodObject<{
+export declare const CuttlefishConfigSchema: z.ZodObject<{
     entry: z.ZodOptional<z.ZodString>;
     target: z.ZodOptional<z.ZodString>;
     mcu: z.ZodOptional<z.ZodString>;
     board: z.ZodOptional<z.ZodString>;
     contract: z.ZodOptional<z.ZodString>;
     framework: z.ZodOptional<z.ZodString>;
-    /** ESP32 PSRAM type. When set, the framework emits the PSRAM-enabling
-     *  Kconfig/define so canvas allocations prefer external RAM (large scroll
-     *  viewports/lists stop failing on PSRAM targets). No effect on boards
-     *  without PSRAM (the runtime falls back to SRAM then the band renderer). */
-    psram: z.ZodOptional<z.ZodEnum<["opi", "quad"]>>;
+    psram: z.ZodOptional<z.ZodEnum<{
+        opi: "opi";
+        quad: "quad";
+    }>>;
     output: z.ZodOptional<z.ZodObject<{
         framework: z.ZodOptional<z.ZodString>;
-        optimize: z.ZodOptional<z.ZodEnum<["none", "size", "speed", "balanced"]>>;
         outDir: z.ZodOptional<z.ZodString>;
         defines: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        extraFlags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strict", z.ZodTypeAny, {
-        framework?: string | undefined;
-        outDir?: string | undefined;
-        optimize?: "none" | "size" | "speed" | "balanced" | undefined;
-        defines?: Record<string, string> | undefined;
-        extraFlags?: string[] | undefined;
-    }, {
-        framework?: string | undefined;
-        outDir?: string | undefined;
-        optimize?: "none" | "size" | "speed" | "balanced" | undefined;
-        defines?: Record<string, string> | undefined;
-        extraFlags?: string[] | undefined;
-    }>>;
+        extraFlags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
     frameworkData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
     test: z.ZodOptional<z.ZodObject<{
-        include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        include: z.ZodOptional<z.ZodArray<z.ZodString>>;
         port: z.ZodOptional<z.ZodString>;
         baudRate: z.ZodOptional<z.ZodNumber>;
         timeout: z.ZodOptional<z.ZodNumber>;
         buildTarget: z.ZodOptional<z.ZodString>;
         board: z.ZodOptional<z.ZodString>;
-    }, "strict", z.ZodTypeAny, {
-        port?: string | undefined;
-        include?: string[] | undefined;
-        board?: string | undefined;
-        timeout?: number | undefined;
-        buildTarget?: string | undefined;
-        baudRate?: number | undefined;
-    }, {
-        port?: string | undefined;
-        include?: string[] | undefined;
-        board?: string | undefined;
-        timeout?: number | undefined;
-        buildTarget?: string | undefined;
-        baudRate?: number | undefined;
-    }>>;
+    }, z.core.$strict>>;
     toolchain: z.ZodOptional<z.ZodObject<{
         type: z.ZodOptional<z.ZodString>;
         frameworkOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, "strict", z.ZodTypeAny, {
-        type?: string | undefined;
-        frameworkOptions?: Record<string, unknown> | undefined;
-    }, {
-        type?: string | undefined;
-        frameworkOptions?: Record<string, unknown> | undefined;
-    }>>;
+    }, z.core.$strict>>;
     console: z.ZodOptional<z.ZodObject<{
         baudRate: z.ZodOptional<z.ZodNumber>;
         port: z.ZodOptional<z.ZodString>;
-    }, "strict", z.ZodTypeAny, {
-        port?: string | undefined;
-        baudRate?: number | undefined;
-    }, {
-        port?: string | undefined;
-        baudRate?: number | undefined;
-    }>>;
+    }, z.core.$strict>>;
     native: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    /** Display profile config (driver, wiring, touch) — loosely typed here so
-     *  the loader's presence/shape extraction round-trips through validation. */
     display: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     zephyr: z.ZodOptional<z.ZodObject<{
         kconfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        cmakeArgs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        cmakeArgs: z.ZodOptional<z.ZodArray<z.ZodString>>;
         runner: z.ZodOptional<z.ZodString>;
-    }, "strict", z.ZodTypeAny, {
-        kconfig?: Record<string, string> | undefined;
-        cmakeArgs?: string[] | undefined;
-        runner?: string | undefined;
-    }, {
-        kconfig?: Record<string, string> | undefined;
-        cmakeArgs?: string[] | undefined;
-        runner?: string | undefined;
-    }>>;
-}, "strict", z.ZodTypeAny, {
-    console?: {
-        port?: string | undefined;
-        baudRate?: number | undefined;
-    } | undefined;
-    frameworkData?: Record<string, unknown> | undefined;
-    target?: string | undefined;
-    output?: {
-        framework?: string | undefined;
-        outDir?: string | undefined;
-        optimize?: "none" | "size" | "speed" | "balanced" | undefined;
-        defines?: Record<string, string> | undefined;
-        extraFlags?: string[] | undefined;
-    } | undefined;
-    include?: string[] | undefined;
-    board?: string | undefined;
-    entry?: string | undefined;
-    display?: Record<string, unknown> | undefined;
-    exclude?: string[] | undefined;
-    toolchain?: {
-        type?: string | undefined;
-        frameworkOptions?: Record<string, unknown> | undefined;
-    } | undefined;
-    zephyr?: {
-        kconfig?: Record<string, string> | undefined;
-        cmakeArgs?: string[] | undefined;
-        runner?: string | undefined;
-    } | undefined;
-    framework?: string | undefined;
-    native?: Record<string, unknown> | undefined;
-    mcu?: string | undefined;
-    contract?: string | undefined;
-    psram?: "opi" | "quad" | undefined;
-    test?: {
-        port?: string | undefined;
-        include?: string[] | undefined;
-        board?: string | undefined;
-        timeout?: number | undefined;
-        buildTarget?: string | undefined;
-        baudRate?: number | undefined;
-    } | undefined;
-}, {
-    console?: {
-        port?: string | undefined;
-        baudRate?: number | undefined;
-    } | undefined;
-    frameworkData?: Record<string, unknown> | undefined;
-    target?: string | undefined;
-    output?: {
-        framework?: string | undefined;
-        outDir?: string | undefined;
-        optimize?: "none" | "size" | "speed" | "balanced" | undefined;
-        defines?: Record<string, string> | undefined;
-        extraFlags?: string[] | undefined;
-    } | undefined;
-    include?: string[] | undefined;
-    board?: string | undefined;
-    entry?: string | undefined;
-    display?: Record<string, unknown> | undefined;
-    exclude?: string[] | undefined;
-    toolchain?: {
-        type?: string | undefined;
-        frameworkOptions?: Record<string, unknown> | undefined;
-    } | undefined;
-    zephyr?: {
-        kconfig?: Record<string, string> | undefined;
-        cmakeArgs?: string[] | undefined;
-        runner?: string | undefined;
-    } | undefined;
-    framework?: string | undefined;
-    native?: Record<string, unknown> | undefined;
-    mcu?: string | undefined;
-    contract?: string | undefined;
-    psram?: "opi" | "quad" | undefined;
-    test?: {
-        port?: string | undefined;
-        include?: string[] | undefined;
-        board?: string | undefined;
-        timeout?: number | undefined;
-        buildTarget?: string | undefined;
-        baudRate?: number | undefined;
-    } | undefined;
-}>, {
-    console?: {
-        port?: string | undefined;
-        baudRate?: number | undefined;
-    } | undefined;
-    frameworkData?: Record<string, unknown> | undefined;
-    target?: string | undefined;
-    output?: {
-        framework?: string | undefined;
-        outDir?: string | undefined;
-        optimize?: "none" | "size" | "speed" | "balanced" | undefined;
-        defines?: Record<string, string> | undefined;
-        extraFlags?: string[] | undefined;
-    } | undefined;
-    include?: string[] | undefined;
-    board?: string | undefined;
-    entry?: string | undefined;
-    display?: Record<string, unknown> | undefined;
-    exclude?: string[] | undefined;
-    toolchain?: {
-        type?: string | undefined;
-        frameworkOptions?: Record<string, unknown> | undefined;
-    } | undefined;
-    zephyr?: {
-        kconfig?: Record<string, string> | undefined;
-        cmakeArgs?: string[] | undefined;
-        runner?: string | undefined;
-    } | undefined;
-    framework?: string | undefined;
-    native?: Record<string, unknown> | undefined;
-    mcu?: string | undefined;
-    contract?: string | undefined;
-    psram?: "opi" | "quad" | undefined;
-    test?: {
-        port?: string | undefined;
-        include?: string[] | undefined;
-        board?: string | undefined;
-        timeout?: number | undefined;
-        buildTarget?: string | undefined;
-        baudRate?: number | undefined;
-    } | undefined;
-}, {
-    console?: {
-        port?: string | undefined;
-        baudRate?: number | undefined;
-    } | undefined;
-    frameworkData?: Record<string, unknown> | undefined;
-    target?: string | undefined;
-    output?: {
-        framework?: string | undefined;
-        outDir?: string | undefined;
-        optimize?: "none" | "size" | "speed" | "balanced" | undefined;
-        defines?: Record<string, string> | undefined;
-        extraFlags?: string[] | undefined;
-    } | undefined;
-    include?: string[] | undefined;
-    board?: string | undefined;
-    entry?: string | undefined;
-    display?: Record<string, unknown> | undefined;
-    exclude?: string[] | undefined;
-    toolchain?: {
-        type?: string | undefined;
-        frameworkOptions?: Record<string, unknown> | undefined;
-    } | undefined;
-    zephyr?: {
-        kconfig?: Record<string, string> | undefined;
-        cmakeArgs?: string[] | undefined;
-        runner?: string | undefined;
-    } | undefined;
-    framework?: string | undefined;
-    native?: Record<string, unknown> | undefined;
-    mcu?: string | undefined;
-    contract?: string | undefined;
-    psram?: "opi" | "quad" | undefined;
-    test?: {
-        port?: string | undefined;
-        include?: string[] | undefined;
-        board?: string | undefined;
-        timeout?: number | undefined;
-        buildTarget?: string | undefined;
-        baudRate?: number | undefined;
-    } | undefined;
-}>;
+        runnerArgs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 /** Inferred TypeScript type from the Zod schema. */
 export type ValidatedCuttlefishConfig = z.infer<typeof CuttlefishConfigSchema>;
 /**

package/dist/config-schema.js

@@ -6,14 +6,11 @@
 // enum constraints before the config is used by the transpiler.
 // ---------------------------------------------------------------------------
 import { z } from 'zod';
-/** Optimization levels accepted by the output.optimize field. */
-const OptimizationLevel = z.enum(['none', 'size', 'speed', 'balanced']);
 /** PSRAM types accepted by the top-level `psram` field (ESP32 PSRAM variants). */
 const PsramType = z.enum(['opi', 'quad']);
 /** Schema for the `output` section. */
 const OutputConfig = z.object({
     framework: z.string().min(1).optional(),
-    optimize: OptimizationLevel.optional(),
     outDir: z.string().optional(),
     defines: z.record(z.string(), z.string()).optional(),
     extraFlags: z.array(z.string()).optional(),
@@ -42,6 +39,7 @@ const ZephyrConfig = z.object({
     kconfig: z.record(z.string(), z.string()).optional(),
     cmakeArgs: z.array(z.string()).optional(),
     runner: z.string().optional(),
+    runnerArgs: z.array(z.string()).optional(),
 }).strict();
 /**
  * Schema for the full CuttlefishConfig shape.

package/dist/contract/contract-parser.d.ts

@@ -11,13 +11,7 @@ export declare const CONTRACT_VERSION: 1;
 declare const ContractComponentSchema: z.ZodObject<{
     reference: z.ZodString;
     dnp: z.ZodBoolean;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    reference: z.ZodString;
-    dnp: z.ZodBoolean;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    reference: z.ZodString;
-    dnp: z.ZodBoolean;
-}, z.ZodTypeAny, "passthrough">>;
+}, z.core.$loose>;
 /**
  * Info about a single connected MCU pin. The fields cuttlefish consumes
  * (pinName, pinType, net) are required; boardName is optional (present only
@@ -31,46 +25,14 @@ declare const ContractPinSchema: z.ZodObject<{
     externalComponents: z.ZodDefault<z.ZodArray<z.ZodObject<{
         reference: z.ZodString;
         dnp: z.ZodBoolean;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        reference: z.ZodString;
-        dnp: z.ZodBoolean;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        reference: z.ZodString;
-        dnp: z.ZodBoolean;
-    }, z.ZodTypeAny, "passthrough">>, "many">>;
-}, "strict", z.ZodTypeAny, {
-    pinName: string;
-    pinType: string;
-    net: string;
-    externalComponents: z.objectOutputType<{
-        reference: z.ZodString;
-        dnp: z.ZodBoolean;
-    }, z.ZodTypeAny, "passthrough">[];
-    boardName?: string | undefined;
-}, {
-    pinName: string;
-    pinType: string;
-    net: string;
-    boardName?: string | undefined;
-    externalComponents?: z.objectInputType<{
-        reference: z.ZodString;
-        dnp: z.ZodBoolean;
-    }, z.ZodTypeAny, "passthrough">[] | undefined;
-}>;
+    }, z.core.$loose>>>;
+}, z.core.$strict>;
 /** Which peripheral buses have all their required pins wired. */
 declare const AvailablePeripheralsSchema: z.ZodObject<{
     i2c: z.ZodBoolean;
     spi: z.ZodBoolean;
     uart: z.ZodBoolean;
-}, "strict", z.ZodTypeAny, {
-    i2c: boolean;
-    spi: boolean;
-    uart: boolean;
-}, {
-    i2c: boolean;
-    spi: boolean;
-    uart: boolean;
-}>;
+}, z.core.$strict>;
 /**
  * The top-level contract object. `.strict()` so a future v2 contract with new
  * top-level keys is rejected clearly (complementing the version check) rather
@@ -80,11 +42,7 @@ export declare const HwContractSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     mcu: z.ZodObject<{
         symbol: z.ZodString;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        symbol: z.ZodString;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        symbol: z.ZodString;
-    }, z.ZodTypeAny, "passthrough">>;
+    }, z.core.$loose>;
     connectedPins: z.ZodRecord<z.ZodString, z.ZodObject<{
         pinName: z.ZodString;
         pinType: z.ZodString;
@@ -93,90 +51,14 @@ export declare const HwContractSchema: z.ZodObject<{
         externalComponents: z.ZodDefault<z.ZodArray<z.ZodObject<{
             reference: z.ZodString;
             dnp: z.ZodBoolean;
-        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-            reference: z.ZodString;
-            dnp: z.ZodBoolean;
-        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-            reference: z.ZodString;
-            dnp: z.ZodBoolean;
-        }, z.ZodTypeAny, "passthrough">>, "many">>;
-    }, "strict", z.ZodTypeAny, {
-        pinName: string;
-        pinType: string;
-        net: string;
-        externalComponents: z.objectOutputType<{
-            reference: z.ZodString;
-            dnp: z.ZodBoolean;
-        }, z.ZodTypeAny, "passthrough">[];
-        boardName?: string | undefined;
-    }, {
-        pinName: string;
-        pinType: string;
-        net: string;
-        boardName?: string | undefined;
-        externalComponents?: z.objectInputType<{
-            reference: z.ZodString;
-            dnp: z.ZodBoolean;
-        }, z.ZodTypeAny, "passthrough">[] | undefined;
-    }>>;
+        }, z.core.$loose>>>;
+    }, z.core.$strict>>;
     availablePeripherals: z.ZodObject<{
         i2c: z.ZodBoolean;
         spi: z.ZodBoolean;
         uart: z.ZodBoolean;
-    }, "strict", z.ZodTypeAny, {
-        i2c: boolean;
-        spi: boolean;
-        uart: boolean;
-    }, {
-        i2c: boolean;
-        spi: boolean;
-        uart: boolean;
-    }>;
-}, "strict", z.ZodTypeAny, {
-    mcu: {
-        symbol: string;
-    } & {
-        [k: string]: unknown;
-    };
-    version: 1;
-    connectedPins: Record<string, {
-        pinName: string;
-        pinType: string;
-        net: string;
-        externalComponents: z.objectOutputType<{
-            reference: z.ZodString;
-            dnp: z.ZodBoolean;
-        }, z.ZodTypeAny, "passthrough">[];
-        boardName?: string | undefined;
-    }>;
-    availablePeripherals: {
-        i2c: boolean;
-        spi: boolean;
-        uart: boolean;
-    };
-}, {
-    mcu: {
-        symbol: string;
-    } & {
-        [k: string]: unknown;
-    };
-    version: 1;
-    connectedPins: Record<string, {
-        pinName: string;
-        pinType: string;
-        net: string;
-        boardName?: string | undefined;
-        externalComponents?: z.objectInputType<{
-            reference: z.ZodString;
-            dnp: z.ZodBoolean;
-        }, z.ZodTypeAny, "passthrough">[] | undefined;
-    }>;
-    availablePeripherals: {
-        i2c: boolean;
-        spi: boolean;
-        uart: boolean;
-    };
-}>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 export type ContractComponent = z.infer<typeof ContractComponentSchema>;
 export type ContractPin = z.infer<typeof ContractPinSchema>;
 export type AvailablePeripherals = z.infer<typeof AvailablePeripheralsSchema>;

package/dist/create/board-checklist.js

@@ -37,7 +37,7 @@ export function generateFrameworkChecklist(spec) {
         '',
         'Then rebuild and test:',
         '  npm run build --workspaces',
-        '  npx vitest run tests/packages/transpiler/init-scaffold.test.ts',
+        '  npx vitest run tests/packages/transpiler/scaffold.test.ts',
         '  npx vitest run tests/packages/framework-arduino/',
         '',
     ];

package/dist/create/board-codegen.js

@@ -4,7 +4,7 @@
 // registry/tests/README (idempotently), and returns the file list + the
 // framework-anticipation checklist.
 //
-// Pattern: mirrors init-scaffold.ts's scaffoldProject — a writeFile closure
+// Pattern: mirrors scaffold.ts's scaffoldProject — a writeFile closure
 // + fs.writeFileSync + tracks createdFiles.
 // ---------------------------------------------------------------------------
 import path from 'node:path';
@@ -100,12 +100,12 @@ export function scaffoldBoardPackages(spec, opts = {}) {
         }
         catch { /* best-effort: skip if package.json isn't valid */ }
     }
-    // 2. init-scaffold.ts registry entry
-    const scaffoldPath = path.join(rootDir, 'packages', 'cuttlefish', 'src', 'create', 'init-scaffold.ts');
+    // 2. scaffold.ts registry entry
+    const scaffoldPath = path.join(rootDir, 'packages', 'cuttlefish', 'src', 'create', 'scaffold.ts');
     const registryEntry = `  {\n    id: '${spec.boardId}',\n    displayName: '${spec.boardName}',\n    isNative: false,\n    architecture: '${arch}',\n    boardPackage: '@typecad/board-${arch}',\n    frameworkPackage: '@typecad/framework-arduino',\n    framework: 'arduino',\n    buildTarget: '${spec.fqbn}',\n    mcu: '${arch}',\n  },\n`;
     insertAfter(scaffoldPath, "  _knownTargets: KnownTarget[] = [", registryEntry, `'${spec.boardId}'`);
     // 3. KNOWN_BOARDS test
-    const testPath = path.join(rootDir, 'tests', 'packages', 'transpiler', 'init-scaffold.test.ts');
+    const testPath = path.join(rootDir, 'tests', 'packages', 'transpiler', 'scaffold.test.ts');
     const testEntry = `
     it("contains ${spec.boardId}", () => {
       const b = KNOWN_BOARDS.find(b => b.id === '${spec.boardId}');