@formicoidea/labre-framework-edgy 0.40.0 → 0.41.0

package/dist/actions.js

@@ -7,6 +7,7 @@ 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 { CROP_LABELED } from './consts.js';
+import { edgyElementLabel, edgyElementLabelKey } from './metamodel.js';
 import { LABEL_GAP, NODE_LABEL, nodeLabelKey, NODE_SIZE, NODE_STROKE, } from './node/consts.js';
 import { EDGY_LABEL_W, edgyLabelProps, edgyNodeProps, edgyNodeTextProps, FACETS_SCALE, } from './presets.js';
 import { EDGY_ROLE } from './roles.js';
@@ -46,6 +47,15 @@ export function createEdgyFacets(std) {
         // The frame: what makes this an EDGY board rather than three circles, and
         // what a finding is attributed to.
         role: EDGY_ROLE.facets,
+        // The three facet names, written HERE rather than left to the model's
+        // defaults (`EdgyFacetsElementModel.identityLabel` etc — a red-zone
+        // field: a document created before this key existed keeps its literal
+        // 'Identity' / 'Architecture' / 'Experience' verbatim). Shares its key
+        // with the very same words wherever the metamodel names a zone
+        // (`edgyElementLabelKey`, `templates/dynamic.ts`, `templates/index.ts`).
+        identityLabel: translateKey(std, edgyElementLabelKey('identity'), edgyElementLabel('identity')),
+        architectureLabel: translateKey(std, edgyElementLabelKey('architecture'), edgyElementLabel('architecture')),
+        experienceLabel: translateKey(std, edgyElementLabelKey('experience'), edgyElementLabel('experience')),
         xywh: new Bound(centerX - width / 2, centerY - height / 2, width, height).serialize(),
     });
     finish(gfx, id);
@@ -59,7 +69,15 @@ export async function createEdgyDynamic(std) {
     if (!gfx.surface)
         return;
     const job = createTemplateJob(std, 'template');
-    const bound = await job.insertTemplate(structuredClone(edgyDynamicTemplate.content));
+    // Resolved through `localize` rather than the raw `content`: this action IS
+    // the command the Templates panel derives "EDGY dynamic" from
+    // (`templates/dynamic.ts`), and inserting the English snapshot here would
+    // make the two paths disagree — a senior-menu insertion staying English
+    // while the very same card from the panel comes out translated.
+    const snapshot = edgyDynamicTemplate.localize
+        ? edgyDynamicTemplate.localize(std)
+        : edgyDynamicTemplate.content;
+    const bound = await job.insertTemplate(structuredClone(snapshot));
     if (bound) {
         const padding = 20 / gfx.viewport.zoom;
         gfx.viewport.setViewportByBound(bound, [padding, padding, padding, padding], true);

package/dist/legend.d.ts

@@ -1,2 +1,11 @@
 import { type AutoLegendSpec } from '@formicoidea/labre-ddd-shared';
+import { type ChromeWording } from '@formicoidea/labre-core/shared/services';
+/**
+ * The two section titles above that are this framework's OWN word rather than
+ * a role's — `titleKey` reuses a role's key where the section says a role's
+ * name (the facets, the intersections), but "Base elements" and "Relations"
+ * name a GROUPING of roles, so each mints a key of its own. For
+ * `translations.ts`'s manifest.
+ */
+export declare const EDGY_LEGEND_CHROME_WORDINGS: readonly ChromeWording[];
 export declare const EDGY_AUTO_LEGEND: AutoLegendSpec;

package/dist/legend.js

@@ -1,5 +1,6 @@
 import { roleLabel, } from '@formicoidea/labre-ddd-shared';
-import { EDGY_DYNAMIC_NODES, EDGY_ZONE_FILL, EDGY_ZONES, edgyElementLabel, } from './metamodel.js';
+import { BOARD_LEGEND_TITLE, } from '@formicoidea/labre-core/shared/services';
+import { EDGY_DYNAMIC_NODES, EDGY_ZONE_FILL, EDGY_ZONES, edgyElementLabel, edgyElementLabelKey, } from './metamodel.js';
 import { NODE_FILL, NODE_STROKE } from './node/consts.js';
 import { EDGY_ROLE, EDGY_ROLES } from './roles.js';
 /**
@@ -38,8 +39,14 @@ function zoneEntries(zone) {
         },
     }));
 }
+/**
+ * A facet's section title says the facet's own name, so it reuses the key the
+ * metamodel's seeds already carry (`edgyElementLabelKey`): the legend and the
+ * facets diagram say "Identity" with one key, not two.
+ */
 const FACET_SECTIONS = EDGY_ZONES.filter(zone => zone.group === 'facet').map(zone => ({
     title: edgyElementLabel(zone.id),
+    titleKey: edgyElementLabelKey(zone.id),
     entries: zoneEntries(zone.id),
 }));
 /**
@@ -49,6 +56,7 @@ const FACET_SECTIONS = EDGY_ZONES.filter(zone => zone.group === 'facet').map(zon
  */
 const INTERSECTIONS_SECTION = {
     title: 'Intersections',
+    titleKey: 'com.labre.edgy.seed.intersections-title',
     entries: EDGY_ZONES.filter(zone => zone.group === 'intersection').flatMap(zone => zoneEntries(zone.id)),
 };
 /**
@@ -66,6 +74,7 @@ const INTERSECTIONS_SECTION = {
  */
 const BASE_SECTION = {
     title: 'Base elements',
+    titleKey: 'com.labre.edgy.legend.section.base-elements',
     entries: ['people', 'outcome', 'object', 'activity'].map(kind => ({
         role: EDGY_ROLE[kind],
         exact: true,
@@ -85,6 +94,7 @@ const BASE_SECTION = {
  */
 const RELATIONS_SECTION = {
     title: 'Relations',
+    titleKey: 'com.labre.edgy.legend.section.relations',
     entries: [
         {
             role: EDGY_ROLE.relation,
@@ -97,8 +107,22 @@ const RELATIONS_SECTION = {
         },
     ],
 };
+/**
+ * The two section titles above that are this framework's OWN word rather than
+ * a role's — `titleKey` reuses a role's key where the section says a role's
+ * name (the facets, the intersections), but "Base elements" and "Relations"
+ * name a GROUPING of roles, so each mints a key of its own. For
+ * `translations.ts`'s manifest.
+ */
+export const EDGY_LEGEND_CHROME_WORDINGS = [
+    ['com.labre.edgy.legend.section.base-elements', 'Base elements'],
+    ['com.labre.edgy.legend.section.relations', 'Relations'],
+];
 export const EDGY_AUTO_LEGEND = {
-    title: 'Legend',
+    // The shared DDD auto-legend box's own generic chrome, resolved through
+    // the same key every board that has one reuses — see `AutoLegendSpec.title`.
+    title: BOARD_LEGEND_TITLE[1],
+    titleKey: BOARD_LEGEND_TITLE[0],
     roles: EDGY_ROLES,
     sections: [
         ...FACET_SECTIONS,

package/dist/metamodel.d.ts

@@ -87,6 +87,26 @@ export type EdgyElementName = 'content' | 'purpose' | 'organisation' | 'process'
  * prints as a row label or a section title. One expression, one wording.
  */
 export declare const edgyElementLabel: (name: EdgyElementName | EdgyZone) => string;
+/**
+ * The i18n key {@link edgyElementLabel} is the English default of — one key
+ * per lowercase name, shared by every surface that writes the word: the "EDGY
+ * dynamic" template (`templates/dynamic.ts`), the Facets overview,
+ * Organisation chart and Customer journey scenes (`templates/index.ts`), and
+ * the facets background's own creation site (`actions.ts`, `EdgyFacetsProps`).
+ * `organisation`, `brand` and `product` are BOTH an element name and an
+ * intersection zone id — one word, one key, exactly the "un mot partagé = une
+ * clé" rule.
+ */
+export declare const edgyElementLabelKey: (name: EdgyElementName | EdgyZone) => string;
+/**
+ * The i18n key one of the metamodel's 24 canonical VERBS is the English
+ * default of — drawn raw as a connector label wherever the "EDGY dynamic"
+ * template or a hand-composed scene uses it (`surfaceText(verb)`), sharing one
+ * key per distinct verb string across every surface that writes it.
+ */
+export declare const edgyVerbSeedKey: (verb: string) => string;
+/** Every distinct verb {@link EDGY_DYNAMIC_RELATIONS} carries, in table order. */
+export declare const EDGY_DYNAMIC_VERBS: readonly string[];
 export declare const EDGY_DYNAMIC_NODES: Record<EdgyElementName, {
     kind: 'outcome' | 'object' | 'activity';
     cx: number;

package/dist/metamodel.js

@@ -100,6 +100,28 @@ export const EDGY_DYNAMIC_RELATIONS = [
  * prints as a row label or a section title. One expression, one wording.
  */
 export const edgyElementLabel = (name) => name.charAt(0).toUpperCase() + name.slice(1);
+/**
+ * The i18n key {@link edgyElementLabel} is the English default of — one key
+ * per lowercase name, shared by every surface that writes the word: the "EDGY
+ * dynamic" template (`templates/dynamic.ts`), the Facets overview,
+ * Organisation chart and Customer journey scenes (`templates/index.ts`), and
+ * the facets background's own creation site (`actions.ts`, `EdgyFacetsProps`).
+ * `organisation`, `brand` and `product` are BOTH an element name and an
+ * intersection zone id — one word, one key, exactly the "un mot partagé = une
+ * clé" rule.
+ */
+export const edgyElementLabelKey = (name) => `com.labre.edgy.seed.${name}`;
+/**
+ * The i18n key one of the metamodel's 24 canonical VERBS is the English
+ * default of — drawn raw as a connector label wherever the "EDGY dynamic"
+ * template or a hand-composed scene uses it (`surfaceText(verb)`), sharing one
+ * key per distinct verb string across every surface that writes it.
+ */
+export const edgyVerbSeedKey = (verb) => `com.labre.edgy.seed.verb-${verb.replace(/\s+/g, '-')}`;
+/** Every distinct verb {@link EDGY_DYNAMIC_RELATIONS} carries, in table order. */
+export const EDGY_DYNAMIC_VERBS = [
+    ...new Set(EDGY_DYNAMIC_RELATIONS.map(([, , verb]) => verb)),
+];
 export const EDGY_DYNAMIC_NODES = {
     content: { kind: 'object', cx: 237.5, cy: 100, zone: 'identity' },
     purpose: { kind: 'outcome', cx: 282.5, cy: 100, zone: 'identity' },

package/dist/templates/dynamic.js

@@ -1,7 +1,8 @@
 import { makeTemplateSnapshot, surfaceText, } from '@formicoidea/labre-core/gfx/template';
 import { ConnectorMode, PointStyle, StrokeStyle } from '@formicoidea/labre-core/model';
+import { translateKey } from '@formicoidea/labre-core/shared/services';
 import { CROP } from '../consts.js';
-import { EDGY_DYNAMIC_NODES, EDGY_DYNAMIC_RELATIONS, EDGY_ZONE_FILL, edgyElementLabel, } from '../metamodel.js';
+import { EDGY_DYNAMIC_NODES, EDGY_DYNAMIC_RELATIONS, EDGY_ZONE_FILL, edgyElementLabel, edgyElementLabelKey, edgyVerbSeedKey, } from '../metamodel.js';
 import { NODE_SIZE, NODE_STROKE } from '../node/consts.js';
 import { edgyNodeProps, edgyNodeTextProps } from '../presets.js';
 import { EDGY_RELATION_LABEL_DISTANCE, edgyVerbLabelXYWH } from '../relation.js';
@@ -31,7 +32,15 @@ export const DYN_SCALE = 4.8;
 export function dynToModel(refX, refY) {
     return [(refX - CROP.x) * DYN_SCALE, (refY - CROP.y) * DYN_SCALE];
 }
-function dynamic() {
+/**
+ * One label's resolved text — the host's catalogue when `std` is a real
+ * inserting editor, the English fallback when building the module's own
+ * `content` (no editor exists yet at that point).
+ */
+function seedText(std, key, fallback) {
+    return std ? translateKey(std, key, fallback) : fallback;
+}
+function dynamic(std) {
     const out = {
         bg: {
             type: 'edgy',
@@ -48,7 +57,7 @@ function dynamic() {
         const nw = w ?? NODE_SIZE[kind].w;
         const nh = NODE_SIZE[kind].h;
         const [mx, my] = dynToModel(cx, cy);
-        const name = edgyElementLabel(key);
+        const name = seedText(std, edgyElementLabelKey(key), edgyElementLabel(key));
         out[key] = {
             // What an EDGY node IS — the same description the toolbox draws from.
             ...edgyNodeProps(kind, {
@@ -65,6 +74,7 @@ function dynamic() {
         };
     }
     EDGY_DYNAMIC_RELATIONS.forEach(([src, dst, verb, t], i) => {
+        const verbText = seedText(std, edgyVerbSeedKey(verb), verb);
         out[`rel${i}`] = {
             type: 'connector',
             mode: ConnectorMode.Straight,
@@ -84,7 +94,12 @@ function dynamic() {
             // re-centred on the path at the first layout, but the w/h ARE the label
             // box — size it to the verb so the text lays out on one line. The
             // distance slides the verb along the link like the reference diagram.
-            text: surfaceText(verb),
+            //
+            // The BOX (`edgyVerbLabelXYWH`) is still measured off the ENGLISH verb:
+            // it is layout, sized once from the table this template already reads,
+            // and a translated word longer than its English original wraps inside
+            // that box like any other native text rather than resizing it.
+            text: surfaceText(verbText),
             labelXYWH: edgyVerbLabelXYWH(verb),
             labelOffset: { distance: t ?? EDGY_RELATION_LABEL_DISTANCE },
         };
@@ -103,4 +118,5 @@ export const edgyDynamicTemplate = {
     // and fails the day the command is renamed.
     commandId: 'edgy.insertDynamic',
     content: makeTemplateSnapshot(dynamic(), NAME),
+    localize: std => makeTemplateSnapshot(dynamic(std), NAME),
 };

package/dist/templates/index.d.ts

@@ -1,4 +1,132 @@
 import { type TemplateCategory } from '@formicoidea/labre-core/gfx/template';
+import { type ChromeWording } from '@formicoidea/labre-core/shared/services';
+/**
+ * The four hand-composed scenes' own tile names — chrome, not seeds: a
+ * `Template.nameKey`, re-resolved every time the panel opens, never written
+ * into a document. None of the four derives from a command.
+ */
+export declare const EDGY_TEMPLATE_NAME_FACETS_OVERVIEW: ChromeWording;
+export declare const EDGY_TEMPLATE_NAME_CUSTOMER_JOURNEY: ChromeWording;
+export declare const EDGY_TEMPLATE_NAME_SERVICE_BLUEPRINT: ChromeWording;
+export declare const EDGY_TEMPLATE_NAME_ORGANISATION_CHART: ChromeWording;
+export declare const EDGY_TEMPLATE_SEED: {
+    readonly facetsTitle: {
+        key: string;
+        fallback: string;
+    };
+    readonly intersectionsTitle: {
+        key: string;
+        fallback: string;
+    };
+    readonly journeyStep: {
+        key: string;
+        fallback: string;
+    };
+    readonly channel: {
+        key: string;
+        fallback: string;
+    };
+    readonly taskN: {
+        key: string;
+        fallback: string;
+    };
+    readonly customer: {
+        key: string;
+        fallback: string;
+    };
+    readonly laneEvidence: {
+        key: string;
+        fallback: string;
+    };
+    readonly laneCustomerActions: {
+        key: string;
+        fallback: string;
+    };
+    readonly laneOnstage: {
+        key: string;
+        fallback: string;
+    };
+    readonly laneBackstage: {
+        key: string;
+        fallback: string;
+    };
+    readonly laneSupportProcesses: {
+        key: string;
+        fallback: string;
+    };
+    readonly laneSupportSystems: {
+        key: string;
+        fallback: string;
+    };
+    readonly admissionForm: {
+        key: string;
+        fallback: string;
+    };
+    readonly confirmation: {
+        key: string;
+        fallback: string;
+    };
+    readonly sendForm: {
+        key: string;
+        fallback: string;
+    };
+    readonly followStatus: {
+        key: string;
+        fallback: string;
+    };
+    readonly receiveDecision: {
+        key: string;
+        fallback: string;
+    };
+    readonly formHandling: {
+        key: string;
+        fallback: string;
+    };
+    readonly customerSupport: {
+        key: string;
+        fallback: string;
+    };
+    readonly contact: {
+        key: string;
+        fallback: string;
+    };
+    readonly customerService: {
+        key: string;
+        fallback: string;
+    };
+    readonly customerFollowUp: {
+        key: string;
+        fallback: string;
+    };
+    readonly processForm: {
+        key: string;
+        fallback: string;
+    };
+    readonly decisionAcceptReject: {
+        key: string;
+        fallback: string;
+    };
+    readonly crmApplication: {
+        key: string;
+        fallback: string;
+    };
+    readonly caseManagement: {
+        key: string;
+        fallback: string;
+    };
+    readonly paymentsSystem: {
+        key: string;
+        fallback: string;
+    };
+    readonly businessUnit: {
+        key: string;
+        fallback: string;
+    };
+    readonly group: {
+        key: string;
+        fallback: string;
+    };
+};
 /**
  * The metamodel itself — the 12 elements and the 24 relations — lives in
  * `../metamodel.ts`, and the template that draws it in `./dynamic.ts`.

package/dist/templates/index.js

@@ -1,10 +1,102 @@
 import { makeTemplateSnapshot, surfaceText, surfaceYMap, templateFromCommand, } from '@formicoidea/labre-core/gfx/template';
 import { ConnectorMode, FontFamily, PointStyle, ShapeStyle, StrokeStyle, TextAlign, } from '@formicoidea/labre-core/model';
 import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
+import { translateKey, } from '@formicoidea/labre-core/shared/services';
 import { edgyCommands } from '../commands.js';
+import { edgyElementLabel, edgyElementLabelKey, edgyVerbSeedKey, } from '../metamodel.js';
 import { NODE_FILL, NODE_STROKE, NODE_STROKE_WIDTH } from '../node/consts.js';
 import { edgyNodeProps, edgyNodeTextProps } from '../presets.js';
 import { edgyDynamicTemplate } from './dynamic.js';
+/**
+ * The seeds that belong to these four scenes only — a case name, a lane
+ * title, a step counter — and nowhere else in the framework. Declared once so
+ * the builders below and the manifest (`../translations.ts`) read the very
+ * same fallback. The twelve element/zone names and the two verbs these scenes
+ * REUSE (`Organisation`, `Task`, `traverses`…) go through
+ * `edgyElementLabelKey` / `edgyVerbSeedKey` instead — the same key the
+ * metamodel and `templates/dynamic.ts` already write, per "un mot partagé =
+ * une clé".
+ */
+const S = (slug, fallback) => ({
+    key: `com.labre.edgy.seed.${slug}`,
+    fallback,
+});
+/**
+ * The four hand-composed scenes' own tile names — chrome, not seeds: a
+ * `Template.nameKey`, re-resolved every time the panel opens, never written
+ * into a document. None of the four derives from a command.
+ */
+export const EDGY_TEMPLATE_NAME_FACETS_OVERVIEW = [
+    'com.labre.edgy.template.facets-overview',
+    'Facets overview',
+];
+export const EDGY_TEMPLATE_NAME_CUSTOMER_JOURNEY = [
+    'com.labre.edgy.template.customer-journey',
+    'Customer journey',
+];
+export const EDGY_TEMPLATE_NAME_SERVICE_BLUEPRINT = [
+    'com.labre.edgy.template.service-blueprint',
+    'Service blueprint',
+];
+export const EDGY_TEMPLATE_NAME_ORGANISATION_CHART = [
+    'com.labre.edgy.template.organisation-chart',
+    'Organisation chart',
+];
+export const EDGY_TEMPLATE_SEED = {
+    facetsTitle: S('facets-title', 'Facets'),
+    intersectionsTitle: S('intersections-title', 'Intersections'),
+    journeyStep: S('journey-step', 'Journey step {{n}}'),
+    channel: S('channel-n', 'Channel {{n}}'),
+    taskN: S('task-n', 'Task {{n}}'),
+    customer: S('customer', 'Customer'),
+    laneEvidence: S('lane-physical-evidence', 'Physical Evidence'),
+    laneCustomerActions: S('lane-customer-actions', 'Customer Actions'),
+    laneOnstage: S('lane-onstage-actions', 'On-stage Actions'),
+    laneBackstage: S('lane-backstage-actions', 'Back-stage Actions'),
+    laneSupportProcesses: S('lane-support-processes', 'Support Processes'),
+    laneSupportSystems: S('lane-support-systems', 'Support Systems'),
+    admissionForm: S('admission-form', 'Admission Form'),
+    confirmation: S('confirmation', 'Confirmation'),
+    sendForm: S('send-form', 'Send Form'),
+    followStatus: S('follow-status', 'Follow status'),
+    receiveDecision: S('receive-decision', 'Receive decision'),
+    formHandling: S('form-handling', 'Form handling'),
+    customerSupport: S('customer-support', 'Customer support'),
+    contact: S('contact', 'Contact'),
+    customerService: S('customer-service', 'Customer service'),
+    customerFollowUp: S('customer-follow-up', 'Customer follow-up'),
+    processForm: S('process-form', 'Process Form'),
+    decisionAcceptReject: S('decision-accept-reject', 'Decision [Accept|Reject]'),
+    crmApplication: S('crm-application', 'CRM Application'),
+    caseManagement: S('case-management', 'Case Management'),
+    paymentsSystem: S('payments-system', 'Payments System'),
+    businessUnit: S('business-unit', 'Business Unit {{unit}}'),
+    group: S('group', 'Group {{code}}'),
+};
+/**
+ * One seed's resolved text — the host's catalogue when `std` is a real
+ * inserting editor, the English fallback when building the module's own
+ * `content` (no editor exists yet at that point).
+ */
+function seedText(std, def, params) {
+    return std
+        ? translateKey(std, def.key, def.fallback, params)
+        : // No interpolation library at module load: every fallback with a
+            // placeholder is filled by hand here, the same way `translateKey`
+            // fills it internally when a host has no entry for the key.
+            Object.entries(params ?? {}).reduce((text, [name, value]) => text.replace(`{{${name}}}`, String(value)), def.fallback);
+}
+/** One of the twelve element/zone names, shared with the rest of the framework. */
+function elementLabel(std, name) {
+    return seedText(std, {
+        key: edgyElementLabelKey(name),
+        fallback: edgyElementLabel(name),
+    });
+}
+/** One of the metamodel's verbs, shared with `templates/dynamic.ts`. */
+function verbLabel(std, verb) {
+    return seedText(std, { key: edgyVerbSeedKey(verb), fallback: verb });
+}
 /**
  * The EDGY palette — DERIVED from the toolbox, one template per command.
  *
@@ -147,8 +239,9 @@ function attach(src, dst, opts = {}) {
     };
 }
 // ── Facets overview (six facets, sub-cards, facets/intersections) ─────
-function facetsOverview() {
+function facetsOverview(std) {
     const out = {};
+    const el = (name) => elementLabel(std, name);
     const tall = (key, x, name, cards) => {
         const [hdr, sub] = C[key];
         out[`${key}F`] = rect(x, 140, 192, 460, {
@@ -200,39 +293,55 @@ function facetsOverview() {
         });
     };
     // lower facets first (drawn behind the tall ones at the overlaps)
-    low('organisation', 240, 'Organisation');
-    low('product', 664, 'Product');
-    low('brand', 1088, 'Brand');
-    tall('identity', 40, 'Identity', ['Purpose', 'Content', 'Story']);
-    tall('architecture', 464, 'Architecture', ['Capability', 'Asset', 'Process']);
-    tall('experience', 888, 'Experience', ['Task', 'Channel', 'Journey']);
-    out.fLabel = label(464, 80, 192, 28, 'Facets', { fontSize: 18 });
+    low('organisation', 240, el('organisation'));
+    low('product', 664, el('product'));
+    low('brand', 1088, el('brand'));
+    tall('identity', 40, el('identity'), [
+        el('purpose'),
+        el('content'),
+        el('story'),
+    ]);
+    tall('architecture', 464, el('architecture'), [
+        el('capability'),
+        el('asset'),
+        el('process'),
+    ]);
+    tall('experience', 888, el('experience'), [
+        el('task'),
+        el('channel'),
+        el('journey'),
+    ]);
+    out.fLabel = label(464, 80, 192, 28, seedText(std, EDGY_TEMPLATE_SEED.facetsTitle), { fontSize: 18 });
     out.fBar = line(136, 120, 984, 120);
-    out.iLabel = label(664, 740, 192, 28, 'Intersections', { fontSize: 18 });
+    out.iLabel = label(664, 740, 192, 28, seedText(std, EDGY_TEMPLATE_SEED.intersectionsTitle), { fontSize: 18 });
     out.iBar = line(336, 728, 1184, 728);
     return out;
 }
 // ── Customer journey ──────────────────────────────────────────────────
-function journey() {
+function journey(std) {
     const step = (i, x) => enode('activity', x, 132, 224, 116, {
         fill: JOURNEY_PINK,
-        text: `Journey step ${i}`,
+        text: seedText(std, EDGY_TEMPLATE_SEED.journeyStep, { n: i }),
         textColor: '#ffffff',
         fontSize: 18,
     });
     const ch = (x, n) => enode('object', x, 392, 184, 96, {
         fill: JOURNEY_PINK,
-        text: `Channel ${n}`,
+        text: seedText(std, EDGY_TEMPLATE_SEED.channel, { n }),
         fontSize: 16,
     });
     const tk = (x, n) => enode('object', x, 540, 168, 92, {
         fill: JOURNEY_PINK,
-        text: `Task ${n}`,
+        text: seedText(std, EDGY_TEMPLATE_SEED.taskN, { n }),
         fontSize: 16,
     });
+    const traverses = verbLabel(std, 'traverses');
+    const uses = verbLabel(std, 'uses');
     return {
         cust: enode('people', 40, 120, 64, 64, { fill: NODE_FILL }),
-        custL: label(20, 192, 104, 24, 'Customer', { fontSize: 14 }),
+        custL: label(20, 192, 104, 24, seedText(std, EDGY_TEMPLATE_SEED.customer), {
+            fontSize: 14,
+        }),
         // The person and its name travel together, as `createEdgyPeople` writes
         // them. A group is placed AFTER its members: the id middleware remaps
         // `children` against elements it has already seen.
@@ -255,7 +364,7 @@ function journey() {
             roughness: 0,
             xywh: '[150,108,860,164]',
         },
-        bandL: label(170, 116, 120, 24, 'Journey', {
+        bandL: label(170, 116, 120, 24, elementLabel(std, 'journey'), {
             color: '#ffffff',
             fontSize: 16,
             align: TextAlign.Left,
@@ -264,7 +373,7 @@ function journey() {
         s2: step(2, 500),
         s3: step(3, 760),
         rightTask: enode('object', 1060, 132, 168, 92, {
-            text: 'Task',
+            text: elementLabel(std, 'task'),
             fontSize: 16,
         }),
         c1: ch(258, 'X'),
@@ -273,27 +382,27 @@ function journey() {
         t1: tk(266, 'A'),
         t2: tk(526, 'B'),
         t3: tk(786, 'C'),
-        trav1: label(258, 350, 184, 20, 'traverses', {
+        trav1: label(258, 350, 184, 20, traverses, {
             fontSize: 13,
             color: NOTATION_NEUTRALS.label,
         }),
-        trav2: label(518, 350, 184, 20, 'traverses', {
+        trav2: label(518, 350, 184, 20, traverses, {
             fontSize: 13,
             color: NOTATION_NEUTRALS.label,
         }),
-        trav3: label(778, 350, 184, 20, 'traverses', {
+        trav3: label(778, 350, 184, 20, traverses, {
             fontSize: 13,
             color: NOTATION_NEUTRALS.label,
         }),
-        use1: label(258, 504, 184, 20, 'uses', {
+        use1: label(258, 504, 184, 20, uses, {
             fontSize: 13,
             color: NOTATION_NEUTRALS.label,
         }),
-        use2: label(518, 504, 184, 20, 'uses', {
+        use2: label(518, 504, 184, 20, uses, {
             fontSize: 13,
             color: NOTATION_NEUTRALS.label,
         }),
-        use3: label(778, 504, 184, 20, 'uses', {
+        use3: label(778, 504, 184, 20, uses, {
             fontSize: 13,
             color: NOTATION_NEUTRALS.label,
         }),
@@ -306,14 +415,14 @@ function journey() {
     };
 }
 // ── Service blueprint (six swimlanes) ─────────────────────────────────
-function blueprint() {
+function blueprint(std) {
     const lanes = [
-        'Physical Evidence',
-        'Customer Actions',
-        'On-stage Actions',
-        'Back-stage Actions',
-        'Support Processes',
-        'Support Systems',
+        seedText(std, EDGY_TEMPLATE_SEED.laneEvidence),
+        seedText(std, EDGY_TEMPLATE_SEED.laneCustomerActions),
+        seedText(std, EDGY_TEMPLATE_SEED.laneOnstage),
+        seedText(std, EDGY_TEMPLATE_SEED.laneBackstage),
+        seedText(std, EDGY_TEMPLATE_SEED.laneSupportProcesses),
+        seedText(std, EDGY_TEMPLATE_SEED.laneSupportSystems),
     ];
     const laneFill = [
         '#fdeef2',
@@ -340,21 +449,25 @@ function blueprint() {
     const box = (x, y, fill, t) => enode('object', x, y, 200, 60, { fill, text: t, fontSize: 14 });
     const P = C.experience[1], B = C.architecture[1];
     Object.assign(out, {
-        af: rect(280, 64, 220, 70, { text: 'Admission Form' }),
-        cf: rect(1010, 64, 220, 70, { text: 'Confirmation' }),
-        sf: chev(280, 214, P, 'Send Form'),
-        fs: chev(600, 214, P, 'Follow status'),
-        rd: chev(1010, 214, P, 'Receive decision'),
-        fh: chev(280, 364, B, 'Form handling'),
-        cs: chev(600, 364, B, 'Customer support'),
-        ct: chev(1010, 364, B, 'Contact'),
-        csv: chev(280, 514, B, 'Customer service'),
-        cfu: box(1010, 514, B, 'Customer follow-up'),
-        pf: chev(600, 664, B, 'Process Form'),
-        dec: chev(900, 664, B, 'Decision [Accept|Reject]'),
-        crm: box(280, 814, B, 'CRM Application'),
-        cms: box(600, 814, B, 'Case Management'),
-        pay: box(900, 814, B, 'Payments System'),
+        af: rect(280, 64, 220, 70, {
+            text: seedText(std, EDGY_TEMPLATE_SEED.admissionForm),
+        }),
+        cf: rect(1010, 64, 220, 70, {
+            text: seedText(std, EDGY_TEMPLATE_SEED.confirmation),
+        }),
+        sf: chev(280, 214, P, seedText(std, EDGY_TEMPLATE_SEED.sendForm)),
+        fs: chev(600, 214, P, seedText(std, EDGY_TEMPLATE_SEED.followStatus)),
+        rd: chev(1010, 214, P, seedText(std, EDGY_TEMPLATE_SEED.receiveDecision)),
+        fh: chev(280, 364, B, seedText(std, EDGY_TEMPLATE_SEED.formHandling)),
+        cs: chev(600, 364, B, seedText(std, EDGY_TEMPLATE_SEED.customerSupport)),
+        ct: chev(1010, 364, B, seedText(std, EDGY_TEMPLATE_SEED.contact)),
+        csv: chev(280, 514, B, seedText(std, EDGY_TEMPLATE_SEED.customerService)),
+        cfu: box(1010, 514, B, seedText(std, EDGY_TEMPLATE_SEED.customerFollowUp)),
+        pf: chev(600, 664, B, seedText(std, EDGY_TEMPLATE_SEED.processForm)),
+        dec: chev(900, 664, B, seedText(std, EDGY_TEMPLATE_SEED.decisionAcceptReject)),
+        crm: box(280, 814, B, seedText(std, EDGY_TEMPLATE_SEED.crmApplication)),
+        cms: box(600, 814, B, seedText(std, EDGY_TEMPLATE_SEED.caseManagement)),
+        pay: box(900, 814, B, seedText(std, EDGY_TEMPLATE_SEED.paymentsSystem)),
         a1: attach('af', 'sf', { arrow: true }),
         a2: attach('sf', 'fs', { arrow: true }),
         a3: attach('fs', 'rd', { arrow: true }),
@@ -367,17 +480,19 @@ function blueprint() {
     return out;
 }
 // ── Organisation chart ────────────────────────────────────────────────
-function orgChart() {
+function orgChart(std) {
     const cyan = C.organisation[0];
     const u = (x, y, w, t) => enode('object', x, y, w, 64, { fill: cyan, text: t, fontSize: 16 });
+    const businessUnit = (unit) => seedText(std, EDGY_TEMPLATE_SEED.businessUnit, { unit });
+    const group = (code) => seedText(std, EDGY_TEMPLATE_SEED.group, { code });
     return {
-        org: u(420, 40, 180, 'Organisation'),
-        a: u(120, 200, 200, 'Business Unit A'),
-        b: u(410, 200, 200, 'Business Unit B'),
-        c: u(700, 200, 200, 'Business Unit C'),
-        a1: u(60, 360, 170, 'Group A-1'),
-        a2: u(260, 360, 170, 'Group A-2'),
-        c1: u(715, 360, 170, 'Group C-1'),
+        org: u(420, 40, 180, elementLabel(std, 'organisation')),
+        a: u(120, 200, 200, businessUnit('A')),
+        b: u(410, 200, 200, businessUnit('B')),
+        c: u(700, 200, 200, businessUnit('C')),
+        a1: u(60, 360, 170, group('A-1')),
+        a2: u(260, 360, 170, group('A-2')),
+        c1: u(715, 360, 170, group('C-1')),
         // Attached orthogonal connectors: the router draws the org-chart elbows
         // and the links follow when units are moved around.
         e1: attach('org', 'a', { mode: ConnectorMode.Orthogonal }),
@@ -397,26 +512,46 @@ function orgChart() {
 export { EDGY_DYNAMIC_NODES, EDGY_DYNAMIC_RELATIONS, } from '../metamodel.js';
 export { DYN_SCALE, dynToModel, edgyDynamicTemplate } from './dynamic.js';
 const ATTRS = 'width="100%" height="100%" viewBox="0 0 135 80" xmlns="http://www.w3.org/2000/svg"';
-/** A hand-composed template — what is left once the artefacts are derived. */
-function tpl(name, preview, elements) {
+/**
+ * A hand-composed template — what is left once the artefacts are derived.
+ *
+ * `build` takes the OPTIONAL inserting editor: called with none, at module
+ * load, for the English `content`; called again with the real `std` as
+ * {@link Template.localize}, so the two builds read the very same layout and
+ * differ only in the words a seed resolves to (`docs/adr/0016`).
+ */
+function tpl(name, preview, build, nameKey) {
     return {
         name,
         type: 'template',
         preview,
-        content: makeTemplateSnapshot(elements, name),
+        nameKey,
+        content: makeTemplateSnapshot(build(), name),
+        localize: std => makeTemplateSnapshot(build(std), name),
     };
 }
 export const edgyTemplateCategory = {
     name: 'EDGY',
+    // Reuses the senior button's own key — see `TemplateCategory.nameKey`.
+    nameKey: 'com.labre.framework.edgy',
     templates: [
-        tpl('Facets overview', `<svg ${ATTRS} fill="none"><rect x="6" y="20" width="18" height="46" rx="3" fill="#1ec873"/><rect x="46" y="20" width="18" height="46" rx="3" fill="#2f6ff0"/><rect x="86" y="20" width="18" height="46" rx="3" fill="#f5246e"/><rect x="26" y="30" width="18" height="40" rx="3" fill="#4fd0ea"/><rect x="66" y="30" width="18" height="40" rx="3" fill="#cf8cff"/><rect x="106" y="30" width="18" height="40" rx="3" fill="#eeba51"/></svg>`, facetsOverview()),
-        tpl('Customer journey', `<svg ${ATTRS} fill="none"><path d="M20 24 H110 L122 40 L110 56 H20 Z" fill="#f3a3c0"/><rect x="26" y="30" width="22" height="20" fill="none" stroke="#fff"/><rect x="54" y="30" width="22" height="20" fill="none" stroke="#fff"/><rect x="82" y="30" width="22" height="20" fill="none" stroke="#fff"/></svg>`, journey()),
-        tpl('Service blueprint', `<svg ${ATTRS} fill="none"><rect x="8" y="14" width="119" height="16" fill="#fbd5e0"/><rect x="8" y="32" width="119" height="34" fill="#d4e9f8"/><rect x="20" y="18" width="22" height="9" fill="#f5246e" opacity="0.5"/><rect x="20" y="40" width="22" height="9" fill="#2f6ff0" opacity="0.4"/><rect x="60" y="40" width="22" height="9" fill="#2f6ff0" opacity="0.4"/></svg>`, blueprint()),
-        tpl('Organisation chart', `<svg ${ATTRS} fill="none"><rect x="52" y="12" width="32" height="14" rx="2" fill="#4fd0ea"/><rect x="14" y="38" width="32" height="14" rx="2" fill="#4fd0ea"/><rect x="52" y="38" width="32" height="14" rx="2" fill="#4fd0ea"/><rect x="90" y="38" width="32" height="14" rx="2" fill="#4fd0ea"/><path d="M68 26 V32 M30 32 H106 M30 32 V38 M68 32 V38 M106 32 V38" stroke="${NODE_STROKE}"/></svg>`, orgChart()),
+        tpl('Facets overview', `<svg ${ATTRS} fill="none"><rect x="6" y="20" width="18" height="46" rx="3" fill="#1ec873"/><rect x="46" y="20" width="18" height="46" rx="3" fill="#2f6ff0"/><rect x="86" y="20" width="18" height="46" rx="3" fill="#f5246e"/><rect x="26" y="30" width="18" height="40" rx="3" fill="#4fd0ea"/><rect x="66" y="30" width="18" height="40" rx="3" fill="#cf8cff"/><rect x="106" y="30" width="18" height="40" rx="3" fill="#eeba51"/></svg>`, facetsOverview, EDGY_TEMPLATE_NAME_FACETS_OVERVIEW[0]),
+        tpl('Customer journey', `<svg ${ATTRS} fill="none"><path d="M20 24 H110 L122 40 L110 56 H20 Z" fill="#f3a3c0"/><rect x="26" y="30" width="22" height="20" fill="none" stroke="#fff"/><rect x="54" y="30" width="22" height="20" fill="none" stroke="#fff"/><rect x="82" y="30" width="22" height="20" fill="none" stroke="#fff"/></svg>`, journey, EDGY_TEMPLATE_NAME_CUSTOMER_JOURNEY[0]),
+        tpl('Service blueprint', `<svg ${ATTRS} fill="none"><rect x="8" y="14" width="119" height="16" fill="#fbd5e0"/><rect x="8" y="32" width="119" height="34" fill="#d4e9f8"/><rect x="20" y="18" width="22" height="9" fill="#f5246e" opacity="0.5"/><rect x="20" y="40" width="22" height="9" fill="#2f6ff0" opacity="0.4"/><rect x="60" y="40" width="22" height="9" fill="#2f6ff0" opacity="0.4"/></svg>`, blueprint, EDGY_TEMPLATE_NAME_SERVICE_BLUEPRINT[0]),
+        tpl('Organisation chart', `<svg ${ATTRS} fill="none"><rect x="52" y="12" width="32" height="14" rx="2" fill="#4fd0ea"/><rect x="14" y="38" width="32" height="14" rx="2" fill="#4fd0ea"/><rect x="52" y="38" width="32" height="14" rx="2" fill="#4fd0ea"/><rect x="90" y="38" width="32" height="14" rx="2" fill="#4fd0ea"/><path d="M68 26 V32 M30 32 H106 M30 32 V38 M68 32 V38 M106 32 V38" stroke="${NODE_STROKE}"/></svg>`, orgChart, EDGY_TEMPLATE_NAME_ORGANISATION_CHART[0]),
+        // Kept: `addFacets`'s own label is "Enterprise Design facets" (the senior
+        // sub-menu's wording), and this tile's tooltip has always said the
+        // shorter "Facets diagram". `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('edgy.addFacets'), `<svg ${ATTRS}><circle cx="55" cy="34" r="18" fill="#00ea4e" opacity="0.9"/><circle cx="80" cy="34" r="18" fill="#034cee" opacity="0.9"/><circle cx="67" cy="54" r="18" fill="#ff0056" opacity="0.9"/></svg>`, 'Facets diagram'),
         edgyDynamicTemplate,
         // The blank board had no template at all until the palette was derived —
         // the coverage test is what said so.
+        //
+        // Kept, same reason as `addFacets` above: `addBoard`'s own label spells
+        // out "(hover spotlight)", which this tile's tooltip never has.
         templateFromCommand(byId('edgy.addBoard'), `<svg ${ATTRS} fill="none"><rect x="8" y="9" width="119" height="62" rx="8" fill="${NOTATION_NEUTRALS.cardFill}" stroke="${NOTATION_NEUTRALS.cardBorder}" stroke-width="2"/><path d="M52 30 H84 M53 31 L66 58 M83 31 L70 58" stroke="${NODE_STROKE}" stroke-width="1.4"/><rect x="48" y="26" width="9" height="9" fill="#00ea4e"/><circle cx="84" cy="30" r="4.5" fill="#034cee"/><path d="M61 54 h8 l4 4 -4 4 h-8 z" fill="#ff0056"/></svg>`, 'EDGY board'),
         templateFromCommand(byId('edgy.addPeople'), `<svg ${ATTRS} fill="${NODE_STROKE}"><circle cx="67" cy="32" r="9" fill="none" stroke="${NODE_STROKE}" stroke-width="2.4"/><path d="M50 60 a17 17 0 0 1 34 0" fill="none" stroke="${NODE_STROKE}" stroke-width="2.4"/></svg>`),
         templateFromCommand(byId('edgy.addOutcome'), `<svg ${ATTRS} fill="none"><rect x="20" y="24" width="95" height="34" rx="6" stroke="${NODE_STROKE}" stroke-width="2"/></svg>`),

package/dist/toolbar/config.d.ts

@@ -1,5 +1,7 @@
 import { type ChromeWording, type ToolbarContext } from '@formicoidea/labre-core/shared/services';
 import { type TemplateResult } from 'lit';
+/** Every wording above, for `translations.ts`'s manifest contribution. */
+export declare const EDGY_TOOLBAR_WORDINGS: readonly ChromeWording[];
 export declare const edgyToolbarConfig: {
     readonly actions: [{
         id: string;

package/dist/toolbar/config.js

@@ -5,6 +5,20 @@ import { BOARD_LEGEND_NOTATION, BOARD_RESIZE_TOGGLE, TelemetryProvider, ToolbarM
 import { BlockFlavourIdentifier } from '@formicoidea/labre-core/std';
 import { html } from 'lit';
 import { EDGY_AUTO_LEGEND } from '../legend.js';
+/** The two toolbar tooltips this file used to hard-code as English literals. */
+const FACET_LABELS_TOGGLE = [
+    'com.labre.edgy.toolbar.facet-labels',
+    'Show / hide facet labels',
+];
+const HOVER_SPOTLIGHT_TOGGLE = [
+    'com.labre.edgy.toolbar.hover-spotlight',
+    'Enable / disable hover spotlight',
+];
+/** Every wording above, for `translations.ts`'s manifest contribution. */
+export const EDGY_TOOLBAR_WORDINGS = [
+    FACET_LABELS_TOGGLE,
+    HOVER_SPOTLIGHT_TOGGLE,
+];
 const ResizeIcon = html `<svg
   width="24"
   height="24"
@@ -118,7 +132,7 @@ function legendAction(Model, id) {
 export const edgyToolbarConfig = {
     actions: [
         booleanToggle(EdgyFacetsElementModel, 'a.toggle-resize', BOARD_RESIZE_TOGGLE, ResizeIcon, 'resizeEnabled'),
-        booleanToggle(EdgyFacetsElementModel, 'b.toggle-labels', 'Show / hide facet labels', LabelsIcon, 'showLabels'),
+        booleanToggle(EdgyFacetsElementModel, 'b.toggle-labels', FACET_LABELS_TOGGLE, LabelsIcon, 'showLabels'),
         // No spotlight toggle here: the hover spotlight is BOARD logic and lives on
         // the EDGY board toolbar below. The Venn only carries APPEARANCE (#195).
         legendAction(EdgyFacetsElementModel, 'c.legend'),
@@ -132,7 +146,7 @@ export const edgyToolbarExtension = ToolbarModuleExtension({
 export const edgyBoardToolbarConfig = {
     actions: [
         booleanToggle(EdgyBoardElementModel, 'a.toggle-resize', BOARD_RESIZE_TOGGLE, ResizeIcon, 'resizeEnabled'),
-        booleanToggle(EdgyBoardElementModel, 'b.toggle-spotlight', 'Enable / disable hover spotlight', SpotlightIcon, 'spotlightEnabled'),
+        booleanToggle(EdgyBoardElementModel, 'b.toggle-spotlight', HOVER_SPOTLIGHT_TOGGLE, SpotlightIcon, 'spotlightEnabled'),
         legendAction(EdgyBoardElementModel, 'c.legend'),
     ],
     when: ctx => ctx.getSurfaceModelsByType(EdgyBoardElementModel).length > 0,

package/dist/toolbar/node-config.d.ts

@@ -1 +1,26 @@
+import { type ChromeWording } from '@formicoidea/labre-core/shared/services';
+/**
+ * The twelve EDGY swatches' own names, resolved by `resolvePaletteLabel`
+ * (`@labre/affine-components/color-picker`) through each swatch's own
+ * {@link NamedPalette.labelWording} — see Wardley's own
+ * `WARDLEY_PALETTE_WORDINGS` (`../../wardley/src/toolbar/node-config.ts`)
+ * for the same mechanism applied to a sibling framework; the two never
+ * import each other.
+ *
+ * Exported so `../translations.ts` can list them in the manifest under
+ * source `chrome`.
+ */
+export declare const EDGY_PALETTE_WORDING_IDENTITY: ChromeWording;
+export declare const EDGY_PALETTE_WORDING_ARCHITECTURE: ChromeWording;
+export declare const EDGY_PALETTE_WORDING_EXPERIENCE: ChromeWording;
+export declare const EDGY_PALETTE_WORDING_ORGANISATION: ChromeWording;
+export declare const EDGY_PALETTE_WORDING_BRAND: ChromeWording;
+export declare const EDGY_PALETTE_WORDING_PRODUCT: ChromeWording;
+export declare const EDGY_PALETTE_WORDING_IDENTITY_LIGHT: ChromeWording;
+export declare const EDGY_PALETTE_WORDING_ARCHITECTURE_LIGHT: ChromeWording;
+export declare const EDGY_PALETTE_WORDING_EXPERIENCE_LIGHT: ChromeWording;
+export declare const EDGY_PALETTE_WORDING_ORGANISATION_LIGHT: ChromeWording;
+export declare const EDGY_PALETTE_WORDING_BRAND_LIGHT: ChromeWording;
+export declare const EDGY_PALETTE_WORDING_PRODUCT_LIGHT: ChromeWording;
+export declare const EDGY_PALETTE_WORDINGS: readonly ChromeWording[];
 export declare const edgyNodeToolbarExtension: import("@formicoidea/labre-core/store").ExtensionType;

package/dist/toolbar/node-config.js

@@ -1,31 +1,151 @@
 import { neutralPalettes, paletteColorAction, shapeToolbarConfig, } from '@formicoidea/labre-core/gfx/shape';
 import { ToolbarModuleExtension, } from '@formicoidea/labre-core/shared/services';
 import { BlockFlavourIdentifier } from '@formicoidea/labre-core/std';
+/**
+ * The twelve EDGY swatches' own names, resolved by `resolvePaletteLabel`
+ * (`@labre/affine-components/color-picker`) through each swatch's own
+ * {@link NamedPalette.labelWording} — see Wardley's own
+ * `WARDLEY_PALETTE_WORDINGS` (`../../wardley/src/toolbar/node-config.ts`)
+ * for the same mechanism applied to a sibling framework; the two never
+ * import each other.
+ *
+ * Exported so `../translations.ts` can list them in the manifest under
+ * source `chrome`.
+ */
+export const EDGY_PALETTE_WORDING_IDENTITY = [
+    'com.labre.edgy.palette.identity',
+    'Identity',
+];
+export const EDGY_PALETTE_WORDING_ARCHITECTURE = [
+    'com.labre.edgy.palette.architecture',
+    'Architecture',
+];
+export const EDGY_PALETTE_WORDING_EXPERIENCE = [
+    'com.labre.edgy.palette.experience',
+    'Experience',
+];
+export const EDGY_PALETTE_WORDING_ORGANISATION = [
+    'com.labre.edgy.palette.organisation',
+    'Organisation',
+];
+export const EDGY_PALETTE_WORDING_BRAND = [
+    'com.labre.edgy.palette.brand',
+    'Brand',
+];
+export const EDGY_PALETTE_WORDING_PRODUCT = [
+    'com.labre.edgy.palette.product',
+    'Product',
+];
+export const EDGY_PALETTE_WORDING_IDENTITY_LIGHT = [
+    'com.labre.edgy.palette.identity-light',
+    'Identity light',
+];
+export const EDGY_PALETTE_WORDING_ARCHITECTURE_LIGHT = [
+    'com.labre.edgy.palette.architecture-light',
+    'Architecture light',
+];
+export const EDGY_PALETTE_WORDING_EXPERIENCE_LIGHT = [
+    'com.labre.edgy.palette.experience-light',
+    'Experience light',
+];
+export const EDGY_PALETTE_WORDING_ORGANISATION_LIGHT = [
+    'com.labre.edgy.palette.organisation-light',
+    'Organisation light',
+];
+export const EDGY_PALETTE_WORDING_BRAND_LIGHT = [
+    'com.labre.edgy.palette.brand-light',
+    'Brand light',
+];
+export const EDGY_PALETTE_WORDING_PRODUCT_LIGHT = [
+    'com.labre.edgy.palette.product-light',
+    'Product light',
+];
+export const EDGY_PALETTE_WORDINGS = [
+    EDGY_PALETTE_WORDING_IDENTITY,
+    EDGY_PALETTE_WORDING_ARCHITECTURE,
+    EDGY_PALETTE_WORDING_EXPERIENCE,
+    EDGY_PALETTE_WORDING_ORGANISATION,
+    EDGY_PALETTE_WORDING_BRAND,
+    EDGY_PALETTE_WORDING_PRODUCT,
+    EDGY_PALETTE_WORDING_IDENTITY_LIGHT,
+    EDGY_PALETTE_WORDING_ARCHITECTURE_LIGHT,
+    EDGY_PALETTE_WORDING_EXPERIENCE_LIGHT,
+    EDGY_PALETTE_WORDING_ORGANISATION_LIGHT,
+    EDGY_PALETTE_WORDING_BRAND_LIGHT,
+    EDGY_PALETTE_WORDING_PRODUCT_LIGHT,
+];
 /**
  * The typical EDGY palette, surfaced as ready-made swatches in the EDGY node
  * color picker (facet + intersection colours, saturated then pastel), followed
  * by the default editor palette.
  */
 const EDGY_PALETTES = [
-    { key: 'Identity', value: '#00ea4e' },
-    { key: 'Architecture', value: '#034cee' },
-    { key: 'Experience', value: '#ff0056' },
-    { key: 'Organisation', value: '#00caf4' },
-    { key: 'Brand', value: '#ffa500' },
-    { key: 'Product', value: '#cf00ff' },
-    { key: 'Identity light', value: '#80ffb7' },
-    { key: 'Architecture light', value: '#a6c0ff' },
-    { key: 'Experience light', value: '#ff99bd' },
-    { key: 'Organisation light', value: '#80eaff' },
-    { key: 'Brand light', value: '#ffd580' },
-    { key: 'Product light', value: '#e599ff' },
+    {
+        key: 'Identity',
+        value: '#00ea4e',
+        labelWording: EDGY_PALETTE_WORDING_IDENTITY,
+    },
+    {
+        key: 'Architecture',
+        value: '#034cee',
+        labelWording: EDGY_PALETTE_WORDING_ARCHITECTURE,
+    },
+    {
+        key: 'Experience',
+        value: '#ff0056',
+        labelWording: EDGY_PALETTE_WORDING_EXPERIENCE,
+    },
+    {
+        key: 'Organisation',
+        value: '#00caf4',
+        labelWording: EDGY_PALETTE_WORDING_ORGANISATION,
+    },
+    { key: 'Brand', value: '#ffa500', labelWording: EDGY_PALETTE_WORDING_BRAND },
+    {
+        key: 'Product',
+        value: '#cf00ff',
+        labelWording: EDGY_PALETTE_WORDING_PRODUCT,
+    },
+    {
+        key: 'Identity light',
+        value: '#80ffb7',
+        labelWording: EDGY_PALETTE_WORDING_IDENTITY_LIGHT,
+    },
+    {
+        key: 'Architecture light',
+        value: '#a6c0ff',
+        labelWording: EDGY_PALETTE_WORDING_ARCHITECTURE_LIGHT,
+    },
+    {
+        key: 'Experience light',
+        value: '#ff99bd',
+        labelWording: EDGY_PALETTE_WORDING_EXPERIENCE_LIGHT,
+    },
+    {
+        key: 'Organisation light',
+        value: '#80eaff',
+        labelWording: EDGY_PALETTE_WORDING_ORGANISATION_LIGHT,
+    },
+    {
+        key: 'Brand light',
+        value: '#ffd580',
+        labelWording: EDGY_PALETTE_WORDING_BRAND_LIGHT,
+    },
+    {
+        key: 'Product light',
+        value: '#e599ff',
+        labelWording: EDGY_PALETTE_WORDING_PRODUCT_LIGHT,
+    },
 ];
 /**
  * From the default editor palette we keep ONLY the neutrals (greys, white,
  * black, transparent) — the historical colours are dropped in favour of the
  * EDGY swatches above.
  */
-const EDGY_PALETTE_LIST = [...EDGY_PALETTES, ...neutralPalettes()];
+const EDGY_PALETTE_LIST = [
+    ...EDGY_PALETTES,
+    ...neutralPalettes(),
+];
 /**
  * EDGY fill / stroke colour picker — identical to the shape one but seeded with
  * the EDGY palette swatches (`.palettes`).

package/dist/translations.js

@@ -1,11 +1,84 @@
 import { collectTranslationKeys, commandCategoryTranslationEntries, commandTranslationEntries, mergeTranslationEntries, } from '@formicoidea/labre-core/std';
 import { edgyCommands } from './commands.js';
+import { EDGY_LEGEND_CHROME_WORDINGS } from './legend.js';
+import { EDGY_DYNAMIC_NODES, EDGY_DYNAMIC_VERBS, EDGY_ZONES, edgyElementLabel, edgyElementLabelKey, edgyVerbSeedKey, } from './metamodel.js';
 import { NODE_LABEL, nodeLabelKey } from './node/consts.js';
 import { EDGY_NUDGES } from './nudges.js';
 import { EDGY_PROFILES } from './profiles.js';
 import { EDGY_READING } from './reading.js';
 import { EDGY_ROLES } from './roles.js';
 import { EDGY_RULES } from './rules.js';
+import { EDGY_TEMPLATE_NAME_CUSTOMER_JOURNEY, EDGY_TEMPLATE_NAME_FACETS_OVERVIEW, EDGY_TEMPLATE_NAME_ORGANISATION_CHART, EDGY_TEMPLATE_NAME_SERVICE_BLUEPRINT, EDGY_TEMPLATE_SEED, } from './templates/index.js';
+import { EDGY_TOOLBAR_WORDINGS } from './toolbar/config.js';
+import { EDGY_PALETTE_WORDINGS } from './toolbar/node-config.js';
+/**
+ * The name every one of the 12 official elements and the 6 Venn zones is
+ * seeded with — one key per distinct lowercase word (`organisation`, `brand`
+ * and `product` name BOTH an element and an intersection zone, so the same
+ * key covers both), reused verbatim by `templates/dynamic.ts`,
+ * `templates/index.ts` and the facets background's own creation site
+ * (`actions.ts`).
+ */
+const elementAndZoneSeedEntries = () => {
+    const names = new Set([
+        ...Object.keys(EDGY_DYNAMIC_NODES),
+        ...EDGY_ZONES.map(zone => zone.id),
+    ]);
+    return [...names].map(name => ({
+        key: edgyElementLabelKey(name),
+        fallback: edgyElementLabel(name),
+        source: 'seed',
+    }));
+};
+/** The legend's own section titles (see {@link EDGY_LEGEND_CHROME_WORDINGS}). */
+const legendChromeEntries = () => EDGY_LEGEND_CHROME_WORDINGS.map(([key, fallback]) => ({
+    key,
+    fallback,
+    source: 'chrome',
+}));
+/** The toolbar tooltips this framework used to hard-code as English literals. */
+const toolbarChromeEntries = () => EDGY_TOOLBAR_WORDINGS.map(([key, fallback]) => ({
+    key,
+    fallback,
+    source: 'chrome',
+}));
+/**
+ * The twelve node-colour-picker swatches' own names
+ * (`EDGY_PALETTE_WORDINGS`, `toolbar/node-config.ts`) — chrome, re-rendered
+ * on every locale switch, never seeded into a document.
+ */
+const paletteWordingEntries = () => EDGY_PALETTE_WORDINGS.map(([key, fallback]) => ({
+    key,
+    fallback,
+    source: 'chrome',
+}));
+/** The metamodel's 24 canonical verbs, drawn raw as a connector label. */
+const verbSeedEntries = () => EDGY_DYNAMIC_VERBS.map(verb => ({
+    key: edgyVerbSeedKey(verb),
+    fallback: verb,
+    source: 'seed',
+}));
+/**
+ * The seeds that belong to the four hand-composed scenes only (a lane title,
+ * a case name, a step counter…) — derived from `EDGY_TEMPLATE_SEED`, the very
+ * table the scenes read at placement.
+ */
+const sceneSeedEntries = () => Object.values(EDGY_TEMPLATE_SEED).map(({ key, fallback }) => ({
+    key,
+    fallback,
+    source: 'seed',
+}));
+/**
+ * The four hand-composed scenes' own tile names — chrome, not seeds: a
+ * `Template.nameKey`, re-resolved every time the panel opens, never written
+ * into a document. None of the four derives from a command.
+ */
+const templateNameEntries = () => [
+    EDGY_TEMPLATE_NAME_FACETS_OVERVIEW,
+    EDGY_TEMPLATE_NAME_CUSTOMER_JOURNEY,
+    EDGY_TEMPLATE_NAME_SERVICE_BLUEPRINT,
+    EDGY_TEMPLATE_NAME_ORGANISATION_CHART,
+].map(([key, fallback]) => ({ key, fallback, source: 'chrome' }));
 /**
  * THIS framework's contribution to the translation-key manifest — every
  * `com.labre.*` key EDGY can hand to `TranslationProvider.t`, derived from the
@@ -42,7 +115,7 @@ Object.entries(NODE_LABEL).map(([kind, label]) => ({
     key: nodeLabelKey(kind),
     fallback: label,
     source: 'seed',
-})), 
+})), elementAndZoneSeedEntries(), verbSeedEntries(), sceneSeedEntries(), templateNameEntries(), legendChromeEntries(), toolbarChromeEntries(), paletteWordingEntries(), 
 // LAST, and the order is load-bearing: a reading profile carries the
 // framework's own `roles`, so walking it reaches every role key the line
 // above already named. `mergeTranslationEntries` keeps the FIRST

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-framework-edgy",
   "description": "Labre edgy framework for @formicoidea/labre-core.",
-  "version": "0.40.0",
+  "version": "0.41.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -31,8 +31,8 @@
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.40.0",
-    "@formicoidea/labre-ddd-shared": "0.40.0",
+    "@formicoidea/labre-core": "0.41.0",
+    "@formicoidea/labre-ddd-shared": "0.41.0",
     "@preact/signals-core": "^1.8.0",
     "lit": "^3.2.0",
     "yjs": "^13.6.21"