@formicoidea/labre-framework-cynefin 0.39.3 → 0.41.0

package/dist/cynefin/consts.d.ts

@@ -1,7 +1,19 @@
+import type { ChromeWording } from '@formicoidea/labre-core/shared/services';
 /**
  * Visual constants for the Liminal Cynefin diagram, reproduced from the official
  * SVG (viewBox 0 0 1080 777). All geometry is authored in that fixed reference
  * space and scaled uniformly to the element bounds by the renderer.
+ *
+ * ## i18n
+ *
+ * Every word painted on the diagram — domain headings and subheadings, the
+ * Probe/Sense/Respond decision lines, the teal annotations, the small
+ * exaptation sub-labels and the two central markers — carries a `…Key`
+ * alongside its English text, resolved by `element-renderer.ts` through the
+ * `CanvasRenderer` it is handed at paint time (the 4th argument every
+ * `ElementRenderer` receives, `renderer.std`). The letters "A" and "C" on the
+ * two markers are notation, not words, and are deliberately NOT keyed (PO
+ * decision) — only their spelled-out NAMES ("Aporia", "Confusion") are.
  */
 export declare const REF_W = 1080;
 export declare const REF_H = 777;
@@ -32,48 +44,60 @@ export declare const HATCHES: ReadonlyArray<readonly [number, number, number, nu
 export declare const DASH_RECTS: ReadonlyArray<readonly [number, number, number, number]>;
 /**
  * The four domain blocks. Each has a heading (h1) and, when descriptions are
- * shown, a subheading (h2) and three decision lines whose lead word is bold.
- * All three text levels share the block's left `x`.
+ * shown, a subheading (h2) and three decision lines whose lead word is bold
+ * (English, no host) or drawn whole (translated). All three text levels share
+ * the block's left `x`.
  */
 export interface DomainBlock {
-    heading: string;
+    heading: ChromeWording;
     /** Left edge shared by heading, subheading and body lines. */
     x: number;
     /** Heading (h1) baseline. */
     hy: number;
-    subheading: string;
+    subheading: ChromeWording;
     /** Subheading (h2) baseline. */
     sy: number;
-    /** Decision lines: bold lead word + remainder, with their baseline. */
+    /** Decision lines: bold lead word + remainder + the full sentence's key. */
     lines: ReadonlyArray<{
         lead: string;
         rest: string;
+        wording: ChromeWording;
         y: number;
     }>;
 }
 export declare const DOMAINS: ReadonlyArray<DomainBlock>;
-/** Teal annotation labels (centered): [text, x, y]. */
-export declare const TEAL_LABELS: ReadonlyArray<readonly [string, number, number]>;
-/** Small exaptation sub-labels (centered): [text, x, y]. */
-export declare const SMALL_LABELS: ReadonlyArray<readonly [string, number, number]>;
+/** Teal annotation labels (centered): [wording, x, y]. */
+export declare const TEAL_LABELS: ReadonlyArray<readonly [ChromeWording, number, number]>;
+/** Small exaptation sub-labels (centered): [wording, x, y]. */
+export declare const SMALL_LABELS: ReadonlyArray<readonly [ChromeWording, number, number]>;
 /**
  * The two central markers — Aporia (A) and Confusion (C) — each a big glyph and
  * a name, with an optional teal note ("prepare to exit"). All centered.
+ *
+ * `letter` is the notation itself ("A" / "C") and is deliberately NOT keyed
+ * (PO decision) — only the spelled-out `name` is.
  */
 export interface Marker {
     letter: string;
     /** Big glyph position. */
     lx: number;
     ly: number;
-    name: string;
+    name: ChromeWording;
     /** Name (body) position. */
     nx: number;
     ny: number;
-    /** Optional teal note position + text. */
+    /** Optional teal note position + wording. */
     note?: {
-        text: string;
+        wording: ChromeWording;
         x: number;
         y: number;
     };
 }
 export declare const MARKERS: ReadonlyArray<Marker>;
+/**
+ * Every wording this file paints, for `translations.ts`'s manifest
+ * contribution. Deduplicated by key (`iterate` and the two shared lines are
+ * each listed once), which is what `mergeTranslationEntries` needs to see one
+ * entry per key rather than two identical ones.
+ */
+export declare const CYNEFIN_CANVAS_WORDINGS: readonly ChromeWording[];

package/dist/cynefin/consts.js

@@ -2,6 +2,17 @@
  * Visual constants for the Liminal Cynefin diagram, reproduced from the official
  * SVG (viewBox 0 0 1080 777). All geometry is authored in that fixed reference
  * space and scaled uniformly to the element bounds by the renderer.
+ *
+ * ## i18n
+ *
+ * Every word painted on the diagram — domain headings and subheadings, the
+ * Probe/Sense/Respond decision lines, the teal annotations, the small
+ * exaptation sub-labels and the two central markers — carries a `…Key`
+ * alongside its English text, resolved by `element-renderer.ts` through the
+ * `CanvasRenderer` it is handed at paint time (the 4th argument every
+ * `ElementRenderer` receives, `renderer.std`). The letters "A" and "C" on the
+ * two markers are notation, not words, and are deliberately NOT keyed (PO
+ * decision) — only their spelled-out NAMES ("Aporia", "Confusion") are.
  */
 export const REF_W = 1080;
 export const REF_H = 777;
@@ -84,94 +95,318 @@ export const DASH_RECTS = [
     [998, 314, 11.9, 168.9],
     [1019, 310, 11.8, 167.3],
 ];
+/* ── i18n: headings, subheadings and decision lines ───────────────────── */
+const HEADING_COMPLEX = [
+    'com.labre.cynefin-estuarine.cynefin.heading.complex',
+    'Complex',
+];
+const HEADING_COMPLICATED = [
+    'com.labre.cynefin-estuarine.cynefin.heading.complicated',
+    'Complicated',
+];
+const HEADING_CHAOTIC = [
+    'com.labre.cynefin-estuarine.cynefin.heading.chaotic',
+    'Chaotic',
+];
+const HEADING_CLEAR = [
+    'com.labre.cynefin-estuarine.cynefin.heading.clear',
+    'Clear',
+];
+const SUBHEADING_ADAPTIVE = [
+    'com.labre.cynefin-estuarine.cynefin.subheading.adaptive-system',
+    'Adaptive system',
+];
+/** Shared by Complicated and Clear — the same word, one key. */
+const SUBHEADING_ORDERED = [
+    'com.labre.cynefin-estuarine.cynefin.subheading.ordered-system',
+    'Ordered system',
+];
+const SUBHEADING_UNORDERED = [
+    'com.labre.cynefin-estuarine.cynefin.subheading.un-ordered-system',
+    'Un-ordered system',
+];
+/**
+ * The ten distinct decision sentences (two are shared verbatim between two
+ * domains — "Sense how the context reacts", "Sense the context with
+ * analytical methods" — one key each, reused rather than duplicated).
+ *
+ * The fallback is the FULL sentence (`lead` + `rest` concatenated): the
+ * renderer draws `lead` bold and `rest` roman as two `fillText` calls only
+ * while NO host answered (byte-identical to before these keys existed); once
+ * a host resolves the key, the whole sentence is drawn as one run — a
+ * translation is not guaranteed to keep the same first word, so splitting it
+ * at the English boundary would be a guess.
+ */
+const LINE_PROBE = [
+    'com.labre.cynefin-estuarine.cynefin.line.probe',
+    'Probe the context with parallel experiments',
+];
+const LINE_SENSE_REACTS = [
+    'com.labre.cynefin-estuarine.cynefin.line.sense-reacts',
+    'Sense how the context reacts',
+];
+const LINE_RESPOND_AMPLIFY = [
+    'com.labre.cynefin-estuarine.cynefin.line.respond-amplify',
+    'Respond by amplifying positive experiments',
+];
+const LINE_SENSE_ANALYTICAL = [
+    'com.labre.cynefin-estuarine.cynefin.line.sense-analytical',
+    'Sense the context with analytical methods',
+];
+const LINE_ANALYSE = [
+    'com.labre.cynefin-estuarine.cynefin.line.analyse',
+    'Analyse observations',
+];
+const LINE_RESPOND_MANY_SOLUTIONS = [
+    'com.labre.cynefin-estuarine.cynefin.line.respond-many-solutions',
+    'Respond by applying one of many good solutions',
+];
+const LINE_ACT = [
+    'com.labre.cynefin-estuarine.cynefin.line.act',
+    'Act on the context to stabilize (it or yourself)',
+];
+const LINE_RESPOND_REACT = [
+    'com.labre.cynefin-estuarine.cynefin.line.respond-react',
+    'Respond by re-acting',
+];
+const LINE_CATEGORIZE = [
+    'com.labre.cynefin-estuarine.cynefin.line.categorize',
+    'Categorize observations',
+];
+const LINE_RESPOND_PRACTICES = [
+    'com.labre.cynefin-estuarine.cynefin.line.respond-practices',
+    'Respond by applying tried and true practices',
+];
 export const DOMAINS = [
     {
-        heading: 'Complex',
+        heading: HEADING_COMPLEX,
         x: 37,
         hy: 31,
-        subheading: 'Adaptive system',
+        subheading: SUBHEADING_ADAPTIVE,
         sy: 53,
         lines: [
-            { lead: 'Probe', rest: ' the context with parallel experiments', y: 71 },
-            { lead: 'Sense', rest: ' how the context reacts', y: 90 },
-            { lead: 'Respond', rest: ' by amplifying positive experiments', y: 109 },
+            {
+                lead: 'Probe',
+                rest: ' the context with parallel experiments',
+                wording: LINE_PROBE,
+                y: 71,
+            },
+            {
+                lead: 'Sense',
+                rest: ' how the context reacts',
+                wording: LINE_SENSE_REACTS,
+                y: 90,
+            },
+            {
+                lead: 'Respond',
+                rest: ' by amplifying positive experiments',
+                wording: LINE_RESPOND_AMPLIFY,
+                y: 109,
+            },
         ],
     },
     {
-        heading: 'Complicated',
+        heading: HEADING_COMPLICATED,
         x: 779,
         hy: 31,
-        subheading: 'Ordered system',
+        subheading: SUBHEADING_ORDERED,
         sy: 53,
         lines: [
-            { lead: 'Sense', rest: ' the context with analytical methods', y: 71 },
-            { lead: 'Analyse', rest: ' observations', y: 90 },
+            {
+                lead: 'Sense',
+                rest: ' the context with analytical methods',
+                wording: LINE_SENSE_ANALYTICAL,
+                y: 71,
+            },
+            { lead: 'Analyse', rest: ' observations', wording: LINE_ANALYSE, y: 90 },
             {
                 lead: 'Respond',
                 rest: ' by applying one of many good solutions',
+                wording: LINE_RESPOND_MANY_SOLUTIONS,
                 y: 109,
             },
         ],
     },
     {
-        heading: 'Chaotic',
+        heading: HEADING_CHAOTIC,
         x: 37,
         hy: 587,
-        subheading: 'Un-ordered system',
+        subheading: SUBHEADING_UNORDERED,
         sy: 609,
         lines: [
             {
                 lead: 'Act',
                 rest: ' on the context to stabilize (it or yourself)',
+                wording: LINE_ACT,
                 y: 627,
             },
-            { lead: 'Sense', rest: ' how the context reacts', y: 646 },
-            { lead: 'Respond', rest: ' by re-acting', y: 665 },
+            {
+                lead: 'Sense',
+                rest: ' how the context reacts',
+                wording: LINE_SENSE_REACTS,
+                y: 646,
+            },
+            {
+                lead: 'Respond',
+                rest: ' by re-acting',
+                wording: LINE_RESPOND_REACT,
+                y: 665,
+            },
         ],
     },
     {
-        heading: 'Clear',
+        heading: HEADING_CLEAR,
         x: 779,
         hy: 587,
-        subheading: 'Ordered system',
+        subheading: SUBHEADING_ORDERED,
         sy: 609,
         lines: [
-            { lead: 'Sense', rest: ' the context with analytical methods', y: 627 },
-            { lead: 'Categorize', rest: ' observations', y: 646 },
+            {
+                lead: 'Sense',
+                rest: ' the context with analytical methods',
+                wording: LINE_SENSE_ANALYTICAL,
+                y: 627,
+            },
+            {
+                lead: 'Categorize',
+                rest: ' observations',
+                wording: LINE_CATEGORIZE,
+                y: 646,
+            },
             {
                 lead: 'Respond',
                 rest: ' by applying tried and true practices',
+                wording: LINE_RESPOND_PRACTICES,
                 y: 665,
             },
         ],
     },
 ];
-/** Teal annotation labels (centered): [text, x, y]. */
+/* ── i18n: teal annotations and small exaptation sub-labels ────────────── */
+const TEAL_ITERATE = [
+    'com.labre.cynefin-estuarine.cynefin.teal.iterate',
+    'iterate',
+];
+const TEAL_STRATEGY_BY_DESIGN = [
+    'com.labre.cynefin-estuarine.cynefin.teal.strategy-by-design',
+    'strategy by design',
+];
+const TEAL_RADICAL_INNOVATION = [
+    'com.labre.cynefin-estuarine.cynefin.teal.radical-innovation',
+    'radical innovation',
+];
+const TEAL_BY_DESIGN = [
+    'com.labre.cynefin-estuarine.cynefin.teal.by-design',
+    'by design',
+];
+const TEAL_EXTREME_REPURPOSING = [
+    'com.labre.cynefin-estuarine.cynefin.teal.extreme-repurposing',
+    'extreme repurposing',
+];
+const TEAL_GOOD_PRACTICE = [
+    'com.labre.cynefin-estuarine.cynefin.teal.good-practice',
+    'good practice',
+];
+const TEAL_BEST_PRACTICE = [
+    'com.labre.cynefin-estuarine.cynefin.teal.best-practice',
+    'best practice',
+];
+/** Teal annotation labels (centered): [wording, x, y]. */
 export const TEAL_LABELS = [
-    ['iterate', 510, 16],
-    ['iterate', 533, 230],
-    ['strategy by design', 257, 225],
-    ['radical innovation', 268, 390],
-    ['by design', 268, 406],
-    ['extreme repurposing', 217, 496],
-    ['good practice', 814, 196],
-    ['best practice', 751, 459],
-];
-/** Small exaptation sub-labels (centered): [text, x, y]. */
+    [TEAL_ITERATE, 510, 16],
+    [TEAL_ITERATE, 533, 230],
+    [TEAL_STRATEGY_BY_DESIGN, 257, 225],
+    [TEAL_RADICAL_INNOVATION, 268, 390],
+    [TEAL_BY_DESIGN, 268, 406],
+    [TEAL_EXTREME_REPURPOSING, 217, 496],
+    [TEAL_GOOD_PRACTICE, 814, 196],
+    [TEAL_BEST_PRACTICE, 751, 459],
+];
+const SMALL_DISPOSITIONAL = [
+    'com.labre.cynefin-estuarine.cynefin.small.dispositional-exaptation',
+    'dispositional exaptation',
+];
+const SMALL_STIMULATED = [
+    'com.labre.cynefin-estuarine.cynefin.small.stimulated-exaptation',
+    'stimulated exaptation',
+];
+const SMALL_STRESS_BASED = [
+    'com.labre.cynefin-estuarine.cynefin.small.stress-based-exaptation',
+    'stress-based exaptation',
+];
+/** Small exaptation sub-labels (centered): [wording, x, y]. */
 export const SMALL_LABELS = [
-    ['dispositional exaptation', 257, 239],
-    ['stimulated exaptation', 268, 419],
-    ['stress-based exaptation', 217, 510],
+    [SMALL_DISPOSITIONAL, 257, 239],
+    [SMALL_STIMULATED, 268, 419],
+    [SMALL_STRESS_BASED, 217, 510],
+];
+/* ── i18n: the two central markers ──────────────────────────────────── */
+const MARKER_APORIA_NAME = [
+    'com.labre.cynefin-estuarine.cynefin.marker.aporia',
+    'Aporia',
+];
+const MARKER_CONFUSION_NAME = [
+    'com.labre.cynefin-estuarine.cynefin.marker.confusion',
+    'Confusion',
+];
+const MARKER_APORIA_NOTE = [
+    'com.labre.cynefin-estuarine.cynefin.marker.aporia-note',
+    'prepare to exit',
 ];
 export const MARKERS = [
     {
         letter: 'A',
         lx: 444,
         ly: 334,
-        name: 'Aporia',
+        name: MARKER_APORIA_NAME,
         nx: 447,
         ny: 349,
-        note: { text: 'prepare to exit', x: 449, y: 366 },
+        note: { wording: MARKER_APORIA_NOTE, x: 449, y: 366 },
+    },
+    {
+        letter: 'C',
+        lx: 531,
+        ly: 419,
+        name: MARKER_CONFUSION_NAME,
+        nx: 529,
+        ny: 436,
     },
-    { letter: 'C', lx: 531, ly: 419, name: 'Confusion', nx: 529, ny: 436 },
+];
+/**
+ * Every wording this file paints, for `translations.ts`'s manifest
+ * contribution. Deduplicated by key (`iterate` and the two shared lines are
+ * each listed once), which is what `mergeTranslationEntries` needs to see one
+ * entry per key rather than two identical ones.
+ */
+export const CYNEFIN_CANVAS_WORDINGS = [
+    HEADING_COMPLEX,
+    HEADING_COMPLICATED,
+    HEADING_CHAOTIC,
+    HEADING_CLEAR,
+    SUBHEADING_ADAPTIVE,
+    SUBHEADING_ORDERED,
+    SUBHEADING_UNORDERED,
+    LINE_PROBE,
+    LINE_SENSE_REACTS,
+    LINE_RESPOND_AMPLIFY,
+    LINE_SENSE_ANALYTICAL,
+    LINE_ANALYSE,
+    LINE_RESPOND_MANY_SOLUTIONS,
+    LINE_ACT,
+    LINE_RESPOND_REACT,
+    LINE_CATEGORIZE,
+    LINE_RESPOND_PRACTICES,
+    TEAL_ITERATE,
+    TEAL_STRATEGY_BY_DESIGN,
+    TEAL_RADICAL_INNOVATION,
+    TEAL_BY_DESIGN,
+    TEAL_EXTREME_REPURPOSING,
+    TEAL_GOOD_PRACTICE,
+    TEAL_BEST_PRACTICE,
+    SMALL_DISPOSITIONAL,
+    SMALL_STIMULATED,
+    SMALL_STRESS_BASED,
+    MARKER_APORIA_NAME,
+    MARKER_CONFUSION_NAME,
+    MARKER_APORIA_NOTE,
 ];

package/dist/cynefin/element-renderer.d.ts

@@ -7,6 +7,22 @@ import type { CynefinElementModel } from '@formicoidea/labre-core/model';
  * (heading + Probe/Sense/Respond decisions), the teal annotation labels and the
  * central Aporia (A) / Confusion (C) markers. Drawn in the fixed reference space
  * and scaled uniformly to the element bounds.
+ *
+ * ## i18n
+ *
+ * Every word above is a `ChromeWording` (`./consts.ts`), resolved through the
+ * `CanvasRenderer` this function is handed as its 4th argument — the same
+ * `renderer.std` `framework-background/renderer.ts` reads for a declared
+ * background. `renderer` is optional (absent in a bare unit test that calls
+ * this function with three arguments), in which case every wording reads its
+ * English fallback, byte-identical to before these keys existed.
+ *
+ * The three-line decisions are the one wrinkle: with no host they are drawn as
+ * they always were — a bold lead word plus the roman remainder, two
+ * `fillText` calls — because that split is known to be exactly the English
+ * text. Once a host answers, the WHOLE sentence is drawn as one run: a
+ * translation is not guaranteed to keep the same first word, so guessing where
+ * to split it would be inventing typography the translator never asked for.
  */
 export declare const cynefin: ElementRenderer<CynefinElementModel>;
 export declare const CynefinRendererExtension: import("@formicoidea/labre-core/store").ExtensionType & {

package/dist/cynefin/element-renderer.js

@@ -1,4 +1,5 @@
 import { ElementRendererExtension, } from '@formicoidea/labre-core/blocks/surface';
+import { TranslationProvider, translateKey, } from '@formicoidea/labre-core/shared/services';
 import { FONT_FAMILY, refScale } from '../utils.js';
 import { COLORS, DARK_BACK_PATHS, DARK_FRONT_PATHS, DASH_RECTS, DOMAINS, HATCHES, MARKERS, REF_H, REF_W, SMALL_LABELS, TEAL_LABELS, TEAL_PATH, TEAL_WIDTH, } from './consts.js';
 /**
@@ -8,8 +9,29 @@ import { COLORS, DARK_BACK_PATHS, DARK_FRONT_PATHS, DASH_RECTS, DOMAINS, HATCHES
  * (heading + Probe/Sense/Respond decisions), the teal annotation labels and the
  * central Aporia (A) / Confusion (C) markers. Drawn in the fixed reference space
  * and scaled uniformly to the element bounds.
+ *
+ * ## i18n
+ *
+ * Every word above is a `ChromeWording` (`./consts.ts`), resolved through the
+ * `CanvasRenderer` this function is handed as its 4th argument — the same
+ * `renderer.std` `framework-background/renderer.ts` reads for a declared
+ * background. `renderer` is optional (absent in a bare unit test that calls
+ * this function with three arguments), in which case every wording reads its
+ * English fallback, byte-identical to before these keys existed.
+ *
+ * The three-line decisions are the one wrinkle: with no host they are drawn as
+ * they always were — a bold lead word plus the roman remainder, two
+ * `fillText` calls — because that split is known to be exactly the English
+ * text. Once a host answers, the WHOLE sentence is drawn as one run: a
+ * translation is not guaranteed to keep the same first word, so guessing where
+ * to split it would be inventing typography the translator never asked for.
  */
-export const cynefin = (model, ctx, matrix) => {
+export const cynefin = (model, ctx, matrix, renderer) => {
+    const tr = (wording) => renderer ? translateKey(renderer.std, ...wording) : wording[1];
+    // The host's catalogue, or `null` with no host — used to decide whether a
+    // decision line is drawn bold-lead/roman-rest (English, exactly as before)
+    // or as one translated run. See the docstring above.
+    const hasHost = Boolean(renderer?.std.getOptional(TranslationProvider));
     const [, , w, h] = model.deserializedXYWH;
     const cx = w / 2;
     const cy = h / 2;
@@ -67,50 +89,61 @@ export const cynefin = (model, ctx, matrix) => {
         ctx.fillStyle = COLORS.heading;
         ctx.font = `700 30px ${FONT_FAMILY}`;
         for (const d of DOMAINS)
-            ctx.fillText(d.heading, d.x, d.hy);
+            ctx.fillText(tr(d.heading), d.x, d.hy);
         ctx.textAlign = 'center';
         for (const m of MARKERS) {
             ctx.fillStyle = COLORS.body;
             ctx.font = `700 38px ${FONT_FAMILY}`;
+            // The letter itself is notation, not a word — never translated.
             ctx.fillText(m.letter, m.lx, m.ly);
             ctx.font = `13.5px ${FONT_FAMILY}`;
-            ctx.fillText(m.name, m.nx, m.ny);
+            ctx.fillText(tr(m.name), m.nx, m.ny);
         }
     }
     // ── Explanatory text: subheadings, decisions, annotations, notes ────
     if (model.showDescriptions) {
-        // Subheadings (h2) + bold-lead decision lines
+        // Subheadings (h2) + decision lines
         ctx.textAlign = 'left';
         for (const d of DOMAINS) {
             ctx.fillStyle = COLORS.heading;
             ctx.font = `700 15px ${FONT_FAMILY}`;
-            ctx.fillText(d.subheading, d.x, d.sy);
+            ctx.fillText(tr(d.subheading), d.x, d.sy);
             ctx.fillStyle = COLORS.body;
-            for (const { lead, rest, y } of d.lines) {
-                ctx.font = `700 13.5px ${FONT_FAMILY}`;
-                ctx.fillText(lead, d.x, y);
-                const leadW = ctx.measureText(lead).width;
-                ctx.font = `13.5px ${FONT_FAMILY}`;
-                ctx.fillText(rest, d.x + leadW, y);
+            for (const { lead, rest, wording, y } of d.lines) {
+                if (hasHost) {
+                    // A translated sentence: one run, no assumed bold-lead boundary.
+                    ctx.font = `13.5px ${FONT_FAMILY}`;
+                    ctx.fillText(tr(wording), d.x, y);
+                }
+                else {
+                    // No host: exactly the bold-lead / roman-rest split that shipped
+                    // before these keys existed.
+                    ctx.font = `700 13.5px ${FONT_FAMILY}`;
+                    ctx.fillText(lead, d.x, y);
+                    const leadW = ctx.measureText(lead).width;
+                    ctx.font = `13.5px ${FONT_FAMILY}`;
+                    ctx.fillText(rest, d.x + leadW, y);
+                }
             }
         }
         ctx.textAlign = 'center';
         // Teal annotation labels
         ctx.fillStyle = COLORS.teal;
         ctx.font = `700 15px ${FONT_FAMILY}`;
-        for (const [t, x, y] of TEAL_LABELS)
-            ctx.fillText(t, x, y);
+        for (const [wording, x, y] of TEAL_LABELS)
+            ctx.fillText(tr(wording), x, y);
         // Small exaptation sub-labels
         ctx.fillStyle = COLORS.body;
         ctx.font = `10.5px ${FONT_FAMILY}`;
-        for (const [t, x, y] of SMALL_LABELS)
-            ctx.fillText(t, x, y);
+        for (const [wording, x, y] of SMALL_LABELS) {
+            ctx.fillText(tr(wording), x, y);
+        }
         // Marker notes ("prepare to exit")
         ctx.fillStyle = COLORS.teal;
         ctx.font = `700 15px ${FONT_FAMILY}`;
         for (const m of MARKERS) {
             if (m.note)
-                ctx.fillText(m.note.text, m.note.x, m.note.y);
+                ctx.fillText(tr(m.note.wording), m.note.x, m.note.y);
         }
     }
 };

package/dist/cynefin/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 CYNEFIN_TOOLBAR_WORDINGS: readonly ChromeWording[];
 export declare const cynefinToolbarConfig: {
     readonly actions: [{
         id: string;

package/dist/cynefin/toolbar/config.js

@@ -52,6 +52,25 @@ const LiminalIcon = html `<svg
 >
   <path d="M5 17 C9 6 15 6 19 7" />
 </svg>`;
+/** The three toolbar tooltips this file used to hard-code as English literals. */
+const TITLES_TOGGLE = [
+    'com.labre.cynefin-estuarine.cynefin.toolbar.titles',
+    'Show / hide titles',
+];
+const DESCRIPTIONS_TOGGLE = [
+    'com.labre.cynefin-estuarine.cynefin.toolbar.descriptions',
+    'Show / hide explanatory text',
+];
+const LIMINAL_LINE_TOGGLE = [
+    'com.labre.cynefin-estuarine.cynefin.toolbar.liminal-line',
+    'Show / hide liminal line',
+];
+/** Every wording above, for `translations.ts`'s manifest contribution. */
+export const CYNEFIN_TOOLBAR_WORDINGS = [
+    TITLES_TOGGLE,
+    DESCRIPTIONS_TOGGLE,
+    LIMINAL_LINE_TOGGLE,
+];
 function booleanToggle(id, tooltip, icon, prop) {
     return {
         id,
@@ -81,9 +100,9 @@ function booleanToggle(id, tooltip, icon, prop) {
 export const cynefinToolbarConfig = {
     actions: [
         booleanToggle('a.toggle-resize', BOARD_RESIZE_TOGGLE, ResizeIcon, 'resizeEnabled'),
-        booleanToggle('b.toggle-titles', 'Show / hide titles', TitlesIcon, 'showTitles'),
-        booleanToggle('c.toggle-descriptions', 'Show / hide explanatory text', DescIcon, 'showDescriptions'),
-        booleanToggle('d.toggle-liminal', 'Show / hide liminal line', LiminalIcon, 'showLiminalLine'),
+        booleanToggle('b.toggle-titles', TITLES_TOGGLE, TitlesIcon, 'showTitles'),
+        booleanToggle('c.toggle-descriptions', DESCRIPTIONS_TOGGLE, DescIcon, 'showDescriptions'),
+        booleanToggle('d.toggle-liminal', LIMINAL_LINE_TOGGLE, LiminalIcon, 'showLiminalLine'),
     ],
     when: ctx => ctx.getSurfaceModelsByType(CynefinElementModel).length > 0,
 };

package/dist/estuarine/consts.d.ts

@@ -1,3 +1,4 @@
+import type { ChromeWording } from '@formicoidea/labre-core/shared/services';
 /**
  * Visual constants for the Estuarine framework map, reproduced from the official
  * SVG (viewBox 0 0 690 801). All geometry is authored in that fixed reference
@@ -7,6 +8,12 @@
  * letterboxed (see `EstuarineFit` in `./element-renderer.ts`). The e axis is
  * vertical & double-headed (energy), the t axis horizontal & single-headed
  * (time only flows one way).
+ *
+ * The three curve legends below (`LABELS`) carry a `wording`, resolved by
+ * `element-renderer.ts` through the `CanvasRenderer` it is handed at paint
+ * time — see `cynefin/consts.ts` for the identical mechanism next door. The
+ * italic `e` / `t` axis LETTERS (`AXIS_LABELS`) are notation, not words, and
+ * are deliberately NOT keyed (PO decision).
  */
 export declare const REF_W = 690;
 export declare const REF_H = 801;
@@ -50,24 +57,26 @@ export declare const COUNTERFACTUAL_WIDTH = 5.5;
 /** Volatile: red boundary descending along the left, bulging right. */
 export declare const VOLATILE_PATH = "M 58 446 C 61 447, 70 451, 76 454 C 82 457, 88 462, 94 466 C 100 470, 107 476, 112 481 C 117 486, 122 492, 126 498 C 130 504, 135 509, 139 515 C 143 521, 145 526, 148 532 C 151 538, 153 544, 155 550 C 157 556, 159 562, 160 568 C 161 574, 162 580, 163 586 C 164 592, 164 598, 164 604 C 164 610, 166 616, 166 622 C 166 628, 166 634, 165 640 C 164 646, 164 652, 163 658 C 162 664, 162 670, 161 676 C 160 682, 160 688, 159 694 C 158 700, 155 706, 154 712 C 153 718, 152 724, 151 730 C 150 736, 148 746, 147 749";
 export declare const VOLATILE_WIDTH = 5;
+/** Every {@link LABELS} wording, for `translations.ts`'s manifest. */
+export declare const ESTUARINE_CANVAS_WORDINGS: readonly ChromeWording[];
 /** Uppercase legends: anchored centre, alphabetic baseline, with letter-spacing. */
 export declare const LABELS: {
     readonly counterfactual: {
-        readonly text: "COUNTER FACTUAL";
+        readonly wording: ChromeWording;
         readonly x: 422;
         readonly y: 25;
         readonly size: 20;
         readonly color: "#1a1a1a";
     };
     readonly liminal: {
-        readonly text: "LIMINAL";
+        readonly wording: ChromeWording;
         readonly x: 316;
         readonly y: 192;
         readonly size: 18;
         readonly color: "#2e7d32";
     };
     readonly volatile: {
-        readonly text: "VOLATILE";
+        readonly wording: ChromeWording;
         readonly x: 219;
         readonly y: 783;
         readonly size: 20;

package/dist/estuarine/consts.js

@@ -7,6 +7,12 @@
  * letterboxed (see `EstuarineFit` in `./element-renderer.ts`). The e axis is
  * vertical & double-headed (energy), the t axis horizontal & single-headed
  * (time only flows one way).
+ *
+ * The three curve legends below (`LABELS`) carry a `wording`, resolved by
+ * `element-renderer.ts` through the `CanvasRenderer` it is handed at paint
+ * time — see `cynefin/consts.ts` for the identical mechanism next door. The
+ * italic `e` / `t` axis LETTERS (`AXIS_LABELS`) are notation, not words, and
+ * are deliberately NOT keyed (PO decision).
  */
 export const REF_W = 690;
 export const REF_H = 801;
@@ -54,24 +60,42 @@ export const COUNTERFACTUAL_WIDTH = 5.5;
 /** Volatile: red boundary descending along the left, bulging right. */
 export const VOLATILE_PATH = 'M 58 446 C 61 447, 70 451, 76 454 C 82 457, 88 462, 94 466 C 100 470, 107 476, 112 481 C 117 486, 122 492, 126 498 C 130 504, 135 509, 139 515 C 143 521, 145 526, 148 532 C 151 538, 153 544, 155 550 C 157 556, 159 562, 160 568 C 161 574, 162 580, 163 586 C 164 592, 164 598, 164 604 C 164 610, 166 616, 166 622 C 166 628, 166 634, 165 640 C 164 646, 164 652, 163 658 C 162 664, 162 670, 161 676 C 160 682, 160 688, 159 694 C 158 700, 155 706, 154 712 C 153 718, 152 724, 151 730 C 150 736, 148 746, 147 749';
 export const VOLATILE_WIDTH = 5;
+const LABEL_COUNTERFACTUAL = [
+    'com.labre.cynefin-estuarine.estuarine.legend.counter-factual',
+    'COUNTER FACTUAL',
+];
+const LABEL_LIMINAL = [
+    'com.labre.cynefin-estuarine.estuarine.legend.liminal',
+    'LIMINAL',
+];
+const LABEL_VOLATILE = [
+    'com.labre.cynefin-estuarine.estuarine.legend.volatile',
+    'VOLATILE',
+];
+/** Every {@link LABELS} wording, for `translations.ts`'s manifest. */
+export const ESTUARINE_CANVAS_WORDINGS = [
+    LABEL_COUNTERFACTUAL,
+    LABEL_LIMINAL,
+    LABEL_VOLATILE,
+];
 /** Uppercase legends: anchored centre, alphabetic baseline, with letter-spacing. */
 export const LABELS = {
     counterfactual: {
-        text: 'COUNTER FACTUAL',
+        wording: LABEL_COUNTERFACTUAL,
         x: 422,
         y: 25,
         size: 20,
         color: COLORS.label,
     },
     liminal: {
-        text: 'LIMINAL',
+        wording: LABEL_LIMINAL,
         x: 316,
         y: 192,
         size: 18,
         color: COLORS.liminalLabel,
     },
     volatile: {
-        text: 'VOLATILE',
+        wording: LABEL_VOLATILE,
         x: 219,
         y: 783,
         size: 20,

package/dist/estuarine/element-renderer.js

@@ -1,4 +1,5 @@
 import { ElementRendererExtension, } from '@formicoidea/labre-core/blocks/surface';
+import { translateKey, } from '@formicoidea/labre-core/shared/services';
 import { FONT_FAMILY } from '../utils.js';
 import { ARROWHEADS, AXIS_LABELS, AXIS_WIDTH, COLORS, COUNTERFACTUAL_PATH, COUNTERFACTUAL_WIDTH, E_AXIS, LABEL_LETTER_SPACING, LABELS, LIMINAL_PATH, LIMINAL_WIDTH, REF_H, REF_W, T_AXIS, VOLATILE_PATH, VOLATILE_WIDTH, } from './consts.js';
 /**
@@ -99,7 +100,8 @@ export function applyEstuarineTransform(ctx, w, h) {
  *   the three curves, which are boundaries across the plane and must cover
  *   whatever plane the user has made.
  */
-export const estuarine = (model, ctx, matrix) => {
+export const estuarine = (model, ctx, matrix, renderer) => {
+    const tr = (wording) => renderer ? translateKey(renderer.std, ...wording) : wording[1];
     const [, , w, h] = model.deserializedXYWH;
     const cx = w / 2;
     const cy = h / 2;
@@ -152,7 +154,7 @@ export const estuarine = (model, ctx, matrix) => {
         if (hasSpacing) {
             ctx.letterSpacing = `${LABEL_LETTER_SPACING * fit.strokeScale}px`;
         }
-        ctx.fillText(l.text, ax(l.x), ay(l.y));
+        ctx.fillText(tr(l.wording), ax(l.x), ay(l.y));
         if (hasSpacing)
             ctx.letterSpacing = '0px';
     };

package/dist/estuarine/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 ESTUARINE_TOOLBAR_WORDINGS: readonly ChromeWording[];
 export declare const estuarineToolbarConfig: {
     readonly actions: [{
         id: string;

package/dist/estuarine/toolbar/config.js

@@ -64,6 +64,30 @@ const AxisIcon = html `<svg
   <path d="M6 3v18M6 12h15" />
   <path d="M3 6l3-3 3 3M18 9l3 3-3 3" />
 </svg>`;
+/** The four toolbar tooltips this file used to hard-code as English literals. */
+const LIMINAL_TOGGLE = [
+    'com.labre.cynefin-estuarine.estuarine.toolbar.liminal',
+    'Show / hide the Liminal line',
+];
+const VOLATILE_TOGGLE = [
+    'com.labre.cynefin-estuarine.estuarine.toolbar.volatile',
+    'Show / hide the Volatile line',
+];
+const COUNTERFACTUAL_TOGGLE = [
+    'com.labre.cynefin-estuarine.estuarine.toolbar.counterfactual',
+    'Show / hide the Counter-factual line',
+];
+const AXIS_LABELS_TOGGLE = [
+    'com.labre.cynefin-estuarine.estuarine.toolbar.axis-labels',
+    'Show / hide axis labels (e / t)',
+];
+/** Every wording above, for `translations.ts`'s manifest contribution. */
+export const ESTUARINE_TOOLBAR_WORDINGS = [
+    LIMINAL_TOGGLE,
+    VOLATILE_TOGGLE,
+    COUNTERFACTUAL_TOGGLE,
+    AXIS_LABELS_TOGGLE,
+];
 function booleanToggle(id, tooltip, icon, prop) {
     return {
         id,
@@ -93,10 +117,10 @@ function booleanToggle(id, tooltip, icon, prop) {
 export const estuarineToolbarConfig = {
     actions: [
         booleanToggle('a.toggle-resize', BOARD_RESIZE_TOGGLE, ResizeIcon, 'resizeEnabled'),
-        booleanToggle('b.toggle-liminal', 'Show / hide the Liminal line', LiminalIcon, 'showLiminal'),
-        booleanToggle('c.toggle-volatile', 'Show / hide the Volatile line', VolatileIcon, 'showVolatile'),
-        booleanToggle('d.toggle-counterfactual', 'Show / hide the Counter-factual line', CounterfactualIcon, 'showCounterfactual'),
-        booleanToggle('e.toggle-axis-labels', 'Show / hide axis labels (e / t)', AxisIcon, 'showAxisLabels'),
+        booleanToggle('b.toggle-liminal', LIMINAL_TOGGLE, LiminalIcon, 'showLiminal'),
+        booleanToggle('c.toggle-volatile', VOLATILE_TOGGLE, VolatileIcon, 'showVolatile'),
+        booleanToggle('d.toggle-counterfactual', COUNTERFACTUAL_TOGGLE, CounterfactualIcon, 'showCounterfactual'),
+        booleanToggle('e.toggle-axis-labels', AXIS_LABELS_TOGGLE, AxisIcon, 'showAxisLabels'),
     ],
     when: ctx => ctx.getSurfaceModelsByType(EstuarineElementModel).length > 0,
 };

package/dist/templates/index.d.ts

@@ -1,3 +1,42 @@
 import { type TemplateCategory } from '@formicoidea/labre-core/gfx/template';
+import { type ChromeWording } from '@formicoidea/labre-core/shared/services';
+/**
+ * The seeds the two hand-composed templates below write into the document:
+ * the "Decision sorting" board's four domain stickies, and the "Constraint
+ * map" board's three hexagon captions. Exported so `translations.ts` derives
+ * the manifest entries from the SAME constants rather than restating them.
+ */
+export declare const CYNEFIN_SEED_PROBE_LEARN: ChromeWording;
+export declare const CYNEFIN_SEED_EXPERT_ANALYSIS: ChromeWording;
+export declare const CYNEFIN_SEED_ACT_NOW: ChromeWording;
+export declare const CYNEFIN_SEED_KNOWN_ISSUE: ChromeWording;
+export declare const ESTUARINE_SEED_POLICY: ChromeWording;
+export declare const ESTUARINE_SEED_HABIT: ChromeWording;
+export declare const ESTUARINE_SEED_BUDGET: ChromeWording;
+/** All seven, for `translations.ts`'s manifest contribution. */
+export declare const CYNEFIN_ESTUARINE_TEMPLATE_SEEDS: readonly ChromeWording[];
+/**
+ * The two Templates-panel tab names — new keys, since Cynefin and Estuarine
+ * share one senior-button key (`com.labre.framework.cynefin-estuarine`) that
+ * names neither individually (see `TemplateCategory.nameKey`). Both are proper
+ * nouns; the PO's French proposal for each is the identical word.
+ */
+export declare const CYNEFIN_TEMPLATE_CATEGORY_NAME: ChromeWording;
+export declare const ESTUARINE_TEMPLATE_CATEGORY_NAME: ChromeWording;
+/**
+ * The two Templates-panel tab names (chrome, not seeds — a widget-resolved
+ * label, never written into a document), for `translations.ts`'s manifest.
+ */
+export declare const CYNEFIN_ESTUARINE_TEMPLATE_CATEGORY_WORDINGS: readonly ChromeWording[];
+/**
+ * The two hand-composed templates' own tile names (`Template.nameKey`):
+ * chrome, resolved by the panel widget every time it opens, never written
+ * into a document — distinct from {@link CYNEFIN_ESTUARINE_TEMPLATE_SEEDS}
+ * above, which the templates WRITE.
+ */
+export declare const CYNEFIN_TEMPLATE_NAME_DECISION_SORTING: ChromeWording;
+export declare const ESTUARINE_TEMPLATE_NAME_CONSTRAINT_MAP: ChromeWording;
+/** Both tile names, for `translations.ts`'s manifest. */
+export declare const CYNEFIN_ESTUARINE_TEMPLATE_NAME_WORDINGS: readonly ChromeWording[];
 export declare const cynefinTemplateCategory: TemplateCategory;
 export declare const estuarineTemplateCategory: TemplateCategory;

package/dist/templates/index.js

@@ -1,5 +1,7 @@
 import { makeTemplateSnapshot, surfaceText, templateFromCommand, } from '@formicoidea/labre-core/gfx/template';
 import { FontFamily, ShapeStyle, TextAlign } from '@formicoidea/labre-core/model';
+import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
+import { translateKey, } from '@formicoidea/labre-core/shared/services';
 import { cynefinEstuarineCommands } from '../commands.js';
 import { HEX_SIZE } from '../estuarine/consts.js';
 import { CYNEFIN_H, CYNEFIN_W, cynefinBackgroundProps, ESTUARINE_MAP_H, ESTUARINE_MAP_W, estuarineHexagonBox, estuarineHexagonProps, estuarineMapProps, MAP_SCALE, } from '../presets.js';
@@ -37,7 +39,7 @@ function sticky(x, y, text) {
         roughness: 0,
         radius: 8,
         text: surfaceText(text),
-        color: '#1a1a1a',
+        color: NOTATION_NEUTRALS.ink,
         fontFamily: FontFamily.Inter,
         fontSize: 18,
         textAlign: TextAlign.Center,
@@ -72,53 +74,159 @@ function caption(cx, cy, str) {
     return {
         type: 'text',
         text: surfaceText(str),
-        color: '#1a1a1a',
+        color: NOTATION_NEUTRALS.ink,
         fontFamily: FontFamily.Inter,
         fontSize: 16,
         textAlign: TextAlign.Center,
         xywh: `[${x},${y},${CAPTION_W},${CAPTION_H}]`,
     };
 }
-/** A hand-composed template — what is left once the artefacts are derived. */
-function tpl(name, preview, elements) {
+/**
+ * The seeds the two hand-composed templates below write into the document:
+ * the "Decision sorting" board's four domain stickies, and the "Constraint
+ * map" board's three hexagon captions. Exported so `translations.ts` derives
+ * the manifest entries from the SAME constants rather than restating them.
+ */
+export const CYNEFIN_SEED_PROBE_LEARN = [
+    'com.labre.cynefin-estuarine.seed.probe-learn',
+    'Probe & learn',
+];
+export const CYNEFIN_SEED_EXPERT_ANALYSIS = [
+    'com.labre.cynefin-estuarine.seed.expert-analysis',
+    'Expert analysis',
+];
+export const CYNEFIN_SEED_ACT_NOW = [
+    'com.labre.cynefin-estuarine.seed.act-now',
+    'Act now',
+];
+export const CYNEFIN_SEED_KNOWN_ISSUE = [
+    'com.labre.cynefin-estuarine.seed.known-issue',
+    'Known issue',
+];
+export const ESTUARINE_SEED_POLICY = [
+    'com.labre.cynefin-estuarine.seed.policy',
+    'Policy',
+];
+export const ESTUARINE_SEED_HABIT = [
+    'com.labre.cynefin-estuarine.seed.habit',
+    'Habit',
+];
+export const ESTUARINE_SEED_BUDGET = [
+    'com.labre.cynefin-estuarine.seed.budget',
+    'Budget',
+];
+/** All seven, for `translations.ts`'s manifest contribution. */
+export const CYNEFIN_ESTUARINE_TEMPLATE_SEEDS = [
+    CYNEFIN_SEED_PROBE_LEARN,
+    CYNEFIN_SEED_EXPERT_ANALYSIS,
+    CYNEFIN_SEED_ACT_NOW,
+    CYNEFIN_SEED_KNOWN_ISSUE,
+    ESTUARINE_SEED_POLICY,
+    ESTUARINE_SEED_HABIT,
+    ESTUARINE_SEED_BUDGET,
+];
+/**
+ * The two Templates-panel tab names — new keys, since Cynefin and Estuarine
+ * share one senior-button key (`com.labre.framework.cynefin-estuarine`) that
+ * names neither individually (see `TemplateCategory.nameKey`). Both are proper
+ * nouns; the PO's French proposal for each is the identical word.
+ */
+export const CYNEFIN_TEMPLATE_CATEGORY_NAME = [
+    'com.labre.cynefin-estuarine.template.category.cynefin',
+    'Cynefin',
+];
+export const ESTUARINE_TEMPLATE_CATEGORY_NAME = [
+    'com.labre.cynefin-estuarine.template.category.estuarine',
+    'Estuarine',
+];
+/**
+ * The two Templates-panel tab names (chrome, not seeds — a widget-resolved
+ * label, never written into a document), for `translations.ts`'s manifest.
+ */
+export const CYNEFIN_ESTUARINE_TEMPLATE_CATEGORY_WORDINGS = [CYNEFIN_TEMPLATE_CATEGORY_NAME, ESTUARINE_TEMPLATE_CATEGORY_NAME];
+/**
+ * The two hand-composed templates' own tile names (`Template.nameKey`):
+ * chrome, resolved by the panel widget every time it opens, never written
+ * into a document — distinct from {@link CYNEFIN_ESTUARINE_TEMPLATE_SEEDS}
+ * above, which the templates WRITE.
+ */
+export const CYNEFIN_TEMPLATE_NAME_DECISION_SORTING = [
+    'com.labre.cynefin-estuarine.template.decision-sorting',
+    'Decision sorting',
+];
+export const ESTUARINE_TEMPLATE_NAME_CONSTRAINT_MAP = [
+    'com.labre.cynefin-estuarine.template.constraint-map',
+    'Constraint map',
+];
+/** Both tile names, for `translations.ts`'s manifest. */
+export const CYNEFIN_ESTUARINE_TEMPLATE_NAME_WORDINGS = [
+    CYNEFIN_TEMPLATE_NAME_DECISION_SORTING,
+    ESTUARINE_TEMPLATE_NAME_CONSTRAINT_MAP,
+];
+/** Resolve a wording through the host, or its English fallback with no host. */
+function tr(std, wording) {
+    return std ? translateKey(std, ...wording) : wording[1];
+}
+/**
+ * A hand-composed template — what is left once the artefacts are derived.
+ *
+ * The seeds a template writes into the document go through the translation
+ * seam at placement (ADR 0016); `content` stays the English build, and
+ * `localize` rebuilds the same snapshot with translated seeds.
+ */
+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),
     };
 }
 const ATTRS = 'width="100%" height="100%" viewBox="0 0 135 80" xmlns="http://www.w3.org/2000/svg"';
 export const cynefinTemplateCategory = {
     name: 'Cynefin',
+    nameKey: CYNEFIN_TEMPLATE_CATEGORY_NAME[0],
     templates: [
-        tpl('Decision sorting', `<svg ${ATTRS} fill="none"><rect x="8" y="10" width="119" height="60" rx="4" stroke="#2a9d99" stroke-width="1.5"/><path d="M67 10 V70 M8 40 H127" stroke="#9aa0a6"/><rect x="18" y="18" width="34" height="14" rx="2" fill="#fff3b0"/><rect x="83" y="18" width="34" height="14" rx="2" fill="#fff3b0"/><rect x="18" y="48" width="34" height="14" rx="2" fill="#fff3b0"/><rect x="83" y="48" width="34" height="14" rx="2" fill="#fff3b0"/></svg>`, {
+        tpl('Decision sorting', `<svg ${ATTRS} fill="none"><rect x="8" y="10" width="119" height="60" rx="4" stroke="#2a9d99" stroke-width="1.5"/><path d="M67 10 V70 M8 40 H127" stroke="${NOTATION_NEUTRALS.divider}"/><rect x="18" y="18" width="34" height="14" rx="2" fill="#fff3b0"/><rect x="83" y="18" width="34" height="14" rx="2" fill="#fff3b0"/><rect x="18" y="48" width="34" height="14" rx="2" fill="#fff3b0"/><rect x="83" y="48" width="34" height="14" rx="2" fill="#fff3b0"/></svg>`, std => ({
             bg: cynefinBackgroundProps({
                 xywh: `[0,0,${CYNEFIN_W},${CYNEFIN_H}]`,
             }),
-            s1: sticky(190, 175, 'Probe & learn'),
-            s2: sticky(690, 175, 'Expert analysis'),
-            s3: sticky(190, 505, 'Act now'),
-            s4: sticky(690, 505, 'Known issue'),
-        }),
-        templateFromCommand(byId('cynefin-estuarine.addCynefin'), `<svg ${ATTRS} fill="none"><rect x="14" y="12" width="107" height="56" rx="4" stroke="#2a9d99" stroke-width="1.6"/><path d="M67 12 V68 M14 40 H121" stroke="#9aa0a6"/></svg>`, 'Cynefin framework'),
+            s1: sticky(190, 175, tr(std, CYNEFIN_SEED_PROBE_LEARN)),
+            s2: sticky(690, 175, tr(std, CYNEFIN_SEED_EXPERT_ANALYSIS)),
+            s3: sticky(190, 505, tr(std, CYNEFIN_SEED_ACT_NOW)),
+            s4: sticky(690, 505, tr(std, CYNEFIN_SEED_KNOWN_ISSUE)),
+        }), CYNEFIN_TEMPLATE_NAME_DECISION_SORTING[0]),
+        // No name override: it would only restate `addCynefin`'s own
+        // `labelFallback` as a second literal the panel could not translate — see
+        // `resolveTemplateName`, which now reads the command's `labelKey` instead.
+        templateFromCommand(byId('cynefin-estuarine.addCynefin'), `<svg ${ATTRS} fill="none"><rect x="14" y="12" width="107" height="56" rx="4" stroke="#2a9d99" stroke-width="1.6"/><path d="M67 12 V68 M14 40 H121" stroke="${NOTATION_NEUTRALS.divider}"/></svg>`),
     ],
 };
 export const estuarineTemplateCategory = {
     name: 'Estuarine',
+    nameKey: ESTUARINE_TEMPLATE_CATEGORY_NAME[0],
     templates: [
-        tpl('Constraint map', `<svg ${ATTRS} fill="none"><path d="M20 12 V70 M20 70 H120" stroke="#941253" stroke-width="2"/><g fill="#34c724" stroke="#1f1f1f"><path d="M44 28 l6 4 l0 8 l-6 4 l-6 -4 l0 -8 z"/><path d="M74 40 l6 4 l0 8 l-6 4 l-6 -4 l0 -8 z"/><path d="M56 52 l6 4 l0 8 l-6 4 l-6 -4 l0 -8 z"/></g></svg>`, {
+        tpl('Constraint map', `<svg ${ATTRS} fill="none"><path d="M20 12 V70 M20 70 H120" stroke="#941253" stroke-width="2"/><g fill="#34c724" stroke="#1f1f1f"><path d="M44 28 l6 4 l0 8 l-6 4 l-6 -4 l0 -8 z"/><path d="M74 40 l6 4 l0 8 l-6 4 l-6 -4 l0 -8 z"/><path d="M56 52 l6 4 l0 8 l-6 4 l-6 -4 l0 -8 z"/></g></svg>`, std => ({
             bg: estuarineMapProps({
                 xywh: `[0,0,${ESTUARINE_MAP_W},${ESTUARINE_MAP_H}]`,
             }),
             h1: hexAt(210, 280),
-            c1: caption(210, 280, 'Policy'),
+            c1: caption(210, 280, tr(std, ESTUARINE_SEED_POLICY)),
             h2: hexAt(390, 420),
-            c2: caption(390, 420, 'Habit'),
+            c2: caption(390, 420, tr(std, ESTUARINE_SEED_HABIT)),
             h3: hexAt(290, 580),
-            c3: caption(290, 580, 'Budget'),
-        }),
-        templateFromCommand(byId('cynefin-estuarine.addEstuarineMap'), `<svg ${ATTRS} fill="none"><path d="M24 10 V70 M24 70 H120" stroke="#941253" stroke-width="2.4"/><path d="M30 52 q40 -30 84 -34" stroke="#5ecc44" stroke-width="2" fill="none"/></svg>`, 'Estuarine map'),
+            c3: caption(290, 580, tr(std, ESTUARINE_SEED_BUDGET)),
+        }), ESTUARINE_TEMPLATE_NAME_CONSTRAINT_MAP[0]),
+        // No name override: same reason as `addCynefin` above.
+        templateFromCommand(byId('cynefin-estuarine.addEstuarineMap'), `<svg ${ATTRS} fill="none"><path d="M24 10 V70 M24 70 H120" stroke="#941253" stroke-width="2.4"/><path d="M30 52 q40 -30 84 -34" stroke="#5ecc44" stroke-width="2" fill="none"/></svg>`),
+        // Kept, unlike the two overrides above: `addConstraintHexagon`'s own
+        // label is "Hexagon node" (the generic node-picker's wording), and this
+        // tile is specifically the CONSTRAINT preset of it — a name of its own,
+        // not a restatement. `resolveTemplateName` still resolves it through the
+        // command's `labelKey`, with THIS literal (not the command's) as the
+        // fallback, so the tile keeps its own English wording with no catalogue.
         templateFromCommand(byId('cynefin-estuarine.addConstraintHexagon'), `<svg ${ATTRS} fill="none"><path d="M67 24 l18 11 l0 22 l-18 11 l-18 -11 l0 -22 z" fill="#34c724" stroke="#1f1f1f" stroke-width="2"/></svg>`, 'Hexagon constraint'),
     ],
 };

package/dist/translations.js

@@ -1,8 +1,13 @@
 import { collectTranslationKeys, commandCategoryTranslationEntries, commandTranslationEntries, mergeTranslationEntries, } from '@formicoidea/labre-core/std';
 import { cynefinEstuarineCommands } from './commands.js';
+import { CYNEFIN_CANVAS_WORDINGS } from './cynefin/consts.js';
+import { CYNEFIN_TOOLBAR_WORDINGS } from './cynefin/toolbar/config.js';
+import { ESTUARINE_CANVAS_WORDINGS } from './estuarine/consts.js';
 import { ESTUARINE_NUDGES } from './estuarine/nudges.js';
 import { ESTUARINE_READING } from './estuarine/reading.js';
 import { ESTUARINE_ROLES } from './estuarine/roles.js';
+import { ESTUARINE_TOOLBAR_WORDINGS } from './estuarine/toolbar/config.js';
+import { CYNEFIN_ESTUARINE_TEMPLATE_CATEGORY_WORDINGS, CYNEFIN_ESTUARINE_TEMPLATE_NAME_WORDINGS, CYNEFIN_ESTUARINE_TEMPLATE_SEEDS, } from './templates/index.js';
 /**
  * THIS framework's contribution to the translation-key manifest.
  *
@@ -34,4 +39,41 @@ commandCategoryTranslationEntries(cynefinEstuarineCommands), collectTranslationK
 // This profile declares no relation, so today it contributes no key of its
 // own — walking it costs nothing and means the day it gains one the
 // manifest already names it.
-collectTranslationKeys('reading', ESTUARINE_READING));
+collectTranslationKeys('reading', ESTUARINE_READING), 
+// The seeds the two hand-composed templates write into the document
+// (`templates/index.ts`), resolved through `Template.localize` rather than
+// a creation action — no command draws these two scenes.
+CYNEFIN_ESTUARINE_TEMPLATE_SEEDS.map(([key, fallback]) => ({
+    key,
+    fallback,
+    source: 'seed',
+})), 
+// The Templates-panel tab names — chrome, resolved by the panel widget,
+// never written into a document.
+CYNEFIN_ESTUARINE_TEMPLATE_CATEGORY_WORDINGS.map(([key, fallback]) => ({
+    key,
+    fallback,
+    source: 'chrome',
+})), 
+// The two hand-composed templates' own tile names — chrome as well, and
+// distinct from the seeds they WRITE above.
+CYNEFIN_ESTUARINE_TEMPLATE_NAME_WORDINGS.map(([key, fallback]) => ({
+    key,
+    fallback,
+    source: 'chrome',
+})), 
+// The two frameworks' own toolbar tooltips.
+[...CYNEFIN_TOOLBAR_WORDINGS, ...ESTUARINE_TOOLBAR_WORDINGS].map(([key, fallback]) => ({ key, fallback, source: 'chrome' })), 
+// Every word the Cynefin frame's canvas renderer paints (headings,
+// decisions, annotations, markers) — fixed notation, not document seeds.
+CYNEFIN_CANVAS_WORDINGS.map(([key, fallback]) => ({
+    key,
+    fallback,
+    source: 'chrome',
+})), 
+// The Estuarine map's own three curve legends.
+ESTUARINE_CANVAS_WORDINGS.map(([key, fallback]) => ({
+    key,
+    fallback,
+    source: 'chrome',
+})));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-framework-cynefin",
   "description": "Labre cynefin-estuarine framework for @formicoidea/labre-core.",
-  "version": "0.39.3",
+  "version": "0.41.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -31,7 +31,7 @@
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.39.3",
+    "@formicoidea/labre-core": "0.41.0",
     "@preact/signals-core": "^1.8.0",
     "lit": "^3.2.0"
   }