@formicoidea/labre-framework-wardley 0.40.0 → 0.41.0

package/dist/morph.js

@@ -1,7 +1,8 @@
 import { morphLabel, } from '@formicoidea/labre-core/blocks/surface';
 import { ConnectorElementModel, GroupElementModel, TextElementModel, WardleyNodeElementModel, } from '@formicoidea/labre-core/model';
+import { translateKey } from '@formicoidea/labre-core/shared/services';
 import { wardleyCommandIcons, wardleyCommands } from './commands.js';
-import { wardleyCanonicalBox, wardleyHandleBox, wardleyHandleProps, wardleyMarketDotBoxes, wardleyMarketDotProps, wardleyMarketLinkPairs, wardleyMarketLinkProps, WARDLEY_NODE_LABEL, wardleyMorphClears, wardleyMorphProps, } from './presets.js';
+import { wardleyCanonicalBox, wardleyHandleBox, wardleyHandleProps, wardleyMarketDotBoxes, wardleyMarketDotProps, wardleyMarketLinkPairs, wardleyMarketLinkProps, WARDLEY_NODE_LABEL, wardleyMorphClears, wardleyMorphProps, wardleyNodeLabelKey, } from './presets.js';
 import { WARDLEY_ROLE } from './roles.js';
 /**
  * What a Wardley artefact may BECOME — the declaration behind the "Change type"
@@ -148,11 +149,26 @@ export function wardleyNodeOfComponent(model) {
  *
  * Pure and total over every string: the input is a canvas text element somebody
  * may have typed anything into.
+ *
+ * `std` is OPTIONAL: "untouched" means equal to the English prompt OR to the
+ * host's own resolved wording for `from`'s kind, and the target's prompt is
+ * likewise resolved through the host when one is given — mirroring
+ * `c4MorphedTypeLine`'s fix for the identical class of gap. With no `std`
+ * this behaves exactly as it always has (English only). The morph toolbar's
+ * `afterMorph` callback (`MorphSpec`, `packages/affine/blocks/surface`) now
+ * hands its callee the inserting editor's `std`, so `rewriteLabel` below
+ * passes it straight through.
  */
-export function wardleyMorphedLabel(from, to, rawText) {
-    return (rawText ?? '').trim() === WARDLEY_NODE_LABEL[from]
-        ? WARDLEY_NODE_LABEL[to]
-        : null;
+export function wardleyMorphedLabel(from, to, rawText, std) {
+    const text = (rawText ?? '').trim();
+    const fromPrompt = std
+        ? translateKey(std, wardleyNodeLabelKey(from), WARDLEY_NODE_LABEL[from])
+        : WARDLEY_NODE_LABEL[from];
+    if (text !== WARDLEY_NODE_LABEL[from] && text !== fromPrompt)
+        return null;
+    return std
+        ? translateKey(std, wardleyNodeLabelKey(to), WARDLEY_NODE_LABEL[to])
+        : WARDLEY_NODE_LABEL[to];
 }
 /** The centre of an element, from the box it currently occupies. */
 function centreOf(model) {
@@ -309,12 +325,12 @@ function removeHandle(group, carrier) {
  * inside the caller's `captureSync`, so the rewrite is part of the same single
  * ctrl+z as the kind that made it necessary.
  */
-function rewriteLabel(group, from, to) {
+function rewriteLabel(group, from, to, std) {
     const label = labelOfComposite(group);
     if (!label || label.isLocked())
         return;
     const text = label.text.toString().trim();
-    const next = wardleyMorphedLabel(from, to, text);
+    const next = wardleyMorphedLabel(from, to, text, std);
     if (next === null || next === text)
         return;
     label.surface.store.transact(() => {
@@ -349,7 +365,7 @@ function rewriteLabel(group, from, to) {
  * LEAVING comes apart before the one it is arriving at is built, so a
  * market → pipeline never has three dots and a handle at once.
  */
-export function wardleyMorphComposite(selected, from, to) {
+export function wardleyMorphComposite(selected, from, to, std) {
     if (!(selected instanceof GroupElementModel))
         return;
     const carrier = wardleyNodeOfComponent(selected);
@@ -367,7 +383,7 @@ export function wardleyMorphComposite(selected, from, to) {
         addMarketGlyph(selected, cx, cy);
     if (to === 'pipeline')
         addHandle(selected, carrier, cx, cy);
-    rewriteLabel(selected, from, to);
+    rewriteLabel(selected, from, to, std);
 }
 /**
  * Wardley's morph declaration, handed to the generic `morphToolbarConfig`.

package/dist/natures.js

@@ -86,11 +86,14 @@ export const WARDLEY_TAG_DEFS = {
     packId: 'wardley-core',
     framework: 'wardley',
     label: 'Wardley',
+    labelKey: 'com.labre.wardley.tag-pack.label',
     tags: [
         {
             id: WARDLEY_NATURE_TAG_ID,
             label: 'Nature',
+            labelKey: 'com.labre.wardley.tag.nature',
             description: 'What kind of thing this component is: an activity, data, a practice or knowledge.',
+            descriptionKey: 'com.labre.wardley.tag.nature.description',
             cardinality: 'single',
             appliesTo: [WARDLEY_ROLE.component],
             // No `order`, on either tag of this pack: an absent order sorts by SEED
@@ -103,29 +106,39 @@ export const WARDLEY_TAG_DEFS = {
                 {
                     id: WARDLEY_NATURE.activity,
                     label: 'Activity',
+                    labelKey: 'com.labre.wardley.tag.nature.activity',
                     description: 'Something that is DONE — a step, a service, a process.',
+                    descriptionKey: 'com.labre.wardley.tag.nature.activity.description',
                 },
                 {
                     id: WARDLEY_NATURE.data,
                     label: 'Data',
+                    labelKey: 'com.labre.wardley.tag.nature.data',
                     description: 'Something that is RECORDED — a dataset, a register.',
+                    descriptionKey: 'com.labre.wardley.tag.nature.data.description',
                 },
                 {
                     id: WARDLEY_NATURE.practice,
                     label: 'Practice',
+                    labelKey: 'com.labre.wardley.tag.nature.practice',
                     description: 'A way of doing — a method, a convention, an operating model.',
+                    descriptionKey: 'com.labre.wardley.tag.nature.practice.description',
                 },
                 {
                     id: WARDLEY_NATURE.knowledge,
                     label: 'Knowledge',
+                    labelKey: 'com.labre.wardley.tag.nature.knowledge',
                     description: 'Something that is KNOWN — a model, a theory, a rule.',
+                    descriptionKey: 'com.labre.wardley.tag.nature.knowledge.description',
                 },
             ],
         },
         {
             id: WARDLEY_COMPETITION_TAG_ID,
             label: 'Competition',
+            labelKey: 'com.labre.wardley.tag.competition',
             description: "Which of Porter's forces this glyph marks: relative competition, a struggle for survival, or a struggle to establish.",
+            descriptionKey: 'com.labre.wardley.tag.competition.description',
             cardinality: 'single',
             appliesTo: [WARDLEY_ROLE.porter],
             values: [
@@ -135,17 +148,23 @@ export const WARDLEY_TAG_DEFS = {
                     // shows: a reader picking a value here is choosing what the circle
                     // will say, not filling in a form about it.
                     label: 'Relative competition (R)',
+                    labelKey: 'com.labre.wardley.tag.competition.relative',
                     description: 'Established players competing against one another on a market that exists.',
+                    descriptionKey: 'com.labre.wardley.tag.competition.relative.description',
                 },
                 {
                     id: WARDLEY_COMPETITION.struggle,
                     label: 'Struggle for survival (L)',
+                    labelKey: 'com.labre.wardley.tag.competition.struggle',
                     description: 'Pressure on a player to stay in a market it is already in.',
+                    descriptionKey: 'com.labre.wardley.tag.competition.struggle.description',
                 },
                 {
                     id: WARDLEY_COMPETITION.establish,
                     label: 'Struggle to establish (E)',
+                    labelKey: 'com.labre.wardley.tag.competition.establish',
                     description: 'Pressure on a newcomer trying to get into a market.',
+                    descriptionKey: 'com.labre.wardley.tag.competition.establish.description',
                 },
             ],
         },

package/dist/presets.d.ts

@@ -72,6 +72,27 @@ export type WardleyLabelledKind = Exclude<WardleyArtefactKind, 'porter' | 'area'
  * still carries, and the only string a morph is ever allowed to rewrite.
  */
 export declare const WARDLEY_NODE_LABEL: Record<WardleyLabelledKind, string>;
+/**
+ * The i18n key {@link WARDLEY_NODE_LABEL} is the English default of —
+ * resolved at placement (`createWardleyNode` / `createWardleyPipeline` /
+ * `createWardleyMarket`), never afterwards. "Pipeline" is the PO's glossary
+ * term for Wardley: the French proposal IS the English word.
+ *
+ * ## The morph's placeholder detection, translated
+ *
+ * `wardleyMorphedLabel` (`morph.ts`) decides whether to refresh an artefact's
+ * name across a morph, and accepts an OPTIONAL `std`: given one, it
+ * recognises the stored text as "untouched" whether it reads the English
+ * prompt or the host's own resolved wording, and resolves the TARGET kind's
+ * prompt through the host too (the same fix `c4MorphedTypeLine` carries,
+ * `gfx/c4/src/type-line.ts`). `MorphSpec.afterMorph`
+ * (`packages/affine/blocks/surface`) now hands its callee the morph
+ * toolbar's own `std`, so `rewriteLabel` passes it straight through: on a
+ * host running a French catalogue, morphing an untouched TRANSLATED node
+ * rewrites its name to the target kind's own translated prompt, exactly as a
+ * standalone playground already rewrote the English one.
+ */
+export declare const wardleyNodeLabelKey: (kind: WardleyLabelledKind) => string;
 /** A box centred on a point — how every Wardley creation site places a node. */
 export declare function wardleyCenteredBox(cx: number, cy: number, w: number, h: number): string;
 /** The canonical box of one kind, centred where the artefact already stands. */

package/dist/presets.js

@@ -65,6 +65,27 @@ export const WARDLEY_NODE_LABEL = {
     accelerator: ACCELERATOR_LABEL,
     decelerator: DECELERATOR_LABEL,
 };
+/**
+ * The i18n key {@link WARDLEY_NODE_LABEL} is the English default of —
+ * resolved at placement (`createWardleyNode` / `createWardleyPipeline` /
+ * `createWardleyMarket`), never afterwards. "Pipeline" is the PO's glossary
+ * term for Wardley: the French proposal IS the English word.
+ *
+ * ## The morph's placeholder detection, translated
+ *
+ * `wardleyMorphedLabel` (`morph.ts`) decides whether to refresh an artefact's
+ * name across a morph, and accepts an OPTIONAL `std`: given one, it
+ * recognises the stored text as "untouched" whether it reads the English
+ * prompt or the host's own resolved wording, and resolves the TARGET kind's
+ * prompt through the host too (the same fix `c4MorphedTypeLine` carries,
+ * `gfx/c4/src/type-line.ts`). `MorphSpec.afterMorph`
+ * (`packages/affine/blocks/surface`) now hands its callee the morph
+ * toolbar's own `std`, so `rewriteLabel` passes it straight through: on a
+ * host running a French catalogue, morphing an untouched TRANSLATED node
+ * rewrites its name to the target kind's own translated prompt, exactly as a
+ * standalone playground already rewrote the English one.
+ */
+export const wardleyNodeLabelKey = (kind) => `com.labre.wardley.seed.${kind}`;
 /**
  * The fill a kind is born with. White for every circle that means "a thing on
  * the value chain"; the method's grey is the one that carries meaning — it

package/dist/templates/index.d.ts

@@ -1,2 +1,11 @@
 import { type TemplateCategory } from '@formicoidea/labre-core/gfx/template';
+import type { ChromeWording } from '@formicoidea/labre-core/shared/services';
+/**
+ * The two hand-drawn palette swatches' own tile names (`Template.nameKey`):
+ * neither derives from a command, since `linkTool` / `evolutionArrow`
+ * activate a tool rather than draw anything (see `tpl` below and its
+ * docstring).
+ */
+export declare const WARDLEY_TEMPLATE_NAME_LINK: ChromeWording;
+export declare const WARDLEY_TEMPLATE_NAME_EVOLUTION_ARROW: ChromeWording;
 export declare const wardleyTemplateCategory: TemplateCategory;

package/dist/templates/index.js

@@ -73,12 +73,27 @@ 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 two hand-drawn palette swatches' own tile names (`Template.nameKey`):
+ * neither derives from a command, since `linkTool` / `evolutionArrow`
+ * 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',
+];
 /** 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),
     };
 }
@@ -99,6 +114,8 @@ function areaTemplate(id, preview) {
 }
 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,10 +143,10 @@ 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 }),
-        }),
+        }, WARDLEY_TEMPLATE_NAME_EVOLUTION_ARROW[0]),
         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"/>')),
     ],

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/0016`.
+ */
+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/0016`.
+ */
+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/0016`).
+ */
+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 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;