@formicoidea/labre-framework-wardley 0.34.2 → 0.36.0

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/natures.d.ts

@@ -47,4 +47,35 @@ export declare const WARDLEY_NATURE: {
     readonly practice: "wardley:nature/practice";
     readonly knowledge: "wardley:nature/knowledge";
 };
+/**
+ * The Porter's-forces **competition** tag — which of the forces a glyph marks.
+ *
+ * The second tag of this pack, and the one that shows the mechanism was worth
+ * building: it is declared beside the nature, on the SAME pack, and it applies
+ * to a role the nature deliberately never reaches. A force is not a link in the
+ * value chain (`roles.ts` says why `wardley:porter` has no parent), so nothing
+ * written on `wardley:component` touches it — and this tag, written on
+ * `wardley:porter` alone, touches nothing else.
+ *
+ * ## Why it duplicates the letter, and why that is not a duplication
+ *
+ * The letter in the circle IS the notation: an architect reads `L` off the map
+ * and knows what it says. But a letter is not a FACT anything can query — no
+ * rule, no reading, no host report can ask "which forces does this map name?"
+ * of a `Y.Text` holding one character. The tag is the queryable half, and
+ * `WardleyPorterWatcher` keeps the two saying the same thing in both
+ * directions, so neither is the master and the author can work in whichever
+ * one is in front of them.
+ *
+ * `cardinality: 'single'` for the reason the nature gives, and one the drawing
+ * gives too: there is exactly one letter in the circle, so a second value would
+ * be a qualification the map could not show.
+ */
+export declare const WARDLEY_COMPETITION_TAG_ID = "wardley:competition";
+/** The three forces, as value ids. Ids are forever; a def is only deprecated. */
+export declare const WARDLEY_COMPETITION: {
+    readonly relative: "wardley:competition/relative";
+    readonly struggle: "wardley:competition/struggle";
+    readonly establish: "wardley:competition/establish";
+};
 export declare const WARDLEY_TAG_DEFS: UniverseTagDefs;

package/dist/natures.js

@@ -47,6 +47,37 @@ export const WARDLEY_NATURE = {
     practice: `${WARDLEY_NATURE_TAG_ID}/practice`,
     knowledge: `${WARDLEY_NATURE_TAG_ID}/knowledge`,
 };
+/**
+ * The Porter's-forces **competition** tag — which of the forces a glyph marks.
+ *
+ * The second tag of this pack, and the one that shows the mechanism was worth
+ * building: it is declared beside the nature, on the SAME pack, and it applies
+ * to a role the nature deliberately never reaches. A force is not a link in the
+ * value chain (`roles.ts` says why `wardley:porter` has no parent), so nothing
+ * written on `wardley:component` touches it — and this tag, written on
+ * `wardley:porter` alone, touches nothing else.
+ *
+ * ## Why it duplicates the letter, and why that is not a duplication
+ *
+ * The letter in the circle IS the notation: an architect reads `L` off the map
+ * and knows what it says. But a letter is not a FACT anything can query — no
+ * rule, no reading, no host report can ask "which forces does this map name?"
+ * of a `Y.Text` holding one character. The tag is the queryable half, and
+ * `WardleyPorterWatcher` keeps the two saying the same thing in both
+ * directions, so neither is the master and the author can work in whichever
+ * one is in front of them.
+ *
+ * `cardinality: 'single'` for the reason the nature gives, and one the drawing
+ * gives too: there is exactly one letter in the circle, so a second value would
+ * be a qualification the map could not show.
+ */
+export const WARDLEY_COMPETITION_TAG_ID = 'wardley:competition';
+/** The three forces, as value ids. Ids are forever; a def is only deprecated. */
+export const WARDLEY_COMPETITION = {
+    relative: `${WARDLEY_COMPETITION_TAG_ID}/relative`,
+    struggle: `${WARDLEY_COMPETITION_TAG_ID}/struggle`,
+    establish: `${WARDLEY_COMPETITION_TAG_ID}/establish`,
+};
 export const WARDLEY_TAG_DEFS = {
     formatVersion: 1,
     // The id of this PACK, not of the framework: several packs may extend
@@ -62,10 +93,12 @@ export const WARDLEY_TAG_DEFS = {
             description: 'What kind of thing this component is: an activity, data, a practice or knowledge.',
             cardinality: 'single',
             appliesTo: [WARDLEY_ROLE.component],
-            // No `order`: it is the only tag this pack declares, and an absent order
-            // sorts by SEED order, which is what puts the library's pack ahead of a
-            // client's extension without either having to know about the other. A
-            // number here would be a claim about packs that do not exist yet.
+            // No `order`, on either tag of this pack: an absent order sorts by SEED
+            // order, which is what puts the library's pack ahead of a client's
+            // extension without either having to know about the other. A number here
+            // would be a claim about packs that do not exist yet — and it would say
+            // nothing anyway, since the two tags below apply to disjoint roles and
+            // are therefore never offered in the same dropdown.
             values: [
                 {
                     id: WARDLEY_NATURE.activity,
@@ -89,5 +122,32 @@ export const WARDLEY_TAG_DEFS = {
                 },
             ],
         },
+        {
+            id: WARDLEY_COMPETITION_TAG_ID,
+            label: 'Competition',
+            description: "Which of Porter's forces this glyph marks: relative competition, a struggle for survival, or a struggle to establish.",
+            cardinality: 'single',
+            appliesTo: [WARDLEY_ROLE.porter],
+            values: [
+                {
+                    id: WARDLEY_COMPETITION.relative,
+                    // The label carries the letter, because the letter is what the map
+                    // shows: a reader picking a value here is choosing what the circle
+                    // will say, not filling in a form about it.
+                    label: 'Relative competition (R)',
+                    description: 'Established players competing against one another on a market that exists.',
+                },
+                {
+                    id: WARDLEY_COMPETITION.struggle,
+                    label: 'Struggle for survival (L)',
+                    description: 'Pressure on a player to stay in a market it is already in.',
+                },
+                {
+                    id: WARDLEY_COMPETITION.establish,
+                    label: 'Struggle to establish (E)',
+                    description: 'Pressure on a newcomer trying to get into a market.',
+                },
+            ],
+        },
     ],
 };

package/dist/node/consts.d.ts

@@ -104,3 +104,126 @@ export declare const METHOD: {
     centerRatio: number;
 };
 export declare const METHOD_LABEL = "Component";
+/**
+ * Porter's forces (composite): a large white circle carrying ONE letter, pushed
+ * on from the four cardinal directions by solid red arrows.
+ *
+ * Twice the market's diameter, at the PO's recette of #210: this is not a link
+ * in the value chain drawn a little differently, it is a pressure bearing on the
+ * whole map, and it has to read as one at the zoom an architect actually works
+ * at. Every other number here is proportional to it.
+ *
+ * The letter IS the notation — **R** relative competition, **L** struggle for
+ * survival, **E** struggle to establish — which is why it is written as the
+ * shape's own inner text rather than as a label beside it: a double-click opens
+ * the native shape editor on the circle, and typing another letter is the whole
+ * of the edit. It is also why this glyph carries no label at all: the three
+ * words behind the three letters are the map's vocabulary, not a name the
+ * author gives one force.
+ */
+export declare const PORTER_SIZE = 60;
+/**
+ * The four arrows, read by `wardleyPorterArrows`: each starts `gap` outside the
+ * circle's rim and runs `length` further out, a `width`-wide shaft carrying a
+ * head `headLength` long and `headWidth` across.
+ *
+ * They are drawn as filled POLYGONS rather than as connectors with a triangle
+ * endpoint, and the recette of #210 is why: a connector sizes its head off its
+ * STROKE WIDTH (`DEFAULT_ARROW_SIZE` × strokeWidth / 2), which is a number about
+ * a line rather than about this notation — the head came out longer than the
+ * arrow, swallowed the circle, the letter and the double-click, and the glyph
+ * rendered as a solid red star. A polygon's head is the number written here and
+ * nothing else, at any size.
+ */
+export declare const PORTER_ARROW: {
+    gap: number;
+    length: number;
+    /** Shaft width. */
+    width: number;
+    headLength: number;
+    headWidth: number;
+};
+/** The letter, sized to sit inside the circle without touching the rim. */
+export declare const PORTER_LETTER_FONT_SIZE = 28;
+/** The letter a fresh glyph opens on: relative competition, the commonest read. */
+export declare const PORTER_DEFAULT_LETTER = "R";
+/**
+ * Accelerators and decelerators — the climate annotations.
+ *
+ * A fat solid arrow with a flat grey fill and a thick dark border: as close as
+ * a native polygon gets to the reference's solid arrow, because this canvas has
+ * no gradient fill. The two are the same drawing mirrored — an accelerator
+ * points RIGHT, towards the commodity end of the evolution axis, a decelerator
+ * points LEFT, back towards genesis — and that direction IS the notation, which
+ * is why the outlines are written out below rather than expressed as one shape
+ * plus a `rotate`: a rotated element is one the selection, the resize handles
+ * and every bounding-box reader then have to de-rotate.
+ *
+ * Neither is a link in the value chain, so neither carries a component role
+ * (see `roles.ts`): they say something about the CLIMATE the map is drawn in.
+ */
+export declare const ACCELERATOR_SIZE: {
+    w: number;
+    h: number;
+};
+/** Flat grey: the arrow is a annotation, and must not out-shout the chain. */
+export declare const ACCELERATOR_FILL = "#bfbfbf";
+/** A thick dark border — `NODE_STROKE`, like every other artefact's rim. */
+export declare const ACCELERATOR_STROKE_WIDTH = 2;
+/**
+ * The accelerator's outline, normalized to its box, pointing RIGHT.
+ *
+ * Seven points: the shaft's two left corners, the head's upper barb, the tip,
+ * the head's lower barb, and back along the shaft. `0.55` is where the head
+ * starts, `0.28 / 0.72` the shaft's own edges.
+ */
+export declare const ACCELERATOR_VERTICES: readonly (readonly [number, number])[];
+/** The decelerator: the same outline mirrored `x → 1 − x`, pointing LEFT. */
+export declare const DECELERATOR_VERTICES: readonly (readonly [number, number])[];
+export declare const ACCELERATOR_LABEL = "Accelerator";
+export declare const DECELERATOR_LABEL = "Decelerator";
+/**
+ * Areas — the zones of the map.
+ *
+ * A ring you draw AROUND components to say "all of this is one thing": a
+ * business unit, a team's territory, a scope under discussion. It is not a link
+ * in the value chain and not an annotation of the climate either, which is why
+ * it carries a role with no parent and sits in a category of its own in the
+ * toolbox.
+ *
+ * Two shapes, one kind: a RECT for the common case and a POLYGON for a zone
+ * whose outline has to follow the components it groups (its corners are then
+ * moved from the shape toolbar's vertex editor). The `shapeType` is what says
+ * which, so nothing about an area is a second kind to keep in step.
+ *
+ * A zone is drawn OVER the map it groups, so the fill is the load-bearing
+ * number here: Peace light at ~25 % opacity, which is a wash the components
+ * underneath still read through. The border is the saturated Peace of the same
+ * swatch, thin like every other artefact's rim — the zone must frame the map,
+ * never compete with it.
+ */
+export declare const AREA_RECT_SIZE: {
+    w: number;
+    h: number;
+};
+/** The polygon is born square: its default outline is a regular pentagon. */
+export declare const AREA_POLYGON_SIZE: {
+    w: number;
+    h: number;
+};
+/** Peace light at ~25 % opacity — an 8-digit hex, exactly as `PIPELINE_FILL`. */
+export declare const AREA_FILL = "#c6dbfc40";
+/** Peace, the saturated shade of the same swatch. */
+export declare const AREA_STROKE = "#5b9cf6";
+export declare const AREA_STROKE_WIDTH = 1;
+/**
+ * The word the legend describes an area by.
+ *
+ * NOT written into the document: an area is created NAMELESS, so the editor
+ * that a double-click opens starts on an empty line and the first thing typed
+ * is the zone's own name. The other artefacts carry a placeholder because their
+ * name is a text element beside them and an empty one would be invisible; an
+ * area's name is its own inner text, and a placeholder there would be a word
+ * the author has to delete before writing theirs.
+ */
+export declare const AREA_LABEL = "Area";