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

package/dist/install/handle-install.js

@@ -1,177 +0,0 @@
-// `cuttlefish install` — installs a chosen @typecad/framework-* package into the
-// current project. The flow asks which board to target first, then narrows the
-// framework choices to those compatible with that board (see framework-catalog).
-// A framework id may be passed directly (`cuttlefish install arduino`) to skip
-// the prompts entirely, which also makes the command usable in CI.
-import * as readline from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
-import { spawnSync } from "node:child_process";
-import chalk from "chalk";
-import { KNOWN_TARGETS } from "../create/index.js";
-import { FRAMEWORK_CATALOG, frameworkCatalogEntry, frameworksForTarget, detectPackageManager, buildInstallCommand, } from "./framework-catalog.js";
-// ── prompts (mirror the create wizard's style for a consistent UX) ──────────
-async function promptSelect(rl, prompt, options) {
-    console.log(`${chalk.cyan("?")} ${prompt}:`);
-    for (let i = 0; i < options.length; i++) {
-        console.log(`  ${chalk.dim(`${i + 1})`)} ${options[i].label}`);
-    }
-    while (true) {
-        const answer = await rl.question(`  Enter number (1-${options.length}): `);
-        const idx = parseInt(answer.trim(), 10) - 1;
-        if (idx >= 0 && idx < options.length) {
-            return options[idx].value;
-        }
-        console.log(`  ${chalk.red("✗")} Please enter a number between 1 and ${options.length}.`);
-    }
-}
-async function selectBoardInteractively(rl) {
-    const options = KNOWN_TARGETS.map((t) => ({
-        label: t.isNative
-            ? `${t.displayName} (Windows/Linux executable)`
-            : `${t.displayName} (${t.architecture.toUpperCase()})`,
-        value: t.id,
-    }));
-    const selectedId = await promptSelect(rl, "Target board", options);
-    return KNOWN_TARGETS.find((t) => t.id === selectedId);
-}
-/**
- * Pick a framework for `target`. When only one framework is compatible with the
- * board it is auto-selected (mirrors the create wizard's single-option path) so
- * the user isn't asked a question with one answer.
- */
-async function selectFrameworkInteractively(rl, target, compatible) {
-    if (compatible.length === 1) {
-        const only = compatible[0];
-        console.log(`${chalk.cyan("?")} Framework: ${chalk.white(only.label)} ${chalk.dim(`(only option for ${target.id})`)}`);
-        return only;
-    }
-    const selectedId = await promptSelect(rl, "Framework", compatible.map((f) => ({ label: f.label, value: f.id })));
-    return compatible.find((f) => f.id === selectedId);
-}
-let testRunner;
-/**
- * FOR TESTS ONLY. Replaces the real spawn-based installer with `runner`.
- * Pass `undefined` to restore the real executor.
- */
-export function __setInstallRunnerForTest(runner) {
-    testRunner = runner;
-}
-function runRealInstall(cmd) {
-    // stdio: "inherit" streams the package manager's own output to the terminal
-    // (install progress, deprecation warnings, etc.). On failure the user has
-    // already seen the details above, so we only need to report the exit code.
-    const result = spawnSync(cmd.bin, cmd.args, {
-        cwd: cmd.cwd,
-        stdio: "inherit",
-    });
-    if (result.error) {
-        const errno = result.error.code;
-        return {
-            status: null,
-            launchError: errno === "ENOENT" ? `'${cmd.bin}' not found on PATH` : String(result.error),
-        };
-    }
-    return { status: result.status };
-}
-/**
- * Resolve the package manager and run the install for `entry`'s package. In
- * dry-run mode the command is printed but not executed. Throws on launch
- * failure or non-zero exit so the CLI surfaces a clear error.
- */
-export function installFrameworkPackage(entry, opts) {
-    const pm = detectPackageManager(opts.cwd);
-    const { bin, args } = buildInstallCommand(pm, entry.packageName);
-    if (opts.dryRun) {
-        console.log(`${chalk.cyan("$")} ${bin} ${args.join(" ")}`);
-        return { pm, bin, args };
-    }
-    const cmd = { bin, args, cwd: opts.cwd };
-    const run = testRunner ?? runRealInstall;
-    const result = run(cmd);
-    if (result.launchError) {
-        throw new Error(`Failed to run '${bin}': ${result.launchError}`);
-    }
-    if (result.status !== 0) {
-        throw new Error(`'${bin} ${args.join(" ")}' exited with code ${result.status}. See the package manager output above for details.`);
-    }
-    return { pm, bin, args };
-}
-// ── command entry point ─────────────────────────────────────────────────────
-export async function handleInstall(options) {
-    const cwd = process.cwd();
-    // 1. Resolve which framework to install.
-    let entry;
-    if (options.framework) {
-        const resolved = frameworkCatalogEntry(options.framework);
-        if (!resolved) {
-            const available = FRAMEWORK_CATALOG.filter((f) => f.installable).map((f) => f.id).join(", ");
-            throw new Error(`Unknown framework '${options.framework}'. Available: ${available}`);
-        }
-        if (!resolved.installable) {
-            throw new Error(`Framework '${options.framework}' has no published package yet and cannot be installed.`);
-        }
-        entry = resolved;
-        console.log(`${chalk.cyan("?")} Framework: ${chalk.white(entry.label)}`);
-    }
-    else {
-        // Resolve the target board. --board skips the board prompt; otherwise the
-        // board is chosen interactively (which requires a TTY — handled below).
-        let target;
-        if (options.board) {
-            const found = KNOWN_TARGETS.find((t) => t.id === options.board);
-            if (!found) {
-                const available = KNOWN_TARGETS.map((t) => t.id).join(", ");
-                throw new Error(`Unknown board '${options.board}'. Available: ${available}`);
-            }
-            target = found;
-            console.log(`${chalk.cyan("?")} Board: ${chalk.white(target.displayName)} (${chalk.dim(target.id)})`);
-        }
-        // Narrow to the frameworks compatible with that board.
-        let compatible;
-        if (target) {
-            compatible = frameworksForTarget(target).filter((f) => f.installable);
-            if (compatible.length === 0) {
-                throw new Error(`No installable frameworks are compatible with board '${target.id}'.`);
-            }
-        }
-        if (compatible && compatible.length === 1) {
-            // Only one framework fits this board — auto-select it (no prompt, so this
-            // path also works under CI / non-interactive stdin).
-            entry = compatible[0];
-            console.log(`${chalk.cyan("?")} Framework: ${chalk.white(entry.label)} ${chalk.dim(`(only option for ${target.id})`)}`);
-        }
-        else {
-            // Need to prompt — for the board (if --board wasn't given) and/or for the
-            // framework (when 2+ are compatible). Refuse to hang on a readline that
-            // can't be answered (e.g. piped stdin under CI).
-            if (!process.stdin.isTTY) {
-                throw new Error("No framework specified and stdin is not interactive. " +
-                    "Pass a framework id (e.g. 'cuttlefish install arduino'), " +
-                    "or a board with a single compatible framework (e.g. '--board arduino-uno').");
-            }
-            const rl = readline.createInterface({ input, output });
-            try {
-                if (!target) {
-                    target = await selectBoardInteractively(rl);
-                    compatible = frameworksForTarget(target).filter((f) => f.installable);
-                    if (compatible.length === 0) {
-                        throw new Error(`No installable frameworks are compatible with board '${target.id}'.`);
-                    }
-                }
-                entry = await selectFrameworkInteractively(rl, target, compatible);
-            }
-            finally {
-                rl.close();
-            }
-        }
-    }
-    // 2. Install it.
-    console.log(`\n${chalk.cyan("⤳")} Installing ${chalk.white(entry.packageName)} into ${chalk.dim(cwd)}…`);
-    const result = installFrameworkPackage(entry, { cwd, dryRun: options.dryRun });
-    if (options.dryRun) {
-        console.log(chalk.dim("(dry-run — nothing was installed)"));
-        return;
-    }
-    console.log(`\n${chalk.green("✓")} Installed ${chalk.white(entry.packageName)} via ${result.pm}.`);
-    console.log(chalk.dim(`Next: run 'cuttlefish create' and pick ${entry.id}, or set framework: "${entry.packageName}" in cuttlefish.config.ts.`));
-}

package/dist/install/index.d.ts

@@ -1,4 +0,0 @@
-export { handleInstall, installFrameworkPackage, __setInstallRunnerForTest } from "./handle-install.js";
-export type { InstallResult } from "./handle-install.js";
-export { FRAMEWORK_CATALOG, frameworkCatalogEntry, frameworksForTarget, detectPackageManager, buildInstallCommand, } from "./framework-catalog.js";
-export type { FrameworkCatalogEntry, BoardLike, PackageManager, } from "./framework-catalog.js";

package/dist/install/index.js

@@ -1,3 +0,0 @@
-// `cuttlefish install` command — install a @typecad/framework-* package.
-export { handleInstall, installFrameworkPackage, __setInstallRunnerForTest } from "./handle-install.js";
-export { FRAMEWORK_CATALOG, frameworkCatalogEntry, frameworksForTarget, detectPackageManager, buildInstallCommand, } from "./framework-catalog.js";

package/dist/ir/pin-state-tracking.d.ts

@@ -1,58 +0,0 @@
-import type { ProgramIR } from "../api/index.js";
-export type TrackedPinLevel = 'high' | 'low' | 'unknown';
-/** C++ identifier for a pin's shadow state variable. */
-export declare function pinShadowVarName(pin: number): string;
-export declare function resetPinStateTracking(): void;
-/** Record gpio.set_mode — OUTPUT* modes enable tracking, anything else ends it. */
-export declare function notePinSetMode(pin: number, mode: string | null): void;
-/** Record gpio.write — literal values set the level; expressions make it unknown. */
-export declare function notePinWrite(pin: number, literalValue: number | boolean | null): void;
-/** Record gpio.toggle — inverts a known level, keeps unknown as unknown. */
-export declare function notePinToggle(pin: number): void;
-/**
- * Record PWM/tone output — the pin no longer has a digital level, so any
- * tracked level goes unknown (reads must not fold to the pre-PWM literal).
- * A later digital write/toggle restores digital tracking.
- */
-export declare function notePinAnalogOutput(pin: number): void;
-/**
- * Resolve a read on a pin at the current program point.
- * Returns 'high'/'low' when the level folds to a constant, 'shadow' when a
- * shadow variable must carry it, or null when the pin is not a tracked
- * output pin (unconfigured or input mode → normal hardware read lowering).
- */
-export declare function resolveTrackedRead(pin: number): 'high' | 'low' | 'shadow' | null;
-/** Whether write/toggle ops on this pin must also update its shadow variable. */
-export declare function isShadowPin(pin: number): boolean;
-/** Consume the shadow declarations owed by this build (pin + initializer).
- *  Clears the shadow set: emit reads the updatesShadow flags baked into the
- *  ops below, never this module's live state (each file's build resets the
- *  tracker, and all files finish building before any emit runs). */
-export declare function takeShadowDeclarations(): {
-    pin: number;
-    initial: boolean;
-}[];
-/** Mark every gpio.write / gpio.toggle op in the program whose pin has a
- *  tracked shadow read, so the emitter appends the shadow-variable update.
- *  Runs once at the end of buildProgramIR, after the whole file is lowered —
- *  at that point the shadow set is final, so writes that were lowered BEFORE
- *  the first shadow read are marked too (their ops are already in the IR).
- *  This is what makes emit independent of tracker state across files. */
-export declare function markShadowUpdatingOps(program: ProgramIR): void;
-export type PinLevelSnapshot = Map<number, TrackedPinLevel>;
-export declare function snapshotPinLevels(): PinLevelSnapshot;
-export declare function restorePinLevels(snapshot: PinLevelSnapshot): void;
-/**
- * Merge two branch-end states into the live state: pins that agree keep
- * their level; pins that differ (or exist in only one branch) become
- * unknown. Pass the pre-branch state as one side when there is no else
- * branch, so pins written in the taken branch invalidate.
- */
-export declare function mergePinLevels(a: PinLevelSnapshot, b: PinLevelSnapshot): void;
-/** Invalidate all known levels (after loop/switch bodies, which may run any
- *  number of times). Shadow tracking is unaffected — it is runtime truth. */
-export declare function invalidatePinLevels(): void;
-/** Disable/enable constant folding around function and callback bodies. */
-export declare function setPinFoldingEnabled(enabled: boolean): void;
-/** Whether pin-level constant folding is currently allowed. */
-export declare function isPinFoldingEnabled(): boolean;

package/dist/ir/pin-state-tracking.js

@@ -1,182 +0,0 @@
-// ---------------------------------------------------------------------------
-// Output Pin State Tracking
-//
-// Tracks the driven level of pins configured as OUTPUT so that
-// OutputPin.read()/isHigh()/isLow() can be answered without a hardware pin
-// read. Reading back an OUTPUT-only pin is not portable (Zephyr's
-// gpio_pin_get reads the input latch, which is undefined for direction-only
-// outputs), so the transpiler instead maintains the state itself:
-//
-// - When the level is statically known at the read site (asOutput(false)
-//   followed by literal high/low/write/toggle calls), the read folds to a
-//   compile-time constant.
-// - When it is not (runtime-valued writes, loops, branches, function
-//   bodies), the read lowers to a shadow variable (`__tc_pin_state_<n>`)
-//   that every generated write/toggle on that pin keeps updated.
-//
-// The tracker is updated in program order during IR lowering (the same pass
-// that resolves HAL method bodies), so the state seen at each read site is
-// the state at that point in the source. Control-flow joins and loop bodies
-// conservatively invalidate levels (see control-flow.ts hooks); function and
-// callback bodies disable folding entirely and force the shadow form.
-// ---------------------------------------------------------------------------
-import { walkProgramIR, walkExpressions } from "./utils/walk-ir.js";
-/** Pin numbers explicitly configured as OUTPUT via gpio.set_mode. */
-const outputPins = new Set();
-/** Last driven level per output pin, at the current program point. */
-const pinLevels = new Map();
-/** Output pins whose reads lowered to the shadow variable form. */
-const shadowPins = new Set();
-/** Initializer for each shadow variable: the statically-known level at the
- *  time the first shadow read was resolved, or `false` when unknown. */
-const shadowInitial = new Map();
-/** Folding is disabled inside function/callback bodies, where the top-level
- *  program-point state does not apply at runtime. */
-let foldingEnabled = true;
-/** C++ identifier for a pin's shadow state variable. */
-export function pinShadowVarName(pin) {
-    return `__tc_pin_state_${pin}`;
-}
-export function resetPinStateTracking() {
-    outputPins.clear();
-    pinLevels.clear();
-    shadowPins.clear();
-    shadowInitial.clear();
-    foldingEnabled = true;
-}
-/** Record gpio.set_mode — OUTPUT* modes enable tracking, anything else ends it. */
-export function notePinSetMode(pin, mode) {
-    const isOutput = mode !== null && /output/i.test(mode);
-    if (isOutput) {
-        outputPins.add(pin);
-        pinLevels.set(pin, 'unknown');
-    }
-    else {
-        outputPins.delete(pin);
-        pinLevels.delete(pin);
-    }
-}
-/** Record gpio.write — literal values set the level; expressions make it unknown. */
-export function notePinWrite(pin, literalValue) {
-    if (!outputPins.has(pin))
-        return;
-    pinLevels.set(pin, literalValue === null ? 'unknown' : (literalValue ? 'high' : 'low'));
-}
-/** Record gpio.toggle — inverts a known level, keeps unknown as unknown. */
-export function notePinToggle(pin) {
-    if (!outputPins.has(pin))
-        return;
-    const level = pinLevels.get(pin);
-    if (level === 'high')
-        pinLevels.set(pin, 'low');
-    else if (level === 'low')
-        pinLevels.set(pin, 'high');
-    else
-        pinLevels.set(pin, 'unknown');
-}
-/**
- * Record PWM/tone output — the pin no longer has a digital level, so any
- * tracked level goes unknown (reads must not fold to the pre-PWM literal).
- * A later digital write/toggle restores digital tracking.
- */
-export function notePinAnalogOutput(pin) {
-    if (!outputPins.has(pin))
-        return;
-    pinLevels.set(pin, 'unknown');
-}
-/**
- * Resolve a read on a pin at the current program point.
- * Returns 'high'/'low' when the level folds to a constant, 'shadow' when a
- * shadow variable must carry it, or null when the pin is not a tracked
- * output pin (unconfigured or input mode → normal hardware read lowering).
- */
-export function resolveTrackedRead(pin) {
-    if (!outputPins.has(pin))
-        return null;
-    const level = pinLevels.get(pin);
-    if (foldingEnabled && (level === 'high' || level === 'low'))
-        return level;
-    shadowPins.add(pin);
-    if (!shadowInitial.has(pin))
-        shadowInitial.set(pin, level === 'high');
-    return 'shadow';
-}
-/** Whether write/toggle ops on this pin must also update its shadow variable. */
-export function isShadowPin(pin) {
-    return shadowPins.has(pin);
-}
-/** Consume the shadow declarations owed by this build (pin + initializer).
- *  Clears the shadow set: emit reads the updatesShadow flags baked into the
- *  ops below, never this module's live state (each file's build resets the
- *  tracker, and all files finish building before any emit runs). */
-export function takeShadowDeclarations() {
-    const decls = [...shadowPins].sort((a, b) => a - b).map(pin => ({
-        pin,
-        initial: shadowInitial.get(pin) ?? false,
-    }));
-    shadowPins.clear();
-    shadowInitial.clear();
-    return decls;
-}
-/** Mark every gpio.write / gpio.toggle op in the program whose pin has a
- *  tracked shadow read, so the emitter appends the shadow-variable update.
- *  Runs once at the end of buildProgramIR, after the whole file is lowered —
- *  at that point the shadow set is final, so writes that were lowered BEFORE
- *  the first shadow read are marked too (their ops are already in the IR).
- *  This is what makes emit independent of tracker state across files. */
-export function markShadowUpdatingOps(program) {
-    if (shadowPins.size === 0)
-        return;
-    const markOp = (op) => {
-        const halOp = op;
-        if (!halOp)
-            return;
-        if ((halOp.operation === "gpio.write" || halOp.operation === "gpio.toggle") && isShadowPin(halOp.pin)) {
-            halOp.updatesShadow = true;
-        }
-    };
-    walkProgramIR(program, (stmt) => {
-        if (stmt.kind === "hal-op")
-            markOp(stmt.operation);
-        walkExpressions([stmt], (expr) => {
-            if (expr.kind === "hal-expr")
-                markOp(expr.operation);
-        });
-    });
-}
-export function snapshotPinLevels() {
-    return new Map(pinLevels);
-}
-export function restorePinLevels(snapshot) {
-    pinLevels.clear();
-    for (const [pin, level] of snapshot)
-        pinLevels.set(pin, level);
-}
-/**
- * Merge two branch-end states into the live state: pins that agree keep
- * their level; pins that differ (or exist in only one branch) become
- * unknown. Pass the pre-branch state as one side when there is no else
- * branch, so pins written in the taken branch invalidate.
- */
-export function mergePinLevels(a, b) {
-    const pins = new Set([...a.keys(), ...b.keys()]);
-    for (const pin of pins) {
-        const la = a.get(pin) ?? 'unknown';
-        const lb = b.get(pin) ?? 'unknown';
-        pinLevels.set(pin, la === lb ? la : 'unknown');
-    }
-}
-/** Invalidate all known levels (after loop/switch bodies, which may run any
- *  number of times). Shadow tracking is unaffected — it is runtime truth. */
-export function invalidatePinLevels() {
-    for (const pin of outputPins)
-        pinLevels.set(pin, 'unknown');
-}
-/** Disable/enable constant folding around function and callback bodies. */
-export function setPinFoldingEnabled(enabled) {
-    foldingEnabled = enabled;
-}
-/** Whether pin-level constant folding is currently allowed. */
-export function isPinFoldingEnabled() {
-    return foldingEnabled;
-}

package/dist/ir/pwm-timer-sharing.d.ts

@@ -1,4 +0,0 @@
-import type { Diagnostic } from '../types.js';
-import type { BoardConstants } from './board-resolver.js';
-import type { PeripheralUsage } from './peripheral-usage.js';
-export declare function validatePWMTimerSharing(usage: PeripheralUsage, boardConstants: BoardConstants | undefined, filePath: string): Diagnostic[];

package/dist/ir/pwm-timer-sharing.js

@@ -1,94 +0,0 @@
-import { findBoardPinByName, formatPinReference } from './board-pin-utils.js';
-function extractTimerId(role, timerField) {
-    // Prefer explicit timer field from board definition
-    if (timerField) {
-        return timerField;
-    }
-    if (!role) {
-        return undefined;
-    }
-    // Fall back to parsing AVR OC register naming convention
-    const match = role.match(/^OC(\d+)[A-Z]?$/i);
-    return match ? `timer${match[1]}` : undefined;
-}
-function getPwmTimerPins(boardConstants) {
-    if (!boardConstants) {
-        return [];
-    }
-    const pinsByIndex = new Map();
-    for (const [key, value] of boardConstants) {
-        const nameMatch = key.match(/^pins\.all\.(\d+)\.name$/);
-        if (nameMatch && typeof value === 'string') {
-            const pinIndex = nameMatch[1];
-            const numberValue = boardConstants.get(`pins.all.${pinIndex}.number`);
-            const aliasesValue = boardConstants.get(`pins.all.${pinIndex}.aliases`);
-            const aliases = typeof aliasesValue === 'string' && aliasesValue.length > 0
-                ? aliasesValue.split(',').map(entry => entry.trim()).filter(Boolean)
-                : [];
-            pinsByIndex.set(pinIndex, {
-                pinNumber: typeof numberValue === 'number' ? numberValue : Number(pinIndex),
-                canonicalName: value,
-                aliases,
-                timerId: '',
-            });
-        }
-    }
-    for (const [key, value] of boardConstants) {
-        const typeMatch = key.match(/^pins\.all\.(\d+)\.functions\.\d+\.type$/);
-        if (!typeMatch || value !== 'pwm') {
-            continue;
-        }
-        const pinIndex = typeMatch[1];
-        const roleKey = key.replace(/\.type$/, '.role');
-        const timerKey = key.replace(/\.type$/, '.timer');
-        const timerId = extractTimerId(boardConstants.get(roleKey), boardConstants.get(timerKey));
-        if (!timerId) {
-            continue;
-        }
-        const pin = pinsByIndex.get(pinIndex);
-        if (pin) {
-            pin.timerId = timerId;
-        }
-    }
-    return Array.from(pinsByIndex.values()).filter(pin => pin.timerId.length > 0);
-}
-export function validatePWMTimerSharing(usage, boardConstants, filePath) {
-    if (usage.pwmPinsUsed.size < 2 || !boardConstants) {
-        return [];
-    }
-    const boardName = boardConstants.get('name');
-    const boardLabel = typeof boardName === 'string' && boardName.length > 0
-        ? ` on ${boardName}`
-        : '';
-    const pins = getPwmTimerPins(boardConstants);
-    const pinsByTimer = new Map();
-    for (const pin of pins) {
-        if (!usage.pwmPinsUsed.has(pin.pinNumber)) {
-            continue;
-        }
-        const group = pinsByTimer.get(pin.timerId) ?? [];
-        group.push(pin);
-        pinsByTimer.set(pin.timerId, group);
-    }
-    const diagnostics = [];
-    for (const [timerId, timerPins] of pinsByTimer) {
-        if (timerPins.length < 2) {
-            continue;
-        }
-        const references = timerPins
-            .sort((left, right) => left.pinNumber - right.pinNumber)
-            .map((pin) => {
-            const usedNames = [pin.canonicalName, ...pin.aliases].filter(name => usage.pinsUsed.has(name));
-            const preferredName = usedNames[0] ?? pin.canonicalName;
-            return formatPinReference(preferredName, findBoardPinByName(pin.canonicalName, boardConstants));
-        });
-        diagnostics.push({
-            severity: 'info',
-            code: 'pwm-timer-sharing',
-            filePath,
-            source: 'pwm-timer-sharing',
-            message: `${references.join(', ')} share ${timerId}${boardLabel}. Duty cycle can differ per pin, but timer-wide PWM settings are shared across that group. Prefer pins on different timer groups if you need independent PWM timing behavior.`,
-        });
-    }
-    return diagnostics;
-}

package/dist/ir/timer0-pwm-timing-conflict.d.ts

@@ -1,4 +0,0 @@
-import type { Diagnostic } from '../types.js';
-import type { BoardConstants } from './board-resolver.js';
-import type { PeripheralUsage } from './peripheral-usage.js';
-export declare function validateTimer0PWMTimingConflict(usage: PeripheralUsage, boardConstants: BoardConstants | undefined, filePath: string): Diagnostic[];

package/dist/ir/timer0-pwm-timing-conflict.js

@@ -1,72 +0,0 @@
-import { findBoardPinByName, formatPinReference } from './board-pin-utils.js';
-function getTimer0PwmPins(boardConstants) {
-    if (!boardConstants) {
-        return [];
-    }
-    const pinsByIndex = new Map();
-    for (const [key, value] of boardConstants) {
-        const match = key.match(/^pins\.all\.(\d+)\.name$/);
-        if (!match || typeof value !== 'string') {
-            continue;
-        }
-        const pinIndex = match[1];
-        const numberValue = boardConstants.get(`pins.all.${pinIndex}.number`);
-        const aliasesValue = boardConstants.get(`pins.all.${pinIndex}.aliases`);
-        const aliases = typeof aliasesValue === 'string' && aliasesValue.length > 0
-            ? aliasesValue.split(',').map(entry => entry.trim()).filter(Boolean)
-            : [];
-        pinsByIndex.set(pinIndex, {
-            pinNumber: typeof numberValue === 'number' ? numberValue : Number(pinIndex),
-            canonicalName: value,
-            aliases,
-        });
-    }
-    const timer0Pins = [];
-    for (const [key, value] of boardConstants) {
-        // Check for timer field first, fall back to OC register regex
-        const timerMatch = key.match(/^pins\.all\.(\d+)\.functions\.(\d+)\.timer$/);
-        if (timerMatch && value === 'timer0') {
-            const pin = pinsByIndex.get(timerMatch[1]);
-            if (pin) {
-                timer0Pins.push(pin);
-            }
-            continue;
-        }
-        const match = key.match(/^pins\.all\.(\d+)\.functions\.\d+\.role$/);
-        if (!match || typeof value !== 'string' || !/^OC0[A-Z]?$/i.test(value)) {
-            continue;
-        }
-        const pin = pinsByIndex.get(match[1]);
-        if (pin && !timer0Pins.some(p => p.pinNumber === pin.pinNumber)) {
-            timer0Pins.push(pin);
-        }
-    }
-    return timer0Pins;
-}
-export function validateTimer0PWMTimingConflict(usage, boardConstants, filePath) {
-    if (!usage.timer0 || usage.pwmPinsUsed.size === 0) {
-        return [];
-    }
-    const timer0Pins = getTimer0PwmPins(boardConstants)
-        .filter(pin => usage.pwmPinsUsed.has(pin.pinNumber));
-    if (timer0Pins.length === 0) {
-        return [];
-    }
-    const boardName = boardConstants?.get('name');
-    const boardLabel = typeof boardName === 'string' && boardName.length > 0
-        ? ` on ${boardName}`
-        : '';
-    const pinReferences = timer0Pins
-        .sort((left, right) => left.pinNumber - right.pinNumber)
-        .map((pin) => {
-        const usedName = [pin.canonicalName, ...pin.aliases].find(name => usage.pinsUsed.has(name)) ?? pin.canonicalName;
-        return formatPinReference(usedName, findBoardPinByName(pin.canonicalName, boardConstants));
-    });
-    return [{
-            severity: 'info',
-            code: 'timer0-pwm-timing-conflict',
-            filePath,
-            source: 'timer0-pwm-timing-conflict',
-            message: `${pinReferences.join(', ')} use Timer0 PWM${boardLabel}, and your program also relies on Timer0-backed timing APIs such as delay(), millis(), or micros(). This coupling is common on AVR boards, so prefer non-Timer0 PWM pins when you want PWM behavior isolated from core timing.`,
-        }];
-}

package/dist/libdef/component-decls.d.ts

@@ -1,2 +0,0 @@
-export { generateComponentDeclsForProject } from "./cpp-to-decl.js";
-export type { ComponentScanRoots } from "./component-discovery.js";

package/dist/libdef/component-decls.js

@@ -1,6 +0,0 @@
-// Public barrel for component declaration generation.
-//
-// framework-esp32 imports `generateComponentDeclsForProject` from here so its
-// dependency on cuttlefish is declared through the package exports map rather
-// than a deep relative path. Spec: 2026-07-19-framework-esp32-components-design.md
-export { generateComponentDeclsForProject } from "./cpp-to-decl.js";

package/dist/libdef/component-discovery.d.ts

@@ -1,43 +0,0 @@
-export interface ComponentScanRoots {
-    /** Subdirectory names under managed_components/ (e.g. espressif__esp_wifi). */
-    managed: string[];
-    /** Absolute paths to local component directories. */
-    local: string[];
-    /**
-     * ESP-IDF built-in component names (e.g. esp_wifi). Resolved against
-     * `idfRoot/components/<name>/include/` when idfRoot is provided; ignored
-     * otherwise (the caller is responsible for passing idfRoot when builtins
-     * are present).
-     */
-    builtin: string[];
-    /** Optional ESP-IDF install root for resolving `builtin` names. */
-    idfRoot?: string;
-}
-/**
- * A discovered header plus the directory its generated .d.ts should land in.
- *
- * `outputDir` is alongside the header for managed/local components (so the
- * .d.ts lives in the same gitignored component dir, regenerated on each run).
- * For built-in components it's a project-local cache — NEVER write into the
- * IDF install itself.
- */
-export interface DiscoveredHeader {
-    /** Absolute path to the source .h file. */
-    path: string;
-    /** Absolute directory where the generated .d.ts should be written. */
-    outputDir: string;
-}
-/**
- * Find all .h files for the declared components.
- *
- * - managed: scan `managed_components/<name>/include/` (falling back to the
- *   component dir if no include/ exists). Populated by `idf.py reconfigure`.
- * - local: scan `<path>/include/` (or `<path>/`).
- * - builtin: scan `<idfRoot>/components/<name>/include/` (IDF ships with these).
- *
- * For builtins the output .d.ts goes to `<projectDir>/.cuttlefish/component-decls/<component>/`
- * — never into `$IDF_PATH/components/`, which would pollute the IDF install.
- *
- * Returned entries are unsorted — the caller decides ordering.
- */
-export declare function discoverComponentHeaders(projectDir: string, roots: ComponentScanRoots): DiscoveredHeader[];