@imenam/mcp-design 1.0.10 → 1.0.12

package/dist/shared/render.js

@@ -6,7 +6,7 @@
  * Ce module ne dépend volontairement d'aucune librairie (pas de zod) pour rester
  * importable depuis le bundle GUI.
  */
-import { boundsOf, childrenByParent, computeLayout, normalizedBox, spaceOriginOf } from "./tree.js";
+import { boundsOf, boxesIntersect, childrenByParent, computeLayout, normalizedBox, spaceOriginOf, } from "./tree.js";
 import { expandInstances } from "./instances.js";
 import { DEFAULT_ICON_STROKE_WIDTH, ICON_GRID, UNKNOWN_ICON_ELEMENTS, iconElements, } from "./icons/index.js";
 // La géométrie de base vit dans tree.ts (module bas-niveau, sans dépendance vers
@@ -175,6 +175,22 @@ export function iconStyle(node) {
         "stroke-linejoin": "round",
     };
 }
+const IMAGE_ASPECT = {
+    cover: "xMidYMid slice",
+    contain: "xMidYMid meet",
+    fill: "none",
+};
+/** Valeur de `preserveAspectRatio` correspondant au `fit` du noeud. */
+export function imageAspect(node) {
+    return IMAGE_ASPECT[node.fit ?? "cover"];
+}
+/** Adresse de l'image du noeud ; echoue si l'appelant n'a pas dit comment la resoudre. */
+export function imageSource(node, options) {
+    if (!options.imageHref) {
+        throw new Error(`Node "${node.id}" is an image, but this render was given no way to resolve image files.`);
+    }
+    return options.imageHref(node.image ?? "");
+}
 function attributesToSvg(attributes) {
     return Object.entries(attributes)
         .map(([key, value]) => `${key}="${escapeXml(value)}"`)
@@ -188,7 +204,7 @@ export function iconElementToSvg([tag, attributes]) {
  * Un groupe ne produit rien par lui-meme : c'est un conteneur, rendu par
  * `documentToSvg` (serveur) ou par le canvas (navigateur).
  */
-export function nodeToSvg(node) {
+export function nodeToSvg(node, options = {}) {
     // Un groupe est un conteneur ; une instance n'atteint jamais le rendu, elle
     // est remplacee par un groupe en amont par `expandInstances`.
     if (node.type === "group" || node.type === "instance")
@@ -221,6 +237,11 @@ export function nodeToSvg(node) {
             const body = iconElementsOf(node).map(iconElementToSvg).join("");
             return `<g transform="${placement}" ${attributesToSvg(iconStyle(node))}${opacityAttr}>${body}</g>`;
         }
+        case "image": {
+            return (`<image x="${round(box.x)}" y="${round(box.y)}" width="${round(box.width)}" height="${round(box.height)}"` +
+                ` href="${escapeXml(imageSource(node, options))}" preserveAspectRatio="${imageAspect(node)}"` +
+                `${opacityAttr}${transformAttr} />`);
+        }
         case "text": {
             const m = textMetrics(node);
             const lines = textLines(node);
@@ -238,24 +259,31 @@ export function nodeToSvg(node) {
 /**
  * Rend une liste de noeuds frères, en descendant récursivement dans les groupes.
  * Partagé par le rendu plein document et le rendu cadré sur un seul élément.
+ *
+ * Avec `frame`, un élément semi-transparent qui ne recoupe pas le cadre est
+ * omis : il n'y serait pas visible, et resvg panique — en emportant le
+ * processus — sur un élément semi-transparent dessiné entièrement hors du cadre.
  */
-function renderSiblings(nodes, children, layout, depth) {
+function renderSiblings(nodes, children, layout, depth, options, frame) {
     const pad = "  ".repeat(depth + 1);
     return nodes.flatMap((node) => {
-        if (node.type !== "group")
-            return [`${pad}${nodeToSvg(node)}`];
         const bounds = boundsOf(layout, node.id);
+        if (frame && node.opacity < 1 && !boxesIntersect(bounds, frame))
+            return [];
+        if (node.type !== "group")
+            return [`${pad}${nodeToSvg(node, options)}`];
         const origin = layout.origin.get(node.id) ?? { x: 0, y: 0 };
         const center = { cx: bounds.x + bounds.width / 2 - origin.x, cy: bounds.y + bounds.height / 2 - origin.y };
         const opacity = node.opacity >= 1 ? "" : ` opacity="${round(node.opacity)}"`;
         return [
             `${pad}<g transform="${groupTransform(node, center)}"${opacity}>`,
-            ...renderSiblings(children.get(node.id) ?? [], children, layout, depth + 1),
+            ...renderSiblings(children.get(node.id) ?? [], children, layout, depth + 1, options, frame),
             `${pad}</g>`,
         ];
     });
 }
-export function documentToSvg(doc) {
+/** Contenu SVG de la planche, en coordonnées document, limité à `frame` s'il est donné. */
+function documentBody(doc, options, frame) {
     // Les instances sont resolues ici, une fois pour toutes : en dessous, il n'y
     // a plus que des groupes ordinaires.
     const nodes = expandInstances(doc.nodes);
@@ -263,13 +291,32 @@ export function documentToSvg(doc) {
     const children = childrenByParent(nodes);
     // Un groupe devient un <g> : ses enfants gardent leurs coordonnées locales,
     // c'est la transformation du conteneur qui les place.
-    const body = renderSiblings(children.get(null) ?? [], children, layout, 0).join("\n");
+    return renderSiblings(children.get(null) ?? [], children, layout, 0, options, frame).join("\n");
+}
+export function documentToSvg(doc, options = {}) {
+    const body = documentBody(doc, options);
     return (`<svg xmlns="http://www.w3.org/2000/svg" width="${doc.width}" height="${doc.height}" ` +
         `viewBox="0 0 ${doc.width} ${doc.height}">\n` +
         `  <rect x="0" y="0" width="${doc.width}" height="${doc.height}" fill="${escapeXml(doc.background)}" />\n` +
         (body ? `${body}\n` : "") +
         `</svg>`);
 }
+/**
+ * SVG cadré sur une zone rectangulaire de la planche, en coordonnées document.
+ * Tout ce qui recoupe la zone y figure, coupé à ses bords ; les éléments
+ * semi-transparents qui ne la recoupent pas sont omis.
+ */
+export function regionToSvg(doc, region, options = {}) {
+    const body = documentBody(doc, options, region);
+    const width = round(Math.max(1, region.width));
+    const height = round(Math.max(1, region.height));
+    return (`<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" ` +
+        `viewBox="${round(region.x)} ${round(region.y)} ${width} ${height}">\n` +
+        `  <rect x="${round(region.x)}" y="${round(region.y)}" width="${width}" height="${height}" ` +
+        `fill="${escapeXml(doc.background)}" />\n` +
+        (body ? `${body}\n` : "") +
+        `</svg>`);
+}
 /**
  * SVG cadré sur un seul élément — l'élément et son contenu, rien d'autre.
  *
@@ -277,7 +324,7 @@ export function documentToSvg(doc) {
  * position document : le viewBox peut alors être exprimé dans le même repère
  * que `computeLayout`, donc directement sur la boîte englobante de l'élément.
  */
-export function subtreeToSvg(doc, nodeId, padding = 0) {
+export function subtreeToSvg(doc, nodeId, padding = 0, options = {}) {
     const nodes = expandInstances(doc.nodes);
     const node = nodes.find((candidate) => candidate.id === nodeId);
     if (!node)
@@ -297,8 +344,8 @@ export function subtreeToSvg(doc, nodeId, padding = 0) {
     // noeud est rendu tel quel, dans le repère de son parent.
     const origin = node.type === "group" ? (layout.origin.get(nodeId) ?? { x: 0, y: 0 }) : spaceOriginOf(layout, node.parentId);
     const inner = node.type === "group"
-        ? renderSiblings([{ ...node, x: 0, y: 0 }], children, layout, 1).join("\n")
-        : `    ${nodeToSvg(node)}`;
+        ? renderSiblings([{ ...node, x: 0, y: 0 }], children, layout, 1, options).join("\n")
+        : `    ${nodeToSvg(node, options)}`;
     return (`<svg xmlns="http://www.w3.org/2000/svg" width="${round(region.width)}" height="${round(region.height)}" ` +
         `viewBox="${round(region.x)} ${round(region.y)} ${round(region.width)} ${round(region.height)}">\n` +
         `  <rect x="${round(region.x)}" y="${round(region.y)}" width="${round(region.width)}" ` +

package/dist/shared/schemas/design.schema.d.ts

@@ -14,11 +14,12 @@ import { z } from "zod";
  * stockage reste plat, donc diffable et lisible, tandis que les coordonnees
  * d'un noeud sont exprimees dans l'espace de son parent.
  */
-export declare const NODE_TYPES: readonly ["rect", "ellipse", "line", "text", "icon", "group", "instance"];
+export declare const NODE_TYPES: readonly ["rect", "ellipse", "line", "text", "icon", "image", "group", "instance"];
 export declare const NodeTypeSchema: z.ZodEnum<{
     ellipse: "ellipse";
     group: "group";
     icon: "icon";
+    image: "image";
     instance: "instance";
     line: "line";
     rect: "rect";
@@ -31,6 +32,12 @@ export declare const TextAlignSchema: z.ZodEnum<{
     left: "left";
     right: "right";
 }>;
+export declare const IMAGE_FITS: readonly ["cover", "contain", "fill"];
+export declare const ImageFitSchema: z.ZodEnum<{
+    contain: "contain";
+    cover: "cover";
+    fill: "fill";
+}>;
 /**
  * Un seul schéma pour tous les types de noeuds : les champs non pertinents pour
  * un type donné sont simplement absents. Un schéma discriminé obligerait l'agent
@@ -42,6 +49,7 @@ export declare const DesignNodeSchema: z.ZodObject<{
         ellipse: "ellipse";
         group: "group";
         icon: "icon";
+        image: "image";
         instance: "instance";
         line: "line";
         rect: "rect";
@@ -61,6 +69,12 @@ export declare const DesignNodeSchema: z.ZodObject<{
     strokeWidth: z.ZodOptional<z.ZodNumber>;
     radius: z.ZodOptional<z.ZodNumber>;
     icon: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodString>;
+    fit: z.ZodOptional<z.ZodEnum<{
+        contain: "contain";
+        cover: "cover";
+        fill: "fill";
+    }>>;
     text: z.ZodOptional<z.ZodString>;
     color: z.ZodOptional<z.ZodString>;
     fontSize: z.ZodOptional<z.ZodNumber>;
@@ -88,6 +102,7 @@ export declare const BaselineSchema: z.ZodObject<{
             ellipse: "ellipse";
             group: "group";
             icon: "icon";
+            image: "image";
             instance: "instance";
             line: "line";
             rect: "rect";
@@ -107,6 +122,12 @@ export declare const BaselineSchema: z.ZodObject<{
         strokeWidth: z.ZodOptional<z.ZodNumber>;
         radius: z.ZodOptional<z.ZodNumber>;
         icon: z.ZodOptional<z.ZodString>;
+        image: z.ZodOptional<z.ZodString>;
+        fit: z.ZodOptional<z.ZodEnum<{
+            contain: "contain";
+            cover: "cover";
+            fill: "fill";
+        }>>;
         text: z.ZodOptional<z.ZodString>;
         color: z.ZodOptional<z.ZodString>;
         fontSize: z.ZodOptional<z.ZodNumber>;
@@ -148,6 +169,7 @@ export declare const DesignSchema: z.ZodObject<{
             ellipse: "ellipse";
             group: "group";
             icon: "icon";
+            image: "image";
             instance: "instance";
             line: "line";
             rect: "rect";
@@ -167,6 +189,12 @@ export declare const DesignSchema: z.ZodObject<{
         strokeWidth: z.ZodOptional<z.ZodNumber>;
         radius: z.ZodOptional<z.ZodNumber>;
         icon: z.ZodOptional<z.ZodString>;
+        image: z.ZodOptional<z.ZodString>;
+        fit: z.ZodOptional<z.ZodEnum<{
+            contain: "contain";
+            cover: "cover";
+            fill: "fill";
+        }>>;
         text: z.ZodOptional<z.ZodString>;
         color: z.ZodOptional<z.ZodString>;
         fontSize: z.ZodOptional<z.ZodNumber>;
@@ -199,6 +227,7 @@ export declare const DesignSchema: z.ZodObject<{
                 ellipse: "ellipse";
                 group: "group";
                 icon: "icon";
+                image: "image";
                 instance: "instance";
                 line: "line";
                 rect: "rect";
@@ -218,6 +247,12 @@ export declare const DesignSchema: z.ZodObject<{
             strokeWidth: z.ZodOptional<z.ZodNumber>;
             radius: z.ZodOptional<z.ZodNumber>;
             icon: z.ZodOptional<z.ZodString>;
+            image: z.ZodOptional<z.ZodString>;
+            fit: z.ZodOptional<z.ZodEnum<{
+                contain: "contain";
+                cover: "cover";
+                fill: "fill";
+            }>>;
             text: z.ZodOptional<z.ZodString>;
             color: z.ZodOptional<z.ZodString>;
             fontSize: z.ZodOptional<z.ZodNumber>;

package/dist/shared/schemas/design.schema.js

@@ -16,10 +16,12 @@ import { NODE_FIELD_DOCS } from "../node-fields.js";
  * stockage reste plat, donc diffable et lisible, tandis que les coordonnees
  * d'un noeud sont exprimees dans l'espace de son parent.
  */
-export const NODE_TYPES = ["rect", "ellipse", "line", "text", "icon", "group", "instance"];
+export const NODE_TYPES = ["rect", "ellipse", "line", "text", "icon", "image", "group", "instance"];
 export const NodeTypeSchema = z.enum(NODE_TYPES);
 export const TEXT_ALIGNS = ["left", "center", "right"];
 export const TextAlignSchema = z.enum(TEXT_ALIGNS);
+export const IMAGE_FITS = ["cover", "contain", "fill"];
+export const ImageFitSchema = z.enum(IMAGE_FITS);
 /**
  * Un seul schéma pour tous les types de noeuds : les champs non pertinents pour
  * un type donné sont simplement absents. Un schéma discriminé obligerait l'agent
@@ -57,6 +59,13 @@ export const DesignNodeSchema = z.object({
      * se redessiner, et un agent qui relit le design sait ce qu'elle represente.
      */
     icon: z.string().describe(NODE_FIELD_DOCS.icon).optional(),
+    /**
+     * Image — le nom du fichier dans la mediatheque du dossier de donnees, jamais
+     * ses octets : le design reste un JSON lisible, et une meme image posee
+     * plusieurs fois n'est stockee qu'une fois.
+     */
+    image: z.string().describe(NODE_FIELD_DOCS.image).optional(),
+    fit: ImageFitSchema.describe(NODE_FIELD_DOCS.fit).optional(),
     // Texte — fontSize et lineHeight sont tous deux en PIXELS.
     text: z.string().describe(NODE_FIELD_DOCS.text).optional(),
     color: z.string().describe(NODE_FIELD_DOCS.color).optional(),

package/dist/shared/schemas/feedback.schema.d.ts

@@ -0,0 +1,191 @@
+import { z } from "zod";
+export declare const RemarkTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"page">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"node">;
+    element: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            ellipse: "ellipse";
+            group: "group";
+            icon: "icon";
+            image: "image";
+            instance: "instance";
+            line: "line";
+            rect: "rect";
+            text: "text";
+        }>;
+    }, z.core.$strip>;
+    path: z.ZodArray<z.ZodString>;
+    box: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"area">;
+    box: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>;
+    elements: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            ellipse: "ellipse";
+            group: "group";
+            icon: "icon";
+            image: "image";
+            instance: "instance";
+            line: "line";
+            rect: "rect";
+            text: "text";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "kind">;
+export declare const FeedbackFileSchema: z.ZodObject<{
+    version: z.ZodLiteral<2>;
+    remarks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        designId: z.ZodString;
+        number: z.ZodNullable<z.ZodNumber>;
+        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"page">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"node">;
+            element: z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                type: z.ZodEnum<{
+                    ellipse: "ellipse";
+                    group: "group";
+                    icon: "icon";
+                    image: "image";
+                    instance: "instance";
+                    line: "line";
+                    rect: "rect";
+                    text: "text";
+                }>;
+            }, z.core.$strip>;
+            path: z.ZodArray<z.ZodString>;
+            box: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"area">;
+            box: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>;
+            elements: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                type: z.ZodEnum<{
+                    ellipse: "ellipse";
+                    group: "group";
+                    icon: "icon";
+                    image: "image";
+                    instance: "instance";
+                    line: "line";
+                    rect: "rect";
+                    text: "text";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>], "kind">;
+        text: z.ZodString;
+        capture: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            draft: "draft";
+            sent: "sent";
+        }>;
+        round: z.ZodNullable<z.ZodNumber>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    rounds: z.ZodArray<z.ZodObject<{
+        number: z.ZodNumber;
+        title: z.ZodString;
+        submittedAt: z.ZodString;
+        remarks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            designId: z.ZodString;
+            designName: z.ZodString;
+            number: z.ZodNullable<z.ZodNumber>;
+            target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"page">;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"node">;
+                element: z.ZodObject<{
+                    id: z.ZodString;
+                    name: z.ZodString;
+                    type: z.ZodEnum<{
+                        ellipse: "ellipse";
+                        group: "group";
+                        icon: "icon";
+                        image: "image";
+                        instance: "instance";
+                        line: "line";
+                        rect: "rect";
+                        text: "text";
+                    }>;
+                }, z.core.$strip>;
+                path: z.ZodArray<z.ZodString>;
+                box: z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    width: z.ZodNumber;
+                    height: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"area">;
+                box: z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    width: z.ZodNumber;
+                    height: z.ZodNumber;
+                }, z.core.$strip>;
+                elements: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    name: z.ZodString;
+                    type: z.ZodEnum<{
+                        ellipse: "ellipse";
+                        group: "group";
+                        icon: "icon";
+                        image: "image";
+                        instance: "instance";
+                        line: "line";
+                        rect: "rect";
+                        text: "text";
+                    }>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>], "kind">;
+            text: z.ZodString;
+            capture: z.ZodNullable<z.ZodString>;
+            processed: z.ZodNullable<z.ZodObject<{
+                at: z.ZodString;
+                by: z.ZodEnum<{
+                    agent: "agent";
+                    user: "user";
+                }>;
+                note: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    lastNumbers: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+export type FeedbackFile = z.infer<typeof FeedbackFileSchema>;
+/**
+ * Met un fichier de version 1 au format courant : chaque retour reçoit le nom
+ * proposé par défaut, et aucune remarque n'est encore traitée. Renvoie null
+ * pour un fichier qui n'est pas en version 1.
+ */
+export declare function migrateFeedbackFile(raw: unknown, defaultTitle: (number: number) => string): unknown | null;

package/dist/shared/schemas/feedback.schema.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { NODE_TYPES } from "./design.schema.js";
+/**
+ * Fichier des remarques : `<dataDir>/feedback/remarks.json`.
+ *
+ * Il tient les remarques en cours (brouillons et transmises) et la liste des
+ * retours transmis, chacun figé au moment de l'envoi, hormis le suivi de son
+ * traitement. Les types TypeScript vivent dans `shared/feedback.ts`,
+ * importable par la GUI sans zod.
+ */
+const BoxSchema = z.object({ x: z.number(), y: z.number(), width: z.number(), height: z.number() });
+const RemarkElementSchema = z.object({ id: z.string(), name: z.string(), type: z.enum(NODE_TYPES) });
+export const RemarkTargetSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("page") }),
+    z.object({ kind: z.literal("node"), element: RemarkElementSchema, path: z.array(z.string()), box: BoxSchema }),
+    z.object({ kind: z.literal("area"), box: BoxSchema, elements: z.array(RemarkElementSchema) }),
+]);
+const RemarkSchema = z.object({
+    id: z.string(),
+    designId: z.string(),
+    number: z.number().int().positive().nullable(),
+    target: RemarkTargetSchema,
+    text: z.string().min(1),
+    capture: z.string().nullable(),
+    status: z.enum(["draft", "sent"]),
+    round: z.number().int().positive().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+const RemarkProcessingSchema = z.object({
+    at: z.string(),
+    by: z.enum(["agent", "user"]),
+    note: z.string().nullable(),
+});
+const RoundRemarkSchema = z.object({
+    id: z.string(),
+    designId: z.string(),
+    designName: z.string(),
+    number: z.number().int().positive().nullable(),
+    target: RemarkTargetSchema,
+    text: z.string().min(1),
+    capture: z.string().nullable(),
+    processed: RemarkProcessingSchema.nullable(),
+});
+const FeedbackRoundSchema = z.object({
+    number: z.number().int().positive(),
+    title: z.string().min(1),
+    submittedAt: z.string(),
+    remarks: z.array(RoundRemarkSchema),
+});
+export const FeedbackFileSchema = z.object({
+    version: z.literal(2),
+    remarks: z.array(RemarkSchema),
+    rounds: z.array(FeedbackRoundSchema),
+    /** Dernier numéro de pastille attribué par design : un numéro supprimé n'est jamais réutilisé. */
+    lastNumbers: z.record(z.string(), z.number().int().nonnegative()),
+});
+/** Version 1 : des retours sans nom, et des remarques sans suivi de traitement. */
+const FeedbackFileV1Schema = z.object({
+    version: z.literal(1),
+    remarks: z.array(RemarkSchema),
+    rounds: z.array(z.object({
+        number: z.number().int().positive(),
+        submittedAt: z.string(),
+        remarks: z.array(RoundRemarkSchema.omit({ processed: true })),
+    })),
+    lastNumbers: z.record(z.string(), z.number().int().nonnegative()),
+});
+/**
+ * Met un fichier de version 1 au format courant : chaque retour reçoit le nom
+ * proposé par défaut, et aucune remarque n'est encore traitée. Renvoie null
+ * pour un fichier qui n'est pas en version 1.
+ */
+export function migrateFeedbackFile(raw, defaultTitle) {
+    const v1 = FeedbackFileV1Schema.safeParse(raw);
+    if (!v1.success)
+        return null;
+    return {
+        ...v1.data,
+        version: 2,
+        rounds: v1.data.rounds.map((round) => ({
+            ...round,
+            title: defaultTitle(round.number),
+            remarks: round.remarks.map((remark) => ({ ...remark, processed: null })),
+        })),
+    };
+}

package/dist/shared/tree.d.ts

@@ -66,6 +66,8 @@ export declare function computeLayout(nodes: RenderNode[]): Layout;
 /** Origine de l'espace de coordonnées dans lequel vit un élément. */
 export declare function spaceOriginOf(layout: Layout, parentId: string | null): Point;
 export declare function boundsOf(layout: Layout, id: string): Box;
+/** Vrai si les deux boîtes ont une surface commune ; un simple contact ne compte pas. */
+export declare function boxesIntersect(a: Box, b: Box): boolean;
 /** Boîte englobante commune à plusieurs éléments, en coordonnées document. */
 export declare function unionBoundsOf(layout: Layout, ids: string[]): Box | null;
 export declare const REORDER_DIRECTIONS: readonly ["front", "back", "forward", "backward"];

package/dist/shared/tree.js

@@ -140,6 +140,10 @@ export function spaceOriginOf(layout, parentId) {
 export function boundsOf(layout, id) {
     return layout.bounds.get(id) ?? { x: 0, y: 0, width: 0, height: 0 };
 }
+/** Vrai si les deux boîtes ont une surface commune ; un simple contact ne compte pas. */
+export function boxesIntersect(a, b) {
+    return a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
+}
 /** Boîte englobante commune à plusieurs éléments, en coordonnées document. */
 export function unionBoundsOf(layout, ids) {
     return unionBox(ids.map((id) => layout.bounds.get(id)).filter((box) => box !== undefined));

package/dist/src/core/design-store.d.ts

@@ -1,4 +1,5 @@
 import { type Design, type DesignSummary } from "../../shared/schemas/design.schema.js";
+import { ImageStore } from "./image-store.js";
 export interface CreateDesignInput {
     name: string;
     width?: number;
@@ -24,6 +25,8 @@ export interface MutateOptions {
 export declare class DesignStore {
     private readonly dataDir;
     private readonly designsDir;
+    /** Images posées sur les planches, partagées par tous les designs du dossier de données. */
+    readonly images: ImageStore;
     /**
      * Cache mémoire : la GUI sauvegarde à chaque geste, relire le disque à chaque
      * fois serait inutile. Chaque entrée retient la signature du fichier au moment
@@ -38,11 +41,7 @@ export declare class DesignStore {
     private stampOf;
     private remember;
     private write;
-    /**
-     * Sérialise le cycle lire-modifier-écrire entre processus. `wx` échoue si le
-     * fichier existe déjà : c'est l'opération atomique qui départage deux
-     * écrivains concurrents. Non réentrant — ne jamais appeler depuis `fn`.
-     */
+    /** Verrou inter-processus du fichier d'un design. Non réentrant — ne jamais appeler depuis `fn`. */
     private withLock;
     /** Identifiant lisible dérivé du nom, suffixé seulement en cas de collision. */
     private allocateId;