@formicoidea/labre-framework-wardley 0.60.0 → 1.0.0

package/dist/commands.js

@@ -1,6 +1,6 @@
 import { GfxControllerIdentifier } from '@formicoidea/labre-core/std/gfx';
 import { activateWardleyAreaPolygon, activateWardleyConnector, createWardleyAccelerator, createWardleyArea, createWardleyBackground, createWardleyInertia, createWardleyMarket, createWardleyNode, createWardleyPipeline, createWardleyPorter, exportOwmFile, importOwmFile, importWardleySvgFile, wardleyMapsSelected, } from './actions.js';
-import { WARDLEY_LEGEND_BOX, wardleyLegendEntry, } from './legend.js';
+import { WARDLEY_LEGEND_BOX, wardleyLegendEntries, } from './legend.js';
 import { WARDLEY_ROLE, WARDLEY_ROLES } from './roles.js';
 import { wardleyAcceleratorIcon, wardleyAnchorIcon, wardleyAreaPolygonIcon, wardleyAreaRectIcon, wardleyArrowIcon, wardleyBackgroundIcon, wardleyDeceleratorIcon, wardleyBenefitIcon, wardleyComponentIcon, wardleyEcosystemIcon, wardleyEvolutionGradientIcon, wardleyExportOwmIcon, wardleyImportOwmIcon, wardleyImportSvgIcon, wardleyInertiaIcon, wardleyLinkIcon, wardleyMarketIcon, wardleyMethodIcon, wardleyOpportunityIcon, wardleyPipelineIcon, wardleyPorterIcon, wardleyToolbarIcon, } from './toolbar/icons.js';
 const SPECS = [
@@ -267,7 +267,7 @@ const toolboxCommands = SPECS.map((spec, order) => ({
     // the sheet's own command carries the box the rows are drawn in. Which
     // sub-title a row files under is `category`, so the sections are the very
     // groups the catalogue already shows.
-    ...(spec.legendRole ? { legend: wardleyLegendEntry(spec.legendRole) } : {}),
+    ...(spec.legendRole ? { legend: wardleyLegendEntries(spec.legendRole) } : {}),
     ...(spec.id === 'addBackground' ? { legendBox: WARDLEY_LEGEND_BOX } : {}),
 }));
 /**

package/dist/dark-palette.d.ts

@@ -7,6 +7,9 @@ import type { NotationDarkPalette } from '@formicoidea/labre-core/blocks/surface
  *   than white in light: the gradient keeps its direction, and the dark
  *   selection accent keeps 3:1 on every band (`notation-dark-palettes`).
  * - The greys a node or a link is painted in keep the contrast they have on
- *   white, on the other side of the card.
+ *   white, on the other side of the card. The buying-policy ramp (make, buy,
+ *   outsource: `METHOD_STYLE`, ADR 0046) keeps its ORDER that way too: its
+ *   darkest grey on white becomes its lightest on the dark card, so outsource
+ *   is still the step furthest from the paper.
  */
 export declare const WARDLEY_DARK_PALETTE: NotationDarkPalette;

package/dist/dark-palette.js

@@ -1,6 +1,6 @@
 import { COLORS } from './consts.js';
 import { PORTER_PANEL } from './legend.js';
-import { ACCELERATOR_FILL, LINK_GREY, METHOD_FILL } from './node/consts.js';
+import { ACCELERATOR_FILL, LINK_GREY, METHOD_BUY_FILL, METHOD_FILL, METHOD_OUTSOURCE_FILL, } from './node/consts.js';
 /**
  * Wardley on a dark canvas (ADR 0039). The neutrals come from the shared
  * scale; these are the map's own values that would vanish on the dark card.
@@ -9,7 +9,10 @@ import { ACCELERATOR_FILL, LINK_GREY, METHOD_FILL } from './node/consts.js';
  *   than white in light: the gradient keeps its direction, and the dark
  *   selection accent keeps 3:1 on every band (`notation-dark-palettes`).
  * - The greys a node or a link is painted in keep the contrast they have on
- *   white, on the other side of the card.
+ *   white, on the other side of the card. The buying-policy ramp (make, buy,
+ *   outsource: `METHOD_STYLE`, ADR 0046) keeps its ORDER that way too: its
+ *   darkest grey on white becomes its lightest on the dark card, so outsource
+ *   is still the step furthest from the paper.
  */
 export const WARDLEY_DARK_PALETTE = {
     framework: 'wardley',
@@ -20,6 +23,8 @@ export const WARDLEY_DARK_PALETTE = {
         [COLORS.band[3]]: '#020a16',
         [LINK_GREY]: '#909090',
         [METHOD_FILL]: '#313131',
+        [METHOD_BUY_FILL]: '#6b6b6b',
+        [METHOD_OUTSOURCE_FILL]: '#b5b5b5',
         [ACCELERATOR_FILL]: '#434343',
         [PORTER_PANEL.backing]: '#26282b',
     },

package/dist/index.d.ts

@@ -2,7 +2,8 @@ export { WARDLEY_ROLE, WARDLEY_ROLES, type WardleyRole, type WardleyRoleId, } fr
 export { WARDLEY_AUDIT_CRITERIA } from './audit-criteria.js';
 export { wardleyCommandIcons, wardleyCommands } from './commands.js';
 export { wardleyTranslationEntries } from './translations.js';
-export { WARDLEY_COMPETITION, WARDLEY_COMPETITION_TAG_ID, WARDLEY_NATURE, WARDLEY_NATURE_TAG_ID, WARDLEY_TAG_DEFS, } from './natures.js';
+export { WARDLEY_COMPETITION, WARDLEY_COMPETITION_TAG_ID, WARDLEY_METHOD, WARDLEY_METHOD_TAG_ID, WARDLEY_NATURE, WARDLEY_NATURE_TAG_ID, WARDLEY_TAG_DEFS, } from './natures.js';
+export { type WardleyMethodFamily, wardleyMethodOf, wardleyMethodParts, type WardleyMethodParts, type WardleyMethodPhase, } from './method.js';
 export { competitionOfPorterLetter, porterLetterOfCompetition, type WardleyPorterLetter, } from './porter-competition.js';
 export { WARDLEY_PROFILES } from './profiles.js';
 export { WARDLEY_NUDGES } from './nudges.js';
@@ -29,6 +30,8 @@ export { exportWardleyOwm, exportWardleyOwmWithWarnings, OWM_SCOPE, type OwmPlot
 export { wardleyBoardFrom } from './export-board.js';
 export { WARDLEY_AXIS_SEED, WARDLEY_TOOLBOX, wardleyAreaElement, wardleyChangeArrowElement, wardleyDependencyElement, wardleyInertiaElement, wardleyMapElement, type WardleyMapTexts, wardleyMarketElements, type WardleyNodeItemKind, wardleyNodeElements, wardleyPipelineElements, wardleyPorterElements, } from './toolbox.js';
 export { importWardleyOwm } from './import.js';
+export { exportWardleyRendererJson } from './renderer-json-export.js';
+export { importWardleyRendererJson } from './renderer-json-import.js';
 export { importWardleySvg } from './svg-import.js';
 export { wardleyBoardOf, wardleyExportElementsOf, wardleyMapsSelected, } from './actions.js';
-export { WARDLEY_INTERCHANGE, WARDLEY_OWM_EXPORT, WARDLEY_OWM_EXTENSION, WARDLEY_OWM_FORMAT, WARDLEY_OWM_IMPORT, WARDLEY_OWM_MIME, WARDLEY_SVG_FORMAT, WARDLEY_SVG_IMPORT, } from './interchange.js';
+export { WARDLEY_INTERCHANGE, WARDLEY_JSON_EXPORT, WARDLEY_JSON_EXTENSION, WARDLEY_JSON_FORMAT, WARDLEY_JSON_IMPORT, WARDLEY_JSON_MIME, WARDLEY_OWM_EXPORT, WARDLEY_OWM_EXTENSION, WARDLEY_OWM_FORMAT, WARDLEY_OWM_IMPORT, WARDLEY_OWM_MIME, WARDLEY_SVG_FORMAT, WARDLEY_SVG_IMPORT, } from './interchange.js';

package/dist/index.js

@@ -2,7 +2,11 @@ export { WARDLEY_ROLE, WARDLEY_ROLES, } from './roles.js';
 export { WARDLEY_AUDIT_CRITERIA } from './audit-criteria.js';
 export { wardleyCommandIcons, wardleyCommands } from './commands.js';
 export { wardleyTranslationEntries } from './translations.js';
-export { WARDLEY_COMPETITION, WARDLEY_COMPETITION_TAG_ID, WARDLEY_NATURE, WARDLEY_NATURE_TAG_ID, WARDLEY_TAG_DEFS, } from './natures.js';
+export { WARDLEY_COMPETITION, WARDLEY_COMPETITION_TAG_ID, WARDLEY_METHOD, WARDLEY_METHOD_TAG_ID, WARDLEY_NATURE, WARDLEY_NATURE_TAG_ID, WARDLEY_TAG_DEFS, } from './natures.js';
+// The method value and the renderer JSON's `{ category, recommendation }`
+// pair, both directions, for an importer — and a host reading a map without
+// an editor — to write and read the tag without re-deriving the table.
+export { wardleyMethodOf, wardleyMethodParts, } from './method.js';
 // The letter and the tag, related in both directions. Exported for the reason
 // the presets are: a host laying out or reading a map without an editor —
 // labre-mcp does — must be able to say which force a glyph marks without
@@ -42,6 +46,9 @@ export { wardleyBoardFrom } from './export-board.js';
 // The toolbar as pure builders (`docs/adr/0045`), also on `./interchange`.
 export { WARDLEY_AXIS_SEED, WARDLEY_TOOLBOX, wardleyAreaElement, wardleyChangeArrowElement, wardleyDependencyElement, wardleyInertiaElement, wardleyMapElement, wardleyMarketElements, wardleyNodeElements, wardleyPipelineElements, wardleyPorterElements, } from './toolbox.js';
 export { importWardleyOwm } from './import.js';
+// The renderer JSON, both ways, pure for the same reason (ADR 0012).
+export { exportWardleyRendererJson } from './renderer-json-export.js';
+export { importWardleyRendererJson } from './renderer-json-import.js';
 // The SVG reader that recognises a map (ADR 0032), pure for the same reason:
 // labre-mcp calls the very function the command does.
 export { importWardleySvg } from './svg-import.js';
@@ -53,4 +60,4 @@ export { wardleyBoardOf, wardleyExportElementsOf, wardleyMapsSelected, } from '.
 // DSL both ways, and the visual-tier SVG fallback. Exported whole so a host can
 // ask what Wardley can read and write without mounting an editor, and call it
 // without one either (P3).
-export { WARDLEY_INTERCHANGE, WARDLEY_OWM_EXPORT, WARDLEY_OWM_EXTENSION, WARDLEY_OWM_FORMAT, WARDLEY_OWM_IMPORT, WARDLEY_OWM_MIME, WARDLEY_SVG_FORMAT, WARDLEY_SVG_IMPORT, } from './interchange.js';
+export { WARDLEY_INTERCHANGE, WARDLEY_JSON_EXPORT, WARDLEY_JSON_EXTENSION, WARDLEY_JSON_FORMAT, WARDLEY_JSON_IMPORT, WARDLEY_JSON_MIME, WARDLEY_OWM_EXPORT, WARDLEY_OWM_EXTENSION, WARDLEY_OWM_FORMAT, WARDLEY_OWM_IMPORT, WARDLEY_OWM_MIME, WARDLEY_SVG_FORMAT, WARDLEY_SVG_IMPORT, } from './interchange.js';

package/dist/interchange-headless.d.ts

@@ -1,11 +1,13 @@
-import type { InterchangeFormat, InterchangeImportCapability } from '@formicoidea/labre-core/interchange';
+import type { InterchangeExportCapability, InterchangeFormat, InterchangeImportCapability } from '@formicoidea/labre-core/interchange';
 /**
- * `@labre/affine-gfx-wardley/interchange` — Wardley's formats and its two
- * READERS, with no editor behind them (ADR 0012, P3 as amended 2026-10-14).
+ * `@labre/affine-gfx-wardley/interchange` — Wardley's formats, its READERS
+ * and the one writer that needs no editor, with no editor behind them
+ * (ADR 0012, P3 as amended 2026-10-14).
  *
- * What a server needs to read an `.owm` or an `.svg` as a map: the format
- * declarations and the import capabilities, whose `run` is a pure function of
- * text. The OWM EXPORT capability is not here: it picks the artefacts out of
+ * What a server needs to read an `.owm`, an `.svg` or a renderer `.json` as a
+ * map: the format declarations and the import capabilities, whose `run` is a
+ * pure function of text, plus the renderer JSON's export, which reads stored
+ * fields only (see its declaration). The OWM EXPORT capability is not here: it picks the artefacts out of
  * live element models (`wardleyBoardFrom`, by `instanceof`), which is the
  * editor graph this entry exists to leave out. It stays in `interchange.ts`,
  * which re-exports everything below. The serializer itself
@@ -62,4 +64,28 @@ export declare const WARDLEY_SVG_FORMAT: InterchangeFormat;
  * {@link WARDLEY_OWM_IMPORT} beside it stays the reference Wardley import.
  */
 export declare const WARDLEY_SVG_IMPORT: InterchangeImportCapability;
+/**
+ * The JSON language of `@formicoidea/wardley-map-renderer`. **Semantic**: an
+ * `(evolution, visibility)` pair IS a position. Unlike OWM it keeps nothing
+ * it cannot show: no foreign id and no foreign field rides on an element, and
+ * what the canvas cannot display is dropped and reported (ADR 0012,
+ * amendment of 2026-10-28 under P1).
+ *
+ * Both directions are here, unlike OWM's: the writer reads elements by their
+ * stored fields rather than by `instanceof`, so it loads no element class and
+ * a host with no editor exports with it too.
+ */
+export declare const WARDLEY_JSON_EXTENSION = ".json";
+export declare const WARDLEY_JSON_MIME = "application/json";
+export declare const WARDLEY_JSON_FORMAT: InterchangeFormat;
+/**
+ * `wardley:json:import` — a renderer JSON map, drawn with the toolbar's own
+ * builders: an evolution is the change arrow dropped on its target point,
+ * never a second component (`renderer-json-import.ts`).
+ */
+export declare const WARDLEY_JSON_IMPORT: InterchangeImportCapability;
+/** `wardley:json:export` — the map back in the renderer's language. */
+export declare const WARDLEY_JSON_EXPORT: InterchangeExportCapability;
+export { exportWardleyRendererJson } from './renderer-json-export.js';
+export { importWardleyRendererJson } from './renderer-json-import.js';
 export { WARDLEY_AXIS_SEED, WARDLEY_TOOLBOX, wardleyAreaElement, wardleyChangeArrowElement, wardleyDependencyElement, wardleyInertiaElement, wardleyMapElement, type WardleyMapTexts, wardleyMarketElements, type WardleyNodeItemKind, wardleyNodeElements, wardleyPipelineElements, wardleyPorterElements, } from './toolbox.js';

package/dist/interchange-headless.js

@@ -1,14 +1,18 @@
 import { interchangeCapabilityId, SVG_SKETCH_EXTENSION, SVG_SKETCH_FORMAT_ID, SVG_SKETCH_MIME, } from '@formicoidea/labre-core/interchange';
-import { WARDLEY_OWM_FORMAT_ID } from './export.js';
+import { WARDLEY_OWM_FORMAT_ID, wardleySafeFilename } from './export.js';
 import { importWardleyOwm } from './import.js';
+import { exportWardleyRendererJson } from './renderer-json-export.js';
+import { importWardleyRendererJson } from './renderer-json-import.js';
 import { importWardleySvg } from './svg-import.js';
 /**
- * `@labre/affine-gfx-wardley/interchange` — Wardley's formats and its two
- * READERS, with no editor behind them (ADR 0012, P3 as amended 2026-10-14).
+ * `@labre/affine-gfx-wardley/interchange` — Wardley's formats, its READERS
+ * and the one writer that needs no editor, with no editor behind them
+ * (ADR 0012, P3 as amended 2026-10-14).
  *
- * What a server needs to read an `.owm` or an `.svg` as a map: the format
- * declarations and the import capabilities, whose `run` is a pure function of
- * text. The OWM EXPORT capability is not here: it picks the artefacts out of
+ * What a server needs to read an `.owm`, an `.svg` or a renderer `.json` as a
+ * map: the format declarations and the import capabilities, whose `run` is a
+ * pure function of text, plus the renderer JSON's export, which reads stored
+ * fields only (see its declaration). The OWM EXPORT capability is not here: it picks the artefacts out of
  * live element models (`wardleyBoardFrom`, by `instanceof`), which is the
  * editor graph this entry exists to leave out. It stays in `interchange.ts`,
  * which re-exports everything below. The serializer itself
@@ -89,6 +93,61 @@ export const WARDLEY_SVG_IMPORT = {
     direction: 'import',
     run: importWardleySvg,
 };
+/* ── The wardley-map-renderer JSON (semantic) ─────────────────────────── */
+/**
+ * The JSON language of `@formicoidea/wardley-map-renderer`. **Semantic**: an
+ * `(evolution, visibility)` pair IS a position. Unlike OWM it keeps nothing
+ * it cannot show: no foreign id and no foreign field rides on an element, and
+ * what the canvas cannot display is dropped and reported (ADR 0012,
+ * amendment of 2026-10-28 under P1).
+ *
+ * Both directions are here, unlike OWM's: the writer reads elements by their
+ * stored fields rather than by `instanceof`, so it loads no element class and
+ * a host with no editor exports with it too.
+ */
+export const WARDLEY_JSON_EXTENSION = '.json';
+export const WARDLEY_JSON_MIME = 'application/json';
+export const WARDLEY_JSON_FORMAT = {
+    id: 'json',
+    tier: 'semantic',
+    extensions: [WARDLEY_JSON_EXTENSION],
+    mime: WARDLEY_JSON_MIME,
+};
+/**
+ * `wardley:json:import` — a renderer JSON map, drawn with the toolbar's own
+ * builders: an evolution is the change arrow dropped on its target point,
+ * never a second component (`renderer-json-import.ts`).
+ */
+export const WARDLEY_JSON_IMPORT = {
+    id: interchangeCapabilityId('wardley', WARDLEY_JSON_FORMAT.id, 'import'),
+    framework: 'wardley',
+    format: WARDLEY_JSON_FORMAT,
+    direction: 'import',
+    run: importWardleyRendererJson,
+};
+/** The board as a renderer JSON map; `warnings` only when something was lost. */
+const runWardleyJsonExport = (elements, context) => {
+    const name = wardleySafeFilename(context.name);
+    const { text, warnings } = exportWardleyRendererJson(elements, {
+        name: context.name,
+    });
+    return {
+        text,
+        filename: `${name}${WARDLEY_JSON_EXTENSION}`,
+        mime: WARDLEY_JSON_MIME,
+        ...(warnings.length > 0 ? { warnings } : {}),
+    };
+};
+/** `wardley:json:export` — the map back in the renderer's language. */
+export const WARDLEY_JSON_EXPORT = {
+    id: interchangeCapabilityId('wardley', WARDLEY_JSON_FORMAT.id, 'export'),
+    framework: 'wardley',
+    format: WARDLEY_JSON_FORMAT,
+    direction: 'export',
+    run: runWardleyJsonExport,
+};
+export { exportWardleyRendererJson } from './renderer-json-export.js';
+export { importWardleyRendererJson } from './renderer-json-import.js';
 // The toolbar as pure builders (`docs/adr/0045`): what a host with no editor
 // places to draw the very elements a user places from the toolbar.
 export { WARDLEY_AXIS_SEED, WARDLEY_TOOLBOX, wardleyAreaElement, wardleyChangeArrowElement, wardleyDependencyElement, wardleyInertiaElement, wardleyMapElement, wardleyMarketElements, wardleyNodeElements, wardleyPipelineElements, wardleyPorterElements, } from './toolbox.js';

package/dist/interchange.d.ts

@@ -1,5 +1,5 @@
 import type { InterchangeCapability, InterchangeExportCapability } from '@formicoidea/labre-core/blocks/surface';
-export { WARDLEY_OWM_EXTENSION, WARDLEY_OWM_FORMAT, WARDLEY_OWM_IMPORT, WARDLEY_OWM_MIME, WARDLEY_SVG_FORMAT, WARDLEY_SVG_IMPORT, } from './interchange-headless.js';
+export { WARDLEY_JSON_EXPORT, WARDLEY_JSON_EXTENSION, WARDLEY_JSON_FORMAT, WARDLEY_JSON_IMPORT, WARDLEY_JSON_MIME, WARDLEY_OWM_EXTENSION, WARDLEY_OWM_FORMAT, WARDLEY_OWM_IMPORT, WARDLEY_OWM_MIME, WARDLEY_SVG_FORMAT, WARDLEY_SVG_IMPORT, } from './interchange-headless.js';
 /** `wardley:owm:export` — the row that replaces labre-mcp's own serializer. */
 export declare const WARDLEY_OWM_EXPORT: InterchangeExportCapability;
 /** Everything Wardley registers, in one list the view extension hands over. */

package/dist/interchange.js

@@ -1,12 +1,15 @@
 import { interchangeCapabilityId } from '@formicoidea/labre-core/blocks/surface';
 import { exportWardleyOwmWithWarnings, wardleySafeFilename } from './export.js';
 import { wardleyBoardFrom } from './export-board.js';
-import { WARDLEY_OWM_EXTENSION, WARDLEY_OWM_FORMAT, WARDLEY_OWM_IMPORT, WARDLEY_OWM_MIME, WARDLEY_SVG_IMPORT, } from './interchange-headless.js';
-export { WARDLEY_OWM_EXTENSION, WARDLEY_OWM_FORMAT, WARDLEY_OWM_IMPORT, WARDLEY_OWM_MIME, WARDLEY_SVG_FORMAT, WARDLEY_SVG_IMPORT, } from './interchange-headless.js';
+import { WARDLEY_JSON_EXPORT, WARDLEY_JSON_IMPORT, WARDLEY_OWM_EXTENSION, WARDLEY_OWM_FORMAT, WARDLEY_OWM_IMPORT, WARDLEY_OWM_MIME, WARDLEY_SVG_IMPORT, } from './interchange-headless.js';
+export { WARDLEY_JSON_EXPORT, WARDLEY_JSON_EXTENSION, WARDLEY_JSON_FORMAT, WARDLEY_JSON_IMPORT, WARDLEY_JSON_MIME, WARDLEY_OWM_EXTENSION, WARDLEY_OWM_FORMAT, WARDLEY_OWM_IMPORT, WARDLEY_OWM_MIME, WARDLEY_SVG_FORMAT, WARDLEY_SVG_IMPORT, } from './interchange-headless.js';
 /**
  * Wardley's entries in the interchange registry (`docs/adr/0012`, P1).
  *
- * Two formats and three rows. Both directions of the OWM DSL — the export is
+ * Three formats and five rows. Both directions of the renderer JSON
+ * (`renderer-json-import.ts`, `renderer-json-export.ts`), the language the
+ * workspace connector trades maps in, built with the toolbar's builders. Both
+ * directions of the OWM DSL — the export is
  * the row the ADR records as **owed** (a Wardley serializer exists today in
  * labre-mcp, outside this repo, and is the one violation of P3 the ADR names;
  * it exists here now, so that repo becomes a caller and its copy is deleted),
@@ -58,6 +61,8 @@ export const WARDLEY_OWM_EXPORT = {
 /* ── The list the view extension registers ────────────────────────────── */
 /** Everything Wardley registers, in one list the view extension hands over. */
 export const WARDLEY_INTERCHANGE = [
+    WARDLEY_JSON_EXPORT,
+    WARDLEY_JSON_IMPORT,
     WARDLEY_OWM_EXPORT,
     WARDLEY_OWM_IMPORT,
     WARDLEY_SVG_IMPORT,

package/dist/legend.d.ts

@@ -85,6 +85,7 @@ export declare const WARDLEY_LEGEND_DESC_WORDINGS: readonly ChromeWording[];
  * catalogue category (Nodes, Connectors, Areas), so a section is declared by
  * filing a command rather than by a second list.
  */
+export declare function wardleyLegendEntries(role: WardleyLegendRole): CommandLegendEntry | CommandLegendEntry[];
 export declare function wardleyLegendEntry(role: WardleyLegendRole): CommandLegendEntry;
 /** Every {@link LEGEND_GRADIENT} caption, for `translations.ts`'s manifest. */
 export declare const WARDLEY_LEGEND_GRADIENT_WORDINGS: readonly ChromeWording[];

package/dist/legend.js

@@ -2,9 +2,11 @@ import { ConnectorMode, FontFamily, ShapeStyle, } from '@formicoidea/labre-core/
 import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
 import { translateKey, } from '@formicoidea/labre-core/shared/services';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
+import { GfxControllerIdentifier, GfxPrimitiveElementModel, setElementTag, } from '@formicoidea/labre-core/std/gfx';
 import { GRADIENT_GREEN, GRADIENT_RED } from './gradient.js';
 import { NODE_FILL, NODE_STROKE, PIPELINE_FILL, PORTER_DEFAULT_LETTER, } from './node/consts.js';
 import { WARDLEY_EDGE_STYLE, wardleyHandleProps, wardleyInertiaProps, wardleyMarketDotProps, wardleyMarketLinkPairs, wardleyMarketLinkProps, wardleyNodeProps, wardleyPorterArrowProps, wardleyPorterArrows, } from './presets.js';
+import { WARDLEY_METHOD_TAG_ID, WARDLEY_TAG_DEFS } from './natures.js';
 import { WARDLEY_ROLE } from './roles.js';
 /**
  * What a Wardley legend ROW is, and the two blocks that are not rows.
@@ -279,7 +281,7 @@ const LEGEND_DESC = {
     ],
     [WARDLEY_ROLE.method]: [
         'com.labre.wardley.legend.desc.method',
-        'Component + method (color = phase)',
+        'Component + method (the ring names the method)',
     ],
     [WARDLEY_ROLE.pipeline]: [
         'com.labre.wardley.legend.desc.pipeline',
@@ -322,6 +324,69 @@ export const WARDLEY_LEGEND_DESC_WORDINGS = Object.values(LEGEND_DESC);
  * catalogue category (Nodes, Connectors, Areas), so a section is declared by
  * filing a command rather than by a second list.
  */
+export function wardleyLegendEntries(role) {
+    const entry = wardleyLegendEntry(role);
+    return role === WARDLEY_ROLE.method
+        ? [entry, ...WARDLEY_METHOD_LEGEND_ENTRIES]
+        : entry;
+}
+/* ── One row per method used (ADR 0046) ──────────────────────────────── */
+/**
+ * A method's swatch: a method node at the method row's size, carrying the
+ * method tag, so it is painted by the very ring painter the map's nodes go
+ * through — the swatch cannot drift from the node it explains.
+ *
+ * The swatch carries no role (the platform strips it, and `glyphProps` never
+ * sets one), so its tag is nobody's: no rule reads it, and the next legend's
+ * scan, which reads tags off role-bearing elements only, does not list it.
+ */
+function drawMethodSwatch(valueId) {
+    return (surface, box, std) => {
+        const [w, h] = METHOD_SWATCH_SIZE;
+        const id = surface.addElement({
+            ...glyphProps('method'),
+            xywh: centred(box.x + box.w / 2, box.y + box.h / 2, w, h),
+        });
+        const swatch = std.get(GfxControllerIdentifier).surface?.getElementById(id);
+        if (swatch instanceof GfxPrimitiveElementModel) {
+            setElementTag(swatch, WARDLEY_METHOD_TAG_ID, [valueId]);
+        }
+        return [id];
+    };
+}
+/** The method row's own swatch size (`WARDLEY_LEGEND_ROWS`). */
+const METHOD_SWATCH_SIZE = [18, 18];
+/**
+ * The nine method rows, lit one by one by the values the board USES
+ * (`CommandLegendEntry.tag`), under the family's title as the sub-title and
+ * with the value's own label — the very wordings of the picker, so the legend
+ * and the dropdown say the same word. Each row is a text element of the box
+ * like every other, which the author rewrites in place to tell the story of
+ * the picture.
+ */
+const WARDLEY_METHOD_LEGEND_ENTRIES = (() => {
+    const tag = WARDLEY_TAG_DEFS.tags.find(def => def.id === WARDLEY_METHOD_TAG_ID);
+    if (!tag || tag.values === 'open')
+        return [];
+    return tag.values.map(value => ({
+        role: WARDLEY_ROLE.method,
+        tag: [WARDLEY_METHOD_TAG_ID, value.id],
+        row: {
+            swatch: 'custom',
+            color: NODE_FILL,
+            draw: drawMethodSwatch(value.id),
+        },
+        labelWording: [value.labelKey ?? value.id, value.label],
+        ...(value.group
+            ? {
+                section: [
+                    value.group.labelKey ?? value.group.label,
+                    value.group.label,
+                ],
+            }
+            : {}),
+    }));
+})();
 export function wardleyLegendEntry(role) {
     return {
         role,

package/dist/method.d.ts

@@ -0,0 +1,53 @@
+import { type WardleyMethodStyle } from './node/consts.js';
+/**
+ * The method tag and the pair the wardley-map-renderer JSON spells it as, in
+ * both directions, and the prefabricated ring each value paints (ADR 0046).
+ *
+ * A pure module on purpose, like `porter-competition.ts`: this is the only
+ * place a `wardley:method/...` value id is related to a family, a phase and a
+ * style. The renderer reads it to paint, an import reads it to write the tag,
+ * and nothing here touches an element, a surface or a registry — the painting
+ * of a stored document never depends on which tag pack the host seeded.
+ */
+/**
+ * The three method families, spelled as the renderer's `method.category`
+ * spells its three defaults.
+ */
+export type WardleyMethodFamily = 'buying-policy' | 'project-management' | 'attitudes';
+/**
+ * The evolution phase a method suits, which is how much of its ring is filled.
+ * The renderer's `method.recommendation`, lower-cased.
+ */
+export type WardleyMethodPhase = 'uncharted' | 'transitional' | 'industrialized';
+export interface WardleyMethodParts {
+    family: WardleyMethodFamily;
+    phase: WardleyMethodPhase;
+}
+/**
+ * The family and phase a method value states, `null` when it is not one of the
+ * nine.
+ *
+ * Total over anything a DOCUMENT can carry: defs are runtime configuration and
+ * are never persisted, so a node may hold a value whose pack was removed or a
+ * newer client added. Such a value names no family, and the node paints as an
+ * untagged one (`make`, the default style) rather than guessing another.
+ */
+export declare function wardleyMethodParts(valueId: string | null | undefined): WardleyMethodParts | null;
+/**
+ * The method value a renderer `method: { category, recommendation }` pair
+ * states, `null` when it states none of the nine.
+ *
+ * Forgiving in case and surrounding blanks only — the renderer's own keys are
+ * capitalised (`Uncharted`) and its categories kebab-case — and strict
+ * everywhere else: a category the renderer config made up (its `methods` list
+ * is open) is not a method here — Labre has no custom category (PO decision,
+ * 2026-10-28) — and an importer keeps it as foreign data (ADR 0012) rather
+ * than filing it under the nearest family.
+ */
+export declare function wardleyMethodOf(category: string | null | undefined, recommendation: string | null | undefined): string | null;
+/**
+ * The prefabricated ring a method value paints (`METHOD_STYLE`), `null`
+ * when the value names no method — the painter then falls back on `make`,
+ * the method node's default style.
+ */
+export declare function wardleyMethodStyle(valueId: string | null | undefined): WardleyMethodStyle | null;

package/dist/method.js

@@ -0,0 +1,88 @@
+import { WARDLEY_METHOD } from './natures.js';
+import { METHOD_STYLE } from './node/consts.js';
+const PARTS_OF_VALUE = {
+    [WARDLEY_METHOD.make]: { family: 'buying-policy', phase: 'uncharted' },
+    [WARDLEY_METHOD.buy]: { family: 'buying-policy', phase: 'transitional' },
+    [WARDLEY_METHOD.outsource]: {
+        family: 'buying-policy',
+        phase: 'industrialized',
+    },
+    [WARDLEY_METHOD.agile]: { family: 'project-management', phase: 'uncharted' },
+    [WARDLEY_METHOD.lean]: {
+        family: 'project-management',
+        phase: 'transitional',
+    },
+    [WARDLEY_METHOD.sixSigma]: {
+        family: 'project-management',
+        phase: 'industrialized',
+    },
+    [WARDLEY_METHOD.pioneers]: { family: 'attitudes', phase: 'uncharted' },
+    [WARDLEY_METHOD.settlers]: { family: 'attitudes', phase: 'transitional' },
+    [WARDLEY_METHOD.townPlanners]: {
+        family: 'attitudes',
+        phase: 'industrialized',
+    },
+};
+const STYLE_OF_VALUE = {
+    [WARDLEY_METHOD.make]: METHOD_STYLE.make,
+    [WARDLEY_METHOD.buy]: METHOD_STYLE.buy,
+    [WARDLEY_METHOD.outsource]: METHOD_STYLE.outsource,
+    [WARDLEY_METHOD.agile]: METHOD_STYLE.agile,
+    [WARDLEY_METHOD.lean]: METHOD_STYLE.lean,
+    [WARDLEY_METHOD.sixSigma]: METHOD_STYLE.sixSigma,
+    [WARDLEY_METHOD.pioneers]: METHOD_STYLE.pioneers,
+    [WARDLEY_METHOD.settlers]: METHOD_STYLE.settlers,
+    [WARDLEY_METHOD.townPlanners]: METHOD_STYLE.townPlanners,
+};
+/**
+ * The family and phase a method value states, `null` when it is not one of the
+ * nine.
+ *
+ * Total over anything a DOCUMENT can carry: defs are runtime configuration and
+ * are never persisted, so a node may hold a value whose pack was removed or a
+ * newer client added. Such a value names no family, and the node paints as an
+ * untagged one (`make`, the default style) rather than guessing another.
+ */
+export function wardleyMethodParts(valueId) {
+    if (typeof valueId !== 'string')
+        return null;
+    // `Object.hasOwn`, so `'toString'` does not resolve to a method.
+    return Object.hasOwn(PARTS_OF_VALUE, valueId)
+        ? PARTS_OF_VALUE[valueId]
+        : null;
+}
+/**
+ * The method value a renderer `method: { category, recommendation }` pair
+ * states, `null` when it states none of the nine.
+ *
+ * Forgiving in case and surrounding blanks only — the renderer's own keys are
+ * capitalised (`Uncharted`) and its categories kebab-case — and strict
+ * everywhere else: a category the renderer config made up (its `methods` list
+ * is open) is not a method here — Labre has no custom category (PO decision,
+ * 2026-10-28) — and an importer keeps it as foreign data (ADR 0012) rather
+ * than filing it under the nearest family.
+ */
+export function wardleyMethodOf(category, recommendation) {
+    if (typeof category !== 'string' || typeof recommendation !== 'string') {
+        return null;
+    }
+    const family = category.trim().toLowerCase();
+    const phase = recommendation.trim().toLowerCase();
+    for (const [valueId, parts] of Object.entries(PARTS_OF_VALUE)) {
+        if (parts.family === family && parts.phase === phase)
+            return valueId;
+    }
+    return null;
+}
+/**
+ * The prefabricated ring a method value paints (`METHOD_STYLE`), `null`
+ * when the value names no method — the painter then falls back on `make`,
+ * the method node's default style.
+ */
+export function wardleyMethodStyle(valueId) {
+    if (typeof valueId !== 'string')
+        return null;
+    return Object.hasOwn(STYLE_OF_VALUE, valueId)
+        ? STYLE_OF_VALUE[valueId]
+        : null;
+}

package/dist/natures.d.ts

@@ -20,8 +20,8 @@ import type { UniverseTagDefs } from '@formicoidea/labre-core/shared/services';
  *
  * ## Why it applies to `wardley:component` and not to `'*'`
  *
- * A nature qualifies a component. `market` and `ecosystem` specialise
- * `wardley:component`, so they get it for free through `roleIsA` — that is the
+ * A nature qualifies a component. `market`, `ecosystem` and `method`
+ * specialise `wardley:component`, so they get it for free through `roleIsA` — that is the
  * entire reason role hierarchy is data. The `anchor` (a user / need) is
  * deliberately NOT a child of `component` and is deliberately NOT qualified
  * here: a need has no nature, it has a demand. The map itself, the change
@@ -78,4 +78,66 @@ export declare const WARDLEY_COMPETITION: {
     readonly struggle: "wardley:competition/struggle";
     readonly establish: "wardley:competition/establish";
 };
+/**
+ * The **method** tag — how a component + method is sourced, run or staffed.
+ *
+ * The third tag of this pack, written on `wardley:method` alone. Since that
+ * role specialises `wardley:component` (ADR 0046), a method node is offered
+ * the nature AND this tag in the same dropdown, while a plain component — the
+ * parent, which a child's tag never reaches — is offered the nature only.
+ *
+ * ## Nine values in one tag, not a category tag and a recommendation tag
+ *
+ * Simon Wardley's three method families each say one thing per evolution
+ * phase: a buying policy makes, buys or outsources; project management runs
+ * agile, lean or six sigma; attitudes are pioneers, settlers or town planners.
+ * The wardley-map-renderer JSON spells the same thing as a pair —
+ * `method: { category, recommendation }`, recommendation one of Uncharted /
+ * Transitional / Industrialized — and the two encodings are the same nine
+ * facts. One value per fact is the shape that admits nothing else: two tags
+ * would let a board say "Transitional" with no family, which nothing can paint
+ * and no reader can name. The pair stays one pure lookup away in `method.ts`,
+ * both directions.
+ *
+ * The family is still shown twice (PO decision, 2026-10-28): each value has its
+ * `group` — the family's title, which the picker prints as a sub-title above
+ * its three values — and each of the nine has its own prefabricated ring
+ * (`METHOD_STYLE`), which is how the map tells them apart. No family beyond
+ * these three: a category the renderer config invented is not a method here.
+ *
+ * `cardinality: 'single'` because the renderer gives a component ONE method,
+ * and because the drawing has one ring to show it with.
+ *
+ * Labels are the practitioners' own words — Make, Buy, Outsource in the PO's
+ * wording — short on purpose: the trigger of the dropdown prints the values
+ * in force ("Activity, Buy").
+ */
+export declare const WARDLEY_METHOD_TAG_ID = "wardley:method";
+/** The nine methods, as value ids. Ids are forever; a def is only deprecated. */
+export declare const WARDLEY_METHOD: {
+    readonly make: "wardley:method/make";
+    readonly buy: "wardley:method/buy";
+    readonly outsource: "wardley:method/outsource";
+    readonly agile: "wardley:method/agile";
+    readonly lean: "wardley:method/lean";
+    readonly sixSigma: "wardley:method/six-sigma";
+    readonly pioneers: "wardley:method/pioneers";
+    readonly settlers: "wardley:method/settlers";
+    readonly townPlanners: "wardley:method/town-planners";
+};
+/** The three families' titles: the picker's sub-titles and the legend's. */
+export declare const WARDLEY_METHOD_GROUP: {
+    readonly buyingPolicy: {
+        readonly label: "Buying policy";
+        readonly labelKey: "com.labre.wardley.tag.method.group.buying-policy";
+    };
+    readonly projectManagement: {
+        readonly label: "Project management";
+        readonly labelKey: "com.labre.wardley.tag.method.group.project-management";
+    };
+    readonly attitudes: {
+        readonly label: "Attitudes";
+        readonly labelKey: "com.labre.wardley.tag.method.group.attitudes";
+    };
+};
 export declare const WARDLEY_TAG_DEFS: UniverseTagDefs;