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

package/dist/config-schema.d.ts

@@ -4,257 +4,49 @@ 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>;
+    soc: 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>;
         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;
-        defines?: Record<string, string> | undefined;
-        extraFlags?: string[] | undefined;
-    }, {
-        framework?: string | undefined;
-        outDir?: string | 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, {
-        board?: string | undefined;
-        include?: string[] | undefined;
-        port?: string | undefined;
-        baudRate?: number | undefined;
-        timeout?: number | undefined;
-        buildTarget?: string | undefined;
-    }, {
-        board?: string | undefined;
-        include?: string[] | undefined;
-        port?: string | undefined;
-        baudRate?: number | undefined;
-        timeout?: number | undefined;
-        buildTarget?: string | 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;
-    }>>;
-    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>>;
+        probe: z.ZodOptional<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, {
-    entry?: string | undefined;
-    target?: string | undefined;
-    mcu?: string | undefined;
-    board?: string | undefined;
-    contract?: string | undefined;
-    framework?: string | undefined;
-    psram?: "opi" | "quad" | undefined;
-    output?: {
-        framework?: string | undefined;
-        outDir?: string | undefined;
-        defines?: Record<string, string> | undefined;
-        extraFlags?: string[] | undefined;
-    } | undefined;
-    frameworkData?: Record<string, unknown> | undefined;
-    include?: string[] | undefined;
-    exclude?: string[] | undefined;
-    test?: {
-        board?: string | undefined;
-        include?: string[] | undefined;
-        port?: string | undefined;
-        baudRate?: number | undefined;
-        timeout?: number | undefined;
-        buildTarget?: string | undefined;
-    } | undefined;
-    toolchain?: {
-        type?: string | undefined;
-        frameworkOptions?: Record<string, unknown> | undefined;
-    } | undefined;
-    console?: {
-        port?: string | undefined;
-        baudRate?: number | undefined;
-    } | undefined;
-    native?: Record<string, unknown> | undefined;
-    display?: Record<string, unknown> | undefined;
-    zephyr?: {
-        kconfig?: Record<string, string> | undefined;
-        cmakeArgs?: string[] | undefined;
-        runner?: string | undefined;
-    } | undefined;
-}, {
-    entry?: string | undefined;
-    target?: string | undefined;
-    mcu?: string | undefined;
-    board?: string | undefined;
-    contract?: string | undefined;
-    framework?: string | undefined;
-    psram?: "opi" | "quad" | undefined;
-    output?: {
-        framework?: string | undefined;
-        outDir?: string | undefined;
-        defines?: Record<string, string> | undefined;
-        extraFlags?: string[] | undefined;
-    } | undefined;
-    frameworkData?: Record<string, unknown> | undefined;
-    include?: string[] | undefined;
-    exclude?: string[] | undefined;
-    test?: {
-        board?: string | undefined;
-        include?: string[] | undefined;
-        port?: string | undefined;
-        baudRate?: number | undefined;
-        timeout?: number | undefined;
-        buildTarget?: string | undefined;
-    } | undefined;
-    toolchain?: {
-        type?: string | undefined;
-        frameworkOptions?: Record<string, unknown> | undefined;
-    } | undefined;
-    console?: {
-        port?: string | undefined;
-        baudRate?: number | undefined;
-    } | undefined;
-    native?: Record<string, unknown> | undefined;
-    display?: Record<string, unknown> | undefined;
-    zephyr?: {
-        kconfig?: Record<string, string> | undefined;
-        cmakeArgs?: string[] | undefined;
-        runner?: string | undefined;
-    } | undefined;
-}>, {
-    entry?: string | undefined;
-    target?: string | undefined;
-    mcu?: string | undefined;
-    board?: string | undefined;
-    contract?: string | undefined;
-    framework?: string | undefined;
-    psram?: "opi" | "quad" | undefined;
-    output?: {
-        framework?: string | undefined;
-        outDir?: string | undefined;
-        defines?: Record<string, string> | undefined;
-        extraFlags?: string[] | undefined;
-    } | undefined;
-    frameworkData?: Record<string, unknown> | undefined;
-    include?: string[] | undefined;
-    exclude?: string[] | undefined;
-    test?: {
-        board?: string | undefined;
-        include?: string[] | undefined;
-        port?: string | undefined;
-        baudRate?: number | undefined;
-        timeout?: number | undefined;
-        buildTarget?: string | undefined;
-    } | undefined;
-    toolchain?: {
-        type?: string | undefined;
-        frameworkOptions?: Record<string, unknown> | undefined;
-    } | undefined;
-    console?: {
-        port?: string | undefined;
-        baudRate?: number | undefined;
-    } | undefined;
-    native?: Record<string, unknown> | undefined;
-    display?: Record<string, unknown> | undefined;
-    zephyr?: {
-        kconfig?: Record<string, string> | undefined;
-        cmakeArgs?: string[] | undefined;
-        runner?: string | undefined;
-    } | undefined;
-}, {
-    entry?: string | undefined;
-    target?: string | undefined;
-    mcu?: string | undefined;
-    board?: string | undefined;
-    contract?: string | undefined;
-    framework?: string | undefined;
-    psram?: "opi" | "quad" | undefined;
-    output?: {
-        framework?: string | undefined;
-        outDir?: string | undefined;
-        defines?: Record<string, string> | undefined;
-        extraFlags?: string[] | undefined;
-    } | undefined;
-    frameworkData?: Record<string, unknown> | undefined;
-    include?: string[] | undefined;
-    exclude?: string[] | undefined;
-    test?: {
-        board?: string | undefined;
-        include?: string[] | undefined;
-        port?: string | undefined;
-        baudRate?: number | undefined;
-        timeout?: number | undefined;
-        buildTarget?: string | undefined;
-    } | undefined;
-    toolchain?: {
-        type?: string | undefined;
-        frameworkOptions?: Record<string, unknown> | undefined;
-    } | undefined;
-    console?: {
-        port?: string | undefined;
-        baudRate?: number | undefined;
-    } | undefined;
-    native?: Record<string, unknown> | undefined;
-    display?: Record<string, unknown> | undefined;
-    zephyr?: {
-        kconfig?: Record<string, string> | undefined;
-        cmakeArgs?: string[] | undefined;
-        runner?: string | undefined;
-    } | undefined;
-}>;
+        runnerArgs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        customBoard: z.ZodOptional<z.ZodBoolean>;
+    }, 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

@@ -15,11 +15,6 @@ const OutputConfig = z.object({
     defines: z.record(z.string(), z.string()).optional(),
     extraFlags: z.array(z.string()).optional(),
 }).strict();
-/** Schema for the `console` section. */
-const ConsoleConfig = z.object({
-    baudRate: z.number().int().positive().optional(),
-    port: z.string().optional(),
-}).strict();
 /** Schema for the `test` section. */
 const TestConfig = z.object({
     include: z.array(z.string()).optional(),
@@ -38,7 +33,14 @@ const ToolchainConfig = z.object({
 const ZephyrConfig = z.object({
     kconfig: z.record(z.string(), z.string()).optional(),
     cmakeArgs: z.array(z.string()).optional(),
+    probe: z.string().optional(),
     runner: z.string().optional(),
+    runnerArgs: z.array(z.string()).optional(),
+    /** Generate an out-of-tree Zephyr board for an MCU-only target (no board
+     *  package): the framework emits boards/typecad/<buildTarget>/ from the
+     *  MCU package's silicon data (SoC, console, clock plan). The board is
+     *  named after `frameworkData.buildTarget`. */
+    customBoard: z.boolean().optional(),
 }).strict();
 /**
  * Schema for the full CuttlefishConfig shape.
@@ -48,8 +50,8 @@ const ZephyrConfig = z.object({
 export const CuttlefishConfigSchema = z.object({
     entry: z.string().optional(),
     target: z.string().min(1).optional(),
-    mcu: z.string().min(1).optional(),
     board: z.string().optional(),
+    soc: z.string().optional(),
     contract: z.string().optional(),
     framework: z.string().optional(),
     /** ESP32 PSRAM type. When set, the framework emits the PSRAM-enabling
@@ -63,13 +65,12 @@ export const CuttlefishConfigSchema = z.object({
     exclude: z.array(z.string()).optional(),
     test: TestConfig.optional(),
     toolchain: ToolchainConfig.optional(),
-    console: ConsoleConfig.optional(),
     native: z.record(z.string(), z.unknown()).optional(),
     /** Display profile config (driver, wiring, touch) — loosely typed here so
      *  the loader's presence/shape extraction round-trips through validation. */
     display: z.record(z.string(), z.unknown()).optional(),
     zephyr: ZephyrConfig.optional(),
-}).strict().refine(data => !(data.board && data.contract), {
+}).strict().refine(data => !(data.board && (data.contract || data.soc)), {
     message: "Specifying both 'board' and 'contract' is not allowed. Choose one.",
     path: ['board'],
 });

package/dist/contract/board-generator.d.ts

@@ -3,11 +3,11 @@ export declare const CUTTLEFISH_DIR = ".cuttlefish";
 export interface GenerateBoardOptions {
     /** Absolute project root dir (where .cuttlefish/ lives). */
     projectDir: string;
-    /** MCU package specifier, e.g. '@typecad/mcu-atmega328p'. */
-    mcuPackage: string;
-    /** Matched MCU pin names to re-export (e.g. ['PB5','PC4']). */
+    /** The Zephyr SoC name the contract narrows (e.g. 'stm32f411xe'). */
+    soc: string;
+    /** Matched pin names to export (e.g. ['PB5','PC4']). */
     connectedPins: string[];
-    /** Selected peripheral instance names to re-export (e.g. ['I2C0']). */
+    /** Selected peripheral instance names to export (e.g. ['I2C0']). */
     peripherals: string[];
 }
 /**

package/dist/contract/board-generator.js

@@ -17,6 +17,7 @@
 // ---------------------------------------------------------------------------
 import fs from 'node:fs';
 import path from 'node:path';
+const BS_DOT = /\./g;
 /** The directory (relative to the project root) where board.ts is generated. */
 export const CUTTLEFISH_DIR = '.cuttlefish';
 /**
@@ -24,7 +25,7 @@ export const CUTTLEFISH_DIR = '.cuttlefish';
  * @returns the absolute path to the generated file.
  */
 export function generateBoardFile(opts) {
-    const { projectDir, mcuPackage, connectedPins, peripherals } = opts;
+    const { projectDir, soc, connectedPins, peripherals } = opts;
     const cuttlefishDir = path.join(projectDir, CUTTLEFISH_DIR);
     if (!fs.existsSync(cuttlefishDir)) {
         fs.mkdirSync(cuttlefishDir, { recursive: true });
@@ -34,21 +35,31 @@ export function generateBoardFile(opts) {
         '// Do not edit manually — regenerate by re-running cuttlefish.',
         '//',
         '// This board exposes only the pins and peripherals that the source contract',
-        `// (${mcuPackage}) declares as connected on the PCB. Pins the board did not wire`,
+        `// (soc ${soc}) declares as connected on the PCB. Pins the board did not wire`,
         '// are intentionally absent: using one is a compile error.',
         '',
         '// Full HAL runtime surface (constants, timing, math, GPIO/bus helpers).',
-        "export * from '@typecad/hal';",
+        "import { Pin, I2CBus, SPIBus, UART } from '@typecad/hal';",
         '',
         '// Narrowed pin set — only pins the contract declares connected.',
     ];
     if (connectedPins.length > 0) {
-        lines.push(`export { ${connectedPins.join(', ')} } from '${mcuPackage}';`);
+        for (const pin of connectedPins) {
+            const ident = pin.replace(BS_DOT, '_');
+            lines.push(`export const ${ident} = Pin.fromPort('${pin}');`);
+        }
     }
     if (peripherals.length > 0) {
         lines.push('');
         lines.push('// Narrowed peripheral set — only buses whose pins are wired on the PCB.');
-        lines.push(`export { ${peripherals.join(', ')} } from '${mcuPackage}';`);
+        for (const p of peripherals) {
+            if (p.startsWith('I2C'))
+                lines.push(`export const ${p} = new I2CBus('${p}');`);
+            else if (p.startsWith('SPI'))
+                lines.push(`export const ${p} = new SPIBus('${p}');`);
+            else if (p.startsWith('UART'))
+                lines.push(`export const ${p} = new UART('${p}');`);
+        }
     }
     lines.push(''); // trailing newline
     const outPath = path.join(cuttlefishDir, 'board.ts');

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>;
@@ -214,4 +96,31 @@ export declare function matchConnectedPins(contract: HwContract, mcuPinNames: re
  * becomes a compile error on a board whose PCB doesn't route SPI.
  */
 export declare function selectPeripherals(contract: HwContract, mcuPeripheralNames: readonly string[]): string[];
+/**
+ * The canonical MCU pad names the contract declares wired — boardName when
+ * typecad.net carried a mapping, else the KiCAD pin-name segment that looks
+ * like a datasheet pad (PA5, PB6, P0.28, GPIO9). De-duplicated, order
+ * preserved. This replaces the old soc-manifest pinNames source: under
+ * SDK-as-truth the contract itself declares the wired pads.
+ */
+export declare function contractPinNames(contract: HwContract): string[];
+/** One wired pad: the MCU datasheet name plus an optional functional alias. */
+export interface ContractPad {
+    /** Datasheet-form pad name (PA9, P0.28, GP25) — what boardgen can place. */
+    mcuName: string;
+    /** Functional name from the schematic (TX, RX, LED) when boardName is not
+     *  itself a pad name. Exported as an alias pointing at the pad. */
+    alias?: string;
+}
+/**
+ * The wired pads of the contract, as MCU datasheet names plus optional
+ * functional aliases. For each non-power pin: boardName is preferred when
+ * it is itself pad-form (PA9); otherwise the KiCAD pin-name segments are
+ * searched for a pad-form name ("XTAL1/PB6" → PB6). When boardName is set
+ * but NOT pad-form (TX, LED), it rides along as the pad's alias.
+ *
+ * This replaces the old soc-manifest pinNames source: under SDK-as-truth
+ * the contract declares the wired pads itself.
+ */
+export declare function contractPads(contract: HwContract): ContractPad[];
 export {};

package/dist/contract/contract-parser.js

@@ -222,3 +222,79 @@ export function selectPeripherals(contract, mcuPeripheralNames) {
         return true;
     });
 }
+/**
+ * The canonical MCU pad names the contract declares wired — boardName when
+ * typecad.net carried a mapping, else the KiCAD pin-name segment that looks
+ * like a datasheet pad (PA5, PB6, P0.28, GPIO9). De-duplicated, order
+ * preserved. This replaces the old soc-manifest pinNames source: under
+ * SDK-as-truth the contract itself declares the wired pads.
+ */
+export function contractPinNames(contract) {
+    const out = [];
+    const seen = new Set();
+    for (const pin of Object.values(contract.connectedPins)) {
+        if (isPowerPin(pin))
+            continue;
+        if (pin.boardName && !seen.has(pin.boardName)) {
+            seen.add(pin.boardName);
+            out.push(pin.boardName);
+            continue;
+        }
+        const segments = pin.pinName.replace(/[~{}]/g, '').split(/[/-]/);
+        const padLike = segments.find((seg) => /^(?:P[A-Za-z]\d|P\d\.\d{1,2}|GPIO\d{1,2}|GP\d{1,2})$/i.test(seg));
+        if (padLike && !seen.has(padLike.toUpperCase())) {
+            seen.add(padLike.toUpperCase());
+            out.push(padLike.toUpperCase());
+        }
+    }
+    return out;
+}
+/** A pad-form name in any supported family notation. */
+function isPadName(name) {
+    return /^(?:P[A-Pa-p]\d{1,2}|P\d\.\d{1,2}|GPIO\d{1,2}|GP\d{1,2})$/.test(name.trim());
+}
+/**
+ * The wired pads of the contract, as MCU datasheet names plus optional
+ * functional aliases. For each non-power pin: boardName is preferred when
+ * it is itself pad-form (PA9); otherwise the KiCAD pin-name segments are
+ * searched for a pad-form name ("XTAL1/PB6" → PB6). When boardName is set
+ * but NOT pad-form (TX, LED), it rides along as the pad's alias.
+ *
+ * This replaces the old soc-manifest pinNames source: under SDK-as-truth
+ * the contract declares the wired pads itself.
+ */
+export function contractPads(contract) {
+    const out = [];
+    const seen = new Set();
+    for (const pin of Object.values(contract.connectedPins)) {
+        if (isPowerPin(pin))
+            continue;
+        let pad;
+        let alias;
+        if (pin.boardName && isPadName(pin.boardName)) {
+            pad = pin.boardName.toUpperCase().replace(/^P([AP]) (\d{1,2})$/, 'P$1.$2');
+        }
+        if (!pad) {
+            const segments = pin.pinName.replace(/[~{}]/g, '').split(/[/-]/);
+            pad = segments.find((seg) => isPadName(seg));
+        }
+        if (!pad)
+            continue;
+        pad = pad.toUpperCase();
+        if (pin.boardName && pin.boardName !== pad)
+            alias = pin.boardName;
+        if (seen.has(pad)) {
+            // Same pad, new functional alias — keep the alias on the existing pad
+            // (a pad can be exported under two names).
+            if (alias) {
+                const existing = out.find((p) => p.mcuName === pad);
+                if (existing && !existing.alias)
+                    existing.alias = alias;
+            }
+            continue;
+        }
+        seen.add(pad);
+        out.push({ mcuName: pad, ...(alias ? { alias } : {}) });
+    }
+    return out;
+}