@formicoidea/labre-framework-wardley 0.34.1 → 0.35.0

package/dist/actions.d.ts

@@ -2,41 +2,20 @@ import { WardleyBackgroundElementModel, type WardleyBgVariant } from '@formicoid
 import type { BlockStdScope } from '@formicoidea/labre-core/std';
 import { type GfxController } from '@formicoidea/labre-core/std/gfx';
 import { type WardleyExportBoard } from './export.js';
+import { type WardleyArtefactKind } from './presets.js';
 /**
  * The single-circle node flavours: one connectable ellipse + a label to its
  * right, grouped. The glyph itself (anchor silhouette, ecosystem hatching,
  * method inner circle) is drawn by the node renderer from `kind`.
+ *
+ * A subset of {@link WardleyArtefactKind}, and named away from
+ * `WardleyNodeKind` on purpose: the model declares a type of that name with
+ * SEVEN values, and two homonyms of different cardinality — one of them the
+ * source of the semantic vocabulary — is a trap. The market and the pipeline
+ * are composites with creation functions of their own; the handle is not an
+ * artefact at all.
  */
-declare const NODE_PRESETS: {
-    readonly component: {
-        readonly d: 18;
-        readonly fill: "#ffffff";
-        readonly label: string;
-    };
-    readonly anchor: {
-        readonly d: 18;
-        readonly fill: "#ffffff";
-        readonly label: string;
-    };
-    readonly ecosystem: {
-        readonly d: 40;
-        readonly fill: "#ffffff";
-        readonly label: "Ecosystem";
-    };
-    readonly method: {
-        readonly d: 35;
-        readonly fill: "#d9d9d9";
-        readonly label: "Component";
-    };
-};
-/**
- * The subset of {@link WardleyNodeKind} that the single-circle presets above
- * cover. Renamed away from `WardleyNodeKind` on purpose: the model declares a
- * type of that name with SEVEN values, and two homonyms of different
- * cardinality — one of them now the source of the semantic vocabulary — is a
- * trap. `WARDLEY_ROLE[kind]` below only compiles while this stays a subset.
- */
-export type WardleySingleCircleKind = keyof typeof NODE_PRESETS;
+export type WardleySingleCircleKind = Exclude<WardleyArtefactKind, 'market' | 'pipeline'>;
 /** Create a wardley map background of the given variant, viewport-centered. */
 export declare function createWardleyBackground(gfx: GfxController, variant?: WardleyBgVariant): void;
 /**
@@ -114,4 +93,3 @@ export declare function exportOwmFile(std: BlockStdScope): void;
  * the capability handed to it.
  */
 export declare function importOwmFile(std: BlockStdScope): Promise<void>;
-export {};

package/dist/actions.js

@@ -10,7 +10,8 @@ import { WARDLEY_BACKGROUND } from './background.js';
 import { WARDLEY_SVG_IMPORT } from './interchange.js';
 import { wardleyBoardFrom, wardleySafeFilename, } from './export.js';
 import { WARDLEY_OWM_EXPORT, WARDLEY_OWM_IMPORT } from './interchange.js';
-import { ECOSYSTEM_LABEL, ECOSYSTEM_SIZE, HANDLE_SIZE, INERTIA_COLOR, INERTIA_SIZE, LABEL_DEFAULT, LABEL_FONT_SIZE, LABEL_GAP, LINK_GREY, LINK_STROKE_WIDTH, MARKET_DOT_RING, MARKET_DOT_SIZE, MARKET_DOT_STROKE_WIDTH, MARKET_LABEL, MARKET_LINK_COLOR, MARKET_LINK_WIDTH, MARKET_SIZE, METHOD_FILL, METHOD_LABEL, METHOD_SIZE, NODE_FILL, NODE_SIZE, NODE_STROKE, NODE_STROKE_WIDTH, PIPELINE_FILL, PIPELINE_HEIGHT, PIPELINE_LABEL, PIPELINE_WIDTH, WARDLEY_RED, } from './node/consts.js';
+import { HANDLE_SIZE, INERTIA_COLOR, INERTIA_SIZE, LABEL_FONT_SIZE, LABEL_GAP, LINK_GREY, LINK_STROKE_WIDTH, NODE_STROKE, WARDLEY_RED, } from './node/consts.js';
+import { wardleyCanonicalBox, wardleyHandleBox, wardleyHandleProps, wardleyMarketDotBoxes, wardleyMarketDotProps, wardleyMarketLinkPairs, wardleyMarketLinkProps, WARDLEY_NODE_LABEL, WARDLEY_NODE_SIZE, wardleyNodeProps, } from './presets.js';
 import { WARDLEY_ROLE } from './roles.js';
 /**
  * Standalone creation/activation actions for the Wardley toolbox — the
@@ -63,20 +64,6 @@ const BACKGROUND_VARIANT_DEFAULTS = {
 };
 /** Height of the native free-text labels (Inter, size 18). */
 const LABEL_H = LABEL_FONT_SIZE + 8;
-/**
- * The single-circle node flavours: one connectable ellipse + a label to its
- * right, grouped. The glyph itself (anchor silhouette, ecosystem hatching,
- * method inner circle) is drawn by the node renderer from `kind`.
- */
-const NODE_PRESETS = {
-    component: { d: NODE_SIZE, fill: NODE_FILL, label: LABEL_DEFAULT.component },
-    anchor: { d: NODE_SIZE, fill: NODE_FILL, label: LABEL_DEFAULT.anchor },
-    // Ecosystem: glyph = double border + hatched donut; connectors attach to
-    // this outer circle's center.
-    ecosystem: { d: ECOSYSTEM_SIZE, fill: NODE_FILL, label: ECOSYSTEM_LABEL },
-    // Method: the FILL color encodes the chosen method (editable).
-    method: { d: METHOD_SIZE, fill: METHOD_FILL, label: METHOD_LABEL },
-};
 function finish(gfx, id) {
     gfx.doc.captureSync();
     gfx.tool.setTool(DefaultTool);
@@ -91,28 +78,15 @@ function group(gfx, ids) {
     });
     return result.groupId || ids[0];
 }
-/** Add a native ellipse wardley node centred on (cx, cy). */
-function addEllipseNode(surface, kind, cx, cy, d, fillColor, strokeWidth = NODE_STROKE_WIDTH, 
-// The market's three inner dots are the GLYPH's own wiring, not artefacts the
-// user placed — the same reason its triangle connectors carry no role. They
-// sit inside the market circle by construction, so a role would make every
-// market composite report an overlap with itself (W3).
-neutral = false) {
-    return surface.addElement({
-        type: 'wardleyNode',
-        kind,
-        // Semantic identity (PF1): posted next to `kind`, which stays untouched
-        // and keeps driving the rendering.
-        role: neutral ? undefined : WARDLEY_ROLE[kind],
-        shapeType: 'ellipse',
-        filled: true,
-        fillColor,
-        strokeColor: NODE_STROKE,
-        strokeWidth,
-        shapeStyle: ShapeStyle.General,
-        roughness: 0,
-        xywh: new Bound(cx - d / 2, cy - d / 2, d, d).serialize(),
-    });
+/**
+ * Add a wardley node of one kind, at its canonical size, centred on (cx, cy).
+ *
+ * The props are {@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`).
+ */
+function addNode(surface, kind, cx, cy) {
+    return surface.addElement(wardleyNodeProps(kind, { xywh: wardleyCanonicalBox(kind, cx, cy) }));
 }
 /** Add a native free-text label (same Inter family as the axis labels). */
 function addLabel(surface, text, x, y, textAlign = 'left') {
@@ -171,10 +145,10 @@ export function createWardleyNode(gfx, kind) {
     const surface = gfx.surface;
     if (!surface)
         return;
-    const { d, fill, label } = NODE_PRESETS[kind];
+    const { w } = WARDLEY_NODE_SIZE[kind];
     const { centerX: cx, centerY: cy } = gfx.viewport;
-    const nodeId = addEllipseNode(surface, kind, cx, cy, d, fill);
-    const labelId = addLabel(surface, label, cx + d / 2 + LABEL_GAP, cy - LABEL_H / 2);
+    const nodeId = addNode(surface, kind, cx, cy);
+    const labelId = addLabel(surface, WARDLEY_NODE_LABEL[kind], cx + w / 2 + LABEL_GAP, cy - LABEL_H / 2);
     finish(gfx, group(gfx, [nodeId, labelId]));
 }
 /** Create an inertia bar (filled black rect). */
@@ -213,43 +187,15 @@ export function createWardleyPipeline(gfx) {
     if (!gfx.surface)
         return;
     const { centerX: cx, centerY: cy } = gfx.viewport;
-    const W = PIPELINE_WIDTH;
-    const H = PIPELINE_HEIGHT;
     const d = HANDLE_SIZE;
-    const top = cy - H / 2;
+    const top = cy - WARDLEY_NODE_SIZE.pipeline.h / 2;
     // Body: a WardleyNode rect, made non-connectable by `kind: 'pipeline'`.
-    const bodyId = gfx.surface.addElement({
-        type: 'wardleyNode',
-        kind: 'pipeline',
-        role: WARDLEY_ROLE.pipeline,
-        shapeType: 'rect',
-        filled: true,
-        fillColor: PIPELINE_FILL,
-        strokeColor: NODE_STROKE,
-        strokeWidth: NODE_STROKE_WIDTH,
-        shapeStyle: ShapeStyle.General,
-        roughness: 0,
-        radius: 0,
-        xywh: new Bound(cx - W / 2, top, W, H).serialize(),
-    });
+    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({
-        type: 'wardleyNode',
-        kind: 'handle',
-        role: WARDLEY_ROLE.handle,
-        shapeType: 'rect',
-        filled: true,
-        fillColor: NODE_FILL,
-        strokeColor: NODE_STROKE,
-        strokeWidth: NODE_STROKE_WIDTH,
-        shapeStyle: ShapeStyle.General,
-        roughness: 0,
-        radius: 0,
-        xywh: new Bound(cx - d / 2, top - d / 2, d, d).serialize(),
-    });
+    const handleId = gfx.surface.addElement(wardleyHandleProps({ xywh: wardleyHandleBox(cx, cy) }));
     // Label centered horizontally on the pipeline, sitting ABOVE the handle.
-    const labelId = addLabel(gfx.surface, PIPELINE_LABEL, cx - 60, top - d / 2 - LABEL_H - LABEL_GAP, 'center');
+    const labelId = addLabel(gfx.surface, WARDLEY_NODE_LABEL.pipeline, cx - 60, top - d / 2 - LABEL_H - LABEL_GAP, 'center');
     // Nested groups: (handle + label), then (body + that group).
     const innerId = group(gfx, [handleId, labelId]);
     finish(gfx, group(gfx, [bodyId, innerId]));
@@ -266,35 +212,14 @@ export function createWardleyMarket(gfx) {
     if (!surface)
         return;
     const { centerX: cx, centerY: cy } = gfx.viewport;
-    const R = MARKET_SIZE / 2;
-    const rho = MARKET_DOT_RING;
-    const sin60 = Math.sqrt(3) / 2;
+    const R = WARDLEY_NODE_SIZE.market.w / 2;
     // Outer circle = the market node (connectable, center-only).
-    const circleId = addEllipseNode(surface, 'market', cx, cy, MARKET_SIZE, NODE_FILL);
+    const circleId = addNode(surface, 'market', cx, cy);
     // 3 inner component nodes (thick border, no label) at the triangle vertices.
-    const verts = [
-        [0, -rho],
-        [rho * sin60, rho / 2],
-        [-rho * sin60, rho / 2],
-    ];
-    const dotIds = verts.map(([vx, vy]) => addEllipseNode(surface, 'component', cx + vx, cy + vy, MARKET_DOT_SIZE, NODE_FILL, MARKET_DOT_STROKE_WIDTH, true));
+    const dotIds = wardleyMarketDotBoxes(cx, cy).map(xywh => surface.addElement(wardleyMarketDotProps({ xywh })));
     // Triangle: 3 attached connectors (auto-route center-to-center, clipped).
-    const connIds = [
-        [dotIds[0], dotIds[1]],
-        [dotIds[1], dotIds[2]],
-        [dotIds[2], dotIds[0]],
-    ].map(([a, b]) => surface.addElement({
-        type: 'connector',
-        mode: ConnectorMode.Straight,
-        source: { id: a },
-        target: { id: b },
-        stroke: MARKET_LINK_COLOR,
-        strokeStyle: StrokeStyle.Solid,
-        strokeWidth: MARKET_LINK_WIDTH,
-        frontEndpointStyle: PointStyle.None,
-        rearEndpointStyle: PointStyle.None,
-    }));
-    const labelId = addLabel(surface, MARKET_LABEL, cx + R + LABEL_GAP, cy - LABEL_H / 2);
+    const connIds = wardleyMarketLinkPairs(dotIds).map(([a, b]) => surface.addElement(wardleyMarketLinkProps(a, b)));
+    const labelId = addLabel(surface, WARDLEY_NODE_LABEL.market, cx + R + LABEL_GAP, cy - LABEL_H / 2);
     finish(gfx, group(gfx, [circleId, ...dotIds, ...connIds, labelId]));
 }
 /**

package/dist/commands-manifest.js

@@ -85,7 +85,7 @@ export const wardleyCommandsManifest = [
         labelKey: 'com.labre.commands.wardley.addAnchor',
         labelFallback: 'Anchor',
         scope: 'edgeless',
-        defaultKeys: { mac: [], other: [] },
+        defaultKeys: { mac: ['w', 'a'], other: ['w', 'a'] },
     },
     {
         id: 'wardley.addPipeline',
@@ -109,7 +109,7 @@ export const wardleyCommandsManifest = [
         labelKey: 'com.labre.keyboardShortcuts.wardley.evolutionArrow',
         labelFallback: 'Arrow (evolution)',
         scope: 'edgeless',
-        defaultKeys: { mac: ['w', 'a'], other: ['w', 'a'] },
+        defaultKeys: { mac: ['w', 'e'], other: ['w', 'e'] },
     },
     {
         id: 'wardley.addInertia',

package/dist/commands.js

@@ -84,6 +84,7 @@ const SPECS = [
     {
         id: 'addAnchor',
         label: 'Anchor',
+        key: 'a',
         iconKey: 'wardley.anchor',
         category: 'nodes',
         kind: 'artefact',
@@ -117,7 +118,7 @@ const SPECS = [
         id: 'evolutionArrow',
         label: 'Arrow (evolution)',
         labelKey: 'com.labre.keyboardShortcuts.wardley.evolutionArrow',
-        key: 'a',
+        key: 'e',
         iconKey: 'wardley.arrow',
         category: 'connectors',
         kind: 'tool',

package/dist/index.d.ts

@@ -7,6 +7,8 @@ export { WARDLEY_PROFILES } from './profiles.js';
 export { WARDLEY_NUDGES } from './nudges.js';
 export { WARDLEY_NAMING_CONVENTIONS, WARDLEY_READING } from './reading.js';
 export { WARDLEY_RULES } from './rules.js';
+export { type WardleyArtefactKind, wardleyCanonicalBox, wardleyCenteredBox, wardleyHandleBox, wardleyHandleProps, wardleyMarketDotBoxes, wardleyMarketDotProps, wardleyMarketLinkPairs, wardleyMarketLinkProps, WARDLEY_NODE_LABEL, WARDLEY_NODE_SIZE, wardleyMorphClears, wardleyMorphProps, wardleyNodeProps, } from './presets.js';
+export { WARDLEY_MORPH_FAMILIES, WARDLEY_MORPH_SPEC, type WardleyMorphKind, wardleyMorphComposite, wardleyMorphedLabel, wardleyNodeOfComponent, } from './morph.js';
 /**
  * The map's own frame, declared. Public because a host that lays elements out
  * against the plot — labre-mcp does, and so does anything that generates a map

package/dist/index.js

@@ -7,6 +7,16 @@ export { WARDLEY_PROFILES } from './profiles.js';
 export { WARDLEY_NUDGES } from './nudges.js';
 export { WARDLEY_NAMING_CONVENTIONS, WARDLEY_READING } from './reading.js';
 export { WARDLEY_RULES } from './rules.js';
+// What a Wardley artefact is BORN as, shared by the palette and — since the
+// morph — by the toolbar that says one artefact differently, so the two can
+// never disagree about what a market looks like. The sizes are the notation
+// itself, which is why a host laying out a map without an editor needs them.
+export { wardleyCanonicalBox, wardleyCenteredBox, wardleyHandleBox, wardleyHandleProps, wardleyMarketDotBoxes, wardleyMarketDotProps, wardleyMarketLinkPairs, wardleyMarketLinkProps, WARDLEY_NODE_LABEL, WARDLEY_NODE_SIZE, wardleyMorphClears, wardleyMorphProps, wardleyNodeProps, } from './presets.js';
+// What an artefact may BECOME: the declared family, the spec the generic morph
+// module is registered with, the resolution from a selected group to the node
+// inside it, and the two rules a composite morph owes its own parts. Data a
+// host can read without an editor.
+export { WARDLEY_MORPH_FAMILIES, WARDLEY_MORPH_SPEC, wardleyMorphComposite, wardleyMorphedLabel, wardleyNodeOfComponent, } from './morph.js';
 /**
  * The map's own frame, declared. Public because a host that lays elements out
  * against the plot — labre-mcp does, and so does anything that generates a map

package/dist/morph.d.ts

@@ -0,0 +1,129 @@
+import { type MorphSpec } from '@formicoidea/labre-core/blocks/surface';
+import { WardleyNodeElementModel } from '@formicoidea/labre-core/model';
+import type { GfxPrimitiveElementModel } from '@formicoidea/labre-core/std/gfx';
+/**
+ * What a Wardley artefact may BECOME — the declaration behind the "Change type"
+ * dropdown on a selected component's contextual toolbar.
+ *
+ * ## One family, and why it is exactly these four
+ *
+ * A component, a market, an ecosystem and a pipeline are four ways of saying
+ * the SAME thing: something the value chain depends on. The map's own reading
+ * agrees — `roles.ts` makes `market` and `ecosystem` children of `component` in
+ * the role tree — and the modelling gesture the morph exists for is the one
+ * every mapper makes: you draw a component, you look at the map, and you
+ * realise that what you drew is a market of many suppliers, or a whole
+ * ecosystem, or a pipeline of choices. Today that costs a delete, a re-draw,
+ * every dependency re-attached and the name typed again.
+ *
+ * The family is DATA and nothing derives it — the same call BPMN and C4 make.
+ * Deriving it from `roleIsA` would have been wrong in both directions here: it
+ * would reach from market to component and not back, and it would say nothing
+ * at all about the pipeline, which is not a specialisation of anything and is
+ * still the fourth way of drawing the same claim.
+ *
+ * ## The two kinds deliberately left out
+ *
+ * - **`anchor`** is the user, and the need they have. It is a role of its own
+ *   precisely because it is NOT a component (`roles.ts`): it is what the value
+ *   chain hangs from, not a link in it. A menu offering "turn this user into a
+ *   pipeline" would invite a map with no anchor at all — the one thing a
+ *   Wardley map cannot be read without.
+ * - **`method`** is not an artefact but an annotation ON one: the coloured ring
+ *   says how a component is being BUILT (buy / build / outsource), and its fill
+ *   encodes the choice. Morphing it away would silently discard that decision,
+ *   and morphing into it would have to invent one.
+ *
+ * `handle` is in no family either, and does not need excluding by name: it is
+ * not an artefact at all, so nothing selects it and {@link wardleyNodeOfComponent}
+ * never resolves to one.
+ */
+export declare const WARDLEY_MORPH_FAMILIES: readonly (readonly WardleyMorphKind[])[];
+/** The kinds this framework offers as morph targets. */
+export type WardleyMorphKind = 'component' | 'market' | 'ecosystem' | 'pipeline';
+/**
+ * The `wardleyNode` a selected GROUP is the artefact of — `undefined` when the
+ * group is not one.
+ *
+ * Every Wardley artefact in this family is a composite: a component is a circle
+ * and its label, a market adds three dots and a triangle, and a pipeline is a
+ * body plus a handle plus a label in a nested group. So what a click selects is
+ * the outer group, and what carries `kind` is one node inside it — RECURSIVELY
+ * inside it, because the pipeline's own creation nests.
+ *
+ * Three conditions, and each one excludes a piece of the notation rather than
+ * an accident:
+ *
+ * - a `WardleyNodeElementModel`, which leaves out the labels and the connectors;
+ * - with a ROLE, which leaves out the market's three neutral dots — they are the
+ *   glyph's wiring and carry none by construction (`presets.ts`);
+ * - whose kind is in the family, which leaves out the pipeline's `handle` and
+ *   any `anchor` or `method` somebody grouped in beside the artefact.
+ *
+ * TWO candidates is a REFUSAL rather than a first-wins pick, exactly as C4's
+ * resolution refuses a group of two components: morphing "it" would mean
+ * picking one by document order, and the honest answer to an ambiguous
+ * selection is nothing at all. A plain lasso round three shapes, a C4 component
+ * and a group of two Wardley components all answer `undefined`, so none of them
+ * is ever offered the menu.
+ */
+export declare function wardleyNodeOfComponent(model: GfxPrimitiveElementModel): WardleyNodeElementModel | undefined;
+/**
+ * The name an artefact should carry once it has morphed — or `null` when the
+ * name is the AUTHOR's and must not be touched.
+ *
+ * Exactly one case rewrites: the label is the source kind's own creation
+ * prompt, letter for letter, which is what an artefact nobody has named still
+ * says. Everything else — a name typed over it, the prompt with a word added, a
+ * cleared label, another kind's prompt — is content, and content survives a
+ * morph untouched. The same timid rule `c4MorphedTitle` states, and for the same
+ * reason: a morph may not take away words somebody put on the picture.
+ *
+ * Pure and total over every string: the input is a canvas text element somebody
+ * may have typed anything into.
+ */
+export declare function wardleyMorphedLabel(from: WardleyMorphKind, to: WardleyMorphKind, rawText: string | null | undefined): string | null;
+/**
+ * Everything the morph owes a Wardley composite beyond the props patch — the
+ * `afterMorph` half of the spec, run inside the generic module's one
+ * `captureSync` so all of it is a single ctrl+z.
+ *
+ * ## The geometry, and why this framework writes it
+ *
+ * A DEVIATION from BPMN and C4, decided by the PO: those two keep the box the
+ * user gave the element, because there a size is a preference. Here it is the
+ * NOTATION. A market is drawn bigger than a component so a reader can tell them
+ * apart at a glance, an ecosystem bigger again, and a pipeline is a 120-wide bar
+ * — a market left at a component's 18 pixels is an unreadable smudge with three
+ * dots crammed into it. So the target's canonical size is applied, CENTRED on
+ * where the artefact already stands: the thing does not move, it becomes the
+ * size its notation says it is. The label keeps its own place, which is the
+ * user's.
+ *
+ * ## And why the rest is here rather than in the patch
+ *
+ * Because a market IS its three dots and a pipeline IS its handle. A patch can
+ * write `kind: 'market'` onto a circle and the result is a circle that claims to
+ * be a market and does not look like one; a patch cannot create an element, nor
+ * move a connector somebody drew. That is exactly what `afterMorph` is for, and
+ * the ORDER below is the whole of the care it needs: the glyph the artefact is
+ * LEAVING comes apart before the one it is arriving at is built, so a
+ * market → pipeline never has three dots and a handle at once.
+ */
+export declare function wardleyMorphComposite(selected: GfxPrimitiveElementModel, from: WardleyMorphKind, to: WardleyMorphKind): void;
+/**
+ * Wardley's morph declaration, handed to the generic `morphToolbarConfig`.
+ *
+ * `modelType` is the native `GroupElementModel` and not
+ * `WardleyNodeElementModel`, because every artefact in this family is a
+ * composite and the group is what a click on one selects. Everything that makes
+ * that safe is in {@link wardleyNodeOfComponent}: the toolbar's own homogeneity
+ * test only proves that each selected element is A group, and the resolution
+ * proves that each one is one of OURS.
+ *
+ * `propsOf` is the shipped creation builder minus `type` / `xywh` / `text`
+ * ({@link wardleyMorphProps}), so the palette and the morph cannot disagree
+ * about what a pipeline looks like, and `clearOf` removes the keys the target
+ * does not write — `radius`, which only the pipeline has.
+ */
+export declare const WARDLEY_MORPH_SPEC: MorphSpec<WardleyMorphKind>;

package/dist/morph.js

@@ -0,0 +1,405 @@
+import { morphLabel, } from '@formicoidea/labre-core/blocks/surface';
+import { ConnectorElementModel, GroupElementModel, TextElementModel, WardleyNodeElementModel, } from '@formicoidea/labre-core/model';
+import { wardleyCommandIcons, wardleyCommands } from './commands.js';
+import { wardleyCanonicalBox, wardleyHandleBox, wardleyHandleProps, wardleyMarketDotBoxes, wardleyMarketDotProps, wardleyMarketLinkPairs, wardleyMarketLinkProps, WARDLEY_NODE_LABEL, wardleyMorphClears, wardleyMorphProps, } from './presets.js';
+import { WARDLEY_ROLE } from './roles.js';
+/**
+ * What a Wardley artefact may BECOME — the declaration behind the "Change type"
+ * dropdown on a selected component's contextual toolbar.
+ *
+ * ## One family, and why it is exactly these four
+ *
+ * A component, a market, an ecosystem and a pipeline are four ways of saying
+ * the SAME thing: something the value chain depends on. The map's own reading
+ * agrees — `roles.ts` makes `market` and `ecosystem` children of `component` in
+ * the role tree — and the modelling gesture the morph exists for is the one
+ * every mapper makes: you draw a component, you look at the map, and you
+ * realise that what you drew is a market of many suppliers, or a whole
+ * ecosystem, or a pipeline of choices. Today that costs a delete, a re-draw,
+ * every dependency re-attached and the name typed again.
+ *
+ * The family is DATA and nothing derives it — the same call BPMN and C4 make.
+ * Deriving it from `roleIsA` would have been wrong in both directions here: it
+ * would reach from market to component and not back, and it would say nothing
+ * at all about the pipeline, which is not a specialisation of anything and is
+ * still the fourth way of drawing the same claim.
+ *
+ * ## The two kinds deliberately left out
+ *
+ * - **`anchor`** is the user, and the need they have. It is a role of its own
+ *   precisely because it is NOT a component (`roles.ts`): it is what the value
+ *   chain hangs from, not a link in it. A menu offering "turn this user into a
+ *   pipeline" would invite a map with no anchor at all — the one thing a
+ *   Wardley map cannot be read without.
+ * - **`method`** is not an artefact but an annotation ON one: the coloured ring
+ *   says how a component is being BUILT (buy / build / outsource), and its fill
+ *   encodes the choice. Morphing it away would silently discard that decision,
+ *   and morphing into it would have to invent one.
+ *
+ * `handle` is in no family either, and does not need excluding by name: it is
+ * not an artefact at all, so nothing selects it and {@link wardleyNodeOfComponent}
+ * never resolves to one.
+ */
+export const WARDLEY_MORPH_FAMILIES = [
+    // Declaration order is menu order, and it opens on the plain component: the
+    // undecorated artefact is the honest first draft, and the three others are
+    // refinements of it — the same call `commands.ts` makes about the senior row.
+    ['component', 'market', 'ecosystem', 'pipeline'],
+];
+/** The same set, as a lookup — the gate every resolution below runs through. */
+const MORPH_KINDS = new Set(WARDLEY_MORPH_FAMILIES.flat());
+/**
+ * The creation command that draws each kind, keyed BY that kind.
+ *
+ * Derived from `telemetry.element`, which is where the kind is already written
+ * down (`node:market`) and is documented as a historical value that must not be
+ * renamed. Deriving rather than restating is what stops a second table of
+ * labels and icons drifting from the one the sub-menu and the catalogue read.
+ */
+const NODE_COMMANDS = new Map(wardleyCommands.flatMap(command => {
+    const element = command.telemetry?.element;
+    return element?.startsWith('node:')
+        ? [[element.slice('node:'.length), command]]
+        : [];
+}));
+/** A kind's wording: the creation command's own key and English. */
+function labelOf(kind) {
+    const command = NODE_COMMANDS.get(kind);
+    return {
+        key: command?.labelKey,
+        fallback: command?.labelFallback ?? kind,
+    };
+}
+/** A kind's icon: the creation command's own, reused rather than redrawn. */
+function iconOf(kind) {
+    const iconKey = NODE_COMMANDS.get(kind)?.iconKey;
+    return ((iconKey && wardleyCommandIcons[iconKey]) ||
+        wardleyCommandIcons['wardley.component']);
+}
+/* ── Resolving the composite ───────────────────────────────────────────── */
+/**
+ * Every element under a group, however deeply nested.
+ *
+ * Recursive because the pipeline's own creation site nests — (handle + label),
+ * then (body + that) — so a flat pass over `childElements` would miss half of
+ * one of the four artefacts this file is about.
+ */
+function* descendants(group) {
+    for (const child of group.childElements) {
+        yield child;
+        if (child instanceof GroupElementModel)
+            yield* descendants(child);
+    }
+}
+/**
+ * The `wardleyNode` a selected GROUP is the artefact of — `undefined` when the
+ * group is not one.
+ *
+ * Every Wardley artefact in this family is a composite: a component is a circle
+ * and its label, a market adds three dots and a triangle, and a pipeline is a
+ * body plus a handle plus a label in a nested group. So what a click selects is
+ * the outer group, and what carries `kind` is one node inside it — RECURSIVELY
+ * inside it, because the pipeline's own creation nests.
+ *
+ * Three conditions, and each one excludes a piece of the notation rather than
+ * an accident:
+ *
+ * - a `WardleyNodeElementModel`, which leaves out the labels and the connectors;
+ * - with a ROLE, which leaves out the market's three neutral dots — they are the
+ *   glyph's wiring and carry none by construction (`presets.ts`);
+ * - whose kind is in the family, which leaves out the pipeline's `handle` and
+ *   any `anchor` or `method` somebody grouped in beside the artefact.
+ *
+ * TWO candidates is a REFUSAL rather than a first-wins pick, exactly as C4's
+ * resolution refuses a group of two components: morphing "it" would mean
+ * picking one by document order, and the honest answer to an ambiguous
+ * selection is nothing at all. A plain lasso round three shapes, a C4 component
+ * and a group of two Wardley components all answer `undefined`, so none of them
+ * is ever offered the menu.
+ */
+export function wardleyNodeOfComponent(model) {
+    if (!(model instanceof GroupElementModel))
+        return undefined;
+    let found;
+    for (const child of descendants(model)) {
+        if (!(child instanceof WardleyNodeElementModel))
+            continue;
+        if (child.role === undefined)
+            continue;
+        if (!MORPH_KINDS.has(child.kind))
+            continue;
+        if (found)
+            return undefined;
+        found = child;
+    }
+    return found;
+}
+/* ── The structural half of the morph ──────────────────────────────────── */
+/**
+ * The name an artefact should carry once it has morphed — or `null` when the
+ * name is the AUTHOR's and must not be touched.
+ *
+ * Exactly one case rewrites: the label is the source kind's own creation
+ * prompt, letter for letter, which is what an artefact nobody has named still
+ * says. Everything else — a name typed over it, the prompt with a word added, a
+ * cleared label, another kind's prompt — is content, and content survives a
+ * morph untouched. The same timid rule `c4MorphedTitle` states, and for the same
+ * reason: a morph may not take away words somebody put on the picture.
+ *
+ * Pure and total over every string: the input is a canvas text element somebody
+ * may have typed anything into.
+ */
+export function wardleyMorphedLabel(from, to, rawText) {
+    return (rawText ?? '').trim() === WARDLEY_NODE_LABEL[from]
+        ? WARDLEY_NODE_LABEL[to]
+        : null;
+}
+/** The centre of an element, from the box it currently occupies. */
+function centreOf(model) {
+    const [x, y, w, h] = model.deserializedXYWH;
+    return [x + w / 2, y + h / 2];
+}
+/** The label of a composite — `undefined` when there is not exactly one. */
+function labelOfComposite(group) {
+    let found;
+    for (const child of descendants(group)) {
+        if (!(child instanceof TextElementModel))
+            continue;
+        if (child.role !== WARDLEY_ROLE.label)
+            continue;
+        if (found)
+            return undefined;
+        found = child;
+    }
+    return found;
+}
+/**
+ * Point every connector that named `fromId` at `toId` instead.
+ *
+ * The whole point of morphing rather than re-drawing: a component wired into
+ * half a value chain becomes a pipeline and keeps every dependency it had. The
+ * endpoint is rewritten to the bare `{ id }` and the `position` is dropped on
+ * purpose — a position is stored RELATIVE to the element it names, so carrying
+ * one across to a different box would land the arrow somewhere nobody chose.
+ * Every Wardley node is `centerAnchorOnly` anyway, so a connector this framework
+ * drew never had one.
+ */
+function reanchor(surface, fromId, toId) {
+    for (const element of surface.elementModels) {
+        if (!(element instanceof ConnectorElementModel))
+            continue;
+        if (element.isLocked())
+            continue;
+        if (element.source?.id === fromId) {
+            surface.updateElement(element.id, { source: { id: toId } });
+        }
+        if (element.target?.id === fromId) {
+            surface.updateElement(element.id, { target: { id: toId } });
+        }
+    }
+}
+/**
+ * Take the market's glyph apart: the three neutral dots, and the triangle
+ * wiring them.
+ *
+ * Identified the way {@link wardleyNodeOfComponent} identifies what it must NOT
+ * resolve to — a `wardleyNode` with no role — and the connectors by the fact
+ * that both their ends name one of those dots. Never by document order, and
+ * never by "the connectors in this group": a dependency the user drew from
+ * their market to something else is a child of nothing and must survive, and one
+ * they drew INTO the composite still has one end outside it.
+ */
+function removeMarketGlyph(group) {
+    const surface = group.surface;
+    const dots = [...descendants(group)].filter((child) => child instanceof WardleyNodeElementModel && child.role === undefined);
+    const dotIds = new Set(dots.map(dot => dot.id));
+    for (const child of [...descendants(group)]) {
+        if (!(child instanceof ConnectorElementModel))
+            continue;
+        const { id: sourceId } = child.source ?? {};
+        const { id: targetId } = child.target ?? {};
+        if (sourceId === undefined || targetId === undefined)
+            continue;
+        if (!dotIds.has(sourceId) || !dotIds.has(targetId))
+            continue;
+        surface.deleteElement(child.id);
+    }
+    for (const dot of dots)
+        surface.deleteElement(dot.id);
+}
+/**
+ * Build the market's glyph round a centre: three dots and the triangle between
+ * them, from the very same constants `createWardleyMarket` uses.
+ *
+ * Added to the group AFTER the circle they sit in, which is also the painting
+ * order the creation site produces — a market drawn from the sub-menu and one
+ * morphed into being are the same stack of elements.
+ */
+function addMarketGlyph(group, cx, cy) {
+    const surface = group.surface;
+    const dotIds = wardleyMarketDotBoxes(cx, cy).map(xywh => surface.addElement(wardleyMarketDotProps({ xywh })));
+    const linkIds = wardleyMarketLinkPairs(dotIds).map(([a, b]) => surface.addElement(wardleyMarketLinkProps(a, b)));
+    for (const id of [...dotIds, ...linkIds]) {
+        const element = surface.getElementById(id);
+        if (element)
+            group.addChild(element);
+    }
+}
+/**
+ * Give a pipeline the handle it is connected through, and move the user's own
+ * links onto it.
+ *
+ * ## The handle lands FLAT in the outer group — a documented simplification
+ *
+ * `createWardleyPipeline` nests: it groups (handle + label), then groups that
+ * with the body. Nothing depends on the nesting — the handle is found by kind
+ * and the label by role, both recursively — and a morph that rebuilt it would
+ * have to move the user's label into a group it never asked for. So the morph
+ * adds the handle as a sibling of the body. A pipeline morphed into being is
+ * therefore ONE group of three elements where a drawn one is a group of two;
+ * they behave identically on the canvas, in the exporter and under every rule,
+ * and the reverse morph flattens a drawn one the same way.
+ */
+function addHandle(group, carrier, cx, cy) {
+    const surface = group.surface;
+    const handleId = surface.addElement(wardleyHandleProps({ xywh: wardleyHandleBox(cx, cy) }));
+    const handle = surface.getElementById(handleId);
+    if (handle)
+        group.addChild(handle);
+    // A pipeline body declares `connectable === false`, so every link the user
+    // drew to the component has to move to the handle or it would point at
+    // something that no longer accepts it.
+    reanchor(surface, carrier.id, handleId);
+}
+/**
+ * Take the handle away, and give the user's links back to the body.
+ *
+ * The mirror of {@link addHandle}, plus the one piece of tidying the nesting
+ * makes necessary: a pipeline DRAWN from the sub-menu keeps its label in an
+ * inner group with the handle, and removing the handle would leave a group of
+ * one behind. The label is promoted into the outer group and the empty wrapper
+ * deleted, which is what leaves a morphed artefact looking exactly like a drawn
+ * one of its new kind.
+ */
+function removeHandle(group, carrier) {
+    const surface = group.surface;
+    const handle = [...descendants(group)].find((child) => child instanceof WardleyNodeElementModel && child.kind === 'handle');
+    if (!handle)
+        return;
+    // Before the deletion, never after: the links have to name something.
+    reanchor(surface, handle.id, carrier.id);
+    const inner = handle.group;
+    surface.deleteElement(handle.id);
+    if (!(inner instanceof GroupElementModel) || inner === group)
+        return;
+    // Emptied first, so `deleteElement` — which deletes a group's children with
+    // it — has nothing left to take.
+    for (const orphan of [...inner.childElements]) {
+        inner.removeChild(orphan);
+        group.addChild(orphan);
+    }
+    surface.deleteElement(inner.id);
+}
+/**
+ * Keep the artefact's own name saying what the artefact now is.
+ *
+ * The one exception to "the words and the placement are the user's": the
+ * placeholder rule of {@link wardleyMorphedLabel}. In place and in one
+ * transaction, because the `Y.Text` instance is what a bound editor holds, and
+ * inside the caller's `captureSync`, so the rewrite is part of the same single
+ * ctrl+z as the kind that made it necessary.
+ */
+function rewriteLabel(group, from, to) {
+    const label = labelOfComposite(group);
+    if (!label || label.isLocked())
+        return;
+    const text = label.text.toString().trim();
+    const next = wardleyMorphedLabel(from, to, text);
+    if (next === null || next === text)
+        return;
+    label.surface.store.transact(() => {
+        label.text.delete(0, label.text.length);
+        label.text.insert(0, next);
+    });
+}
+/**
+ * Everything the morph owes a Wardley composite beyond the props patch — the
+ * `afterMorph` half of the spec, run inside the generic module's one
+ * `captureSync` so all of it is a single ctrl+z.
+ *
+ * ## The geometry, and why this framework writes it
+ *
+ * A DEVIATION from BPMN and C4, decided by the PO: those two keep the box the
+ * user gave the element, because there a size is a preference. Here it is the
+ * NOTATION. A market is drawn bigger than a component so a reader can tell them
+ * apart at a glance, an ecosystem bigger again, and a pipeline is a 120-wide bar
+ * — a market left at a component's 18 pixels is an unreadable smudge with three
+ * dots crammed into it. So the target's canonical size is applied, CENTRED on
+ * where the artefact already stands: the thing does not move, it becomes the
+ * size its notation says it is. The label keeps its own place, which is the
+ * user's.
+ *
+ * ## And why the rest is here rather than in the patch
+ *
+ * Because a market IS its three dots and a pipeline IS its handle. A patch can
+ * write `kind: 'market'` onto a circle and the result is a circle that claims to
+ * be a market and does not look like one; a patch cannot create an element, nor
+ * move a connector somebody drew. That is exactly what `afterMorph` is for, and
+ * the ORDER below is the whole of the care it needs: the glyph the artefact is
+ * LEAVING comes apart before the one it is arriving at is built, so a
+ * market → pipeline never has three dots and a handle at once.
+ */
+export function wardleyMorphComposite(selected, from, to) {
+    if (!(selected instanceof GroupElementModel))
+        return;
+    const carrier = wardleyNodeOfComponent(selected);
+    if (!carrier)
+        return;
+    const [cx, cy] = centreOf(carrier);
+    carrier.surface.updateElement(carrier.id, {
+        xywh: wardleyCanonicalBox(to, cx, cy),
+    });
+    if (from === 'market')
+        removeMarketGlyph(selected);
+    if (from === 'pipeline')
+        removeHandle(selected, carrier);
+    if (to === 'market')
+        addMarketGlyph(selected, cx, cy);
+    if (to === 'pipeline')
+        addHandle(selected, carrier, cx, cy);
+    rewriteLabel(selected, from, to);
+}
+/**
+ * Wardley's morph declaration, handed to the generic `morphToolbarConfig`.
+ *
+ * `modelType` is the native `GroupElementModel` and not
+ * `WardleyNodeElementModel`, because every artefact in this family is a
+ * composite and the group is what a click on one selects. Everything that makes
+ * that safe is in {@link wardleyNodeOfComponent}: the toolbar's own homogeneity
+ * test only proves that each selected element is A group, and the resolution
+ * proves that each one is one of OURS.
+ *
+ * `propsOf` is the shipped creation builder minus `type` / `xywh` / `text`
+ * ({@link wardleyMorphProps}), so the palette and the morph cannot disagree
+ * about what a pipeline looks like, and `clearOf` removes the keys the target
+ * does not write — `radius`, which only the pipeline has.
+ */
+export const WARDLEY_MORPH_SPEC = {
+    framework: 'wardley',
+    families: WARDLEY_MORPH_FAMILIES,
+    modelType: GroupElementModel,
+    resolveTarget: wardleyNodeOfComponent,
+    kindOf: (model) => model instanceof WardleyNodeElementModel && MORPH_KINDS.has(model.kind)
+        ? model.kind
+        : undefined,
+    // The NODE's role, which is the only role a Wardley artefact has: the group
+    // carries none, the label carries `wardley:label` (which says it is a name,
+    // not what it names) and the market's dots carry none at all.
+    roleOf: kind => WARDLEY_ROLE[kind],
+    propsOf: wardleyMorphProps,
+    clearOf: wardleyMorphClears,
+    afterMorph: wardleyMorphComposite,
+    labelOf,
+    iconOf,
+    label: morphLabel('com.labre.morph.toolbar.label', 'Change type'),
+};

package/dist/presets.d.ts

@@ -0,0 +1,130 @@
+import { type WardleyNodeKind } from '@formicoidea/labre-core/model';
+/**
+ * What a Wardley artefact IS, as props — the ONE description the creation sites
+ * and the morph both read.
+ *
+ * Split out of `actions.ts` when the morph landed, for the reason C4's and
+ * BPMN's `presets.ts` give: a kind's appearance is written by the preset of the
+ * kind it was CREATED as and nothing else ever rewrites it, so a morph that
+ * restated the table would agree with the palette the day it was written and
+ * drift on the first restyle. Derived, they cannot — a component morphed into a
+ * market and one drawn from the sub-menu are the same element.
+ *
+ * The three pieces that are not artefacts live here too, and for the same
+ * reason: the pipeline's HANDLE, the market's three neutral DOTS and the
+ * triangle that wires them are glyph parts, and the morph has to be able to
+ * build and unbuild them exactly as `createWardleyMarket` /
+ * `createWardleyPipeline` build them once.
+ */
+/**
+ * Every kind a user can draw — {@link WardleyNodeKind} minus the `handle`.
+ *
+ * The handle is not an artefact: it is the square that straddles a pipeline's
+ * top edge so connectors have somewhere to land (the body itself declares
+ * `connectable === false`). Nobody picks one from the palette, nothing may morph
+ * into one, and {@link wardleyHandleProps} is how the two composites that need
+ * one ask for it.
+ */
+export type WardleyArtefactKind = Exclude<WardleyNodeKind, 'handle'>;
+/**
+ * The size a kind is BORN at, which for Wardley is the notation rather than a
+ * default.
+ *
+ * A market is 30 across and a component is 18 because that is what tells a
+ * reader which is which — the two are the same white circle otherwise. Same for
+ * the ecosystem's 40 and the pipeline's 120×25 bar. This is the table the morph
+ * re-centres an artefact on, and the one the palette draws from.
+ */
+export declare const WARDLEY_NODE_SIZE: Record<WardleyArtefactKind, {
+    w: number;
+    h: number;
+}>;
+/**
+ * The words a kind is created NEXT TO — the prompt an artefact nobody has named
+ * still carries, and the only string a morph is ever allowed to rewrite.
+ */
+export declare const WARDLEY_NODE_LABEL: Record<WardleyArtefactKind, string>;
+/** A box centred on a point — how every Wardley creation site places a node. */
+export declare function wardleyCenteredBox(cx: number, cy: number, w: number, h: number): string;
+/** The canonical box of one kind, centred where the artefact already stands. */
+export declare function wardleyCanonicalBox(kind: WardleyArtefactKind, cx: number, cy: number): string;
+/**
+ * Every prop a Wardley node is created with, for one kind and one box.
+ *
+ * Five of the six are a native ELLIPSE and differ only in fill and size: the
+ * glyph — the anchor's silhouette, the ecosystem's hatched donut, the method's
+ * inner circle — is drawn by the renderer from `kind`, off this same model, so
+ * stroke and fill stay editable from the shape toolbar exactly like any other
+ * shape's. The pipeline is the exception and the reason `clearOf` exists on this
+ * pack: it is a RECT, and it is the only kind that writes `radius`.
+ *
+ * No `text`: a Wardley label is a separate free-text element grouped with the
+ * node (see `addLabel` in `actions.ts`), never words stored on the shape.
+ */
+export declare function wardleyNodeProps(kind: WardleyArtefactKind, box: {
+    xywh: string;
+}): Record<string, unknown> & {
+    type: string;
+};
+/**
+ * The pipeline's handle: a node-sized square straddling the body's top edge, and
+ * the only place a connector may land on a pipeline.
+ *
+ * It inherits `centerAnchorOnly` from the model like every other Wardley node,
+ * and it carries `wardley:handle` — a role of its own, so nothing that judges
+ * components ever judges it.
+ */
+export declare function wardleyHandleProps(box: {
+    xywh: string;
+}): Record<string, unknown> & {
+    type: string;
+};
+/** Where a handle sits, given the body's centre: astride the top edge. */
+export declare function wardleyHandleBox(cx: number, cy: number): string;
+/**
+ * One of the market's three inner dots — thicker-bordered, and deliberately
+ * ROLE-LESS.
+ *
+ * They are the GLYPH's own wiring rather than artefacts the user placed, the
+ * same reason the triangle between them carries no role: they sit inside the
+ * market circle by construction, so a role would make every market composite
+ * report an overlap with itself (W3).
+ */
+export declare function wardleyMarketDotProps(box: {
+    xywh: string;
+}): Record<string, unknown> & {
+    type: string;
+};
+/** The three dot boxes of a market centred on (cx, cy) — an upright triangle. */
+export declare function wardleyMarketDotBoxes(cx: number, cy: number): string[];
+/**
+ * One side of the market's triangle: an ATTACHED connector, so it auto-routes
+ * centre to centre and follows the dots on move and resize.
+ */
+export declare function wardleyMarketLinkProps(sourceId: string, targetId: string): Record<string, unknown> & {
+    type: string;
+};
+/** The pairs the triangle wires, given the three dots in creation order. */
+export declare function wardleyMarketLinkPairs<T>(dots: readonly T[]): [T, T][];
+/**
+ * What a kind is worth to a node that ALREADY EXISTS — {@link wardleyNodeProps}
+ * minus the three things a morph has no business touching.
+ *
+ * The whole preset and not `{kind, role}`, and on this pack it is visibly not a
+ * formality: a pipeline is a rect with square corners and a semi-transparent
+ * fill, and the other three members of the family are opaque white ellipses. A
+ * two-key patch would turn a component into a "pipeline" still drawn as a
+ * circle.
+ */
+export declare function wardleyMorphProps(kind: WardleyArtefactKind): Record<string, unknown>;
+/**
+ * The fields to DELETE after morphing to `kind` — the keys some other kind
+ * writes and this one does not.
+ *
+ * `radius` for every kind but the pipeline, and that is not a formality either:
+ * a patch cannot express absence, so a pipeline morphed back to a component
+ * would keep `radius: 0` sitting in the Y.Map, silently in force on an ellipse.
+ * Derived rather than listed, so the day a preset gains a conditional key it is
+ * covered without anybody remembering to come here.
+ */
+export declare function wardleyMorphClears(kind: WardleyArtefactKind): readonly string[];

package/dist/presets.js

@@ -0,0 +1,230 @@
+import { ConnectorMode, PointStyle, ShapeStyle, StrokeStyle, } from '@formicoidea/labre-core/model';
+import { Bound } from '@formicoidea/labre-core/global/gfx';
+import { ECOSYSTEM_LABEL, ECOSYSTEM_SIZE, HANDLE_SIZE, LABEL_DEFAULT, MARKET_DOT_RING, MARKET_DOT_SIZE, MARKET_DOT_STROKE_WIDTH, MARKET_LABEL, MARKET_LINK_COLOR, MARKET_LINK_WIDTH, MARKET_SIZE, METHOD_FILL, METHOD_LABEL, METHOD_SIZE, NODE_FILL, NODE_SIZE, NODE_STROKE, NODE_STROKE_WIDTH, PIPELINE_FILL, PIPELINE_HEIGHT, PIPELINE_LABEL, PIPELINE_WIDTH, } from './node/consts.js';
+import { WARDLEY_ROLE } from './roles.js';
+/**
+ * The size a kind is BORN at, which for Wardley is the notation rather than a
+ * default.
+ *
+ * A market is 30 across and a component is 18 because that is what tells a
+ * reader which is which — the two are the same white circle otherwise. Same for
+ * the ecosystem's 40 and the pipeline's 120×25 bar. This is the table the morph
+ * re-centres an artefact on, and the one the palette draws from.
+ */
+export const WARDLEY_NODE_SIZE = {
+    component: { w: NODE_SIZE, h: NODE_SIZE },
+    anchor: { w: NODE_SIZE, h: NODE_SIZE },
+    ecosystem: { w: ECOSYSTEM_SIZE, h: ECOSYSTEM_SIZE },
+    method: { w: METHOD_SIZE, h: METHOD_SIZE },
+    market: { w: MARKET_SIZE, h: MARKET_SIZE },
+    pipeline: { w: PIPELINE_WIDTH, h: PIPELINE_HEIGHT },
+};
+/**
+ * The words a kind is created NEXT TO — the prompt an artefact nobody has named
+ * still carries, and the only string a morph is ever allowed to rewrite.
+ */
+export const WARDLEY_NODE_LABEL = {
+    component: LABEL_DEFAULT.component,
+    anchor: LABEL_DEFAULT.anchor,
+    ecosystem: ECOSYSTEM_LABEL,
+    method: METHOD_LABEL,
+    market: MARKET_LABEL,
+    pipeline: PIPELINE_LABEL,
+};
+/**
+ * The fill a kind is born with. White for every circle that means "a thing on
+ * the value chain"; the method's grey is the one that carries meaning — it
+ * ENCODES the chosen method and stays editable from the toolbar.
+ */
+const NODE_FILL_OF = {
+    component: NODE_FILL,
+    anchor: NODE_FILL,
+    ecosystem: NODE_FILL,
+    method: METHOD_FILL,
+    market: NODE_FILL,
+    // White at ~60% opacity: a pipeline is a bar you place components ON, so the
+    // map has to stay visible through it. The 1px border stays opaque.
+    pipeline: PIPELINE_FILL,
+};
+/** A box centred on a point — how every Wardley creation site places a node. */
+export function wardleyCenteredBox(cx, cy, w, h) {
+    return new Bound(cx - w / 2, cy - h / 2, w, h).serialize();
+}
+/** The canonical box of one kind, centred where the artefact already stands. */
+export function wardleyCanonicalBox(kind, cx, cy) {
+    const { w, h } = WARDLEY_NODE_SIZE[kind];
+    return wardleyCenteredBox(cx, cy, w, h);
+}
+/**
+ * Every prop a Wardley node is created with, for one kind and one box.
+ *
+ * Five of the six are a native ELLIPSE and differ only in fill and size: the
+ * glyph — the anchor's silhouette, the ecosystem's hatched donut, the method's
+ * inner circle — is drawn by the renderer from `kind`, off this same model, so
+ * stroke and fill stay editable from the shape toolbar exactly like any other
+ * shape's. The pipeline is the exception and the reason `clearOf` exists on this
+ * pack: it is a RECT, and it is the only kind that writes `radius`.
+ *
+ * No `text`: a Wardley label is a separate free-text element grouped with the
+ * node (see `addLabel` in `actions.ts`), never words stored on the shape.
+ */
+export function wardleyNodeProps(kind, box) {
+    const rect = kind === 'pipeline';
+    return {
+        type: 'wardleyNode',
+        kind,
+        // Semantic identity (PF1): posted next to `kind`, which stays untouched and
+        // keeps driving the rendering. The role is what every rule reads — no rule
+        // will ever look at a shape type.
+        role: WARDLEY_ROLE[kind],
+        shapeType: rect ? 'rect' : 'ellipse',
+        filled: true,
+        fillColor: NODE_FILL_OF[kind],
+        strokeColor: NODE_STROKE,
+        strokeWidth: NODE_STROKE_WIDTH,
+        shapeStyle: ShapeStyle.General,
+        roughness: 0,
+        // Square corners, and ONLY on the kind that has corners at all. Spread
+        // conditionally rather than written as 0 everywhere, because that is the
+        // truth about the ellipses — and because a key some kinds write and others
+        // do not is precisely what `wardleyMorphClears` is for.
+        ...(rect ? { radius: 0 } : {}),
+        xywh: box.xywh,
+    };
+}
+/**
+ * The pipeline's handle: a node-sized square straddling the body's top edge, and
+ * the only place a connector may land on a pipeline.
+ *
+ * It inherits `centerAnchorOnly` from the model like every other Wardley node,
+ * and it carries `wardley:handle` — a role of its own, so nothing that judges
+ * components ever judges it.
+ */
+export function wardleyHandleProps(box) {
+    return {
+        type: 'wardleyNode',
+        kind: 'handle',
+        role: WARDLEY_ROLE.handle,
+        shapeType: 'rect',
+        filled: true,
+        fillColor: NODE_FILL,
+        strokeColor: NODE_STROKE,
+        strokeWidth: NODE_STROKE_WIDTH,
+        shapeStyle: ShapeStyle.General,
+        roughness: 0,
+        radius: 0,
+        xywh: box.xywh,
+    };
+}
+/** Where a handle sits, given the body's centre: astride the top edge. */
+export function wardleyHandleBox(cx, cy) {
+    const top = cy - WARDLEY_NODE_SIZE.pipeline.h / 2;
+    return wardleyCenteredBox(cx, top, HANDLE_SIZE, HANDLE_SIZE);
+}
+/**
+ * One of the market's three inner dots — thicker-bordered, and deliberately
+ * ROLE-LESS.
+ *
+ * They are the GLYPH's own wiring rather than artefacts the user placed, the
+ * same reason the triangle between them carries no role: they sit inside the
+ * market circle by construction, so a role would make every market composite
+ * report an overlap with itself (W3).
+ */
+export function wardleyMarketDotProps(box) {
+    return {
+        type: 'wardleyNode',
+        kind: 'component',
+        role: undefined,
+        shapeType: 'ellipse',
+        filled: true,
+        fillColor: NODE_FILL,
+        strokeColor: NODE_STROKE,
+        strokeWidth: MARKET_DOT_STROKE_WIDTH,
+        shapeStyle: ShapeStyle.General,
+        roughness: 0,
+        xywh: box.xywh,
+    };
+}
+/** The three dot boxes of a market centred on (cx, cy) — an upright triangle. */
+export function wardleyMarketDotBoxes(cx, cy) {
+    const rho = MARKET_DOT_RING;
+    const sin60 = Math.sqrt(3) / 2;
+    return [
+        [0, -rho],
+        [rho * sin60, rho / 2],
+        [-rho * sin60, rho / 2],
+    ].map(([vx, vy]) => wardleyCenteredBox(cx + vx, cy + vy, MARKET_DOT_SIZE, MARKET_DOT_SIZE));
+}
+/**
+ * One side of the market's triangle: an ATTACHED connector, so it auto-routes
+ * centre to centre and follows the dots on move and resize.
+ */
+export function wardleyMarketLinkProps(sourceId, targetId) {
+    return {
+        type: 'connector',
+        mode: ConnectorMode.Straight,
+        source: { id: sourceId },
+        target: { id: targetId },
+        stroke: MARKET_LINK_COLOR,
+        strokeStyle: StrokeStyle.Solid,
+        strokeWidth: MARKET_LINK_WIDTH,
+        frontEndpointStyle: PointStyle.None,
+        rearEndpointStyle: PointStyle.None,
+    };
+}
+/** The pairs the triangle wires, given the three dots in creation order. */
+export function wardleyMarketLinkPairs(dots) {
+    return [
+        [dots[0], dots[1]],
+        [dots[1], dots[2]],
+        [dots[2], dots[0]],
+    ];
+}
+/**
+ * The box {@link wardleyMorphProps} hands {@link wardleyNodeProps} and then
+ * throws away. Never written to a document: the morph places the element
+ * itself, from {@link wardleyCanonicalBox}, in `afterMorph`.
+ */
+const DISCARDED_BOX = '[0,0,0,0]';
+/** What a morph must never rewrite: identity, geometry, and the user's words. */
+const NOT_A_MORPH = ['type', 'xywh', 'text'];
+/**
+ * What a kind is worth to a node that ALREADY EXISTS — {@link wardleyNodeProps}
+ * minus the three things a morph has no business touching.
+ *
+ * The whole preset and not `{kind, role}`, and on this pack it is visibly not a
+ * formality: a pipeline is a rect with square corners and a semi-transparent
+ * fill, and the other three members of the family are opaque white ellipses. A
+ * two-key patch would turn a component into a "pipeline" still drawn as a
+ * circle.
+ */
+export function wardleyMorphProps(kind) {
+    const props = {
+        ...wardleyNodeProps(kind, { xywh: DISCARDED_BOX }),
+    };
+    for (const key of NOT_A_MORPH)
+        delete props[key];
+    return props;
+}
+/**
+ * Every key ANY kind's props may carry — the union over the whole pack.
+ *
+ * Computed rather than listed, so a preset that starts spreading a key
+ * conditionally is covered on the day it is added rather than on the day
+ * somebody notices.
+ */
+const EVERY_MORPH_KEY = new Set(Object.keys(WARDLEY_NODE_SIZE).flatMap(kind => Object.keys(wardleyMorphProps(kind))));
+/**
+ * The fields to DELETE after morphing to `kind` — the keys some other kind
+ * writes and this one does not.
+ *
+ * `radius` for every kind but the pipeline, and that is not a formality either:
+ * a patch cannot express absence, so a pipeline morphed back to a component
+ * would keep `radius: 0` sitting in the Y.Map, silently in force on an ellipse.
+ * Derived rather than listed, so the day a preset gains a conditional key it is
+ * covered without anybody remembering to come here.
+ */
+export function wardleyMorphClears(kind) {
+    const present = new Set(Object.keys(wardleyMorphProps(kind)));
+    return [...EVERY_MORPH_KEY].filter(key => !present.has(key));
+}

package/dist/roles.js

@@ -55,16 +55,21 @@ const DEFS = [
         labelKey: 'com.labre.wardley.role.method',
     },
     /**
-     * The value-chain link: "A depends on B".
+     * The value-chain link: "A needs B".
      *
      * The comment above was the whole of the convention until `docs/adr/0010`
      * made it DATA. Tier 1 of that ADR is generic — `source` is the subject of
      * the role's verb, `target` its object — and tier 2 is this `direction`
-     * block: the verb of THIS role is "depends on", so its source is the
-     * consumer and its target is what the consumer needs. Needs descend from
-     * source to target; value flows back up. W4 evaluates exactly that reading,
-     * and the tool hint below is what makes it a statement the user made rather
-     * than a by-product of which end their finger landed on first.
+     * block: the verb of THIS role is "needs", so its source is the consumer and
+     * its target is what the consumer needs. Needs descend from source to target;
+     * value flows back up. W4 evaluates exactly that reading, and the tool hint
+     * below is what makes it a statement the user made rather than a by-product
+     * of which end their finger landed on first.
+     *
+     * The verb read "depends on" until the PO recette of 02/09/2026: one word, in
+     * the user's own vocabulary, on a chip that is laid ALONG the link and must
+     * not outgrow it. Only the FALLBACK moved — `verbKey` is stable, and the
+     * French wording ("A besoin") comes from the host's catalogue.
      */
     {
         id: WARDLEY_ROLE.dependency,
@@ -73,9 +78,15 @@ const DEFS = [
         labelFallback: 'Dependency',
         direction: {
             verbKey: 'com.labre.wardley.role.dependency.verb',
-            verbFallback: 'depends on',
+            verbFallback: 'needs',
             gestureHintKey: 'com.labre.wardley.role.dependency.gesture',
             gestureHintFallback: 'Drag from the component that has the need to what it needs.',
+            // The house primary, on THIS chip and no other (same recette). The value
+            // chain is what a Wardley map is read along, and the PO asked for the
+            // relation that carries it to be unmistakable — a decision about one
+            // relation, so it is declared on that relation rather than on the
+            // mechanism, and every other framework's reveal keeps the colour it had.
+            chipColor: '#2563eb',
         },
     },
     // The map itself: the axes frame the other roles are positioned against.

package/dist/view.js

@@ -1,5 +1,5 @@
-import { InterchangeExtension, ReadingProfileExtension, tagsToolbarConfig, validationToolbarConfig, QualityNudgeExtension, ValidationProfileExtension, ValidationRuleExtension, } from '@formicoidea/labre-core/blocks/surface';
-import { AuditCriterionExtension, ToolbarModuleExtension, UniverseTagDefsExtension, } from '@formicoidea/labre-core/shared/services';
+import { InterchangeExtension, morphToolbarConfig, ReadingProfileExtension, tagsToolbarConfig, validationToolbarConfig, QualityNudgeExtension, ValidationProfileExtension, ValidationRuleExtension, } from '@formicoidea/labre-core/blocks/surface';
+import { AuditCriterionExtension, ToolbarModuleExtension, toolbarModuleKey, UniverseTagDefsExtension, } from '@formicoidea/labre-core/shared/services';
 import { ViewExtensionProvider, } from '@formicoidea/labre-core/ext-loader';
 import { extendTemplateCategory } from '@formicoidea/labre-core/gfx/template';
 import { BlockFlavourIdentifier, CommandExtension } from '@formicoidea/labre-core/std';
@@ -8,6 +8,7 @@ import { WARDLEY_AUDIT_CRITERIA } from './audit-criteria.js';
 import { wardleyCommandIcons, wardleyCommands } from './commands.js';
 import { effects } from './effects.js';
 import { WARDLEY_INTERCHANGE } from './interchange.js';
+import { WARDLEY_MORPH_SPEC } from './morph.js';
 import { WARDLEY_TAG_DEFS } from './natures.js';
 import { WARDLEY_PROFILES } from './profiles.js';
 import { WARDLEY_NUDGES } from './nudges.js';
@@ -133,6 +134,33 @@ export class WardleyViewExtension extends ViewExtensionProvider {
                     config: tagsToolbarConfig(WARDLEY_ROLES),
                 }));
             }
+            // The "Change type" dropdown on a selected COMPONENT's contextual
+            // toolbar — the generic module, parameterized by Wardley's own family.
+            //
+            // ## Why the key carries an owner
+            //
+            // A Wardley artefact is a native `group`, so the row the toolbar draws
+            // for it is the GROUP's row — and both plain group keys are already
+            // claimed: `affine:surface:group` by the native group operations, and
+            // `custom:affine:surface:group` by the qualification dropdown twenty
+            // lines above, which is on the group for the very same reason this is.
+            // Registering a second module on either would throw
+            // `DuplicateServiceDefinitionError` before the editor finished setting
+            // up. `toolbarModuleKey` is what lifts that ceiling — C4's morph already
+            // uses it on this flavour — so the module is registered under the
+            // DISTINCT variant `custom:affine:surface:group#wardley-morph` and the
+            // registry hands it to the same row.
+            //
+            // ## Why here
+            //
+            // In the flag-gated half, because a morph is TOOLING: a market drawn
+            // while the flag was on keeps its circle, its dots, its role and its
+            // place in every rule when the flag goes off — it just stops being
+            // something the toolbar offers to say differently (`docs/adr/0009`).
+            context.register(ToolbarModuleExtension({
+                id: BlockFlavourIdentifier(toolbarModuleKey('custom:affine:surface:group', 'wardley-morph')),
+                config: morphToolbarConfig(WARDLEY_MORPH_SPEC),
+            }));
             // The reversed reading (MF3): what the map says about a component, on
             // demand. One declaration — the roles, the nature tag, the dependency
             // edge and the map's own zones, all of them already stated elsewhere in

package/package.json

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