@imenam/mcp-design 1.0.1

package/dist/src/core/diff.d.ts

@@ -0,0 +1,22 @@
+import type { DesignNode } from "../../shared/schemas/design.schema.js";
+export interface NodeFieldChange {
+    field: string;
+    before: unknown;
+    after: unknown;
+}
+export interface UpdatedNode {
+    id: string;
+    name: string;
+    type: string;
+    changes: NodeFieldChange[];
+}
+export interface DesignDiff {
+    added: DesignNode[];
+    updated: UpdatedNode[];
+    removed: DesignNode[];
+    reordered: boolean;
+}
+export declare function diffNodes(before: DesignNode[], after: DesignNode[]): DesignDiff;
+export declare function countChanges(before: DesignNode[], after: DesignNode[]): number;
+/** Résumé lisible du diff, destiné à être renvoyé tel quel à l'agent. */
+export declare function formatDiff(diff: DesignDiff): string;

package/dist/src/core/diff.js

@@ -0,0 +1,97 @@
+import { GROUP_DERIVED_FIELDS } from "../../shared/node-defaults.js";
+/** Champs recalculés automatiquement : les signaler serait du bruit, pas un changement de design. */
+const DERIVED_GROUP_FIELDS = new Set(GROUP_DERIVED_FIELDS);
+/** Les nombres issus de la GUI portent du bruit sous-pixel qui n'est pas un changement de design. */
+function equalValues(a, b) {
+    if (typeof a === "number" && typeof b === "number")
+        return Math.abs(a - b) < 0.01;
+    return a === b;
+}
+export function diffNodes(before, after) {
+    const beforeById = new Map(before.map((n) => [n.id, n]));
+    const afterById = new Map(after.map((n) => [n.id, n]));
+    const added = after.filter((n) => !beforeById.has(n.id));
+    const removed = before.filter((n) => !afterById.has(n.id));
+    const updated = [];
+    for (const node of after) {
+        const previous = beforeById.get(node.id);
+        if (!previous)
+            continue;
+        const fields = new Set([...Object.keys(previous), ...Object.keys(node)]);
+        const changes = [];
+        for (const field of fields) {
+            if (field === "id" || field === "type")
+                continue;
+            if (node.type === "group" && DERIVED_GROUP_FIELDS.has(field))
+                continue;
+            const a = previous[field];
+            const b = node[field];
+            if (!equalValues(a, b))
+                changes.push({ field, before: a, after: b });
+        }
+        if (changes.length > 0) {
+            updated.push({ id: node.id, name: node.name, type: node.type, changes });
+        }
+    }
+    // L'ordre d'empilement change le rendu sans changer un seul champ : on le signale à part.
+    const commonBefore = before.filter((n) => afterById.has(n.id)).map((n) => n.id);
+    const commonAfter = after.filter((n) => beforeById.has(n.id)).map((n) => n.id);
+    const reordered = commonBefore.join("|") !== commonAfter.join("|");
+    return { added, updated, removed, reordered };
+}
+export function countChanges(before, after) {
+    const diff = diffNodes(before, after);
+    return diff.added.length + diff.updated.length + diff.removed.length;
+}
+function formatValue(value) {
+    if (value === undefined)
+        return "—";
+    if (value === null)
+        return "racine";
+    if (typeof value === "number")
+        return String(Math.round(value * 100) / 100);
+    return JSON.stringify(value);
+}
+/** "dans le groupe X" plutôt qu'un identifiant nu, quand le noeud n'est pas à la racine. */
+function parentSuffix(node) {
+    return node.parentId === null ? "" : ` in group ${node.parentId}`;
+}
+/** Résumé lisible du diff, destiné à être renvoyé tel quel à l'agent. */
+export function formatDiff(diff) {
+    const lines = [];
+    if (diff.added.length > 0) {
+        lines.push(`## Added (${diff.added.length})`);
+        for (const node of diff.added) {
+            const geometry = node.type === "group"
+                ? `at ${Math.round(node.x)},${Math.round(node.y)}`
+                : `at ${Math.round(node.x)},${Math.round(node.y)} size ${Math.round(node.width)}x${Math.round(node.height)}`;
+            lines.push(`- ${node.id} — "${node.name}" (${node.type}) ${geometry}${parentSuffix(node)}`);
+        }
+        lines.push("");
+    }
+    if (diff.updated.length > 0) {
+        lines.push(`## Updated (${diff.updated.length})`);
+        for (const node of diff.updated) {
+            lines.push(`- ${node.id} — "${node.name}" (${node.type})`);
+            for (const change of node.changes) {
+                lines.push(`    ${change.field}: ${formatValue(change.before)} -> ${formatValue(change.after)}`);
+            }
+        }
+        lines.push("");
+    }
+    if (diff.removed.length > 0) {
+        lines.push(`## Removed (${diff.removed.length})`);
+        for (const node of diff.removed) {
+            lines.push(`- ${node.id} — "${node.name}" (${node.type})`);
+        }
+        lines.push("");
+    }
+    if (diff.reordered) {
+        lines.push("## Reordered");
+        lines.push("- The stacking order of existing nodes changed.");
+        lines.push("");
+    }
+    if (lines.length === 0)
+        return "No changes since the last mark_synced.";
+    return lines.join("\n").trimEnd();
+}

package/dist/src/core/export.d.ts

@@ -0,0 +1,6 @@
+import type { Design } from "../../shared/schemas/design.schema.js";
+export declare const EXPORT_FORMATS: readonly ["svg", "html", "jsx", "json", "summary"];
+export type ExportFormat = (typeof EXPORT_FORMATS)[number];
+/** Inventaire textuel : ce que l'agent lit quand il veut comprendre sans parser du JSON. */
+export declare function toSummary(design: Design): string;
+export declare function exportDesign(design: Design, format: ExportFormat): string;

package/dist/src/core/export.js

@@ -0,0 +1,251 @@
+import { DEFAULT_FONT_FAMILY, documentToSvg, escapeXml, measuredTextHeight, normalizedBox, textLines, textMetrics, } from "../../shared/render.js";
+import { boundsOf, childrenByParent, computeLayout } from "../../shared/tree.js";
+export const EXPORT_FORMATS = ["svg", "html", "jsx", "json", "summary"];
+function round(value) {
+    return Math.round(value * 100) / 100;
+}
+function toRenderNodes(design) {
+    return design.nodes;
+}
+/** "Titre principal" -> "titre-principal" ; sert de nom de classe CSS. */
+function cssClassName(node) {
+    const base = node.name
+        .normalize("NFD")
+        .replace(/\p{Diacritic}/gu, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return `d-${base || node.type}-${node.id.replace(/[^a-z0-9]/gi, "")}`;
+}
+/**
+ * Position d'un élément **dans la div de son parent**.
+ *
+ * Un groupe est exporté comme une div positionnée sur la boîte englobante de son
+ * contenu ; ses enfants sont donc décalés de cette boîte, ce qui produit du HTML
+ * imbriqué directement réutilisable plutôt qu'une liste plate de coordonnées.
+ */
+function offsetWithin(layout, node, parentBox) {
+    const box = boundsOf(layout, node.id);
+    return { left: box.x - (parentBox?.x ?? 0), top: box.y - (parentBox?.y ?? 0) };
+}
+function nodeCss(node, layout, parentBox) {
+    const declarations = ["position: absolute"];
+    const offset = offsetWithin(layout, node, parentBox);
+    if (node.type === "group") {
+        const box = boundsOf(layout, node.id);
+        declarations.push(`left: ${round(offset.left)}px`, `top: ${round(offset.top)}px`, `width: ${round(box.width)}px`, `height: ${round(box.height)}px`);
+        if (node.rotation)
+            declarations.push(`transform: rotate(${round(node.rotation)}deg)`);
+        if (node.opacity < 1)
+            declarations.push(`opacity: ${round(node.opacity)}`);
+        return declarations;
+    }
+    if (node.type === "line") {
+        // Une ligne se rend comme une barre pivotée autour de son point de départ :
+        // c'est le seul type dont l'ancrage n'est pas le coin de la boîte englobante.
+        const length = Math.hypot(node.width, node.height);
+        const angle = (Math.atan2(node.height, node.width) * 180) / Math.PI;
+        const thickness = round(node.strokeWidth ?? 1);
+        const local = normalizedBox(node);
+        // offset porte sur la boîte normalisée ; le trait part de son extrémité d'origine.
+        const startLeft = offset.left + (node.x - local.x);
+        const startTop = offset.top + (node.y - local.y);
+        declarations.push(`left: ${round(startLeft)}px`, `top: ${round(startTop - thickness / 2)}px`, `width: ${round(length)}px`, `height: ${thickness}px`, `background: ${node.stroke ?? "#000000"}`, `transform: rotate(${round(angle + node.rotation)}deg)`, "transform-origin: 0 50%");
+    }
+    else {
+        const box = boundsOf(layout, node.id);
+        declarations.push(`left: ${round(offset.left)}px`, `top: ${round(offset.top)}px`, `width: ${round(box.width)}px`, `height: ${round(box.height)}px`);
+        if (node.rotation)
+            declarations.push(`transform: rotate(${round(node.rotation)}deg)`);
+    }
+    if (node.opacity < 1)
+        declarations.push(`opacity: ${round(node.opacity)}`);
+    if (node.type === "rect") {
+        if (node.fill)
+            declarations.push(`background: ${node.fill}`);
+        if (node.stroke && (node.strokeWidth ?? 0) > 0) {
+            declarations.push(`border: ${round(node.strokeWidth ?? 1)}px solid ${node.stroke}`);
+            declarations.push("box-sizing: border-box");
+        }
+        if (node.radius)
+            declarations.push(`border-radius: ${round(node.radius)}px`);
+    }
+    else if (node.type === "ellipse") {
+        if (node.fill)
+            declarations.push(`background: ${node.fill}`);
+        if (node.stroke && (node.strokeWidth ?? 0) > 0) {
+            declarations.push(`border: ${round(node.strokeWidth ?? 1)}px solid ${node.stroke}`);
+            declarations.push("box-sizing: border-box");
+        }
+        declarations.push("border-radius: 50%");
+    }
+    else if (node.type === "text") {
+        declarations.push(`color: ${node.color ?? "#000000"}`, `font-family: ${node.fontFamily ?? DEFAULT_FONT_FAMILY}`, `font-size: ${round(node.fontSize ?? 24)}px`, `font-weight: ${node.fontWeight ?? 400}`, `line-height: ${round(textMetrics(node).lineStep)}px`, `text-align: ${node.textAlign ?? "left"}`, "white-space: pre-wrap");
+        if (node.fontStyle === "italic")
+            declarations.push("font-style: italic");
+        declarations.push("height: auto", `min-height: ${round(measuredTextHeight(node))}px`);
+    }
+    return declarations;
+}
+function contextOf(design) {
+    return { layout: computeLayout(toRenderNodes(design)), children: childrenByParent(design.nodes) };
+}
+function toHtml(design) {
+    const { layout, children } = contextOf(design);
+    const rules = [];
+    const walk = (nodes, parentBox, depth) => {
+        const pad = "    ".repeat(depth + 1);
+        return nodes.flatMap((node) => {
+            rules.push(`.${cssClassName(node)} {\n${nodeCss(node, layout, parentBox).map((d) => `  ${d};`).join("\n")}\n}`);
+            const cls = cssClassName(node);
+            if (node.type === "group") {
+                return [
+                    `${pad}<div class="${cls}">`,
+                    ...walk(children.get(node.id) ?? [], boundsOf(layout, node.id), depth + 1),
+                    `${pad}</div>`,
+                ];
+            }
+            if (node.type === "text")
+                return [`${pad}<div class="${cls}">${escapeXml(node.text ?? "")}</div>`];
+            return [`${pad}<div class="${cls}"></div>`];
+        });
+    };
+    const body = walk(children.get(null) ?? [], null, 1).join("\n");
+    return [
+        "<!doctype html>",
+        '<html lang="fr">',
+        "<head>",
+        '  <meta charset="utf-8" />',
+        `  <title>${escapeXml(design.name)}</title>`,
+        "  <style>",
+        "    body { margin: 0; }",
+        `    .design-root { position: relative; width: ${design.width}px; height: ${design.height}px; background: ${design.background}; overflow: hidden; }`,
+        rules
+            .join("\n\n")
+            .split("\n")
+            .map((line) => (line ? `    ${line}` : ""))
+            .join("\n"),
+        "  </style>",
+        "</head>",
+        "<body>",
+        '  <div class="design-root">',
+        body,
+        "  </div>",
+        "</body>",
+        "</html>",
+    ].join("\n");
+}
+function toCamelCase(property) {
+    return property.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function toComponentName(name) {
+    const pascal = name
+        .normalize("NFD")
+        .replace(/\p{Diacritic}/gu, "")
+        .replace(/[^a-zA-Z0-9]+(.)?/g, (_, letter) => (letter ? letter.toUpperCase() : ""))
+        .replace(/^[a-z]/, (letter) => letter.toUpperCase());
+    return /^[A-Za-z]/.test(pascal) ? pascal : "Design";
+}
+function toJsx(design) {
+    const { layout, children } = contextOf(design);
+    const styleOf = (node, parentBox) => nodeCss(node, layout, parentBox)
+        .map((declaration) => {
+        const separator = declaration.indexOf(":");
+        const property = declaration.slice(0, separator).trim();
+        const value = declaration.slice(separator + 1).trim();
+        return `${toCamelCase(property)}: ${JSON.stringify(value)}`;
+    })
+        .join(", ");
+    const walk = (nodes, parentBox, depth) => {
+        const pad = "  ".repeat(depth + 3);
+        return nodes.flatMap((node) => {
+            const comment = `${pad}{/* ${node.name} */}`;
+            const style = styleOf(node, parentBox);
+            if (node.type === "group") {
+                return [
+                    comment,
+                    `${pad}<div style={{ ${style} }}>`,
+                    ...walk(children.get(node.id) ?? [], boundsOf(layout, node.id), depth + 1),
+                    `${pad}</div>`,
+                ];
+            }
+            if (node.type === "text") {
+                return [comment, `${pad}<div style={{ ${style} }}>{${JSON.stringify(node.text ?? "")}}</div>`];
+            }
+            return [comment, `${pad}<div style={{ ${style} }} />`];
+        });
+    };
+    return [
+        `export function ${toComponentName(design.name)}() {`,
+        "  return (",
+        `    <div style={{ position: "relative", width: ${design.width}, height: ${design.height}, background: ${JSON.stringify(design.background)}, overflow: "hidden" }}>`,
+        ...walk(children.get(null) ?? [], null, 0),
+        "    </div>",
+        "  );",
+        "}",
+        "",
+    ].join("\n");
+}
+/** Inventaire textuel : ce que l'agent lit quand il veut comprendre sans parser du JSON. */
+export function toSummary(design) {
+    const { layout, children } = contextOf(design);
+    const lines = [
+        `# ${design.name} (${design.id})`,
+        `Canvas: ${design.width}x${design.height}, background ${design.background}`,
+        `Revision ${design.revision}, last edited by ${design.lastEditor} at ${design.updatedAt}`,
+        `Nodes: ${design.nodes.length} (listed bottom to top; indentation = grouping, coordinates are document-absolute)`,
+        "",
+    ];
+    const walk = (nodes, depth) => {
+        const indent = "  ".repeat(depth);
+        for (const node of nodes) {
+            const box = boundsOf(layout, node.id);
+            const geometry = `${Math.round(box.x)},${Math.round(box.y)} ${Math.round(box.width)}x${Math.round(box.height)}`;
+            if (node.type === "group") {
+                const count = (children.get(node.id) ?? []).length;
+                lines.push(`${indent}- ${node.id} group "${node.name}" @ ${geometry} — ${count} child(ren)`);
+                walk(children.get(node.id) ?? [], depth + 1);
+            }
+            else if (node.type === "text") {
+                const preview = textLines(node).join(" / ");
+                lines.push(`${indent}- ${node.id} text "${node.name}" @ ${geometry} — ${node.fontSize}px/${node.fontWeight} ${node.color} — "${preview}"`);
+            }
+            else if (node.type === "line") {
+                lines.push(`${indent}- ${node.id} line "${node.name}" @ ${geometry} — ${node.strokeWidth}px ${node.stroke}`);
+            }
+            else {
+                lines.push(`${indent}- ${node.id} ${node.type} "${node.name}" @ ${geometry} — fill ${node.fill ?? "none"}, ` +
+                    `stroke ${node.stroke ?? "none"}${node.radius ? `, radius ${node.radius}` : ""}`);
+            }
+        }
+    };
+    walk(children.get(null) ?? [], 0);
+    return lines.join("\n");
+}
+export function exportDesign(design, format) {
+    switch (format) {
+        case "svg":
+            return documentToSvg({
+                name: design.name,
+                width: design.width,
+                height: design.height,
+                background: design.background,
+                nodes: toRenderNodes(design),
+            });
+        case "html":
+            return toHtml(design);
+        case "jsx":
+            return toJsx(design);
+        case "json":
+            return JSON.stringify({
+                id: design.id,
+                name: design.name,
+                width: design.width,
+                height: design.height,
+                background: design.background,
+                nodes: design.nodes,
+            }, null, 2);
+        case "summary":
+            return toSummary(design);
+    }
+}

package/dist/src/core/hierarchy.d.ts

@@ -0,0 +1,18 @@
+import type { DesignNode } from "../../shared/schemas/design.schema.js";
+/**
+ * Invariants de la hiérarchie, appliqués à chaque mutation.
+ *
+ * Une planche dont un `parentId` pend dans le vide ou boucle sur elle-même est
+ * irréparable côté GUI : on refuse l'écriture plutôt que de rendre un design
+ * partiellement invisible.
+ */
+export declare function validateHierarchy(nodes: DesignNode[]): void;
+/**
+ * Recalcule la taille de chaque groupe à partir de son contenu. Ces champs sont
+ * dérivés : ils existent pour que l'agent puisse lire l'encombrement d'un
+ * groupe sans refaire le calcul, jamais pour être écrits.
+ */
+export declare function recomputeGroupSizes(nodes: DesignNode[]): DesignNode[];
+export declare function normalizeHierarchy(nodes: DesignNode[]): DesignNode[];
+/** Un élément et tous ses descendants — ce qu'une suppression de groupe emporte. */
+export declare function withDescendants(nodes: DesignNode[], ids: string[]): Set<string>;

package/dist/src/core/hierarchy.js

@@ -0,0 +1,68 @@
+import { boundsOf, computeLayout, descendantIds, flattenPreOrder } from "../../shared/tree.js";
+import { DesignError } from "./node-factory.js";
+/**
+ * Invariants de la hiérarchie, appliqués à chaque mutation.
+ *
+ * Une planche dont un `parentId` pend dans le vide ou boucle sur elle-même est
+ * irréparable côté GUI : on refuse l'écriture plutôt que de rendre un design
+ * partiellement invisible.
+ */
+export function validateHierarchy(nodes) {
+    const byId = new Map(nodes.map((node) => [node.id, node]));
+    const duplicates = nodes.filter((node, index) => nodes.findIndex((other) => other.id === node.id) !== index);
+    if (duplicates.length > 0) {
+        throw new DesignError(`Duplicate node id(s): ${[...new Set(duplicates.map((n) => n.id))].join(", ")}.`);
+    }
+    for (const node of nodes) {
+        if (node.parentId === null)
+            continue;
+        const parent = byId.get(node.parentId);
+        if (!parent) {
+            throw new DesignError(`Node "${node.id}" references a parent "${node.parentId}" that does not exist.`);
+        }
+        if (parent.type !== "group") {
+            throw new DesignError(`Node "${node.id}" cannot be parented to "${parent.id}" because it is a "${parent.type}", not a group.`);
+        }
+        // Un cycle rendrait le calcul de disposition infini.
+        let cursor = parent;
+        const seen = new Set([node.id]);
+        while (cursor) {
+            if (seen.has(cursor.id)) {
+                throw new DesignError(`Node "${node.id}" would create a cycle through group "${parent.id}".`);
+            }
+            seen.add(cursor.id);
+            cursor = cursor.parentId === null ? undefined : byId.get(cursor.parentId);
+        }
+    }
+}
+/**
+ * Recalcule la taille de chaque groupe à partir de son contenu. Ces champs sont
+ * dérivés : ils existent pour que l'agent puisse lire l'encombrement d'un
+ * groupe sans refaire le calcul, jamais pour être écrits.
+ */
+export function recomputeGroupSizes(nodes) {
+    if (!nodes.some((node) => node.type === "group"))
+        return nodes;
+    const layout = computeLayout(nodes);
+    return nodes.map((node) => {
+        if (node.type !== "group")
+            return node;
+        const box = boundsOf(layout, node.id);
+        if (node.width === box.width && node.height === box.height)
+            return node;
+        return { ...node, width: box.width, height: box.height };
+    });
+}
+export function normalizeHierarchy(nodes) {
+    validateHierarchy(nodes);
+    return recomputeGroupSizes(flattenPreOrder(nodes));
+}
+/** Un élément et tous ses descendants — ce qu'une suppression de groupe emporte. */
+export function withDescendants(nodes, ids) {
+    const all = new Set(ids);
+    for (const id of ids) {
+        for (const descendant of descendantIds(nodes, id))
+            all.add(descendant);
+    }
+    return all;
+}

package/dist/src/core/ids.d.ts

@@ -0,0 +1,4 @@
+/** Identifiant court, lisible dans un JSON lu par un agent. */
+export declare function shortId(prefix: string, length?: number): string;
+/** "Ma Landing Page" -> "ma-landing-page" */
+export declare function slugify(value: string): string;

package/dist/src/core/ids.js

@@ -0,0 +1,21 @@
+import crypto from "crypto";
+const ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+/** Identifiant court, lisible dans un JSON lu par un agent. */
+export function shortId(prefix, length = 8) {
+    const bytes = crypto.randomBytes(length);
+    let out = "";
+    for (const byte of bytes)
+        out += ALPHABET[byte % ALPHABET.length];
+    return `${prefix}_${out}`;
+}
+/** "Ma Landing Page" -> "ma-landing-page" */
+export function slugify(value) {
+    const slug = value
+        .normalize("NFD")
+        .replace(/\p{Diacritic}/gu, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 48);
+    return slug || "design";
+}

package/dist/src/core/log-dir.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Répertoire des logs : MCP_LOG_DIR s'il est renseigné, sinon <racine>/.design-data/logs.
+ * Lu depuis process.env uniquement (le .env du package est chargé après l'init du
+ * logger), donc la variable doit venir de la config du client MCP.
+ */
+export declare function resolveLogDir(rootDir: string): string;

package/dist/src/core/log-dir.js

@@ -0,0 +1,12 @@
+import path from "path";
+/**
+ * Répertoire des logs : MCP_LOG_DIR s'il est renseigné, sinon <racine>/.design-data/logs.
+ * Lu depuis process.env uniquement (le .env du package est chargé après l'init du
+ * logger), donc la variable doit venir de la config du client MCP.
+ */
+export function resolveLogDir(rootDir) {
+    const configured = process.env.MCP_LOG_DIR?.trim();
+    if (configured)
+        return path.resolve(configured);
+    return path.join(rootDir, ".design-data", "logs");
+}

package/dist/src/core/migrate.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Mises à niveau appliquées à la lecture d'un fichier de design.
+ *
+ * Elles tournent avant la validation de schéma et sont idempotentes : un design
+ * déjà à jour ressort inchangé, et le fichier n'est réécrit que si quelque chose
+ * a bougé.
+ */
+/**
+ * `lineHeight` a d'abord été stocké comme un multiplicateur de `fontSize`
+ * (1.35), puis est passé en pixels — la seule unité que les agents emploient
+ * spontanément, et la seule cohérente avec x, y et fontSize.
+ *
+ * Une valeur sous MIN_LINE_HEIGHT_PX est donc forcément un ancien ratio : on la
+ * reconvertit en la multipliant par la taille de police du noeud.
+ */
+export declare function migrateNode(node: Record<string, unknown>): Record<string, unknown>;
+/** Applique la migration à un design brut. Retourne `null` si rien n'a changé. */
+export declare function migrateDesign(raw: unknown): Record<string, unknown> | null;

package/dist/src/core/migrate.js

@@ -0,0 +1,54 @@
+import { DEFAULT_FONT_SIZE, MIN_LINE_HEIGHT_PX } from "../../shared/render.js";
+/**
+ * Mises à niveau appliquées à la lecture d'un fichier de design.
+ *
+ * Elles tournent avant la validation de schéma et sont idempotentes : un design
+ * déjà à jour ressort inchangé, et le fichier n'est réécrit que si quelque chose
+ * a bougé.
+ */
+/**
+ * `lineHeight` a d'abord été stocké comme un multiplicateur de `fontSize`
+ * (1.35), puis est passé en pixels — la seule unité que les agents emploient
+ * spontanément, et la seule cohérente avec x, y et fontSize.
+ *
+ * Une valeur sous MIN_LINE_HEIGHT_PX est donc forcément un ancien ratio : on la
+ * reconvertit en la multipliant par la taille de police du noeud.
+ */
+export function migrateNode(node) {
+    const lineHeight = node.lineHeight;
+    if (typeof lineHeight !== "number" || !(lineHeight > 0) || lineHeight >= MIN_LINE_HEIGHT_PX)
+        return node;
+    const fontSize = typeof node.fontSize === "number" && node.fontSize > 0 ? node.fontSize : DEFAULT_FONT_SIZE;
+    return { ...node, lineHeight: Math.round(lineHeight * fontSize * 100) / 100 };
+}
+/** Applique la migration à un design brut. Retourne `null` si rien n'a changé. */
+export function migrateDesign(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const design = raw;
+    let changed = false;
+    const migrateList = (value) => {
+        if (!Array.isArray(value))
+            return value;
+        return value.map((entry) => {
+            if (!entry || typeof entry !== "object")
+                return entry;
+            const next = migrateNode(entry);
+            if (next !== entry)
+                changed = true;
+            return next;
+        });
+    };
+    const nodes = migrateList(design.nodes);
+    // La baseline sert de référence au diff : la laisser dans l'ancienne unité
+    // ferait apparaître un faux changement sur chaque texte.
+    const baseline = design.baseline;
+    const baselineNodes = baseline && typeof baseline === "object" ? migrateList(baseline.nodes) : undefined;
+    if (!changed)
+        return null;
+    return {
+        ...design,
+        nodes,
+        ...(baselineNodes === undefined ? {} : { baseline: { ...baseline, nodes: baselineNodes } }),
+    };
+}

package/dist/src/core/node-factory.d.ts

@@ -0,0 +1,19 @@
+import { type DesignNode } from "../../shared/schemas/design.schema.js";
+import { NODE_DEFAULTS } from "../../shared/node-defaults.js";
+export declare class DesignError extends Error {
+}
+export interface CreateNodeInput {
+    [key: string]: unknown;
+    type?: unknown;
+}
+/**
+ * Construit un noeud complet et valide à partir d'une entrée partielle d'agent :
+ * seul `type` est obligatoire, tout le reste vient des valeurs par défaut, ce qui
+ * évite les noeuds invisibles (taille nulle, pas de remplissage).
+ *
+ * `existingIds` empêche une collision d'identifiants fournis explicitement.
+ */
+export declare function buildNode(input: CreateNodeInput, existingIds: Set<string>, index: number): DesignNode;
+/** Applique un patch partiel en ne conservant que les champs valides pour le type du noeud. */
+export declare function applyPatch(node: DesignNode, patch: Record<string, unknown>): DesignNode;
+export { NODE_DEFAULTS };