@formicoidea/labre-framework-edgy 0.37.0 → 0.38.2

package/dist/actions.d.ts

@@ -1,6 +1,6 @@
 import type { BlockStdScope } from '@formicoidea/labre-core/std';
 import { type GfxController } from '@formicoidea/labre-core/std/gfx';
-export type EdgyBoxKind = 'outcome' | 'object' | 'activity';
+import { type EdgyBoxKind } from './presets.js';
 /**
  * Create the Enterprise Design Facets diagram centred on the viewport —
  * cropped to the circles + facet labels (no dead margins around the Venn).

package/dist/actions.js

@@ -2,23 +2,26 @@ import { DefaultTool } from '@formicoidea/labre-core/blocks/surface';
 import { ConnectorTool } from '@formicoidea/labre-core/gfx/connector';
 import { createGroupCommand } from '@formicoidea/labre-core/gfx/group';
 import { createTemplateJob } from '@formicoidea/labre-core/gfx/template';
-import { ConnectorMode, FontFamily, PointStyle, ShapeStyle, StrokeStyle, } from '@formicoidea/labre-core/model';
+import { ConnectorMode, PointStyle, StrokeStyle } from '@formicoidea/labre-core/model';
 import { translateKey } from '@formicoidea/labre-core/shared/services';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
 import { GfxControllerIdentifier } from '@formicoidea/labre-core/std/gfx';
 import { CROP_LABELED } from './consts.js';
-import { ACTIVITY_VERTICES, INNER_FONT_SIZE, LABEL_FONT_SIZE, LABEL_GAP, NODE_FILL, NODE_LABEL, nodeLabelKey, NODE_SIZE, NODE_STROKE, NODE_STROKE_WIDTH, OUTCOME_RADIUS, } from './node/consts.js';
+import { LABEL_GAP, NODE_LABEL, nodeLabelKey, NODE_SIZE, NODE_STROKE, } from './node/consts.js';
+import { EDGY_LABEL_W, edgyLabelProps, edgyNodeProps, edgyNodeTextProps, FACETS_SCALE, } from './presets.js';
 import { EDGY_ROLE } from './roles.js';
-import { edgyDynamicTemplate } from './templates/index.js';
+import { edgyDynamicTemplate } from './templates/dynamic.js';
 /** Stroke width the 24 template relations are drawn with. */
 const RELATION_STROKE_WIDTH = 2;
-/** Default facets-diagram size (REF aspect, scaled up so it reads on canvas). */
-const FACETS_SCALE = 1.5;
+/**
+ * Standalone creation actions for the EDGY toolbox — the behaviour layer,
+ * lifted out of `toolbar/edgy-menu.ts` by PF3 so the menu can become a pure
+ * renderer over the command registry. They emit no telemetry: the single
+ * emission point is `runCommand` (`docs/adr/0008`).
+ */
 /** Default blank-board size. */
 const BOARD_W = 1600;
 const BOARD_H = 1000;
-/** Height of the native People free-text label. */
-const LABEL_H = LABEL_FONT_SIZE + 8;
 const gfxOf = (std) => std.get(GfxControllerIdentifier);
 function finish(gfx, id) {
     gfx.doc.captureSync();
@@ -26,38 +29,6 @@ function finish(gfx, id) {
     gfx.selection.set({ elements: [id], editing: false });
     // Keep the palette open (native sub-menu behaviour).
 }
-/**
- * Shared props for an EDGY node shape.
- *
- * The `role` is the PERSISTED KIND and nothing more: somebody picking "Object"
- * in the palette has said "this is an object", not "this is a Channel". The
- * twelve official elements are named by the metamodel template, which knows
- * which of them it is drawing; a base element created here specialises
- * `edgy:element` through its kind and is judged by every rule written on the
- * root — the overlap rule — and by none written on a leaf.
- */
-const baseShapeProps = (kind) => ({
-    type: 'edgyNode',
-    kind,
-    role: EDGY_ROLE[kind],
-    filled: true,
-    fillColor: NODE_FILL,
-    strokeColor: NODE_STROKE,
-    shapeStyle: ShapeStyle.General,
-    roughness: 0,
-});
-/** Add a native free-text label (Inter), used for the People node. */
-function addLabel(surface, text, x, y) {
-    return surface.addElement({
-        type: 'text',
-        text,
-        fontFamily: FontFamily.Inter,
-        fontSize: LABEL_FONT_SIZE,
-        color: NODE_STROKE,
-        textAlign: 'center',
-        xywh: new Bound(x, y, 120, LABEL_H).serialize(),
-    });
-}
 /**
  * Create the Enterprise Design Facets diagram centred on the viewport —
  * cropped to the circles + facet labels (no dead margins around the Venn).
@@ -119,21 +90,13 @@ export function createEdgyBox(std, kind) {
         return;
     const { w, h } = NODE_SIZE[kind];
     const { centerX: cx, centerY: cy } = gfx.viewport;
-    const shapeType = kind === 'activity' ? 'polygon' : 'rect';
     const id = surface.addElement({
-        ...baseShapeProps(kind),
-        shapeType,
-        strokeWidth: NODE_STROKE_WIDTH,
-        radius: kind === 'outcome' ? OUTCOME_RADIUS : 0,
-        vertices: kind === 'activity' ? ACTIVITY_VERTICES : null,
+        ...edgyNodeProps(kind, {
+            xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
+        }),
         // Translated HERE and once: what a gesture writes onto the canvas is
         // document content the moment it lands (`nodeLabelKey`).
-        text: translateKey(std, nodeLabelKey(kind), NODE_LABEL[kind]),
-        color: NODE_STROKE,
-        fontFamily: FontFamily.Inter,
-        fontSize: INNER_FONT_SIZE,
-        textAlign: 'center',
-        xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
+        ...edgyNodeTextProps(translateKey(std, nodeLabelKey(kind), NODE_LABEL[kind])),
     });
     finish(gfx, id);
 }
@@ -148,14 +111,10 @@ export function createEdgyPeople(std) {
         return;
     const { w, h } = NODE_SIZE.people;
     const { centerX: cx, centerY: cy } = gfx.viewport;
-    const nodeId = surface.addElement({
-        ...baseShapeProps('people'),
-        shapeType: 'ellipse',
-        // No visible outline — People is just the glyph; the ellipse is the bound.
-        strokeWidth: 0,
+    const nodeId = surface.addElement(edgyNodeProps('people', {
         xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
-    });
-    const labelId = addLabel(surface, translateKey(std, nodeLabelKey('people'), NODE_LABEL.people), cx - 60, cy + h / 2 + LABEL_GAP);
+    }));
+    const labelId = surface.addElement(edgyLabelProps(translateKey(std, nodeLabelKey('people'), NODE_LABEL.people), cx - EDGY_LABEL_W / 2, cy + h / 2 + LABEL_GAP));
     const [, result] = std.command.exec(createGroupCommand, {
         elements: [nodeId, labelId],
     });

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export { edgyCommandIcons, edgyCommands } from './commands.js';
 export { edgyTranslationEntries } from './translations.js';
 export { EDGY_ROLE, EDGY_ROLES, type EdgyRoleId } from './roles.js';
 export { EDGY_READING } from './reading.js';
+export { EDGY_RULES } from './rules.js';

package/dist/index.js

@@ -4,3 +4,4 @@ export { edgyTranslationEntries } from './translations.js';
 // library's own cross-framework guard test — can read without an editor.
 export { EDGY_ROLE, EDGY_ROLES } from './roles.js';
 export { EDGY_READING } from './reading.js';
+export { EDGY_RULES } from './rules.js';

package/dist/presets.d.ts

@@ -0,0 +1,69 @@
+import { type EdgyNodeKind, FontFamily, TextAlign } from '@formicoidea/labre-core/model';
+/**
+ * What an EDGY artefact IS, as props — the ONE description the creation sites
+ * and the templates both read.
+ *
+ * Split out of `actions.ts` for the reason Wardley's and BPMN's `presets.ts`
+ * give, and which the 2026-09-09 template audit measured on this pack: the
+ * palette restated by hand what a node is, and the copy drifted. The four
+ * single-element templates had lost the `role` the toolbox has written since
+ * the EDGY roles landed (so `edgy.overlapping-artefacts` saw nothing, the auto
+ * legend legended nothing and the info panel would not open), People arrived
+ * ungrouped from its name, and the label box was 16/24/+70 against the
+ * toolbox's 18/26/+72. Those templates are DERIVED now
+ * (`templateFromCommand`), and the compositions that cannot derive are built
+ * on the helpers below — so there is nothing left to restate.
+ */
+/** The three kinds the palette drops as a labelled box (People is not one). */
+export type EdgyBoxKind = 'outcome' | 'object' | 'activity';
+/**
+ * Default facets-diagram size (REF aspect, scaled up so it reads on canvas).
+ *
+ * Here rather than at the creation site because the "Facets diagram" template
+ * used to spell the same `1.5` out a second time.
+ */
+export declare const FACETS_SCALE = 1.5;
+/**
+ * An EDGY node, as props.
+ *
+ * The `role` is the PERSISTED KIND and nothing more: somebody picking "Object"
+ * in the palette has said "this is an object", not "this is a Channel". The
+ * twelve official elements are named by the metamodel template, which knows
+ * which of them it is drawing; a base element created here specialises
+ * `edgy:element` through its kind and is judged by every rule written on the
+ * root — the overlap rule — and by none written on a leaf.
+ *
+ * No `text`: the inner words are content, added by the caller through
+ * {@link edgyNodeTextProps} (at placement, translated once) or overridden by an
+ * illustrative template.
+ */
+export declare function edgyNodeProps(kind: EdgyNodeKind, box: {
+    xywh: string;
+}): Record<string, unknown> & {
+    type: string;
+};
+/**
+ * The words INSIDE a box, as props.
+ *
+ * `text` is a plain STRING, as `Surface.addElement` takes it; a snapshot writes
+ * the same field as a serialized `Y.Text`, which is the one key a hand-written
+ * template overrides on the way in.
+ */
+export declare function edgyNodeTextProps(text: string, fontSize?: number): {
+    text: string;
+    color: string;
+    fontFamily: FontFamily;
+    fontSize: number;
+    textAlign: TextAlign;
+};
+/** Width of the free-text label a People node travels with. */
+export declare const EDGY_LABEL_W = 120;
+/** Height of that label (Inter, size 18). */
+export declare const EDGY_LABEL_H: number;
+/**
+ * The NAME under a People node, as a native free-text element — the one EDGY
+ * artefact whose name is not stored on the shape itself.
+ */
+export declare function edgyLabelProps(text: string, x: number, y: number): Record<string, unknown> & {
+    type: string;
+};

package/dist/presets.js

@@ -0,0 +1,86 @@
+import { FontFamily, ShapeStyle, TextAlign, } from '@formicoidea/labre-core/model';
+import { Bound } from '@formicoidea/labre-core/global/gfx';
+import { ACTIVITY_VERTICES, INNER_FONT_SIZE, LABEL_FONT_SIZE, NODE_FILL, NODE_STROKE, NODE_STROKE_WIDTH, OUTCOME_RADIUS, } from './node/consts.js';
+import { EDGY_ROLE } from './roles.js';
+/**
+ * Default facets-diagram size (REF aspect, scaled up so it reads on canvas).
+ *
+ * Here rather than at the creation site because the "Facets diagram" template
+ * used to spell the same `1.5` out a second time.
+ */
+export const FACETS_SCALE = 1.5;
+/**
+ * An EDGY node, as props.
+ *
+ * The `role` is the PERSISTED KIND and nothing more: somebody picking "Object"
+ * in the palette has said "this is an object", not "this is a Channel". The
+ * twelve official elements are named by the metamodel template, which knows
+ * which of them it is drawing; a base element created here specialises
+ * `edgy:element` through its kind and is judged by every rule written on the
+ * root — the overlap rule — and by none written on a leaf.
+ *
+ * No `text`: the inner words are content, added by the caller through
+ * {@link edgyNodeTextProps} (at placement, translated once) or overridden by an
+ * illustrative template.
+ */
+export function edgyNodeProps(kind, box) {
+    const people = kind === 'people';
+    return {
+        type: 'edgyNode',
+        kind,
+        role: EDGY_ROLE[kind],
+        filled: true,
+        fillColor: NODE_FILL,
+        strokeColor: NODE_STROKE,
+        shapeStyle: ShapeStyle.General,
+        roughness: 0,
+        shapeType: people ? 'ellipse' : kind === 'activity' ? 'polygon' : 'rect',
+        // No visible outline on People — it IS the glyph the renderer draws, and
+        // the ellipse is only its bound.
+        strokeWidth: people ? 0 : NODE_STROKE_WIDTH,
+        // The two keys only a BOX has: People carries neither, and a key some
+        // kinds write and others do not is the truth about the shapes.
+        ...(people
+            ? {}
+            : {
+                radius: kind === 'outcome' ? OUTCOME_RADIUS : 0,
+                vertices: kind === 'activity' ? ACTIVITY_VERTICES : null,
+            }),
+        xywh: box.xywh,
+    };
+}
+/**
+ * The words INSIDE a box, as props.
+ *
+ * `text` is a plain STRING, as `Surface.addElement` takes it; a snapshot writes
+ * the same field as a serialized `Y.Text`, which is the one key a hand-written
+ * template overrides on the way in.
+ */
+export function edgyNodeTextProps(text, fontSize = INNER_FONT_SIZE) {
+    return {
+        text,
+        color: NODE_STROKE,
+        fontFamily: FontFamily.Inter,
+        fontSize,
+        textAlign: TextAlign.Center,
+    };
+}
+/** Width of the free-text label a People node travels with. */
+export const EDGY_LABEL_W = 120;
+/** Height of that label (Inter, size 18). */
+export const EDGY_LABEL_H = LABEL_FONT_SIZE + 8;
+/**
+ * The NAME under a People node, as a native free-text element — the one EDGY
+ * artefact whose name is not stored on the shape itself.
+ */
+export function edgyLabelProps(text, x, y) {
+    return {
+        type: 'text',
+        text,
+        fontFamily: FontFamily.Inter,
+        fontSize: LABEL_FONT_SIZE,
+        color: NODE_STROKE,
+        textAlign: TextAlign.Center,
+        xywh: new Bound(x, y, EDGY_LABEL_W, EDGY_LABEL_H).serialize(),
+    };
+}

package/dist/templates/dynamic.d.ts

@@ -0,0 +1,26 @@
+import { type Template } from '@formicoidea/labre-core/gfx/template';
+/**
+ * The "EDGY dynamic" template — the relational metamodel drawn on the facets
+ * background, and the ONE template of this pack that cannot be derived from
+ * its command: `edgy.insertDynamic` INSERTS this very object
+ * (`createEdgyDynamic`), so deriving it from itself would be circular.
+ *
+ * Its own module for exactly that reason: `actions.ts` needs the template,
+ * `templates/index.ts` needs the command registry to derive the rest of the
+ * palette, and a single templates module would close the loop
+ * templates → commands → actions → templates.
+ */
+/**
+ * Background scale (from REF coords to model coords): large enough that the
+ * default-size nodes breathe inside each zone. The background is cropped to
+ * the circles (`cropToCircles`), so its xywh covers CROP × DYN_SCALE.
+ */
+export declare const DYN_SCALE = 4.8;
+/**
+ * Reference coords → template model coords: the background element sits at
+ * (0,0) and renders the cropped circles box, so a reference point maps to
+ * `(p - CROP.origin) × DYN_SCALE`.
+ */
+export declare function dynToModel(refX: number, refY: number): [number, number];
+/** Exported for direct insertion from the EDGY senior toolbar menu. */
+export declare const edgyDynamicTemplate: Template;

package/dist/templates/dynamic.js

@@ -0,0 +1,106 @@
+import { makeTemplateSnapshot, surfaceText, } from '@formicoidea/labre-core/gfx/template';
+import { ConnectorMode, PointStyle, StrokeStyle } from '@formicoidea/labre-core/model';
+import { CROP } from '../consts.js';
+import { EDGY_DYNAMIC_NODES, EDGY_DYNAMIC_RELATIONS, EDGY_ZONE_FILL, edgyElementLabel, } from '../metamodel.js';
+import { NODE_SIZE, NODE_STROKE } from '../node/consts.js';
+import { edgyNodeProps, edgyNodeTextProps } from '../presets.js';
+import { EDGY_RELATION_LABEL_DISTANCE, edgyVerbLabelXYWH } from '../relation.js';
+import { EDGY_ROLE, EDGY_VERB_ROLE } from '../roles.js';
+/**
+ * The "EDGY dynamic" template — the relational metamodel drawn on the facets
+ * background, and the ONE template of this pack that cannot be derived from
+ * its command: `edgy.insertDynamic` INSERTS this very object
+ * (`createEdgyDynamic`), so deriving it from itself would be circular.
+ *
+ * Its own module for exactly that reason: `actions.ts` needs the template,
+ * `templates/index.ts` needs the command registry to derive the rest of the
+ * palette, and a single templates module would close the loop
+ * templates → commands → actions → templates.
+ */
+/**
+ * Background scale (from REF coords to model coords): large enough that the
+ * default-size nodes breathe inside each zone. The background is cropped to
+ * the circles (`cropToCircles`), so its xywh covers CROP × DYN_SCALE.
+ */
+export const DYN_SCALE = 4.8;
+/**
+ * Reference coords → template model coords: the background element sits at
+ * (0,0) and renders the cropped circles box, so a reference point maps to
+ * `(p - CROP.origin) × DYN_SCALE`.
+ */
+export function dynToModel(refX, refY) {
+    return [(refX - CROP.x) * DYN_SCALE, (refY - CROP.y) * DYN_SCALE];
+}
+function dynamic() {
+    const out = {
+        bg: {
+            type: 'edgy',
+            showLabels: false,
+            showPictos: false,
+            cropToCircles: true,
+            // The frame a finding is attributed to. Stamped here and nowhere else in
+            // this template: the background is what makes the board an EDGY board.
+            role: EDGY_ROLE.facets,
+            xywh: `[0,0,${CROP.w * DYN_SCALE},${CROP.h * DYN_SCALE}]`,
+        },
+    };
+    for (const [key, { kind, cx, cy, w, zone }] of Object.entries(EDGY_DYNAMIC_NODES)) {
+        const nw = w ?? NODE_SIZE[kind].w;
+        const nh = NODE_SIZE[kind].h;
+        const [mx, my] = dynToModel(cx, cy);
+        const name = edgyElementLabel(key);
+        out[key] = {
+            // What an EDGY node IS — the same description the toolbox draws from.
+            ...edgyNodeProps(kind, {
+                xywh: `[${mx - nw / 2},${my - nh / 2},${nw},${nh}]`,
+            }),
+            ...edgyNodeTextProps(name),
+            // A snapshot stores the words as a serialized `Y.Text`, where
+            // `addElement` takes a plain string.
+            text: surfaceText(name),
+            fillColor: EDGY_ZONE_FILL[zone],
+            // The OFFICIAL element, not just its kind: this template IS the
+            // metamodel, so its Purpose is a Purpose and not merely an outcome.
+            role: EDGY_ROLE[key],
+        };
+    }
+    EDGY_DYNAMIC_RELATIONS.forEach(([src, dst, verb, t], i) => {
+        out[`rel${i}`] = {
+            type: 'connector',
+            mode: ConnectorMode.Straight,
+            stroke: NODE_STROKE,
+            strokeWidth: 2,
+            strokeStyle: StrokeStyle.Solid,
+            frontEndpointStyle: PointStyle.None,
+            rearEndpointStyle: PointStyle.None,
+            source: { id: src },
+            target: { id: dst },
+            // The verb, as a ROLE — one per canonical verb, derived from this very
+            // table (`../roles.ts`). Source is the subject and target the object
+            // (`docs/adr/0010` tier 1), which is exactly how the row above reads, so
+            // `edgy.non-canonical-link` finds all 24 of these sentences legal.
+            role: EDGY_VERB_ROLE[verb],
+            // Native connector label: the verb travels with the link. The x/y are
+            // re-centred on the path at the first layout, but the w/h ARE the label
+            // box — size it to the verb so the text lays out on one line. The
+            // distance slides the verb along the link like the reference diagram.
+            text: surfaceText(verb),
+            labelXYWH: edgyVerbLabelXYWH(verb),
+            labelOffset: { distance: t ?? EDGY_RELATION_LABEL_DISTANCE },
+        };
+    });
+    return out;
+}
+const NAME = 'EDGY dynamic';
+/** Exported for direct insertion from the EDGY senior toolbar menu. */
+export const edgyDynamicTemplate = {
+    name: NAME,
+    type: 'template',
+    preview: `<svg width="100%" height="100%" viewBox="0 0 135 80" xmlns="http://www.w3.org/2000/svg"><circle cx="55" cy="34" r="18" fill="#00ea4e" opacity="0.9"/><circle cx="80" cy="34" r="18" fill="#034cee" opacity="0.9"/><circle cx="67" cy="54" r="18" fill="#ff0056" opacity="0.9"/><path d="M55 30 H80 M56 31 L66 52 M79 31 L69 52" stroke="#fff" stroke-width="2"/><rect x="51" y="26" width="8" height="8" fill="#fff"/><circle cx="80" cy="30" r="4" fill="#fff"/><path d="M62 49 h6 l3 3 -3 3 h-6 z" fill="#fff"/></svg>`,
+    // Stamped by hand, and it is the one `commandId` in this pack that is a
+    // literal rather than a derivation: importing the registry here would close
+    // the very loop this module exists to avoid. The coverage test pairs the two
+    // and fails the day the command is renamed.
+    commandId: 'edgy.insertDynamic',
+    content: makeTemplateSnapshot(dynamic(), NAME),
+};

package/dist/templates/index.d.ts

@@ -1,23 +1,10 @@
-import { type Template, type TemplateCategory } from '@formicoidea/labre-core/gfx/template';
+import { type TemplateCategory } from '@formicoidea/labre-core/gfx/template';
 /**
- * Background scale (from REF coords to model coords): large enough that the
- * default-size nodes breathe inside each zone. The background is cropped to
- * the circles (`cropToCircles`), so its xywh covers CROP × DYN_SCALE.
- */
-export declare const DYN_SCALE = 4.8;
-/**
- * The metamodel itself — the 12 elements and the 24 relations — now lives in
- * `../metamodel.ts`, so the role vocabulary can DERIVE from it without this
- * module and that one importing each other. Re-exported here under the names
- * they have always had: nothing that reads them had to change.
+ * The metamodel itself — the 12 elements and the 24 relations — lives in
+ * `../metamodel.ts`, and the template that draws it in `./dynamic.ts`.
+ * Re-exported here under the names they have always had: nothing that reads
+ * them had to change.
  */
 export { EDGY_DYNAMIC_NODES, EDGY_DYNAMIC_RELATIONS, type EdgyElementName, } from '../metamodel.js';
-/**
- * Reference coords → template model coords: the background element sits at
- * (0,0) and renders the cropped circles box, so a reference point maps to
- * `(p - CROP.origin) × DYN_SCALE`.
- */
-export declare function dynToModel(refX: number, refY: number): [number, number];
-/** Exported for direct insertion from the EDGY senior toolbar menu. */
-export declare const edgyDynamicTemplate: Template;
+export { DYN_SCALE, dynToModel, edgyDynamicTemplate } from './dynamic.js';
 export declare const edgyTemplateCategory: TemplateCategory;

package/dist/templates/index.js

@@ -1,11 +1,41 @@
-import { makeTemplateSnapshot, surfaceText, } from '@formicoidea/labre-core/gfx/template';
+import { makeTemplateSnapshot, surfaceText, surfaceYMap, templateFromCommand, } from '@formicoidea/labre-core/gfx/template';
 import { ConnectorMode, FontFamily, PointStyle, ShapeStyle, StrokeStyle, TextAlign, } from '@formicoidea/labre-core/model';
-import { CROP, CROP_LABELED } from '../consts.js';
-import { EDGY_DYNAMIC_NODES, EDGY_DYNAMIC_RELATIONS, EDGY_ZONE_FILL, edgyElementLabel, } from '../metamodel.js';
-import { EDGY_RELATION_LABEL_DISTANCE, edgyVerbLabelXYWH } from '../relation.js';
-import { EDGY_ROLE, EDGY_VERB_ROLE } from '../roles.js';
-import { ACTIVITY_VERTICES, INNER_FONT_SIZE, NODE_FILL, NODE_SIZE, NODE_STROKE, NODE_STROKE_WIDTH, OUTCOME_RADIUS, } from '../node/consts.js';
+import { edgyCommands } from '../commands.js';
+import { NODE_STROKE, NODE_STROKE_WIDTH } from '../node/consts.js';
+import { edgyNodeProps, edgyNodeTextProps } from '../presets.js';
+import { edgyDynamicTemplate } from './dynamic.js';
+/**
+ * The EDGY palette — DERIVED from the toolbox, one template per command.
+ *
+ * Every single-artefact entry below is what its command actually draws, run
+ * once against a recording surface. They used to be hand-written restatements
+ * and had drifted exactly as far as a copy drifts (audit of 2026-09-09): the
+ * four base elements carried no `role` at all, so `edgy.overlapping-artefacts`
+ * never saw them, the auto legend never legended them and the info panel would
+ * not open on them; "People" arrived as two loose elements where the button
+ * groups the glyph with its name; the texts were English literals outside the
+ * translation seam; the label box was 16/24/+70 against the toolbox's
+ * 18/26/+72; and `1.5` was spelled out a second time instead of
+ * `FACETS_SCALE`. Derived, none of that can happen again — and
+ * `templates-parity.unit.spec.ts` re-runs each command and compares.
+ *
+ * The five COMPOSITIONS stay hand-written: a customer journey or an org chart
+ * is an arrangement of a dozen artefacts, which no single command draws. They
+ * are built on the same presets, and the same test checks their composition.
+ */
+/** The command a derived template is the picture of. Throws rather than skips. */
+function byId(id) {
+    const command = edgyCommands.find(entry => entry.id === id);
+    if (!command)
+        throw new Error(`[edgy] templates: no command "${id}"`);
+    return command;
+}
 // EDGY facet palette (header / pale sub-card).
+//
+// NOT `EDGY_ZONE_FILL`: the metamodel's palette is ONE pastel per zone — the
+// colour an official element is drawn with — where the overview needs a
+// saturated header AND the pale card that sits on it. Two colours per facet is
+// a different table, not a drifted copy of that one.
 const C = {
     identity: ['#1ec873', '#9fe6c2'],
     organisation: ['#4fd0ea', '#c2eef8'],
@@ -39,39 +69,28 @@ function rect(x, y, w, h, opts = {}) {
     return el;
 }
 /**
- * An EDGY node (kind drives the native shape): outcome/object box, people,
- * activity chevron.
+ * An EDGY node of a COMPOSITION — {@link edgyNodeProps} says what that is, and
+ * this adds the two things an illustration decides for itself.
  *
- * `role` is optional and writes NOTHING when absent: the illustrative templates
- * (journey, blueprint, org chart) stay neutral drawings the engine never looks
- * at, exactly as they were before roles existed. Only the EDGY dynamic template
- * — the one that IS the metamodel — stamps its elements.
+ * `role: undefined` writes nothing, and it is the point: the journey, the
+ * blueprint, the org chart and the facets overview are DRAWINGS the engine
+ * never looks at, a decision `edgy-dynamic.unit.spec.ts` pins. Only the EDGY
+ * dynamic template — the one that IS the metamodel — stamps its elements, and
+ * it does so through the same preset.
  */
 function enode(kind, x, y, w, h, opts = {}) {
     const el = {
-        type: 'edgyNode',
-        kind,
-        filled: true,
-        fillColor: opts.fill ?? NODE_FILL,
-        strokeColor: NODE_STROKE,
-        strokeWidth: kind === 'people' ? 0 : NODE_STROKE_WIDTH,
-        shapeStyle: ShapeStyle.General,
-        roughness: 0,
-        shapeType: kind === 'people' ? 'ellipse' : kind === 'activity' ? 'polygon' : 'rect',
-        radius: kind === 'outcome' ? OUTCOME_RADIUS : 0,
-        xywh: `[${x},${y},${w},${h}]`,
+        ...edgyNodeProps(kind, { xywh: `[${x},${y},${w},${h}]` }),
+        role: undefined,
+        ...(opts.fill === undefined ? {} : { fillColor: opts.fill }),
     };
-    if (kind === 'activity')
-        el.vertices = ACTIVITY_VERTICES;
-    // `undefined` writes nothing: a neutral node keeps no `role` key.
-    if (opts.role !== undefined)
-        el.role = opts.role;
     if (opts.text != null) {
+        Object.assign(el, edgyNodeTextProps(opts.text, opts.fontSize));
+        // A snapshot stores the words as a serialized `Y.Text`, where
+        // `addElement` takes a plain string.
         el.text = surfaceText(opts.text);
-        el.color = opts.textColor ?? NODE_STROKE;
-        el.fontFamily = FontFamily.Inter;
-        el.fontSize = opts.fontSize ?? INNER_FONT_SIZE;
-        el.textAlign = TextAlign.Center;
+        if (opts.textColor !== undefined)
+            el.color = opts.textColor;
     }
     return el;
 }
@@ -86,6 +105,15 @@ function label(x, y, w, h, str, opts = {}) {
         xywh: `[${x},${y},${w},${h}]`,
     };
 }
+/**
+ * The group a node and its name travel as — what `createEdgyPeople` writes and
+ * what these compositions had never carried, so dragging the person out of a
+ * journey left the word "Customer" behind.
+ */
+const pair = (node, name) => ({
+    type: 'group',
+    children: surfaceYMap({ [node]: true, [name]: true }),
+});
 function line(x1, y1, x2, y2, opts = {}) {
     return {
         type: 'connector',
@@ -204,6 +232,10 @@ function journey() {
     return {
         cust: enode('people', 40, 120, 64, 64, { fill: '#ffffff' }),
         custL: label(20, 192, 104, 24, 'Customer', { fontSize: 14 }),
+        // The person and its name travel together, as `createEdgyPeople` writes
+        // them. A group is placed AFTER its members: the id middleware remaps
+        // `children` against elements it has already seen.
+        custG: pair('cust', 'custL'),
         band: {
             type: 'shape',
             shapeType: 'polygon',
@@ -346,85 +378,16 @@ function orgChart() {
         e6: attach('c', 'c1', { mode: ConnectorMode.Orthogonal }),
     };
 }
-// ── EDGY dynamic (the relational metamodel, on the facets background) ──
 /**
- * Background scale (from REF coords to model coords): large enough that the
- * default-size nodes breathe inside each zone. The background is cropped to
- * the circles (`cropToCircles`), so its xywh covers CROP × DYN_SCALE.
- */
-export const DYN_SCALE = 4.8;
-/**
- * The metamodel itself — the 12 elements and the 24 relations — now lives in
- * `../metamodel.ts`, so the role vocabulary can DERIVE from it without this
- * module and that one importing each other. Re-exported here under the names
- * they have always had: nothing that reads them had to change.
+ * The metamodel itself — the 12 elements and the 24 relations — lives in
+ * `../metamodel.ts`, and the template that draws it in `./dynamic.ts`.
+ * Re-exported here under the names they have always had: nothing that reads
+ * them had to change.
  */
 export { EDGY_DYNAMIC_NODES, EDGY_DYNAMIC_RELATIONS, } from '../metamodel.js';
-/**
- * Reference coords → template model coords: the background element sits at
- * (0,0) and renders the cropped circles box, so a reference point maps to
- * `(p - CROP.origin) × DYN_SCALE`.
- */
-export function dynToModel(refX, refY) {
-    return [(refX - CROP.x) * DYN_SCALE, (refY - CROP.y) * DYN_SCALE];
-}
-function dynamic() {
-    const out = {
-        bg: {
-            type: 'edgy',
-            showLabels: false,
-            showPictos: false,
-            cropToCircles: true,
-            // The frame a finding is attributed to. Stamped here and nowhere else in
-            // this template: the background is what makes the board an EDGY board.
-            role: EDGY_ROLE.facets,
-            xywh: `[0,0,${CROP.w * DYN_SCALE},${CROP.h * DYN_SCALE}]`,
-        },
-    };
-    for (const [key, { kind, cx, cy, w, zone }] of Object.entries(EDGY_DYNAMIC_NODES)) {
-        const nw = w ?? NODE_SIZE[kind].w;
-        const nh = NODE_SIZE[kind].h;
-        const [mx, my] = dynToModel(cx, cy);
-        const name = edgyElementLabel(key);
-        out[key] = enode(kind, mx - nw / 2, my - nh / 2, nw, nh, {
-            text: name,
-            fill: EDGY_ZONE_FILL[zone],
-            // The OFFICIAL element, not just its kind: this template IS the
-            // metamodel, so its Purpose is a Purpose and not merely an outcome.
-            role: EDGY_ROLE[key],
-        });
-    }
-    EDGY_DYNAMIC_RELATIONS.forEach(([src, dst, verb, t], i) => {
-        out[`rel${i}`] = {
-            type: 'connector',
-            mode: ConnectorMode.Straight,
-            stroke: NODE_STROKE,
-            strokeWidth: 2,
-            strokeStyle: StrokeStyle.Solid,
-            frontEndpointStyle: PointStyle.None,
-            rearEndpointStyle: PointStyle.None,
-            source: { id: src },
-            target: { id: dst },
-            // The verb, as a ROLE — one per canonical verb, derived from this very
-            // table (`../roles.ts`). Source is the subject and target the object
-            // (`docs/adr/0010` tier 1), which is exactly how the row above reads, so
-            // `edgy.non-canonical-link` finds all 24 of these sentences legal.
-            role: EDGY_VERB_ROLE[verb],
-            // Native connector label: the verb travels with the link. The x/y are
-            // re-centred on the path at the first layout, but the w/h ARE the label
-            // box — size it to the verb so the text lays out on one line. The
-            // distance slides the verb along the link like the reference diagram.
-            text: surfaceText(verb),
-            labelXYWH: edgyVerbLabelXYWH(verb),
-            labelOffset: { distance: t ?? EDGY_RELATION_LABEL_DISTANCE },
-        };
-    });
-    return out;
-}
-const single = (el) => ({
-    a: el,
-});
+export { DYN_SCALE, dynToModel, edgyDynamicTemplate } from './dynamic.js';
 const ATTRS = 'width="100%" height="100%" viewBox="0 0 135 80" xmlns="http://www.w3.org/2000/svg"';
+/** A hand-composed template — what is left once the artefacts are derived. */
 function tpl(name, preview, elements) {
     return {
         name,
@@ -433,8 +396,6 @@ function tpl(name, preview, elements) {
         content: makeTemplateSnapshot(elements, name),
     };
 }
-/** Exported for direct insertion from the EDGY senior toolbar menu. */
-export const edgyDynamicTemplate = tpl('EDGY dynamic', `<svg ${ATTRS}><circle cx="55" cy="34" r="18" fill="#00ea4e" opacity="0.9"/><circle cx="80" cy="34" r="18" fill="#034cee" opacity="0.9"/><circle cx="67" cy="54" r="18" fill="#ff0056" opacity="0.9"/><path d="M55 30 H80 M56 31 L66 52 M79 31 L69 52" stroke="#fff" stroke-width="2"/><rect x="51" y="26" width="8" height="8" fill="#fff"/><circle cx="80" cy="30" r="4" fill="#fff"/><path d="M62 49 h6 l3 3 -3 3 h-6 z" fill="#fff"/></svg>`, dynamic());
 export const edgyTemplateCategory = {
     name: 'EDGY',
     templates: [
@@ -442,19 +403,14 @@ export const edgyTemplateCategory = {
         tpl('Customer journey', `<svg ${ATTRS} fill="none"><path d="M20 24 H110 L122 40 L110 56 H20 Z" fill="#f3a3c0"/><rect x="26" y="30" width="22" height="20" fill="none" stroke="#fff"/><rect x="54" y="30" width="22" height="20" fill="none" stroke="#fff"/><rect x="82" y="30" width="22" height="20" fill="none" stroke="#fff"/></svg>`, journey()),
         tpl('Service blueprint', `<svg ${ATTRS} fill="none"><rect x="8" y="14" width="119" height="16" fill="#fbd5e0"/><rect x="8" y="32" width="119" height="34" fill="#d4e9f8"/><rect x="20" y="18" width="22" height="9" fill="#f5246e" opacity="0.5"/><rect x="20" y="40" width="22" height="9" fill="#2f6ff0" opacity="0.4"/><rect x="60" y="40" width="22" height="9" fill="#2f6ff0" opacity="0.4"/></svg>`, blueprint()),
         tpl('Organisation chart', `<svg ${ATTRS} fill="none"><rect x="52" y="12" width="32" height="14" rx="2" fill="#4fd0ea"/><rect x="14" y="38" width="32" height="14" rx="2" fill="#4fd0ea"/><rect x="52" y="38" width="32" height="14" rx="2" fill="#4fd0ea"/><rect x="90" y="38" width="32" height="14" rx="2" fill="#4fd0ea"/><path d="M68 26 V32 M30 32 H106 M30 32 V38 M68 32 V38 M106 32 V38" stroke="#262626"/></svg>`, orgChart()),
-        tpl('Facets diagram', `<svg ${ATTRS}><circle cx="55" cy="34" r="18" fill="#00ea4e" opacity="0.9"/><circle cx="80" cy="34" r="18" fill="#034cee" opacity="0.9"/><circle cx="67" cy="54" r="18" fill="#ff0056" opacity="0.9"/></svg>`, single({
-            type: 'edgy',
-            cropToCircles: true,
-            role: EDGY_ROLE.facets,
-            xywh: `[0,0,${CROP_LABELED.w * 1.5},${CROP_LABELED.h * 1.5}]`,
-        })),
+        templateFromCommand(byId('edgy.addFacets'), `<svg ${ATTRS}><circle cx="55" cy="34" r="18" fill="#00ea4e" opacity="0.9"/><circle cx="80" cy="34" r="18" fill="#034cee" opacity="0.9"/><circle cx="67" cy="54" r="18" fill="#ff0056" opacity="0.9"/></svg>`, 'Facets diagram'),
         edgyDynamicTemplate,
-        tpl('People', `<svg ${ATTRS} fill="#262626"><circle cx="67" cy="32" r="9" fill="none" stroke="#262626" stroke-width="2.4"/><path d="M50 60 a17 17 0 0 1 34 0" fill="none" stroke="#262626" stroke-width="2.4"/></svg>`, {
-            n: enode('people', 0, 0, 64, 64),
-            l: label(-28, 70, 120, 24, 'People', { fontSize: 16 }),
-        }),
-        tpl('Outcome', `<svg ${ATTRS} fill="none"><rect x="20" y="24" width="95" height="34" rx="6" stroke="#262626" stroke-width="2"/></svg>`, single(enode('outcome', 0, 0, 130, 80, { text: 'Outcome' }))),
-        tpl('Object', `<svg ${ATTRS} fill="none"><rect x="20" y="24" width="95" height="34" stroke="#262626" stroke-width="2"/></svg>`, single(enode('object', 0, 0, 130, 80, { text: 'Object' }))),
-        tpl('Activity', `<svg ${ATTRS} fill="none"><path d="M20 24 H98 L116 41 H116 L98 58 H20 Z" stroke="#262626" stroke-width="2" stroke-linejoin="round"/></svg>`, single(enode('activity', 0, 0, 140, 80, { text: 'Activity' }))),
+        // The blank board had no template at all until the palette was derived —
+        // the coverage test is what said so.
+        templateFromCommand(byId('edgy.addBoard'), `<svg ${ATTRS} fill="none"><rect x="8" y="9" width="119" height="62" rx="8" fill="#ffffff" stroke="#e0e0e0" stroke-width="2"/><path d="M52 30 H84 M53 31 L66 58 M83 31 L70 58" stroke="#262626" stroke-width="1.4"/><rect x="48" y="26" width="9" height="9" fill="#00ea4e"/><circle cx="84" cy="30" r="4.5" fill="#034cee"/><path d="M61 54 h8 l4 4 -4 4 h-8 z" fill="#ff0056"/></svg>`, 'EDGY board'),
+        templateFromCommand(byId('edgy.addPeople'), `<svg ${ATTRS} fill="#262626"><circle cx="67" cy="32" r="9" fill="none" stroke="#262626" stroke-width="2.4"/><path d="M50 60 a17 17 0 0 1 34 0" fill="none" stroke="#262626" stroke-width="2.4"/></svg>`),
+        templateFromCommand(byId('edgy.addOutcome'), `<svg ${ATTRS} fill="none"><rect x="20" y="24" width="95" height="34" rx="6" stroke="#262626" stroke-width="2"/></svg>`),
+        templateFromCommand(byId('edgy.addObject'), `<svg ${ATTRS} fill="none"><rect x="20" y="24" width="95" height="34" stroke="#262626" stroke-width="2"/></svg>`),
+        templateFromCommand(byId('edgy.addActivity'), `<svg ${ATTRS} fill="none"><path d="M20 24 H98 L116 41 H116 L98 58 H20 Z" stroke="#262626" stroke-width="2" stroke-linejoin="round"/></svg>`),
     ],
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-framework-edgy",
   "description": "Labre edgy framework for @formicoidea/labre-core.",
-  "version": "0.37.0",
+  "version": "0.38.2",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -31,8 +31,8 @@
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.37.0",
-    "@formicoidea/labre-ddd-shared": "0.37.0",
+    "@formicoidea/labre-core": "0.38.2",
+    "@formicoidea/labre-ddd-shared": "0.38.2",
     "@preact/signals-core": "^1.8.0",
     "lit": "^3.2.0",
     "yjs": "^13.6.21"