@formicoidea/labre-framework-c4 0.41.0 → 0.43.1

package/dist/index.js

@@ -48,10 +48,10 @@ export { C4_ELEMENT_MATRIX, C4_RELATIONSHIP_MATRIX, C4_RULES, } from './rules.js
 // The toolbox, for the host that composes the command registry and the
 // translation-key manifest out of the frameworks it installed (see
 // `packages/affine/all/src/{commands,translations}.ts`).
+// What the board's automatic legend can say is no longer a table of its own:
+// every row is subscribed by the command that draws the artefact
+// (`CommandDescriptor.legend`, `docs/adr/0026`), so `c4Commands` already
+// answers "what does this framework document about itself" without a canvas.
 export { c4CommandIcons, c4Commands } from './commands.js';
 export { c4TranslationEntries } from './translations.js';
-// The legend TABLE — what the board's automatic legend can say. Exported for
-// the same reason the two background declarations are: it answers "what does
-// this framework document about itself" without a canvas.
-export { C4_AUTO_LEGEND } from './legend.js';
 export { C4_COMPONENT_READING, C4_CONTAINER_READING, C4_PERSON_READING, C4_READINGS, C4_SYSTEM_READING, } from './reading.js';

package/dist/toolbar/c4-senior-button.d.ts

@@ -16,4 +16,5 @@ export declare class EdgelessC4SeniorButton extends DddSeniorButtonBase {
     protected label: string;
     protected labelKey: string;
     protected icon: import("lit-html").TemplateResult<2>;
+    protected owner: "c4";
 }

package/dist/toolbar/c4-senior-button.js

@@ -19,5 +19,6 @@ export class EdgelessC4SeniorButton extends DddSeniorButtonBase {
         this.label = 'C4 model';
         this.labelKey = 'com.labre.framework.c4';
         this.icon = c4ToolbarIcon;
+        this.owner = 'c4';
     }
 }

package/dist/toolbar/config.d.ts

@@ -1,5 +1,4 @@
-import { ActionPlacement, type ToolbarContext, type ToolbarModuleConfig } from '@formicoidea/labre-core/shared/services';
-import { type TemplateResult } from 'lit';
+import { type ToolbarContext, type ToolbarModuleConfig } from '@formicoidea/labre-core/shared/services';
 /**
  * The selected C4 board's contextual toolbar: the resize toggle, and the
  * automatic legend of what is actually drawn on the board.
@@ -13,15 +12,14 @@ import { type TemplateResult } from 'lit';
  * The PO's call is that generating one belongs to a board you have SELECTED and
  * to nothing else: it is not an artefact to pick off a palette, and an entry in
  * a catalogue of things C4 draws would offer it to a user with no board in front
- * of them. So there is no `c4.legend` command, this button is the only way to
- * reach it, and the telemetry it owes is emitted by hand below.
+ * of them. So there is no `c4.legend` command, and this button is the only way
+ * to reach it.
  *
- * That is the same shape — and the same exception — the Context Map board makes
- * (`ddd-context-map/src/toolbar/board-config.ts`), down to the payload, so the
- * two frameworks' legends stay comparable on one dashboard. The cost is the one
- * the bottleneck exists to avoid and is accepted knowingly: this `track()` call
- * is a second emitter, and it is on whoever edits it to keep the wire values
- * matching what `reportCommandTelemetry` would have sent.
+ * That is the same shape — and the same exception — every other framework with a
+ * legend makes. The cost is the one the bottleneck exists to avoid: the
+ * telemetry it owes is emitted outside `runCommand`. It is emitted ONCE, by the
+ * shared factory (`legend-toolbar.ts`), so the seven copies of those wire values
+ * that used to sit in seven files can no longer drift apart.
  *
  * ## Two modules on one element, and why
  *
@@ -66,35 +64,26 @@ export declare const c4BoardToolbarConfig: {
     readonly actions: [{
         readonly id: "a.toggle-resize";
         readonly tooltipWording: import("@formicoidea/labre-core/shared/services").ChromeWording;
-        readonly icon: TemplateResult<1>;
+        readonly icon: import("lit-html").TemplateResult<1>;
         readonly active: (ctx: ToolbarContext) => boolean;
         readonly run: (ctx: ToolbarContext) => void;
-    }, {
-        id: string;
-        placement: ActionPlacement;
-        when: (ctx: ToolbarContext) => boolean;
-        generate: (ctx: ToolbarContext) => {
-            icon: TemplateResult;
-            label: string;
-            run: (runCtx: ToolbarContext) => void;
-        };
-    }];
+    }, import("@formicoidea/labre-core/shared/services").ToolbarActionGenerator];
     readonly when: (ctx: ToolbarContext) => boolean;
 };
 export declare const c4BoardToolbarExtension: import("@formicoidea/labre-core/store").ExtensionType;
 /**
  * The legend button — the flag-gated half of the row (see the note above).
  *
- * `b.` sorts it after the resize toggle, so the two modules render as the one
- * row a user sees rather than in registration order.
+ * The SHARED factory, not a C4 copy of it: the button, the placement, the box
+ * and the one `FrameworkLegendCreated` emission all live in the surface block
+ * (`legend-toolbar.ts`, `docs/adr/0026`), and C4 hands it the board model to
+ * look for, whose commands to read the rows off, and the historical wire value.
+ *
+ * `b.` — the factory's default — sorts it after the resize toggle, so the two
+ * modules render as the one row a user sees rather than in registration order.
  */
 export declare const c4LegendToolbarConfig: {
-    readonly actions: [{
-        readonly id: "b.legend";
-        readonly tooltipWording: import("@formicoidea/labre-core/shared/services").ChromeWording;
-        readonly icon: TemplateResult<1>;
-        readonly run: (ctx: ToolbarContext) => void;
-    }];
+    readonly actions: [import("@formicoidea/labre-core/shared/services").ToolbarAction];
     readonly when: (ctx: ToolbarContext) => boolean;
 };
 /**

package/dist/toolbar/config.js

@@ -1,10 +1,8 @@
-import { EdgelessCRUDIdentifier, validationToolbarConfig, } from '@formicoidea/labre-core/blocks/surface';
-import { dddLegendIcon } from '@formicoidea/labre-ddd-shared';
+import { EdgelessCRUDIdentifier, legendToolbarAction, validationToolbarConfig, } from '@formicoidea/labre-core/blocks/surface';
 import { C4BoardElementModel } from '@formicoidea/labre-core/model';
-import { ActionPlacement, BOARD_LEGEND_NOTATION, BOARD_RESIZE_TOGGLE, TelemetryProvider, ToolbarModuleExtension, translateKey, } from '@formicoidea/labre-core/shared/services';
-import { BlockFlavourIdentifier, getRegisteredCommands, runCommand, } from '@formicoidea/labre-core/std';
+import { BOARD_RESIZE_TOGGLE, commandMoreAction, TelemetryProvider, ToolbarModuleExtension, translateKey, } from '@formicoidea/labre-core/shared/services';
+import { BlockFlavourIdentifier } from '@formicoidea/labre-core/std';
 import { html, nothing } from 'lit';
-import { createC4Legend } from '../actions.js';
 import { C4_BOARD_LEVEL_MENU } from '../levels.js';
 import { c4ExportMermaidIcon } from './icons.js';
 const ResizeIcon = html `<svg
@@ -56,55 +54,6 @@ const CheckIcon = html `<svg
 >
   <path d="M5 12.5l4.5 4.5L19 7.5" />
 </svg>`;
-const findCommand = (ctx, id) => getRegisteredCommands(ctx.std).find(candidate => candidate.id === id);
-/**
- * A "⋮" entry that INVOKES a registered command instead of restating what it
- * does — the shape `docs/adr/0010` M3 introduced, and the reason the export has
- * one behaviour, one availability rule and one telemetry emission whether it is
- * reached from here, from the catalogue, from the palette, from
- * Settings › Shortcuts or from the agent.
- *
- * Two things the widget imposes: a menu line is drawn from `label` (a tooltip on
- * a line that is already words would be a second copy of them), and
- * `placement: ActionPlacement.More` is what partitions it out of the row in the
- * first place — `renderToolbar` splits on exactly that flag, and the entries it
- * collects come from every module contributing to the element, so a framework
- * can add to the "⋮" without owning it.
- *
- * `generate` rather than a static entry because the i18n seam needs `std`:
- * `translateKey` is what reaches the host's catalogue, and a hard-coded English
- * label would be the one wording a host could not override.
- *
- * Lifted from the BPMN pool's row, where `bpmn.exportXml` sits in exactly this
- * position.
- */
-function commandMoreAction(id, commandId, labelKey, labelFallback, icon) {
-    return {
-        id,
-        placement: ActionPlacement.More,
-        when: (ctx) => {
-            const command = findCommand(ctx, commandId);
-            return command !== undefined && (command.when?.(ctx.std) ?? true);
-        },
-        generate: (ctx) => ({
-            icon,
-            label: translateKey(ctx.std, labelKey, labelFallback),
-            run: (runCtx) => {
-                const command = findCommand(runCtx, commandId);
-                if (!command)
-                    return;
-                // The same `source` the row's own entries report: the "⋮" is a
-                // degradation of the row, not a surface of its own, and the
-                // `ElementCreationSource` union deliberately names places rather than
-                // widths (`docs/adr/0008`).
-                runCommand(runCtx.std, command, {
-                    surface: 'contextual-toolbar',
-                    source: 'toolbar:general',
-                });
-            },
-        }),
-    };
-}
 /**
  * The selected C4 board's contextual toolbar: the resize toggle, and the
  * automatic legend of what is actually drawn on the board.
@@ -118,15 +67,14 @@ function commandMoreAction(id, commandId, labelKey, labelFallback, icon) {
  * The PO's call is that generating one belongs to a board you have SELECTED and
  * to nothing else: it is not an artefact to pick off a palette, and an entry in
  * a catalogue of things C4 draws would offer it to a user with no board in front
- * of them. So there is no `c4.legend` command, this button is the only way to
- * reach it, and the telemetry it owes is emitted by hand below.
+ * of them. So there is no `c4.legend` command, and this button is the only way
+ * to reach it.
  *
- * That is the same shape — and the same exception — the Context Map board makes
- * (`ddd-context-map/src/toolbar/board-config.ts`), down to the payload, so the
- * two frameworks' legends stay comparable on one dashboard. The cost is the one
- * the bottleneck exists to avoid and is accepted knowingly: this `track()` call
- * is a second emitter, and it is on whoever edits it to keep the wire values
- * matching what `reportCommandTelemetry` would have sent.
+ * That is the same shape — and the same exception — every other framework with a
+ * legend makes. The cost is the one the bottleneck exists to avoid: the
+ * telemetry it owes is emitted outside `runCommand`. It is emitted ONCE, by the
+ * shared factory (`legend-toolbar.ts`), so the seven copies of those wire values
+ * that used to sit in seven files can no longer drift apart.
  *
  * ## Two modules on one element, and why
  *
@@ -345,32 +293,21 @@ const levelPickerAction = {
 /**
  * The legend button — the flag-gated half of the row (see the note above).
  *
- * `b.` sorts it after the resize toggle, so the two modules render as the one
- * row a user sees rather than in registration order.
+ * The SHARED factory, not a C4 copy of it: the button, the placement, the box
+ * and the one `FrameworkLegendCreated` emission all live in the surface block
+ * (`legend-toolbar.ts`, `docs/adr/0026`), and C4 hands it the board model to
+ * look for, whose commands to read the rows off, and the historical wire value.
+ *
+ * `b.` — the factory's default — sorts it after the resize toggle, so the two
+ * modules render as the one row a user sees rather than in registration order.
  */
 export const c4LegendToolbarConfig = {
     actions: [
-        {
-            id: 'b.legend',
-            tooltipWording: BOARD_LEGEND_NOTATION,
-            icon: dddLegendIcon,
-            run(ctx) {
-                createC4Legend(ctx.std);
-                ctx.std
-                    .getOptional(TelemetryProvider)
-                    ?.track('FrameworkLegendCreated', {
-                    // The WIRE values, and they are the ones `reportCommandTelemetry`
-                    // would have sent for a `kind: 'legend'` command — `framework` from
-                    // the descriptor's `telemetryKey`, `element: 'legend'` as Wardley
-                    // and the Context Map both emit, so the three are one metric.
-                    framework: 'c4',
-                    element: 'legend',
-                    page: 'whiteboard editor',
-                    segment: 'element toolbar',
-                    module: 'c4 toolbar',
-                });
-            },
-        },
+        legendToolbarAction({
+            Model: C4BoardElementModel,
+            owner: 'c4',
+            framework: 'c4',
+        }),
     ],
     when: (ctx) => ctx.getSurfaceModelsByType(C4BoardElementModel).length > 0,
 };

package/dist/toolbar/icons.d.ts

@@ -67,11 +67,14 @@ export declare const c4ExportMermaidIcon: import("lit-html").TemplateResult<2>;
  *
  * {@link c4ExportMermaidIcon} is deliberately NOT here and is added to
  * `c4CommandIcons` in `commands.ts` instead: this record is the TOOLBOX — the
- * thirteen glyphs of things C4 DRAWS — and an export draws nothing.
+ * thirteen glyphs of things C4 DRAWS — and an export draws nothing. The same
+ * goes for {@link c4ToolbarIcon}, registered there under `c4.toolbar` for
+ * `FrameworkDescriptor.iconKey`; it is the one key that test exempts from the
+ * glyph ⇄ command bijection.
  *
  * The legend's glyph is in neither, because the legend is no longer a command at
- * all: it is `dddLegendIcon`, referenced straight from `config.ts` by the button
- * that is now the only way to reach it (PO arbitration, 27/08/2026).
+ * all: it is the surface block's own `legendIcon`, drawn by the shared button
+ * factory that is now the only way to reach it (PO arbitration, 27/08/2026).
  */
 export declare const C4_TOOLBOX_ICONS: {
     readonly 'c4.person': import("lit-html").TemplateResult<2>;

package/dist/toolbar/icons.js

@@ -134,11 +134,14 @@ export const c4ExportMermaidIcon = svg `<svg width="24" height="24" viewBox="0 0
  *
  * {@link c4ExportMermaidIcon} is deliberately NOT here and is added to
  * `c4CommandIcons` in `commands.ts` instead: this record is the TOOLBOX — the
- * thirteen glyphs of things C4 DRAWS — and an export draws nothing.
+ * thirteen glyphs of things C4 DRAWS — and an export draws nothing. The same
+ * goes for {@link c4ToolbarIcon}, registered there under `c4.toolbar` for
+ * `FrameworkDescriptor.iconKey`; it is the one key that test exempts from the
+ * glyph ⇄ command bijection.
  *
  * The legend's glyph is in neither, because the legend is no longer a command at
- * all: it is `dddLegendIcon`, referenced straight from `config.ts` by the button
- * that is now the only way to reach it (PO arbitration, 27/08/2026).
+ * all: it is the surface block's own `legendIcon`, drawn by the shared button
+ * factory that is now the only way to reach it (PO arbitration, 27/08/2026).
  */
 export const C4_TOOLBOX_ICONS = {
     'c4.person': c4PersonIcon,

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,13 +1,13 @@
 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_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_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
@@ -39,6 +39,16 @@ const seedEntries = () => [
         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,
@@ -79,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(), 
+]), 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

@@ -164,7 +164,7 @@ export declare const C4_TYPE_PLACEHOLDER: Record<C4NodeKind, string>;
  * 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
+ * (`docs/adr/0023`). With no `std` this returns exactly
  * `C4_TYPE_PLACEHOLDER[kind]`.
  */
 export declare function c4TypePlaceholder(kind: C4NodeKind, std?: BlockStdScope): string;

package/dist/type-line.js

@@ -295,7 +295,7 @@ export const C4_TYPE_PLACEHOLDER = Object.fromEntries(Object.keys(C4_TYPE_WORD).
  * 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
+ * (`docs/adr/0023`). With no `std` this returns exactly
  * `C4_TYPE_PLACEHOLDER[kind]`.
  */
 export function c4TypePlaceholder(kind, 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.41.0",
+  "version": "0.43.1",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -31,8 +31,8 @@
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.41.0",
-    "@formicoidea/labre-ddd-shared": "0.41.0",
+    "@formicoidea/labre-core": "0.43.1",
+    "@formicoidea/labre-ddd-shared": "0.43.1",
     "lit": "^3.2.0"
   }
 }

package/dist/legend.d.ts

@@ -1,5 +0,0 @@
-import { type AutoLegendSpec } from '@formicoidea/labre-ddd-shared';
-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;