@formicoidea/labre-framework-wardley 0.34.2 → 0.36.0

package/dist/commands.js

@@ -1,7 +1,7 @@
 import { GfxControllerIdentifier } from '@formicoidea/labre-core/std/gfx';
-import { activateWardleyConnector, createWardleyBackground, createWardleyInertia, createWardleyMarket, createWardleyNode, createWardleyPipeline, exportOwmFile, importOwmFile, importWardleySvgFile, wardleyMapsOnBoard, } from './actions.js';
+import { activateWardleyConnector, createWardleyAccelerator, createWardleyArea, createWardleyBackground, createWardleyInertia, createWardleyMarket, createWardleyNode, createWardleyPipeline, createWardleyPorter, exportOwmFile, importOwmFile, importWardleySvgFile, wardleyMapsOnBoard, } from './actions.js';
 import { WARDLEY_ROLE, WARDLEY_ROLES } from './roles.js';
-import { wardleyAnchorIcon, wardleyArrowIcon, wardleyBackgroundIcon, wardleyBenefitIcon, wardleyComponentIcon, wardleyEcosystemIcon, wardleyEvolutionGradientIcon, wardleyExportOwmIcon, wardleyImportOwmIcon, wardleyImportSvgIcon, wardleyInertiaIcon, wardleyLinkIcon, wardleyMarketIcon, wardleyMethodIcon, wardleyOpportunityIcon, wardleyPipelineIcon, } from './toolbar/icons.js';
+import { wardleyAcceleratorIcon, wardleyAnchorIcon, wardleyAreaPolygonIcon, wardleyAreaRectIcon, wardleyArrowIcon, wardleyBackgroundIcon, wardleyDeceleratorIcon, wardleyBenefitIcon, wardleyComponentIcon, wardleyEcosystemIcon, wardleyEvolutionGradientIcon, wardleyExportOwmIcon, wardleyImportOwmIcon, wardleyImportSvgIcon, wardleyInertiaIcon, wardleyLinkIcon, wardleyMarketIcon, wardleyMethodIcon, wardleyOpportunityIcon, wardleyPipelineIcon, wardleyPorterIcon, } from './toolbar/icons.js';
 const SPECS = [
     {
         id: 'addBackground',
@@ -12,6 +12,7 @@ const SPECS = [
         category: 'backgrounds',
         kind: 'artefact',
         element: 'background:classic',
+        board: true,
         run: gfx => createWardleyBackground(gfx, 'classic'),
     },
     {
@@ -21,6 +22,7 @@ const SPECS = [
         category: 'backgrounds',
         kind: 'artefact',
         element: 'background:opportunity',
+        board: true,
         run: gfx => createWardleyBackground(gfx, 'opportunity'),
     },
     {
@@ -30,6 +32,7 @@ const SPECS = [
         category: 'backgrounds',
         kind: 'artefact',
         element: 'background:benefit',
+        board: true,
         run: gfx => createWardleyBackground(gfx, 'benefit'),
     },
     {
@@ -39,6 +42,7 @@ const SPECS = [
         category: 'backgrounds',
         kind: 'artefact',
         element: 'background:evolution-gradient',
+        board: true,
         run: gfx => createWardleyBackground(gfx, 'evolution-gradient'),
     },
     {
@@ -137,6 +141,69 @@ const SPECS = [
         element: 'node:inertia',
         run: createWardleyInertia,
     },
+    // Last of the nodes, and last of the row: a Porter's force is the only
+    // artefact on this palette that is not part of the map — it is what presses
+    // on it from outside — so it reads as an annotation you reach for once the
+    // chain is drawn. Keyless: the `w` chord already seats eight artefacts, and
+    // a framework binds past that by host override rather than by default.
+    {
+        id: 'addPorter',
+        label: "Porter's forces",
+        iconKey: 'wardley.porter',
+        category: 'nodes',
+        kind: 'artefact',
+        element: 'node:porter',
+        run: createWardleyPorter,
+    },
+    // The two climate annotations, after the force and for the same reason: they
+    // are not links in the value chain either, and they are reached for once the
+    // chain is drawn and the question becomes how fast it is moving. Keyless,
+    // like the porter — the `w` chord seats eight artefacts and a framework binds
+    // past that by host override.
+    {
+        id: 'addAccelerator',
+        label: 'Accelerator',
+        iconKey: 'wardley.accelerator',
+        category: 'nodes',
+        kind: 'artefact',
+        element: 'node:accelerator',
+        run: gfx => createWardleyAccelerator(gfx, 'accelerator'),
+    },
+    {
+        id: 'addDecelerator',
+        label: 'Decelerator',
+        iconKey: 'wardley.decelerator',
+        category: 'nodes',
+        kind: 'artefact',
+        element: 'node:decelerator',
+        run: gfx => createWardleyAccelerator(gfx, 'decelerator'),
+    },
+    // The zones, last of the toolbox and after the connectors: an area is drawn
+    // around a chain that already exists, so it is the last gesture of a map and
+    // reads as the last entry of the row. Two entries and ONE kind — the shape is
+    // the choice, and offering it as two buttons is what saves the author a trip
+    // through "switch type" for the commonest case.
+    //
+    // Keyless, like the porter and the two climate arrows: the `w` chord seats
+    // eight artefacts and a framework binds past that by host override.
+    {
+        id: 'addAreaRect',
+        label: 'Area (rectangle)',
+        iconKey: 'wardley.area-rect',
+        category: 'areas',
+        kind: 'artefact',
+        element: 'node:area-rect',
+        run: gfx => createWardleyArea(gfx, 'rect'),
+    },
+    {
+        id: 'addAreaPolygon',
+        label: 'Area (polygon)',
+        iconKey: 'wardley.area-polygon',
+        category: 'areas',
+        kind: 'artefact',
+        element: 'node:area-polygon',
+        run: gfx => createWardleyArea(gfx, 'polygon'),
+    },
 ];
 /**
  * The sentence a tool shows under its label — the role's own gesture hint
@@ -171,7 +238,7 @@ const toolboxCommands = SPECS.map((spec, order) => ({
         : { mac: [], other: [] },
     availability: 'always',
     run: std => spec.run(std.get(GfxControllerIdentifier)),
-    telemetry: { framework: 'wardley', element: spec.element },
+    telemetry: { framework: 'wardley', element: spec.element, board: spec.board },
 }));
 /**
  * The IMPORT — the first Wardley command whose subject is a whole map rather
@@ -183,9 +250,9 @@ const toolboxCommands = SPECS.map((spec, order) => ({
  * the sub-menu is the first thing a user opens, and "start from the map
  * somebody sent me" belongs in that row beside "start from a component" —
  * asking them to find the catalogue sidepanel first is the friction the
- * decision names. It is Wardley's fourteenth nomination, which is exactly the
- * cap, so nothing about the sub-menu's arbitration changes and no button is
- * pushed out of the row.
+ * decision names. It is the `+1` of ADR 0014's R4 — the single deliberate
+ * over-nomination the PO signed off on, and the reason this framework's
+ * nomination budget is `SENIOR_MENU_CAP + 1` rather than the cap itself.
  *
  * No `'contextual-toolbar'`: a contextual toolbar is a statement about a
  * SELECTION, and the moment this command is most wanted is on a board with
@@ -323,8 +390,25 @@ const importSvgCommand = {
     telemetry: { framework: 'wardley', element: 'board:import-svg' },
 };
 /**
- * The Wardley registry: the thirteen toolbox entries, then the two directions
+ * The Wardley registry: the eighteen toolbox entries, then the two directions
  * of the OWM DSL and the SVG fallback (`docs/adr/0012`).
+ *
+ * ## Nineteen nominations, and the curation decision behind them
+ *
+ * `addPorter` spent the last seat of ADR 0014 R4's `SENIOR_MENU_CAP + 1`
+ * budget, and `addAccelerator` / `addDecelerator` are the two past it. The PO
+ * made the call on 2026-09-03 (Amendment 2026-09-03 under R4): **every Wardley
+ * artefact nominates the row**. The row itself is unchanged — thirteen
+ * arbitrated seats plus "More artefacts…", the cap of fourteen it has had since
+ * the OWM pair tipped this framework over — so what the decision buys is that
+ * a newly-drawn artefact is ELIGIBLE for a seat, and recency and frequency
+ * decide who gets one. Nothing becomes unreachable: the catalogue lists
+ * everything, which is the registry's own invariant.
+ *
+ * `addAreaRect` and `addAreaPolygon` are the two after those, and they land
+ * under that same amendment rather than reopening it: they nominate like every
+ * other Wardley artefact, the row is still thirteen arbitrated seats plus "More
+ * artefacts…", and the catalogue grows by a section of its own.
  */
 export const wardleyCommands = [
     ...toolboxCommands,
@@ -347,6 +431,11 @@ export const wardleyCommandIcons = {
     'wardley.link': wardleyLinkIcon,
     'wardley.arrow': wardleyArrowIcon,
     'wardley.inertia': wardleyInertiaIcon,
+    'wardley.porter': wardleyPorterIcon,
+    'wardley.accelerator': wardleyAcceleratorIcon,
+    'wardley.decelerator': wardleyDeceleratorIcon,
+    'wardley.area-rect': wardleyAreaRectIcon,
+    'wardley.area-polygon': wardleyAreaPolygonIcon,
     'wardley.import-owm': wardleyImportOwmIcon,
     'wardley.export-owm': wardleyExportOwmIcon,
     'wardley.import-svg': wardleyImportSvgIcon,

package/dist/export.js

@@ -336,6 +336,10 @@ function labelAnchors(node, label) {
  *
  * A pipeline HANDLE never claims a label: it sits on the body's top edge, right
  * under the name the body owns, and would win every pipeline's name from it.
+ * A Porter's-forces glyph never claims one either, and for a sharper reason: it
+ * HAS no name — its one letter is the shape's own inner text — so any label it
+ * matched would be some neighbouring artefact's, taken out of that artefact's
+ * mouth and then thrown away, since a force is not written to the file at all.
  */
 function matchLabels(nodes, labels) {
     const pairs = [];
@@ -343,8 +347,15 @@ function matchLabels(nodes, labels) {
         // A handle sits on the pipeline body's top edge, directly under the name
         // the BODY owns, and would win it from the body every time. A roleless node
         // is a glyph's own wiring (a market's three inner dots) and names nothing.
-        if (node.kind === 'handle' || node.role === undefined)
+        // An AREA claims none either, and it is the one that would do real damage:
+        // a zone is drawn around the components it groups, so its box sits next to
+        // every label on the map and would win one from the artefact it belongs to.
+        if (node.kind === 'handle' ||
+            node.kind === 'porter' ||
+            node.kind === 'area' ||
+            node.role === undefined) {
             return;
+        }
         const nodeBox = boxOf(node);
         labels.forEach((label, labelIndex) => {
             const labelBox = boxOf(label);
@@ -380,7 +391,17 @@ export function textOf(element) {
  * method is the `(build)` / `(buy)` / `(outsource)` decorator on a component
  * line — so a Labre method node is written as a component and the export warns
  * that the method itself could not be said. `pipeline` and `handle` are absent
- * because a pipeline is written from its BODY, in its own section.
+ * because a pipeline is written from its BODY, in its own section — and
+ * `porter` because OWM has no word for an external competition force at all —
+ * and `area` for the same silence, since the format has no word for a zone of
+ * the map either. The node loop skips both before this table is consulted, so a
+ * kind's absence here is never the reason it is left out.
+ *
+ * The climate annotations DO have a word, and OWM's own spelling of the second
+ * one is `deaccelerator` — not a typo on this side but the keyword the
+ * reference parser claims, so writing `decelerator` would produce a line no
+ * other Wardley tool reads. Both are written like a component line, `keyword
+ * name [visibility, evolution]`, which is exactly what they are in that format.
  */
 const OWM_KEYWORD_OF_KIND = {
     component: 'component',
@@ -388,6 +409,8 @@ const OWM_KEYWORD_OF_KIND = {
     market: 'market',
     ecosystem: 'ecosystem',
     method: 'component',
+    accelerator: 'accelerator',
+    decelerator: 'deaccelerator',
 };
 /** What one element carried from the file it came out of, if anything. */
 function carriedOf(element) {
@@ -506,11 +529,30 @@ export function exportWardleyOwmWithWarnings(board, options = {}) {
     const nodeLines = [];
     const pipelineLines = [];
     const methodNodes = [];
+    const porterNodes = [];
+    const areaNodes = [];
     for (const node of board.nodes) {
         if (node.role === undefined)
             continue; // a glyph's own wiring, not an artefact
         if (node.kind === 'handle')
             continue;
+        // Skipped BEFORE `nameOf`, and that is the whole reason it is a branch of
+        // its own rather than a missing entry in `OWM_KEYWORD_OF_KIND`: a force
+        // carries no name, so asking for one would christen it "Component 3" and
+        // count it among the artefacts that lost theirs — a warning about a loss
+        // that never happened, on a line the file does not contain.
+        if (node.kind === 'porter') {
+            porterNodes.push(node.id);
+            continue;
+        }
+        // Same branch, same reason: an area's name is its own inner text rather
+        // than a label beside it, so `nameOf` would find none and christen the zone
+        // "Component 4" — counting a nameless artefact among the ones that lost
+        // their name, on a line the file does not contain either way.
+        if (node.kind === 'area') {
+            areaNodes.push(node.id);
+            continue;
+        }
         if (twins.has(node.id))
             continue; // written by its `evolve` line
         const name = nameOf(node);
@@ -597,6 +639,12 @@ export function exportWardleyOwmWithWarnings(board, options = {}) {
     if (methodNodes.length > 0) {
         warnings.push(`${methodNodes.length} component${methodNodes.length === 1 ? ' carries' : 's carry'} a method (build / buy / outsource). OWM writes a method as a decorator this export cannot tell apart, so ${methodNodes.length === 1 ? 'it was' : 'they were'} written as plain components.`);
     }
+    if (porterNodes.length > 0) {
+        warnings.push(`${porterNodes.length} Porter's forces glyph${porterNodes.length === 1 ? '' : 's'} could not be written: OWM has no word for an external competition force, so ${porterNodes.length === 1 ? 'it was' : 'they were'} left out.`);
+    }
+    if (areaNodes.length > 0) {
+        warnings.push(`${areaNodes.length} area${areaNodes.length === 1 ? '' : 's'} could not be written: OWM has no word for a zone of the map, so ${areaNodes.length === 1 ? 'it was' : 'they were'} left out.`);
+    }
     if (looseLinks.length > 0) {
         warnings.push(`${looseLinks.length} link${looseLinks.length === 1 ? ' has an end' : 's have ends'} that is loose or attached to something that is not a Wardley artefact. A link names two components, so ${looseLinks.length === 1 ? 'it was' : 'they were'} left out.`);
     }

package/dist/import.d.ts

@@ -44,10 +44,11 @@ import { OWM_SCOPE, WARDLEY_OWM_FORMAT_ID } from './export.js';
  * ## Three states, and the middle one is where the file survives
  *
  * **Mapped** is what the pack draws: `component`, `anchor`, `market`,
- * `ecosystem`, `pipeline`, `note`, `evolve`, `title`, and the `->` links.
+ * `ecosystem`, `accelerator`, `deaccelerator`, `pipeline`, `note`, `evolve`,
+ * `title`, and the `->` links.
  * **Carried** is every other statement — `style`, `annotation`, `attitudes`
  * (`pioneers` / `settlers` / `townplanners`), `submap`, `url`, `size`,
- * `accelerator`, the axis-label overrides, the flow links (`+>`, `+<`, `+<>`,
+ * the axis-label overrides, the flow links (`+>`, `+<`, `+<>`,
  * `+'…'>`), a link carrying a `;` context, and every `//` comment — kept
  * verbatim in `interchange.owm.children['@document']` on the map's background
  * element (D6) and written back, in order, at the end of the next export.
@@ -67,6 +68,7 @@ import { OWM_SCOPE, WARDLEY_OWM_FORMAT_ID } from './export.js';
  * | what                                                                   | state       | after a round trip                                                                                                     |
  * | ---------------------------------------------------------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------- |
  * | `component` / `anchor` / `market` / `ecosystem` and their coordinates  | mapped      | drawn, and written back from the drawing, to two decimals                                                              |
+ * | `accelerator` / `deaccelerator` and their coordinates                 | mapped      | drawn as the climate arrow, and written back under OWM's own spelling (`deaccelerator` for a decelerator)              |
  * | the NAME, which in this format is the identity                        | mapped      | given back verbatim, quoted exactly as it needs to be — the fixed point                                                |
  * | `pipeline Name [m1, m2]`                                              | mapped      | drawn as the body + handle composite; `[m1, m2]` written back from the body's two edges                                |
  * | `note Text [v, e]`                                                    | mapped      | a free text on the map, written back from its centre                                                                   |
@@ -74,7 +76,7 @@ import { OWM_SCOPE, WARDLEY_OWM_FORMAT_ID } from './export.js';
  * | `A->B` links                                                          | mapped      | a `wardley:dependency` connector, consumer → what it needs, never inverted                                             |
  * | `title`                                                               | mapped      | consumed as the board's own name; written back from the board's name (see the two rows below)                          |
  * | a mapped line's TAIL — `label [x, y]`, `(build)`, `inertia`, comments | carried     | invisible on the canvas, re-appended to the very line it came off                                                      |
- * | `style`, `annotation(s)`, `attitudes`, `submap`, `url`, `size`, `accelerator`, the axis-label overrides | carried | invisible on the canvas, re-emitted verbatim at the end of the file          |
+ * | `style`, `annotation(s)`, `attitudes`, `submap`, `url`, `size`, the axis-label overrides | carried | invisible on the canvas, re-emitted verbatim at the end of the file          |
  * | flow links (`+>`, `+<`, `+<>`, `+'…'>`) and a link with a `;` context | carried     | not drawn — a flow is not a dependency — and re-emitted verbatim                                                       |
  * | a `pipeline` with a `{ … }` body                                      | carried     | the block is kept whole and written back whole; the pack draws no pipeline children                                    |
  * | `//` comments                                                         | carried     | re-emitted verbatim, at the end                                                                                        |

package/dist/import.js

@@ -1,7 +1,8 @@
-import { ConnectorMode, FontFamily, PointStyle, ShapeStyle, StrokeStyle, TextAlign, } from '@formicoidea/labre-core/model';
+import { ConnectorMode, FontFamily, FontWeight, PointStyle, ShapeStyle, StrokeStyle, TextAlign, } from '@formicoidea/labre-core/model';
 import { WARDLEY_BACKGROUND } from './background.js';
 import { OWM_DEFAULT_MAP_HEIGHT, OWM_DEFAULT_MAP_WIDTH, OWM_LABEL_HEIGHT, OWM_LABEL_WIDTH, OWM_SCOPE, OWM_TAIL_ATTR, OWM_KEYWORDS, OWM_TITLE_ATTR, owmDefaultPlot, owmPointOf, WARDLEY_OWM_FORMAT_ID, } from './export.js';
 import { HANDLE_SIZE, LABEL_GAP, LABEL_FONT_SIZE, LINK_GREY, LINK_STROKE_WIDTH, MARKET_DOT_RING, MARKET_DOT_SIZE, MARKET_DOT_STROKE_WIDTH, MARKET_LINK_COLOR, MARKET_LINK_WIDTH, MARKET_SIZE, ECOSYSTEM_SIZE, NODE_FILL, NODE_SIZE, NODE_STROKE, NODE_STROKE_WIDTH, PIPELINE_FILL, PIPELINE_HEIGHT, WARDLEY_RED, } from './node/consts.js';
+import { WARDLEY_NODE_SIZE, wardleyNodeProps } from './presets.js';
 import { WARDLEY_ROLE } from './roles.js';
 /**
  * An OnlineWardleyMaps (OWM) DSL document, read as a Wardley map — the inverse
@@ -47,10 +48,11 @@ import { WARDLEY_ROLE } from './roles.js';
  * ## Three states, and the middle one is where the file survives
  *
  * **Mapped** is what the pack draws: `component`, `anchor`, `market`,
- * `ecosystem`, `pipeline`, `note`, `evolve`, `title`, and the `->` links.
+ * `ecosystem`, `accelerator`, `deaccelerator`, `pipeline`, `note`, `evolve`,
+ * `title`, and the `->` links.
  * **Carried** is every other statement — `style`, `annotation`, `attitudes`
  * (`pioneers` / `settlers` / `townplanners`), `submap`, `url`, `size`,
- * `accelerator`, the axis-label overrides, the flow links (`+>`, `+<`, `+<>`,
+ * the axis-label overrides, the flow links (`+>`, `+<`, `+<>`,
  * `+'…'>`), a link carrying a `;` context, and every `//` comment — kept
  * verbatim in `interchange.owm.children['@document']` on the map's background
  * element (D6) and written back, in order, at the end of the next export.
@@ -70,6 +72,7 @@ import { WARDLEY_ROLE } from './roles.js';
  * | what                                                                   | state       | after a round trip                                                                                                     |
  * | ---------------------------------------------------------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------- |
  * | `component` / `anchor` / `market` / `ecosystem` and their coordinates  | mapped      | drawn, and written back from the drawing, to two decimals                                                              |
+ * | `accelerator` / `deaccelerator` and their coordinates                 | mapped      | drawn as the climate arrow, and written back under OWM's own spelling (`deaccelerator` for a decelerator)              |
  * | the NAME, which in this format is the identity                        | mapped      | given back verbatim, quoted exactly as it needs to be — the fixed point                                                |
  * | `pipeline Name [m1, m2]`                                              | mapped      | drawn as the body + handle composite; `[m1, m2]` written back from the body's two edges                                |
  * | `note Text [v, e]`                                                    | mapped      | a free text on the map, written back from its centre                                                                   |
@@ -77,7 +80,7 @@ import { WARDLEY_ROLE } from './roles.js';
  * | `A->B` links                                                          | mapped      | a `wardley:dependency` connector, consumer → what it needs, never inverted                                             |
  * | `title`                                                               | mapped      | consumed as the board's own name; written back from the board's name (see the two rows below)                          |
  * | a mapped line's TAIL — `label [x, y]`, `(build)`, `inertia`, comments | carried     | invisible on the canvas, re-appended to the very line it came off                                                      |
- * | `style`, `annotation(s)`, `attitudes`, `submap`, `url`, `size`, `accelerator`, the axis-label overrides | carried | invisible on the canvas, re-emitted verbatim at the end of the file          |
+ * | `style`, `annotation(s)`, `attitudes`, `submap`, `url`, `size`, the axis-label overrides | carried | invisible on the canvas, re-emitted verbatim at the end of the file          |
  * | flow links (`+>`, `+<`, `+<>`, `+'…'>`) and a link with a `;` context | carried     | not drawn — a flow is not a dependency — and re-emitted verbatim                                                       |
  * | a `pipeline` with a `{ … }` body                                      | carried     | the block is kept whole and written back whole; the pack draws no pipeline children                                    |
  * | `//` comments                                                         | carried     | re-emitted verbatim, at the end                                                                                        |
@@ -217,12 +220,21 @@ const MATURITY = String.raw `[0-9]*\.[0-9]+`;
 const BEFORE_MATURITY = new RegExp(String.raw `^(.*?)(\s+${MATURITY})(\s.*)?$`);
 const LEADING_MATURITY = new RegExp(String.raw `^\s*(${MATURITY})`);
 /* ── The statements a document is made of ─────────────────────────────── */
-/** The keywords that declare a positioned artefact, and the kind each is. */
+/**
+ * The keywords that declare a positioned artefact, and the kind each is.
+ *
+ * `deaccelerator` is OWM's own spelling of a decelerator — the keyword the
+ * reference parser claims — so the KEY is the format's word and the VALUE is
+ * this canvas's kind. It is the one row where the two differ, and the reason
+ * this is a table rather than an identity.
+ */
 const NODE_KEYWORDS = {
     component: 'component',
     anchor: 'anchor',
     market: 'market',
     ecosystem: 'ecosystem',
+    accelerator: 'accelerator',
+    deaccelerator: 'decelerator',
 };
 /* ── The reader ───────────────────────────────────────────────────────── */
 /**
@@ -724,7 +736,12 @@ function payload(parts) {
     return { [WARDLEY_OWM_FORMAT_ID]: carried };
 }
 /** A name, as the free text element this canvas writes one as. */
-function label(text, x, y, textAlign, color = NODE_STROKE) {
+function label(text, x, y, textAlign, color = NODE_STROKE, 
+// Regular by default, because that is what a value-chain name is. The one
+// caller that passes anything else is the climate arrow below, and it does so
+// for the reason `createWardleyAccelerator` does: an imported map and a drawn
+// one must be the same document, down to the weight of the words.
+fontWeight = FontWeight.Regular) {
     return {
         type: 'text',
         text,
@@ -734,12 +751,40 @@ function label(text, x, y, textAlign, color = NODE_STROKE) {
         color,
         fontFamily: FontFamily.Inter,
         fontSize: LABEL_FONT_SIZE,
+        fontWeight,
         textAlign,
         xywh: `[${x},${y},${OWM_LABEL_WIDTH},${OWM_LABEL_HEIGHT}]`,
     };
 }
 /** The circle (or composite) one positioned statement draws, plus its name. */
 function artefact(keyword, name, cx, cy, tail, mintHandle) {
+    // The two climate annotations are the only statements this reader draws as
+    // something other than a circle: a fat polygon, at the canonical size the
+    // palette gives one, with its name on the side its shaft is on. The presets
+    // own both facts, so a map that arrives from a file and one drawn by hand are
+    // the same element.
+    const kind = NODE_KEYWORDS[keyword];
+    if (kind === 'accelerator' || kind === 'decelerator') {
+        const { w, h } = WARDLEY_NODE_SIZE[kind];
+        const arrow = {
+            ...wardleyNodeProps(kind, {
+                xywh: `[${cx - w / 2},${cy - h / 2},${w},${h}]`,
+            }),
+            interchange: payload({ id: name, tail }),
+        };
+        const rightwards = kind === 'accelerator';
+        return [
+            arrow,
+            label(name, rightwards
+                ? cx + w / 2 + LABEL_GAP
+                : cx - w / 2 - LABEL_GAP - OWM_LABEL_WIDTH, cy - OWM_LABEL_HEIGHT / 2, rightwards ? TextAlign.Left : TextAlign.Right, NODE_STROKE, 
+            // SemiBold, exactly as the sub-menu draws one. The recette of #212
+            // caught the two paths disagreeing: a climate arrow is an annotation
+            // laid over a map already full of names, and where it came from is not
+            // something the reader should be able to see.
+            FontWeight.SemiBold),
+        ];
+    }
     const diameter = keyword === 'anchor'
         ? OWM_ANCHOR_SIZE
         : keyword === 'market'
@@ -749,8 +794,8 @@ function artefact(keyword, name, cx, cy, tail, mintHandle) {
                 : NODE_SIZE;
     const circle = {
         type: 'wardleyNode',
-        kind: NODE_KEYWORDS[keyword],
-        role: WARDLEY_ROLE[NODE_KEYWORDS[keyword]],
+        kind,
+        role: WARDLEY_ROLE[kind],
         shapeType: 'ellipse',
         filled: true,
         fillColor: NODE_FILL,

package/dist/index.d.ts

@@ -2,11 +2,14 @@ export { WARDLEY_ROLE, WARDLEY_ROLES, type WardleyRole, type WardleyRoleId, } fr
 export { WARDLEY_AUDIT_CRITERIA } from './audit-criteria.js';
 export { wardleyCommandIcons, wardleyCommands } from './commands.js';
 export { wardleyTranslationEntries } from './translations.js';
-export { WARDLEY_NATURE, WARDLEY_NATURE_TAG_ID, WARDLEY_TAG_DEFS, } from './natures.js';
+export { WARDLEY_COMPETITION, WARDLEY_COMPETITION_TAG_ID, WARDLEY_NATURE, WARDLEY_NATURE_TAG_ID, WARDLEY_TAG_DEFS, } from './natures.js';
+export { competitionOfPorterLetter, porterLetterOfCompetition, type WardleyPorterLetter, } from './porter-competition.js';
 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 { WARDLEY_AREA_SIZE, wardleyAreaBox, wardleyAreaProps, type WardleyAreaShape, type WardleyArtefactKind, wardleyCanonicalBox, wardleyCenteredBox, wardleyHandleBox, wardleyHandleProps, wardleyMarketDotBoxes, wardleyMarketDotProps, wardleyMarketLinkPairs, wardleyMarketLinkProps, WARDLEY_NODE_LABEL, WARDLEY_NODE_SIZE, type WardleyLabelledKind, WARDLEY_MORPHABLE_KINDS, wardleyMorphClears, wardleyMorphProps, wardleyNodeProps, type WardleyPorterArrow, wardleyPorterArrowProps, wardleyPorterArrows, wardleyPorterLetterProps, } 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

@@ -2,11 +2,26 @@ export { WARDLEY_ROLE, WARDLEY_ROLES, } from './roles.js';
 export { WARDLEY_AUDIT_CRITERIA } from './audit-criteria.js';
 export { wardleyCommandIcons, wardleyCommands } from './commands.js';
 export { wardleyTranslationEntries } from './translations.js';
-export { WARDLEY_NATURE, WARDLEY_NATURE_TAG_ID, WARDLEY_TAG_DEFS, } from './natures.js';
+export { WARDLEY_COMPETITION, WARDLEY_COMPETITION_TAG_ID, WARDLEY_NATURE, WARDLEY_NATURE_TAG_ID, WARDLEY_TAG_DEFS, } from './natures.js';
+// The letter and the tag, related in both directions. Exported for the reason
+// the presets are: a host laying out or reading a map without an editor —
+// labre-mcp does — must be able to say which force a glyph marks without
+// re-deriving the mapping from the three labels.
+export { competitionOfPorterLetter, porterLetterOfCompetition, } from './porter-competition.js';
 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 { WARDLEY_AREA_SIZE, wardleyAreaBox, wardleyAreaProps, wardleyCanonicalBox, wardleyCenteredBox, wardleyHandleBox, wardleyHandleProps, wardleyMarketDotBoxes, wardleyMarketDotProps, wardleyMarketLinkPairs, wardleyMarketLinkProps, WARDLEY_NODE_LABEL, WARDLEY_NODE_SIZE, WARDLEY_MORPHABLE_KINDS, wardleyMorphClears, wardleyMorphProps, wardleyNodeProps, wardleyPorterArrowProps, wardleyPorterArrows, wardleyPorterLetterProps, } 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/legend.d.ts

@@ -1,11 +1,37 @@
 import { type WardleyBackgroundElementModel } from '@formicoidea/labre-core/model';
 import type { BlockStdScope } from '@formicoidea/labre-core/std';
+/** A box in the panel, relative to the panel's top-left, plus its words. */
+interface PorterPanelBox {
+    xywh: [number, number, number, number];
+    label: string;
+}
+interface PorterPanelLayout {
+    w: number;
+    h: number;
+    title: [number, number, number, number];
+    /** The glyph's centre. */
+    center: [number, number];
+    radius: number;
+    boxes: PorterPanelBox[];
+    caption: [number, number, number, number];
+}
+/**
+ * The panel's geometry for a given width — the PO's reference drawing, as
+ * numbers.
+ *
+ * A pure function so the layout can be asserted without a surface, and so the
+ * one thing that must hold — that none of the four boxes overlaps the glyph
+ * they surround — is checkable rather than eyeballed.
+ */
+export declare function porterPanelLayout(w: number): PorterPanelLayout;
 /**
  * Build a "Legend" group from real, editable elements (white rect frame +
  * "Legend" text + one row of [real component glyph + description text] per
  * Wardley component TYPE present inside the background's perimeter + a
- * gradient-meaning block when the background is a gradient variant). A snapshot
+ * gradient-meaning block when the background is a gradient variant + the
+ * five-forces panel when a Porter's-forces glyph is on the map). A snapshot
  * is created on each call; everything is grouped so it can be moved / resized /
  * edited and is dropped bottom-left of the background.
  */
 export declare function createWardleyLegend(std: BlockStdScope, bg: WardleyBackgroundElementModel): void;
+export {};