@formicoidea/labre-framework-wardley 0.39.3 → 0.41.0

package/dist/legend.js

@@ -1,5 +1,7 @@
 import { createGroupCommand } from '@formicoidea/labre-core/gfx/group';
 import { ConnectorElementModel, ConnectorMode, FontFamily, PointStyle, ShapeElementModel, ShapeStyle, StrokeStyle, WardleyNodeElementModel, } from '@formicoidea/labre-core/model';
+import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
+import { translateKey, } from '@formicoidea/labre-core/shared/services';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
 import { GfxControllerIdentifier } from '@formicoidea/labre-core/std/gfx';
 import { GRADIENT_GREEN, GRADIENT_RED } from './gradient.js';
@@ -20,37 +22,82 @@ const LEGEND_ORDER = [
     'decelerator',
     'area',
 ];
-/** Default (editable) descriptions for each legend row. */
+/**
+ * Default (editable) descriptions for each legend row — a `ChromeWording` per
+ * row so the seed a legend writes into the document is resolved through the
+ * host at BUILD time, like every other text `createWardleyLegend` creates.
+ * The fallback is the literal that shipped before these keys existed.
+ */
 const LEGEND_DESC = {
-    component: 'Need / capability (activity, practice, data…)',
-    anchor: 'Stakeholder (customer, user…)',
-    market: 'Market (set of actors)',
-    ecosystem: 'Ecosystem',
-    method: 'Component + method (color = phase)',
-    pipeline: 'Pipeline (possible choices for a capability)',
-    link: 'Need relation (parent → child)',
-    arrow: 'Evolution / movement (red = future)',
-    inertia: 'Inertia to change',
-    porter: "Porter's forces (external competition: R relative, L survival, E establish)",
-    accelerator: 'Accelerator (speeds evolution up)',
-    decelerator: 'Decelerator (slows evolution down)',
-    area: 'Area (zone of the map)',
+    component: [
+        'com.labre.wardley.legend.desc.component',
+        'Need / capability (activity, practice, data…)',
+    ],
+    anchor: [
+        'com.labre.wardley.legend.desc.anchor',
+        'Stakeholder (customer, user…)',
+    ],
+    market: ['com.labre.wardley.legend.desc.market', 'Market (set of actors)'],
+    ecosystem: ['com.labre.wardley.legend.desc.ecosystem', 'Ecosystem'],
+    method: [
+        'com.labre.wardley.legend.desc.method',
+        'Component + method (color = phase)',
+    ],
+    pipeline: [
+        'com.labre.wardley.legend.desc.pipeline',
+        'Pipeline (possible choices for a capability)',
+    ],
+    link: [
+        'com.labre.wardley.legend.desc.link',
+        'Need relation (parent → child)',
+    ],
+    arrow: [
+        'com.labre.wardley.legend.desc.arrow',
+        'Evolution / movement (red = future)',
+    ],
+    inertia: ['com.labre.wardley.legend.desc.inertia', 'Inertia to change'],
+    porter: [
+        'com.labre.wardley.legend.desc.porter',
+        "Porter's forces (external competition: R relative, L survival, E establish)",
+    ],
+    accelerator: [
+        'com.labre.wardley.legend.desc.accelerator',
+        'Accelerator (speeds evolution up)',
+    ],
+    decelerator: [
+        'com.labre.wardley.legend.desc.decelerator',
+        'Decelerator (slows evolution down)',
+    ],
+    area: ['com.labre.wardley.legend.desc.area', 'Area (zone of the map)'],
 };
+/** Every {@link LEGEND_DESC} wording, for `translations.ts`'s manifest. */
+export const WARDLEY_LEGEND_DESC_WORDINGS = Object.values(LEGEND_DESC);
 /** Gradient-meaning block, keyed by variant (caption + 2-colour swatch). */
 const LEGEND_GRADIENT = {
     opportunity: {
-        caption: 'Opportunity gradient: differential value (green) vs operational value (red).',
+        caption: [
+            'com.labre.wardley.legend.gradient.opportunity',
+            'Opportunity gradient: differential value (green) vs operational value (red).',
+        ],
         swatch: [GRADIENT_GREEN, GRADIENT_RED],
     },
     benefit: {
-        caption: 'Gradient: investment (red) then benefit (green).',
+        caption: [
+            'com.labre.wardley.legend.gradient.benefit',
+            'Gradient: investment (red) then benefit (green).',
+        ],
         swatch: [GRADIENT_RED, GRADIENT_GREEN],
     },
     'evolution-gradient': {
-        caption: "Gradient representing the growth of Wardley's evolution function.",
-        swatch: ['#9aa0a6', '#cfd2d6'],
+        caption: [
+            'com.labre.wardley.legend.gradient.evolution',
+            "Gradient representing the growth of Wardley's evolution function.",
+        ],
+        swatch: [NOTATION_NEUTRALS.divider, NOTATION_NEUTRALS.legendBorder],
     },
 };
+/** Every {@link LEGEND_GRADIENT} caption, for `translations.ts`'s manifest. */
+export const WARDLEY_LEGEND_GRADIENT_WORDINGS = Object.values(LEGEND_GRADIENT).map(g => g.caption);
 /* ── Porter's five forces: the panel under the rows ───────────────────── */
 /** The panel's own numbers. Model units, like every other measure here. */
 const PORTER_PANEL = {
@@ -74,19 +121,50 @@ const PORTER_PANEL = {
     captionFs: 13,
     captionH: 21,
     backing: '#e5e7eb',
-    backingStroke: '#9aa0a6',
+    backingStroke: NOTATION_NEUTRALS.divider,
 };
 /** The four forces the boxes name, north first and then clockwise. */
 const PORTER_FORCES = [
-    'Threat of new entrants',
-    'Bargaining power of customers',
-    'Threat of substitutes',
-    'Bargaining power of suppliers',
+    [
+        'com.labre.wardley.legend.porter.force.new-entrants',
+        'Threat of new entrants',
+    ],
+    [
+        'com.labre.wardley.legend.porter.force.customers',
+        'Bargaining power of customers',
+    ],
+    [
+        'com.labre.wardley.legend.porter.force.substitutes',
+        'Threat of substitutes',
+    ],
+    [
+        'com.labre.wardley.legend.porter.force.suppliers',
+        'Bargaining power of suppliers',
+    ],
 ];
-/** What the panel's own glyph reads: the notation, not one force. */
+/** What the panel's own glyph reads: the notation, not one force — untouched, like the Cynefin A/C letters. */
 const PORTER_PANEL_LETTERS = 'R/L/E';
 /** What the letters mean, spelled out under the diagram. */
-const PORTER_CAPTION = 'R/L/E = Relative competition, or struggLe for survival, or struggle to Establish';
+const PORTER_CAPTION = [
+    'com.labre.wardley.legend.porter.caption',
+    'R/L/E = Relative competition, or struggLe for survival, or struggle to Establish',
+];
+/** The legend box's own title. */
+export const WARDLEY_LEGEND_TITLE = [
+    'com.labre.wardley.legend.title',
+    'Legend',
+];
+/** The five-forces panel's own title. */
+export const WARDLEY_LEGEND_PORTER_TITLE = [
+    'com.labre.wardley.legend.porter.title',
+    "Porter's five forces",
+];
+/** Every {@link PORTER_FORCES} wording, plus the caption, for the manifest. */
+export const WARDLEY_LEGEND_PORTER_WORDINGS = [
+    WARDLEY_LEGEND_PORTER_TITLE,
+    ...PORTER_FORCES,
+    PORTER_CAPTION,
+];
 /**
  * How far a porter glyph of the given radius reaches, arrow tips included.
  *
@@ -144,6 +222,18 @@ export function porterPanelLayout(w) {
         caption: [p.pad, captionY, inner, p.captionH],
     };
 }
+/**
+ * Every wording this file writes onto the canvas, for `translations.ts`'s
+ * manifest contribution — the auto-legend's own title, its rows' captions,
+ * the gradient blocks and the Porter panel, all as `seed` (written into the
+ * document once, at the moment a legend is generated).
+ */
+export const WARDLEY_LEGEND_WORDINGS = [
+    WARDLEY_LEGEND_TITLE,
+    ...WARDLEY_LEGEND_DESC_WORDINGS,
+    ...WARDLEY_LEGEND_GRADIENT_WORDINGS,
+    ...WARDLEY_LEGEND_PORTER_WORDINGS,
+];
 /**
  * Build a "Legend" group from real, editable elements (white rect frame +
  * "Legend" text + one row of [real component glyph + description text] per
@@ -482,8 +572,8 @@ export function createWardleyLegend(std, bg) {
         type: 'shape',
         shapeType: 'rect',
         filled: true,
-        fillColor: '#ffffff',
-        strokeColor: '#cfd2d6',
+        fillColor: NOTATION_NEUTRALS.cardFill,
+        strokeColor: NOTATION_NEUTRALS.legendBorder,
         strokeWidth: 1,
         shapeStyle: ShapeStyle.General,
         roughness: 0,
@@ -491,13 +581,13 @@ export function createWardleyLegend(std, bg) {
         xywh: new Bound(x0, y0, W, H).serialize(),
     }));
     // Title.
-    ids.push(text('Legend', x0 + PAD, y0 + PAD, W - PAD * 2, TITLE_FS + 6, TITLE_FS));
+    ids.push(text(translateKey(std, ...WARDLEY_LEGEND_TITLE), x0 + PAD, y0 + PAD, W - PAD * 2, TITLE_FS + 6, TITLE_FS));
     // Rows.
     let ry = y0 + PAD + TITLE_H;
     for (const t of rows) {
         const cyRow = ry + ROW_H / 2;
         ids.push(...glyph(t, x0 + PAD + GLYPH_W / 2, cyRow));
-        ids.push(text(LEGEND_DESC[t], x0 + PAD + GLYPH_W + GAP, cyRow - (TEXT_FS + 8) / 2, TEXT_W, TEXT_FS + 8, TEXT_FS));
+        ids.push(text(translateKey(std, ...LEGEND_DESC[t]), x0 + PAD + GLYPH_W + GAP, cyRow - (TEXT_FS + 8) / 2, TEXT_W, TEXT_FS + 8, TEXT_FS));
         ry += ROW_H;
     }
     // Gradient meaning block: a separator, then [2-colour swatch | caption].
@@ -507,8 +597,8 @@ export function createWardleyLegend(std, bg) {
             type: 'shape',
             shapeType: 'rect',
             filled: true,
-            fillColor: '#cfd2d6',
-            strokeColor: '#cfd2d6',
+            fillColor: NOTATION_NEUTRALS.legendBorder,
+            strokeColor: NOTATION_NEUTRALS.legendBorder,
             strokeWidth: 0,
             shapeStyle: ShapeStyle.General,
             roughness: 0,
@@ -525,7 +615,7 @@ export function createWardleyLegend(std, bg) {
                 shapeType: 'rect',
                 filled: true,
                 fillColor: col,
-                strokeColor: '#cfd2d6',
+                strokeColor: NOTATION_NEUTRALS.legendBorder,
                 strokeWidth: 0.5,
                 shapeStyle: ShapeStyle.General,
                 roughness: 0,
@@ -533,7 +623,7 @@ export function createWardleyLegend(std, bg) {
                 xywh: new Bound(sx + i * (sw + sgap), cyRow - sw / 2, sw, sw).serialize(),
             }));
         });
-        ids.push(text(grad.caption, x0 + PAD + GLYPH_W + GAP, cyRow - GRAD_ROW_H / 2, TEXT_W, GRAD_ROW_H, TEXT_FS));
+        ids.push(text(translateKey(std, ...grad.caption), x0 + PAD + GLYPH_W + GAP, cyRow - GRAD_ROW_H / 2, TEXT_W, GRAD_ROW_H, TEXT_FS));
     }
     // Porter's five forces: the panel the PO's reference draws, under everything
     // else. It is not a row — a row says what a glyph IS, and this says what the
@@ -559,7 +649,7 @@ export function createWardleyLegend(std, bg) {
             xywh: new Bound(px, py, panel.w, panel.h).serialize(),
         }));
         const [tx, ty, tw, th] = panel.title;
-        ids.push(text("Porter's five forces", px + tx, py + ty, tw, th, p.titleFs));
+        ids.push(text(translateKey(std, ...WARDLEY_LEGEND_PORTER_TITLE), px + tx, py + ty, tw, th, p.titleFs));
         const [cx, cy] = panel.center;
         ids.push(surface.addElement({
             type: 'wardleyNode',
@@ -592,7 +682,7 @@ export function createWardleyLegend(std, bg) {
                 type: 'shape',
                 shapeType: 'rect',
                 filled: true,
-                fillColor: '#ffffff',
+                fillColor: NODE_FILL,
                 strokeColor: NODE_STROKE,
                 strokeWidth: 1,
                 shapeStyle: ShapeStyle.General,
@@ -600,10 +690,10 @@ export function createWardleyLegend(std, bg) {
                 radius: 0,
                 xywh: new Bound(px + bx, py + by, bw, bh).serialize(),
             }));
-            ids.push(text(box.label, px + bx + 4, py + by + 3, bw - 8, bh - 6, p.boxFs, 'center'));
+            ids.push(text(translateKey(std, ...box.label), px + bx + 4, py + by + 3, bw - 8, bh - 6, p.boxFs, 'center'));
         }
         const [capX, capY, capW, capH] = panel.caption;
-        ids.push(text(PORTER_CAPTION, px + capX, py + capY, capW, capH, p.captionFs, 'center'));
+        ids.push(text(translateKey(std, ...PORTER_CAPTION), px + capX, py + capY, capW, capH, p.captionFs, 'center'));
     }
     // 4. Group everything and select it.
     const [, result] = std.command.exec(createGroupCommand, { elements: ids });

package/dist/morph.d.ts

@@ -1,5 +1,6 @@
 import { type MorphSpec } from '@formicoidea/labre-core/blocks/surface';
 import { WardleyNodeElementModel } from '@formicoidea/labre-core/model';
+import type { BlockStdScope } from '@formicoidea/labre-core/std';
 import type { GfxPrimitiveElementModel } from '@formicoidea/labre-core/std/gfx';
 /**
  * What a Wardley artefact may BECOME — the declaration behind the "Change type"
@@ -81,8 +82,17 @@ export declare function wardleyNodeOfComponent(model: GfxPrimitiveElementModel):
  *
  * 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 declare function wardleyMorphedLabel(from: WardleyMorphKind, to: WardleyMorphKind, rawText: string | null | undefined): string | null;
+export declare function wardleyMorphedLabel(from: WardleyMorphKind, to: WardleyMorphKind, rawText: string | null | undefined, std?: BlockStdScope): string | null;
 /**
  * Everything the morph owes a Wardley composite beyond the props patch — the
  * `afterMorph` half of the spec, run inside the generic module's one
@@ -110,7 +120,7 @@ export declare function wardleyMorphedLabel(from: WardleyMorphKind, to: WardleyM
  * 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 declare function wardleyMorphComposite(selected: GfxPrimitiveElementModel, from: WardleyMorphKind, to: WardleyMorphKind): void;
+export declare function wardleyMorphComposite(selected: GfxPrimitiveElementModel, from: WardleyMorphKind, to: WardleyMorphKind, std?: BlockStdScope): void;
 /**
  * Wardley's morph declaration, handed to the generic `morphToolbarConfig`.
  *

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

@@ -9,8 +9,9 @@
  */
 /** Default node diameter (= the map label font size, 18). White fill, thin border. */
 export declare const NODE_SIZE = 18;
-export declare const NODE_FILL = "#ffffff";
-export declare const NODE_STROKE = "#1f2328";
+/** The shared notation scale's card fill and ink — Wardley is its reference. */
+export declare const NODE_FILL: string;
+export declare const NODE_STROKE: string;
 /** Thin border, matching the link / silhouette line weight. */
 export declare const NODE_STROKE_WIDTH = 1;
 /**
@@ -53,11 +54,33 @@ export declare const PIPELINE_LABEL = "Pipeline";
  * to the 1px node border.
  */
 export declare const LINK_STROKE_WIDTH = 2;
-/** Wardley red ("future"/evolution) — matches the validated arrow icon. */
+/**
+ * Wardley red ("future"/evolution) — matches the validated arrow icon.
+ *
+ * An IDENTITY colour: the legend recognises a stored evolution link by it
+ * (`legend.ts`, `el.stroke === WARDLEY_RED`). It stays a literal and must never
+ * be derived from `NOTATION_NEUTRALS` or any other scale — a change of value
+ * would orphan every link already drawn with it.
+ */
 export declare const WARDLEY_RED = "#d6455d";
-/** Dependency link grey. */
+/**
+ * Dependency link grey.
+ *
+ * An IDENTITY colour: the legend recognises a stored dependency link by it
+ * (`legend.ts`, `el.stroke === LINK_GREY`). It stays a literal and must never
+ * be derived from `NOTATION_NEUTRALS` — a change of value would orphan every
+ * link already drawn with it.
+ */
 export declare const LINK_GREY = "#666666";
-/** Inertia bar color + size. */
+/**
+ * Inertia bar color + size.
+ *
+ * An IDENTITY colour: the legend recognises a stored inertia bar by it
+ * (`legend.ts`, `el.fillColor === INERTIA_COLOR`). It happens to equal the
+ * scale's ink today, but it stays a literal and must never be derived from
+ * `NOTATION_NEUTRALS`: a change of the shared ink would orphan every inertia bar
+ * already on a map.
+ */
 export declare const INERTIA_COLOR = "#1f2328";
 export declare const INERTIA_SIZE: {
     w: number;
@@ -75,7 +98,7 @@ export declare const MARKET_DOT_RING = 8;
 export declare const MARKET_DOT_STROKE_WIDTH = 2;
 /** Triangle connectors: thin + dark, no arrows. */
 export declare const MARKET_LINK_WIDTH = 1;
-export declare const MARKET_LINK_COLOR = "#1f2328";
+export declare const MARKET_LINK_COLOR: string;
 export declare const MARKET_LABEL = "Market";
 /**
  * Ecosystem node: a single connectable circle drawn as a GLYPH — a double border

package/dist/node/consts.js

@@ -1,3 +1,4 @@
+import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
 /**
  * Visual constants for Wardley nodes (component + anchor) and the connector /
  * inertia presets created from the Wardley menu.
@@ -9,8 +10,9 @@
  */
 /** Default node diameter (= the map label font size, 18). White fill, thin border. */
 export const NODE_SIZE = 18;
-export const NODE_FILL = '#ffffff';
-export const NODE_STROKE = '#1f2328';
+/** The shared notation scale's card fill and ink — Wardley is its reference. */
+export const NODE_FILL = NOTATION_NEUTRALS.cardFill;
+export const NODE_STROKE = NOTATION_NEUTRALS.ink;
 /** Thin border, matching the link / silhouette line weight. */
 export const NODE_STROKE_WIDTH = 1;
 /**
@@ -50,11 +52,33 @@ export const PIPELINE_LABEL = 'Pipeline';
  * to the 1px node border.
  */
 export const LINK_STROKE_WIDTH = 2;
-/** Wardley red ("future"/evolution) — matches the validated arrow icon. */
+/**
+ * Wardley red ("future"/evolution) — matches the validated arrow icon.
+ *
+ * An IDENTITY colour: the legend recognises a stored evolution link by it
+ * (`legend.ts`, `el.stroke === WARDLEY_RED`). It stays a literal and must never
+ * be derived from `NOTATION_NEUTRALS` or any other scale — a change of value
+ * would orphan every link already drawn with it.
+ */
 export const WARDLEY_RED = '#d6455d';
-/** Dependency link grey. */
+/**
+ * Dependency link grey.
+ *
+ * An IDENTITY colour: the legend recognises a stored dependency link by it
+ * (`legend.ts`, `el.stroke === LINK_GREY`). It stays a literal and must never
+ * be derived from `NOTATION_NEUTRALS` — a change of value would orphan every
+ * link already drawn with it.
+ */
 export const LINK_GREY = '#666666';
-/** Inertia bar color + size. */
+/**
+ * Inertia bar color + size.
+ *
+ * An IDENTITY colour: the legend recognises a stored inertia bar by it
+ * (`legend.ts`, `el.fillColor === INERTIA_COLOR`). It happens to equal the
+ * scale's ink today, but it stays a literal and must never be derived from
+ * `NOTATION_NEUTRALS`: a change of the shared ink would orphan every inertia bar
+ * already on a map.
+ */
 export const INERTIA_COLOR = '#1f2328';
 export const INERTIA_SIZE = { w: 8, h: 44 };
 /**

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;