@formicoidea/labre-framework-wardley 0.42.0 → 0.45.0

package/dist/import.js

@@ -1,8 +1,8 @@
 import { ConnectorMode, FontFamily, FontWeight, PointStyle, ShapeStyle, StrokeStyle, TextAlign, } from '@formicoidea/labre-core/model';
 import { WARDLEY_BACKGROUND } from './background.js';
 import { OWM_DEFAULT_MAP_HEIGHT, OWM_DEFAULT_MAP_WIDTH, OWM_LABEL_HEIGHT, OWM_LABEL_WIDTH, OWM_SCOPE, OWM_TAIL_ATTR, OWM_KEYWORDS, OWM_TITLE_ATTR, owmDefaultPlot, owmPointOf, WARDLEY_OWM_FORMAT_ID, } from './export.js';
-import { HANDLE_SIZE, LABEL_GAP, LABEL_FONT_SIZE, LINK_GREY, LINK_STROKE_WIDTH, MARKET_DOT_RING, MARKET_DOT_SIZE, MARKET_DOT_STROKE_WIDTH, MARKET_LINK_COLOR, MARKET_LINK_WIDTH, MARKET_SIZE, ECOSYSTEM_SIZE, NODE_FILL, NODE_SIZE, NODE_STROKE, NODE_STROKE_WIDTH, PIPELINE_FILL, PIPELINE_HEIGHT, WARDLEY_RED, } from './node/consts.js';
-import { WARDLEY_NODE_SIZE, wardleyNodeProps } from './presets.js';
+import { HANDLE_SIZE, INERTIA_SIZE, LABEL_GAP, LABEL_FONT_SIZE, LINK_GREY, LINK_STROKE_WIDTH, MARKET_DOT_RING, MARKET_DOT_SIZE, MARKET_DOT_STROKE_WIDTH, MARKET_LINK_COLOR, MARKET_LINK_WIDTH, MARKET_SIZE, ECOSYSTEM_SIZE, NODE_FILL, NODE_SIZE, NODE_STROKE, NODE_STROKE_WIDTH, PIPELINE_FILL, PIPELINE_HEIGHT, WARDLEY_RED, } from './node/consts.js';
+import { WARDLEY_NODE_SIZE, wardleyInertiaProps, wardleyNodeProps, } from './presets.js';
 import { WARDLEY_ROLE } from './roles.js';
 /**
  * The OWM import remarks whose wording is FIXED, as `[key, English]` pairs.
@@ -153,8 +153,6 @@ export const WARDLEY_OWM_IMPORT_REMARKS = {
  * this library does not itself write — the honest form of "a file we wrote",
  * since the format has no marker to claim one with.
  */
-/* ── The format, re-exported so both halves agree ─────────────────────── */
-export { WARDLEY_OWM_FORMAT_ID, OWM_SCOPE };
 /** The dialect this reader implements, and how a Labre-shaped file reads. */
 const OWM_DIALECT = 'DSL';
 const OWM_DIALECT_LABRE = 'DSL (Labre)';
@@ -226,8 +224,8 @@ function readName(raw) {
  * layout of our own, so an artefact this reader places without coordinates
  * lands where the tool that wrote the file would have drawn it.
  */
-export const OWM_DEFAULT_VISIBILITY = 0.9;
-export const OWM_DEFAULT_EVOLUTION = 0.1;
+const OWM_DEFAULT_VISIBILITY = 0.9;
+const OWM_DEFAULT_EVOLUTION = 0.1;
 /**
  * Read `[v, e]` the way `extractLocation` reads one — PER AXIS.
  *
@@ -578,6 +576,68 @@ export function importWardleyOwm(source, context = {}) {
         }
     }
     /* ── Laying it out ────────────────────────────────────────────────── */
+    // Where the document's residue rides: on the map, which is always first.
+    const mapPayload = {};
+    if (title !== undefined) {
+        mapPayload.attrs = { [OWM_SCOPE.document]: { [OWM_TITLE_ATTR]: title } };
+    }
+    if (carriedLines.length > 0) {
+        mapPayload.children = { [OWM_SCOPE.document]: carriedLines };
+    }
+    const elements = layoutWardleyStatements({
+        nodes: nodeStatements,
+        pipelines,
+        notes: noteStatements,
+        evolutions,
+        links,
+        inertias: [],
+    }, { mapPayload, onInvented: inventedNote });
+    /* ── The report ───────────────────────────────────────────────────── */
+    const mapped = (titledByFile ? 1 : 0) +
+        nodeStatements.length +
+        pipelines.length +
+        noteStatements.length +
+        evolutions.length +
+        links.length;
+    return {
+        elements,
+        report: {
+            mapped,
+            carried: carriedLines.length,
+            // Nothing. Every statement this format writes is a standalone sentence,
+            // so a carried one cannot contradict the drawing — which is what D5's
+            // quarantine is FOR. Stated here rather than left to be inferred from a
+            // zero: a format with no quarantine case is a finding about the format.
+            quarantined: 0,
+            notes,
+            sourceVersion: carriedLines.length === 0 && notes.length === 0
+                ? OWM_DIALECT_LABRE
+                : OWM_DIALECT,
+        },
+    };
+}
+/* ── Laying statements out ───────────────────────────────────────────── */
+/**
+ * Statements as element props, on a new map at the reference size — the OWM
+ * reader's own layout, shared with the SVG reader (ADR 0032 §2.3) so the two
+ * paths draw the same elements.
+ *
+ * Every element that a later statement refers to carries its identity under
+ * `interchange.owm.id` (D3): the OWM reader hands that to the materializer
+ * as is, and the SVG reader turns it into a provisional local id and drops
+ * the payload, because a picture promises no round-trip.
+ *
+ * @param options.mapPayload what rides on the map element under `owm`, if
+ *   anything.
+ * @param options.onInvented told of every position this layout made up.
+ */
+export function layoutWardleyStatements(statements, options) {
+    const { nodes: nodeStatements, pipelines, notes: noteStatements, evolutions, links, inertias, } = statements;
+    const inventedNote = options.onInvented;
+    const mapPayload = options.mapPayload ?? {};
+    /** What a statement is referred to by: its id, or (OWM) its name. */
+    const identity = (statement) => statement.id ?? statement.name;
+    const declared = new Set(nodeStatements.map(identity));
     const plot = owmDefaultPlot();
     const elements = [];
     /** The place a name was declared at, for the statements that reference one. */
@@ -585,8 +645,8 @@ export function importWardleyOwm(source, context = {}) {
     for (const statement of nodeStatements) {
         // FIRST wins, matching the materializer's own rule for a duplicated name
         // and OWM's: a pipeline or an `evolve` naming it means the first one.
-        if (!declaredAt.has(statement.name)) {
-            declaredAt.set(statement.name, {
+        if (!declaredAt.has(identity(statement))) {
+            declaredAt.set(identity(statement), {
                 visibility: statement.visibility,
                 evolution: statement.evolution,
             });
@@ -604,14 +664,6 @@ export function importWardleyOwm(source, context = {}) {
         minted.add(candidate);
         return candidate;
     };
-    /* The map itself, always first, and where the document's residue rides. */
-    const mapPayload = {};
-    if (title !== undefined) {
-        mapPayload.attrs = { [OWM_SCOPE.document]: { [OWM_TITLE_ATTR]: title } };
-    }
-    if (carriedLines.length > 0) {
-        mapPayload.children = { [OWM_SCOPE.document]: carriedLines };
-    }
     elements.push({
         type: WARDLEY_BACKGROUND.type,
         role: WARDLEY_BACKGROUND.role,
@@ -624,18 +676,20 @@ export function importWardleyOwm(source, context = {}) {
     });
     for (const statement of nodeStatements) {
         const [cx, cy] = owmPointOf(plot, statement.visibility, statement.evolution);
-        elements.push(...artefact(statement.keyword, statement.name, cx, cy, statement.tail, mintHandle));
+        elements.push(...artefact(statement.keyword, statement.name, identity(statement), cx, cy, statement.tail, mintHandle));
     }
     for (const pipeline of pipelines) {
-        const at = declaredAt.get(pipeline.name);
-        if (at === undefined) {
+        const standing = pipeline.top !== undefined;
+        const at = standing ? undefined : declaredAt.get(identity(pipeline));
+        if (!standing && at === undefined) {
             inventedNote('pipeline', pipeline.name, 'no component of this name is declared, so the pipeline was drawn halfway up the value chain. OWM takes a pipeline’s height from the component it belongs to.');
         }
-        const visibility = at?.visibility ?? 0.5;
+        const visibility = pipeline.top ?? at?.visibility ?? 0.5;
         const [left] = owmPointOf(plot, visibility, pipeline.from);
         const [right, y] = owmPointOf(plot, visibility, pipeline.to);
-        // Under the component it belongs to, the way OWM draws it.
-        const top = y + NODE_SIZE;
+        // Under the component it belongs to, the way OWM draws it — or exactly
+        // where a picture drew its top edge.
+        const top = standing ? y : y + NODE_SIZE;
         const width = Math.max(right - left, 1);
         const centre = left + width / 2;
         elements.push({
@@ -651,7 +705,7 @@ export function importWardleyOwm(source, context = {}) {
             roughness: 0,
             radius: 0,
             xywh: `[${left},${top},${width},${PIPELINE_HEIGHT}]`,
-            interchange: payload({ id: pipeline.name, tail: pipeline.tail }),
+            interchange: payload({ id: identity(pipeline), tail: pipeline.tail }),
         });
         elements.push({
             type: 'wardleyNode',
@@ -667,7 +721,7 @@ export function importWardleyOwm(source, context = {}) {
             radius: 0,
             xywh: `[${centre - HANDLE_SIZE / 2},${top - HANDLE_SIZE / 2},${HANDLE_SIZE},${HANDLE_SIZE}]`,
             interchange: payload({
-                id: mintHandle(`${pipeline.name} handle`),
+                id: mintHandle(`${identity(pipeline)} handle`),
                 element: 'pipeline',
             }),
         });
@@ -691,13 +745,13 @@ export function importWardleyOwm(source, context = {}) {
     /** The twin an `evolve` line draws, and the handle its arrow points at. */
     const twinHandles = [];
     for (const evolution of evolutions) {
-        const at = declaredAt.get(evolution.name);
+        const at = declaredAt.get(identity(evolution));
         if (at === undefined) {
             inventedNote('evolve', evolution.name, 'no component of this name is declared, so its evolved twin was laid out halfway up the value chain. The file did not say where it sits.');
         }
         const visibility = at?.visibility ?? 0.5;
         const [cx, cy] = owmPointOf(plot, visibility, evolution.evolution);
-        const handle = mintHandle(`evolve ${evolution.name}`);
+        const handle = mintHandle(`evolve ${identity(evolution)}`);
         twinHandles.push(handle);
         elements.push({
             type: 'wardleyNode',
@@ -734,7 +788,7 @@ export function importWardleyOwm(source, context = {}) {
             strokeWidth: LINK_STROKE_WIDTH,
             frontEndpointStyle: PointStyle.None,
             rearEndpointStyle: PointStyle.Triangle,
-            source: { id: evolution.name },
+            source: { id: identity(evolution) },
             target: { id: twinHandles[index] },
         });
     });
@@ -755,29 +809,12 @@ export function importWardleyOwm(source, context = {}) {
             target: { id: link.to },
         });
     }
-    /* ── The report ───────────────────────────────────────────────────── */
-    const mapped = (titledByFile ? 1 : 0) +
-        nodeStatements.length +
-        pipelines.length +
-        noteStatements.length +
-        evolutions.length +
-        links.length;
-    return {
-        elements,
-        report: {
-            mapped,
-            carried: carriedLines.length,
-            // Nothing. Every statement this format writes is a standalone sentence,
-            // so a carried one cannot contradict the drawing — which is what D5's
-            // quarantine is FOR. Stated here rather than left to be inferred from a
-            // zero: a format with no quarantine case is a finding about the format.
-            quarantined: 0,
-            notes,
-            sourceVersion: carriedLines.length === 0 && notes.length === 0
-                ? OWM_DIALECT_LABRE
-                : OWM_DIALECT,
-        },
-    };
+    for (const inertia of inertias) {
+        const [cx, cy] = owmPointOf(plot, inertia.visibility, inertia.evolution);
+        const { w, h } = INERTIA_SIZE;
+        elements.push(wardleyInertiaProps({ xywh: `[${cx - w / 2},${cy - h / 2},${w},${h}]` }));
+    }
+    return elements;
 }
 /* ── The pieces ───────────────────────────────────────────────────────── */
 /** The `interchange` value for an element, or `undefined` when it carries none. */
@@ -816,7 +853,7 @@ fontWeight = FontWeight.Regular) {
     };
 }
 /** The circle (or composite) one positioned statement draws, plus its name. */
-function artefact(keyword, name, cx, cy, tail, mintHandle) {
+function artefact(keyword, name, id, cx, cy, tail, mintHandle) {
     // The two climate annotations are the only statements this reader draws as
     // something other than a circle: a fat polygon, at the canonical size the
     // palette gives one, with its name on the side its shaft is on. The presets
@@ -829,9 +866,14 @@ function artefact(keyword, name, cx, cy, tail, mintHandle) {
             ...wardleyNodeProps(kind, {
                 xywh: `[${cx - w / 2},${cy - h / 2},${w},${h}]`,
             }),
-            interchange: payload({ id: name, tail }),
+            interchange: payload({ id, tail }),
         };
         const rightwards = kind === 'accelerator';
+        // A picture may draw the arrow and no name (OnlineWardleyMaps does); a
+        // label with nothing in it would be an empty box nobody asked for. The DSL
+        // reader always names one, so this only ever drops a label for the SVG.
+        if (name.length === 0)
+            return [arrow];
         return [
             arrow,
             label(name, rightwards
@@ -863,7 +905,7 @@ function artefact(keyword, name, cx, cy, tail, mintHandle) {
         shapeStyle: ShapeStyle.General,
         roughness: 0,
         xywh: `[${cx - diameter / 2},${cy - diameter / 2},${diameter},${diameter}]`,
-        interchange: payload({ id: name, tail }),
+        interchange: payload({ id, tail }),
     };
     const named = label(name, cx + diameter / 2 + LABEL_GAP, cy - OWM_LABEL_HEIGHT / 2, TextAlign.Left);
     if (keyword !== 'market')
@@ -880,7 +922,7 @@ function artefact(keyword, name, cx, cy, tail, mintHandle) {
         [ring * sin60, ring / 2],
         [-ring * sin60, ring / 2],
     ];
-    const handles = vertices.map((_, index) => mintHandle(`${name} market ${index + 1}`));
+    const handles = vertices.map((_, index) => mintHandle(`${id} market ${index + 1}`));
     const dots = vertices.map(([dx, dy], index) => ({
         type: 'wardleyNode',
         kind: 'component',

package/dist/index.d.ts

@@ -27,5 +27,6 @@ export { WARDLEY_BACKGROUND } from './background.js';
  */
 export { exportWardleyOwm, exportWardleyOwmWithWarnings, OWM_SCOPE, type OwmPlot, owmCoordsOf, owmPlotOf, owmPointOf, WARDLEY_OWM_FORMAT_ID, type WardleyExportBoard, wardleyBoardFrom, wardleySafeFilename, } from './export.js';
 export { importWardleyOwm } from './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';

package/dist/index.js

@@ -39,6 +39,9 @@ export { WARDLEY_BACKGROUND } from './background.js';
  */
 export { exportWardleyOwm, exportWardleyOwmWithWarnings, OWM_SCOPE, owmCoordsOf, owmPlotOf, owmPointOf, WARDLEY_OWM_FORMAT_ID, wardleyBoardFrom, wardleySafeFilename, } from './export.js';
 export { importWardleyOwm } from './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';
 // The half of the export that needs an editor, kept apart from the half that
 // does not — the same split C4's and BPMN's indexes make for the same reason:
 // what the selection scopes the file to lives here, the serializer next door.

package/dist/interchange.d.ts

@@ -9,7 +9,8 @@ import type { InterchangeCapability, InterchangeExportCapability, InterchangeFor
  * and the import is the row the ADR calls **the reference Wardley import**,
  * because the OWM DSL is the settled Wardley vocabulary while mermaid's Wardley
  * diagram type is still experimental upstream. Then SVG IN, the visual-tier
- * FALLBACK, which promises recognition and nothing else.
+ * route for a picture, which recognises the map when it knows who drew it and
+ * sketches the rest (ADR 0032).
  *
  * The file is laid out as one section per FORMAT, each holding its format
  * object then its capabilities, with {@link WARDLEY_INTERCHANGE} at the bottom
@@ -56,24 +57,18 @@ export declare const WARDLEY_OWM_IMPORT: InterchangeImportCapability;
  */
 export declare const WARDLEY_SVG_FORMAT: InterchangeFormat;
 /**
- * `wardley:svg:import` — an SVG as a sketch, best effort.
+ * `wardley:svg:import` — an SVG as the Wardley map it is a picture of, and
+ * whatever else it holds as a sketch (ADR 0032).
  *
- * **The heuristics statement and the known failure modes this capability owes
- * (ADR 0012, open question 2) are the module documentation of
- * `packages/affine/blocks/surface/src/extensions/svg-sketch.ts`.** Written once
- * there because Wardley and BPMN wrap the SAME parser and therefore make the
- * same guesses — and because the ADR's question is about what a visual
- * capability is ALLOWED to guess, which for both of them is: geometry, and
- * nothing else. A circle is a circle; whether it is a component is the
- * author's sentence, not this reader's.
- *
- * What lands is an ADR 0007 level-1 sketch — plain shapes, brush strokes and
- * editable free text — which the author then PROMOTES onto a map. In
- * particular the two axes and the evolution bands are NOT recovered: a map's
- * coordinates are its meaning, and reading them off a picture would be
- * inventing a position and presenting it as read. {@link WARDLEY_OWM_IMPORT}
- * beside it is the route a user should be pointed at, exactly as P2 says —
- * this one is for the picture somebody sent you from a tool that writes no OWM.
+ * **The heuristics statement this capability owes (ADR 0012, open question 2)
+ * is the module documentation of `./svg-import.ts`**, beside the parser that
+ * makes the guesses: ADR 0032 superseded, for Wardley only, the rule that a
+ * visual capability guesses geometry and nothing else. A picture from a
+ * producer the reader recognises arrives as native Wardley elements; the rest
+ * of it — and the whole of a picture nobody recognises — arrives as the same
+ * level-1 sketch BPMN's reader draws (`parseSvgSketch`, which BPMN still
+ * declares). Still the visual tier: no payload, no round-trip, and
+ * {@link WARDLEY_OWM_IMPORT} beside it stays the reference Wardley import.
  */
 export declare const WARDLEY_SVG_IMPORT: InterchangeImportCapability;
 /** Everything Wardley registers, in one list the view extension hands over. */

package/dist/interchange.js

@@ -1,6 +1,7 @@
-import { interchangeCapabilityId, parseSvgSketch, SVG_SKETCH_EXTENSION, SVG_SKETCH_FORMAT_ID, SVG_SKETCH_MIME, } from '@formicoidea/labre-core/blocks/surface';
+import { interchangeCapabilityId, SVG_SKETCH_EXTENSION, SVG_SKETCH_FORMAT_ID, SVG_SKETCH_MIME, } from '@formicoidea/labre-core/blocks/surface';
 import { exportWardleyOwmWithWarnings, WARDLEY_OWM_FORMAT_ID, wardleyBoardFrom, wardleySafeFilename, } from './export.js';
 import { importWardleyOwm } from './import.js';
+import { importWardleySvg } from './svg-import.js';
 /**
  * Wardley's entries in the interchange registry (`docs/adr/0012`, P1).
  *
@@ -11,7 +12,8 @@ import { importWardleyOwm } from './import.js';
  * and the import is the row the ADR calls **the reference Wardley import**,
  * because the OWM DSL is the settled Wardley vocabulary while mermaid's Wardley
  * diagram type is still experimental upstream. Then SVG IN, the visual-tier
- * FALLBACK, which promises recognition and nothing else.
+ * route for a picture, which recognises the map when it knows who drew it and
+ * sketches the rest (ADR 0032).
  *
  * The file is laid out as one section per FORMAT, each holding its format
  * object then its capabilities, with {@link WARDLEY_INTERCHANGE} at the bottom
@@ -103,31 +105,25 @@ export const WARDLEY_SVG_FORMAT = {
     mime: SVG_SKETCH_MIME,
 };
 /**
- * `wardley:svg:import` — an SVG as a sketch, best effort.
+ * `wardley:svg:import` — an SVG as the Wardley map it is a picture of, and
+ * whatever else it holds as a sketch (ADR 0032).
  *
- * **The heuristics statement and the known failure modes this capability owes
- * (ADR 0012, open question 2) are the module documentation of
- * `packages/affine/blocks/surface/src/extensions/svg-sketch.ts`.** Written once
- * there because Wardley and BPMN wrap the SAME parser and therefore make the
- * same guesses — and because the ADR's question is about what a visual
- * capability is ALLOWED to guess, which for both of them is: geometry, and
- * nothing else. A circle is a circle; whether it is a component is the
- * author's sentence, not this reader's.
- *
- * What lands is an ADR 0007 level-1 sketch — plain shapes, brush strokes and
- * editable free text — which the author then PROMOTES onto a map. In
- * particular the two axes and the evolution bands are NOT recovered: a map's
- * coordinates are its meaning, and reading them off a picture would be
- * inventing a position and presenting it as read. {@link WARDLEY_OWM_IMPORT}
- * beside it is the route a user should be pointed at, exactly as P2 says —
- * this one is for the picture somebody sent you from a tool that writes no OWM.
+ * **The heuristics statement this capability owes (ADR 0012, open question 2)
+ * is the module documentation of `./svg-import.ts`**, beside the parser that
+ * makes the guesses: ADR 0032 superseded, for Wardley only, the rule that a
+ * visual capability guesses geometry and nothing else. A picture from a
+ * producer the reader recognises arrives as native Wardley elements; the rest
+ * of it — and the whole of a picture nobody recognises — arrives as the same
+ * level-1 sketch BPMN's reader draws (`parseSvgSketch`, which BPMN still
+ * declares). Still the visual tier: no payload, no round-trip, and
+ * {@link WARDLEY_OWM_IMPORT} beside it stays the reference Wardley import.
  */
 export const WARDLEY_SVG_IMPORT = {
     id: interchangeCapabilityId('wardley', WARDLEY_SVG_FORMAT.id, 'import'),
     framework: 'wardley',
     format: WARDLEY_SVG_FORMAT,
     direction: 'import',
-    run: parseSvgSketch,
+    run: importWardleySvg,
 };
 /* ── The list the view extension registers ────────────────────────────── */
 /** Everything Wardley registers, in one list the view extension hands over. */

package/dist/node/node-renderer.d.ts

@@ -11,6 +11,6 @@ import { type WardleyNodeElementModel } from '@formicoidea/labre-core/model';
  * the hollow center come from the base fill, so colors stay editable.
  */
 export declare const wardleyNode: ElementRenderer<WardleyNodeElementModel>;
-export declare const WardleyNodeRendererExtension: import("@formicoidea/labre-core/store").ExtensionType & {
+export declare const WardleyNodeRendererExtension: import("@formicoidea/labre-core/_pkgs/store").ExtensionType & {
     identifier: import("@formicoidea/labre-core/_pkgs/global/di").ServiceIdentifier<ElementRenderer<WardleyNodeElementModel>>;
 };

package/dist/reading.js

@@ -141,6 +141,10 @@ export const WARDLEY_READING = {
         background: WARDLEY_BACKGROUND,
         // Evolution runs along the plot's x axis; its four zones ARE the phases.
         axis: 'x',
+        // No `label` / `none`: "Evolution phase" is the engine's default wording
+        // (`READING_FRAME_DEFAULT_WORDING`), declared once in the surface package
+        // so a 0.43 host profile reads with it too. Restating it here would be a
+        // second declaration of the same two keys.
     },
     /**
      * The two record properties a reading may compare itself against.

package/dist/roles.js

@@ -22,6 +22,7 @@ const DEFS = [
         id: WARDLEY_ROLE.component,
         kind: 'node',
         labelKey: 'com.labre.wardley.role.component',
+        labelFallback: 'Component',
     },
     // A user / need: a component with no need of its own, hence its own role
     // rather than a specialisation of `component`.
@@ -29,34 +30,40 @@ const DEFS = [
         id: WARDLEY_ROLE.anchor,
         kind: 'node',
         labelKey: 'com.labre.wardley.role.anchor',
+        labelFallback: 'Anchor',
     },
     // The pipeline body. Connections go through its handle, never the body.
     {
         id: WARDLEY_ROLE.pipeline,
         kind: 'node',
         labelKey: 'com.labre.wardley.role.pipeline',
+        labelFallback: 'Pipeline',
     },
     {
         id: WARDLEY_ROLE.handle,
         kind: 'node',
         labelKey: 'com.labre.wardley.role.handle',
+        labelFallback: 'Pipeline handle',
     },
     {
         id: WARDLEY_ROLE.market,
         parent: WARDLEY_ROLE.component,
         kind: 'node',
         labelKey: 'com.labre.wardley.role.market',
+        labelFallback: 'Market',
     },
     {
         id: WARDLEY_ROLE.ecosystem,
         parent: WARDLEY_ROLE.component,
         kind: 'node',
         labelKey: 'com.labre.wardley.role.ecosystem',
+        labelFallback: 'Ecosystem',
     },
     {
         id: WARDLEY_ROLE.method,
         kind: 'node',
         labelKey: 'com.labre.wardley.role.method',
+        labelFallback: 'Method',
     },
     /**
      * A Porter's-forces glyph: one of the five forces of external competition
@@ -148,12 +155,21 @@ const DEFS = [
             verbFallback: 'needs',
             gestureHintKey: 'com.labre.wardley.role.dependency.gesture',
             gestureHintFallback: 'Drag from the component that has the need to what it needs.',
-            // The house primary, on THIS chip and no other (same recette). The value
-            // chain is what a Wardley map is read along, and the PO asked for the
-            // relation that carries it to be unmistakable — a decision about one
-            // relation, so it is declared on that relation rather than on the
-            // mechanism, and every other framework's reveal keeps the colour it had.
-            chipColor: '#2563eb',
+            // No `chipColor`. This role used to declare one (PR #203), so that the
+            // relation carrying the value chain would be unmistakable — and the
+            // result, on one map, was two chips in two different blues: this one in
+            // the colour it asked for, `wardley:change-arrow` in the mechanism's
+            // default. Neither had been compared against the other, because the pin
+            // that watched this field only ever looked at Wardley.
+            //
+            // The chip is chrome — the tool talking about the drawing, not part of
+            // it — so it follows the theme's accent token like every other
+            // affordance, and both relations of a map now wear the same blue
+            // (`EDGE_DIRECTION_COLOR`, `gfx/connector`). `chipColor` stays on the
+            // role contract as the extension point it was meant to be: a framework
+            // MAY claim its own, and the cross-framework guard in
+            // `affine/all/src/__tests__/direction-chip-accent.unit.spec.ts` is what
+            // keeps a second accent from creeping back in unnoticed.
         },
     },
     // The map itself: the axes frame the other roles are positioned against.
@@ -163,6 +179,7 @@ const DEFS = [
         id: WARDLEY_ROLE.map,
         kind: 'node',
         labelKey: 'com.labre.wardley.role.map',
+        labelFallback: 'Wardley map',
     },
     // The change (evolution) arrow: "this is where it is going". An EDGE, and
     // deliberately not a specialisation of `dependency` — it says nothing about
@@ -191,6 +208,7 @@ const DEFS = [
         id: WARDLEY_ROLE.inertia,
         kind: 'node',
         labelKey: 'com.labre.wardley.role.inertia',
+        labelFallback: 'Inertia',
     },
     // The name written next to an artefact. A role of its own rather than a
     // property of the node it labels: on this canvas a label IS a separate free
@@ -203,6 +221,7 @@ const DEFS = [
         id: WARDLEY_ROLE.label,
         kind: 'text',
         labelKey: 'com.labre.wardley.role.label',
+        labelFallback: 'Label',
     },
 ];
 // Null prototype: this is a lookup table keyed by ids that may one day come

package/dist/svg-import.d.ts

@@ -0,0 +1,2 @@
+import type { InterchangeImportContext, InterchangeImportResult } from '@formicoidea/labre-core/blocks/surface';
+export declare function importWardleySvg(source: string, context?: InterchangeImportContext): InterchangeImportResult;