@formicoidea/labre-framework-wardley 0.40.0 → 0.41.0

package/dist/actions.d.ts

@@ -4,6 +4,35 @@ 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 WardleyAreaShape, type WardleyArtefactKind } from './presets.js';
+/**
+ * Standalone creation/activation actions for the Wardley toolbox — the
+ * BEHAVIOUR layer, shared by every surface. They only depend on the
+ * {@link GfxController}.
+ *
+ * They no longer emit telemetry: since PF3 the single emission point is the
+ * command registry's `runCommand` (`docs/adr/0008`), which is the only function
+ * every surface goes through. `WardleyActionSource` is gone with it — the
+ * segment/module discrimination it carried is now `CommandInvocation.surface`.
+ */
+/**
+ * The three axis words a translated variant's background is seeded with —
+ * declared once, so the resolver below and the manifest
+ * (`../translations.ts`) read the very same fallback.
+ */
+export declare const WARDLEY_AXIS_SEED: {
+    readonly opportunity: {
+        readonly key: "com.labre.wardley.seed.axis-opportunity";
+        readonly fallback: "Opportunity";
+    };
+    readonly benefit: {
+        readonly key: "com.labre.wardley.seed.axis-benefit";
+        readonly fallback: "Benefit";
+    };
+    readonly investment: {
+        readonly key: "com.labre.wardley.seed.axis-investment";
+        readonly fallback: "Investment";
+    };
+};
 /**
  * The single-circle node flavours: one connectable ellipse + a label to its
  * right, grouped. The glyph itself (anchor silhouette, ecosystem hatching,

package/dist/actions.js

@@ -11,7 +11,7 @@ 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_SIZE, LABEL_GAP, LINK_GREY, LINK_STROKE_WIDTH, PORTER_DEFAULT_LETTER, WARDLEY_RED, } from './node/consts.js';
-import { wardleyAreaBox, wardleyAreaProps, wardleyCanonicalBox, wardleyHandleBox, wardleyHandleProps, wardleyInertiaProps, WARDLEY_LABEL_H, WARDLEY_LABEL_W, wardleyLabelProps, wardleyMarketDotBoxes, wardleyMarketDotProps, wardleyMarketLinkPairs, wardleyMarketLinkProps, WARDLEY_NODE_LABEL, WARDLEY_NODE_SIZE, wardleyNodeProps, wardleyPorterArrowProps, wardleyPorterArrows, wardleyPorterLetterProps, } from './presets.js';
+import { wardleyAreaBox, wardleyAreaProps, wardleyCanonicalBox, wardleyHandleBox, wardleyHandleProps, wardleyInertiaProps, WARDLEY_LABEL_H, WARDLEY_LABEL_W, wardleyLabelProps, wardleyMarketDotBoxes, wardleyMarketDotProps, wardleyMarketLinkPairs, wardleyMarketLinkProps, WARDLEY_NODE_LABEL, wardleyNodeLabelKey, 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
@@ -24,44 +24,62 @@ import { WARDLEY_ROLE } from './roles.js';
  * segment/module discrimination it carried is now `CommandInvocation.surface`.
  */
 /**
- * Per-variant default label overrides applied at creation (all remain editable
- * afterwards via the inline editor / toggles). The gradient itself is driven by
- * `variant` in the renderer.
- *
- * TODO(PF2 follow-up): these write ENGLISH PROSE into the document. Since PF2
- * the ten label props default to `undefined` precisely so the declaration's
- * i18n keys are reachable — but a map created as `opportunity` or `benefit`
- * lands with "Opportunity" / "Benefit" / "Investment" already persisted as if
- * the user had typed them, so those three are un-localisable for the life of
- * the document. Only `classic` and `evolution-gradient` are fully localisable
- * today.
- *
- * The fix is to make the variant part of the declaration — one axis/end-label
- * set per variant, each naming its own `labelKey` — rather than a bag of prop
- * overrides applied at creation. Out of scope here (it changes what a variant
- * IS). This is now the ONLY copy: the four background templates are derived
- * from these four commands, so the table goes away in one place.
+ * The three axis words a translated variant's background is seeded with —
+ * declared once, so the resolver below and the manifest
+ * (`../translations.ts`) read the very same fallback.
  */
-const BACKGROUND_VARIANT_DEFAULTS = {
-    classic: {},
-    // The Y axis becomes "Opportunity"; phase labels keep the classic defaults.
+export const WARDLEY_AXIS_SEED = {
     opportunity: {
-        yAxisTitle: 'Opportunity',
-        showVisibilityLabels: false,
-        showCornerLabels: false,
+        key: 'com.labre.wardley.seed.axis-opportunity',
+        fallback: 'Opportunity',
     },
-    // The Y axis splits into Benefit (top) / Investment (bottom) around a zero
-    // line drawn by the renderer.
     benefit: {
-        yAxisTitle: '',
-        visibilityHigh: 'Benefit',
-        visibilityLow: 'Investment',
-        showCornerLabels: false,
+        key: 'com.labre.wardley.seed.axis-benefit',
+        fallback: 'Benefit',
+    },
+    investment: {
+        key: 'com.labre.wardley.seed.axis-investment',
+        fallback: 'Investment',
     },
-    // Keeps the classic labels (Value Chain / Uncharted / Industrialized…); only
-    // the grey gradient differs.
-    'evolution-gradient': {},
 };
+/**
+ * Per-variant default label overrides applied at creation (all remain editable
+ * afterwards via the inline editor / toggles). The gradient itself is driven by
+ * `variant` in the renderer.
+ *
+ * Resolved through the translation seam since the i18n pass (#278): the ten
+ * label props still default to `undefined` on the declaration itself, but
+ * `opportunity` and `benefit` are the two variants whose Y axis is PROSE the
+ * gesture bakes into the document at creation — `WARDLEY_AXIS_SEED` above is
+ * what a host's catalogue is offered for the three words, resolved HERE, once,
+ * exactly like every other seed in this file. `classic` and
+ * `evolution-gradient` keep the classic labels (Value Chain / Uncharted /
+ * Industrialized…), which are declaration `labelKey`s and were already fully
+ * localisable — this function names no override for them.
+ */
+function backgroundVariantDefaults(gfx) {
+    const axis = (def) => translateKey(gfx.std, def.key, def.fallback);
+    return {
+        classic: {},
+        // The Y axis becomes "Opportunity"; phase labels keep the classic defaults.
+        opportunity: {
+            yAxisTitle: axis(WARDLEY_AXIS_SEED.opportunity),
+            showVisibilityLabels: false,
+            showCornerLabels: false,
+        },
+        // The Y axis splits into Benefit (top) / Investment (bottom) around a zero
+        // line drawn by the renderer.
+        benefit: {
+            yAxisTitle: '',
+            visibilityHigh: axis(WARDLEY_AXIS_SEED.benefit),
+            visibilityLow: axis(WARDLEY_AXIS_SEED.investment),
+            showCornerLabels: false,
+        },
+        // Keeps the classic labels (Value Chain / Uncharted / Industrialized…); only
+        // the grey gradient differs.
+        'evolution-gradient': {},
+    };
+}
 // The label box, now owned by `presets.ts` — the local names stay so the four
 // placements below keep reading as they did.
 const LABEL_H = WARDLEY_LABEL_H;
@@ -128,7 +146,7 @@ export function createWardleyBackground(gfx, variant = 'classic') {
         // declaration decides, and the toolbar toggle takes over from there.
         resizeEnabled: WARDLEY_BACKGROUND.geometry.resizable,
         variant,
-        ...BACKGROUND_VARIANT_DEFAULTS[variant],
+        ...backgroundVariantDefaults(gfx)[variant],
         xywh: new Bound(centerX - width / 2, centerY - height / 2, width, height).serialize(),
     });
     finish(gfx, id);
@@ -145,7 +163,12 @@ export function createWardleyNode(gfx, kind) {
     const { w } = WARDLEY_NODE_SIZE[kind];
     const { centerX: cx, centerY: cy } = gfx.viewport;
     const nodeId = addNode(surface, kind, cx, cy);
-    const labelId = addLabel(surface, WARDLEY_NODE_LABEL[kind], cx + w / 2 + LABEL_GAP, cy - LABEL_H / 2);
+    const labelId = addLabel(surface, 
+    // Resolved HERE, once — the prompt a node nobody has named still carries,
+    // exactly like a BPMN node's caption. `gfx.std` is how this file reaches
+    // the translation seam: these creation sites take `GfxController`, not
+    // `BlockStdScope`, directly (`WardleyView` reads the same member).
+    translateKey(gfx.std, wardleyNodeLabelKey(kind), WARDLEY_NODE_LABEL[kind]), cx + w / 2 + LABEL_GAP, cy - LABEL_H / 2);
     finish(gfx, group(gfx, [nodeId, labelId]));
 }
 /** Create an inertia bar (filled black rect). */
@@ -178,7 +201,7 @@ export function createWardleyPipeline(gfx) {
     // `centerAnchorOnly` so connectors attach to its center only.
     const handleId = gfx.surface.addElement(wardleyHandleProps({ xywh: wardleyHandleBox(cx, cy) }));
     // Label centered horizontally on the pipeline, sitting ABOVE the handle.
-    const labelId = addLabel(gfx.surface, WARDLEY_NODE_LABEL.pipeline, cx - 60, top - d / 2 - LABEL_H - LABEL_GAP, 'center');
+    const labelId = addLabel(gfx.surface, translateKey(gfx.std, wardleyNodeLabelKey('pipeline'), WARDLEY_NODE_LABEL.pipeline), cx - 60, top - d / 2 - LABEL_H - LABEL_GAP, 'center');
     // Nested groups: (handle + label), then (body + that group).
     const innerId = group(gfx, [handleId, labelId]);
     finish(gfx, group(gfx, [bodyId, innerId]));
@@ -202,7 +225,7 @@ export function createWardleyMarket(gfx) {
     const dotIds = wardleyMarketDotBoxes(cx, cy).map(xywh => surface.addElement(wardleyMarketDotProps({ xywh })));
     // Triangle: 3 attached connectors (auto-route center-to-center, clipped).
     const connIds = wardleyMarketLinkPairs(dotIds).map(([a, b]) => surface.addElement(wardleyMarketLinkProps(a, b)));
-    const labelId = addLabel(surface, WARDLEY_NODE_LABEL.market, cx + R + LABEL_GAP, cy - LABEL_H / 2);
+    const labelId = addLabel(surface, translateKey(gfx.std, wardleyNodeLabelKey('market'), WARDLEY_NODE_LABEL.market), cx + R + LABEL_GAP, cy - LABEL_H / 2);
     finish(gfx, group(gfx, [circleId, ...dotIds, ...connIds, labelId]));
 }
 /**
@@ -263,7 +286,7 @@ export function createWardleyAccelerator(gfx, 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], 
+    const labelId = addLabel(surface, translateKey(gfx.std, wardleyNodeLabelKey(kind), 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);

package/dist/import.d.ts

@@ -1,5 +1,33 @@
 import type { InterchangeImportContext, InterchangeImportResult } from '@formicoidea/labre-core/blocks/surface';
 import { OWM_SCOPE, WARDLEY_OWM_FORMAT_ID } from './export.js';
+/**
+ * The OWM import remarks whose wording is FIXED, as `[key, English]` pairs.
+ *
+ * A reader is a pure function of text (mirroring `.bpmn`'s own, ADR 0012 P3)
+ * and has no `std`, so it cannot ask the host's catalogue for anything: it
+ * declares the key on the note and `reportInterchangeImport` resolves it when
+ * it draws the report (`InterchangeNote.messageKey`). The English string
+ * stays here and stays the fallback.
+ *
+ * Every remark's fallback is the whole sentence a call site builds — a
+ * `{{name}}` / `{{count}}` hole is filled by `messageParams`
+ * (`InterchangeNote.messageParams`) at the call site, never by minting a new
+ * key for every value the file happens to carry. Plural wording stays
+ * grammatically neutral in the fallback (`'{{count}} line(s)…'`) — the
+ * host's job, the same rule BPMN's own remarks follow
+ * (`gfx/bpmn/src/import.ts`).
+ *
+ * Contributed to the manifest by `./translations.ts`.
+ */
+export declare const WARDLEY_OWM_IMPORT_REMARKS: {
+    readonly unreadableCoordinatesInvented: readonly ["com.labre.wardley.import.remark.unreadable-coordinates", "its coordinates were unreadable, so it was placed where a map with no coordinates places things. The file did not say where it goes."];
+    readonly noCoordinatesInvented: readonly ["com.labre.wardley.import.remark.no-coordinates", "the file gives it no coordinates, so it was placed where a map with no coordinates places things. The file did not say where it goes."];
+    readonly duplicateName: readonly ["com.labre.wardley.import.remark.duplicate-name", "this name is declared more than once. Both artefacts are on the map, and every link naming it means the first — OWM identifies a component by its name."];
+    readonly linkEmptyEnd: readonly ["com.labre.wardley.import.remark.link-empty-end", "a link names nothing on one of its ends, so the arrow it asks for runs to no artefact and is invisible on the canvas."];
+    readonly linkUndeclaredEnd: readonly ["com.labre.wardley.import.remark.link-undeclared-end", "a link names this, and no statement in the file declares it. The arrow is in the document and runs to no artefact, so it is invisible on the canvas."];
+    readonly unreadableCoordinatesLine: readonly ["com.labre.wardley.import.remark.unreadable-coordinates-line", "line {{line}} declares coordinates this reader cannot make a number of, so they were not used."];
+    readonly carriedConstruct: readonly ["com.labre.wardley.import.remark.carried-construct", "{{count}} `{{kind}}` line(s) kept verbatim on the map and written back on the next export. Nothing on this canvas draws them."];
+};
 /**
  * An OnlineWardleyMaps (OWM) DSL document, read as a Wardley map — the inverse
  * of `export.ts` on the vocabulary Labre draws, and an honest accounting of

package/dist/import.js

@@ -4,6 +4,55 @@ import { OWM_DEFAULT_MAP_HEIGHT, OWM_DEFAULT_MAP_WIDTH, OWM_LABEL_HEIGHT, OWM_LA
 import { HANDLE_SIZE, LABEL_GAP, LABEL_FONT_SIZE, LINK_GREY, LINK_STROKE_WIDTH, MARKET_DOT_RING, MARKET_DOT_SIZE, MARKET_DOT_STROKE_WIDTH, MARKET_LINK_COLOR, MARKET_LINK_WIDTH, MARKET_SIZE, ECOSYSTEM_SIZE, NODE_FILL, NODE_SIZE, NODE_STROKE, NODE_STROKE_WIDTH, PIPELINE_FILL, PIPELINE_HEIGHT, WARDLEY_RED, } from './node/consts.js';
 import { WARDLEY_NODE_SIZE, wardleyNodeProps } from './presets.js';
 import { WARDLEY_ROLE } from './roles.js';
+/**
+ * The OWM import remarks whose wording is FIXED, as `[key, English]` pairs.
+ *
+ * A reader is a pure function of text (mirroring `.bpmn`'s own, ADR 0012 P3)
+ * and has no `std`, so it cannot ask the host's catalogue for anything: it
+ * declares the key on the note and `reportInterchangeImport` resolves it when
+ * it draws the report (`InterchangeNote.messageKey`). The English string
+ * stays here and stays the fallback.
+ *
+ * Every remark's fallback is the whole sentence a call site builds — a
+ * `{{name}}` / `{{count}}` hole is filled by `messageParams`
+ * (`InterchangeNote.messageParams`) at the call site, never by minting a new
+ * key for every value the file happens to carry. Plural wording stays
+ * grammatically neutral in the fallback (`'{{count}} line(s)…'`) — the
+ * host's job, the same rule BPMN's own remarks follow
+ * (`gfx/bpmn/src/import.ts`).
+ *
+ * Contributed to the manifest by `./translations.ts`.
+ */
+export const WARDLEY_OWM_IMPORT_REMARKS = {
+    unreadableCoordinatesInvented: [
+        'com.labre.wardley.import.remark.unreadable-coordinates',
+        'its coordinates were unreadable, so it was placed where a map with no coordinates places things. The file did not say where it goes.',
+    ],
+    noCoordinatesInvented: [
+        'com.labre.wardley.import.remark.no-coordinates',
+        'the file gives it no coordinates, so it was placed where a map with no coordinates places things. The file did not say where it goes.',
+    ],
+    duplicateName: [
+        'com.labre.wardley.import.remark.duplicate-name',
+        'this name is declared more than once. Both artefacts are on the map, and every link naming it means the first — OWM identifies a component by its name.',
+    ],
+    linkEmptyEnd: [
+        'com.labre.wardley.import.remark.link-empty-end',
+        'a link names nothing on one of its ends, so the arrow it asks for runs to no artefact and is invisible on the canvas.',
+    ],
+    linkUndeclaredEnd: [
+        'com.labre.wardley.import.remark.link-undeclared-end',
+        'a link names this, and no statement in the file declares it. The arrow is in the document and runs to no artefact, so it is invisible on the canvas.',
+    ],
+    unreadableCoordinatesLine: [
+        'com.labre.wardley.import.remark.unreadable-coordinates-line',
+        'line {{line}} declares coordinates this reader cannot make a number of, so they were not used.',
+    ],
+    carriedConstruct: [
+        'com.labre.wardley.import.remark.carried-construct',
+        '{{count}} `{{kind}}` line(s) kept verbatim on the map and written back on the next export. Nothing on this canvas draws them.',
+    ],
+};
 /**
  * An OnlineWardleyMaps (OWM) DSL document, read as a Wardley map — the inverse
  * of `export.ts` on the vocabulary Labre draws, and an honest accounting of
@@ -261,12 +310,13 @@ export function importWardleyOwm(source, context = {}) {
         carriedLines.push(line);
         carriedKinds.set(kind, (carriedKinds.get(kind) ?? 0) + 1);
     };
-    const inventedNote = (element, name, why) => {
+    const inventedNote = (element, name, why, whyKey) => {
         notes.push({
             kind: 'invented-layout',
             sourceId: name,
             element,
             message: why,
+            ...(whyKey ? { messageKey: whyKey } : {}),
         });
     };
     /**
@@ -297,12 +347,16 @@ export function importWardleyOwm(source, context = {}) {
                     kind: 'warning',
                     sourceId: name,
                     element,
+                    messageKey: WARDLEY_OWM_IMPORT_REMARKS.unreadableCoordinatesLine[0],
                     message: `line ${lineIndex + 1} declares coordinates this reader cannot make a number of, so they were not used.`,
+                    messageParams: { line: lineIndex + 1 },
                 });
             }
             inventedNote(element, name, bracket.present
-                ? 'its coordinates were unreadable, so it was placed where a map with no coordinates places things. The file did not say where it goes.'
-                : 'the file gives it no coordinates, so it was placed where a map with no coordinates places things. The file did not say where it goes.');
+                ? WARDLEY_OWM_IMPORT_REMARKS.unreadableCoordinatesInvented[1]
+                : WARDLEY_OWM_IMPORT_REMARKS.noCoordinatesInvented[1], bracket.present
+                ? WARDLEY_OWM_IMPORT_REMARKS.unreadableCoordinatesInvented[0]
+                : WARDLEY_OWM_IMPORT_REMARKS.noCoordinatesInvented[0]);
             return { ...place, invented: true };
         }
         inventedNote(element, name, visibility === undefined
@@ -467,7 +521,9 @@ export function importWardleyOwm(source, context = {}) {
         notes.push({
             kind: 'carried',
             element: kind,
-            message: `${count} \`${kind}\` line${count === 1 ? '' : 's'} kept verbatim on the map and written back on the next export. Nothing on this canvas draws ${count === 1 ? 'it' : 'them'}.`,
+            messageKey: WARDLEY_OWM_IMPORT_REMARKS.carriedConstruct[0],
+            message: `${count} \`${kind}\` line(s) kept verbatim on the map and written back on the next export. Nothing on this canvas draws them.`,
+            messageParams: { count, kind },
         });
     }
     /* ── A name declared twice ────────────────────────────────────────── */
@@ -478,7 +534,8 @@ export function importWardleyOwm(source, context = {}) {
                 kind: 'warning',
                 sourceId: statement.name,
                 element: statement.keyword,
-                message: 'this name is declared more than once. Both artefacts are on the map, and every link naming it means the first — OWM identifies a component by its name.',
+                message: WARDLEY_OWM_IMPORT_REMARKS.duplicateName[1],
+                messageKey: WARDLEY_OWM_IMPORT_REMARKS.duplicateName[0],
             });
         }
         declared.add(statement.name);
@@ -504,7 +561,8 @@ export function importWardleyOwm(source, context = {}) {
                 notes.push({
                     kind: 'warning',
                     element: 'link',
-                    message: 'a link names nothing on one of its ends, so the arrow it asks for runs to no artefact and is invisible on the canvas.',
+                    message: WARDLEY_OWM_IMPORT_REMARKS.linkEmptyEnd[1],
+                    messageKey: WARDLEY_OWM_IMPORT_REMARKS.linkEmptyEnd[0],
                 });
                 continue;
             }
@@ -514,7 +572,8 @@ export function importWardleyOwm(source, context = {}) {
                 kind: 'warning',
                 sourceId: end,
                 element: 'link',
-                message: 'a link names this, and no statement in the file declares it. The arrow is in the document and runs to no artefact, so it is invisible on the canvas.',
+                message: WARDLEY_OWM_IMPORT_REMARKS.linkUndeclaredEnd[1],
+                messageKey: WARDLEY_OWM_IMPORT_REMARKS.linkUndeclaredEnd[0],
             });
         }
     }

package/dist/legend.d.ts

@@ -1,9 +1,20 @@
 import { type WardleyBackgroundElementModel } from '@formicoidea/labre-core/model';
+import { type ChromeWording } from '@formicoidea/labre-core/shared/services';
 import type { BlockStdScope } from '@formicoidea/labre-core/std';
-/** A box in the panel, relative to the panel's top-left, plus its words. */
+/** Every {@link LEGEND_DESC} wording, for `translations.ts`'s manifest. */
+export declare const WARDLEY_LEGEND_DESC_WORDINGS: readonly ChromeWording[];
+/** Every {@link LEGEND_GRADIENT} caption, for `translations.ts`'s manifest. */
+export declare const WARDLEY_LEGEND_GRADIENT_WORDINGS: readonly ChromeWording[];
+/** The legend box's own title. */
+export declare const WARDLEY_LEGEND_TITLE: ChromeWording;
+/** The five-forces panel's own title. */
+export declare const WARDLEY_LEGEND_PORTER_TITLE: ChromeWording;
+/** Every {@link PORTER_FORCES} wording, plus the caption, for the manifest. */
+export declare const WARDLEY_LEGEND_PORTER_WORDINGS: readonly ChromeWording[];
+/** A box in the panel, relative to the panel's top-left, plus its wording. */
 interface PorterPanelBox {
     xywh: [number, number, number, number];
-    label: string;
+    label: ChromeWording;
 }
 interface PorterPanelLayout {
     w: number;
@@ -24,6 +35,13 @@ interface PorterPanelLayout {
  * they surround — is checkable rather than eyeballed.
  */
 export declare function porterPanelLayout(w: number): PorterPanelLayout;
+/**
+ * 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 declare const WARDLEY_LEGEND_WORDINGS: readonly ChromeWording[];
 /**
  * Build a "Legend" group from real, editable elements (white rect frame +
  * "Legend" text + one row of [real component glyph + description text] per

package/dist/legend.js

@@ -1,6 +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';
@@ -21,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.",
+        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 = {
@@ -79,15 +125,46 @@ const PORTER_PANEL = {
 };
 /** 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.
  *
@@ -145,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
@@ -492,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].
@@ -534,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
@@ -560,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',
@@ -601,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`.
  *