@formicoidea/labre-framework-wardley 0.35.0 → 0.36.0

package/dist/actions.d.ts

@@ -1,8 +1,9 @@
 import { WardleyBackgroundElementModel, type WardleyBgVariant } from '@formicoidea/labre-core/model';
+import { Bound } from '@formicoidea/labre-core/global/gfx';
 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';
+import { type WardleyAreaShape, 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,
@@ -10,12 +11,15 @@ import { type WardleyArtefactKind } from './presets.js';
  *
  * 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.
+ * eleven values, and two homonyms of different cardinality — one of them the
+ * source of the semantic vocabulary — is a trap. The market, the pipeline and
+ * the Porter's-forces glyph are composites with creation functions of their
+ * own; the accelerator and the decelerator are not circles at all and place
+ * their label on the side their arrow points from
+ * ({@link createWardleyAccelerator}); the area is a zone with no label element
+ * at all ({@link createWardleyArea}); the handle is not an artefact.
  */
-export type WardleySingleCircleKind = Exclude<WardleyArtefactKind, 'market' | 'pipeline'>;
+export type WardleySingleCircleKind = Exclude<WardleyArtefactKind, 'market' | 'pipeline' | 'porter' | 'accelerator' | 'decelerator' | 'area'>;
 /** Create a wardley map background of the given variant, viewport-centered. */
 export declare function createWardleyBackground(gfx: GfxController, variant?: WardleyBgVariant): void;
 /**
@@ -42,6 +46,104 @@ export declare function createWardleyPipeline(gfx: GfxController): void;
  * everything is grouped into one object.
  */
 export declare function createWardleyMarket(gfx: GfxController): void;
+/**
+ * Create a Porter's-forces glyph: a white circle carrying ONE letter, pushed on
+ * from the four cardinal directions by solid red arrows, all grouped as one
+ * object.
+ *
+ * It marks an EXTERNAL competition force acting on the map — which is why the
+ * circle carries `wardley:porter` and nothing under `wardley:component`: it is
+ * not a link in the value chain, and no rule written about the chain has
+ * anything to say about a pressure applied from outside it.
+ *
+ * No label, and that is the notation rather than an omission: the letter says
+ * which force this is (R relative competition, L struggle for survival, E
+ * struggle to establish) and it is the circle's OWN inner text, so a
+ * double-click opens the native shape editor on it (`node/node-view.ts`). The
+ * four arrows are the glyph's own wiring — role-less filled red polygons,
+ * outside the rim — exactly as the market's triangle is its own.
+ */
+export declare function createWardleyPorter(gfx: GfxController): void;
+/**
+ * Create an accelerator or a decelerator: one fat native POLYGON and the words
+ * that say what it is, grouped like every other artefact.
+ *
+ * Not a link in the value chain, and not a pressure on it either: an annotation
+ * of the CLIMATE, saying that something is speeding evolution up (an arrow
+ * pointing right, towards commodity) or holding it back (the mirror, pointing
+ * left). Which way it points IS the notation, so the two are separate kinds
+ * with outlines of their own rather than one kind with a `rotate`.
+ *
+ * ## Where the words go, and why it is not always the right
+ *
+ * Every other single artefact on this canvas wears its name on its right,
+ * because a circle has no direction to disagree with. An arrow does. The
+ * reference puts the words on the side the arrow's SHAFT is on — right of an
+ * accelerator, left of a decelerator — so the reading runs into the arrow
+ * rather than across it, and the label is aligned towards it (left-aligned on
+ * the right, right-aligned on the left) so the words end against the shaft
+ * whatever their length.
+ *
+ * SemiBold, which no other Wardley label is: these two are annotations laid
+ * over a map that is already full of names, and the weight is what keeps the
+ * word readable as a remark ABOUT the map rather than as one more component.
+ */
+export declare function createWardleyAccelerator(gfx: GfxController, kind: 'accelerator' | 'decelerator'): void;
+/**
+ * Create an AREA: a translucent zone of the map, drawn as a rectangle or as a
+ * polygon whose corners the author then moves.
+ *
+ * One element and no group, which makes it the plainest creation site in this
+ * file — and the difference is the name. Every other artefact wears its name as
+ * a text element beside it, so every other artefact is a group of two. A zone's
+ * name belongs INSIDE the zone, so it is the shape's own inner text: created
+ * empty, opened by a double-click on the zone (`node/node-view.ts`), and set in
+ * a fit mode that never resizes the boundary around it.
+ *
+ * ## Why it is sent to the back
+ *
+ * A zone is drawn precisely OVER the components it groups, and the surface
+ * paints in index order: an area added last would sit on top of everything it
+ * surrounds — hiding it under a wash, and worse, intercepting every click meant
+ * for a component inside it. So the element is lowered the moment it exists,
+ * to the depth {@link wardleyAreaIndexOver} works out.
+ */
+export declare function createWardleyArea(gfx: GfxController, shape: WardleyAreaShape): void;
+/**
+ * One already-placed element, as {@link wardleyAreaIndexOver} needs to read it.
+ *
+ * Three fields and no model, so the placement can be reasoned about — and
+ * tested — without a document: what it is, where it is, and how deep.
+ */
+export interface WardleyStackedElement {
+    /** Fractional index. Sorts lexicographically, which IS the paint order. */
+    index: string;
+    /** Serialized box. */
+    xywh: string;
+    /** Whether this is a framework BACKGROUND — a map, a pool, a C4 board… */
+    isBackground: boolean;
+}
+/**
+ * How deep a freshly drawn zone goes: just ABOVE the framework backgrounds it
+ * covers, and below everything else. `null` means the back of the surface.
+ *
+ * "The back" alone was the first answer and it was wrong, as the recette of
+ * #213 found: a Wardley map is a framework BACKGROUND — an opaque one — so a
+ * zone sent behind the whole surface went behind the map and vanished. What a
+ * zone must be under is the artefacts it groups; what it must be over is the
+ * canvas they are drawn on. Those are two different depths, and only the first
+ * one is "the back".
+ *
+ * So: find the topmost background the zone actually OVERLAPS — the map it was
+ * drawn on, and not some other framework's board parked elsewhere on the same
+ * canvas — and mint a key between it and whatever sits directly above it. With
+ * no background under the zone at all there is nothing to clear, and the back
+ * of the surface is right again.
+ *
+ * `siblings` need not be sorted: fractional indexes sort lexicographically, so
+ * this sorts them itself and reads the paint order straight off the strings.
+ */
+export declare function wardleyAreaIndexOver(siblings: readonly WardleyStackedElement[], box: Bound): string | null;
 /**
  * Read an SVG the user picks as a SKETCH, and say what it cost.
  *

package/dist/actions.js

@@ -1,17 +1,17 @@
 import { backgroundSize, DefaultTool, runInterchangeImportFile, } from '@formicoidea/labre-core/blocks/surface';
 import { ConnectorTool } from '@formicoidea/labre-core/gfx/connector';
 import { createGroupCommand } from '@formicoidea/labre-core/gfx/group';
-import { ConnectorMode, FontFamily, PointStyle, ShapeStyle, StrokeStyle, TextFitMode, WardleyBackgroundElementModel, } from '@formicoidea/labre-core/model';
+import { ConnectorMode, FontFamily, FontWeight, FrameworkBackgroundElementModel, PointStyle, ShapeStyle, StrokeStyle, TextFitMode, WardleyBackgroundElementModel, } from '@formicoidea/labre-core/model';
 import { NotificationProvider, translateKey, } from '@formicoidea/labre-core/shared/services';
 import { downloadBlob } from '@formicoidea/labre-core/shared/utils';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
-import { GfxControllerIdentifier } from '@formicoidea/labre-core/std/gfx';
+import { generateKeyBetween, GfxControllerIdentifier, } from '@formicoidea/labre-core/std/gfx';
 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 { 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 { HANDLE_SIZE, INERTIA_COLOR, INERTIA_SIZE, LABEL_FONT_SIZE, LABEL_GAP, LINK_GREY, LINK_STROKE_WIDTH, NODE_STROKE, PORTER_DEFAULT_LETTER, WARDLEY_RED, } from './node/consts.js';
+import { wardleyAreaBox, wardleyAreaProps, wardleyCanonicalBox, wardleyHandleBox, wardleyHandleProps, wardleyMarketDotBoxes, wardleyMarketDotProps, wardleyMarketLinkPairs, wardleyMarketLinkProps, WARDLEY_NODE_LABEL, WARDLEY_NODE_SIZE, wardleyNodeProps, wardleyPorterArrowProps, wardleyPorterArrows, wardleyPorterLetterProps, } from './presets.js';
 import { WARDLEY_ROLE } from './roles.js';
 /**
  * Standalone creation/activation actions for the Wardley toolbox — the
@@ -64,6 +64,14 @@ const BACKGROUND_VARIANT_DEFAULTS = {
 };
 /** Height of the native free-text labels (Inter, size 18). */
 const LABEL_H = LABEL_FONT_SIZE + 8;
+/**
+ * Width of a label box, whatever it reads.
+ *
+ * A number rather than a measurement, which is why a RIGHT-aligned label has to
+ * subtract it: the box does not shrink to the words, so the only way to make
+ * the words end on a given edge is to start the box a full width before it.
+ */
+const LABEL_W = 120;
 function finish(gfx, id) {
     gfx.doc.captureSync();
     gfx.tool.setTool(DefaultTool);
@@ -81,18 +89,27 @@ function group(gfx, ids) {
 /**
  * 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`).
+ * The APPEARANCE is {@link wardleyNodeProps}' and nothing else: the palette and
+ * the "Change type" dropdown read that one description, so a market drawn here
+ * and a component morphed into one are the same element (`presets.ts`).
+ *
+ * `extra` is for what a preset cannot carry — the Porter's-forces letter, which
+ * is CONTENT the author then edits, not a look. `wardleyMorphProps` strips
+ * `text` for exactly that reason, so a preset that wrote one would be a preset
+ * the morph has to un-write.
  */
-function addNode(surface, kind, cx, cy) {
-    return surface.addElement(wardleyNodeProps(kind, { xywh: wardleyCanonicalBox(kind, cx, cy) }));
+function addNode(surface, kind, cx, cy, extra = {}) {
+    return surface.addElement({
+        ...wardleyNodeProps(kind, { xywh: wardleyCanonicalBox(kind, cx, cy) }),
+        ...extra,
+    });
 }
 /** Add a native free-text label (same Inter family as the axis labels). */
-function addLabel(surface, text, x, y, textAlign = 'left') {
+function addLabel(surface, text, x, y, textAlign = 'left', fontWeight = FontWeight.Regular) {
     return surface.addElement({
         type: 'text',
         text,
+        fontWeight,
         // Semantic identity (PF1, revised in PF13.4): a Wardley label is a free
         // text element like any other, so its ROLE is the only thing that tells W3
         // it must not land on top of a node. A free text the user typed elsewhere
@@ -102,7 +119,7 @@ function addLabel(surface, text, x, y, textAlign = 'left') {
         fontSize: LABEL_FONT_SIZE,
         color: NODE_STROKE,
         textAlign,
-        xywh: new Bound(x, y, 120, LABEL_H).serialize(),
+        xywh: new Bound(x, y, LABEL_W, LABEL_H).serialize(),
     });
 }
 /** Create a wardley map background of the given variant, viewport-centered. */
@@ -222,6 +239,150 @@ export function createWardleyMarket(gfx) {
     const labelId = addLabel(surface, WARDLEY_NODE_LABEL.market, cx + R + LABEL_GAP, cy - LABEL_H / 2);
     finish(gfx, group(gfx, [circleId, ...dotIds, ...connIds, labelId]));
 }
+/**
+ * Create a Porter's-forces glyph: a white circle carrying ONE letter, pushed on
+ * from the four cardinal directions by solid red arrows, all grouped as one
+ * object.
+ *
+ * It marks an EXTERNAL competition force acting on the map — which is why the
+ * circle carries `wardley:porter` and nothing under `wardley:component`: it is
+ * not a link in the value chain, and no rule written about the chain has
+ * anything to say about a pressure applied from outside it.
+ *
+ * No label, and that is the notation rather than an omission: the letter says
+ * which force this is (R relative competition, L struggle for survival, E
+ * struggle to establish) and it is the circle's OWN inner text, so a
+ * double-click opens the native shape editor on it (`node/node-view.ts`). The
+ * four arrows are the glyph's own wiring — role-less filled red polygons,
+ * outside the rim — exactly as the market's triangle is its own.
+ */
+export function createWardleyPorter(gfx) {
+    const surface = gfx.surface;
+    if (!surface)
+        return;
+    const { centerX: cx, centerY: cy } = gfx.viewport;
+    const circleId = addNode(surface, 'porter', cx, cy, wardleyPorterLetterProps(PORTER_DEFAULT_LETTER));
+    const arrowIds = wardleyPorterArrows(cx, cy).map(arrow => surface.addElement(wardleyPorterArrowProps(arrow)));
+    finish(gfx, group(gfx, [circleId, ...arrowIds]));
+}
+/**
+ * Create an accelerator or a decelerator: one fat native POLYGON and the words
+ * that say what it is, grouped like every other artefact.
+ *
+ * Not a link in the value chain, and not a pressure on it either: an annotation
+ * of the CLIMATE, saying that something is speeding evolution up (an arrow
+ * pointing right, towards commodity) or holding it back (the mirror, pointing
+ * left). Which way it points IS the notation, so the two are separate kinds
+ * with outlines of their own rather than one kind with a `rotate`.
+ *
+ * ## Where the words go, and why it is not always the right
+ *
+ * Every other single artefact on this canvas wears its name on its right,
+ * because a circle has no direction to disagree with. An arrow does. The
+ * reference puts the words on the side the arrow's SHAFT is on — right of an
+ * accelerator, left of a decelerator — so the reading runs into the arrow
+ * rather than across it, and the label is aligned towards it (left-aligned on
+ * the right, right-aligned on the left) so the words end against the shaft
+ * whatever their length.
+ *
+ * SemiBold, which no other Wardley label is: these two are annotations laid
+ * over a map that is already full of names, and the weight is what keeps the
+ * word readable as a remark ABOUT the map rather than as one more component.
+ */
+export function createWardleyAccelerator(gfx, kind) {
+    const surface = gfx.surface;
+    if (!surface)
+        return;
+    const { w } = WARDLEY_NODE_SIZE[kind];
+    const { centerX: cx, centerY: cy } = gfx.viewport;
+    const nodeId = addNode(surface, kind, cx, cy);
+    const rightwards = kind === 'accelerator';
+    const labelId = addLabel(surface, WARDLEY_NODE_LABEL[kind], 
+    // A label box is a fixed LABEL_W wide whatever it reads, so a right-aligned
+    // one has to start a box-width before the edge the words must end on.
+    rightwards ? cx + w / 2 + LABEL_GAP : cx - w / 2 - LABEL_GAP - LABEL_W, cy - LABEL_H / 2, rightwards ? 'left' : 'right', FontWeight.SemiBold);
+    finish(gfx, group(gfx, [nodeId, labelId]));
+}
+/**
+ * Create an AREA: a translucent zone of the map, drawn as a rectangle or as a
+ * polygon whose corners the author then moves.
+ *
+ * One element and no group, which makes it the plainest creation site in this
+ * file — and the difference is the name. Every other artefact wears its name as
+ * a text element beside it, so every other artefact is a group of two. A zone's
+ * name belongs INSIDE the zone, so it is the shape's own inner text: created
+ * empty, opened by a double-click on the zone (`node/node-view.ts`), and set in
+ * a fit mode that never resizes the boundary around it.
+ *
+ * ## Why it is sent to the back
+ *
+ * A zone is drawn precisely OVER the components it groups, and the surface
+ * paints in index order: an area added last would sit on top of everything it
+ * surrounds — hiding it under a wash, and worse, intercepting every click meant
+ * for a component inside it. So the element is lowered the moment it exists,
+ * to the depth {@link wardleyAreaIndexOver} works out.
+ */
+export function createWardleyArea(gfx, shape) {
+    const surface = gfx.surface;
+    if (!surface)
+        return;
+    const { centerX: cx, centerY: cy } = gfx.viewport;
+    const xywh = wardleyAreaBox(shape, cx, cy);
+    const id = surface.addElement(wardleyAreaProps(shape, { xywh }));
+    const model = surface.getElementById(id);
+    if (model) {
+        const over = wardleyAreaIndexOver(stackedElementsOf(surface, id), Bound.deserialize(xywh));
+        // `null` is "nothing under it": the back of the surface, minted by the
+        // layer itself so an empty board gets the layer's own initial index rather
+        // than a key invented here.
+        model.index = over ?? gfx.layer.getReorderedIndex(model, 'back');
+    }
+    finish(gfx, id);
+}
+/** The top-level canvas elements of a surface, minus the one being placed. */
+function stackedElementsOf(surface, exclude) {
+    return surface.elementModels
+        .filter(model => model.id !== exclude && model.group === null)
+        .map(model => ({
+        index: model.index,
+        xywh: model.xywh,
+        isBackground: model instanceof FrameworkBackgroundElementModel,
+    }));
+}
+/**
+ * How deep a freshly drawn zone goes: just ABOVE the framework backgrounds it
+ * covers, and below everything else. `null` means the back of the surface.
+ *
+ * "The back" alone was the first answer and it was wrong, as the recette of
+ * #213 found: a Wardley map is a framework BACKGROUND — an opaque one — so a
+ * zone sent behind the whole surface went behind the map and vanished. What a
+ * zone must be under is the artefacts it groups; what it must be over is the
+ * canvas they are drawn on. Those are two different depths, and only the first
+ * one is "the back".
+ *
+ * So: find the topmost background the zone actually OVERLAPS — the map it was
+ * drawn on, and not some other framework's board parked elsewhere on the same
+ * canvas — and mint a key between it and whatever sits directly above it. With
+ * no background under the zone at all there is nothing to clear, and the back
+ * of the surface is right again.
+ *
+ * `siblings` need not be sorted: fractional indexes sort lexicographically, so
+ * this sorts them itself and reads the paint order straight off the strings.
+ */
+export function wardleyAreaIndexOver(siblings, box) {
+    const stack = [...siblings].sort((a, b) => a.index < b.index ? -1 : a.index > b.index ? 1 : 0);
+    // The LAST match, which is the topmost: a board with two maps on it gets the
+    // zone above the one it is actually drawn over, whichever was drawn first.
+    const under = stack.reduce((found, element, at) => element.isBackground &&
+        Bound.deserialize(element.xywh).isOverlapWithBound(box)
+        ? at
+        : found, -1);
+    if (under < 0)
+        return null;
+    // `null` for the upper bound when the background is the topmost element
+    // there is — `generateKeyBetween` reads that as "append after".
+    return generateKeyBetween(stack[under].index, stack[under + 1]?.index ?? null);
+}
 /**
  * Read an SVG the user picks as a SKETCH, and say what it cost.
  *

package/dist/commands-manifest.js

@@ -119,6 +119,46 @@ export const wardleyCommandsManifest = [
         scope: 'edgeless',
         defaultKeys: { mac: ['w', 'i'], other: ['w', 'i'] },
     },
+    {
+        id: 'wardley.addPorter',
+        owner: 'wardley',
+        labelKey: 'com.labre.commands.wardley.addPorter',
+        labelFallback: "Porter's forces",
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'wardley.addAccelerator',
+        owner: 'wardley',
+        labelKey: 'com.labre.commands.wardley.addAccelerator',
+        labelFallback: 'Accelerator',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'wardley.addDecelerator',
+        owner: 'wardley',
+        labelKey: 'com.labre.commands.wardley.addDecelerator',
+        labelFallback: 'Decelerator',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'wardley.addAreaRect',
+        owner: 'wardley',
+        labelKey: 'com.labre.commands.wardley.addAreaRect',
+        labelFallback: 'Area (rectangle)',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
+    {
+        id: 'wardley.addAreaPolygon',
+        owner: 'wardley',
+        labelKey: 'com.labre.commands.wardley.addAreaPolygon',
+        labelFallback: 'Area (polygon)',
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+    },
     {
         id: 'wardley.importOwm',
         owner: 'wardley',

package/dist/commands.d.ts

@@ -1,8 +1,25 @@
 import type { CommandDescriptor } from '@formicoidea/labre-core/std';
 import type { TemplateResult } from 'lit';
 /**
- * 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 declare const wardleyCommands: CommandDescriptor[];
 /** `iconKey` → template. Never travels through either manifest (ADR 0008). */

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,