@formicoidea/labre-framework-wardley 0.40.0 → 0.42.0

package/dist/toolbar/config.js

@@ -1,10 +1,48 @@
-import { EdgelessCRUDIdentifier } from '@formicoidea/labre-core/blocks/surface';
+import { EdgelessCRUDIdentifier, legendToolbarAction, validationToolbarConfig, } from '@formicoidea/labre-core/blocks/surface';
 import { WardleyBackgroundElementModel } from '@formicoidea/labre-core/model';
-import { BOARD_LEGEND_COMPONENTS, BOARD_RESIZE_TOGGLE, TelemetryProvider, ToolbarModuleExtension, } from '@formicoidea/labre-core/shared/services';
+import { BOARD_LEGEND_COMPONENTS, BOARD_RESIZE_TOGGLE, commandMoreAction, ToolbarModuleExtension, } from '@formicoidea/labre-core/shared/services';
 import { BlockFlavourIdentifier } from '@formicoidea/labre-core/std';
 import { html } from 'lit';
-import { createWardleyLegend } from '../legend.js';
-import { wardleyLegendIcon } from './icons.js';
+import { wardleyExportOwmIcon, wardleyLegendIcon } from './icons.js';
+/** The seven toolbar tooltips this file used to hard-code as English literals. */
+const EVOLUTION_AXIS_TOGGLE = [
+    'com.labre.wardley.toolbar.evolution-axis',
+    'Evolution axis (X)',
+];
+const EVOLUTION_PHASE_LABELS_TOGGLE = [
+    'com.labre.wardley.toolbar.evolution-phase-labels',
+    'Evolution phase labels',
+];
+const COLUMNS_TOGGLE = [
+    'com.labre.wardley.toolbar.columns',
+    'Columns (dividers)',
+];
+const CORNER_LABELS_TOGGLE = [
+    'com.labre.wardley.toolbar.corner-labels',
+    'Labels Uncharted / Industrialized',
+];
+const GRADIENT_TOGGLE = [
+    'com.labre.wardley.toolbar.gradient',
+    'Show / hide the gradient',
+];
+const VALUE_CHAIN_AXIS_TOGGLE = [
+    'com.labre.wardley.toolbar.value-chain-axis',
+    'Value Chain axis (Y)',
+];
+const VISIBILITY_LABELS_TOGGLE = [
+    'com.labre.wardley.toolbar.visibility-labels',
+    'Labels Visible / Invisible',
+];
+/** Every wording above, for `translations.ts`'s manifest contribution. */
+export const WARDLEY_TOOLBAR_WORDINGS = [
+    EVOLUTION_AXIS_TOGGLE,
+    EVOLUTION_PHASE_LABELS_TOGGLE,
+    COLUMNS_TOGGLE,
+    CORNER_LABELS_TOGGLE,
+    GRADIENT_TOGGLE,
+    VALUE_CHAIN_AXIS_TOGGLE,
+    VISIBILITY_LABELS_TOGGLE,
+];
 const ResizeIcon = html `<svg
   width="24"
   height="24"
@@ -162,12 +200,12 @@ export const wardleyToolbarConfig = {
         {
             id: 'b.evolution',
             actions: [
-                booleanToggle('b.1-axis-x', 'Evolution axis (X)', XAxisIcon, 'showXAxis'),
-                booleanToggle('b.2-column-labels', 'Evolution phase labels', ColumnLabelsIcon, 'showColumnLabels'),
-                booleanToggle('b.3-columns', 'Columns (dividers)', ColumnsIcon, 'showColumnDividers'),
-                booleanToggle('b.4-corner-labels', 'Labels Uncharted / Industrialized', CornerLabelsIcon, 'showCornerLabels'),
+                booleanToggle('b.1-axis-x', EVOLUTION_AXIS_TOGGLE, XAxisIcon, 'showXAxis'),
+                booleanToggle('b.2-column-labels', EVOLUTION_PHASE_LABELS_TOGGLE, ColumnLabelsIcon, 'showColumnLabels'),
+                booleanToggle('b.3-columns', COLUMNS_TOGGLE, ColumnsIcon, 'showColumnDividers'),
+                booleanToggle('b.4-corner-labels', CORNER_LABELS_TOGGLE, CornerLabelsIcon, 'showCornerLabels'),
                 // Only relevant when the selection has a gradient variant.
-                booleanToggle('b.5-gradient', 'Show / hide the gradient', GradientIcon, 'showGradient', ctx => ctx
+                booleanToggle('b.5-gradient', GRADIENT_TOGGLE, GradientIcon, 'showGradient', ctx => ctx
                     .getSurfaceModelsByType(WardleyBackgroundElementModel)
                     .some(model => model.variant !== 'classic')),
             ],
@@ -176,33 +214,18 @@ export const wardleyToolbarConfig = {
         {
             id: 'c.value-chain',
             actions: [
-                booleanToggle('c.1-axis-y', 'Value Chain axis (Y)', YAxisIcon, 'showYAxis'),
-                booleanToggle('c.2-visibility-labels', 'Labels Visible / Invisible', VisibilityIcon, 'showVisibilityLabels'),
+                booleanToggle('c.1-axis-y', VALUE_CHAIN_AXIS_TOGGLE, YAxisIcon, 'showYAxis'),
+                booleanToggle('c.2-visibility-labels', VISIBILITY_LABELS_TOGGLE, VisibilityIcon, 'showVisibilityLabels'),
             ],
         },
-        // Generate the auto-legend from the components present inside this
-        // background's perimeter (+ a gradient-meaning block for gradient variants).
-        {
-            id: 'd.legend',
-            tooltipWording: BOARD_LEGEND_COMPONENTS,
-            icon: wardleyLegendIcon,
-            run(ctx) {
-                const models = ctx.getSurfaceModelsByType(WardleyBackgroundElementModel);
-                const bg = models[0];
-                if (!bg)
-                    return;
-                createWardleyLegend(ctx.std, bg);
-                ctx.std
-                    .getOptional(TelemetryProvider)
-                    ?.track('FrameworkLegendCreated', {
-                    framework: 'wardley',
-                    element: 'legend',
-                    page: 'whiteboard editor',
-                    segment: 'element toolbar',
-                    module: 'wardley toolbar',
-                });
-            },
-        },
+        // The OWM export, in the "⋮" — R5 of
+        // `docs/add-a-framework/02-framework-rules.md`, the position
+        // `bpmn.exportXml` and `c4.exportMermaid` already hold on their own boards.
+        // This module is registered ALWAYS-ON (`view.ts`) while the commands are
+        // flag-gated, and that needs no extra guard: the entry's `when` looks the
+        // command up in the registry and withdraws when the wardley flag left it
+        // unregistered.
+        commandMoreAction('z.export-owm', 'wardley.exportOwm', 'com.labre.commands.wardley.exportOwm', 'Export Wardley map (OWM)', wardleyExportOwmIcon),
     ],
     when: ctx => ctx.getSurfaceModelsByType(WardleyBackgroundElementModel).length > 0,
 };
@@ -210,3 +233,55 @@ export const wardleyToolbarExtension = ToolbarModuleExtension({
     id: BlockFlavourIdentifier('affine:surface:wardley'),
     config: wardleyToolbarConfig,
 });
+/**
+ * The map's flag-gated row, WHOLE: the Legend button and the Validation
+ * dropdown, in one module.
+ *
+ * ## Why they cannot be two modules
+ *
+ * `renderToolbar` merges exactly four slots per element — `<flavour>`,
+ * `custom:<flavour>` and the two `affine:surface:*` wildcards — and
+ * `ToolbarModuleExtension` binds by DI variant, so a second module claiming
+ * `custom:affine:surface:wardley` would throw
+ * `DuplicateServiceDefinitionError` before the editor finished setting up. Two
+ * slots, and Wardley has three things to put on a selected map: the axis and
+ * label toggles (always-on, `<flavour>`, above), the legend and the level of
+ * requirement. The precedent is C4's `c4BoardToolingToolbarConfig`.
+ *
+ * ## Why the legend moved OUT of the always-on half
+ *
+ * Because GENERATING one is tooling, and `docs/adr/0009` gates tooling: the
+ * flag off takes away the gesture that writes legend elements, exactly as it
+ * takes away the sub-menu that draws components. What the gesture already
+ * wrote is document CONTENT and keeps being painted — the box is plain shapes,
+ * text and `wardleyNode`s with no role, all drawn by the always-on renderers.
+ * The axis and label toggles stay always-on for the opposite reason: a stored
+ * map must keep its axes whatever the flag says.
+ *
+ * Sorting keeps the row readable across the merge — `a.` … `d.legend` from the
+ * two modules, then `z.validation` — whatever order they were registered in.
+ */
+export const wardleyBoardToolingToolbarConfig = {
+    actions: [
+        // `d.legend` and not the factory's default `b.legend`: the row is sorted
+        // lexicographically by id and the two axis groups already hold `b.` and
+        // `c.`, so the legend reads after the toggles it documents the map beside.
+        legendToolbarAction({
+            id: 'd.legend',
+            Model: WardleyBackgroundElementModel,
+            owner: 'wardley',
+            framework: 'wardley',
+            tooltipWording: BOARD_LEGEND_COMPONENTS,
+            icon: wardleyLegendIcon,
+        }),
+        // The generic dropdown, not a Wardley variant of it: the config names no
+        // framework — it reads the registered rules and profiles — so this is the
+        // very same object c4, bpmn and the context map register.
+        ...validationToolbarConfig.actions,
+    ],
+    when: wardleyToolbarConfig.when,
+};
+export const wardleyBoardToolingToolbarExtension = ToolbarModuleExtension({
+    id: BlockFlavourIdentifier('custom:affine:surface:wardley'),
+    config: wardleyBoardToolingToolbarConfig,
+});

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

@@ -1,4 +1,6 @@
-import { type Color, type Palette, type ShapeElementModel } from '@formicoidea/labre-core/model';
+import type { FrameworkPalette, NamedPalette } from '@formicoidea/labre-core/components/color-picker';
+import { type Color, type ShapeElementModel } from '@formicoidea/labre-core/model';
+import { type ChromeWording } from '@formicoidea/labre-core/shared/services';
 /**
  * What a picked swatch WRITES on a Wardley node.
  *
@@ -13,9 +15,39 @@ import { type Color, type Palette, type ShapeElementModel } from '@formicoidea/l
  * (`--affine-…`) is not a hex at all and must reach the document intact.
  */
 export declare function wardleyFillColor(model: ShapeElementModel, value: Color): Color;
+/**
+ * The nine Wardley swatches' own names, resolved by `resolvePaletteLabel`
+ * (`@labre/affine-components/color-picker`) through each swatch's own
+ * {@link NamedPalette.labelWording} — the framework-agnostic mechanism a
+ * gfx module uses to name a palette without touching `Palette`
+ * (`packages/affine/model`, RED ZONE) or importing another framework.
+ *
+ * Exported so `../translations.ts` can list them in the manifest under
+ * source `chrome`, the same treatment `WARDLEY_TOOLBAR_WORDINGS` already
+ * gets — a swatch's name is toolbar chrome, re-rendered on every locale
+ * switch, never seeded into a document.
+ */
+export declare const WARDLEY_PALETTE_WORDING_WONDER: ChromeWording;
+export declare const WARDLEY_PALETTE_WORDING_PEACE: ChromeWording;
+export declare const WARDLEY_PALETTE_WORDING_WAR: ChromeWording;
+export declare const WARDLEY_PALETTE_WORDING_WONDER_LIGHT: ChromeWording;
+export declare const WARDLEY_PALETTE_WORDING_PEACE_LIGHT: ChromeWording;
+export declare const WARDLEY_PALETTE_WORDING_WAR_LIGHT: ChromeWording;
+export declare const WARDLEY_PALETTE_WORDING_RED: ChromeWording;
+export declare const WARDLEY_PALETTE_WORDING_INERTIA: ChromeWording;
+export declare const WARDLEY_PALETTE_WORDING_METHOD_GREY: ChromeWording;
+export declare const WARDLEY_PALETTE_WORDINGS: readonly ChromeWording[];
 /**
  * From the default editor palette we keep ONLY the neutrals — the historical
  * colours are dropped in favour of the Wardley swatches above.
  */
-export declare const WARDLEY_PALETTE_LIST: Palette[];
+export declare const WARDLEY_PALETTE_LIST: NamedPalette[];
+/**
+ * Wardley's page of the colour pickers' carousel (`docs/adr/0027`) — the very
+ * list its own node picker is seeded with, offered on every other picker too:
+ * a connector between two components, a free-text label, a frame drawn over
+ * the map. Registered from the FLAG-GATED view extension, because offering
+ * hues is tooling (`docs/adr/0009`).
+ */
+export declare const WARDLEY_FRAMEWORK_PALETTE: FrameworkPalette;
 export declare const wardleyNodeToolbarExtension: import("@formicoidea/labre-core/store").ExtensionType;

package/dist/toolbar/node-config.js

@@ -29,6 +29,65 @@ export function wardleyFillColor(model, value) {
         return value;
     return `${value}${AREA_ALPHA}`;
 }
+/**
+ * The nine Wardley swatches' own names, resolved by `resolvePaletteLabel`
+ * (`@labre/affine-components/color-picker`) through each swatch's own
+ * {@link NamedPalette.labelWording} — the framework-agnostic mechanism a
+ * gfx module uses to name a palette without touching `Palette`
+ * (`packages/affine/model`, RED ZONE) or importing another framework.
+ *
+ * Exported so `../translations.ts` can list them in the manifest under
+ * source `chrome`, the same treatment `WARDLEY_TOOLBAR_WORDINGS` already
+ * gets — a swatch's name is toolbar chrome, re-rendered on every locale
+ * switch, never seeded into a document.
+ */
+export const WARDLEY_PALETTE_WORDING_WONDER = [
+    'com.labre.wardley.palette.wonder',
+    'Wonder',
+];
+export const WARDLEY_PALETTE_WORDING_PEACE = [
+    'com.labre.wardley.palette.peace',
+    'Peace',
+];
+export const WARDLEY_PALETTE_WORDING_WAR = [
+    'com.labre.wardley.palette.war',
+    'War',
+];
+export const WARDLEY_PALETTE_WORDING_WONDER_LIGHT = [
+    'com.labre.wardley.palette.wonder-light',
+    'Wonder light',
+];
+export const WARDLEY_PALETTE_WORDING_PEACE_LIGHT = [
+    'com.labre.wardley.palette.peace-light',
+    'Peace light',
+];
+export const WARDLEY_PALETTE_WORDING_WAR_LIGHT = [
+    'com.labre.wardley.palette.war-light',
+    'War light',
+];
+export const WARDLEY_PALETTE_WORDING_RED = [
+    'com.labre.wardley.palette.wardley-red',
+    'Wardley red',
+];
+export const WARDLEY_PALETTE_WORDING_INERTIA = [
+    'com.labre.wardley.palette.inertia',
+    'Inertia',
+];
+export const WARDLEY_PALETTE_WORDING_METHOD_GREY = [
+    'com.labre.wardley.palette.method-grey',
+    'Method grey',
+];
+export const WARDLEY_PALETTE_WORDINGS = [
+    WARDLEY_PALETTE_WORDING_WONDER,
+    WARDLEY_PALETTE_WORDING_PEACE,
+    WARDLEY_PALETTE_WORDING_WAR,
+    WARDLEY_PALETTE_WORDING_WONDER_LIGHT,
+    WARDLEY_PALETTE_WORDING_PEACE_LIGHT,
+    WARDLEY_PALETTE_WORDING_WAR_LIGHT,
+    WARDLEY_PALETTE_WORDING_RED,
+    WARDLEY_PALETTE_WORDING_INERTIA,
+    WARDLEY_PALETTE_WORDING_METHOD_GREY,
+];
 /**
  * The Wardley **evolution cycle**, surfaced as ready-made swatches in the node
  * colour picker: Wonder / Peace / War, the three climatic phases a component
@@ -41,15 +100,47 @@ export function wardleyFillColor(model, value) {
  * an author is free to ignore them, and the custom picker stays one click away.
  */
 const WARDLEY_PALETTES = [
-    { key: 'Wonder', value: '#3ec9f2' },
-    { key: 'Peace', value: '#5b9cf6' },
-    { key: 'War', value: '#9d6df0' },
-    { key: 'Wonder light', value: '#b9e9fa' },
-    { key: 'Peace light', value: '#c6dbfc' },
-    { key: 'War light', value: '#d9c9fa' },
-    { key: 'Wardley red', value: WARDLEY_RED },
-    { key: 'Inertia', value: INERTIA_COLOR },
-    { key: 'Method grey', value: METHOD_FILL },
+    {
+        key: 'Wonder',
+        value: '#3ec9f2',
+        labelWording: WARDLEY_PALETTE_WORDING_WONDER,
+    },
+    {
+        key: 'Peace',
+        value: '#5b9cf6',
+        labelWording: WARDLEY_PALETTE_WORDING_PEACE,
+    },
+    { key: 'War', value: '#9d6df0', labelWording: WARDLEY_PALETTE_WORDING_WAR },
+    {
+        key: 'Wonder light',
+        value: '#b9e9fa',
+        labelWording: WARDLEY_PALETTE_WORDING_WONDER_LIGHT,
+    },
+    {
+        key: 'Peace light',
+        value: '#c6dbfc',
+        labelWording: WARDLEY_PALETTE_WORDING_PEACE_LIGHT,
+    },
+    {
+        key: 'War light',
+        value: '#d9c9fa',
+        labelWording: WARDLEY_PALETTE_WORDING_WAR_LIGHT,
+    },
+    {
+        key: 'Wardley red',
+        value: WARDLEY_RED,
+        labelWording: WARDLEY_PALETTE_WORDING_RED,
+    },
+    {
+        key: 'Inertia',
+        value: INERTIA_COLOR,
+        labelWording: WARDLEY_PALETTE_WORDING_INERTIA,
+    },
+    {
+        key: 'Method grey',
+        value: METHOD_FILL,
+        labelWording: WARDLEY_PALETTE_WORDING_METHOD_GREY,
+    },
 ];
 /**
  * From the default editor palette we keep ONLY the neutrals — the historical
@@ -59,6 +150,18 @@ export const WARDLEY_PALETTE_LIST = [
     ...WARDLEY_PALETTES,
     ...neutralPalettes(),
 ];
+/**
+ * Wardley's page of the colour pickers' carousel (`docs/adr/0027`) — the very
+ * list its own node picker is seeded with, offered on every other picker too:
+ * a connector between two components, a free-text label, a frame drawn over
+ * the map. Registered from the FLAG-GATED view extension, because offering
+ * hues is tooling (`docs/adr/0009`).
+ */
+export const WARDLEY_FRAMEWORK_PALETTE = {
+    framework: 'wardley',
+    labelWording: ['com.labre.framework.wardley', 'Wardley map'],
+    palettes: WARDLEY_PALETTE_LIST,
+};
 /**
  * Wardley nodes are {@link ShapeElementModel} subclasses, so the shape toolbar's
  * actions (which target `getSurfaceModelsByType(ShapeElementModel)`) operate on

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

@@ -12,6 +12,14 @@ export declare class EdgelessWardleySeniorButton extends EdgelessWardleySeniorBu
     enableActiveBackground: boolean;
     type: typeof EmptyTool;
     private _toggleMenu;
+    /**
+     * Lit while one of THIS framework's artefacts is armed under the cursor, as
+     * well as while its menu is open. The menu closes the moment the pointer goes
+     * to the board, so without this the ghost would be traceable to no button at
+     * all — and Shift+S, which walks that ghost along this framework's row, would
+     * read as a keystroke belonging to nothing.
+     */
+    private get _armed();
     render(): import("lit-html").TemplateResult<1>;
 }
 export {};

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

@@ -1,7 +1,7 @@
 import { DefaultTool } from '@formicoidea/labre-core/blocks/surface';
 import { EmptyTool } from '@formicoidea/labre-core/gfx/pointer';
 import { translateKey } from '@formicoidea/labre-core/shared/services';
-import { EdgelessToolbarToolMixin } from '@formicoidea/labre-core/widgets/edgeless-toolbar';
+import { armedArtefact, EdgelessToolbarToolMixin, } from '@formicoidea/labre-core/widgets/edgeless-toolbar';
 import { SignalWatcher } from '@formicoidea/labre-core/global/lit';
 import { css, html, LitElement } from 'lit';
 import { wardleyToolbarIcon } from './icons.js';
@@ -80,6 +80,16 @@ export class EdgelessWardleySeniorButton extends EdgelessToolbarToolMixin(Signal
         const menu = this.createPopper('edgeless-wardley-menu', this);
         menu.element.edgeless = this.edgeless;
     }
+    /**
+     * Lit while one of THIS framework's artefacts is armed under the cursor, as
+     * well as while its menu is open. The menu closes the moment the pointer goes
+     * to the board, so without this the ghost would be traceable to no button at
+     * all — and Shift+S, which walks that ghost along this framework's row, would
+     * read as a keystroke belonging to nothing.
+     */
+    get _armed() {
+        return armedArtefact(this.gfx)?.owner === 'wardley';
+    }
     render() {
         return html `<edgeless-toolbar-button
       class="wardley-button"
@@ -87,7 +97,7 @@ export class EdgelessWardleySeniorButton extends EdgelessToolbarToolMixin(Signal
             ? ''
             : translateKey(this.edgeless.std, 'com.labre.framework.wardley', 'Wardley map')}
       .tooltipOffset=${4}
-      .active=${!!this.popper}
+      .active=${!!this.popper || this._armed}
       @click=${this._toggleMenu}
     >
       <div class="wardley-root">

package/dist/translations.js

@@ -1,12 +1,88 @@
+import { tagDefsTranslationEntries } from '@formicoidea/labre-core/shared/services';
 import { collectTranslationKeys, commandCategoryTranslationEntries, commandTranslationEntries, mergeTranslationEntries, } from '@formicoidea/labre-core/std';
+import { WARDLEY_AXIS_SEED } from './actions.js';
 import { WARDLEY_AUDIT_CRITERIA } from './audit-criteria.js';
 import { WARDLEY_BACKGROUND } from './background.js';
 import { wardleyCommands } from './commands.js';
+import { WARDLEY_OWM_IMPORT_REMARKS } from './import.js';
+import { WARDLEY_LEGEND_WORDINGS } from './legend.js';
+import { WARDLEY_TAG_DEFS } from './natures.js';
 import { WARDLEY_NUDGES } from './nudges.js';
+import { WARDLEY_NODE_LABEL, wardleyNodeLabelKey } from './presets.js';
 import { WARDLEY_PROFILES } from './profiles.js';
 import { WARDLEY_READING } from './reading.js';
 import { WARDLEY_ROLES } from './roles.js';
 import { WARDLEY_RULES } from './rules.js';
+import { KODAK_INERTIA_SEED, TEA_SHOP_SEED, WARDLEY_TEMPLATE_NAME_KODAK_INERTIA, WARDLEY_TEMPLATE_NAME_TEA_SHOP, } from './templates/maps.js';
+import { WARDLEY_TEMPLATE_NAME_AREA_POLYGON, WARDLEY_TEMPLATE_NAME_EVOLUTION_ARROW, WARDLEY_TEMPLATE_NAME_LINK, } from './templates/index.js';
+import { WARDLEY_TOOLBAR_WORDINGS } from './toolbar/config.js';
+import { WARDLEY_PALETTE_WORDINGS } from './toolbar/node-config.js';
+/**
+ * The prompt every labelled artefact is created NEXT TO — the fallback IS
+ * `WARDLEY_NODE_LABEL[kind]`, never restated, mirroring BPMN's `seedEntries`.
+ */
+const nodeSeedEntries = () => Object.entries(WARDLEY_NODE_LABEL).map(([kind, label]) => ({
+    key: wardleyNodeLabelKey(kind),
+    fallback: label,
+    source: 'seed',
+}));
+/** The three axis words a translated background variant is seeded with. */
+const axisSeedEntries = () => Object.values(WARDLEY_AXIS_SEED).map(({ key, fallback }) => ({
+    key,
+    fallback,
+    source: 'seed',
+}));
+/**
+ * The seeds the two worked-example maps write — derived from the very tables
+ * `templates/maps.ts` reads at placement.
+ */
+const exampleSeedEntries = () => [...Object.values(TEA_SHOP_SEED), ...Object.values(KODAK_INERTIA_SEED)].map(({ key, fallback }) => ({ key, fallback, source: 'seed' }));
+/**
+ * The auto-legend's own wordings — title, row captions, gradient blocks and
+ * the Porter panel — derived from `legend.ts`'s own `WARDLEY_LEGEND_WORDINGS`,
+ * the very declarations the rows subscribe and the two extras write when the
+ * group lands on the canvas.
+ */
+const legendSeedEntries = () => WARDLEY_LEGEND_WORDINGS.map(([key, fallback]) => ({
+    key,
+    fallback,
+    source: 'seed',
+}));
+/** The toolbar tooltips this framework used to hard-code as English literals. */
+const toolbarChromeEntries = () => WARDLEY_TOOLBAR_WORDINGS.map(([key, fallback]) => ({
+    key,
+    fallback,
+    source: 'chrome',
+}));
+/**
+ * The five hand-composed cards' own tile names — chrome, not seeds: a
+ * `Template.nameKey`, re-resolved every time the panel opens, never written
+ * into a document. See `templates/index.ts` and `templates/maps.ts`.
+ */
+const templateNameEntries = () => [
+    WARDLEY_TEMPLATE_NAME_LINK,
+    WARDLEY_TEMPLATE_NAME_EVOLUTION_ARROW,
+    WARDLEY_TEMPLATE_NAME_AREA_POLYGON,
+    WARDLEY_TEMPLATE_NAME_TEA_SHOP,
+    WARDLEY_TEMPLATE_NAME_KODAK_INERTIA,
+].map(([key, fallback]) => ({ key, fallback, source: 'chrome' }));
+/** The five fixed-wording OWM import remarks ({@link WARDLEY_OWM_IMPORT_REMARKS}). */
+const importRemarkEntries = () => Object.values(WARDLEY_OWM_IMPORT_REMARKS).map(([key, english]) => ({
+    key,
+    fallback: english,
+    source: 'chrome',
+}));
+/**
+ * The nine node-colour-picker swatches' own names (`WARDLEY_PALETTE_WORDINGS`,
+ * `toolbar/node-config.ts`) — chrome, like the toolbar tooltips above: a
+ * swatch's name is re-rendered on every locale switch, never seeded into a
+ * document.
+ */
+const paletteWordingEntries = () => WARDLEY_PALETTE_WORDINGS.map(([key, fallback]) => ({
+    key,
+    fallback,
+    source: 'chrome',
+}));
 /**
  * THIS framework's contribution to the translation-key manifest — every
  * `com.labre.*` key Wardley can hand to `TranslationProvider.t`, derived from
@@ -27,4 +103,8 @@ export const wardleyTranslationEntries = mergeTranslationEntries(commandTranslat
 // registry names no framework category in the bundled distribution, so a
 // host that composed core's manifest alone drew translated entries under
 // English headers (#183).
-commandCategoryTranslationEntries(wardleyCommands), collectTranslationKeys('role', WARDLEY_ROLES), collectTranslationKeys('background', WARDLEY_BACKGROUND), collectTranslationKeys('rule', WARDLEY_RULES), collectTranslationKeys('nudge', WARDLEY_NUDGES), collectTranslationKeys('profile', WARDLEY_PROFILES), collectTranslationKeys('audit-criterion', WARDLEY_AUDIT_CRITERIA), collectTranslationKeys('reading', WARDLEY_READING));
+commandCategoryTranslationEntries(wardleyCommands), collectTranslationKeys('role', WARDLEY_ROLES), collectTranslationKeys('background', WARDLEY_BACKGROUND), collectTranslationKeys('rule', WARDLEY_RULES), collectTranslationKeys('nudge', WARDLEY_NUDGES), collectTranslationKeys('profile', WARDLEY_PROFILES), collectTranslationKeys('audit-criterion', WARDLEY_AUDIT_CRITERIA), nodeSeedEntries(), axisSeedEntries(), exampleSeedEntries(), legendSeedEntries(), templateNameEntries(), toolbarChromeEntries(), importRemarkEntries(), paletteWordingEntries(), collectTranslationKeys('reading', WARDLEY_READING), 
+// The library's own tag pack (`WARDLEY_TAG_DEFS`) — the natures and the
+// Porter competition tags. A host's app-seeded pack needs no entry here:
+// see `tagDefsTranslationEntries`.
+tagDefsTranslationEntries(WARDLEY_TAG_DEFS));

package/dist/view.js

@@ -1,5 +1,6 @@
-import { InterchangeExtension, morphToolbarConfig, ReadingProfileExtension, tagsToolbarConfig, validationToolbarConfig, QualityNudgeExtension, ValidationProfileExtension, ValidationRuleExtension, } from '@formicoidea/labre-core/blocks/surface';
+import { InterchangeExtension, morphToolbarConfig, ReadingProfileExtension, tagsToolbarConfig, QualityNudgeExtension, ValidationProfileExtension, ValidationRuleExtension, } from '@formicoidea/labre-core/blocks/surface';
 import { AuditCriterionExtension, ToolbarModuleExtension, toolbarModuleKey, UniverseTagDefsExtension, } from '@formicoidea/labre-core/shared/services';
+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 { BlockFlavourIdentifier, CommandExtension } from '@formicoidea/labre-core/std';
@@ -21,8 +22,8 @@ import { WardleyInteraction, WardleyView } from './element-view.js';
 import { WardleyNodeRendererExtension } from './node/node-renderer.js';
 import { WardleyNodeView } from './node/node-view.js';
 import { WardleyPorterWatcher } from './node/porter-watcher.js';
-import { wardleyNodeToolbarExtension } from './toolbar/node-config.js';
-import { wardleyToolbarExtension } from './toolbar/config.js';
+import { WARDLEY_FRAMEWORK_PALETTE, wardleyNodeToolbarExtension, } from './toolbar/node-config.js';
+import { wardleyBoardToolingToolbarExtension, wardleyToolbarExtension, } from './toolbar/config.js';
 import { wardleySeniorTool } from './toolbar/senior-tool.js';
 /**
  * Wardley rendering — ALWAYS registered, independent of any flag. Disabling
@@ -106,18 +107,15 @@ export class WardleyViewExtension extends ViewExtensionProvider {
             // off contributes none and `map.audit` finds nothing to ask about — while
             // `ai-audit` independently decides whether the command exists at all.
             context.register(AuditCriterionExtension(WARDLEY_AUDIT_CRITERIA));
-            // The Validation dropdown on a selected map's contextual toolbar. A
-            // SECOND module on the same element, through the `custom:` flavour slot
-            // (the pattern `gfx/mindmap` uses on `custom:affine:surface:shape`):
-            // `wardleyToolbarExtension` is registered always-on because a stored map
-            // must keep its axes and labels, while choosing how hard to check it is
-            // tooling and belongs here. The config itself names no framework — it
-            // reads roles and profiles — so a second framework registers the very
-            // same object on its own flavour.
-            context.register(ToolbarModuleExtension({
-                id: BlockFlavourIdentifier('custom:affine:surface:wardley'),
-                config: validationToolbarConfig,
-            }));
+            // The Legend button and the Validation dropdown on a selected map's
+            // contextual toolbar — ONE module, through the `custom:` flavour slot
+            // (the pattern `gfx/mindmap` uses on `custom:affine:surface:shape`), for
+            // the reason `wardleyBoardToolingToolbarConfig` states: a flavour carries
+            // exactly one, and a second would throw at set-up. Here and not in the
+            // always-on half because both are TOOLING — generating a legend and
+            // choosing how hard to check the map — while `wardleyToolbarExtension`
+            // stays always-on so a stored map keeps its axes and labels.
+            context.register(wardleyBoardToolingToolbarExtension);
             // The four natures — Wardley's type-3 qualification (MF3, ADR 0007).
             // Seeded on the SAME mechanism a host uses for its own taxonomy: the
             // library ships one real pack, and a client's private extension is a
@@ -179,6 +177,12 @@ export class WardleyViewExtension extends ViewExtensionProvider {
             // the flag without either side naming the other.
             context.register(ReadingProfileExtension(WARDLEY_READING));
             context.register(wardleySeniorTool);
+            // Wardley's page of the colour pickers' carousel (`docs/adr/0027`).
+            // Here, beside the senior tool, because offering hues is TOOLING: a map
+            // 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`).
+            context.register(FrameworkPaletteExtension(WARDLEY_FRAMEWORK_PALETTE));
             // The Templates-panel category — tooling, so it goes with the flag (#244).
             context.register(TemplateCategoryExtension(wardleyTemplateCategory));
             // The Wardley commands — thirteen artefacts plus the two directions of

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-framework-wardley",
   "description": "Labre wardley framework for @formicoidea/labre-core.",
-  "version": "0.40.0",
+  "version": "0.42.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -31,7 +31,7 @@
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.40.0",
+    "@formicoidea/labre-core": "0.42.0",
     "lit": "^3.2.0"
   }
 }