@formicoidea/labre-framework-c4 0.40.0 → 0.41.0

package/dist/actions.js

@@ -7,12 +7,12 @@ import { downloadBlob } from '@formicoidea/labre-core/shared/utils';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
 import { GfxControllerIdentifier, } from '@formicoidea/labre-core/std/gfx';
 import { c4TierBoxes } from './component.js';
-import { BOARD_REF_HEIGHT, BOARD_REF_WIDTH, BOUNDARY_LABEL, BOUNDARY_REF_HEIGHT, BOUNDARY_REF_WIDTH, DESCRIPTION_FONT_SIZE, DESCRIPTION_PLACEHOLDER, NODE_LABEL, NODE_PALETTE, NODE_SIZE, RELATIONSHIP_STROKE, RELATIONSHIP_WIDTH, TITLE_FONT_SIZE, TYPE_FONT_SIZE, } from './consts.js';
+import { BOARD_REF_HEIGHT, BOARD_REF_WIDTH, BOUNDARY_LABEL, boundaryLabelKey, BOUNDARY_REF_HEIGHT, BOUNDARY_REF_WIDTH, DESCRIPTION_FONT_SIZE, DESCRIPTION_PLACEHOLDER, DESCRIPTION_PLACEHOLDER_KEY, NODE_LABEL, nodeLabelKey, NODE_PALETTE, NODE_SIZE, RELATIONSHIP_STROKE, RELATIONSHIP_WIDTH, TITLE_FONT_SIZE, TYPE_FONT_SIZE, } from './consts.js';
 import { C4_MERMAID_EXPORT, c4BoardFrom, c4SafeFilename } from './interchange.js';
 import { C4_AUTO_LEGEND } from './legend.js';
 import { c4NodeProps } from './presets.js';
 import { C4_BOUNDARY_ROLE, C4_ROLE, c4BoardRoleKey } from './roles.js';
-import { C4_TYPE_PLACEHOLDER } from './type-line.js';
+import { c4TypePlaceholder } from './type-line.js';
 /**
  * Standalone creation/activation actions for the C4 toolbox — the same shape
  * BPMN's `actions.ts` has, and for the same reason: the menu is a pure renderer
@@ -126,13 +126,34 @@ export function createC4Node(std, kind) {
     const boxes = c4TierBoxes(kind, x, y, w, h);
     const titleId = addTier(surface, gfx.layer.generateIndex(), C4_ROLE.title, 
     // The kind's own label — `Person`, `Web app`. A name and a prompt at once,
-    // which is why the exporter writes it through unchanged.
-    NODE_LABEL[kind], TITLE_FONT_SIZE, 
+    // which is why the exporter writes it through unchanged. Resolved HERE,
+    // once, exactly like a BPMN node's caption (`nodeLabelKey`): content from
+    // the moment it lands, so a component drawn in a translated host starts in
+    // that language.
+    translateKey(std, nodeLabelKey(kind), NODE_LABEL[kind]), TITLE_FONT_SIZE, 
     // The one tier with weight on it: it is the heading of the box, and at 20px
     // against a 16px sentence the size alone does not carry that.
     FontWeight.SemiBold, paint.text, boxes.title);
-    const typeLineId = addTier(surface, gfx.layer.generateIndex(), C4_ROLE['type-line'], C4_TYPE_PLACEHOLDER[kind], TYPE_FONT_SIZE, FontWeight.Regular, paint.text, boxes.typeLine);
-    const descriptionId = addTier(surface, gfx.layer.generateIndex(), C4_ROLE.description, DESCRIPTION_PLACEHOLDER, DESCRIPTION_FONT_SIZE, FontWeight.Regular, paint.text, boxes.description);
+    const typeLineId = addTier(surface, gfx.layer.generateIndex(), C4_ROLE['type-line'], 
+    // Resolved at placement, like the title above: `c4TypePlaceholder` reads
+    // through the host's catalogue for both halves of the prompt (the
+    // bracketed word AND the technology slot), and `C4TypeLineWatcher`
+    // (`node/type-line-watcher.ts`) now recomputes the canonical line the same
+    // way on every edit commit, so a translated seed here is no longer
+    // reverted to English the first time an author opens and closes the
+    // tier's editor without typing anything. `technologyOfTypeLine` and
+    // `c4StatedTechnology` (`component.ts`) recognise EITHER the English
+    // literal or the host's own resolved word (`type-line.ts`).
+    c4TypePlaceholder(kind, std), TYPE_FONT_SIZE, FontWeight.Regular, paint.text, boxes.typeLine);
+    const descriptionId = addTier(surface, gfx.layer.generateIndex(), C4_ROLE.description, 
+    // Resolved at placement like the title above. `c4StatedDescription`
+    // (`component.ts`) still compares the stored text against the ENGLISH
+    // `DESCRIPTION_PLACEHOLDER` to read "nothing stated yet" — this lot's own
+    // French proposal for this key is the identical word ('description'), so
+    // the shipped catalogue keeps that comparison true; a host catalogue that
+    // chose a different wording would regain the same residual risk the type
+    // line carries permanently (see `notes`).
+    translateKey(std, DESCRIPTION_PLACEHOLDER_KEY, DESCRIPTION_PLACEHOLDER), DESCRIPTION_FONT_SIZE, FontWeight.Regular, paint.text, boxes.description);
     const groupId = surface.addElement({
         type: 'group',
         index: gfx.layer.generateIndex(),
@@ -209,7 +230,10 @@ export function createC4Boundary(std, variant) {
         // role of a boundary drawn before the split and of nothing this editor
         // creates. See the note above.
         role: C4_BOUNDARY_ROLE[variant],
-        name: BOUNDARY_LABEL[variant],
+        // Resolved HERE, once — the boundary's name is exported verbatim
+        // (`export.ts`) with no placeholder comparison, so it is as safe to
+        // translate as a component's title.
+        name: translateKey(std, boundaryLabelKey(variant), BOUNDARY_LABEL[variant]),
         variant,
         xywh: new Bound(cx - BOUNDARY_REF_WIDTH / 2, cy - BOUNDARY_REF_HEIGHT / 2, BOUNDARY_REF_WIDTH, BOUNDARY_REF_HEIGHT).serialize(),
     });

package/dist/consts.d.ts

@@ -246,6 +246,22 @@ export declare const NODE_SIZE: Record<C4NodeKind, {
  * nothing at all: the words are the artefact.
  */
 export declare const NODE_LABEL: Record<C4NodeKind, string>;
+/**
+ * The i18n key {@link NODE_LABEL} is the English default of — mirrors BPMN's
+ * {@link nodeLabelKey} exactly, one package over: resolved at placement
+ * (`createC4Node`, the NAME tier) and never afterwards, since the title is
+ * content from the moment it lands and an author is free to retype it.
+ *
+ * Safe to translate where the type line is not: the exporter reads a
+ * component's NAME verbatim (`c4StatedName`) with no placeholder suppression,
+ * so nothing downstream compares this text against the English literal.
+ */
+export declare const nodeLabelKey: (kind: C4NodeKind) => string;
+/**
+ * The prompt a fresh description tier carries, resolved at placement exactly
+ * like {@link DESCRIPTION_PLACEHOLDER} below is the English default of.
+ */
+export declare const DESCRIPTION_PLACEHOLDER_KEY = "com.labre.c4.seed.description-placeholder";
 export declare const FONT_FAMILY = "Inter, sans-serif";
 /**
  * The card — the same white every framework background paints, framed and
@@ -336,6 +352,14 @@ export declare const BOUNDARY_MARGIN = 12;
  * on the canvas keeps its words whatever its variant.
  */
 export declare const BOUNDARY_LABEL: Record<C4BoundaryVariant, string>;
+/**
+ * The i18n key {@link BOUNDARY_LABEL} is the English default of — resolved at
+ * placement (`createC4Boundary`) exactly like {@link nodeLabelKey}: the name
+ * is exported verbatim (`export.ts`, `boundary.name`) with no comparison
+ * against the English literal, so translating it is as safe as a component's
+ * title.
+ */
+export declare const boundaryLabelKey: (variant: C4BoundaryVariant) => string;
 /**
  * Relationship connector preset — the dashed arrow C4 draws between elements.
  *

package/dist/consts.js

@@ -291,6 +291,22 @@ export const NODE_LABEL = {
     browser: 'Web app',
     component: 'Component',
 };
+/**
+ * The i18n key {@link NODE_LABEL} is the English default of — mirrors BPMN's
+ * {@link nodeLabelKey} exactly, one package over: resolved at placement
+ * (`createC4Node`, the NAME tier) and never afterwards, since the title is
+ * content from the moment it lands and an author is free to retype it.
+ *
+ * Safe to translate where the type line is not: the exporter reads a
+ * component's NAME verbatim (`c4StatedName`) with no placeholder suppression,
+ * so nothing downstream compares this text against the English literal.
+ */
+export const nodeLabelKey = (kind) => `com.labre.c4.seed.${kind}`;
+/**
+ * The prompt a fresh description tier carries, resolved at placement exactly
+ * like {@link DESCRIPTION_PLACEHOLDER} below is the English default of.
+ */
+export const DESCRIPTION_PLACEHOLDER_KEY = 'com.labre.c4.seed.description-placeholder';
 /* ── The board ─────────────────────────────────────────────────────────── */
 export const FONT_FAMILY = 'Inter, sans-serif';
 /**
@@ -389,6 +405,14 @@ export const BOUNDARY_LABEL = {
     system: 'System boundary',
     container: 'Container boundary',
 };
+/**
+ * The i18n key {@link BOUNDARY_LABEL} is the English default of — resolved at
+ * placement (`createC4Boundary`) exactly like {@link nodeLabelKey}: the name
+ * is exported verbatim (`export.ts`, `boundary.name`) with no comparison
+ * against the English literal, so translating it is as safe as a component's
+ * title.
+ */
+export const boundaryLabelKey = (variant) => `com.labre.c4.seed.boundary-${variant}`;
 /* ── The relationship ──────────────────────────────────────────────────── */
 /**
  * Relationship connector preset — the dashed arrow C4 draws between elements.

package/dist/legend.d.ts

@@ -1,37 +1,5 @@
 import { type AutoLegendSpec } from '@formicoidea/labre-ddd-shared';
-/**
- * What the C4 board's automatic legend can say — a TABLE, and nothing else: the
- * scan, the placement and the box are `createAutoLegend`'s job, shared with the
- * three DDD boards.
- *
- * Every row is DERIVED twice over: its WORDING from the role vocabulary's own
- * `labelFallback` ({@link roleLabel}), and its COLOUR from the very palette the
- * creation site paints with ({@link NODE_PALETTE}). Neither is restated here, so
- * renaming a role renames its legend row and restyling the pack restyles its
- * swatches — which is what keeps a legend a description of the board rather than
- * a second opinion about it.
- *
- * ## Why `exact` on the container, and only there
- *
- * `c4:database` specialises `c4:container`, so an inclusive entry on the parent
- * would put a "Container" row — with the container's blue square — on a board
- * carrying nothing but cylinders. The row would name a shape that is nowhere on
- * the diagram. EDGY's four base kinds hit this first and `AutoLegendEntry.exact`
- * exists for it: base and specialisation become two separate statements, each
- * listed when it is the thing the user actually drew.
- *
- * The other four element roles are childless, so `exact` would change nothing
- * for them and is left off — the flag marks the places where the distinction is
- * real.
- *
- * ## What is missing, and why
- *
- * `mobile` and `browser` get no row of their own: they carry `c4:container`,
- * because a phone app and a single-page app are containers with a picture
- * (`roles.ts`). Detection is by role and only by role, so a board of nothing but
- * mobile apps lists "Container" — which is the honest answer about what the
- * boxes MEAN. `person-ext` and `system-ext` collapse the same way onto person
- * and system, for the same reason: the grey says "out of scope", not "a
- * different sort of thing".
- */
+import { type ChromeWording } from '@formicoidea/labre-core/shared/services';
+/** Every section `titleKey` above, for `translations.ts`'s manifest. */
+export declare const C4_LEGEND_SECTION_WORDINGS: readonly ChromeWording[];
 export declare const C4_AUTO_LEGEND: AutoLegendSpec;

package/dist/legend.js

@@ -1,4 +1,5 @@
 import { roleLabel } from '@formicoidea/labre-ddd-shared';
+import { BOARD_LEGEND_TITLE, } from '@formicoidea/labre-core/shared/services';
 import { BOUNDARY_STROKE, NODE_PALETTE, RELATIONSHIP_STROKE } from './consts.js';
 import { C4_ROLE, C4_ROLES } from './roles.js';
 /**
@@ -36,13 +37,36 @@ import { C4_ROLE, C4_ROLES } from './roles.js';
  * and system, for the same reason: the grey says "out of scope", not "a
  * different sort of thing".
  */
+/** This section's own keys. */
+const SECTION_ELEMENTS = [
+    'com.labre.c4.legend.section.elements',
+    'Elements',
+];
+const SECTION_FRAMES = [
+    'com.labre.c4.legend.section.frames',
+    'Frames',
+];
+const SECTION_RELATIONS = [
+    'com.labre.c4.legend.section.relations',
+    'Relations',
+];
+/** Every section `titleKey` above, for `translations.ts`'s manifest. */
+export const C4_LEGEND_SECTION_WORDINGS = [
+    SECTION_ELEMENTS,
+    SECTION_FRAMES,
+    SECTION_RELATIONS,
+];
 export const C4_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],
     width: 290,
     roles: C4_ROLES,
     sections: [
         {
             title: 'Elements',
+            titleKey: SECTION_ELEMENTS[0],
             entries: [
                 {
                     role: C4_ROLE.person,
@@ -90,6 +114,7 @@ export const C4_AUTO_LEGEND = {
         },
         {
             title: 'Frames',
+            titleKey: SECTION_FRAMES[0],
             entries: [
                 {
                     role: C4_ROLE.boundary,
@@ -107,6 +132,7 @@ export const C4_AUTO_LEGEND = {
         },
         {
             title: 'Relations',
+            titleKey: SECTION_RELATIONS[0],
             entries: [
                 {
                     role: C4_ROLE.relationship,

package/dist/morph.js

@@ -167,8 +167,8 @@ function rewriteTier(model, role, decide) {
  *   "Customer database" keeps that name whatever it becomes, which is the PO's
  *   "the label is intact" for every title that is real content.
  */
-function rewriteTiers(model, from, to) {
-    rewriteTier(model, C4_ROLE['type-line'], text => c4MorphedTypeLine(from, to, text));
+function rewriteTiers(model, from, to, std) {
+    rewriteTier(model, C4_ROLE['type-line'], text => c4MorphedTypeLine(from, to, text, std));
     rewriteTier(model, C4_ROLE.title, text => c4MorphedTitle(from, to, text));
 }
 /**

package/dist/node/type-line-watcher.js

@@ -103,7 +103,12 @@ export class C4TypeLineWatcher extends InteractivityExtension {
         if (!kind)
             return;
         const raw = element.text.toString();
-        const canonical = normalizeC4TypeLine(kind, raw);
+        // `this.std` resolves the canonical line through the host's catalogue —
+        // both halves of the prompt, and the technology round-trip
+        // (`technologyOfTypeLine`) recognising the host's own resolved word —
+        // so a translated document's type line stays in that language across a
+        // commit instead of being silently reverted to English (`type-line.ts`).
+        const canonical = normalizeC4TypeLine(kind, raw, this.std);
         if (canonical === raw)
             return;
         this.std.store.captureSync();

package/dist/templates.js

@@ -46,6 +46,8 @@ const boundaryPreview = (inner = '') => `<svg ${ATTRS} fill="none"><rect x="14"
 const CONTAINER = NODE_PALETTE.container;
 export const c4TemplateCategory = {
     name: 'C4',
+    // Reuses the senior button's own key — see `TemplateCategory.nameKey`.
+    nameKey: 'com.labre.framework.c4',
     templates: [
         templateFromCommand(byId('c4.addBoard'), `<svg ${ATTRS} fill="none"><rect x="10" y="10" width="115" height="60" rx="6" fill="${BOARD_CARD_FILL}" stroke="${BOARD_CARD_BORDER}" stroke-width="1.5"/><path d="M10 26 H125" stroke="${BOARD_CARD_BORDER}" stroke-width="1.5"/><rect x="11" y="11" width="113" height="15" fill="${BOARD_BAND_FILL}"/><rect x="20" y="15" width="40" height="6" rx="3" fill="${BOARD_TITLE_COLOR}" opacity="0.55"/><rect x="22" y="36" width="34" height="20" rx="2" fill="${NODE_PALETTE.system.fill}"/><rect x="79" y="36" width="34" height="20" rx="2" fill="${CONTAINER.fill}"/><path d="M58 46 H75" stroke="${RELATIONSHIP_STROKE}" stroke-width="1.6" stroke-dasharray="4 3"/></svg>`),
         templateFromCommand(byId('c4.addPerson'), personPreview('person')),

package/dist/translations.js

@@ -1,11 +1,50 @@
 import { collectTranslationKeys, commandCategoryTranslationEntries, commandTranslationEntries, mergeTranslationEntries, } from '@formicoidea/labre-core/std';
 import { C4_BOARD_BACKGROUND, C4_BOUNDARY_BACKGROUND } from './background.js';
 import { c4Commands } from './commands.js';
+import { BOUNDARY_LABEL, boundaryLabelKey, DESCRIPTION_PLACEHOLDER, DESCRIPTION_PLACEHOLDER_KEY, NODE_LABEL, nodeLabelKey, } from './consts.js';
+import { C4_LEGEND_SECTION_WORDINGS } from './legend.js';
 import { C4_BOARD_LEVEL_MENU } from './levels.js';
 import { C4_PROFILES } from './profiles.js';
 import { C4_READINGS } from './reading.js';
 import { C4_ROLES } from './roles.js';
 import { C4_RULES } from './rules.js';
+import { C4_TYPE_LINE_WORDINGS } from './type-line.js';
+/**
+ * The captions a placed component and a placed boundary are seeded with — the
+ * fallback IS `NODE_LABEL[kind]` / `BOUNDARY_LABEL[variant]`, never restated,
+ * mirroring BPMN's `seedEntries` exactly. The type line's own bracketed word
+ * and the technology placeholder ARE here too (`C4_TYPE_LINE_WORDINGS`),
+ * resolved at placement (`createC4Node`, `actions.ts`) and rebuilt through the
+ * same seam on every edit commit (`C4TypeLineWatcher`).
+ */
+const seedEntries = () => [
+    ...Object.entries(NODE_LABEL).map(([kind, label]) => ({
+        key: nodeLabelKey(kind),
+        fallback: label,
+        source: 'seed',
+    })),
+    ...Object.entries(BOUNDARY_LABEL).map(([variant, label]) => ({
+        key: boundaryLabelKey(variant),
+        fallback: label,
+        source: 'seed',
+    })),
+    {
+        key: DESCRIPTION_PLACEHOLDER_KEY,
+        fallback: DESCRIPTION_PLACEHOLDER,
+        source: 'seed',
+    },
+    ...C4_TYPE_LINE_WORDINGS.map(([key, fallback]) => ({
+        key,
+        fallback,
+        source: 'seed',
+    })),
+];
+/** The auto-legend's own section titles ({@link C4_LEGEND_SECTION_WORDINGS}). */
+const legendSectionEntries = () => C4_LEGEND_SECTION_WORDINGS.map(([key, fallback]) => ({
+    key,
+    fallback,
+    source: 'chrome',
+}));
 /**
  * THIS framework's contribution to the translation-key manifest — every
  * `com.labre.*` key C4 can hand to `TranslationProvider.t`, derived from the
@@ -40,7 +79,7 @@ commandCategoryTranslationEntries(c4Commands), collectTranslationKeys('role', C4
     // nothing is restated in `affine/all`, so a key added to the picker
     // reaches a host's catalogue by construction.
     C4_BOARD_LEVEL_MENU,
-]), 
+]), seedEntries(), legendSectionEntries(), 
 // AFTER the two above, and the order is load-bearing: a rule carries its
 // framework's `roles` and, for `c4.person-in-boundary`, the boundary's own
 // declaration, so walking the rules reaches keys those two lists already

package/dist/type-line.d.ts

@@ -1,4 +1,6 @@
 import type { C4NodeKind } from '@formicoidea/labre-core/model';
+import { type ChromeWording } from '@formicoidea/labre-core/shared/services';
+import type { BlockStdScope } from '@formicoidea/labre-core/std';
 /**
  * The middle tier of a C4 element's label — `[Person]`, `[Software System]`,
  * `[Container: Java]` — SEMI-DERIVED: the word comes from the kind, the
@@ -41,6 +43,7 @@ import type { C4NodeKind } from '@formicoidea/labre-core/model';
  * without a word to announce it fails the build here.
  */
 export declare const C4_TYPE_WORD: Record<C4NodeKind, string>;
+export declare const C4_TYPE_WORD_KEY: Record<C4NodeKind, string>;
 /**
  * The type line as it is drawn, brackets included.
  *
@@ -49,10 +52,12 @@ export declare const C4_TYPE_WORD: Record<C4NodeKind, string>;
  * produce a dangling `[Container: ]`. Whitespace runs collapse for the same
  * reason they do in the mermaid sanitizer: the line is one line.
  *
- * Pure, total and `std`-free, so the renderer, the exporter and a test can all
- * ask the same question and get the same answer.
+ * Pure and total; `std` is OPTIONAL and, when given, resolves the bracketed
+ * word through the host's catalogue ({@link typeWord}) — the renderer, the
+ * exporter and a test can all still ask the same question with no `std` at
+ * all and get the same English answer they always have.
  */
-export declare function c4TypeLine(kind: C4NodeKind, technology?: string): string;
+export declare function c4TypeLine(kind: C4NodeKind, technology?: string, std?: BlockStdScope): string;
 /**
  * The technology an author stated in a type line, whatever shape they left it
  * in — `''` when they stated none.
@@ -70,8 +75,12 @@ export declare function c4TypeLine(kind: C4NodeKind, technology?: string): strin
  * https://x/docs     →  https://x/docs   a colon that is NOT a prefix
  * ```
  *
- * Pure and `std`-free, so the commit hook, the exporter and a test all read the
- * same line the same way.
+ * Pure and total; `std` is OPTIONAL, exactly like {@link c4TypeLine} —
+ * without it this reads a line the same way it always has, and with it the
+ * vocabulary the `<word>:` prefix is matched against ALSO recognises the
+ * host's own resolved word ({@link knownTypeWords}), so a line seeded or
+ * normalized in a translated host still gives back the right technology
+ * rather than the whole line.
  *
  * It deliberately does NOT know about the creation placeholder: a node created
  * and never touched carries `[Container: technology]`, and reading that as "no
@@ -80,7 +89,7 @@ export declare function c4TypeLine(kind: C4NodeKind, technology?: string): strin
  * placeholder is a question for whoever asks what the element STATES, which is
  * the exporter, and it is answered there.
  */
-export declare function technologyOfTypeLine(text: string | null | undefined): string;
+export declare function technologyOfTypeLine(text: string | null | undefined, std?: BlockStdScope): string;
 /**
  * A type line as it must be STORED, whatever was typed into it.
  *
@@ -91,8 +100,14 @@ export declare function technologyOfTypeLine(text: string | null | undefined): s
  *
  * Idempotent by construction — `normalize(normalize(x)) === normalize(x)` —
  * which is what lets it run on every commit without a guard.
+ *
+ * `std` is OPTIONAL and, when given, is threaded to both halves: the
+ * technology is read back recognising the host's own word
+ * ({@link technologyOfTypeLine}) and the line is rebuilt with it
+ * ({@link c4TypeLine}) — see `C4TypeLineWatcher`, the one real caller that
+ * has an `std` to give it.
  */
-export declare function normalizeC4TypeLine(kind: C4NodeKind, rawText: string | null | undefined): string;
+export declare function normalizeC4TypeLine(kind: C4NodeKind, rawText: string | null | undefined, std?: BlockStdScope): string;
 /**
  * The word a fresh type line prompts the author with, in the technology's slot.
  *
@@ -101,6 +116,19 @@ export declare function normalizeC4TypeLine(kind: C4NodeKind, rawText: string |
  * {@link C4_TYPE_PLACEHOLDER}.
  */
 export declare const TYPE_TECHNOLOGY_PLACEHOLDER = "technology";
+/**
+ * {@link TYPE_TECHNOLOGY_PLACEHOLDER}'s own key — see the long comment on
+ * {@link C4_TYPE_WORD_KEY} for why this lot's shipped French proposal keeps
+ * it identical to English.
+ */
+export declare const C4_TECHNOLOGY_PLACEHOLDER_KEY = "com.labre.c4.type.technology-placeholder";
+/**
+ * Every wording this file writes onto the canvas, for `translations.ts`'s
+ * manifest contribution — the four distinct type words plus the technology
+ * prompt, all `seed` (written into the document once, at placement or at a
+ * commit the watcher normalizes).
+ */
+export declare const C4_TYPE_LINE_WORDINGS: readonly ChromeWording[];
 /**
  * Which kinds announce a technology in their type line AT ALL.
  *
@@ -131,6 +159,15 @@ export declare const C4_TYPE_TAKES_TECHNOLOGY: Record<C4NodeKind, boolean>;
  * with a technology literally called "technology".
  */
 export declare const C4_TYPE_PLACEHOLDER: Record<C4NodeKind, string>;
+/**
+ * {@link C4_TYPE_PLACEHOLDER}, resolved through `std` when given — the
+ * placement site (`createC4Node`, `actions.ts`) seeds a fresh element with
+ * this rather than the English-only constant, so a component drawn in a
+ * translated host starts in that language, like every other seed
+ * (`docs/adr/0016`). With no `std` this returns exactly
+ * `C4_TYPE_PLACEHOLDER[kind]`.
+ */
+export declare function c4TypePlaceholder(kind: C4NodeKind, std?: BlockStdScope): string;
 /**
  * The type line a component should carry once its shape has morphed from `from`
  * to `to` — or `null` when the line is the AUTHOR's and must not be touched.
@@ -172,4 +209,4 @@ export declare const C4_TYPE_PLACEHOLDER: Record<C4NodeKind, string>;
  *
  * Pure, total and `std`-free, like everything else in this file.
  */
-export declare function c4MorphedTypeLine(from: C4NodeKind, to: C4NodeKind, rawText: string | null | undefined): string | null;
+export declare function c4MorphedTypeLine(from: C4NodeKind, to: C4NodeKind, rawText: string | null | undefined, std?: BlockStdScope): string | null;

package/dist/type-line.js

@@ -1,3 +1,4 @@
+import { translateKey, } from '@formicoidea/labre-core/shared/services';
 /**
  * The middle tier of a C4 element's label — `[Person]`, `[Software System]`,
  * `[Container: Java]` — SEMI-DERIVED: the word comes from the kind, the
@@ -50,6 +51,51 @@ export const C4_TYPE_WORD = {
     browser: 'Container',
     component: 'Component',
 };
+/**
+ * {@link C4_TYPE_WORD}'s own i18n key, one per DISTINCT word (four kinds
+ * share `Container`, two share `Person`, two share `Software System`, one
+ * word each carries one key).
+ *
+ * The PO's own glossary (`brief-i18n.md`) names "Software System",
+ * "Container" and "Component" franglais — the French proposal IS the English
+ * word — and this lot extends the same choice to "Person" and to
+ * {@link TYPE_TECHNOLOGY_PLACEHOLDER}, for a reason beyond consistency: this
+ * whole file's comparisons (`technologyOfTypeLine`, `C4_TYPE_PLACEHOLDER`,
+ * `c4StatedTechnology` in `component.ts`) read the STORED text back against
+ * these very words, and `c4StatedTechnology` runs from the `std`-free exporter
+ * (`export.ts`, ADR 0012 P3) — it cannot ask a host's catalogue at all. Keeping
+ * the shipped French wording IDENTICAL to English is what keeps that
+ * comparison correct on a document seeded in French. A host that overrides
+ * the catalogue with a genuinely different word regains the risk the
+ * `DESCRIPTION_PLACEHOLDER_KEY` comment in `consts.ts` already names for the
+ * description tier.
+ */
+// Named constants rather than the key literals inline: `manifest.unit.spec.ts`
+// reads two adjacent single-quoted literals in one argument list as a
+// key/fallback PAIR, with no anchor on `translateKey(` — and a `Record`
+// spelling each key out beside the NEXT (quoted, hyphenated) property name
+// below it reads exactly like one. Referencing an identifier instead of
+// repeating the literal sidesteps the false pairing.
+const PERSON_KEY = 'com.labre.c4.type.person';
+const SYSTEM_KEY = 'com.labre.c4.type.system';
+const CONTAINER_KEY = 'com.labre.c4.type.container';
+const COMPONENT_KEY = 'com.labre.c4.type.component';
+export const C4_TYPE_WORD_KEY = {
+    person: PERSON_KEY,
+    'person-ext': PERSON_KEY,
+    system: SYSTEM_KEY,
+    'system-ext': SYSTEM_KEY,
+    container: CONTAINER_KEY,
+    database: CONTAINER_KEY,
+    mobile: CONTAINER_KEY,
+    browser: CONTAINER_KEY,
+    component: COMPONENT_KEY,
+};
+/** The word an `std` (when given) resolves {@link kind}'s bracket to. */
+function typeWord(kind, std) {
+    const english = C4_TYPE_WORD[kind];
+    return std ? translateKey(std, C4_TYPE_WORD_KEY[kind], english) : english;
+}
 /**
  * The type line as it is drawn, brackets included.
  *
@@ -58,11 +104,13 @@ export const C4_TYPE_WORD = {
  * produce a dangling `[Container: ]`. Whitespace runs collapse for the same
  * reason they do in the mermaid sanitizer: the line is one line.
  *
- * Pure, total and `std`-free, so the renderer, the exporter and a test can all
- * ask the same question and get the same answer.
+ * Pure and total; `std` is OPTIONAL and, when given, resolves the bracketed
+ * word through the host's catalogue ({@link typeWord}) — the renderer, the
+ * exporter and a test can all still ask the same question with no `std` at
+ * all and get the same English answer they always have.
  */
-export function c4TypeLine(kind, technology) {
-    const word = C4_TYPE_WORD[kind];
+export function c4TypeLine(kind, technology, std) {
+    const word = typeWord(kind, std);
     const techn = (technology ?? '').replaceAll(/\s+/g, ' ').trim();
     return techn ? `[${word}: ${techn}]` : `[${word}]`;
 }
@@ -82,6 +130,22 @@ export function c4TypeLine(kind, technology) {
  * instead can only ever strip a word the notation itself writes.
  */
 const KNOWN_TYPE_WORDS = new Set(Object.values(C4_TYPE_WORD).map(word => word.toLowerCase()));
+/**
+ * {@link KNOWN_TYPE_WORDS}, plus the host-resolved word of every kind when
+ * `std` is given — so a line seeded in a translated host (`c4TypeLine(kind,
+ * …, std)` at placement, or after a commit the watcher rebuilt) is still
+ * recognised as carrying THE NOTATION'S word and not a technology typed on
+ * its own. With no `std` this is exactly {@link KNOWN_TYPE_WORDS}.
+ */
+function knownTypeWords(std) {
+    if (!std)
+        return KNOWN_TYPE_WORDS;
+    const words = new Set(KNOWN_TYPE_WORDS);
+    for (const kind of Object.keys(C4_TYPE_WORD)) {
+        words.add(typeWord(kind, std).toLowerCase());
+    }
+    return words;
+}
 /**
  * The technology an author stated in a type line, whatever shape they left it
  * in — `''` when they stated none.
@@ -99,8 +163,12 @@ const KNOWN_TYPE_WORDS = new Set(Object.values(C4_TYPE_WORD).map(word => word.to
  * https://x/docs     →  https://x/docs   a colon that is NOT a prefix
  * ```
  *
- * Pure and `std`-free, so the commit hook, the exporter and a test all read the
- * same line the same way.
+ * Pure and total; `std` is OPTIONAL, exactly like {@link c4TypeLine} —
+ * without it this reads a line the same way it always has, and with it the
+ * vocabulary the `<word>:` prefix is matched against ALSO recognises the
+ * host's own resolved word ({@link knownTypeWords}), so a line seeded or
+ * normalized in a translated host still gives back the right technology
+ * rather than the whole line.
  *
  * It deliberately does NOT know about the creation placeholder: a node created
  * and never touched carries `[Container: technology]`, and reading that as "no
@@ -109,18 +177,19 @@ const KNOWN_TYPE_WORDS = new Set(Object.values(C4_TYPE_WORD).map(word => word.to
  * placeholder is a question for whoever asks what the element STATES, which is
  * the exporter, and it is answered there.
  */
-export function technologyOfTypeLine(text) {
+export function technologyOfTypeLine(text, std) {
     const flat = (text ?? '')
         .replaceAll(/[[\]]/g, ' ')
         .replaceAll(/\s+/g, ' ')
         .trim();
     const colon = flat.indexOf(':');
+    const words = knownTypeWords(std);
     // No colon at all: the line is either the bare notation word — which states no
     // technology — or it is the technology, typed on its own.
     if (colon < 0)
-        return KNOWN_TYPE_WORDS.has(flat.toLowerCase()) ? '' : flat;
+        return words.has(flat.toLowerCase()) ? '' : flat;
     const head = flat.slice(0, colon).trim().toLowerCase();
-    if (!KNOWN_TYPE_WORDS.has(head))
+    if (!words.has(head))
         return flat;
     return flat.slice(colon + 1).trim();
 }
@@ -134,9 +203,15 @@ export function technologyOfTypeLine(text) {
  *
  * Idempotent by construction — `normalize(normalize(x)) === normalize(x)` —
  * which is what lets it run on every commit without a guard.
+ *
+ * `std` is OPTIONAL and, when given, is threaded to both halves: the
+ * technology is read back recognising the host's own word
+ * ({@link technologyOfTypeLine}) and the line is rebuilt with it
+ * ({@link c4TypeLine}) — see `C4TypeLineWatcher`, the one real caller that
+ * has an `std` to give it.
  */
-export function normalizeC4TypeLine(kind, rawText) {
-    return c4TypeLine(kind, technologyOfTypeLine(rawText));
+export function normalizeC4TypeLine(kind, rawText, std) {
+    return c4TypeLine(kind, technologyOfTypeLine(rawText, std), std);
 }
 /* ── What a fresh element says before anybody writes on it ─────────────── */
 /**
@@ -147,6 +222,31 @@ export function normalizeC4TypeLine(kind, rawText) {
  * {@link C4_TYPE_PLACEHOLDER}.
  */
 export const TYPE_TECHNOLOGY_PLACEHOLDER = 'technology';
+/**
+ * {@link TYPE_TECHNOLOGY_PLACEHOLDER}'s own key — see the long comment on
+ * {@link C4_TYPE_WORD_KEY} for why this lot's shipped French proposal keeps
+ * it identical to English.
+ */
+export const C4_TECHNOLOGY_PLACEHOLDER_KEY = 'com.labre.c4.type.technology-placeholder';
+/** The word an `std` (when given) resolves the technology prompt to. */
+function technologyPlaceholderWord(std) {
+    return std
+        ? translateKey(std, C4_TECHNOLOGY_PLACEHOLDER_KEY, TYPE_TECHNOLOGY_PLACEHOLDER)
+        : TYPE_TECHNOLOGY_PLACEHOLDER;
+}
+/**
+ * Every wording this file writes onto the canvas, for `translations.ts`'s
+ * manifest contribution — the four distinct type words plus the technology
+ * prompt, all `seed` (written into the document once, at placement or at a
+ * commit the watcher normalizes).
+ */
+export const C4_TYPE_LINE_WORDINGS = [
+    [C4_TYPE_WORD_KEY.person, C4_TYPE_WORD.person],
+    [C4_TYPE_WORD_KEY.system, C4_TYPE_WORD.system],
+    [C4_TYPE_WORD_KEY.container, C4_TYPE_WORD.container],
+    [C4_TYPE_WORD_KEY.component, C4_TYPE_WORD.component],
+    [C4_TECHNOLOGY_PLACEHOLDER_KEY, TYPE_TECHNOLOGY_PLACEHOLDER],
+];
 /**
  * Which kinds announce a technology in their type line AT ALL.
  *
@@ -190,6 +290,17 @@ export const C4_TYPE_PLACEHOLDER = Object.fromEntries(Object.keys(C4_TYPE_WORD).
     kind,
     c4TypeLine(kind, C4_TYPE_TAKES_TECHNOLOGY[kind] ? TYPE_TECHNOLOGY_PLACEHOLDER : undefined),
 ]));
+/**
+ * {@link C4_TYPE_PLACEHOLDER}, resolved through `std` when given — the
+ * placement site (`createC4Node`, `actions.ts`) seeds a fresh element with
+ * this rather than the English-only constant, so a component drawn in a
+ * translated host starts in that language, like every other seed
+ * (`docs/adr/0016`). With no `std` this returns exactly
+ * `C4_TYPE_PLACEHOLDER[kind]`.
+ */
+export function c4TypePlaceholder(kind, std) {
+    return c4TypeLine(kind, C4_TYPE_TAKES_TECHNOLOGY[kind] ? technologyPlaceholderWord(std) : undefined, std);
+}
 /* ── What the line becomes when the shape becomes something else ───────── */
 /**
  * The type line a component should carry once its shape has morphed from `from`
@@ -232,13 +343,19 @@ export const C4_TYPE_PLACEHOLDER = Object.fromEntries(Object.keys(C4_TYPE_WORD).
  *
  * Pure, total and `std`-free, like everything else in this file.
  */
-export function c4MorphedTypeLine(from, to, rawText) {
+export function c4MorphedTypeLine(from, to, rawText, std) {
     const text = (rawText ?? '').trim();
     if (!text)
         return null;
-    if (text === C4_TYPE_PLACEHOLDER[from])
-        return C4_TYPE_PLACEHOLDER[to];
-    if (text !== normalizeC4TypeLine(from, text))
+    // The untouched prompt, in EITHER language: the English literal (a document
+    // seeded before these keys existed, or with no host) or the host's own
+    // resolved wording (`c4TypePlaceholder`, which equals the English constant
+    // when `std` is absent) — see the module docstring.
+    if (text === C4_TYPE_PLACEHOLDER[from] ||
+        text === c4TypePlaceholder(from, std)) {
+        return c4TypePlaceholder(to, std);
+    }
+    if (text !== normalizeC4TypeLine(from, text, std))
         return null;
-    return c4TypeLine(to, technologyOfTypeLine(text));
+    return c4TypeLine(to, technologyOfTypeLine(text, std), std);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-framework-c4",
   "description": "Labre c4 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",
     "lit": "^3.2.0"
   }
 }