@formicoidea/labre-framework-wardley 0.40.0 → 0.42.0

package/dist/templates/index.js

@@ -5,6 +5,7 @@ import { lowerWardleyArea } from '../actions.js';
 import { wardleyCommands } from '../commands.js';
 import { COLORS } from '../consts.js';
 import { INERTIA_COLOR, LINK_GREY, LINK_STROKE_WIDTH, NODE_FILL, NODE_STROKE, WARDLEY_RED, } from '../node/consts.js';
+import { WARDLEY_AREA_SIZE, wardleyAreaProps } from '../presets.js';
 import { WARDLEY_ROLE } from '../roles.js';
 import { wardleyMaps } from './maps.js';
 /**
@@ -73,17 +74,36 @@ const arrowPreview = (rightwards) => `<svg ${ATTRS} fill="none"><path d="${right
     : 'M103 32 H55 V23 L32 40 L55 57 V48 H103 Z'}" fill="#bfbfbf" stroke="${NODE_STROKE}" stroke-width="1.8" stroke-linejoin="round"/></svg>`;
 /** The zone, in its Peace wash — the pair differs on the outline and on nothing else. */
 const areaPreview = (outline) => `<svg ${ATTRS} fill="none">${outline}</svg>`;
+/**
+ * The three hand-drawn palette swatches' own tile names (`Template.nameKey`):
+ * none derives from a command, since `linkTool` / `evolutionArrow` /
+ * `addAreaPolygon` activate a tool rather than draw anything (see `tpl` below
+ * and its docstring).
+ */
+export const WARDLEY_TEMPLATE_NAME_LINK = [
+    'com.labre.wardley.template.link',
+    'Link',
+];
+export const WARDLEY_TEMPLATE_NAME_EVOLUTION_ARROW = [
+    'com.labre.wardley.template.evolution-arrow',
+    'Evolution arrow',
+];
+export const WARDLEY_TEMPLATE_NAME_AREA_POLYGON = [
+    'com.labre.wardley.template.area-polygon',
+    'Area (polygon)',
+];
 /** A hand-composed template — what is left once the artefacts are derived. */
-function tpl(name, preview, elements) {
+function tpl(name, preview, elements, nameKey) {
     return {
         name,
         type: 'template',
         preview,
+        nameKey,
         content: makeTemplateSnapshot(elements, name),
     };
 }
 /**
- * A zone, plus the one thing a snapshot cannot say.
+ * A zone card, plus the one thing a snapshot cannot say.
  *
  * `createWardleyArea` lowers the zone the moment it exists, to just above the
  * framework backgrounds it covers — otherwise the wash sits on top of every
@@ -91,14 +111,16 @@ function tpl(name, preview, elements) {
  * ALREADY ON THE BOARD, which a snapshot knows nothing about, so the panel
  * replays it on the freshly inserted element instead.
  */
-function areaTemplate(id, preview) {
+function areaTemplate(template) {
     return {
-        ...templateFromCommand(byId(id), preview),
+        ...template,
         afterInsert: (std, insertedIds) => lowerWardleyArea(std.get(GfxControllerIdentifier), insertedIds[0]),
     };
 }
 export const wardleyTemplateCategory = {
     name: 'Wardley',
+    // Reuses the senior button's own key — see `TemplateCategory.nameKey`.
+    nameKey: 'com.labre.framework.wardley',
     templates: [
         ...wardleyMaps,
         templateFromCommand(byId('wardley.addBackground'), bgPreview(), 'Map background'),
@@ -126,11 +148,21 @@ export const wardleyTemplateCategory = {
         // artefact to record — the user draws it.
         tpl('Link', `<svg ${ATTRS} fill="none"><path d="M24 40 H110" stroke="${LINK_GREY}" stroke-width="2.4"/></svg>`, {
             a: connect({ position: [0, 0] }, { position: [160, 0] }, { typed: false }),
-        }),
+        }, WARDLEY_TEMPLATE_NAME_LINK[0]),
         tpl('Evolution arrow', `<svg ${ATTRS} fill="none"><path d="M24 40 H100" stroke="${WARDLEY_RED}" stroke-width="2.4" stroke-dasharray="6 4"/><path d="M98 33 L112 40 L98 47 Z" fill="${WARDLEY_RED}"/></svg>`, {
             a: connect({ position: [0, 0] }, { position: [160, 0] }, { evolution: true, typed: false }),
-        }),
-        areaTemplate('wardley.addAreaRect', areaPreview('<rect x="24" y="16" width="87" height="48" rx="2" fill="#c6dbfc" fill-opacity="0.25" stroke="#5b9cf6" stroke-width="1.5"/>')),
-        areaTemplate('wardley.addAreaPolygon', areaPreview('<path d="M67 12 L110 43 L94 68 H40 L24 43 Z" fill="#c6dbfc" fill-opacity="0.25" stroke="#5b9cf6" stroke-width="1.5" stroke-linejoin="round"/>')),
+        }, WARDLEY_TEMPLATE_NAME_EVOLUTION_ARROW[0]),
+        areaTemplate(templateFromCommand(byId('wardley.addAreaRect'), areaPreview('<rect x="24" y="16" width="87" height="48" rx="2" fill="#c6dbfc" fill-opacity="0.25" stroke="#5b9cf6" stroke-width="1.5"/>'))),
+        // Hand-composed, like the two connector swatches and for the same reason:
+        // `wardley.addAreaPolygon` arms the polygon tool (#343) and draws nothing,
+        // so there is no action to record. A panel card cannot arm a tool — it
+        // inserts a snapshot — so the card keeps offering the zone ready-made, and
+        // the author who wants to place the corners uses the sub-menu. The props
+        // still come from the pack, so the two zones cannot disagree.
+        areaTemplate(tpl(WARDLEY_TEMPLATE_NAME_AREA_POLYGON[1], areaPreview('<path d="M67 12 L110 43 L94 68 H40 L24 43 Z" fill="#c6dbfc" fill-opacity="0.25" stroke="#5b9cf6" stroke-width="1.5" stroke-linejoin="round"/>'), {
+            area: wardleyAreaProps('polygon', {
+                xywh: `[0,0,${WARDLEY_AREA_SIZE.polygon.w},${WARDLEY_AREA_SIZE.polygon.h}]`,
+            }),
+        }, WARDLEY_TEMPLATE_NAME_AREA_POLYGON[0])),
     ],
 };

package/dist/templates/maps.d.ts

@@ -1,2 +1,96 @@
 import { type Template } from '@formicoidea/labre-core/gfx/template';
+import { type ChromeWording } from '@formicoidea/labre-core/shared/services';
+/**
+ * The seeds the two worked maps write — declared once so the builders below
+ * and the manifest (`../translations.ts`) read the very same fallback, never
+ * a restated literal. `com.labre.wardley.example.<map>.<slug>`, per
+ * `docs/adr/0023`.
+ */
+export declare const TEA_SHOP_SEED: {
+    readonly title: {
+        readonly key: "com.labre.wardley.example.tea-shop.title";
+        readonly fallback: "Tea Shop";
+    };
+    readonly annotations: {
+        readonly key: "com.labre.wardley.example.tea-shop.annotations";
+        readonly fallback: "Annotations:\n1. Standardising power lets kettles evolve faster\n2. Hot water is obvious and well known";
+    };
+    readonly business: {
+        readonly key: "com.labre.wardley.example.tea-shop.business";
+        readonly fallback: "Business";
+    };
+    readonly public: {
+        readonly key: "com.labre.wardley.example.tea-shop.public";
+        readonly fallback: "Public";
+    };
+    readonly cupOfTea: {
+        readonly key: "com.labre.wardley.example.tea-shop.cup-of-tea";
+        readonly fallback: "Cup of Tea";
+    };
+    readonly cup: {
+        readonly key: "com.labre.wardley.example.tea-shop.cup";
+        readonly fallback: "Cup";
+    };
+    readonly tea: {
+        readonly key: "com.labre.wardley.example.tea-shop.tea";
+        readonly fallback: "Tea";
+    };
+    readonly hotWater: {
+        readonly key: "com.labre.wardley.example.tea-shop.hot-water";
+        readonly fallback: "Hot Water";
+    };
+    readonly water: {
+        readonly key: "com.labre.wardley.example.tea-shop.water";
+        readonly fallback: "Water";
+    };
+    readonly kettle: {
+        readonly key: "com.labre.wardley.example.tea-shop.kettle";
+        readonly fallback: "Kettle";
+    };
+    readonly electricKettle: {
+        readonly key: "com.labre.wardley.example.tea-shop.electric-kettle";
+        readonly fallback: "Electric Kettle";
+    };
+    readonly power: {
+        readonly key: "com.labre.wardley.example.tea-shop.power";
+        readonly fallback: "Power";
+    };
+    readonly limitedBy: {
+        readonly key: "com.labre.wardley.example.tea-shop.limited-by";
+        readonly fallback: "limited by";
+    };
+};
+export declare const KODAK_INERTIA_SEED: {
+    readonly title: {
+        readonly key: "com.labre.wardley.example.kodak-inertia.title";
+        readonly fallback: "Wardley map of Kodak's 2005 inertia to digital";
+    };
+    readonly user: {
+        readonly key: "com.labre.wardley.example.kodak-inertia.user";
+        readonly fallback: "User";
+    };
+    readonly captureAMoment: {
+        readonly key: "com.labre.wardley.example.kodak-inertia.capture-a-moment";
+        readonly fallback: "Capture a moment";
+    };
+    readonly filmCamera: {
+        readonly key: "com.labre.wardley.example.kodak-inertia.film-camera";
+        readonly fallback: "Film camera";
+    };
+    readonly digitalCamera: {
+        readonly key: "com.labre.wardley.example.kodak-inertia.digital-camera";
+        readonly fallback: "Digital camera";
+    };
+    readonly photographicFilm: {
+        readonly key: "com.labre.wardley.example.kodak-inertia.photographic-film";
+        readonly fallback: "Photographic film";
+    };
+    readonly digitalStorage: {
+        readonly key: "com.labre.wardley.example.kodak-inertia.digital-storage";
+        readonly fallback: "Digital storage";
+    };
+};
+/** The two worked maps' own tile names (`Template.nameKey`). */
+export declare const WARDLEY_TEMPLATE_NAME_TEA_SHOP: ChromeWording;
+export declare const WARDLEY_TEMPLATE_NAME_KODAK_INERTIA: ChromeWording;
 export declare const wardleyMaps: Template[];

package/dist/templates/maps.js

@@ -1,5 +1,6 @@
 import { makeTemplateSnapshot, surfaceText, surfaceYMap, } from '@formicoidea/labre-core/gfx/template';
 import { ConnectorMode, FontFamily, PointStyle, ShapeStyle, StrokeStyle, TextAlign, } from '@formicoidea/labre-core/model';
+import { translateKey, } from '@formicoidea/labre-core/shared/services';
 import { COLORS } from '../consts.js';
 import { INERTIA_COLOR, LINK_GREY, LINK_STROKE_WIDTH, NODE_FILL, NODE_SIZE, NODE_STROKE, WARDLEY_RED, } from '../node/consts.js';
 import { backgroundPlot, backgroundZoneBoundaries, } from '@formicoidea/labre-core/blocks/surface';
@@ -217,14 +218,119 @@ function title(str) {
 }
 const ATTRS = 'width="100%" height="100%" viewBox="0 0 135 80" xmlns="http://www.w3.org/2000/svg"';
 const mapPreview = (extra) => `<svg ${ATTRS} fill="none"><path d="M22 12 V64 H120" stroke="${COLORS.axis}" stroke-width="2"/>${extra}</svg>`;
-function tpl(name, preview, elements) {
+/**
+ * The seeds the two worked maps write — declared once so the builders below
+ * and the manifest (`../translations.ts`) read the very same fallback, never
+ * a restated literal. `com.labre.wardley.example.<map>.<slug>`, per
+ * `docs/adr/0023`.
+ */
+export const TEA_SHOP_SEED = {
+    title: {
+        key: 'com.labre.wardley.example.tea-shop.title',
+        fallback: 'Tea Shop',
+    },
+    annotations: {
+        key: 'com.labre.wardley.example.tea-shop.annotations',
+        fallback: 'Annotations:\n1. Standardising power lets kettles evolve faster\n2. Hot water is obvious and well known',
+    },
+    business: {
+        key: 'com.labre.wardley.example.tea-shop.business',
+        fallback: 'Business',
+    },
+    public: {
+        key: 'com.labre.wardley.example.tea-shop.public',
+        fallback: 'Public',
+    },
+    cupOfTea: {
+        key: 'com.labre.wardley.example.tea-shop.cup-of-tea',
+        fallback: 'Cup of Tea',
+    },
+    cup: { key: 'com.labre.wardley.example.tea-shop.cup', fallback: 'Cup' },
+    tea: { key: 'com.labre.wardley.example.tea-shop.tea', fallback: 'Tea' },
+    hotWater: {
+        key: 'com.labre.wardley.example.tea-shop.hot-water',
+        fallback: 'Hot Water',
+    },
+    water: { key: 'com.labre.wardley.example.tea-shop.water', fallback: 'Water' },
+    kettle: {
+        key: 'com.labre.wardley.example.tea-shop.kettle',
+        fallback: 'Kettle',
+    },
+    electricKettle: {
+        key: 'com.labre.wardley.example.tea-shop.electric-kettle',
+        fallback: 'Electric Kettle',
+    },
+    power: { key: 'com.labre.wardley.example.tea-shop.power', fallback: 'Power' },
+    limitedBy: {
+        key: 'com.labre.wardley.example.tea-shop.limited-by',
+        fallback: 'limited by',
+    },
+};
+export const KODAK_INERTIA_SEED = {
+    title: {
+        key: 'com.labre.wardley.example.kodak-inertia.title',
+        fallback: "Wardley map of Kodak's 2005 inertia to digital",
+    },
+    user: {
+        key: 'com.labre.wardley.example.kodak-inertia.user',
+        fallback: 'User',
+    },
+    captureAMoment: {
+        key: 'com.labre.wardley.example.kodak-inertia.capture-a-moment',
+        fallback: 'Capture a moment',
+    },
+    filmCamera: {
+        key: 'com.labre.wardley.example.kodak-inertia.film-camera',
+        fallback: 'Film camera',
+    },
+    digitalCamera: {
+        key: 'com.labre.wardley.example.kodak-inertia.digital-camera',
+        fallback: 'Digital camera',
+    },
+    photographicFilm: {
+        key: 'com.labre.wardley.example.kodak-inertia.photographic-film',
+        fallback: 'Photographic film',
+    },
+    digitalStorage: {
+        key: 'com.labre.wardley.example.kodak-inertia.digital-storage',
+        fallback: 'Digital storage',
+    },
+};
+/**
+ * One seed's resolved text — the host's catalogue when `std` is a real
+ * inserting editor, the English fallback when building the module's own
+ * `content` (no editor exists yet at that point).
+ */
+function seedText(std, def) {
+    return std ? translateKey(std, def.key, def.fallback) : def.fallback;
+}
+/**
+ * A shipped map — what is left once the artefacts are derived.
+ *
+ * `build` takes the OPTIONAL inserting editor: called with none, at module
+ * load, for the English `content`; called again with the real `std` as
+ * {@link Template.localize}, so the two builds read the very same layout and
+ * differ only in the words a seed resolves to (`docs/adr/0023`).
+ */
+function tpl(name, preview, build, nameKey) {
     return {
         name,
         type: 'template',
         preview,
-        content: makeTemplateSnapshot(elements, name),
+        nameKey,
+        content: makeTemplateSnapshot(build(), name),
+        localize: std => makeTemplateSnapshot(build(std), name),
     };
 }
+/** The two worked maps' own tile names (`Template.nameKey`). */
+export const WARDLEY_TEMPLATE_NAME_TEA_SHOP = [
+    'com.labre.wardley.template.tea-shop',
+    'Tea Shop',
+];
+export const WARDLEY_TEMPLATE_NAME_KODAK_INERTIA = [
+    'com.labre.wardley.template.kodak-inertia',
+    'Kodak inertia',
+];
 function ann(e, v) {
     const cx = ex(e);
     const cy = vy(v);
@@ -254,48 +360,56 @@ function annTxt(e, v, n) {
     };
 }
 // ── Tea Shop (the canonical map) ──────────────────────────────────────
-function teaShop() {
+function teaShop(std) {
+    const s = (def) => seedText(std, def);
     return {
         bg: bg(),
-        title: title('Tea Shop'),
+        title: title(s(TEA_SHOP_SEED.title)),
         annBox: panel(120, 200, 420, 64),
-        annText: freeText(132, 208, 400, 'Annotations:\n1. Standardising power lets kettles evolve faster\n2. Hot water is obvious and well known', 13),
+        annText: freeText(132, 208, 400, s(TEA_SHOP_SEED.annotations), 13),
         business: stake(0.62, 0.93),
-        businessL: lbl(0.62, 0.93, 'Business', {
+        businessL: lbl(0.62, 0.93, s(TEA_SHOP_SEED.business), {
             align: 'center',
             dy: -28,
             w: 120,
         }),
         businessG: pair('business', 'businessL'),
         public: stake(0.78, 0.93),
-        publicL: lbl(0.78, 0.93, 'Public', { align: 'center', dy: -28, w: 120 }),
+        publicL: lbl(0.78, 0.93, s(TEA_SHOP_SEED.public), {
+            align: 'center',
+            dy: -28,
+            w: 120,
+        }),
         publicG: pair('public', 'publicL'),
         cupOfTea: comp(0.62, 0.74),
-        cupOfTeaL: lbl(0.62, 0.74, 'Cup of Tea', { align: 'right' }),
+        cupOfTeaL: lbl(0.62, 0.74, s(TEA_SHOP_SEED.cupOfTea), { align: 'right' }),
         cupOfTeaG: pair('cupOfTea', 'cupOfTeaL'),
         cup: comp(0.8, 0.7),
-        cupL: lbl(0.8, 0.7, 'Cup'),
+        cupL: lbl(0.8, 0.7, s(TEA_SHOP_SEED.cup)),
         cupG: pair('cup', 'cupL'),
         tea: comp(0.83, 0.6),
-        teaL: lbl(0.83, 0.6, 'Tea'),
+        teaL: lbl(0.83, 0.6, s(TEA_SHOP_SEED.tea)),
         teaG: pair('tea', 'teaL'),
         hotWater: comp(0.8, 0.47),
-        hotWaterL: lbl(0.8, 0.47, 'Hot Water'),
+        hotWaterL: lbl(0.8, 0.47, s(TEA_SHOP_SEED.hotWater)),
         hotWaterG: pair('hotWater', 'hotWaterL'),
         water: comp(0.81, 0.34),
-        waterL: lbl(0.81, 0.34, 'Water'),
+        waterL: lbl(0.81, 0.34, s(TEA_SHOP_SEED.water)),
         waterG: pair('water', 'waterL'),
         kettle: comp(0.36, 0.38),
-        kettleL: lbl(0.36, 0.38, 'Kettle', { align: 'right', dy: 6 }),
+        kettleL: lbl(0.36, 0.38, s(TEA_SHOP_SEED.kettle), {
+            align: 'right',
+            dy: 6,
+        }),
         kettleG: pair('kettle', 'kettleL'),
         electric: future(0.56, 0.38),
-        electricL: lbl(0.56, 0.38, 'Electric Kettle'),
+        electricL: lbl(0.56, 0.38, s(TEA_SHOP_SEED.electricKettle)),
         electricG: pair('electric', 'electricL'),
         power: comp(0.7, 0.1),
-        powerL: lbl(0.7, 0.1, 'Power', { align: 'right', dy: 6 }),
+        powerL: lbl(0.7, 0.1, s(TEA_SHOP_SEED.power), { align: 'right', dy: 6 }),
         powerG: pair('power', 'powerL'),
         powerFut: future(0.88, 0.1),
-        powerFutL: lbl(0.88, 0.1, 'Power'),
+        powerFutL: lbl(0.88, 0.1, s(TEA_SHOP_SEED.power)),
         powerFutG: pair('powerFut', 'powerFutL'),
         // ABOVE the link it annotates, not across it. Written on the line it reads
         // as a label nobody can read — which is the finding W3 raises, and it was
@@ -303,7 +417,7 @@ function teaShop() {
         //
         // NEUTRAL: it is a remark about a LINK, not the name of an artefact, so it
         // travels with nothing and nothing measures it (see `LblOpts.neutral`).
-        limitedBy: lbl(0.56, 0.43, 'limited by', {
+        limitedBy: lbl(0.56, 0.43, s(TEA_SHOP_SEED.limitedBy), {
             align: 'center',
             w: 120,
             size: 13,
@@ -327,7 +441,8 @@ function teaShop() {
     };
 }
 // ── Kodak inertia (2005) ──────────────────────────────────────────────
-function kodak() {
+function kodak(std) {
+    const s = (def) => seedText(std, def);
     // The future dependency `capture → storage` is the movement Kodak resisted,
     // and the inertia bar belongs where that dependency crosses into commodity —
     // the boundary the capability refused to cross. It used to sit 105 units away
@@ -341,30 +456,36 @@ function kodak() {
     const [barE, barV] = crossing(CAPTURE, STORAGE, 2);
     return {
         bg: bg(),
-        title: title("Wardley map of Kodak's 2005 inertia to digital"),
+        title: title(s(KODAK_INERTIA_SEED.title)),
         user: stake(0.54, 0.92),
-        userL: lbl(0.54, 0.92, 'User'),
+        userL: lbl(0.54, 0.92, s(KODAK_INERTIA_SEED.user)),
         userG: pair('user', 'userL'),
         capture: dot(CAPTURE[0], CAPTURE[1], 3),
         // To the LEFT, like the other two capability names: to the right of this
         // node runs the future dependency towards digital storage, and a name
         // written across the line that carries the whole argument is exactly the
         // case W3 exists for.
-        captureL: lbl(CAPTURE[0], CAPTURE[1], 'Capture a moment', {
+        captureL: lbl(CAPTURE[0], CAPTURE[1], s(KODAK_INERTIA_SEED.captureAMoment), {
             align: 'right',
         }),
         captureG: pair('capture', 'captureL'),
         film: comp(0.52, 0.62),
-        filmL: lbl(0.52, 0.62, 'Film camera', { align: 'right' }),
+        filmL: lbl(0.52, 0.62, s(KODAK_INERTIA_SEED.filmCamera), {
+            align: 'right',
+        }),
         filmG: pair('film', 'filmL'),
         digital: future(0.74, 0.62),
-        digitalL: lbl(0.74, 0.62, 'Digital camera', { color: WARDLEY_RED }),
+        digitalL: lbl(0.74, 0.62, s(KODAK_INERTIA_SEED.digitalCamera), {
+            color: WARDLEY_RED,
+        }),
         digitalG: pair('digital', 'digitalL'),
         roll: comp(0.52, 0.4),
-        rollL: lbl(0.52, 0.4, 'Photographic film', { align: 'right' }),
+        rollL: lbl(0.52, 0.4, s(KODAK_INERTIA_SEED.photographicFilm), {
+            align: 'right',
+        }),
         rollG: pair('roll', 'rollL'),
         storage: future(STORAGE[0], STORAGE[1]),
-        storageL: lbl(STORAGE[0], STORAGE[1], 'Digital storage', {
+        storageL: lbl(STORAGE[0], STORAGE[1], s(KODAK_INERTIA_SEED.digitalStorage), {
             color: WARDLEY_RED,
         }),
         storageG: pair('storage', 'storageL'),
@@ -378,6 +499,6 @@ function kodak() {
     };
 }
 export const wardleyMaps = [
-    tpl('Tea Shop', mapPreview(`<circle cx="78" cy="24" r="3" fill="${NODE_FILL}" stroke="${NODE_STROKE}"/><circle cx="50" cy="44" r="3" fill="${NODE_FILL}" stroke="${NODE_STROKE}"/><circle cx="86" cy="40" r="3" fill="${NODE_FILL}" stroke="${NODE_STROKE}"/><circle cx="92" cy="58" r="3" fill="${NODE_FILL}" stroke="${NODE_STROKE}"/><path d="M78 24 L50 44 M78 24 L86 40 L92 58" stroke="${LINK_GREY}"/><path d="M50 44 h22" stroke="${WARDLEY_RED}" stroke-dasharray="3 2"/>`), teaShop()),
-    tpl('Kodak inertia', mapPreview(`<circle cx="56" cy="22" r="3" fill="${NODE_FILL}" stroke="${NODE_STROKE}"/><circle cx="54" cy="40" r="3" fill="${NODE_FILL}" stroke="${NODE_STROKE}"/><circle cx="86" cy="40" r="3" fill="${NODE_FILL}" stroke="${WARDLEY_RED}"/><rect x="76" y="35" width="2.5" height="11" fill="${INERTIA_COLOR}"/><path d="M57 40 h17" stroke="${WARDLEY_RED}" stroke-dasharray="3 2"/>`), kodak()),
+    tpl('Tea Shop', mapPreview(`<circle cx="78" cy="24" r="3" fill="${NODE_FILL}" stroke="${NODE_STROKE}"/><circle cx="50" cy="44" r="3" fill="${NODE_FILL}" stroke="${NODE_STROKE}"/><circle cx="86" cy="40" r="3" fill="${NODE_FILL}" stroke="${NODE_STROKE}"/><circle cx="92" cy="58" r="3" fill="${NODE_FILL}" stroke="${NODE_STROKE}"/><path d="M78 24 L50 44 M78 24 L86 40 L92 58" stroke="${LINK_GREY}"/><path d="M50 44 h22" stroke="${WARDLEY_RED}" stroke-dasharray="3 2"/>`), teaShop, WARDLEY_TEMPLATE_NAME_TEA_SHOP[0]),
+    tpl('Kodak inertia', mapPreview(`<circle cx="56" cy="22" r="3" fill="${NODE_FILL}" stroke="${NODE_STROKE}"/><circle cx="54" cy="40" r="3" fill="${NODE_FILL}" stroke="${NODE_STROKE}"/><circle cx="86" cy="40" r="3" fill="${NODE_FILL}" stroke="${WARDLEY_RED}"/><rect x="76" y="35" width="2.5" height="11" fill="${INERTIA_COLOR}"/><path d="M57 40 h17" stroke="${WARDLEY_RED}" stroke-dasharray="3 2"/>`), kodak, WARDLEY_TEMPLATE_NAME_KODAK_INERTIA[0]),
 ];

package/dist/toolbar/config.d.ts

@@ -1,5 +1,7 @@
-import { type ChromeWording, type ToolbarContext } from '@formicoidea/labre-core/shared/services';
+import { type ChromeWording, type ToolbarContext, type ToolbarModuleConfig } from '@formicoidea/labre-core/shared/services';
 import { type TemplateResult } from 'lit';
+/** Every wording above, for `translations.ts`'s manifest contribution. */
+export declare const WARDLEY_TOOLBAR_WORDINGS: readonly ChromeWording[];
 export declare const wardleyToolbarConfig: {
     readonly actions: [{
         id: string;
@@ -71,12 +73,37 @@ export declare const wardleyToolbarConfig: {
             active(ctx: ToolbarContext): boolean;
             run(ctx: ToolbarContext): void;
         }];
-    }, {
-        readonly id: "d.legend";
-        readonly tooltipWording: ChromeWording;
-        readonly icon: TemplateResult<2>;
-        readonly run: (ctx: ToolbarContext) => void;
-    }];
+    }, import("@formicoidea/labre-core/shared/services").ToolbarActionGenerator];
     readonly when: (ctx: ToolbarContext) => boolean;
 };
 export declare const wardleyToolbarExtension: import("@formicoidea/labre-core/store").ExtensionType;
+/**
+ * The map's flag-gated row, WHOLE: the Legend button and the Validation
+ * dropdown, in one module.
+ *
+ * ## Why they cannot be two modules
+ *
+ * `renderToolbar` merges exactly four slots per element — `<flavour>`,
+ * `custom:<flavour>` and the two `affine:surface:*` wildcards — and
+ * `ToolbarModuleExtension` binds by DI variant, so a second module claiming
+ * `custom:affine:surface:wardley` would throw
+ * `DuplicateServiceDefinitionError` before the editor finished setting up. Two
+ * slots, and Wardley has three things to put on a selected map: the axis and
+ * label toggles (always-on, `<flavour>`, above), the legend and the level of
+ * requirement. The precedent is C4's `c4BoardToolingToolbarConfig`.
+ *
+ * ## Why the legend moved OUT of the always-on half
+ *
+ * Because GENERATING one is tooling, and `docs/adr/0009` gates tooling: the
+ * flag off takes away the gesture that writes legend elements, exactly as it
+ * takes away the sub-menu that draws components. What the gesture already
+ * wrote is document CONTENT and keeps being painted — the box is plain shapes,
+ * text and `wardleyNode`s with no role, all drawn by the always-on renderers.
+ * The axis and label toggles stay always-on for the opposite reason: a stored
+ * map must keep its axes whatever the flag says.
+ *
+ * Sorting keeps the row readable across the merge — `a.` … `d.legend` from the
+ * two modules, then `z.validation` — whatever order they were registered in.
+ */
+export declare const wardleyBoardToolingToolbarConfig: ToolbarModuleConfig;
+export declare const wardleyBoardToolingToolbarExtension: import("@formicoidea/labre-core/store").ExtensionType;