@formicoidea/labre-framework-wardley 0.58.0 → 0.60.0

package/dist/actions.d.ts

@@ -4,6 +4,7 @@ import type { BlockStdScope } from '@formicoidea/labre-core/std';
 import { type GfxController, type GfxPrimitiveElementModel } from '@formicoidea/labre-core/std/gfx';
 import { type WardleyExportBoard } from './export.js';
 import { type WardleyAreaShape, type WardleyArtefactKind } from './presets.js';
+import { WARDLEY_AXIS_SEED } from './toolbox.js';
 /**
  * Standalone creation/activation actions for the Wardley toolbox — the
  * BEHAVIOUR layer, shared by every surface. They only depend on the
@@ -14,25 +15,7 @@ import { type WardleyAreaShape, type WardleyArtefactKind } from './presets.js';
  * every surface goes through. `WardleyActionSource` is gone with it — the
  * segment/module discrimination it carried is now `CommandInvocation.surface`.
  */
-/**
- * The three axis words a translated variant's background is seeded with —
- * declared once, so the resolver below and the manifest
- * (`../translations.ts`) read the very same fallback.
- */
-export declare const WARDLEY_AXIS_SEED: {
-    readonly opportunity: {
-        readonly key: "com.labre.wardley.seed.axis-opportunity";
-        readonly fallback: "Opportunity";
-    };
-    readonly benefit: {
-        readonly key: "com.labre.wardley.seed.axis-benefit";
-        readonly fallback: "Benefit";
-    };
-    readonly investment: {
-        readonly key: "com.labre.wardley.seed.axis-investment";
-        readonly fallback: "Investment";
-    };
-};
+export { WARDLEY_AXIS_SEED };
 /**
  * The single-circle node flavours: one connectable ellipse + a label to its
  * right, grouped. The glyph itself (anchor silhouette, ecosystem hatching,
@@ -116,6 +99,7 @@ export declare function createWardleyPorter(gfx: GfxController): void;
  * SemiBold, which no other Wardley label is: these two are annotations laid
  * over a map that is already full of names, and the weight is what keeps the
  * word readable as a remark ABOUT the map rather than as one more component.
+ * Both rules are the builder's (`wardleyNodeElements`).
  */
 export declare function createWardleyAccelerator(gfx: GfxController, kind: 'accelerator' | 'decelerator'): void;
 /**

package/dist/actions.js

@@ -2,7 +2,7 @@ import { backgroundSize, containingFrame, DefaultTool, indexOverBackgrounds, run
 import { ConnectorTool } from '@formicoidea/labre-core/gfx/connector';
 import { createGroupCommand } from '@formicoidea/labre-core/gfx/group';
 import { PolygonTool } from '@formicoidea/labre-core/gfx/shape';
-import { ConnectorMode, FontWeight, FrameworkBackgroundElementModel, TextElementModel, WardleyBackgroundElementModel, } from '@formicoidea/labre-core/model';
+import { ConnectorMode, FrameworkBackgroundElementModel, TextElementModel, WardleyBackgroundElementModel, } from '@formicoidea/labre-core/model';
 import { NotificationProvider, translateKey, } from '@formicoidea/labre-core/shared/services';
 import { downloadBlob } from '@formicoidea/labre-core/shared/utils';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
@@ -12,9 +12,10 @@ import { WARDLEY_SVG_IMPORT } from './interchange.js';
 import { wardleySafeFilename } from './export.js';
 import { wardleyBoardFrom } from './export-board.js';
 import { WARDLEY_OWM_EXPORT, WARDLEY_OWM_IMPORT } from './interchange.js';
-import { INERTIA_SIZE, PORTER_DEFAULT_LETTER } from './node/consts.js';
-import { wardleyAreaBox, wardleyAreaProps, wardleyCanonicalBox, WARDLEY_EDGE_STYLE, wardleyHandleBox, wardleyHandleProps, wardleyInertiaProps, wardleyLabelBoxFor, wardleyLabelProps, wardleyMarketDotBoxes, wardleyMarketDotProps, wardleyMarketLinkPairs, wardleyMarketLinkProps, WARDLEY_NODE_LABEL, wardleyNodeLabelKey, wardleyNodeProps, wardleyPorterArrowProps, wardleyPorterArrows, wardleyPorterLetterProps, } from './presets.js';
+import { INERTIA_SIZE, PORTER_SIZE } from './node/consts.js';
+import { wardleyAreaBox, wardleyAreaProps, WARDLEY_AREA_SIZE, WARDLEY_EDGE_STYLE, WARDLEY_NODE_LABEL, WARDLEY_NODE_SIZE, wardleyNodeLabelKey, } from './presets.js';
 import { WARDLEY_ROLE } from './roles.js';
+import { WARDLEY_AXIS_SEED, wardleyAreaElement, wardleyInertiaElement, wardleyMapElement, wardleyMarketElements, wardleyNodeElements, wardleyPipelineElements, wardleyPorterElements, } from './toolbox.js';
 /**
  * Standalone creation/activation actions for the Wardley toolbox — the
  * BEHAVIOUR layer, shared by every surface. They only depend on the
@@ -25,61 +26,27 @@ import { WARDLEY_ROLE } from './roles.js';
  * every surface goes through. `WardleyActionSource` is gone with it — the
  * segment/module discrimination it carried is now `CommandInvocation.surface`.
  */
+// Declared with the editor-free toolbox (`docs/adr/0045`), which writes the
+// English fallbacks; re-exported here unchanged.
+export { WARDLEY_AXIS_SEED };
 /**
- * The three axis words a translated variant's background is seeded with —
- * declared once, so the resolver below and the manifest
- * (`../translations.ts`) read the very same fallback.
- */
-export const WARDLEY_AXIS_SEED = {
-    opportunity: {
-        key: 'com.labre.wardley.seed.axis-opportunity',
-        fallback: 'Opportunity',
-    },
-    benefit: {
-        key: 'com.labre.wardley.seed.axis-benefit',
-        fallback: 'Benefit',
-    },
-    investment: {
-        key: 'com.labre.wardley.seed.axis-investment',
-        fallback: 'Investment',
-    },
-};
-/**
- * Per-variant default label overrides applied at creation (all remain editable
- * afterwards via the inline editor / toggles). The gradient itself is driven by
- * `variant` in the renderer.
+ * The three axis words a translated variant's background is seeded with,
+ * resolved through the host's catalogue.
  *
  * Resolved through the translation seam since the i18n pass (#278): the ten
  * label props still default to `undefined` on the declaration itself, but
  * `opportunity` and `benefit` are the two variants whose Y axis is PROSE the
- * gesture bakes into the document at creation — `WARDLEY_AXIS_SEED` above is
- * what a host's catalogue is offered for the three words, resolved HERE, once,
- * exactly like every other seed in this file. `classic` and
- * `evolution-gradient` keep the classic labels (Value Chain / Uncharted /
- * Industrialized…), which are declaration `labelKey`s and were already fully
- * localisable — this function names no override for them.
+ * gesture bakes into the document at creation — `WARDLEY_AXIS_SEED` is what a
+ * host's catalogue is offered for the three words, resolved HERE, once,
+ * exactly like every other seed in this file. Which variant writes which word
+ * is the builder's (`wardleyMapElement`).
  */
-function backgroundVariantDefaults(gfx) {
+function axisSeeds(gfx) {
     const axis = (def) => translateKey(gfx.std, def.key, def.fallback);
     return {
-        classic: {},
-        // The Y axis becomes "Opportunity"; phase labels keep the classic defaults.
-        opportunity: {
-            yAxisTitle: axis(WARDLEY_AXIS_SEED.opportunity),
-            showVisibilityLabels: false,
-            showCornerLabels: false,
-        },
-        // The Y axis splits into Benefit (top) / Investment (bottom) around a zero
-        // line drawn by the renderer.
-        benefit: {
-            yAxisTitle: '',
-            visibilityHigh: axis(WARDLEY_AXIS_SEED.benefit),
-            visibilityLow: axis(WARDLEY_AXIS_SEED.investment),
-            showCornerLabels: false,
-        },
-        // Keeps the classic labels (Value Chain / Uncharted / Industrialized…); only
-        // the grey gradient differs.
-        'evolution-gradient': {},
+        opportunity: axis(WARDLEY_AXIS_SEED.opportunity),
+        benefit: axis(WARDLEY_AXIS_SEED.benefit),
+        investment: axis(WARDLEY_AXIS_SEED.investment),
     };
 }
 function finish(gfx, id) {
@@ -97,26 +64,63 @@ function group(gfx, ids) {
     return result.groupId || ids[0];
 }
 /**
- * Add a wardley node of one kind, at its canonical size, centred on (cx, cy).
- *
- * The APPEARANCE is {@link wardleyNodeProps}' and nothing else: the palette and
- * the "Change type" dropdown read that one description, so a market drawn here
- * and a component morphed into one are the same element (`presets.ts`).
+ * Write what a toolbox builder returned (`toolbox.ts`, `docs/adr/0045`) and
+ * return the id of the LAST element — the outermost group of a composite, or
+ * the one element of a single artefact — which is what the gesture selects.
  *
- * `extra` is for what a preset cannot carry — the Porter's-forces letter, which
- * is CONTENT the author then edits, not a look. `wardleyMorphProps` strips
- * `text` for exactly that reason, so a preset that wrote one would be a preset
- * the morph has to un-write.
+ * The builder is the ONE assembly of an artefact, shared with a host that has
+ * no editor; what stays here is what only an editor has. Local ids are minted
+ * in order, so a connector's ends and a group's members, which always come
+ * after the elements they name, resolve to the real ids. A group goes through
+ * {@link createGroupCommand} as it always has, which writes the group's
+ * translated title and its layer: the builder only says who the members are.
  */
-function addNode(surface, kind, cx, cy, extra = {}) {
-    return surface.addElement({
-        ...wardleyNodeProps(kind, { xywh: wardleyCanonicalBox(kind, cx, cy) }),
-        ...extra,
-    });
+function place(gfx, elements) {
+    const surface = gfx.surface;
+    if (!surface)
+        return;
+    const minted = new Map();
+    const real = (local) => minted.get(local) ?? local;
+    let last;
+    for (const { id: local, ...props } of elements) {
+        if (props.type === 'group') {
+            const children = Object.keys(props.children);
+            last = group(gfx, children.map(real));
+        }
+        else {
+            for (const end of ['source', 'target']) {
+                const ref = props[end];
+                if (ref?.id !== undefined)
+                    props[end] = { ...ref, id: real(ref.id) };
+            }
+            last = surface.addElement(props);
+        }
+        if (typeof local === 'string' && last)
+            minted.set(local, last);
+    }
+    return last;
+}
+/** The point that centres a box of `w`×`h` on the viewport. */
+function viewportTopLeft(gfx, w, h) {
+    const { centerX, centerY } = gfx.viewport;
+    return { x: centerX - w / 2, y: centerY - h / 2 };
+}
+/**
+ * A labelled kind's name prompt, resolved HERE, once — the prompt a node
+ * nobody has named still carries, exactly like a BPMN node's caption.
+ * `gfx.std` is how this file reaches the translation seam: these creation
+ * sites take `GfxController`, not `BlockStdScope`, directly (`WardleyView`
+ * reads the same member).
+ */
+function seedName(gfx, kind) {
+    return translateKey(gfx.std, wardleyNodeLabelKey(kind), WARDLEY_NODE_LABEL[kind]);
 }
-/** Add a native free-text label (same Inter family as the axis labels). */
-function addLabel(surface, text, x, y, textAlign = 'left', fontWeight = FontWeight.Regular) {
-    return surface.addElement(wardleyLabelProps(text, x, y, textAlign, fontWeight));
+/** Place a node + name composite of one kind, centred on the viewport. */
+function placeNode(gfx, kind) {
+    const { w, h } = WARDLEY_NODE_SIZE[kind];
+    const id = place(gfx, wardleyNodeElements(kind, viewportTopLeft(gfx, w, h), seedName(gfx, kind)));
+    if (id)
+        finish(gfx, id);
 }
 /** Create a wardley map background of the given variant, viewport-centered. */
 export function createWardleyBackground(gfx, variant = 'classic') {
@@ -132,22 +136,12 @@ export function createWardleyBackground(gfx, variant = 'classic') {
         atLeastWidth = Math.max(atLeastWidth, ew);
         atLeastHeight = Math.max(atLeastHeight, eh);
     }
-    const { width, height } = backgroundSize(WARDLEY_BACKGROUND, atLeastWidth, atLeastHeight);
-    const { centerX, centerY } = gfx.viewport;
-    const id = gfx.surface.addElement({
-        type: WARDLEY_BACKGROUND.type,
-        // The map is a first-class role: validation rules position artefacts
-        // against `wardley:map`, never against the `wardley` element type. The
-        // declaration owns it, so a templated map and a hand-drawn one agree.
-        role: WARDLEY_BACKGROUND.role,
-        // A map is a frame you place things on, not a shape you nudge — the
-        // declaration decides, and the toolbar toggle takes over from there.
-        resizeEnabled: WARDLEY_BACKGROUND.geometry.resizable,
-        variant,
-        ...backgroundVariantDefaults(gfx)[variant],
-        xywh: new Bound(centerX - width / 2, centerY - height / 2, width, height).serialize(),
-    });
-    finish(gfx, id);
+    const size = backgroundSize(WARDLEY_BACKGROUND, atLeastWidth, atLeastHeight);
+    const id = place(gfx, [
+        wardleyMapElement(variant, viewportTopLeft(gfx, size.width, size.height), axisSeeds(gfx), undefined, size),
+    ]);
+    if (id)
+        finish(gfx, id);
 }
 /**
  * Create a single-circle node (component / anchor / ecosystem / method):
@@ -155,30 +149,14 @@ export function createWardleyBackground(gfx, variant = 'classic') {
  * move together (enter the group to reposition / edit the label).
  */
 export function createWardleyNode(gfx, kind) {
-    const surface = gfx.surface;
-    if (!surface)
-        return;
-    const { centerX: cx, centerY: cy } = gfx.viewport;
-    const nodeId = addNode(surface, kind, cx, cy);
-    const { x, y, textAlign } = wardleyLabelBoxFor(kind, cx, cy);
-    const labelId = addLabel(surface, 
-    // Resolved HERE, once — the prompt a node nobody has named still carries,
-    // exactly like a BPMN node's caption. `gfx.std` is how this file reaches
-    // the translation seam: these creation sites take `GfxController`, not
-    // `BlockStdScope`, directly (`WardleyView` reads the same member).
-    translateKey(gfx.std, wardleyNodeLabelKey(kind), WARDLEY_NODE_LABEL[kind]), x, y, textAlign);
-    finish(gfx, group(gfx, [nodeId, labelId]));
+    placeNode(gfx, kind);
 }
 /** Create an inertia bar (filled black rect). */
 export function createWardleyInertia(gfx) {
-    if (!gfx.surface)
-        return;
     const { w, h } = INERTIA_SIZE;
-    const { centerX, centerY } = gfx.viewport;
-    const id = gfx.surface.addElement(wardleyInertiaProps({
-        xywh: new Bound(centerX - w / 2, centerY - h / 2, w, h).serialize(),
-    }));
-    finish(gfx, id);
+    const id = place(gfx, [wardleyInertiaElement(viewportTopLeft(gfx, w, h))]);
+    if (id)
+        finish(gfx, id);
 }
 /**
  * Create a pipeline: a wide thin native rect body (white semi-transparent,
@@ -188,20 +166,10 @@ export function createWardleyInertia(gfx) {
  * moves as one. Pure composition of native elements — no custom type / view.
  */
 export function createWardleyPipeline(gfx) {
-    if (!gfx.surface)
-        return;
-    const { centerX: cx, centerY: cy } = gfx.viewport;
-    // Body: a WardleyNode rect, made non-connectable by `kind: 'pipeline'`.
-    const bodyId = addNode(gfx.surface, 'pipeline', cx, cy);
-    // Handle: a node-sized WardleyNode square straddling the top edge. Inherits
-    // `centerAnchorOnly` so connectors attach to its center only.
-    const handleId = gfx.surface.addElement(wardleyHandleProps({ xywh: wardleyHandleBox(cx, cy) }));
-    // Label centered horizontally on the pipeline, sitting ABOVE the handle.
-    const { x, y, textAlign } = wardleyLabelBoxFor('pipeline', cx, cy);
-    const labelId = addLabel(gfx.surface, translateKey(gfx.std, wardleyNodeLabelKey('pipeline'), WARDLEY_NODE_LABEL.pipeline), x, y, textAlign);
-    // Nested groups: (handle + label), then (body + that group).
-    const innerId = group(gfx, [handleId, labelId]);
-    finish(gfx, group(gfx, [bodyId, innerId]));
+    const { w, h } = WARDLEY_NODE_SIZE.pipeline;
+    const id = place(gfx, wardleyPipelineElements(viewportTopLeft(gfx, w, h), seedName(gfx, 'pipeline')));
+    if (id)
+        finish(gfx, id);
 }
 /**
  * Create a market: a large thin-bordered circle (the connectable market node)
@@ -211,19 +179,10 @@ export function createWardleyPipeline(gfx) {
  * everything is grouped into one object.
  */
 export function createWardleyMarket(gfx) {
-    const surface = gfx.surface;
-    if (!surface)
-        return;
-    const { centerX: cx, centerY: cy } = gfx.viewport;
-    // Outer circle = the market node (connectable, center-only).
-    const circleId = addNode(surface, 'market', cx, cy);
-    // 3 inner component nodes (thick border, no label) at the triangle vertices.
-    const dotIds = wardleyMarketDotBoxes(cx, cy).map(xywh => surface.addElement(wardleyMarketDotProps({ xywh })));
-    // Triangle: 3 attached connectors (auto-route center-to-center, clipped).
-    const connIds = wardleyMarketLinkPairs(dotIds).map(([a, b]) => surface.addElement(wardleyMarketLinkProps(a, b)));
-    const { x, y, textAlign } = wardleyLabelBoxFor('market', cx, cy);
-    const labelId = addLabel(surface, translateKey(gfx.std, wardleyNodeLabelKey('market'), WARDLEY_NODE_LABEL.market), x, y, textAlign);
-    finish(gfx, group(gfx, [circleId, ...dotIds, ...connIds, labelId]));
+    const { w, h } = WARDLEY_NODE_SIZE.market;
+    const id = place(gfx, wardleyMarketElements(viewportTopLeft(gfx, w, h), seedName(gfx, 'market')));
+    if (id)
+        finish(gfx, id);
 }
 /**
  * Create a Porter's-forces glyph: a white circle carrying ONE letter, pushed on
@@ -243,13 +202,9 @@ export function createWardleyMarket(gfx) {
  * outside the rim — exactly as the market's triangle is its own.
  */
 export function createWardleyPorter(gfx) {
-    const surface = gfx.surface;
-    if (!surface)
-        return;
-    const { centerX: cx, centerY: cy } = gfx.viewport;
-    const circleId = addNode(surface, 'porter', cx, cy, wardleyPorterLetterProps(PORTER_DEFAULT_LETTER));
-    const arrowIds = wardleyPorterArrows(cx, cy).map(arrow => surface.addElement(wardleyPorterArrowProps(arrow)));
-    finish(gfx, group(gfx, [circleId, ...arrowIds]));
+    const id = place(gfx, wardleyPorterElements(viewportTopLeft(gfx, PORTER_SIZE, PORTER_SIZE)));
+    if (id)
+        finish(gfx, id);
 }
 /**
  * Create an accelerator or a decelerator: one fat native POLYGON and the words
@@ -274,18 +229,10 @@ export function createWardleyPorter(gfx) {
  * SemiBold, which no other Wardley label is: these two are annotations laid
  * over a map that is already full of names, and the weight is what keeps the
  * word readable as a remark ABOUT the map rather than as one more component.
+ * Both rules are the builder's (`wardleyNodeElements`).
  */
 export function createWardleyAccelerator(gfx, kind) {
-    const surface = gfx.surface;
-    if (!surface)
-        return;
-    const { centerX: cx, centerY: cy } = gfx.viewport;
-    const nodeId = addNode(surface, kind, cx, cy);
-    // Which side, and which alignment, are the placement's answer: the
-    // decelerator's mirrored label is one of the two rules `presets.ts` states.
-    const { x, y, textAlign } = wardleyLabelBoxFor(kind, cx, cy);
-    const labelId = addLabel(surface, translateKey(gfx.std, wardleyNodeLabelKey(kind), WARDLEY_NODE_LABEL[kind]), x, y, textAlign, FontWeight.SemiBold);
-    finish(gfx, group(gfx, [nodeId, labelId]));
+    placeNode(gfx, kind);
 }
 /**
  * Create an AREA: a translucent zone of the map, drawn as a rectangle or as a
@@ -311,8 +258,15 @@ export function createWardleyArea(gfx, shape) {
     if (!surface)
         return;
     const { centerX: cx, centerY: cy } = gfx.viewport;
-    const xywh = wardleyAreaBox(shape, cx, cy);
-    const id = surface.addElement(wardleyAreaProps(shape, { xywh }));
+    // The rectangle is a toolbox item (`wardleyAreaElement`); the polygon is
+    // drawn corner by corner from the palette ({@link activateWardleyAreaPolygon})
+    // and placed whole only by a caller of this function.
+    const { w, h } = WARDLEY_AREA_SIZE.rect;
+    const id = shape === 'rect'
+        ? place(gfx, [wardleyAreaElement(viewportTopLeft(gfx, w, h))])
+        : surface.addElement(wardleyAreaProps(shape, { xywh: wardleyAreaBox(shape, cx, cy) }));
+    if (!id)
+        return;
     lowerWardleyArea(gfx, id);
     finish(gfx, id);
 }

package/dist/import.js

@@ -1,9 +1,10 @@
 import { ConnectorMode, FontFamily, FontWeight, PointStyle, ShapeStyle, StrokeStyle, TextAlign, } from '@formicoidea/labre-core/model/headless';
 import { WARDLEY_BACKGROUND } from './background.js';
 import { OWM_DEFAULT_MAP_HEIGHT, OWM_DEFAULT_MAP_WIDTH, OWM_LABEL_HEIGHT, OWM_LABEL_WIDTH, OWM_SCOPE, OWM_TAIL_ATTR, OWM_KEYWORDS, OWM_TITLE_ATTR, owmDefaultPlot, owmPointOf, WARDLEY_OWM_FORMAT_ID, } from './export.js';
-import { HANDLE_SIZE, INERTIA_SIZE, LABEL_GAP, LABEL_FONT_SIZE, LINK_GREY, LINK_STROKE_WIDTH, MARKET_DOT_RING, MARKET_DOT_SIZE, MARKET_DOT_STROKE_WIDTH, MARKET_LINK_COLOR, MARKET_LINK_WIDTH, MARKET_SIZE, ECOSYSTEM_SIZE, NODE_FILL, NODE_SIZE, NODE_STROKE, NODE_STROKE_WIDTH, PIPELINE_FILL, PIPELINE_HEIGHT, WARDLEY_RED, } from './node/consts.js';
+import { HANDLE_SIZE, INERTIA_SIZE, LABEL_GAP, LABEL_FONT_SIZE, MARKET_DOT_RING, MARKET_DOT_SIZE, MARKET_DOT_STROKE_WIDTH, MARKET_LINK_COLOR, MARKET_LINK_WIDTH, MARKET_SIZE, ECOSYSTEM_SIZE, NODE_FILL, NODE_SIZE, NODE_STROKE, NODE_STROKE_WIDTH, PIPELINE_FILL, PIPELINE_HEIGHT, WARDLEY_RED, } from './node/consts.js';
 import { WARDLEY_NODE_SIZE, wardleyInertiaProps, wardleyNodeProps, } from './presets.js';
 import { WARDLEY_ROLE } from './roles.js';
+import { wardleyChangeArrowElement, wardleyDependencyElement, } from './toolbox.js';
 /**
  * The OWM import remarks whose wording is FIXED, as `[key, English]` pairs.
  *
@@ -778,36 +779,16 @@ export function layoutWardleyStatements(statements, options) {
         });
         elements.push(label(evolution.becomes, cx + NODE_SIZE / 2 + LABEL_GAP, cy - OWM_LABEL_HEIGHT / 2, TextAlign.Left, WARDLEY_RED));
     }
+    // The two edges are the toolbar's own (`toolbox.ts`, `docs/adr/0045`): an
+    // arrow read from a file and one drawn with the tool are one assembly.
     evolutions.forEach((evolution, index) => {
-        elements.push({
-            type: 'connector',
-            mode: ConnectorMode.Straight,
-            role: WARDLEY_ROLE.changeArrow,
-            stroke: WARDLEY_RED,
-            strokeStyle: StrokeStyle.Dash,
-            strokeWidth: LINK_STROKE_WIDTH,
-            frontEndpointStyle: PointStyle.None,
-            rearEndpointStyle: PointStyle.Triangle,
-            source: { id: identity(evolution) },
-            target: { id: twinHandles[index] },
-        });
+        elements.push(wardleyChangeArrowElement(identity(evolution), twinHandles[index]));
     });
     for (const link of links) {
-        elements.push({
-            type: 'connector',
-            mode: ConnectorMode.Straight,
-            // The value-chain link. `source` is the CONSUMER and `target` is what it
-            // needs — the verb of `wardley:dependency` (ADR 0010), which is exactly
-            // what `A->B` says in this DSL. Never inverted.
-            role: WARDLEY_ROLE.dependency,
-            stroke: LINK_GREY,
-            strokeStyle: StrokeStyle.Solid,
-            strokeWidth: LINK_STROKE_WIDTH,
-            frontEndpointStyle: PointStyle.None,
-            rearEndpointStyle: PointStyle.None,
-            source: { id: link.from },
-            target: { id: link.to },
-        });
+        // The value-chain link. `source` is the CONSUMER and `target` is what it
+        // needs — the verb of `wardley:dependency` (ADR 0010), which is exactly
+        // what `A->B` says in this DSL. Never inverted.
+        elements.push(wardleyDependencyElement(link.from, link.to));
     }
     for (const inertia of inertias) {
         const [cx, cy] = owmPointOf(plot, inertia.visibility, inertia.evolution);

package/dist/index.d.ts

@@ -27,6 +27,7 @@ export { WARDLEY_BACKGROUND } from './background.js';
  */
 export { exportWardleyOwm, exportWardleyOwmWithWarnings, OWM_SCOPE, type OwmPlot, owmCoordsOf, owmPlotOf, owmPointOf, WARDLEY_OWM_FORMAT_ID, type WardleyExportBoard, wardleySafeFilename, } from './export.js';
 export { wardleyBoardFrom } from './export-board.js';
+export { WARDLEY_AXIS_SEED, WARDLEY_TOOLBOX, wardleyAreaElement, wardleyChangeArrowElement, wardleyDependencyElement, wardleyInertiaElement, wardleyMapElement, type WardleyMapTexts, wardleyMarketElements, type WardleyNodeItemKind, wardleyNodeElements, wardleyPipelineElements, wardleyPorterElements, } from './toolbox.js';
 export { importWardleyOwm } from './import.js';
 export { importWardleySvg } from './svg-import.js';
 export { wardleyBoardOf, wardleyExportElementsOf, wardleyMapsSelected, } from './actions.js';

package/dist/index.js

@@ -39,6 +39,8 @@ export { WARDLEY_BACKGROUND } from './background.js';
  */
 export { exportWardleyOwm, exportWardleyOwmWithWarnings, OWM_SCOPE, owmCoordsOf, owmPlotOf, owmPointOf, WARDLEY_OWM_FORMAT_ID, wardleySafeFilename, } from './export.js';
 export { wardleyBoardFrom } from './export-board.js';
+// The toolbar as pure builders (`docs/adr/0045`), also on `./interchange`.
+export { WARDLEY_AXIS_SEED, WARDLEY_TOOLBOX, wardleyAreaElement, wardleyChangeArrowElement, wardleyDependencyElement, wardleyInertiaElement, wardleyMapElement, wardleyMarketElements, wardleyNodeElements, wardleyPipelineElements, wardleyPorterElements, } from './toolbox.js';
 export { importWardleyOwm } from './import.js';
 // The SVG reader that recognises a map (ADR 0032), pure for the same reason:
 // labre-mcp calls the very function the command does.

package/dist/interchange-headless.d.ts

@@ -62,3 +62,4 @@ export declare const WARDLEY_SVG_FORMAT: InterchangeFormat;
  * {@link WARDLEY_OWM_IMPORT} beside it stays the reference Wardley import.
  */
 export declare const WARDLEY_SVG_IMPORT: InterchangeImportCapability;
+export { WARDLEY_AXIS_SEED, WARDLEY_TOOLBOX, wardleyAreaElement, wardleyChangeArrowElement, wardleyDependencyElement, wardleyInertiaElement, wardleyMapElement, type WardleyMapTexts, wardleyMarketElements, type WardleyNodeItemKind, wardleyNodeElements, wardleyPipelineElements, wardleyPorterElements, } from './toolbox.js';

package/dist/interchange-headless.js

@@ -89,3 +89,6 @@ export const WARDLEY_SVG_IMPORT = {
     direction: 'import',
     run: importWardleySvg,
 };
+// The toolbar as pure builders (`docs/adr/0045`): what a host with no editor
+// places to draw the very elements a user places from the toolbar.
+export { WARDLEY_AXIS_SEED, WARDLEY_TOOLBOX, wardleyAreaElement, wardleyChangeArrowElement, wardleyDependencyElement, wardleyInertiaElement, wardleyMapElement, wardleyMarketElements, wardleyNodeElements, wardleyPipelineElements, wardleyPorterElements, } from './toolbox.js';

package/dist/toolbox.d.ts

@@ -0,0 +1,94 @@
+import type { FrameworkToolbox, SerializedElementProps, ToolboxPoint } from '@formicoidea/labre-core/interchange';
+import type { WardleyBgVariant } from '@formicoidea/labre-core/model';
+/**
+ * Wardley's toolbar as pure builders (`docs/adr/0045`): what the sub-menu's
+ * creation actions (`actions.ts`) place, with no editor behind them. The
+ * actions call these, so an artefact a host builds and one a user places from
+ * the toolbar are the same elements.
+ *
+ * Each builder is the TOOLBAR's artefact, not the OWM reader's: the reader
+ * (`import.ts`) lays a whole file out with a wider label box and a larger
+ * anchor, and draws no group. Every prop that is not geometry is the same on
+ * both paths (`toolbox.unit.spec.ts` holds the two to it).
+ */
+/**
+ * The three axis words a translated variant's background is seeded with —
+ * declared once, so the builder below, the editor action that resolves them
+ * and the manifest (`translations.ts`) read the very same fallback. Moved here
+ * from `actions.ts`, which re-exports it unchanged.
+ */
+export declare const WARDLEY_AXIS_SEED: {
+    readonly opportunity: {
+        readonly key: "com.labre.wardley.seed.axis-opportunity";
+        readonly fallback: "Opportunity";
+    };
+    readonly benefit: {
+        readonly key: "com.labre.wardley.seed.axis-benefit";
+        readonly fallback: "Benefit";
+    };
+    readonly investment: {
+        readonly key: "com.labre.wardley.seed.axis-investment";
+        readonly fallback: "Investment";
+    };
+};
+/** The axis words a map variant writes, by seed name; English when absent. */
+export type WardleyMapTexts = Partial<Record<keyof typeof WARDLEY_AXIS_SEED, string>>;
+/**
+ * A map background of one variant at `at`, at the declaration's reference
+ * size unless `size` says otherwise (the editor passes the size of the
+ * biggest map already on the board, which only an editor can read).
+ */
+export declare function wardleyMapElement(variant: WardleyBgVariant, at: ToolboxPoint, texts?: WardleyMapTexts, local?: string, size?: {
+    width: number;
+    height: number;
+}): SerializedElementProps;
+/** The kinds drawn as one node and the name beside it, grouped. */
+export type WardleyNodeItemKind = 'component' | 'method' | 'ecosystem' | 'anchor' | 'accelerator' | 'decelerator';
+/**
+ * A single node at `at` (the top-left of the node's own box) and its name
+ * beside it, grouped: a component, a method, an ecosystem, an anchor, or one
+ * of the two climate arrows, whose name sits on the side their shaft is on.
+ */
+export declare function wardleyNodeElements(kind: WardleyNodeItemKind, at: ToolboxPoint, name?: string, local?: string): SerializedElementProps[];
+/**
+ * A market at `at` (the top-left of its 30-unit circle): the circle, its
+ * three role-less dots wired into a triangle by three attached connectors,
+ * and its name, all in one group.
+ */
+export declare function wardleyMarketElements(at: ToolboxPoint, name?: string, local?: string): SerializedElementProps[];
+/**
+ * A pipeline at `at` (the top-left of its 120×25 body): the body, the
+ * `handle` square astride its top edge (the only place a connector lands),
+ * the name above it, and two nested groups — (handle + name), then (body +
+ * that group) — as `createWardleyPipeline` has always built it.
+ */
+export declare function wardleyPipelineElements(at: ToolboxPoint, name?: string, local?: string): SerializedElementProps[];
+/**
+ * A Porter's-forces glyph at `at` (the top-left of its 60-unit circle): the
+ * circle carrying ONE letter as its own inner text (R, L or E; R when
+ * absent) and the four role-less red arrows pushing on it, grouped.
+ */
+export declare function wardleyPorterElements(at: ToolboxPoint, letter?: string, local?: string): SerializedElementProps[];
+/** An inertia bar at `at`: a plain filled rect whose role is its meaning. */
+export declare function wardleyInertiaElement(at: ToolboxPoint, local?: string): SerializedElementProps;
+/**
+ * A rectangular AREA at `at`, its name its own inner text (the toolbar
+ * creates it empty). The editor then lowers it under the components it
+ * covers (`lowerWardleyArea`), a depth relative to what is already on the
+ * board: a host that writes one sets that depth itself.
+ */
+export declare function wardleyAreaElement(at: ToolboxPoint, name?: string, local?: string): SerializedElementProps;
+/**
+ * The value-chain link the Link tool draws: `from` is the CONSUMER and `to`
+ * what it needs (ADR 0010), never inverted.
+ */
+export declare function wardleyDependencyElement(from: string, to: string, label?: string): SerializedElementProps;
+/** The evolution arrow the Arrow tool draws, from a component to its twin. */
+export declare function wardleyChangeArrowElement(from: string, to: string, label?: string): SerializedElementProps;
+/**
+ * Every item of the Wardley toolbar, in the toolbar's order. The polygon
+ * AREA is not here: it is a drawing tool, the author clicks its corners, and
+ * a prefabricated outline is precisely what the toolbar refuses to place
+ * (`activateWardleyAreaPolygon`).
+ */
+export declare const WARDLEY_TOOLBOX: FrameworkToolbox;

package/dist/toolbox.js

@@ -0,0 +1,348 @@
+import { ConnectorMode, FontWeight } from '@formicoidea/labre-core/model/headless';
+import { Bound } from '@formicoidea/labre-core/global/gfx';
+import { WARDLEY_BACKGROUND } from './background.js';
+import { wardleyCommandsManifest } from './commands-manifest.js';
+import { INERTIA_SIZE, PORTER_DEFAULT_LETTER, PORTER_SIZE, } from './node/consts.js';
+import { WARDLEY_AREA_SIZE, wardleyAreaProps, wardleyCanonicalBox, WARDLEY_EDGE_STYLE, wardleyHandleBox, wardleyHandleProps, wardleyInertiaProps, wardleyLabelBoxFor, wardleyLabelProps, wardleyMarketDotBoxes, wardleyMarketDotProps, wardleyMarketLinkPairs, wardleyMarketLinkProps, WARDLEY_NODE_LABEL, WARDLEY_NODE_SIZE, wardleyNodeProps, wardleyPorterArrowProps, wardleyPorterArrows, wardleyPorterLetterProps, } from './presets.js';
+import { WARDLEY_ROLE } from './roles.js';
+/**
+ * Wardley's toolbar as pure builders (`docs/adr/0045`): what the sub-menu's
+ * creation actions (`actions.ts`) place, with no editor behind them. The
+ * actions call these, so an artefact a host builds and one a user places from
+ * the toolbar are the same elements.
+ *
+ * Each builder is the TOOLBAR's artefact, not the OWM reader's: the reader
+ * (`import.ts`) lays a whole file out with a wider label box and a larger
+ * anchor, and draws no group. Every prop that is not geometry is the same on
+ * both paths (`toolbox.unit.spec.ts` holds the two to it).
+ */
+/**
+ * The three axis words a translated variant's background is seeded with —
+ * declared once, so the builder below, the editor action that resolves them
+ * and the manifest (`translations.ts`) read the very same fallback. Moved here
+ * from `actions.ts`, which re-exports it unchanged.
+ */
+export const WARDLEY_AXIS_SEED = {
+    opportunity: {
+        key: 'com.labre.wardley.seed.axis-opportunity',
+        fallback: 'Opportunity',
+    },
+    benefit: {
+        key: 'com.labre.wardley.seed.axis-benefit',
+        fallback: 'Benefit',
+    },
+    investment: {
+        key: 'com.labre.wardley.seed.axis-investment',
+        fallback: 'Investment',
+    },
+};
+const given = (text, fallback) => text?.trim() || fallback;
+/**
+ * Per-variant default labels written at creation (all remain editable
+ * afterwards). `opportunity` and `benefit` are the two variants whose Y axis
+ * is PROSE baked into the document; `classic` and `evolution-gradient` keep
+ * the declaration's own labels, which are `labelKey`s and need no seed.
+ */
+function mapVariantProps(variant, texts) {
+    const axis = (seed) => given(texts[seed], WARDLEY_AXIS_SEED[seed].fallback);
+    switch (variant) {
+        case 'opportunity':
+            // The Y axis becomes "Opportunity"; phase labels keep the classic ones.
+            return {
+                yAxisTitle: axis('opportunity'),
+                showVisibilityLabels: false,
+                showCornerLabels: false,
+            };
+        case 'benefit':
+            // The Y axis splits into Benefit (top) / Investment (bottom) around a
+            // zero line drawn by the renderer.
+            return {
+                yAxisTitle: '',
+                visibilityHigh: axis('benefit'),
+                visibilityLow: axis('investment'),
+                showCornerLabels: false,
+            };
+        default:
+            return {};
+    }
+}
+/**
+ * A map background of one variant at `at`, at the declaration's reference
+ * size unless `size` says otherwise (the editor passes the size of the
+ * biggest map already on the board, which only an editor can read).
+ */
+export function wardleyMapElement(variant, at, texts = {}, local = 'map', size = WARDLEY_BACKGROUND.geometry) {
+    return {
+        type: WARDLEY_BACKGROUND.type,
+        id: local,
+        // The map is a first-class role: validation rules position artefacts
+        // against `wardley:map`, never against the `wardley` element type.
+        role: WARDLEY_BACKGROUND.role,
+        // A map is a frame you place things on, not a shape you nudge.
+        resizeEnabled: WARDLEY_BACKGROUND.geometry.resizable,
+        variant,
+        ...mapVariantProps(variant, texts),
+        xywh: new Bound(at.x, at.y, size.width, size.height).serialize(),
+    };
+}
+/** The centre of a box of size `w`×`h` whose top-left is `at`. */
+const centreOf = (at, w, h) => ({
+    cx: at.x + w / 2,
+    cy: at.y + h / 2,
+});
+/** The name beside a labelled kind centred on (cx, cy). */
+function labelOf(kind, name, cx, cy, id) {
+    const { x, y, textAlign } = wardleyLabelBoxFor(kind, cx, cy);
+    return {
+        ...wardleyLabelProps(given(name, WARDLEY_NODE_LABEL[kind]), x, y, textAlign, 
+        // The two climate arrows are the only SemiBold names: an annotation laid
+        // over a map already full of names (`createWardleyAccelerator`).
+        kind === 'accelerator' || kind === 'decelerator'
+            ? FontWeight.SemiBold
+            : FontWeight.Regular),
+        id,
+    };
+}
+const groupOf = (id, members) => ({
+    type: 'group',
+    id,
+    children: Object.fromEntries(members.map(m => [m.id, true])),
+});
+/**
+ * A single node at `at` (the top-left of the node's own box) and its name
+ * beside it, grouped: a component, a method, an ecosystem, an anchor, or one
+ * of the two climate arrows, whose name sits on the side their shaft is on.
+ */
+export function wardleyNodeElements(kind, at, name, local = kind) {
+    const { w, h } = WARDLEY_NODE_SIZE[kind];
+    const { cx, cy } = centreOf(at, w, h);
+    const members = [
+        {
+            ...wardleyNodeProps(kind, { xywh: wardleyCanonicalBox(kind, cx, cy) }),
+            id: `${local}:node`,
+        },
+        labelOf(kind, name, cx, cy, `${local}:label`),
+    ];
+    return [...members, groupOf(`${local}:group`, members)];
+}
+/**
+ * A market at `at` (the top-left of its 30-unit circle): the circle, its
+ * three role-less dots wired into a triangle by three attached connectors,
+ * and its name, all in one group.
+ */
+export function wardleyMarketElements(at, name, local = 'market') {
+    const { w, h } = WARDLEY_NODE_SIZE.market;
+    const { cx, cy } = centreOf(at, w, h);
+    const circle = {
+        ...wardleyNodeProps('market', {
+            xywh: wardleyCanonicalBox('market', cx, cy),
+        }),
+        id: `${local}:node`,
+    };
+    const dots = wardleyMarketDotBoxes(cx, cy).map((xywh, index) => ({
+        ...wardleyMarketDotProps({ xywh }),
+        id: `${local}:dot-${index + 1}`,
+    }));
+    const links = wardleyMarketLinkPairs(dots.map(dot => dot.id)).map(([a, b], index) => ({
+        ...wardleyMarketLinkProps(a, b),
+        id: `${local}:link-${index + 1}`,
+    }));
+    const members = [
+        circle,
+        ...dots,
+        ...links,
+        labelOf('market', name, cx, cy, `${local}:label`),
+    ];
+    return [...members, groupOf(`${local}:group`, members)];
+}
+/**
+ * A pipeline at `at` (the top-left of its 120×25 body): the body, the
+ * `handle` square astride its top edge (the only place a connector lands),
+ * the name above it, and two nested groups — (handle + name), then (body +
+ * that group) — as `createWardleyPipeline` has always built it.
+ */
+export function wardleyPipelineElements(at, name, local = 'pipeline') {
+    const { w, h } = WARDLEY_NODE_SIZE.pipeline;
+    const { cx, cy } = centreOf(at, w, h);
+    const body = {
+        ...wardleyNodeProps('pipeline', {
+            xywh: wardleyCanonicalBox('pipeline', cx, cy),
+        }),
+        id: `${local}:node`,
+    };
+    const handle = {
+        ...wardleyHandleProps({ xywh: wardleyHandleBox(cx, cy) }),
+        id: `${local}:handle`,
+    };
+    const label = labelOf('pipeline', name, cx, cy, `${local}:label`);
+    const inner = groupOf(`${local}:handle-group`, [handle, label]);
+    return [body, handle, label, inner, groupOf(`${local}:group`, [body, inner])];
+}
+/**
+ * A Porter's-forces glyph at `at` (the top-left of its 60-unit circle): the
+ * circle carrying ONE letter as its own inner text (R, L or E; R when
+ * absent) and the four role-less red arrows pushing on it, grouped.
+ */
+export function wardleyPorterElements(at, letter, local = 'porter') {
+    const { cx, cy } = centreOf(at, PORTER_SIZE, PORTER_SIZE);
+    const members = [
+        {
+            ...wardleyNodeProps('porter', {
+                xywh: wardleyCanonicalBox('porter', cx, cy),
+            }),
+            ...wardleyPorterLetterProps(given(letter, PORTER_DEFAULT_LETTER)),
+            id: `${local}:node`,
+        },
+        ...wardleyPorterArrows(cx, cy).map((arrow, index) => ({
+            ...wardleyPorterArrowProps(arrow),
+            id: `${local}:arrow-${index + 1}`,
+        })),
+    ];
+    return [...members, groupOf(`${local}:group`, members)];
+}
+/** An inertia bar at `at`: a plain filled rect whose role is its meaning. */
+export function wardleyInertiaElement(at, local = 'inertia') {
+    const { w, h } = INERTIA_SIZE;
+    return {
+        ...wardleyInertiaProps({
+            xywh: new Bound(at.x, at.y, w, h).serialize(),
+        }),
+        id: local,
+    };
+}
+/**
+ * A rectangular AREA at `at`, its name its own inner text (the toolbar
+ * creates it empty). The editor then lowers it under the components it
+ * covers (`lowerWardleyArea`), a depth relative to what is already on the
+ * board: a host that writes one sets that depth itself.
+ */
+export function wardleyAreaElement(at, name, local = 'area') {
+    const { w, h } = WARDLEY_AREA_SIZE.rect;
+    const trimmed = name?.trim();
+    return {
+        ...wardleyAreaProps('rect', {
+            xywh: new Bound(at.x, at.y, w, h).serialize(),
+        }),
+        ...(trimmed ? { text: trimmed } : {}),
+        id: local,
+    };
+}
+function edge(kind, from, to, label) {
+    return {
+        type: 'connector',
+        mode: ConnectorMode.Straight,
+        // Two roles, never one specialising the other: W1 is about where an
+        // arrow points and must never fall on a dependency.
+        role: kind === 'link' ? WARDLEY_ROLE.dependency : WARDLEY_ROLE.changeArrow,
+        ...WARDLEY_EDGE_STYLE[kind],
+        source: { id: from },
+        target: { id: to },
+        ...(label?.trim() ? { text: label.trim() } : {}),
+    };
+}
+/**
+ * The value-chain link the Link tool draws: `from` is the CONSUMER and `to`
+ * what it needs (ADR 0010), never inverted.
+ */
+export function wardleyDependencyElement(from, to, label) {
+    return edge('link', from, to, label);
+}
+/** The evolution arrow the Arrow tool draws, from a component to its twin. */
+export function wardleyChangeArrowElement(from, to, label) {
+    return edge('arrow', from, to, label);
+}
+/** The toolbar command's label, so a host names an item as the toolbar does. */
+function label(commandId) {
+    const row = wardleyCommandsManifest.find(r => r.id === commandId);
+    return {
+        labelKey: row?.labelKey ?? commandId,
+        labelFallback: row?.labelFallback ?? commandId,
+    };
+}
+const mapItem = (id, commandId, variant, texts) => ({
+    id,
+    ...label(commandId),
+    texts,
+    size: {
+        w: WARDLEY_BACKGROUND.geometry.width,
+        h: WARDLEY_BACKGROUND.geometry.height,
+    },
+    build: (at, slots, local) => [wardleyMapElement(variant, at, slots, local)],
+});
+const nodeItem = (kind, commandId) => ({
+    id: kind,
+    ...label(commandId),
+    texts: ['name'],
+    size: WARDLEY_NODE_SIZE[kind],
+    build: (at, texts, local) => wardleyNodeElements(kind, at, texts?.name, local),
+});
+const dependency = {
+    id: 'dependency',
+    ...label('wardley.linkTool'),
+    build: wardleyDependencyElement,
+};
+const changeArrow = {
+    id: 'change-arrow',
+    ...label('wardley.evolutionArrow'),
+    build: wardleyChangeArrowElement,
+};
+/**
+ * Every item of the Wardley toolbar, in the toolbar's order. The polygon
+ * AREA is not here: it is a drawing tool, the author clicks its corners, and
+ * a prefabricated outline is precisely what the toolbar refuses to place
+ * (`activateWardleyAreaPolygon`).
+ */
+export const WARDLEY_TOOLBOX = {
+    framework: 'wardley',
+    items: [
+        mapItem('map', 'wardley.addBackground', 'classic', []),
+        mapItem('opportunity-map', 'wardley.addOpportunityBackground', 'opportunity', ['opportunity']),
+        mapItem('benefit-map', 'wardley.addBenefitBackground', 'benefit', [
+            'benefit',
+            'investment',
+        ]),
+        mapItem('evolution-map', 'wardley.addEvolutionBackground', 'evolution-gradient', []),
+        nodeItem('component', 'wardley.addComponent'),
+        nodeItem('method', 'wardley.addMethod'),
+        {
+            id: 'market',
+            ...label('wardley.addMarket'),
+            texts: ['name'],
+            size: WARDLEY_NODE_SIZE.market,
+            build: (at, texts, local) => wardleyMarketElements(at, texts?.name, local),
+        },
+        nodeItem('ecosystem', 'wardley.addEcosystem'),
+        nodeItem('anchor', 'wardley.addAnchor'),
+        {
+            id: 'pipeline',
+            ...label('wardley.addPipeline'),
+            texts: ['name'],
+            size: WARDLEY_NODE_SIZE.pipeline,
+            build: (at, texts, local) => wardleyPipelineElements(at, texts?.name, local),
+        },
+        {
+            id: 'inertia',
+            ...label('wardley.addInertia'),
+            texts: [],
+            size: INERTIA_SIZE,
+            build: (at, _texts, local) => [wardleyInertiaElement(at, local)],
+        },
+        {
+            id: 'porter',
+            ...label('wardley.addPorter'),
+            texts: ['letter'],
+            size: WARDLEY_NODE_SIZE.porter,
+            build: (at, texts, local) => wardleyPorterElements(at, texts?.letter, local),
+        },
+        nodeItem('accelerator', 'wardley.addAccelerator'),
+        nodeItem('decelerator', 'wardley.addDecelerator'),
+        {
+            id: 'area',
+            ...label('wardley.addAreaRect'),
+            texts: ['name'],
+            size: WARDLEY_AREA_SIZE.rect,
+            build: (at, texts, local) => [wardleyAreaElement(at, texts?.name, local)],
+        },
+    ],
+    links: [dependency, changeArrow],
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-framework-wardley",
   "description": "Labre wardley framework for @formicoidea/labre-core.",
-  "version": "0.58.0",
+  "version": "0.60.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -35,7 +35,7 @@
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.58.0",
+    "@formicoidea/labre-core": "0.60.0",
     "lit": "^3.2.0"
   }
 }