@typecad/ui 1.0.0-alpha.11 → 1.0.0-alpha.13

package/dist/wizard/config-writer.js

@@ -0,0 +1,366 @@
+// ---------------------------------------------------------------------------
+// cuttlefish.config.ts reader/writer for the @typecad/ui integration wizard.
+//
+// The build's config loader (packages/cuttlefish/src/config-loader.ts) is
+// AST-based and deliberately never evaluates user code — only inline literals
+// survive extraction. The writer here plays by the same rules: the wizard
+// emits plain object literals and splices them into the config's default
+// export object via the TypeScript AST, so every other section (and its
+// comments) survives an update byte-for-byte.
+// ---------------------------------------------------------------------------
+import fs from "node:fs";
+import path from "node:path";
+import ts from "typescript";
+const CONFIG_FILENAME = "cuttlefish.config.ts";
+/** Walk up from `startDir` looking for cuttlefish.config.ts. */
+export function findCuttlefishConfig(startDir) {
+    let dir = path.resolve(startDir);
+    for (;;) {
+        const candidate = path.join(dir, CONFIG_FILENAME);
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+            return candidate;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+// ---------------------------------------------------------------------------
+// AST helpers (kept aligned with the config loader's extraction rules)
+// ---------------------------------------------------------------------------
+function unwrapTypeCast(node) {
+    let curr = node;
+    for (;;) {
+        if (ts.isAsExpression(curr) || ts.isTypeAssertionExpression(curr) || ts.isParenthesizedExpression(curr)) {
+            curr = curr.expression;
+            continue;
+        }
+        const isSatisfies = ts.isSatisfiesExpression;
+        if (typeof isSatisfies === "function" && isSatisfies(curr)) {
+            curr = curr.expression;
+            continue;
+        }
+        return curr;
+    }
+}
+function propertyKeyName(prop) {
+    const name = prop.name;
+    if (!name)
+        return undefined;
+    return ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : undefined;
+}
+function getScalarValue(node) {
+    const unwrapped = unwrapTypeCast(node);
+    if (ts.isStringLiteral(unwrapped) || ts.isNoSubstitutionTemplateLiteral(unwrapped)) {
+        return unwrapped.text;
+    }
+    if (ts.isNumericLiteral(unwrapped)) {
+        return Number(unwrapped.text);
+    }
+    if (ts.isPrefixUnaryExpression(unwrapped)
+        && (unwrapped.operator === ts.SyntaxKind.MinusToken || unwrapped.operator === ts.SyntaxKind.PlusToken)
+        && ts.isNumericLiteral(unwrapped.operand)) {
+        const magnitude = Number(unwrapped.operand.text);
+        return unwrapped.operator === ts.SyntaxKind.MinusToken ? -magnitude : magnitude;
+    }
+    if (unwrapped.kind === ts.SyntaxKind.TrueKeyword)
+        return true;
+    if (unwrapped.kind === ts.SyntaxKind.FalseKeyword)
+        return false;
+    return undefined;
+}
+function getStringLiteral(node) {
+    const unwrapped = unwrapTypeCast(node);
+    if (ts.isStringLiteral(unwrapped) || ts.isNoSubstitutionTemplateLiteral(unwrapped)) {
+        return unwrapped.text;
+    }
+    return undefined;
+}
+/**
+ * Find the config's default-export object literal. Accepts the same shapes as
+ * the build's loader:
+ *   1. `export default { ... }`
+ *   2. `const config: CuttlefishConfig = { ... }; export default config;`
+ * with `as` / `satisfies` / parenthesized wrappers unwrapped.
+ */
+function findConfigObjectLiteral(sourceFile) {
+    const variableDecls = new Map();
+    let defaultExportName;
+    let inlineDefaultObject;
+    for (const stmt of sourceFile.statements) {
+        if (ts.isVariableStatement(stmt)) {
+            for (const decl of stmt.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name)) {
+                    variableDecls.set(decl.name.text, decl);
+                }
+            }
+        }
+        if (ts.isExportAssignment(stmt) && !stmt.isExportEquals) {
+            const expr = unwrapTypeCast(stmt.expression);
+            if (ts.isIdentifier(expr)) {
+                defaultExportName = expr.text;
+            }
+            else if (ts.isObjectLiteralExpression(expr)) {
+                inlineDefaultObject = expr;
+            }
+        }
+    }
+    if (inlineDefaultObject)
+        return inlineDefaultObject;
+    if (defaultExportName) {
+        const decl = variableDecls.get(defaultExportName);
+        if (decl?.initializer) {
+            const init = unwrapTypeCast(decl.initializer);
+            if (ts.isObjectLiteralExpression(init))
+                return init;
+        }
+    }
+    return undefined;
+}
+function parseSource(sourceText) {
+    return ts.createSourceFile(CONFIG_FILENAME, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+}
+function objectLiteralToRecord(obj) {
+    const result = {};
+    for (const prop of obj.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const key = propertyKeyName(prop);
+        if (!key)
+            continue;
+        const init = unwrapTypeCast(prop.initializer);
+        if (ts.isObjectLiteralExpression(init)) {
+            result[key] = objectLiteralToRecord(init);
+        }
+        else if (ts.isArrayLiteralExpression(init)) {
+            const items = [];
+            for (const elem of init.elements) {
+                const s = getStringLiteral(elem);
+                if (s === undefined)
+                    break;
+                items.push(s);
+            }
+            if (items.length === init.elements.length && items.length > 0)
+                result[key] = items;
+        }
+        else {
+            const scalar = getScalarValue(init);
+            if (scalar !== undefined)
+                result[key] = scalar;
+        }
+    }
+    return result;
+}
+/**
+ * Read a top-level section of the config (e.g. `display`) as a plain record.
+ * Returns undefined when the section is missing or not an object literal.
+ */
+export function readConfigSection(sourceText, section) {
+    const obj = findConfigObjectLiteral(parseSource(sourceText));
+    if (!obj)
+        return undefined;
+    for (const prop of obj.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        if (propertyKeyName(prop) !== section)
+            continue;
+        const init = unwrapTypeCast(prop.initializer);
+        if (!ts.isObjectLiteralExpression(init))
+            return undefined;
+        return objectLiteralToRecord(init);
+    }
+    return undefined;
+}
+/** Read the top-level `entry` scalar (the .ui/.ts entry path). */
+export function readEntryPath(sourceText) {
+    const obj = findConfigObjectLiteral(parseSource(sourceText));
+    if (!obj)
+        return undefined;
+    for (const prop of obj.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        if (propertyKeyName(prop) !== "entry")
+            continue;
+        const value = getStringLiteral(unwrapTypeCast(prop.initializer));
+        return value;
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Rendering — build the `display` object-literal text
+// ---------------------------------------------------------------------------
+/** Keys whose numeric values read best in hex (I2C addresses). */
+const HEX_KEYS = new Set(["address", "i2cAddress"]);
+function escapeString(value) {
+    return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function isPlainRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function renderValue(key, value) {
+    if (typeof value === "number") {
+        if (HEX_KEYS.has(key) && Number.isInteger(value) && value >= 0) {
+            return `0x${value.toString(16)}`;
+        }
+        return String(value);
+    }
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (typeof value === "string")
+        return `'${escapeString(value)}'`;
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => renderValue(key, item)).join(", ")}]`;
+    }
+    if (isPlainRecord(value)) {
+        const inner = Object.entries(value)
+            .map(([nestedKey, nestedValue]) => `${nestedKey}: ${renderValue(nestedKey, nestedValue)}`)
+            .join(", ");
+        return `{ ${inner} }`;
+    }
+    throw new Error(`Cannot render display config value for key "${key}" (${typeof value}).`);
+}
+/**
+ * Render the display section as an object-literal body (braces included).
+ * Key order follows insertion order of the record, matching the demos
+ * (profile/wiring first, touch last). Nested objects render inline.
+ */
+export function renderDisplayBody(display, options = {}) {
+    const indent = options.indent ?? "  ";
+    const closingIndent = options.closingIndent ?? "";
+    const eol = options.eol ?? "\n";
+    const lines = [];
+    for (const [key, value] of Object.entries(display)) {
+        const comment = options.comments?.[key];
+        if (comment) {
+            lines.push(`${indent}// ${comment}`);
+        }
+        lines.push(`${indent}${key}: ${renderValue(key, value)},`);
+    }
+    return `{${eol}${lines.join(eol)}${eol}${closingIndent}}`;
+}
+/** Render the complete `display: { ... }` property text for a property that
+ *  starts at `options.indent`. The returned text's first line is NOT indented
+ *  — the caller positions the property start; body lines and the closing
+ *  brace are indented relative to `options.indent`. */
+export function renderDisplayProperty(display, options = {}) {
+    const indent = options.indent ?? "";
+    return `display: ${renderDisplayBody(display, {
+        ...options,
+        indent: `${indent}  `,
+        closingIndent: indent,
+    })}`;
+}
+// ---------------------------------------------------------------------------
+// Splicing — insert or replace the display section inside the config
+// ---------------------------------------------------------------------------
+/** Leading whitespace of the line containing `pos` ("" when mid-line). */
+function lineIndentAt(text, pos) {
+    const lineStart = text.lastIndexOf("\n", pos - 1) + 1;
+    const before = text.slice(lineStart, pos);
+    return /^[ \t]*$/.test(before) ? before : "";
+}
+function detectLineEnding(text) {
+    return text.includes("\r\n") ? "\r\n" : "\n";
+}
+/** Skip whitespace and comments from `pos`; true when the next char is ','. */
+function spanStartsWithComma(text, pos, end) {
+    let i = pos;
+    while (i < end) {
+        const ch = text[i];
+        if (ch === " " || ch === "\t" || ch === "\r" || ch === "\n") {
+            i++;
+            continue;
+        }
+        if (ch === "/" && text[i + 1] === "/") {
+            const newline = text.indexOf("\n", i);
+            if (newline === -1 || newline >= end)
+                return false;
+            i = newline + 1;
+            continue;
+        }
+        if (ch === "/" && text[i + 1] === "*") {
+            const close = text.indexOf("*/", i);
+            if (close === -1 || close + 2 > end)
+                return false;
+            i = close + 2;
+            continue;
+        }
+        return ch === ",";
+    }
+    return false;
+}
+/**
+ * Insert or replace the `display` section in a cuttlefish.config.ts source
+ * string, preserving every other section and comment. Throws when the config
+ * has no recognizable default-export object literal.
+ */
+export function upsertDisplaySection(sourceText, display, options = {}) {
+    const sourceFile = parseSource(sourceText);
+    const obj = findConfigObjectLiteral(sourceFile);
+    if (!obj) {
+        throw new Error("cuttlefish.config.ts has no recognizable config object — expected `export default { ... }` or `const config = { ... }; export default config;`.");
+    }
+    const eol = options.eol ?? detectLineEnding(sourceText);
+    const existing = obj.properties.find((prop) => ts.isPropertyAssignment(prop) && propertyKeyName(prop) === "display");
+    if (existing) {
+        const indent = lineIndentAt(sourceText, existing.getStart());
+        const body = renderDisplayBody(display, { ...options, indent: `${indent}  `, closingIndent: indent, eol });
+        const init = unwrapTypeCast(existing.initializer);
+        if (ts.isObjectLiteralExpression(init)) {
+            // Replace just the initializer — `display:` name and its comments stay.
+            return {
+                text: sourceText.slice(0, init.getStart()) + body + sourceText.slice(init.getEnd()),
+                mode: "replaced",
+            };
+        }
+        // `display: someExpression` — replace the whole property.
+        return {
+            text: sourceText.slice(0, existing.getStart()) + `display: ${body}` + sourceText.slice(existing.getEnd()),
+            mode: "replaced",
+        };
+    }
+    // No display section — insert before the object literal's closing brace.
+    const closeBrace = obj.getEnd() - 1;
+    const lastProp = obj.properties[obj.properties.length - 1];
+    const indent = lastProp
+        ? lineIndentAt(sourceText, lastProp.getStart())
+        : lineIndentAt(sourceText, obj.getStart()) + "  ";
+    const body = renderDisplayBody(display, { ...options, indent: `${indent}  `, closingIndent: indent, eol });
+    const closingIndent = lineIndentAt(sourceText, closeBrace);
+    let prefix = sourceText;
+    if (lastProp && !spanStartsWithComma(sourceText, lastProp.getEnd(), closeBrace)) {
+        prefix = sourceText.slice(0, lastProp.getEnd()) + "," + sourceText.slice(lastProp.getEnd());
+    }
+    // Recompute the brace position if a comma was inserted before it.
+    const insertedComma = prefix !== sourceText;
+    const closeBraceFinal = closeBrace + (insertedComma ? 1 : 0);
+    return {
+        text: prefix.slice(0, closeBraceFinal)
+            // Trailing comma keeps the multi-property style of the demos.
+            + `${indent}display: ${body},${eol}${closingIndent}`
+            + prefix.slice(closeBraceFinal),
+        mode: "inserted",
+    };
+}
+/**
+ * Syntactic sanity check for wizard output: returns the first error message
+ * when the text no longer parses as TypeScript, or null when it is clean.
+ * (Semantic checking is the build's job — this only guards the splice.)
+ */
+export function findSyntaxError(text) {
+    const output = ts.transpileModule(text, {
+        reportDiagnostics: true,
+        compilerOptions: { target: ts.ScriptTarget.ESNext, module: ts.ModuleKind.ESNext },
+    });
+    const errors = (output.diagnostics ?? []).filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
+    if (errors.length === 0)
+        return null;
+    const first = errors[0];
+    const message = ts.flattenDiagnosticMessageText(first.messageText, "\n");
+    if (typeof first.start === "number") {
+        const line = text.slice(0, first.start).split("\n").length;
+        return `line ${line}: ${message}`;
+    }
+    return message;
+}

package/dist/wizard/display-catalog.d.ts

@@ -0,0 +1,75 @@
+export type WizardBus = "spi" | "i2c" | "none";
+export type WizardTouchKind = "none" | "spi" | "i2c" | "analog" | "adapter" | "sdl";
+export interface DisplayCatalogEntry {
+    /** Catalog id — also the `display.profile` value for built-ins. */
+    id: string;
+    label: string;
+    hint: string;
+    /** Built-in profile name written to config (omitted for custom/sdl). */
+    profile?: string;
+    /** Driver name written when no built-in profile applies. */
+    driver?: string;
+    bus: WizardBus;
+    /** Wizard question defaults. */
+    defaults: {
+        cs?: number;
+        dc?: number;
+        rst?: number;
+        /** Backlight GPIO; undefined = don't ask, null = ask but default blank. */
+        backlight?: number | null;
+        /** Backlight pin the built-in profile drives when `backlight` is omitted. */
+        backlightProfileDefault?: number;
+        spiFrequency?: number;
+        address?: number;
+        width?: number;
+        height?: number;
+        /** Native panel size before rotation (used for capacitive touch calibration). */
+        nativeWidth?: number;
+        nativeHeight?: number;
+        rotation?: number;
+        colorOrder?: "rgb" | "bgr";
+        invert?: boolean;
+        antialias?: boolean;
+    };
+    /** Arduino libraries the driver needs (for the printed next steps). */
+    arduinoLibraries?: string[];
+    /** A wiring note printed with the summary. */
+    wiringNote?: string;
+}
+export declare const DISPLAY_CATALOG: readonly DisplayCatalogEntry[];
+export interface TouchCatalogEntry {
+    /** `touch.library` value written to config (built-in libraries only). */
+    id: string;
+    label: string;
+    hint: string;
+    kind: WizardTouchKind;
+    defaults: {
+        cs?: number;
+        irq?: number;
+        i2cAddress?: number;
+        i2cFrequency?: number;
+        resetPin?: number;
+        /** Resistive raw-ADC calibration (capacitive uses panel pixel space). */
+        calibration?: {
+            xMin: number;
+            xMax: number;
+            yMin: number;
+            yMax: number;
+        };
+        analogPins?: {
+            xp: number;
+            yp: number;
+            xm: number;
+            ym: number;
+            rx: number;
+        };
+    };
+    arduinoLibrary?: string;
+}
+export declare const TOUCH_CATALOG: readonly TouchCatalogEntry[];
+/**
+ * Collect GPIO collisions between the display wiring and the touch wiring so
+ * the wizard can warn before writing the config (a shared pin is almost
+ * always a mis-entered default rather than real hardware).
+ */
+export declare function findPinConflicts(displayPins: Record<string, number | undefined>, touchPins: Record<string, number | undefined>): string[];

package/dist/wizard/display-catalog.js

@@ -0,0 +1,207 @@
+// ---------------------------------------------------------------------------
+// Display + touch hardware catalog for the @typecad/ui integration wizard.
+//
+// Mirrors the built-in display profiles exported by @typecad/framework-arduino
+// (src/displays/*.ts — BUILT_IN_PROFILES) and the TouchLibrary union in
+// @typecad/cuttlefish's display-profile.ts. The wizard asks questions and
+// fills defaults from these entries; the resulting object literal is written
+// into the project's cuttlefish.config.ts `display` section.
+//
+// Keep this catalog in sync with the framework's BUILT_IN_PROFILES when a
+// display or touch library is added there.
+// ---------------------------------------------------------------------------
+export const DISPLAY_CATALOG = [
+    {
+        id: "ili9341-spi",
+        label: "ILI9341 320×240 SPI TFT",
+        hint: '2.2"–3.2" color TFT modules, often with resistive touch',
+        profile: "ili9341-spi",
+        bus: "spi",
+        defaults: {
+            // ESP32 VSPI wiring used by the repo demos and the framework profile.
+            cs: 5,
+            dc: 21,
+            rst: 22,
+            // The ILI9341 built-in profile drives backlight GPIO 17 when the config
+            // omits `backlight` — surface that in the wizard's blank-answer hint.
+            backlightProfileDefault: 17,
+            spiFrequency: 40_000_000,
+            width: 320,
+            height: 240,
+            rotation: 1,
+            colorOrder: "rgb",
+            antialias: true,
+        },
+        arduinoLibraries: ["Adafruit GFX Library", "Adafruit ILI9341"],
+        wiringNote: "Defaults assume ESP32 VSPI: SCK=18, MOSI=23, MISO=19.",
+    },
+    {
+        id: "st7796-spi",
+        label: "ST7796S 320×480 SPI TFT",
+        hint: '3.5"/4" color TFT modules, often with FT6336U capacitive touch',
+        profile: "st7796-spi",
+        bus: "spi",
+        defaults: {
+            // Wiring proven on the repo's ESP32-S3 demo hardware (demos/demo-st).
+            cs: 5,
+            dc: 17,
+            rst: 16,
+            backlight: null,
+            spiFrequency: 80_000_000,
+            width: 480,
+            height: 320,
+            nativeWidth: 320,
+            nativeHeight: 480,
+            rotation: 1,
+            colorOrder: "bgr",
+            invert: false,
+            antialias: true,
+        },
+        arduinoLibraries: ["Adafruit GFX Library", "Adafruit ST7735 and ST7789 Library"],
+        wiringNote: "Defaults assume ESP32 VSPI: SCK=18, MOSI=23, MISO=19. Adafruit_ST7796S.h comes from the" +
+            " Adafruit_ST7735_and_ST7789 fork bundled in the typecode demos (demos/demo-st/lib) —" +
+            " copy it into your sketchbook libraries/ if your Library Manager copy lacks the class.",
+    },
+    {
+        id: "ssd1309-i2c",
+        label: "SSD1309 128×64 monochrome OLED (I2C)",
+        hint: "1-bit OLED panels driven via the Adafruit_SSD1306 API",
+        profile: "ssd1309-i2c",
+        bus: "i2c",
+        defaults: {
+            address: 0x3c,
+            width: 128,
+            height: 64,
+            rotation: 0,
+            antialias: false,
+        },
+        arduinoLibraries: ["Adafruit GFX Library", "Adafruit SSD1306"],
+    },
+    {
+        id: "sdl",
+        label: "Desktop simulator window (no hardware)",
+        hint: "native target — renders your UI in an SDL2 window",
+        driver: "sdl",
+        bus: "none",
+        defaults: {
+            width: 320,
+            height: 240,
+            rotation: 0,
+            antialias: true,
+        },
+    },
+    {
+        id: "custom",
+        label: "Custom display — enter driver, bus, and pins manually",
+        hint: "any controller not listed above",
+        bus: "spi",
+        defaults: {},
+    },
+];
+export const TOUCH_CATALOG = [
+    {
+        id: "none",
+        label: "No touch (display only)",
+        hint: "skip touch configuration",
+        kind: "none",
+        defaults: {},
+    },
+    {
+        id: "XPT2046_Touchscreen",
+        label: "XPT2046 resistive (SPI)",
+        hint: "the resistive controller on most ILI9341 modules",
+        kind: "spi",
+        defaults: {
+            cs: 15,
+            // Typical raw-ADC range for 320×240 modules; refine per panel.
+            calibration: { xMin: 375, xMax: 3950, yMin: 200, yMax: 3750 },
+        },
+        arduinoLibrary: "XPT2046_Touchscreen",
+    },
+    {
+        id: "FT6336U",
+        label: "FT6336U capacitive (I2C)",
+        hint: "on many ST7796S 320×480 modules",
+        kind: "i2c",
+        defaults: {
+            i2cAddress: 0x38,
+            i2cFrequency: 400_000,
+        },
+        // The framework's FT6336U adapter includes RAK14014_FT6336U.h.
+        arduinoLibrary: "RAK14014-FT6336U",
+    },
+    {
+        id: "GT911",
+        label: "GT911 capacitive (I2C)",
+        hint: "common on larger IPS panels",
+        kind: "i2c",
+        defaults: {
+            i2cAddress: 0x5d,
+            i2cFrequency: 400_000,
+        },
+        arduinoLibrary: "GT911",
+    },
+    {
+        id: "CST816S",
+        label: "CST816S capacitive (I2C)",
+        hint: "on many compact ESP32 display boards",
+        kind: "i2c",
+        defaults: {
+            i2cAddress: 0x15,
+            i2cFrequency: 400_000,
+        },
+        arduinoLibrary: "CST816S",
+    },
+    {
+        id: "Adafruit_TouchScreen",
+        label: "Adafruit 4-wire resistive (analog pins)",
+        hint: '2.4"/2.8" Adafruit shields with XP/YP/XM/YM analog pins',
+        kind: "analog",
+        defaults: {
+            analogPins: { xp: 24, yp: 25, xm: 26, ym: 27, rx: 300 },
+            calibration: { xMin: 100, xMax: 900, yMin: 120, yMax: 900 },
+        },
+        arduinoLibrary: "Adafruit TouchScreen",
+    },
+    {
+        id: "Adafruit_STMPE610",
+        label: "STMPE610 resistive (SPI)",
+        hint: 'Adafruit 2.8" TFT touch cape controller',
+        kind: "spi",
+        defaults: {
+            cs: 14,
+            calibration: { xMin: 375, xMax: 3950, yMin: 200, yMax: 3750 },
+        },
+        arduinoLibrary: "Adafruit STMPE610",
+    },
+    {
+        id: "adapter",
+        label: "Custom touch adapter file",
+        hint: "path to your own TypeScript adapter",
+        kind: "adapter",
+        defaults: {},
+    },
+];
+/**
+ * Collect GPIO collisions between the display wiring and the touch wiring so
+ * the wizard can warn before writing the config (a shared pin is almost
+ * always a mis-entered default rather than real hardware).
+ */
+export function findPinConflicts(displayPins, touchPins) {
+    const conflicts = [];
+    const claimed = new Map();
+    for (const [displayKey, displayValue] of Object.entries(displayPins)) {
+        if (displayValue === undefined)
+            continue;
+        claimed.set(displayValue, displayKey);
+    }
+    for (const [touchKey, touchValue] of Object.entries(touchPins)) {
+        if (touchValue === undefined)
+            continue;
+        const owner = claimed.get(touchValue);
+        if (owner !== undefined) {
+            conflicts.push(`display.${owner} and touch.${touchKey} are both wired to GPIO ${touchValue}`);
+        }
+    }
+    return conflicts;
+}

package/dist/wizard/index.d.ts

@@ -0,0 +1,7 @@
+export { DISPLAY_CATALOG, TOUCH_CATALOG, findPinConflicts, } from "./display-catalog.js";
+export type { DisplayCatalogEntry, TouchCatalogEntry, WizardBus, WizardTouchKind, } from "./display-catalog.js";
+export { findCuttlefishConfig, findSyntaxError, readConfigSection, readEntryPath, renderDisplayBody, renderDisplayProperty, upsertDisplaySection, } from "./config-writer.js";
+export type { ConfigRecord, RenderDisplayOptions, UpsertDisplayResult, } from "./config-writer.js";
+export { renderStarterUi } from "./starter-ui.js";
+export { runIntegrationWizard } from "./integration-wizard.js";
+export type { WizardRunResult, WizardStreams } from "./integration-wizard.js";

package/dist/wizard/index.js

@@ -0,0 +1,10 @@
+// ---------------------------------------------------------------------------
+// Public surface of the @typecad/ui integration wizard (`npx @typecad/ui
+// --config`). Pure helpers (catalog, rendering, config splicing, starter
+// template) are exported for tests and tooling; the interactive flow lives in
+// integration-wizard.ts.
+// ---------------------------------------------------------------------------
+export { DISPLAY_CATALOG, TOUCH_CATALOG, findPinConflicts, } from "./display-catalog.js";
+export { findCuttlefishConfig, findSyntaxError, readConfigSection, readEntryPath, renderDisplayBody, renderDisplayProperty, upsertDisplaySection, } from "./config-writer.js";
+export { renderStarterUi } from "./starter-ui.js";
+export { runIntegrationWizard } from "./integration-wizard.js";

package/dist/wizard/integration-wizard.d.ts

@@ -0,0 +1,15 @@
+export interface WizardRunResult {
+    exitCode: number;
+    /** Absolute path of the config that was written, when a write happened. */
+    configPath?: string;
+}
+/** Optional stream overrides so tests can drive the interactive flow. */
+export interface WizardStreams {
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+/**
+ * Run the interactive integration wizard. Returns a process exit code
+ * (0 = wrote (or deliberately declined), 1 = blocked before writing).
+ */
+export declare function runIntegrationWizard(cwd?: string, streams?: WizardStreams): Promise<WizardRunResult>;