@formicoidea/labre-framework-c4 0.40.0 → 0.42.0

package/dist/toolbar/palette.d.ts

@@ -0,0 +1,33 @@
+import type { FrameworkPalette, NamedPalette } from '@formicoidea/labre-core/components/color-picker';
+import type { ChromeWording } from '@formicoidea/labre-core/shared/services';
+/**
+ * The C4 swatches' own names, resolved by `resolvePaletteLabel`
+ * (`@labre/affine-components/color-picker`) through each swatch's own
+ * {@link NamedPalette.labelWording} — the same framework-agnostic mechanism
+ * Wardley and EDGY use (`WARDLEY_PALETTE_WORDINGS`), so nothing here touches
+ * `packages/affine/model` (RED ZONE) or another framework's package.
+ *
+ * Exported so `../translations.ts` can list them under source `chrome`: a
+ * swatch's name is toolbar chrome, re-rendered on every locale switch, never
+ * seeded into a document.
+ */
+export declare const C4_PALETTE_WORDING_PERSON: ChromeWording;
+export declare const C4_PALETTE_WORDING_SYSTEM: ChromeWording;
+export declare const C4_PALETTE_WORDING_CONTAINER: ChromeWording;
+export declare const C4_PALETTE_WORDING_COMPONENT: ChromeWording;
+export declare const C4_PALETTE_WORDING_EXTERNAL: ChromeWording;
+export declare const C4_PALETTE_WORDING_RELATIONSHIP: ChromeWording;
+export declare const C4_PALETTE_WORDINGS: readonly ChromeWording[];
+/**
+ * From the default editor palette we keep ONLY the neutrals — the historical
+ * colours say nothing in this notation.
+ */
+export declare const C4_PALETTE_LIST: NamedPalette[];
+/**
+ * C4's page of the colour pickers' carousel (`docs/adr/0027`). Registered from
+ * the FLAG-GATED view extension, because offering hues is TOOLING: a diagram
+ * drawn while the flag was on keeps every colour it was painted with when the
+ * flag goes off — the shelf that offers more of them is what goes away
+ * (`docs/adr/0009`).
+ */
+export declare const C4_FRAMEWORK_PALETTE: FrameworkPalette;

package/dist/toolbar/palette.js

@@ -0,0 +1,114 @@
+import { neutralPalettes } from '@formicoidea/labre-core/gfx/shape';
+import { NODE_PALETTE, RELATIONSHIP_STROKE } from '../consts.js';
+/**
+ * The C4 swatches' own names, resolved by `resolvePaletteLabel`
+ * (`@labre/affine-components/color-picker`) through each swatch's own
+ * {@link NamedPalette.labelWording} — the same framework-agnostic mechanism
+ * Wardley and EDGY use (`WARDLEY_PALETTE_WORDINGS`), so nothing here touches
+ * `packages/affine/model` (RED ZONE) or another framework's package.
+ *
+ * Exported so `../translations.ts` can list them under source `chrome`: a
+ * swatch's name is toolbar chrome, re-rendered on every locale switch, never
+ * seeded into a document.
+ */
+export const C4_PALETTE_WORDING_PERSON = [
+    'com.labre.c4.palette.person-blue',
+    'Person blue',
+];
+export const C4_PALETTE_WORDING_SYSTEM = [
+    'com.labre.c4.palette.system-blue',
+    'System blue',
+];
+export const C4_PALETTE_WORDING_CONTAINER = [
+    'com.labre.c4.palette.container-blue',
+    'Container blue',
+];
+export const C4_PALETTE_WORDING_COMPONENT = [
+    'com.labre.c4.palette.component-blue',
+    'Component blue',
+];
+export const C4_PALETTE_WORDING_EXTERNAL = [
+    'com.labre.c4.palette.external-grey',
+    'External grey',
+];
+export const C4_PALETTE_WORDING_RELATIONSHIP = [
+    'com.labre.c4.palette.relationship-grey',
+    'Relationship grey',
+];
+export const C4_PALETTE_WORDINGS = [
+    C4_PALETTE_WORDING_PERSON,
+    C4_PALETTE_WORDING_SYSTEM,
+    C4_PALETTE_WORDING_CONTAINER,
+    C4_PALETTE_WORDING_COMPONENT,
+    C4_PALETTE_WORDING_EXTERNAL,
+    C4_PALETTE_WORDING_RELATIONSHIP,
+];
+/**
+ * The C4 **level ladder**, surfaced as ready-made swatches.
+ *
+ * C4's stencil IS a colour code (see `../consts.ts`): the four levels are four
+ * blues running lighter as they go in — person, software system, container,
+ * component — anything outside the diagram's scope is one grey, and everything
+ * that is not an element (the relationship arrow, the boundary frame) is drawn
+ * in a second, darker one.
+ *
+ * Every value is read off {@link NODE_PALETTE} and {@link RELATIONSHIP_STROKE}
+ * rather than restated, so the shelf and the notation cannot drift apart. They
+ * are SHORTCUTS, never constraints: no rule of this pack reads a colour.
+ */
+const C4_PALETTES = [
+    {
+        key: 'Person blue',
+        value: NODE_PALETTE.person.fill,
+        labelWording: C4_PALETTE_WORDING_PERSON,
+    },
+    {
+        key: 'System blue',
+        value: NODE_PALETTE.system.fill,
+        labelWording: C4_PALETTE_WORDING_SYSTEM,
+    },
+    {
+        key: 'Container blue',
+        value: NODE_PALETTE.container.fill,
+        labelWording: C4_PALETTE_WORDING_CONTAINER,
+    },
+    {
+        key: 'Component blue',
+        value: NODE_PALETTE.component.fill,
+        labelWording: C4_PALETTE_WORDING_COMPONENT,
+    },
+    // One grey for both external kinds, because the stencil paints them the same:
+    // "outside the scope of this diagram" is one statement.
+    {
+        key: 'External grey',
+        value: NODE_PALETTE['system-ext'].fill,
+        labelWording: C4_PALETTE_WORDING_EXTERNAL,
+    },
+    // The grey of the relationship arrow — and of the boundary frame, which the
+    // stencil draws in the very same `#444444`.
+    {
+        key: 'Relationship grey',
+        value: RELATIONSHIP_STROKE,
+        labelWording: C4_PALETTE_WORDING_RELATIONSHIP,
+    },
+];
+/**
+ * From the default editor palette we keep ONLY the neutrals — the historical
+ * colours say nothing in this notation.
+ */
+export const C4_PALETTE_LIST = [
+    ...C4_PALETTES,
+    ...neutralPalettes(),
+];
+/**
+ * C4's page of the colour pickers' carousel (`docs/adr/0027`). Registered from
+ * the FLAG-GATED view extension, because offering hues is TOOLING: a diagram
+ * drawn while the flag was on keeps every colour it was painted with when the
+ * flag goes off — the shelf that offers more of them is what goes away
+ * (`docs/adr/0009`).
+ */
+export const C4_FRAMEWORK_PALETTE = {
+    framework: 'c4',
+    labelWording: ['com.labre.framework.c4', 'C4 model'],
+    palettes: C4_PALETTE_LIST,
+};

package/dist/translations.js

@@ -1,11 +1,60 @@
 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 { c4Commands, C4_LEGEND_SECTION_WORDINGS } from './commands.js';
+import { BOUNDARY_LABEL, boundaryLabelKey, DESCRIPTION_PLACEHOLDER, DESCRIPTION_PLACEHOLDER_KEY, NODE_LABEL, nodeLabelKey, } from './consts.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_PALETTE_WORDINGS } from './toolbar/palette.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 carousel swatches' own names ({@link C4_PALETTE_WORDINGS}) — chrome,
+ * re-rendered by the colour picker on every locale switch, never seeded into
+ * a document. Same treatment as Wardley's and EDGY's.
+ */
+const paletteEntries = () => C4_PALETTE_WORDINGS.map(([key, fallback]) => ({
+    key,
+    fallback,
+    source: 'chrome',
+}));
+/** 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 +89,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(), paletteEntries(), 
 // 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/0023`). 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/0023`). 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/dist/view.js

@@ -1,4 +1,5 @@
 import { FrameworkBackgroundInteractionExtension, InterchangeExtension, morphToolbarConfig, ReadingProfileExtension, ValidationProfileExtension, ValidationRuleExtension, } from '@formicoidea/labre-core/blocks/surface';
+import { FrameworkPaletteExtension } from '@formicoidea/labre-core/components/color-picker';
 import { ViewExtensionProvider, } from '@formicoidea/labre-core/ext-loader';
 import { TemplateCategoryExtension } from '@formicoidea/labre-core/gfx/template';
 import { ToolbarModuleExtension, toolbarModuleKey, } from '@formicoidea/labre-core/shared/services';
@@ -20,6 +21,7 @@ import { C4_ROLES } from './roles.js';
 import { C4_RULES } from './rules.js';
 import { c4TemplateCategory } from './templates.js';
 import { c4BoardToolbarExtension, c4BoardToolingToolbarExtension, } from './toolbar/config.js';
+import { C4_FRAMEWORK_PALETTE } from './toolbar/palette.js';
 import { c4SeniorTool } from './toolbar/senior-tool.js';
 /**
  * C4 rendering — ALWAYS registered, independent of any flag. Boards, boundaries
@@ -112,6 +114,11 @@ export class C4ViewExtension extends ViewExtensionProvider {
                 context.register(ReadingProfileExtension(reading));
             }
             context.register(c4SeniorTool);
+            // C4's page of the colour pickers' carousel (`docs/adr/0027`). Here,
+            // beside the senior tool, because offering hues is TOOLING — the colours
+            // already painted on a stored diagram are content and do not move
+            // (`docs/adr/0009`).
+            context.register(FrameworkPaletteExtension(C4_FRAMEWORK_PALETTE));
             // The Templates-panel category — tooling, so it goes with the flag (#244).
             context.register(TemplateCategoryExtension(c4TemplateCategory));
             context.register(CommandExtension(c4Commands, c4CommandIcons));

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.42.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.42.0",
+    "@formicoidea/labre-ddd-shared": "0.42.0",
     "lit": "^3.2.0"
   }
 }

package/dist/legend.d.ts

@@ -1,37 +0,0 @@
-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".
- */
-export declare const C4_AUTO_LEGEND: AutoLegendSpec;