@formicoidea/labre-framework-edgy 0.32.0 → 0.34.1

package/dist/actions.d.ts

@@ -1,4 +1,5 @@
 import type { BlockStdScope } from '@formicoidea/labre-core/std';
+import { type GfxController } from '@formicoidea/labre-core/std/gfx';
 export type EdgyBoxKind = 'outcome' | 'object' | 'activity';
 /**
  * Create the Enterprise Design Facets diagram centred on the viewport —
@@ -19,3 +20,20 @@ export declare function createEdgyBox(std: BlockStdScope, kind: EdgyBoxKind): vo
  * person glyph by the renderer, plus a native text label below, grouped.
  */
 export declare function createEdgyPeople(std: BlockStdScope): void;
+/**
+ * Activate the native connector tool for an EDGY RELATION: pre-styled like the
+ * 24 links of the metamodel template, and stamped with the GENERIC role
+ * `edgy:relation`.
+ *
+ * Generic on purpose, and this is the whole design (`./relation.ts`): the verb
+ * of an EDGY relation is determined by the ordered pair of elements it runs
+ * between — 24 rows, 24 distinct pairs — so there is nothing to ask the user
+ * and nothing to pick from a list of twenty-two. The tool arms the parent role,
+ * the user drags from the subject to the object, and `EdgyRelationResolver`
+ * writes the verb the metamodel gives that pair, as a role and as the label.
+ *
+ * The style is the template's, to the pixel: straight, `NODE_STROKE`, two units
+ * wide, and NO arrowhead at either end — EDGY's reference diagram draws its
+ * relations as bare lines and lets the verb say which way the sentence runs.
+ */
+export declare function activateEdgyRelation(gfx: GfxController): void;

package/dist/actions.js

@@ -1,12 +1,17 @@
 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 { FontFamily, ShapeStyle } from '@formicoidea/labre-core/model';
+import { ConnectorMode, FontFamily, PointStyle, ShapeStyle, 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, NODE_SIZE, NODE_STROKE, NODE_STROKE_WIDTH, OUTCOME_RADIUS, } from './node/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 { EDGY_ROLE } from './roles.js';
 import { edgyDynamicTemplate } from './templates/index.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;
 /** Default blank-board size. */
@@ -21,10 +26,20 @@ 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. */
+/**
+ * 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,
@@ -57,6 +72,9 @@ export function createEdgyFacets(std) {
     const id = gfx.surface.addElement({
         type: 'edgy',
         cropToCircles: true,
+        // The frame: what makes this an EDGY board rather than three circles, and
+        // what a finding is attributed to.
+        role: EDGY_ROLE.facets,
         xywh: new Bound(centerX - width / 2, centerY - height / 2, width, height).serialize(),
     });
     finish(gfx, id);
@@ -86,6 +104,9 @@ export function createEdgyBoard(std) {
     const { centerX, centerY } = gfx.viewport;
     const id = gfx.surface.addElement({
         type: 'edgyBoard',
+        // The blank board is a frame too: the same rules apply to what is drawn on
+        // it, and the same map-wide arbitration has to have somewhere to live.
+        role: EDGY_ROLE.board,
         xywh: new Bound(centerX - BOARD_W / 2, centerY - BOARD_H / 2, BOARD_W, BOARD_H).serialize(),
     });
     finish(gfx, id);
@@ -105,7 +126,9 @@ export function createEdgyBox(std, kind) {
         strokeWidth: NODE_STROKE_WIDTH,
         radius: kind === 'outcome' ? OUTCOME_RADIUS : 0,
         vertices: kind === 'activity' ? ACTIVITY_VERTICES : null,
-        text: NODE_LABEL[kind],
+        // 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,
@@ -132,9 +155,42 @@ export function createEdgyPeople(std) {
         strokeWidth: 0,
         xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
     });
-    const labelId = addLabel(surface, NODE_LABEL.people, cx - 60, cy + h / 2 + LABEL_GAP);
+    const labelId = addLabel(surface, translateKey(std, nodeLabelKey('people'), NODE_LABEL.people), cx - 60, cy + h / 2 + LABEL_GAP);
     const [, result] = std.command.exec(createGroupCommand, {
         elements: [nodeId, labelId],
     });
     finish(gfx, result.groupId || nodeId);
 }
+/**
+ * Activate the native connector tool for an EDGY RELATION: pre-styled like the
+ * 24 links of the metamodel template, and stamped with the GENERIC role
+ * `edgy:relation`.
+ *
+ * Generic on purpose, and this is the whole design (`./relation.ts`): the verb
+ * of an EDGY relation is determined by the ordered pair of elements it runs
+ * between — 24 rows, 24 distinct pairs — so there is nothing to ask the user
+ * and nothing to pick from a list of twenty-two. The tool arms the parent role,
+ * the user drags from the subject to the object, and `EdgyRelationResolver`
+ * writes the verb the metamodel gives that pair, as a role and as the label.
+ *
+ * The style is the template's, to the pixel: straight, `NODE_STROKE`, two units
+ * wide, and NO arrowhead at either end — EDGY's reference diagram draws its
+ * relations as bare lines and lets the verb say which way the sentence runs.
+ */
+export function activateEdgyRelation(gfx) {
+    gfx.tool.setTool(ConnectorTool, {
+        mode: ConnectorMode.Straight,
+        role: EDGY_ROLE.relation,
+        // The look rides on the activation, never through the last-props store:
+        // the plain connector tool must keep the user's own style (#144 M1).
+        style: {
+            stroke: NODE_STROKE,
+            strokeStyle: StrokeStyle.Solid,
+            strokeWidth: RELATION_STROKE_WIDTH,
+            frontEndpointStyle: PointStyle.None,
+            rearEndpointStyle: PointStyle.None,
+        },
+    });
+    // Keep the palette open (native sub-menu behaviour): it only closes on
+    // re-click of the senior button, another senior tool, or Escape.
+}

package/dist/board-renderer.js

@@ -13,7 +13,10 @@ export const edgyBoard = (model, ctx, matrix) => {
     const [, , w, h] = model.deserializedXYWH;
     const cx = w / 2;
     const cy = h / 2;
-    ctx.setTransform(matrix.translateSelf(cx, cy).rotateSelf(model.rotate).translateSelf(-cx, -cy));
+    ctx.setTransform(matrix
+        .translateSelf(cx, cy)
+        .rotateSelf(model.rotate)
+        .translateSelf(-cx, -cy));
     ctx.beginPath();
     ctx.roundRect(0, 0, w, h, BOARD_RADIUS);
     ctx.fillStyle = BOARD_FILL;

package/dist/commands-manifest.d.ts

@@ -0,0 +1,18 @@
+import type { ShortcutManifestEntry } from '@formicoidea/labre-core/std';
+/**
+ * The EDGY commands as SHORTCUT-MANIFEST rows — id, label, chord, scope,
+ * owner — and nothing else.
+ *
+ * DATA ONLY, and that is the whole point (`docs/adr/0008` § Packaging). A
+ * `CommandDescriptor` carries its `run`, so a host settings pane that imports
+ * the package entry to list names and chords drags the entire action graph —
+ * the import/export machinery, the surface and gfx deep paths — into its
+ * chunk. This module has type-only imports, so the published bundle exposes it
+ * as `./commands-manifest`: a few hundred bytes that reference nothing.
+ *
+ * GENERATED-SHAPED, hand-committed: `commands-manifest.unit.spec.ts` asserts
+ * row-for-row equality with `toShortcutManifestEntry` over {@link edgyCommands},
+ * so this file cannot drift from the commands it projects. Add a command and
+ * the test says exactly what to add here.
+ */
+export declare const edgyCommandsManifest: ShortcutManifestEntry[];

package/dist/commands-manifest.js

@@ -0,0 +1,82 @@
+/**
+ * The EDGY commands as SHORTCUT-MANIFEST rows — id, label, chord, scope,
+ * owner — and nothing else.
+ *
+ * DATA ONLY, and that is the whole point (`docs/adr/0008` § Packaging). A
+ * `CommandDescriptor` carries its `run`, so a host settings pane that imports
+ * the package entry to list names and chords drags the entire action graph —
+ * the import/export machinery, the surface and gfx deep paths — into its
+ * chunk. This module has type-only imports, so the published bundle exposes it
+ * as `./commands-manifest`: a few hundred bytes that reference nothing.
+ *
+ * GENERATED-SHAPED, hand-committed: `commands-manifest.unit.spec.ts` asserts
+ * row-for-row equality with `toShortcutManifestEntry` over {@link edgyCommands},
+ * so this file cannot drift from the commands it projects. Add a command and
+ * the test says exactly what to add here.
+ */
+export const edgyCommandsManifest = [
+    {
+        id: 'edgy.addFacets',
+        owner: 'edgy',
+        labelKey: 'com.labre.commands.edgy.addFacets',
+        labelFallback: 'Enterprise Design facets',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'edgy.insertDynamic',
+        owner: 'edgy',
+        labelKey: 'com.labre.commands.edgy.insertDynamic',
+        labelFallback: 'EDGY dynamic (elements & relations)',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'edgy.addBoard',
+        owner: 'edgy',
+        labelKey: 'com.labre.commands.edgy.addBoard',
+        labelFallback: 'EDGY board (hover spotlight)',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'edgy.addPeople',
+        owner: 'edgy',
+        labelKey: 'com.labre.commands.edgy.addPeople',
+        labelFallback: 'People',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'edgy.addOutcome',
+        owner: 'edgy',
+        labelKey: 'com.labre.commands.edgy.addOutcome',
+        labelFallback: 'Outcome',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'edgy.addObject',
+        owner: 'edgy',
+        labelKey: 'com.labre.commands.edgy.addObject',
+        labelFallback: 'Object',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'edgy.addActivity',
+        owner: 'edgy',
+        labelKey: 'com.labre.commands.edgy.addActivity',
+        labelFallback: 'Activity',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'edgy.addRelation',
+        owner: 'edgy',
+        labelKey: 'com.labre.commands.edgy.addRelation',
+        labelFallback: 'Relation',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+];

package/dist/commands.js

@@ -1,5 +1,6 @@
-import { createEdgyBoard, createEdgyBox, createEdgyDynamic, createEdgyFacets, createEdgyPeople, } from './actions.js';
-import { edgyActivityIcon, edgyBoardIcon, edgyDynamicIcon, edgyFacetsIcon, edgyObjectIcon, edgyOutcomeIcon, edgyPeopleIcon, } from './toolbar/icons.js';
+import { GfxControllerIdentifier } from '@formicoidea/labre-core/std/gfx';
+import { activateEdgyRelation, createEdgyBoard, createEdgyBox, createEdgyDynamic, createEdgyFacets, createEdgyPeople, } from './actions.js';
+import { edgyActivityIcon, edgyBoardIcon, edgyDynamicIcon, edgyFacetsIcon, edgyObjectIcon, edgyOutcomeIcon, edgyPeopleIcon, edgyRelationIcon, } from './toolbar/icons.js';
 const SPECS = [
     {
         id: 'addFacets',
@@ -57,13 +58,29 @@ const SPECS = [
         element: 'node:activity',
         run: std => createEdgyBox(std, 'activity'),
     },
+    {
+        id: 'addRelation',
+        label: 'Relation',
+        description: 'Drag from the element that is the subject of the relation to the one it is about; EDGY names the link itself.',
+        iconKey: 'edgy.relation',
+        category: 'relations',
+        kind: 'tool',
+        element: 'connector:relation',
+        run: std => activateEdgyRelation(std.get(GfxControllerIdentifier)),
+    },
 ];
 export const edgyCommands = SPECS.map((spec, order) => ({
     id: `edgy.${spec.id}`,
     owner: 'edgy',
-    kind: 'artefact',
+    kind: spec.kind ?? 'artefact',
     labelKey: `com.labre.commands.edgy.${spec.id}`,
     labelFallback: spec.label,
+    ...(spec.description === undefined
+        ? {}
+        : {
+            descriptionKey: `com.labre.commands.edgy.${spec.id}.description`,
+            descriptionFallback: spec.description,
+        }),
     category: spec.category,
     iconKey: spec.iconKey,
     surfaces: ['senior-menu', 'catalogue', 'palette', 'agent'],
@@ -82,4 +99,5 @@ export const edgyCommandIcons = {
     'edgy.outcome': edgyOutcomeIcon,
     'edgy.object': edgyObjectIcon,
     'edgy.activity': edgyActivityIcon,
+    'edgy.relation': edgyRelationIcon,
 };

package/dist/element-renderer.js

@@ -1,6 +1,6 @@
 import { ElementRendererExtension, } from '@formicoidea/labre-core/blocks/surface';
 import { COLORS, cropLabeledScale, cropScale, FONT_FAMILY, LABEL_FONT_SIZE, PICTO_STROKE, REF_H, REF_W, refScale, VENN, } from './consts.js';
-import { CIRCLE_A, CIRCLE_B, CIRCLE_C, facetLabelAnchors } from './label-layout.js';
+import { CIRCLE_A, CIRCLE_B, CIRCLE_C, facetLabelAnchors, } from './label-layout.js';
 /**
  * Canvas renderer for the EDGY Enterprise Design Facets diagram — reproduces the
  * validated mockup: three overlapping circles (Identity / Architecture /
@@ -15,7 +15,10 @@ export const edgy = (model, ctx, matrix) => {
     const [, , w, h] = model.deserializedXYWH;
     const cx = w / 2;
     const cy = h / 2;
-    ctx.setTransform(matrix.translateSelf(cx, cy).rotateSelf(model.rotate).translateSelf(-cx, -cy));
+    ctx.setTransform(matrix
+        .translateSelf(cx, cy)
+        .rotateSelf(model.rotate)
+        .translateSelf(-cx, -cy));
     // Uniform fit of the reference design, centered (letterboxed) — or, when
     // the diagram is cropped, of the circles' bounding box (plus the facet
     // label allowance if the labels are shown).

package/dist/element-view.d.ts

@@ -1,4 +1,6 @@
 import type { EdgyFacetsElementModel } from '@formicoidea/labre-core/model';
+import type { EditorHost } from '@formicoidea/labre-core/std';
+import type { PointTestOptions } from '@formicoidea/labre-core/std/gfx';
 import { GfxElementModelView } from '@formicoidea/labre-core/std/gfx';
 export declare class EdgyView extends GfxElementModelView<EdgyFacetsElementModel> {
     static type: string;
@@ -6,6 +8,18 @@ export declare class EdgyView extends GfxElementModelView<EdgyFacetsElementModel
     private _labelEditor;
     onCreated(): void;
     onDestroyed(): void;
+    /** The editable facet label under a MODEL-space point, or null. */
+    private _labelAt;
+    /**
+     * The diagram is SELECTED by its border (`EdgyFacetsElementModel`), but its
+     * three facet labels must still receive the double-click that renames them.
+     *
+     * Same seam Wardley uses, for the same reason: the pointer router asks the
+     * VIEW, so a framework declares its own gesture zones next to the code that
+     * draws them, and the model layer keeps a hit test that only says what a
+     * click SELECTS.
+     */
+    includesPoint(x: number, y: number, options: PointTestOptions, host: EditorHost): boolean;
     /** Double-click on a label → edit its text in place. */
     private _onDblClick;
     private _openLabelEditor;

package/dist/element-view.js

@@ -18,14 +18,11 @@ export class EdgyView extends GfxElementModelView {
         this._closeLabelEditor();
         super.onDestroyed();
     }
-    /** Double-click on a label → edit its text in place. */
-    _onDblClick(e) {
-        if (this.model.isLocked())
-            return;
+    /** The editable facet label under a MODEL-space point, or null. */
+    _labelAt(mx, my) {
         // No labels shown → nothing to edit (and the cropped mapping differs).
         if (!this.model.showLabels)
-            return;
-        const [mx, my] = this.gfx.viewport.toModelCoord(e.x, e.y);
+            return null;
         const [bx, by, w, h] = this.model.deserializedXYWH;
         // Convert the model-space point into element-local coordinates, undoing the
         // element rotation around its center.
@@ -45,7 +42,28 @@ export class EdgyView extends GfxElementModelView {
             : refScale(w, h);
         const rx = (lx - ox) / s;
         const ry = (ly - oy) / s;
-        const hit = hitTestEdgyLabel(getEdgyLabelHits(this.model), rx, ry);
+        return hitTestEdgyLabel(getEdgyLabelHits(this.model), rx, ry);
+    }
+    /**
+     * The diagram is SELECTED by its border (`EdgyFacetsElementModel`), but its
+     * three facet labels must still receive the double-click that renames them.
+     *
+     * Same seam Wardley uses, for the same reason: the pointer router asks the
+     * VIEW, so a framework declares its own gesture zones next to the code that
+     * draws them, and the model layer keeps a hit test that only says what a
+     * click SELECTS.
+     */
+    includesPoint(x, y, options, host) {
+        if (super.includesPoint(x, y, options, host))
+            return true;
+        return this._labelAt(x, y) !== null;
+    }
+    /** Double-click on a label → edit its text in place. */
+    _onDblClick(e) {
+        if (this.model.isLocked())
+            return;
+        const [mx, my] = this.gfx.viewport.toModelCoord(e.x, e.y);
+        const hit = this._labelAt(mx, my);
         if (!hit)
             return;
         this._openLabelEditor(hit.field, e);

package/dist/label-layout.js

@@ -1,7 +1,13 @@
 import { LABEL_FONT_SIZE, VENN } from './consts.js';
 /** The three circle centres in reference coords. */
-export const CIRCLE_A = { x: VENN.cx - 0.866 * VENN.r0, y: VENN.cy - 0.5 * VENN.r0 }; // Identity
-export const CIRCLE_B = { x: VENN.cx + 0.866 * VENN.r0, y: VENN.cy - 0.5 * VENN.r0 }; // Architecture
+export const CIRCLE_A = {
+    x: VENN.cx - 0.866 * VENN.r0,
+    y: VENN.cy - 0.5 * VENN.r0,
+}; // Identity
+export const CIRCLE_B = {
+    x: VENN.cx + 0.866 * VENN.r0,
+    y: VENN.cy - 0.5 * VENN.r0,
+}; // Architecture
 export const CIRCLE_C = { x: VENN.cx, y: VENN.cy + VENN.r0 }; // Experience
 /**
  * The three facet name anchors in reference coords, positioned fully outside

package/dist/legend.d.ts

@@ -0,0 +1,2 @@
+import { type AutoLegendSpec } from '@formicoidea/labre-ddd-shared';
+export declare const EDGY_AUTO_LEGEND: AutoLegendSpec;

package/dist/legend.js

@@ -0,0 +1,109 @@
+import { roleLabel, } from '@formicoidea/labre-ddd-shared';
+import { EDGY_DYNAMIC_NODES, EDGY_ZONE_FILL, EDGY_ZONES, edgyElementLabel, } from './metamodel.js';
+import { NODE_FILL, NODE_STROKE } from './node/consts.js';
+import { EDGY_ROLE, EDGY_ROLES } from './roles.js';
+/**
+ * What an EDGY background's automatic legend can say — a TABLE, and nothing
+ * else: the scan, the placement and the box are `createAutoLegend`'s job, the
+ * same generic the three DDD backgrounds were given
+ * (`@labre/affine-gfx-ddd-shared`, `shared/legend-auto.ts`). EDGY takes a
+ * dependency on that package for the generic and the box prefab alone; moving
+ * them to a neutral home would be the tidier answer and is not worth the churn
+ * of this fix.
+ *
+ * Every row is DERIVED — from the metamodel (`./metamodel.ts`: which elements
+ * exist, which zone each belongs to, what colour that zone is drawn in) and
+ * from the role vocabulary's own labels (`./roles.ts`). Nothing here is
+ * restated: a thirteenth element added to the metamodel gets its legend row the
+ * same way it gets its role, with no edit to this file.
+ *
+ * ## The order
+ *
+ * By ZONE, and the order of the table carries it: the three facets first
+ * (Identity, Architecture, Experience), then the three intersections in one
+ * section, then the four base elements, then the relations — which is the
+ * reading order of {@link EDGY_ZONES} and, before it, of the Venn itself.
+ */
+/** One row per official element of `zone`, in the metamodel's own order. */
+function zoneEntries(zone) {
+    return Object.entries(EDGY_DYNAMIC_NODES)
+        .filter(([, node]) => node.zone === zone)
+        .map(([name]) => ({
+        role: EDGY_ROLE[name],
+        row: {
+            swatch: 'square',
+            // The zone's fill, which IS what the diagram paints the element with.
+            color: EDGY_ZONE_FILL[zone],
+            label: roleLabel(EDGY_ROLES, EDGY_ROLE[name]),
+        },
+    }));
+}
+const FACET_SECTIONS = EDGY_ZONES.filter(zone => zone.group === 'facet').map(zone => ({
+    title: edgyElementLabel(zone.id),
+    entries: zoneEntries(zone.id),
+}));
+/**
+ * The three intersection elements in ONE section: Organisation, Product and
+ * Brand are not three facets, they are the three lenses between them, and the
+ * diagram says so by drawing them in the overlaps. Each keeps its own colour.
+ */
+const INTERSECTIONS_SECTION = {
+    title: 'Intersections',
+    entries: EDGY_ZONES.filter(zone => zone.group === 'intersection').flatMap(zone => zoneEntries(zone.id)),
+};
+/**
+ * The four base elements, listed only when one is on the board BARE — an
+ * element the user dropped from the toolbox and left as a People, an Outcome,
+ * an Object or an Activity, without saying which of the twelve it is. White,
+ * because that is the fill the palette gives them (`node/consts.ts`).
+ *
+ * `exact` is what makes "bare" true. Detection is otherwise an ancestor walk,
+ * and the twelve official elements specialise these four — Content is an
+ * object, Story an activity — so an "Object" row would appear on a board
+ * carrying nothing but Contents, keyed to a white swatch that is drawn nowhere
+ * on it. The relation entry below keeps the walk, because there the parent row
+ * IS the fair summary: a board carrying `edgy:expresses` carries a relation.
+ */
+const BASE_SECTION = {
+    title: 'Base elements',
+    entries: ['people', 'outcome', 'object', 'activity'].map(kind => ({
+        role: EDGY_ROLE[kind],
+        exact: true,
+        row: {
+            swatch: 'square',
+            color: NODE_FILL,
+            label: roleLabel(EDGY_ROLES, EDGY_ROLE[kind]),
+        },
+    })),
+};
+/**
+ * ONE row for the whole relation family, keyed on the PARENT role: a board
+ * carrying "content expresses purpose" carries `edgy:expresses`, which is a
+ * relation, and that is all the legend has to say. Twenty-two rows naming the
+ * verbs would restate the metamodel rather than document the drawing — and the
+ * verb travels on the link itself, visible, where it belongs.
+ */
+const RELATIONS_SECTION = {
+    title: 'Relations',
+    entries: [
+        {
+            role: EDGY_ROLE.relation,
+            row: {
+                swatch: 'line',
+                // The stroke `activateEdgyRelation` arms the connector tool with.
+                color: NODE_STROKE,
+                label: roleLabel(EDGY_ROLES, EDGY_ROLE.relation),
+            },
+        },
+    ],
+};
+export const EDGY_AUTO_LEGEND = {
+    title: 'Legend',
+    roles: EDGY_ROLES,
+    sections: [
+        ...FACET_SECTIONS,
+        INTERSECTIONS_SECTION,
+        BASE_SECTION,
+        RELATIONS_SECTION,
+    ],
+};

package/dist/metamodel.d.ts

@@ -0,0 +1,96 @@
+/**
+ * The EDGY metamodel, as DATA — the 12 official elements and the 24 canonical
+ * relations that link them.
+ *
+ * It used to live in `templates/index.ts`, where it was drawn. It moved here
+ * the day the roles started being DERIVED from it (`./roles.ts`): the template
+ * needs the vocabulary to stamp its elements, and the vocabulary needs the
+ * metamodel to know which verbs exist, so a single module holding both would be
+ * a cycle. Nothing was renamed — `templates/index.ts` re-exports both tables
+ * under the names they always had.
+ *
+ * This file is the ONE place the metamodel is written down. `roles.ts` derives
+ * an edge role per verb from it, `rules.ts` derives the sanctioned sentences of
+ * `edgy.non-canonical-link` from it, and the template draws it. Restating the
+ * matrix anywhere else would be inviting the three to disagree.
+ */
+/**
+ * Official pastel fills per zone (the `pictograms/Shape-*.svg` colors) — the
+ * colour an element of that zone is DRAWN with, on the diagram and therefore in
+ * the legend that documents it.
+ *
+ * Exported because the legend needs the same swatch the board uses: a swatch
+ * restated as a second literal would be a colour free to drift away from the
+ * one the eye sees.
+ */
+export declare const EDGY_ZONE_FILL: {
+    readonly identity: "#80ffb7";
+    readonly architecture: "#a6c0ff";
+    readonly experience: "#ff99bd";
+    readonly organisation: "#80eaff";
+    readonly brand: "#ffd580";
+    readonly product: "#e599ff";
+};
+/** One of the six regions of the Venn: three facets, three intersections. */
+export type EdgyZone = keyof typeof EDGY_ZONE_FILL;
+/**
+ * The six zones, in reading order — the three FACETS first, then the three
+ * INTERSECTIONS, each named by the pair of circles it is the lens of (the very
+ * pairs `element-renderer.ts` clips: A∩B, B∩C, A∩C).
+ *
+ * Written down as data because the split is otherwise readable only inside the
+ * renderer's paint calls, and the legend has to group the twelve elements by
+ * it. `group` is the only thing here a reader could not already derive from
+ * {@link EDGY_DYNAMIC_NODES}.
+ */
+export declare const EDGY_ZONES: readonly {
+    id: EdgyZone;
+    group: 'facet' | 'intersection';
+}[];
+/**
+ * The 24 canonical EDGY relations (source, target, verb, label position along
+ * the link) — exported for the unit tests. 7 per facet + 3 between the
+ * intersections. The optional 4th member mirrors the reference diagram's
+ * placements: verbs of intersection-outgoing links sit near the far element
+ * (`labelOffset.distance` ≈ .75), short peer links keep the middle.
+ *
+ * Read the way `docs/adr/0010` reads every typed edge: the SOURCE is the
+ * subject of the verb and the TARGET its object, so each row is one sentence a
+ * practitioner would say out loud — "content expresses purpose". That is what
+ * makes the row usable as an {@link EndpointTriplet} without a single
+ * coordinate taking part.
+ */
+export declare const EDGY_DYNAMIC_RELATIONS: [string, string, string, number?][];
+/**
+ * The 12 elements, centred coordinates in REFERENCE coords (the fixed space
+ * of consts.ts — the same space as `VENN`), laid out like the reference
+ * "elements & relations" diagram: aligned top row, Story/Capability flanks,
+ * Brand/Product astride the white centre, Task/Journey/Channel triangle.
+ * Exported (with `dynToModel`) for the containment test.
+ *
+ * `kind` is the OFFICIAL kind of each element — the base shape EDGY draws it
+ * with — and `roles.ts` reads it to give each of the twelve leaf roles its
+ * parent. Written once, here, rather than restated as a second table nobody
+ * would think to keep in step.
+ *
+ * `zone` is the region of the Venn the element belongs to, and it REPLACES the
+ * fill this table used to carry: the fill is `EDGY_ZONE_FILL[zone]` and nothing
+ * else, so an element cannot be filed under one facet and painted another's
+ * colour. The template reads it to draw, the legend reads it to group and to
+ * swatch.
+ */
+export type EdgyElementName = 'content' | 'purpose' | 'organisation' | 'process' | 'asset' | 'story' | 'capability' | 'brand' | 'product' | 'task' | 'journey' | 'channel';
+/**
+ * The metamodel's own wording for one of its lowercase names — one of the
+ * twelve elements, or one of the six zones. It is the name written on the
+ * diagram, so it is also what the vocabulary falls back to and what the legend
+ * prints as a row label or a section title. One expression, one wording.
+ */
+export declare const edgyElementLabel: (name: EdgyElementName | EdgyZone) => string;
+export declare const EDGY_DYNAMIC_NODES: Record<EdgyElementName, {
+    kind: 'outcome' | 'object' | 'activity';
+    cx: number;
+    cy: number;
+    w?: number;
+    zone: EdgyZone;
+}>;