@formicoidea/labre-framework-edgy 0.59.0 → 0.61.0

package/dist/actions.js

@@ -4,25 +4,24 @@ import { createGroupCommand } from '@formicoidea/labre-core/gfx/group';
 import { createTemplateJob } from '@formicoidea/labre-core/gfx/template';
 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 { edgyElementLabel, edgyElementLabelKey } from './metamodel.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 { NODE_LABEL, nodeLabelKey, NODE_SIZE, NODE_STROKE, } from './node/consts.js';
+import { EDGY_BOARD_SIZE, RELATION_STROKE_WIDTH, } from './presets.js';
 import { EDGY_ROLE } from './roles.js';
 import { edgyDynamicTemplate } from './templates/dynamic.js';
-/** Stroke width the 24 template relations are drawn with. */
-const RELATION_STROKE_WIDTH = 2;
+import { EDGY_FACETS_SIZE, EDGY_PEOPLE_SIZE, edgyBoardElement, edgyBoxElement, edgyFacetsElement, edgyPeopleElements, } from './toolbox.js';
 /**
  * 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`).
+ *
+ * What they place comes from the ONE assembly a host with no editor also
+ * calls (`toolbox.ts`, `docs/adr/0045`); what stays here is what only an
+ * editor has: the viewport centre, the seeds resolved in the host's language
+ * (`docs/adr/0023`), the group command and the selection.
  */
-/** Default blank-board size. */
-const BOARD_W = 1600;
-const BOARD_H = 1000;
 const gfxOf = (std) => std.get(GfxControllerIdentifier);
 function finish(gfx, id) {
     gfx.doc.captureSync();
@@ -38,27 +37,22 @@ export function createEdgyFacets(std) {
     const gfx = gfxOf(std);
     if (!gfx.surface)
         return;
-    const width = CROP_LABELED.w * FACETS_SCALE;
-    const height = CROP_LABELED.h * FACETS_SCALE;
+    const { w, h } = EDGY_FACETS_SIZE;
     const { centerX, centerY } = gfx.viewport;
-    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,
-        // The three facet names, written HERE rather than left to the model's
-        // defaults (`EdgyFacetsElementModel.identityLabel` etc — a red-zone
-        // field: a document created before this key existed keeps its literal
-        // 'Identity' / 'Architecture' / 'Experience' verbatim). Shares its key
-        // with the very same words wherever the metamodel names a zone
-        // (`edgyElementLabelKey`, `templates/dynamic.ts`, `templates/index.ts`).
-        identityLabel: translateKey(std, edgyElementLabelKey('identity'), edgyElementLabel('identity')),
-        architectureLabel: translateKey(std, edgyElementLabelKey('architecture'), edgyElementLabel('architecture')),
-        experienceLabel: translateKey(std, edgyElementLabelKey('experience'), edgyElementLabel('experience')),
-        xywh: new Bound(centerX - width / 2, centerY - height / 2, width, height).serialize(),
+    const zone = (name) => translateKey(std, edgyElementLabelKey(name), edgyElementLabel(name));
+    const { id: _local, ...props } = edgyFacetsElement({ x: centerX - w / 2, y: centerY - h / 2 }, 
+    // The three facet names, written HERE rather than left to the model's
+    // defaults (`EdgyFacetsElementModel.identityLabel` etc — a red-zone
+    // field: a document created before this key existed keeps its literal
+    // 'Identity' / 'Architecture' / 'Experience' verbatim). Shares its key
+    // with the very same words wherever the metamodel names a zone
+    // (`edgyElementLabelKey`, `templates/dynamic.ts`, `templates/index.ts`).
+    {
+        identity: zone('identity'),
+        architecture: zone('architecture'),
+        experience: zone('experience'),
     });
-    finish(gfx, id);
+    finish(gfx, gfx.surface.addElement(props));
 }
 /**
  * Insert the "EDGY dynamic" template (facets background + the 12 elements
@@ -90,15 +84,13 @@ export function createEdgyBoard(std) {
     const gfx = gfxOf(std);
     if (!gfx.surface)
         return;
+    const { w, h } = EDGY_BOARD_SIZE;
     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(),
+    const { id: _local, ...props } = edgyBoardElement({
+        x: centerX - w / 2,
+        y: centerY - h / 2,
     });
-    finish(gfx, id);
+    finish(gfx, gfx.surface.addElement(props));
 }
 /** Create a box base element (outcome / object / activity) with inner text. */
 export function createEdgyBox(std, kind) {
@@ -108,15 +100,11 @@ export function createEdgyBox(std, kind) {
         return;
     const { w, h } = NODE_SIZE[kind];
     const { centerX: cx, centerY: cy } = gfx.viewport;
-    const id = surface.addElement({
-        ...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`).
-        ...edgyNodeTextProps(translateKey(std, nodeLabelKey(kind), NODE_LABEL[kind])),
-    });
-    finish(gfx, id);
+    const { id: _local, ...props } = edgyBoxElement(kind, { x: cx - w / 2, y: cy - h / 2 }, 
+    // Translated HERE and once: what a gesture writes onto the canvas is
+    // document content the moment it lands (`nodeLabelKey`).
+    translateKey(std, nodeLabelKey(kind), NODE_LABEL[kind]));
+    finish(gfx, surface.addElement(props));
 }
 /**
  * Create the People base element: an (invisible) ellipse decorated with the
@@ -127,14 +115,27 @@ export function createEdgyPeople(std) {
     const surface = gfx.surface;
     if (!surface)
         return;
-    const { w, h } = NODE_SIZE.people;
     const { centerX: cx, centerY: cy } = gfx.viewport;
-    const nodeId = surface.addElement(edgyNodeProps('people', {
-        xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
-    }));
-    const labelId = surface.addElement(edgyLabelProps(translateKey(std, nodeLabelKey('people'), NODE_LABEL.people), cx - EDGY_LABEL_W / 2, cy + h / 2 + LABEL_GAP));
+    // The GLYPH, not the whole item, sits on the viewport centre, as it always
+    // has: the item's box is as wide as the name and starts at the glyph's top.
+    const elements = edgyPeopleElements({
+        x: cx - EDGY_PEOPLE_SIZE.w / 2,
+        y: cy - NODE_SIZE.people.h / 2,
+    }, translateKey(std, nodeLabelKey('people'), NODE_LABEL.people));
+    const members = [];
+    for (const { id: _local, ...props } of elements) {
+        // The builder's group is for a host with no editor. Here the editor's own
+        // group command makes it, because it writes what only an editor has: the
+        // numbered "Group N" title from the host's catalogue and the user layer.
+        if (props.type === 'group')
+            continue;
+        members.push(surface.addElement(props));
+    }
+    const nodeId = members[0];
+    if (!nodeId)
+        return;
     const [, result] = std.command.exec(createGroupCommand, {
-        elements: [nodeId, labelId],
+        elements: members,
     });
     finish(gfx, result.groupId || nodeId);
 }

package/dist/consts.d.ts

@@ -6,18 +6,7 @@
  * uniformly to the element bounds — so the three circles always stay circular
  * and the pictos/labels keep their relative proportions at any size.
  */
-/** Reference design size (the validated mockup canvas). */
-export declare const REF_W = 680;
-export declare const REF_H = 400;
-/** Circle geometry in reference coords. */
-export declare const VENN: {
-    readonly cx: number;
-    readonly cy: 176;
-    /** Circle radius. */
-    readonly R: 95;
-    /** Distance of each circle centre from the diagram centre. */
-    readonly r0: 56;
-};
+export { CROP, CROP_LABELED, cropLabeledScale, cropScale, REF_H, REF_W, VENN, } from './facets-crop.js';
 /** Saturated facet + intersection colours (faithful to the official icons). */
 export declare const COLORS: {
     readonly identity: "#00ea4e";
@@ -43,56 +32,3 @@ export declare const FONT_FAMILY = "Inter, sans-serif";
  * reference size is this framework's business.
  */
 export declare function refScale(w: number, h: number): import("@formicoidea/labre-core/_pkgs/affine-block-surface").RefFit;
-/**
- * Bounding box of the three circles in reference coords, with just enough
- * padding to see their outline. When a diagram hides its facet names
- * (`cropToCircles` without `showLabels`) the renderer fits THIS box into the
- * element bounds, so the background hugs the Venn.
- *
- * ## Why the padding is 2.5 and not the 8 it was
- *
- * The padding is the ONLY empty band such a board has, and it is spent at the
- * element's scale, not at the reference one. The EDGY dynamic template draws
- * its board at `DYN_SCALE = 4.8`, so eight reference units of padding were
- * **32.4 model units** of nothing on each of the four sides — the board a user
- * has to catch by its border (R37) sat a good inch away from the circles, which
- * is what the recette of 23/09/2026 reported. 2.5 leaves 1.25 past the circles'
- * own 2.5-wide outline, i.e. 6 model units at the dynamic board's scale and
- * under 2 at a facets board's.
- *
- * `templates/dynamic.ts` places every element of the dynamic board in
- * coordinates relative to this box (`dynToModel`) and sizes the board from it,
- * so the template follows in the same breath: both are derived here, and a
- * freshly inserted template is aligned by construction. A board built from the
- * OLD template keeps its `xywh` and sees the Venn grow 3.8 % inside it — see
- * the changeset.
- */
-export declare const CROP: {
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-};
-/**
- * Crop box KEEPING room for the three facet name labels (drawn outside the
- * circles): the circles plus {@link LABEL_ALLOWANCE}, which is asymmetric
- * because the words are. Used when a cropped diagram still shows its labels.
- */
-export declare const CROP_LABELED: {
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-};
-/** `refScale` variant fitting the cropped circles box (see {@link CROP}). */
-export declare const cropScale: (w: number, h: number) => {
-    s: number;
-    ox: number;
-    oy: number;
-};
-/** `refScale` variant fitting the circles + facet labels box. */
-export declare const cropLabeledScale: (w: number, h: number) => {
-    s: number;
-    ox: number;
-    oy: number;
-};

package/dist/consts.js

@@ -7,18 +7,11 @@
  * and the pictos/labels keep their relative proportions at any size.
  */
 import { refScale as fitReference } from '@formicoidea/labre-core/blocks/surface';
-/** Reference design size (the validated mockup canvas). */
-export const REF_W = 680;
-export const REF_H = 400;
-/** Circle geometry in reference coords. */
-export const VENN = {
-    cx: REF_W / 2,
-    cy: 176,
-    /** Circle radius. */
-    R: 95,
-    /** Distance of each circle centre from the diagram centre. */
-    r0: 56,
-};
+import { REF_H, REF_W } from './facets-crop.js';
+// The reference geometry lives in an editor-free file (`facets-crop.ts`) so the
+// toolbox can size a facets background without the surface index; every
+// binding is re-exported here unchanged.
+export { CROP, CROP_LABELED, cropLabeledScale, cropScale, REF_H, REF_W, VENN, } from './facets-crop.js';
 /** Saturated facet + intersection colours (faithful to the official icons). */
 export const COLORS = {
     identity: '#00ea4e',
@@ -46,120 +39,3 @@ export const FONT_FAMILY = 'Inter, sans-serif';
 export function refScale(w, h) {
     return fitReference(w, h, REF_W, REF_H);
 }
-/**
- * The three circles, and nothing else: their exact bounding box in reference
- * coords. Both crop boxes below are this box plus what each of them has to make
- * room for, so the two can never disagree about where the Venn is.
- */
-const CIRCLES = (() => {
-    const ax = VENN.cx - 0.866 * VENN.r0; // Identity / Architecture centres
-    const abY = VENN.cy - 0.5 * VENN.r0;
-    const cY = VENN.cy + VENN.r0; // Experience centre
-    return {
-        minX: ax - VENN.R,
-        maxX: VENN.cx + 0.866 * VENN.r0 + VENN.R,
-        minY: abY - VENN.R,
-        maxY: cY + VENN.R,
-    };
-})();
-/**
- * Bounding box of the three circles in reference coords, with just enough
- * padding to see their outline. When a diagram hides its facet names
- * (`cropToCircles` without `showLabels`) the renderer fits THIS box into the
- * element bounds, so the background hugs the Venn.
- *
- * ## Why the padding is 2.5 and not the 8 it was
- *
- * The padding is the ONLY empty band such a board has, and it is spent at the
- * element's scale, not at the reference one. The EDGY dynamic template draws
- * its board at `DYN_SCALE = 4.8`, so eight reference units of padding were
- * **32.4 model units** of nothing on each of the four sides — the board a user
- * has to catch by its border (R37) sat a good inch away from the circles, which
- * is what the recette of 23/09/2026 reported. 2.5 leaves 1.25 past the circles'
- * own 2.5-wide outline, i.e. 6 model units at the dynamic board's scale and
- * under 2 at a facets board's.
- *
- * `templates/dynamic.ts` places every element of the dynamic board in
- * coordinates relative to this box (`dynToModel`) and sizes the board from it,
- * so the template follows in the same breath: both are derived here, and a
- * freshly inserted template is aligned by construction. A board built from the
- * OLD template keeps its `xywh` and sees the Venn grow 3.8 % inside it — see
- * the changeset.
- */
-export const CROP = (() => {
-    const pad = 2.5;
-    return {
-        x: CIRCLES.minX - pad,
-        y: CIRCLES.minY - pad,
-        w: CIRCLES.maxX - CIRCLES.minX + 2 * pad,
-        h: CIRCLES.maxY - CIRCLES.minY + 2 * pad,
-    };
-})();
-/**
- * How far past the circles each side of the labelled box has to reach, in REF
- * units. MEASURED on the canvas, in the shipped wording, at
- * {@link LABEL_FONT_SIZE}; each number is that reach plus 4 or 5 units of
- * gutter.
- *
- * It used to be one symmetric number — `sideAllowance = 140` either side of the
- * padded box, `bottomAllowance = 35` under it — and the three words are not
- * symmetric at all. "Identity" is written right-aligned 10 left of the left
- * circle and reaches 63.6 past the circles; "Architecture" is written
- * left-aligned 10 right of the right circle and reaches 98.1; "Experience"
- * hangs 29.2 below the bottom one (a `middle` baseline plus the descender of
- * its "p"); and above them there is no word at all, only the 1.25 of circle
- * stroke. So a facets diagram was born inside 126.6 model units of nothing on
- * its left and 74.8 on its right — and a framework background is caught by its
- * border and by nothing else
- * (`model/src/elements/framework-background/hit-test.ts`), which put the
- * catchable edge a seventh of the board away from anything drawn.
- *
- * ## Why constants rather than a measurement at paint time
- *
- * Because the three names are EDITABLE props of the element (`identityLabel` &
- * co) and `cropLabeledScale` is not only what the renderer draws through —
- * `element-view.ts` maps every click back through it too. Deriving the box from
- * the current text would rescale and re-centre the whole Venn on each
- * keystroke, and move the click mapping under the user's finger while they
- * type; two boards of the same size would also draw their circles at two
- * different sizes. The allowance is furniture: it is measured once, here.
- *
- * A name rewritten to something much longer than the vocabulary therefore
- * reaches past the element's edge. It paints (the surface clips nothing); only
- * the SVG export, which crops to the `xywh`, would cut it.
- */
-const LABEL_ALLOWANCE = {
-    /** No word up there: the circle's own stroke, and room to see it. */
-    top: 5,
-    /** "Identity", right-aligned, reaching left of the circles. */
-    left: 68,
-    /** "Architecture", left-aligned, reaching right of them. */
-    right: 103,
-    /** "Experience", under the bottom circle, descender included. */
-    bottom: 32,
-};
-/**
- * Crop box KEEPING room for the three facet name labels (drawn outside the
- * circles): the circles plus {@link LABEL_ALLOWANCE}, which is asymmetric
- * because the words are. Used when a cropped diagram still shows its labels.
- */
-export const CROP_LABELED = {
-    x: CIRCLES.minX - LABEL_ALLOWANCE.left,
-    y: CIRCLES.minY - LABEL_ALLOWANCE.top,
-    w: CIRCLES.maxX - CIRCLES.minX + LABEL_ALLOWANCE.left + LABEL_ALLOWANCE.right,
-    h: CIRCLES.maxY - CIRCLES.minY + LABEL_ALLOWANCE.top + LABEL_ALLOWANCE.bottom,
-};
-function fitScale(box) {
-    return (w, h) => {
-        const s = Math.min(w / box.w, h / box.h);
-        return {
-            s,
-            ox: (w - box.w * s) / 2 - box.x * s,
-            oy: (h - box.h * s) / 2 - box.y * s,
-        };
-    };
-}
-/** `refScale` variant fitting the cropped circles box (see {@link CROP}). */
-export const cropScale = fitScale(CROP);
-/** `refScale` variant fitting the circles + facet labels box. */
-export const cropLabeledScale = fitScale(CROP_LABELED);

package/dist/facets-crop.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The facets diagram's reference geometry: the fixed design space, the Venn
+ * and the two crop boxes, as plain numbers.
+ *
+ * Split out of `consts.ts`, which re-exports every binding unchanged, because
+ * that file also reads the library's fit from the surface package index: the
+ * toolbox (`toolbox.ts`, `docs/adr/0045`) sizes a facets background from
+ * {@link CROP_LABELED} on the editor-free `./interchange` entry, which must not
+ * load the editor graph that index brings.
+ */
+/** Reference design size (the validated mockup canvas). */
+export declare const REF_W = 680;
+export declare const REF_H = 400;
+/** Circle geometry in reference coords. */
+export declare const VENN: {
+    readonly cx: number;
+    readonly cy: 176;
+    /** Circle radius. */
+    readonly R: 95;
+    /** Distance of each circle centre from the diagram centre. */
+    readonly r0: 56;
+};
+/**
+ * Bounding box of the three circles in reference coords, with just enough
+ * padding to see their outline. When a diagram hides its facet names
+ * (`cropToCircles` without `showLabels`) the renderer fits THIS box into the
+ * element bounds, so the background hugs the Venn.
+ *
+ * ## Why the padding is 2.5 and not the 8 it was
+ *
+ * The padding is the ONLY empty band such a board has, and it is spent at the
+ * element's scale, not at the reference one. The EDGY dynamic template draws
+ * its board at `DYN_SCALE = 4.8`, so eight reference units of padding were
+ * **32.4 model units** of nothing on each of the four sides — the board a user
+ * has to catch by its border (R37) sat a good inch away from the circles, which
+ * is what the recette of 23/09/2026 reported. 2.5 leaves 1.25 past the circles'
+ * own 2.5-wide outline, i.e. 6 model units at the dynamic board's scale and
+ * under 2 at a facets board's.
+ *
+ * `templates/dynamic.ts` places every element of the dynamic board in
+ * coordinates relative to this box (`dynToModel`) and sizes the board from it,
+ * so the template follows in the same breath: both are derived here, and a
+ * freshly inserted template is aligned by construction. A board built from the
+ * OLD template keeps its `xywh` and sees the Venn grow 3.8 % inside it — see
+ * the changeset.
+ */
+export declare const CROP: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+/**
+ * Crop box KEEPING room for the three facet name labels (drawn outside the
+ * circles): the circles plus {@link LABEL_ALLOWANCE}, which is asymmetric
+ * because the words are. Used when a cropped diagram still shows its labels.
+ */
+export declare const CROP_LABELED: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+/** `refScale` variant fitting the cropped circles box (see {@link CROP}). */
+export declare const cropScale: (w: number, h: number) => {
+    s: number;
+    ox: number;
+    oy: number;
+};
+/** `refScale` variant fitting the circles + facet labels box. */
+export declare const cropLabeledScale: (w: number, h: number) => {
+    s: number;
+    ox: number;
+    oy: number;
+};

package/dist/facets-crop.js

@@ -0,0 +1,139 @@
+/**
+ * The facets diagram's reference geometry: the fixed design space, the Venn
+ * and the two crop boxes, as plain numbers.
+ *
+ * Split out of `consts.ts`, which re-exports every binding unchanged, because
+ * that file also reads the library's fit from the surface package index: the
+ * toolbox (`toolbox.ts`, `docs/adr/0045`) sizes a facets background from
+ * {@link CROP_LABELED} on the editor-free `./interchange` entry, which must not
+ * load the editor graph that index brings.
+ */
+/** Reference design size (the validated mockup canvas). */
+export const REF_W = 680;
+export const REF_H = 400;
+/** Circle geometry in reference coords. */
+export const VENN = {
+    cx: REF_W / 2,
+    cy: 176,
+    /** Circle radius. */
+    R: 95,
+    /** Distance of each circle centre from the diagram centre. */
+    r0: 56,
+};
+/**
+ * The three circles, and nothing else: their exact bounding box in reference
+ * coords. Both crop boxes below are this box plus what each of them has to make
+ * room for, so the two can never disagree about where the Venn is.
+ */
+const CIRCLES = (() => {
+    const ax = VENN.cx - 0.866 * VENN.r0; // Identity / Architecture centres
+    const abY = VENN.cy - 0.5 * VENN.r0;
+    const cY = VENN.cy + VENN.r0; // Experience centre
+    return {
+        minX: ax - VENN.R,
+        maxX: VENN.cx + 0.866 * VENN.r0 + VENN.R,
+        minY: abY - VENN.R,
+        maxY: cY + VENN.R,
+    };
+})();
+/**
+ * Bounding box of the three circles in reference coords, with just enough
+ * padding to see their outline. When a diagram hides its facet names
+ * (`cropToCircles` without `showLabels`) the renderer fits THIS box into the
+ * element bounds, so the background hugs the Venn.
+ *
+ * ## Why the padding is 2.5 and not the 8 it was
+ *
+ * The padding is the ONLY empty band such a board has, and it is spent at the
+ * element's scale, not at the reference one. The EDGY dynamic template draws
+ * its board at `DYN_SCALE = 4.8`, so eight reference units of padding were
+ * **32.4 model units** of nothing on each of the four sides — the board a user
+ * has to catch by its border (R37) sat a good inch away from the circles, which
+ * is what the recette of 23/09/2026 reported. 2.5 leaves 1.25 past the circles'
+ * own 2.5-wide outline, i.e. 6 model units at the dynamic board's scale and
+ * under 2 at a facets board's.
+ *
+ * `templates/dynamic.ts` places every element of the dynamic board in
+ * coordinates relative to this box (`dynToModel`) and sizes the board from it,
+ * so the template follows in the same breath: both are derived here, and a
+ * freshly inserted template is aligned by construction. A board built from the
+ * OLD template keeps its `xywh` and sees the Venn grow 3.8 % inside it — see
+ * the changeset.
+ */
+export const CROP = (() => {
+    const pad = 2.5;
+    return {
+        x: CIRCLES.minX - pad,
+        y: CIRCLES.minY - pad,
+        w: CIRCLES.maxX - CIRCLES.minX + 2 * pad,
+        h: CIRCLES.maxY - CIRCLES.minY + 2 * pad,
+    };
+})();
+/**
+ * How far past the circles each side of the labelled box has to reach, in REF
+ * units. MEASURED on the canvas, in the shipped wording, at
+ * `LABEL_FONT_SIZE` (`consts.ts`); each number is that reach plus 4 or 5 units of
+ * gutter.
+ *
+ * It used to be one symmetric number — `sideAllowance = 140` either side of the
+ * padded box, `bottomAllowance = 35` under it — and the three words are not
+ * symmetric at all. "Identity" is written right-aligned 10 left of the left
+ * circle and reaches 63.6 past the circles; "Architecture" is written
+ * left-aligned 10 right of the right circle and reaches 98.1; "Experience"
+ * hangs 29.2 below the bottom one (a `middle` baseline plus the descender of
+ * its "p"); and above them there is no word at all, only the 1.25 of circle
+ * stroke. So a facets diagram was born inside 126.6 model units of nothing on
+ * its left and 74.8 on its right — and a framework background is caught by its
+ * border and by nothing else
+ * (`model/src/elements/framework-background/hit-test.ts`), which put the
+ * catchable edge a seventh of the board away from anything drawn.
+ *
+ * ## Why constants rather than a measurement at paint time
+ *
+ * Because the three names are EDITABLE props of the element (`identityLabel` &
+ * co) and `cropLabeledScale` is not only what the renderer draws through —
+ * `element-view.ts` maps every click back through it too. Deriving the box from
+ * the current text would rescale and re-centre the whole Venn on each
+ * keystroke, and move the click mapping under the user's finger while they
+ * type; two boards of the same size would also draw their circles at two
+ * different sizes. The allowance is furniture: it is measured once, here.
+ *
+ * A name rewritten to something much longer than the vocabulary therefore
+ * reaches past the element's edge. It paints (the surface clips nothing); only
+ * the SVG export, which crops to the `xywh`, would cut it.
+ */
+const LABEL_ALLOWANCE = {
+    /** No word up there: the circle's own stroke, and room to see it. */
+    top: 5,
+    /** "Identity", right-aligned, reaching left of the circles. */
+    left: 68,
+    /** "Architecture", left-aligned, reaching right of them. */
+    right: 103,
+    /** "Experience", under the bottom circle, descender included. */
+    bottom: 32,
+};
+/**
+ * Crop box KEEPING room for the three facet name labels (drawn outside the
+ * circles): the circles plus {@link LABEL_ALLOWANCE}, which is asymmetric
+ * because the words are. Used when a cropped diagram still shows its labels.
+ */
+export const CROP_LABELED = {
+    x: CIRCLES.minX - LABEL_ALLOWANCE.left,
+    y: CIRCLES.minY - LABEL_ALLOWANCE.top,
+    w: CIRCLES.maxX - CIRCLES.minX + LABEL_ALLOWANCE.left + LABEL_ALLOWANCE.right,
+    h: CIRCLES.maxY - CIRCLES.minY + LABEL_ALLOWANCE.top + LABEL_ALLOWANCE.bottom,
+};
+function fitScale(box) {
+    return (w, h) => {
+        const s = Math.min(w / box.w, h / box.h);
+        return {
+            s,
+            ox: (w - box.w * s) / 2 - box.x * s,
+            oy: (h - box.h * s) / 2 - box.y * s,
+        };
+    };
+}
+/** `refScale` variant fitting the cropped circles box (see {@link CROP}). */
+export const cropScale = fitScale(CROP);
+/** `refScale` variant fitting the circles + facet labels box. */
+export const cropLabeledScale = fitScale(CROP_LABELED);

package/dist/index.d.ts

@@ -3,3 +3,4 @@ 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';
+export { EDGY_FACETS_SIZE, EDGY_PEOPLE_SIZE, EDGY_TOOLBOX, edgyBoardElement, edgyBoxElement, edgyFacetsElement, type EdgyFacetsTexts, edgyPeopleElements, edgyRelationElement, } from './toolbox.js';

package/dist/index.js

@@ -5,3 +5,5 @@ export { edgyTranslationEntries } from './translations.js';
 export { EDGY_ROLE, EDGY_ROLES } from './roles.js';
 export { EDGY_READING } from './reading.js';
 export { EDGY_RULES } from './rules.js';
+// The toolbar as pure builders (`docs/adr/0045`), also on `./interchange`.
+export { EDGY_FACETS_SIZE, EDGY_PEOPLE_SIZE, EDGY_TOOLBOX, edgyBoardElement, edgyBoxElement, edgyFacetsElement, edgyPeopleElements, edgyRelationElement, } from './toolbox.js';

package/dist/interchange-headless.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `@labre/affine-gfx-edgy/interchange` — EDGY with no editor behind it.
+ *
+ * EDGY declares no file format. What a host without an editor uses is its
+ * toolbar as pure builders (`docs/adr/0045`): the elements a user places from
+ * the toolbar, for a server or an MCP tool to place the same ones.
+ *
+ * Held by `interchange-headless.unit.spec.ts` in `packages/affine/all`.
+ */
+export { EDGY_FACETS_SIZE, EDGY_PEOPLE_SIZE, EDGY_TOOLBOX, edgyBoardElement, edgyBoxElement, edgyFacetsElement, type EdgyFacetsTexts, edgyPeopleElements, edgyRelationElement, } from './toolbox.js';

package/dist/interchange-headless.js

@@ -0,0 +1,10 @@
+/**
+ * `@labre/affine-gfx-edgy/interchange` — EDGY with no editor behind it.
+ *
+ * EDGY declares no file format. What a host without an editor uses is its
+ * toolbar as pure builders (`docs/adr/0045`): the elements a user places from
+ * the toolbar, for a server or an MCP tool to place the same ones.
+ *
+ * Held by `interchange-headless.unit.spec.ts` in `packages/affine/all`.
+ */
+export { EDGY_FACETS_SIZE, EDGY_PEOPLE_SIZE, EDGY_TOOLBOX, edgyBoardElement, edgyBoxElement, edgyFacetsElement, edgyPeopleElements, edgyRelationElement, } from './toolbox.js';

package/dist/node/consts.js

@@ -1,4 +1,4 @@
-import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
+import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/headless';
 /**
  * Visual constants for the four EDGY base-element nodes. Each node is a NATIVE
  * shape (ShapeElementModel-derived) so its stroke / fill / inner text are

package/dist/presets.d.ts

@@ -1,4 +1,5 @@
-import { type EdgyNodeKind, FontFamily, TextAlign } from '@formicoidea/labre-core/model';
+import type { EdgyNodeKind } from '@formicoidea/labre-core/model';
+import { FontFamily, TextAlign } from '@formicoidea/labre-core/model/headless';
 /**
  * What an EDGY artefact IS, as props — the ONE description the creation sites
  * and the templates both read.
@@ -23,6 +24,13 @@ export type EdgyBoxKind = 'outcome' | 'object' | 'activity';
  * used to spell the same `1.5` out a second time.
  */
 export declare const FACETS_SCALE = 1.5;
+/** Default blank-board size. */
+export declare const EDGY_BOARD_SIZE: {
+    readonly w: 1600;
+    readonly h: 1000;
+};
+/** Stroke width the 24 template relations are drawn with. */
+export declare const RELATION_STROKE_WIDTH = 2;
 /**
  * An EDGY node, as props.
  *

package/dist/presets.js

@@ -1,4 +1,7 @@
-import { FontFamily, ShapeStyle, TextAlign, } from '@formicoidea/labre-core/model';
+// Values from the headless entry, never the model index: the toolbox
+// (`toolbox.ts`, `docs/adr/0045`) builds on these presets from the
+// editor-free `./interchange` entry.
+import { FontFamily, ShapeStyle, TextAlign, } from '@formicoidea/labre-core/model/headless';
 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';
@@ -9,6 +12,10 @@ import { EDGY_ROLE } from './roles.js';
  * used to spell the same `1.5` out a second time.
  */
 export const FACETS_SCALE = 1.5;
+/** Default blank-board size. */
+export const EDGY_BOARD_SIZE = { w: 1600, h: 1000 };
+/** Stroke width the 24 template relations are drawn with. */
+export const RELATION_STROKE_WIDTH = 2;
 /**
  * An EDGY node, as props.
  *

package/dist/toolbox.d.ts

@@ -0,0 +1,67 @@
+import type { FrameworkToolbox, SerializedElementProps, ToolboxPoint } from '@formicoidea/labre-core/interchange';
+import { type EdgyBoxKind } from './presets.js';
+/**
+ * EDGY's toolbar as pure builders (`docs/adr/0045`): what `createEdgyFacets`,
+ * `createEdgyBoard`, `createEdgyPeople`, `createEdgyBox` and the relation tool
+ * place, with no editor behind them. The actions call these, so an element
+ * built here and one placed from the toolbar are the same element.
+ *
+ * "EDGY dynamic" is NOT an item: it inserts a template snapshot through the
+ * template job (`createEdgyDynamic`), not elements a builder can return.
+ */
+/** The facets background is drawn cropped to its circles and their names. */
+export declare const EDGY_FACETS_SIZE: {
+    readonly w: number;
+    readonly h: number;
+};
+/** People's box: the glyph on top, its name centred under it. */
+export declare const EDGY_PEOPLE_SIZE: {
+    readonly w: number;
+    readonly h: number;
+};
+/** The three facet names a facets background writes. */
+export interface EdgyFacetsTexts {
+    identity?: string;
+    architecture?: string;
+    experience?: string;
+}
+/**
+ * The Enterprise Design facets background at `at`, cropped to the circles and
+ * the facet names. The three names are WRITTEN on the element rather than left
+ * to the model's defaults, as `createEdgyFacets` requires: the action passes
+ * them resolved in the host's language, a host passes its own or gets the
+ * English seed.
+ */
+export declare function edgyFacetsElement(at: ToolboxPoint, texts?: EdgyFacetsTexts, local?: string): SerializedElementProps;
+/** A blank EDGY board (the hover spotlight host) at `at`. */
+export declare function edgyBoardElement(at: ToolboxPoint, local?: string): SerializedElementProps;
+/**
+ * An Outcome, Object or Activity at `at`: one node carrying its name as the
+ * shape's own inner text.
+ */
+export declare function edgyBoxElement(kind: EdgyBoxKind, at: ToolboxPoint, name?: string, local?: string): SerializedElementProps;
+/**
+ * People at `at`, the top-left of {@link EDGY_PEOPLE_SIZE}: the glyph's
+ * ellipse centred on top, its name as a free text under it, and the group
+ * that makes the two one thing — last, holding both.
+ *
+ * The group carries no title: the numbered "Group N" the toolbar's group
+ * command writes counts the document's groups and asks the host's catalogue,
+ * which only an editor has (`createEdgyPeople`).
+ */
+export declare function edgyPeopleElements(at: ToolboxPoint, name?: string, local?: string): SerializedElementProps[];
+/**
+ * The connector the relation tool is armed with, between two ends: straight,
+ * the stencil ink, two units wide, no arrowhead, and the GENERIC role.
+ *
+ * The verb is not the builder's: in the editor, `EdgyRelationResolver` names a
+ * generic relation from the roles of the two elements it joins, as a verb role
+ * and a label. A `label` given here is written as the link's text and leaves
+ * the role generic.
+ */
+export declare function edgyRelationElement(from: string, to: string, label?: string): SerializedElementProps;
+/**
+ * Every item of the EDGY toolbar that places elements, in the toolbar's order,
+ * "EDGY dynamic" excepted (see the note at the top of this file).
+ */
+export declare const EDGY_TOOLBOX: FrameworkToolbox;

package/dist/toolbox.js

@@ -0,0 +1,190 @@
+import { ConnectorMode, PointStyle, StrokeStyle, } from '@formicoidea/labre-core/model/headless';
+import { Bound } from '@formicoidea/labre-core/global/gfx';
+import { edgyCommandsManifest } from './commands-manifest.js';
+import { CROP_LABELED } from './facets-crop.js';
+import { edgyElementLabel } from './metamodel.js';
+import { LABEL_GAP, NODE_LABEL, NODE_SIZE, NODE_STROKE } from './node/consts.js';
+import { EDGY_BOARD_SIZE, EDGY_LABEL_H, EDGY_LABEL_W, edgyLabelProps, edgyNodeProps, edgyNodeTextProps, FACETS_SCALE, RELATION_STROKE_WIDTH, } from './presets.js';
+import { EDGY_ROLE } from './roles.js';
+/**
+ * EDGY's toolbar as pure builders (`docs/adr/0045`): what `createEdgyFacets`,
+ * `createEdgyBoard`, `createEdgyPeople`, `createEdgyBox` and the relation tool
+ * place, with no editor behind them. The actions call these, so an element
+ * built here and one placed from the toolbar are the same element.
+ *
+ * "EDGY dynamic" is NOT an item: it inserts a template snapshot through the
+ * template job (`createEdgyDynamic`), not elements a builder can return.
+ */
+/** The facets background is drawn cropped to its circles and their names. */
+export const EDGY_FACETS_SIZE = {
+    w: CROP_LABELED.w * FACETS_SCALE,
+    h: CROP_LABELED.h * FACETS_SCALE,
+};
+/** People's box: the glyph on top, its name centred under it. */
+export const EDGY_PEOPLE_SIZE = {
+    w: Math.max(NODE_SIZE.people.w, EDGY_LABEL_W),
+    h: NODE_SIZE.people.h + LABEL_GAP + EDGY_LABEL_H,
+};
+/**
+ * The Enterprise Design facets background at `at`, cropped to the circles and
+ * the facet names. The three names are WRITTEN on the element rather than left
+ * to the model's defaults, as `createEdgyFacets` requires: the action passes
+ * them resolved in the host's language, a host passes its own or gets the
+ * English seed.
+ */
+export function edgyFacetsElement(at, texts = {}, local = 'facets') {
+    const name = (zone) => texts[zone]?.trim() || edgyElementLabel(zone);
+    return {
+        type: 'edgy',
+        id: local,
+        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,
+        identityLabel: name('identity'),
+        architectureLabel: name('architecture'),
+        experienceLabel: name('experience'),
+        xywh: new Bound(at.x, at.y, EDGY_FACETS_SIZE.w, EDGY_FACETS_SIZE.h).serialize(),
+    };
+}
+/** A blank EDGY board (the hover spotlight host) at `at`. */
+export function edgyBoardElement(at, local = 'board') {
+    return {
+        type: 'edgyBoard',
+        id: local,
+        // 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(at.x, at.y, EDGY_BOARD_SIZE.w, EDGY_BOARD_SIZE.h).serialize(),
+    };
+}
+/**
+ * An Outcome, Object or Activity at `at`: one node carrying its name as the
+ * shape's own inner text.
+ */
+export function edgyBoxElement(kind, at, name, local = kind) {
+    const { w, h } = NODE_SIZE[kind];
+    return {
+        ...edgyNodeProps(kind, {
+            xywh: new Bound(at.x, at.y, w, h).serialize(),
+        }),
+        ...edgyNodeTextProps(name?.trim() || NODE_LABEL[kind]),
+        id: local,
+    };
+}
+/**
+ * People at `at`, the top-left of {@link EDGY_PEOPLE_SIZE}: the glyph's
+ * ellipse centred on top, its name as a free text under it, and the group
+ * that makes the two one thing — last, holding both.
+ *
+ * The group carries no title: the numbered "Group N" the toolbar's group
+ * command writes counts the document's groups and asks the host's catalogue,
+ * which only an editor has (`createEdgyPeople`).
+ */
+export function edgyPeopleElements(at, name, local = 'people') {
+    const { w, h } = NODE_SIZE.people;
+    const id = (part) => `${local}:${part}`;
+    const members = [
+        {
+            ...edgyNodeProps('people', {
+                xywh: new Bound(at.x + (EDGY_PEOPLE_SIZE.w - w) / 2, at.y, w, h).serialize(),
+            }),
+            id: id('node'),
+        },
+        {
+            ...edgyLabelProps(name?.trim() || NODE_LABEL.people, at.x + (EDGY_PEOPLE_SIZE.w - EDGY_LABEL_W) / 2, at.y + h + LABEL_GAP),
+            id: id('label'),
+        },
+    ];
+    return [
+        ...members,
+        {
+            type: 'group',
+            id: id('group'),
+            children: Object.fromEntries(members.map(m => [m.id, true])),
+        },
+    ];
+}
+/**
+ * The connector the relation tool is armed with, between two ends: straight,
+ * the stencil ink, two units wide, no arrowhead, and the GENERIC role.
+ *
+ * The verb is not the builder's: in the editor, `EdgyRelationResolver` names a
+ * generic relation from the roles of the two elements it joins, as a verb role
+ * and a label. A `label` given here is written as the link's text and leaves
+ * the role generic.
+ */
+export function edgyRelationElement(from, to, label) {
+    return {
+        type: 'connector',
+        mode: ConnectorMode.Straight,
+        role: EDGY_ROLE.relation,
+        stroke: NODE_STROKE,
+        strokeStyle: StrokeStyle.Solid,
+        strokeWidth: RELATION_STROKE_WIDTH,
+        frontEndpointStyle: PointStyle.None,
+        rearEndpointStyle: PointStyle.None,
+        source: { id: from },
+        target: { id: to },
+        ...(label?.trim() ? { text: label.trim() } : {}),
+    };
+}
+/** The toolbar command's label, so a host names an item as the toolbar does. */
+function label(commandId) {
+    const row = edgyCommandsManifest.find(r => r.id === commandId);
+    return {
+        labelKey: row?.labelKey ?? commandId,
+        labelFallback: row?.labelFallback ?? commandId,
+    };
+}
+const BOX_COMMANDS = {
+    outcome: 'edgy.addOutcome',
+    object: 'edgy.addObject',
+    activity: 'edgy.addActivity',
+};
+const boxItem = (kind) => ({
+    id: kind,
+    ...label(BOX_COMMANDS[kind]),
+    texts: ['name'],
+    size: NODE_SIZE[kind],
+    build: (at, texts, local) => [edgyBoxElement(kind, at, texts?.name, local)],
+});
+const relation = {
+    id: 'relation',
+    ...label('edgy.addRelation'),
+    build: edgyRelationElement,
+};
+/**
+ * Every item of the EDGY toolbar that places elements, in the toolbar's order,
+ * "EDGY dynamic" excepted (see the note at the top of this file).
+ */
+export const EDGY_TOOLBOX = {
+    framework: 'edgy',
+    items: [
+        {
+            id: 'facets',
+            ...label('edgy.addFacets'),
+            texts: ['identity', 'architecture', 'experience'],
+            size: EDGY_FACETS_SIZE,
+            build: (at, texts, local) => [edgyFacetsElement(at, texts, local)],
+        },
+        {
+            id: 'board',
+            ...label('edgy.addBoard'),
+            texts: [],
+            size: EDGY_BOARD_SIZE,
+            build: (at, _texts, local) => [edgyBoardElement(at, local)],
+        },
+        {
+            id: 'people',
+            ...label('edgy.addPeople'),
+            texts: ['name'],
+            size: EDGY_PEOPLE_SIZE,
+            build: (at, texts, local) => edgyPeopleElements(at, texts?.name, local),
+        },
+        boxItem('outcome'),
+        boxItem('object'),
+        boxItem('activity'),
+    ],
+    links: [relation],
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-framework-edgy",
   "description": "Labre edgy framework for @formicoidea/labre-core.",
-  "version": "0.59.0",
+  "version": "0.61.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -25,13 +25,17 @@
     "./commands-manifest": {
       "types": "./dist/commands-manifest.d.ts",
       "import": "./dist/commands-manifest.js"
+    },
+    "./interchange": {
+      "types": "./dist/interchange-headless.d.ts",
+      "import": "./dist/interchange-headless.js"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.59.0",
+    "@formicoidea/labre-core": "0.61.0",
     "@preact/signals-core": "^1.8.0",
     "lit": "^3.2.0",
     "yjs": "^13.6.21"