@typecad/cuttlefish 1.0.0-alpha.7 → 1.0.0-alpha.9

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

@@ -0,0 +1,217 @@
+import { z } from 'zod';
+/** Contract schema version. Only 1 is currently defined. */
+export declare const CONTRACT_VERSION: 1;
+/**
+ * An external component on the same net as an MCU pin. Validated LENIENTLY:
+ * cuttlefish does not act on component metadata, so we only require the fields
+ * the firmware toolchain reads (reference + dnp) and accept unknown extras
+ * (voltage, wattage, tolerance, ...) without rejecting the contract. This
+ * keeps cuttlefish forward-compatible with typecad.net adding component fields.
+ */
+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">>;
+/**
+ * Info about a single connected MCU pin. The fields cuttlefish consumes
+ * (pinName, pinType, net) are required; boardName is optional (present only
+ * when typecad.net's Component.typehal map was set).
+ */
+declare const ContractPinSchema: z.ZodObject<{
+    pinName: z.ZodString;
+    pinType: z.ZodString;
+    boardName: z.ZodOptional<z.ZodString>;
+    net: z.ZodString;
+    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;
+}>;
+/** 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;
+}>;
+/**
+ * The top-level contract object. `.strict()` so a future v2 contract with new
+ * top-level keys is rejected clearly (complementing the version check) rather
+ * than silently accepted with the new fields dropped.
+ */
+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">>;
+    connectedPins: z.ZodRecord<z.ZodString, z.ZodObject<{
+        pinName: z.ZodString;
+        pinType: z.ZodString;
+        boardName: z.ZodOptional<z.ZodString>;
+        net: z.ZodString;
+        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;
+    }>>;
+    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;
+    };
+}>;
+export type ContractComponent = z.infer<typeof ContractComponentSchema>;
+export type ContractPin = z.infer<typeof ContractPinSchema>;
+export type AvailablePeripherals = z.infer<typeof AvailablePeripheralsSchema>;
+export type HwContract = z.infer<typeof HwContractSchema>;
+/**
+ * Parses a TypeCAD contract file.
+ *
+ * The version is checked first as a fast path so a v2 (or later) contract
+ * fails with "unsupported version, update cuttlefish" rather than a cascade
+ * of field-mismatch errors. After the version check, the full schema is
+ * applied for precise per-field validation.
+ *
+ * @throws on an unreadable file, invalid JSON, unsupported version, or
+ *   schema-validation failure (with a path-annotated message).
+ */
+export declare function parseContractFile(contractPath: string): HwContract;
+/**
+ * Matches contract pins to canonical MCU pin names (e.g. 'PB5', 'PC4').
+ *
+ * Strategy (boardName-first, substring fallback):
+ *   1. If the contract pin carries a `boardName` (populated by typecad.net when
+ *      Component.typehal was set) and that name appears in mcuPinNames, use it
+ *      directly — it is the user-validated mapping.
+ *   2. Otherwise, substring-match the KiCAD `pinName` against mcuPinNames
+ *      (e.g. "XTAL1/PB6" contains "PB6"). This covers contracts emitted without
+ *      a typehal map.
+ *
+ * Power/ground pins are excluded. The result is de-duplicated.
+ */
+export declare function matchConnectedPins(contract: HwContract, mcuPinNames: readonly string[]): string[];
+/**
+ * Selects which MCU peripheral instance names to re-export based on the
+ * contract's availablePeripherals. If the contract says SPI isn't wired,
+ * SPI0 (and friends) is dropped from the narrowed board — so `SPI0.begin()`
+ * becomes a compile error on a board whose PCB doesn't route SPI.
+ */
+export declare function selectPeripherals(contract: HwContract, mcuPeripheralNames: readonly string[]): string[];
+export {};

package/dist/contract/contract-parser.js

@@ -0,0 +1,224 @@
+// ---------------------------------------------------------------------------
+// Contract parser — reads a TypeCAD hardware contract (*.contract.json)
+//
+// A contract is produced by the sister project typecad.net (TypeScript +
+// KiCAD). It describes the physical connections of an MCU on a designed PCB:
+// which pins are wired, to what nets, and which peripherals (I2C/SPI/UART)
+// are available. This module parses that file and narrows it against an MCU
+// package's TypeCADManifest to find the concrete MCU pin/peripheral names
+// that the firmware is allowed to touch.
+//
+// The matched names feed board-generator.ts, which writes a narrowed
+// `.cuttlefish/board.ts` so that `import { ... } from '@typecad/board'`
+// exposes only the pins the actual PCB has wired — a pin used elsewhere on
+// the board becomes a compile error in the firmware.
+//
+// Zod is used (rather than a plain JSON.parse + cast) because the contract is
+// a cross-project interchange format: it crosses a trust boundary from a
+// different codebase (typecad.net) with its own release cadence. Precise
+// validation at this boundary turns silent "board generated with no pins"
+// failures into clear "expected boolean, received string at
+// availablePeripherals.i2c" errors. zod is already a runtime dependency of
+// cuttlefish (config-schema.ts).
+// ---------------------------------------------------------------------------
+import fs from 'node:fs';
+import { z } from 'zod';
+// ---------------------------------------------------------------------------
+// Contract schema — the authoritative shape of a *.contract.json file.
+//
+// The types exported below (HwContract, ContractPin, ...) are DERIVED from
+// this schema via z.infer, so the runtime validation and the compile-time
+// type cannot drift. This mirrors the shape produced by
+// typeCAD/@typecad/typecad/src/contract.ts; the schema is the local source of
+// truth so cuttlefish pins to a stable contract format regardless of
+// typecad.net's internal evolution.
+// ---------------------------------------------------------------------------
+/** Contract schema version. Only 1 is currently defined. */
+export const CONTRACT_VERSION = 1;
+/**
+ * An external component on the same net as an MCU pin. Validated LENIENTLY:
+ * cuttlefish does not act on component metadata, so we only require the fields
+ * the firmware toolchain reads (reference + dnp) and accept unknown extras
+ * (voltage, wattage, tolerance, ...) without rejecting the contract. This
+ * keeps cuttlefish forward-compatible with typecad.net adding component fields.
+ */
+const ContractComponentSchema = z.object({
+    reference: z.string(),
+    dnp: z.boolean(),
+}).passthrough();
+/**
+ * Info about a single connected MCU pin. The fields cuttlefish consumes
+ * (pinName, pinType, net) are required; boardName is optional (present only
+ * when typecad.net's Component.typehal map was set).
+ */
+const ContractPinSchema = z.object({
+    pinName: z.string(),
+    pinType: z.string(),
+    boardName: z.string().optional(),
+    net: z.string(),
+    externalComponents: z.array(ContractComponentSchema).default([]),
+}).strict();
+/** Which peripheral buses have all their required pins wired. */
+const AvailablePeripheralsSchema = z.object({
+    i2c: z.boolean(),
+    spi: z.boolean(),
+    uart: z.boolean(),
+}).strict();
+/** MCU identifying metadata. Only `symbol` is load-bearing for cuttlefish. */
+const ContractMcuSchema = z.object({
+    symbol: z.string(),
+}).passthrough();
+/**
+ * The top-level contract object. `.strict()` so a future v2 contract with new
+ * top-level keys is rejected clearly (complementing the version check) rather
+ * than silently accepted with the new fields dropped.
+ */
+export const HwContractSchema = z.object({
+    version: z.literal(CONTRACT_VERSION),
+    mcu: ContractMcuSchema,
+    connectedPins: z.record(z.string(), ContractPinSchema),
+    availablePeripherals: AvailablePeripheralsSchema,
+}).strict();
+// ---------------------------------------------------------------------------
+// KiCAD electrical-type and net-name tables for power-pin exclusion.
+// ---------------------------------------------------------------------------
+/** KiCAD pin types that are not user GPIO and must not be re-exported as digital pins. */
+const NON_GPIO_PIN_TYPES = new Set([
+    'power_in',
+    'power_out',
+    'passive', // typically decoupling/nc ties
+]);
+/** Net names that indicate a power/ground rail, not a signal. */
+const POWER_NET_NAMES = new Set(['VCC', 'GND', 'VDD', 'VSS', '+3V3', '+5V', 'AVCC', 'AREF']);
+// ---------------------------------------------------------------------------
+// Parsing
+// ---------------------------------------------------------------------------
+/**
+ * Reformats a ZodError into a single readable, path-annotated message.
+ * Zod's default .message is a JSON blob; users want "at availablePeripherals.i2c:
+ * expected boolean, received string".
+ */
+function formatZodError(err, contractPath) {
+    const issues = err.issues.map((issue) => {
+        const path = issue.path.length > 0 ? issue.path.join('.') : '(root)';
+        return `  at ${path}: ${issue.message}`;
+    });
+    return `Contract ${contractPath} failed validation:\n${issues.join('\n')}`;
+}
+/**
+ * Parses a TypeCAD contract file.
+ *
+ * The version is checked first as a fast path so a v2 (or later) contract
+ * fails with "unsupported version, update cuttlefish" rather than a cascade
+ * of field-mismatch errors. After the version check, the full schema is
+ * applied for precise per-field validation.
+ *
+ * @throws on an unreadable file, invalid JSON, unsupported version, or
+ *   schema-validation failure (with a path-annotated message).
+ */
+export function parseContractFile(contractPath) {
+    let content;
+    try {
+        content = fs.readFileSync(contractPath, 'utf-8');
+    }
+    catch (err) {
+        throw new Error(`Could not read contract file at ${contractPath}: ${err.message}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch (err) {
+        throw new Error(`Contract file ${contractPath} is not valid JSON: ${err.message}`);
+    }
+    // Fast path: reject an unsupported version before the full schema runs, so
+    // the error names the real problem rather than listing every field that
+    // differs from v1.
+    const version = parsed?.version;
+    if (version !== CONTRACT_VERSION) {
+        throw new Error(`Unsupported contract version in ${contractPath}: expected ${CONTRACT_VERSION}, got ${String(version)}. ` +
+            `This may be a newer contract format; update @typecad/cuttlefish.`);
+    }
+    // Full schema validation.
+    try {
+        return HwContractSchema.parse(parsed);
+    }
+    catch (err) {
+        if (err instanceof z.ZodError) {
+            throw new Error(formatZodError(err, contractPath));
+        }
+        throw err;
+    }
+}
+// ---------------------------------------------------------------------------
+// Matching — narrows the contract against an MCU package's manifest.
+// ---------------------------------------------------------------------------
+/**
+ * Returns true if a contract pin represents a power/ground/decoupling connection
+ * rather than a usable GPIO. Such pins must not be re-exported as digital pins.
+ */
+function isPowerPin(pin) {
+    if (NON_GPIO_PIN_TYPES.has(pin.pinType))
+        return true;
+    if (POWER_NET_NAMES.has(pin.net))
+        return true;
+    // KiCAD auto-generated nets like "net6" are signal nets; named power rails are not.
+    return false;
+}
+/**
+ * Matches contract pins to canonical MCU pin names (e.g. 'PB5', 'PC4').
+ *
+ * Strategy (boardName-first, substring fallback):
+ *   1. If the contract pin carries a `boardName` (populated by typecad.net when
+ *      Component.typehal was set) and that name appears in mcuPinNames, use it
+ *      directly — it is the user-validated mapping.
+ *   2. Otherwise, substring-match the KiCAD `pinName` against mcuPinNames
+ *      (e.g. "XTAL1/PB6" contains "PB6"). This covers contracts emitted without
+ *      a typehal map.
+ *
+ * Power/ground pins are excluded. The result is de-duplicated.
+ */
+export function matchConnectedPins(contract, mcuPinNames) {
+    const mcuSet = new Set(mcuPinNames);
+    const matched = new Set();
+    for (const pin of Object.values(contract.connectedPins)) {
+        if (isPowerPin(pin))
+            continue;
+        // (1) boardName-first: explicit, firmware-friendly mapping.
+        if (pin.boardName && mcuSet.has(pin.boardName)) {
+            matched.add(pin.boardName);
+            continue;
+        }
+        // (2) substring fallback: the MCU port name appears inside the KiCAD pin name.
+        // Compound KiCAD names like "XTAL1/PB6" or "~{RESET}/PC6" are split on "/"
+        // and each segment is checked so we don't false-match on a prefix.
+        const segments = pin.pinName.replace(/[~{}]/g, '').split(/[/-]/);
+        for (const mcuPin of mcuPinNames) {
+            if (segments.includes(mcuPin)) {
+                matched.add(mcuPin);
+                break;
+            }
+        }
+    }
+    return Array.from(matched);
+}
+/**
+ * Selects which MCU peripheral instance names to re-export based on the
+ * contract's availablePeripherals. If the contract says SPI isn't wired,
+ * SPI0 (and friends) is dropped from the narrowed board — so `SPI0.begin()`
+ * becomes a compile error on a board whose PCB doesn't route SPI.
+ */
+export function selectPeripherals(contract, mcuPeripheralNames) {
+    const avail = contract.availablePeripherals ?? { i2c: false, spi: false, uart: false };
+    return mcuPeripheralNames.filter((name) => {
+        // Match instance-family prefixes: I2C0/I2C1 → "i2c", SPI0/SPI1 → "spi", UART0 → "uart".
+        if (/^I2C\d/.test(name))
+            return avail.i2c;
+        if (/^SPI\d/.test(name))
+            return avail.spi;
+        if (/^UART\d/.test(name))
+            return avail.uart;
+        // Unknown peripheral families are preserved (don't silently drop something we don't recognize).
+        return true;
+    });
+}

package/dist/contract/index.d.ts

@@ -0,0 +1,22 @@
+import type { ResolvedCuttlefishConfig } from '../config-loader.js';
+export type { HwContract, ContractPin, ContractComponent, AvailablePeripherals, } from './contract-parser.js';
+export { parseContractFile, matchConnectedPins, selectPeripherals } from './contract-parser.js';
+export { generateBoardFile, CUTTLEFISH_DIR } from './board-generator.js';
+export type { GenerateBoardOptions } from './board-generator.js';
+/**
+ * Orchestrates contract-based board generation for a resolved config:
+ *   1. Reads the contract file at `config.contract` (resolved relative to the
+ *      project root, i.e. the dir containing cuttlefish.config.ts).
+ *   2. Dynamically imports the MCU package's `TypeCADManifest` to discover the
+ *      canonical pin and peripheral names.
+ *   3. Matches contract pins → MCU pin names and selects peripherals.
+ *   4. Writes the narrowed `.cuttlefish/board.ts`.
+ *
+ * This is the step that re-opens the typecad.net → cuttlefish interop. After it
+ * runs, the existing `export * from './board.js'` in cuttlefish-env.d.ts
+ * resolves to a board exposing only the pins the actual PCB has wired.
+ *
+ * @throws on a missing/unreadable/unparseable contract, an unsupported version,
+ *   or if the MCU package can't be loaded for its manifest.
+ */
+export declare function generateContractBoard(config: ResolvedCuttlefishConfig): Promise<string>;

package/dist/contract/index.js

@@ -0,0 +1,68 @@
+// ---------------------------------------------------------------------------
+// Contract module barrel — entry point for contract-based board generation.
+//
+// Exports the parser, the board generator, and the `generateContractBoard`
+// orchestrator that the CLI calls when `config.contract` is set. The env.d.ts
+// emitted by config-loader.ts points `@typecad/board` at `./board.js`, and this
+// module is what writes that file.
+// ---------------------------------------------------------------------------
+import path from 'node:path';
+import { parseContractFile, matchConnectedPins, selectPeripherals } from './contract-parser.js';
+import { generateBoardFile } from './board-generator.js';
+export { parseContractFile, matchConnectedPins, selectPeripherals } from './contract-parser.js';
+export { generateBoardFile, CUTTLEFISH_DIR } from './board-generator.js';
+/**
+ * Orchestrates contract-based board generation for a resolved config:
+ *   1. Reads the contract file at `config.contract` (resolved relative to the
+ *      project root, i.e. the dir containing cuttlefish.config.ts).
+ *   2. Dynamically imports the MCU package's `TypeCADManifest` to discover the
+ *      canonical pin and peripheral names.
+ *   3. Matches contract pins → MCU pin names and selects peripherals.
+ *   4. Writes the narrowed `.cuttlefish/board.ts`.
+ *
+ * This is the step that re-opens the typecad.net → cuttlefish interop. After it
+ * runs, the existing `export * from './board.js'` in cuttlefish-env.d.ts
+ * resolves to a board exposing only the pins the actual PCB has wired.
+ *
+ * @throws on a missing/unreadable/unparseable contract, an unsupported version,
+ *   or if the MCU package can't be loaded for its manifest.
+ */
+export async function generateContractBoard(config) {
+    if (!config.contract) {
+        throw new Error('generateContractBoard called without config.contract');
+    }
+    if (!config.mcu) {
+        throw new Error(`A 'contract' config requires an 'mcu' package to narrow against. ` +
+            `Add e.g. mcu: '@typecad/mcu-atmega328p' to cuttlefish.config.ts.`);
+    }
+    const projectDir = path.dirname(config.configPath);
+    const contractPath = path.isAbsolute(config.contract)
+        ? config.contract
+        : path.resolve(projectDir, config.contract);
+    // (1) Parse the contract.
+    const contract = parseContractFile(contractPath);
+    // (2) Load the MCU manifest. The MCU package is a peer at runtime — import
+    // it dynamically so cuttlefish doesn't hard-depend on any single MCU.
+    let manifest;
+    try {
+        const mod = (await import(config.mcu));
+        if (!mod.TypeCADManifest) {
+            throw new Error(`'${config.mcu}' does not export a TypeCADManifest.`);
+        }
+        manifest = mod.TypeCADManifest;
+    }
+    catch (err) {
+        throw new Error(`Could not load TypeCADManifest from MCU package '${config.mcu}' for contract-based ` +
+            `board generation: ${err.message}`);
+    }
+    // (3) Match + select.
+    const connectedPins = matchConnectedPins(contract, manifest.pinNames);
+    const peripherals = selectPeripherals(contract, manifest.peripheralNames);
+    // (4) Emit the narrowed board.
+    return generateBoardFile({
+        projectDir,
+        mcuPackage: config.mcu,
+        connectedPins,
+        peripherals,
+    });
+}

package/dist/create/board-codegen.js

@@ -53,8 +53,8 @@ function insertAfter(filePath, marker, insertion, searchForId) {
 export function scaffoldBoardPackages(spec, opts = {}) {
     const arch = spec.architecture;
     const rootDir = opts.rootDir ? path.resolve(opts.rootDir) : findMonorepoRoot(process.cwd());
-    const mcuDir = path.join(rootDir, 'packages', `mcu-${arch}`);
-    const boardDir = path.join(rootDir, 'packages', `board-${arch}`);
+    const mcuDir = path.join(rootDir, 'mcus', `mcu-${arch}`);
+    const boardDir = path.join(rootDir, 'boards', `board-${arch}`);
     // Overwrite protection
     const mcuExists = fs.existsSync(mcuDir);
     const boardExists = fs.existsSync(boardDir);
@@ -93,8 +93,8 @@ export function scaffoldBoardPackages(spec, opts = {}) {
     if (fs.existsSync(rootPjPath)) {
         try {
             const rootPj = JSON.parse(fs.readFileSync(rootPjPath, 'utf8'));
-            if (Array.isArray(rootPj.workspaces) && !rootPj.workspaces.includes(`packages/mcu-${arch}`)) {
-                rootPj.workspaces.push(`packages/mcu-${arch}`, `packages/board-${arch}`);
+            if (Array.isArray(rootPj.workspaces) && !rootPj.workspaces.includes(`mcus/mcu-${arch}`)) {
+                rootPj.workspaces.push(`mcus/mcu-${arch}`, `boards/board-${arch}`);
                 fs.writeFileSync(rootPjPath, JSON.stringify(rootPj, null, 2) + '\n', 'utf8');
             }
         }

package/dist/create/board-generators.js

@@ -3,8 +3,8 @@
 // tool. Each function takes a BoardSpec and returns the file content as a
 // string. No filesystem I/O — the orchestrator (board-codegen.ts) writes files.
 //
-// Golden reference: the hand-written packages/mcu-esp32c6/ and
-// packages/board-esp32c6/ packages. These generators reproduce them from a
+// Golden reference: the hand-written mcus/mcu-esp32c6/ and
+// boards/board-esp32c6/ packages. These generators reproduce them from a
 // C6 spec.
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
@@ -71,7 +71,7 @@ export function genMcuTsconfig(_spec) {
             experimentalDecorators: true, emitDecoratorMetadata: true,
         },
         include: ['src/**/*.ts'],
-        references: [{ path: '../hal' }, { path: '../cuttlefish' }],
+        references: [{ path: '../../packages/hal' }, { path: '../../packages/cuttlefish' }],
     }, null, 2) + '\n';
 }
 export function genMcuPins(spec) {
@@ -408,7 +408,7 @@ export function genBoardTsconfig(spec) {
         },
         include: ['src/**/*.ts'],
         references: [
-            { path: '../hal' }, { path: '../cuttlefish' }, { path: `../mcu-${spec.architecture}` },
+            { path: '../../packages/hal' }, { path: '../../packages/cuttlefish' }, { path: `../../mcus/mcu-${spec.architecture}` },
         ],
     }, null, 2) + '\n';
 }
@@ -535,7 +535,6 @@ export function genBoardIndex(spec) {
     // Build config
     lines.push(`  build: {`);
     lines.push(`    frameworks: {`);
-    lines.push(`      platformio: '${spec.platformioTarget}',`);
     lines.push(`      arduino: '${spec.fqbn}',`);
     lines.push(`    },`);
     lines.push(`    defines: {`);