@formicoidea/labre-framework-cynefin 0.40.0 → 0.42.0

package/dist/cynefin/labels.js

@@ -0,0 +1,40 @@
+import { backgroundTextHitBox } from '@formicoidea/labre-core/blocks/surface';
+import { refScale } from '../utils.js';
+import { DOMAINS, HEADING_SIZE, REF_H, REF_W } from './consts.js';
+/**
+ * What a domain heading SAYS: the user's own word, else the vocabulary.
+ *
+ * The very precedence `backgroundLabelText` applies to a declared background —
+ * user text wins over the catalogue, the catalogue over the shipped English —
+ * spelled out here because this diagram has no declaration to apply it for it.
+ * An empty string is a real answer (the user erased the word), which is why the
+ * test is against `undefined` and not against falsiness.
+ */
+export function cynefinHeadingText(model, block, translate) {
+    const own = model[block.prop];
+    return own === undefined || own === null
+        ? translate(block.heading)
+        : String(own);
+}
+/**
+ * Clickable boxes of the four domain headings, in ELEMENT-LOCAL coordinates.
+ *
+ * Built from the same reference positions and the same uniform letterbox fit
+ * the renderer draws them with, so the target tracks the word at any size, and
+ * empty while the headings are hidden — a label that is not painted may not be
+ * aimed at either.
+ */
+export function cynefinLabelHits(model, w, h, translate) {
+    if (!model.showTitles)
+        return [];
+    const { s, ox, oy } = refScale(w, h, REF_W, REF_H);
+    return DOMAINS.map(block => {
+        const text = cynefinHeadingText(model, block, translate);
+        return {
+            id: block.prop,
+            prop: block.prop,
+            text,
+            ...backgroundTextHitBox(text, HEADING_SIZE * s, ox + block.x * s, oy + block.hy * s),
+        };
+    });
+}

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,42 @@ 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;
-/** Uppercase legends: anchored centre, alphabetic baseline, with letter-spacing. */
+/** 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.
+ *
+ * `prop` names the model key a double-click renames the legend into (issue
+ * #355), and `visibleProp` the toggle that shows it — the legend is painted
+ * with its curve and hidden with it, so it is aimable exactly when it is drawn.
+ *
+ * The three legends and nothing else: the italic `e` / `t` axis letters are
+ * notation, not words (PO decision, and the reason they carry no i18n key
+ * either), so they are not renamable.
+ */
 export declare const LABELS: {
     readonly counterfactual: {
-        readonly text: "COUNTER FACTUAL";
+        readonly wording: ChromeWording;
+        readonly prop: "counterfactualLabel";
+        readonly visibleProp: "showCounterfactual";
         readonly x: 422;
         readonly y: 25;
         readonly size: 20;
         readonly color: "#1a1a1a";
     };
     readonly liminal: {
-        readonly text: "LIMINAL";
+        readonly wording: ChromeWording;
+        readonly prop: "liminalLabel";
+        readonly visibleProp: "showLiminal";
         readonly x: 316;
         readonly y: 192;
         readonly size: 18;
         readonly color: "#2e7d32";
     };
     readonly volatile: {
-        readonly text: "VOLATILE";
+        readonly wording: ChromeWording;
+        readonly prop: "volatileLabel";
+        readonly visibleProp: "showVolatile";
         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,58 @@ 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;
-/** Uppercase legends: anchored centre, alphabetic baseline, with letter-spacing. */
+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.
+ *
+ * `prop` names the model key a double-click renames the legend into (issue
+ * #355), and `visibleProp` the toggle that shows it — the legend is painted
+ * with its curve and hidden with it, so it is aimable exactly when it is drawn.
+ *
+ * The three legends and nothing else: the italic `e` / `t` axis letters are
+ * notation, not words (PO decision, and the reason they carry no i18n key
+ * either), so they are not renamable.
+ */
 export const LABELS = {
     counterfactual: {
-        text: 'COUNTER FACTUAL',
+        wording: LABEL_COUNTERFACTUAL,
+        prop: 'counterfactualLabel',
+        visibleProp: 'showCounterfactual',
         x: 422,
         y: 25,
         size: 20,
         color: COLORS.label,
     },
     liminal: {
-        text: 'LIMINAL',
+        wording: LABEL_LIMINAL,
+        prop: 'liminalLabel',
+        visibleProp: 'showLiminal',
         x: 316,
         y: 192,
         size: 18,
         color: COLORS.liminalLabel,
     },
     volatile: {
-        text: 'VOLATILE',
+        wording: LABEL_VOLATILE,
+        prop: 'volatileLabel',
+        visibleProp: 'showVolatile',
         x: 219,
         y: 783,
         size: 20,

package/dist/estuarine/element-renderer.js

@@ -1,6 +1,8 @@
-import { ElementRendererExtension, } from '@formicoidea/labre-core/blocks/surface';
+import { ElementRendererExtension, taggedPath2D, } 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';
+import { estuarineLegendText } from './labels.js';
 /**
  * The three reference curves are drawn as a permanent GHOST (PO arbitration,
  * 26/08/2026): dashed, translucent, never solid again.
@@ -39,21 +41,21 @@ export function estuarineCurves() {
     return (_curves ??= [
         {
             key: 'liminal',
-            path: new Path2D(LIMINAL_PATH),
+            path: taggedPath2D(LIMINAL_PATH),
             color: COLORS.liminal,
             width: LIMINAL_WIDTH,
             visibleProp: 'showLiminal',
         },
         {
             key: 'volatile',
-            path: new Path2D(VOLATILE_PATH),
+            path: taggedPath2D(VOLATILE_PATH),
             color: COLORS.volatile,
             width: VOLATILE_WIDTH,
             visibleProp: 'showVolatile',
         },
         {
             key: 'counterfactual',
-            path: new Path2D(COUNTERFACTUAL_PATH),
+            path: taggedPath2D(COUNTERFACTUAL_PATH),
             color: COLORS.counterfactual,
             width: COUNTERFACTUAL_WIDTH,
             visibleProp: 'showCounterfactual',
@@ -99,7 +101,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;
@@ -144,7 +147,8 @@ export const estuarine = (model, ctx, matrix) => {
     // Uppercase legend (centre-anchored, alphabetic baseline, letter-spaced).
     // Anchored proportionally, typed isotropically — never inside the stretch.
     const hasSpacing = 'letterSpacing' in ctx;
-    const legend = (l) => {
+    const legend = (key) => {
+        const l = LABELS[key];
         ctx.fillStyle = l.color;
         ctx.font = `600 ${l.size * fit.strokeScale}px ${FONT_FAMILY}`;
         ctx.textAlign = 'center';
@@ -152,7 +156,9 @@ 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));
+        // The user's own word when they have renamed this legend, the catalogue's
+        // otherwise — the same precedence a declared background applies.
+        ctx.fillText(estuarineLegendText(model, key, tr), ax(l.x), ay(l.y));
         if (hasSpacing)
             ctx.letterSpacing = '0px';
     };
@@ -171,7 +177,7 @@ export const estuarine = (model, ctx, matrix) => {
         ctx.setLineDash([...GHOST_DASH]);
         ctx.stroke(curve.path);
         ctx.restore();
-        legend(LABELS[curve.key]);
+        legend(curve.key);
     }
     // ── Italic e / t axis letters ───────────────────────────────────────
     if (model.showAxisLabels) {

package/dist/estuarine/element-view.d.ts

@@ -1,11 +1,19 @@
+import type { EditableBackgroundLabel } from '@formicoidea/labre-core/blocks/surface';
+import { FrameworkBackgroundView } from '@formicoidea/labre-core/blocks/surface';
 import type { EstuarineElementModel } from '@formicoidea/labre-core/model';
-import { GfxElementModelView } from '@formicoidea/labre-core/std/gfx';
 /**
  * View for the Estuarine background. Registering it ensures `gfx.view.get(model)`
  * returns a view (required so move / select interactions work).
+ *
+ * Extends {@link FrameworkBackgroundView} rather than
+ * `DeclaredBackgroundView`: the map is a reproduction of the official SVG with
+ * a stretch of its own and no `FrameworkBackgroundDef` behind it, so it says
+ * where its three legends are through the very fit the renderer anchors them
+ * with. The gesture itself is the shared one (issue #355).
  */
-export declare class EstuarineView extends GfxElementModelView<EstuarineElementModel> {
+export declare class EstuarineView extends FrameworkBackgroundView<EstuarineElementModel> {
     static type: string;
+    protected labelAt(lx: number, ly: number, w: number, h: number): EditableBackgroundLabel | null;
 }
 /**
  * Resize gating: the resize handles are hidden unless `model.resizeEnabled` is

package/dist/estuarine/element-view.js

@@ -1,10 +1,25 @@
-import { GfxElementModelView, GfxViewInteractionExtension, } from '@formicoidea/labre-core/std/gfx';
+import { FrameworkBackgroundView, hitTestBackgroundLabel, } from '@formicoidea/labre-core/blocks/surface';
+import { translateKey, } from '@formicoidea/labre-core/shared/services';
+import { GfxViewInteractionExtension } from '@formicoidea/labre-core/std/gfx';
+import { estuarineFit } from './element-renderer.js';
+import { estuarineLabelHits } from './labels.js';
 /**
  * View for the Estuarine background. Registering it ensures `gfx.view.get(model)`
  * returns a view (required so move / select interactions work).
+ *
+ * Extends {@link FrameworkBackgroundView} rather than
+ * `DeclaredBackgroundView`: the map is a reproduction of the official SVG with
+ * a stretch of its own and no `FrameworkBackgroundDef` behind it, so it says
+ * where its three legends are through the very fit the renderer anchors them
+ * with. The gesture itself is the shared one (issue #355).
  */
-export class EstuarineView extends GfxElementModelView {
+export class EstuarineView extends FrameworkBackgroundView {
     static { this.type = 'estuarine'; }
+    labelAt(lx, ly, w, h) {
+        const translate = (wording) => translateKey(this.gfx.std, ...wording);
+        const hit = hitTestBackgroundLabel(estuarineLabelHits(this.model, estuarineFit(w, h), translate), lx, ly);
+        return hit ? { prop: hit.prop, text: hit.text } : null;
+    }
 }
 /**
  * Resize gating: the resize handles are hidden unless `model.resizeEnabled` is

package/dist/estuarine/labels.d.ts

@@ -0,0 +1,39 @@
+import type { BackgroundLabelHit } from '@formicoidea/labre-core/blocks/surface';
+import type { EstuarineElementModel } from '@formicoidea/labre-core/model';
+import type { ChromeWording } from '@formicoidea/labre-core/shared/services';
+import { LABELS } from './consts.js';
+/** Resolves a wording against the host's catalogue, or falls back to English. */
+export type EstuarineWordingResolver = (wording: ChromeWording) => string;
+/** The three curve legends, in the order the renderer paints them. */
+export type EstuarineLegendKey = keyof typeof LABELS;
+/**
+ * Only the factors the legends need out of `EstuarineFit`.
+ *
+ * Taken as a parameter rather than imported: the fit is computed in
+ * `./element-renderer.ts`, which reads this module to know what a legend says,
+ * and a module cycle to save two fields would be a poor trade.
+ */
+export interface EstuarineLegendFit {
+    sx: number;
+    sy: number;
+    /** The one undeformed factor — type is never stretched. */
+    strokeScale: number;
+}
+/**
+ * What a legend SAYS: the user's own word, else the vocabulary.
+ *
+ * The very precedence `backgroundLabelText` applies to a declared background —
+ * user text wins over the catalogue, the catalogue over the shipped English —
+ * spelled out here because this map has no declaration to apply it for it. An
+ * empty string is a real answer (the user erased the word), which is why the
+ * test is against `undefined` and not against falsiness.
+ */
+export declare function estuarineLegendText(model: EstuarineElementModel, key: EstuarineLegendKey, translate: EstuarineWordingResolver): string;
+/**
+ * Clickable boxes of the visible legends, in ELEMENT-LOCAL coordinates.
+ *
+ * Anchored through the same fit the renderer anchors them with: proportionally
+ * in both directions, typed isotropically. A legend whose curve is switched off
+ * is not painted and is therefore not aimable either.
+ */
+export declare function estuarineLabelHits(model: EstuarineElementModel, fit: EstuarineLegendFit, translate: EstuarineWordingResolver): BackgroundLabelHit[];

package/dist/estuarine/labels.js

@@ -0,0 +1,49 @@
+import { backgroundTextHitBox } from '@formicoidea/labre-core/blocks/surface';
+import { LABEL_LETTER_SPACING, LABELS } from './consts.js';
+/**
+ * What a legend SAYS: the user's own word, else the vocabulary.
+ *
+ * The very precedence `backgroundLabelText` applies to a declared background —
+ * user text wins over the catalogue, the catalogue over the shipped English —
+ * spelled out here because this map has no declaration to apply it for it. An
+ * empty string is a real answer (the user erased the word), which is why the
+ * test is against `undefined` and not against falsiness.
+ */
+export function estuarineLegendText(model, key, translate) {
+    const label = LABELS[key];
+    const own = model[label.prop];
+    return own === undefined || own === null
+        ? translate(label.wording)
+        : String(own);
+}
+/**
+ * Clickable boxes of the visible legends, in ELEMENT-LOCAL coordinates.
+ *
+ * Anchored through the same fit the renderer anchors them with: proportionally
+ * in both directions, typed isotropically. A legend whose curve is switched off
+ * is not painted and is therefore not aimable either.
+ */
+export function estuarineLabelHits(model, fit, translate) {
+    const props = model;
+    const hits = [];
+    for (const key of Object.keys(LABELS)) {
+        const label = LABELS[key];
+        if (!props[label.visibleProp])
+            continue;
+        const text = estuarineLegendText(model, key, translate);
+        const box = backgroundTextHitBox(text, label.size * fit.strokeScale, label.x * fit.sx, label.y * fit.sy, 'center');
+        // A legend is letter-spaced, so it is wider than the shared estimate: half
+        // of the extra width on each side, since the word is centred on its anchor.
+        const spread = (Math.max(text.length - 1, 0) * LABEL_LETTER_SPACING * fit.strokeScale) /
+            2;
+        hits.push({
+            id: key,
+            prop: label.prop,
+            text,
+            ...box,
+            minX: box.minX - spread,
+            maxX: box.maxX + spread,
+        });
+    }
+    return hits;
+}

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;