@formicoidea/labre-framework-wardley 0.40.0 → 0.42.0

package/dist/morph.d.ts

@@ -1,5 +1,6 @@
 import { type MorphSpec } from '@formicoidea/labre-core/blocks/surface';
 import { WardleyNodeElementModel } from '@formicoidea/labre-core/model';
+import type { BlockStdScope } from '@formicoidea/labre-core/std';
 import type { GfxPrimitiveElementModel } from '@formicoidea/labre-core/std/gfx';
 /**
  * What a Wardley artefact may BECOME — the declaration behind the "Change type"
@@ -81,8 +82,17 @@ export declare function wardleyNodeOfComponent(model: GfxPrimitiveElementModel):
  *
  * Pure and total over every string: the input is a canvas text element somebody
  * may have typed anything into.
+ *
+ * `std` is OPTIONAL: "untouched" means equal to the English prompt OR to the
+ * host's own resolved wording for `from`'s kind, and the target's prompt is
+ * likewise resolved through the host when one is given — mirroring
+ * `c4MorphedTypeLine`'s fix for the identical class of gap. With no `std`
+ * this behaves exactly as it always has (English only). The morph toolbar's
+ * `afterMorph` callback (`MorphSpec`, `packages/affine/blocks/surface`) now
+ * hands its callee the inserting editor's `std`, so `rewriteLabel` below
+ * passes it straight through.
  */
-export declare function wardleyMorphedLabel(from: WardleyMorphKind, to: WardleyMorphKind, rawText: string | null | undefined): string | null;
+export declare function wardleyMorphedLabel(from: WardleyMorphKind, to: WardleyMorphKind, rawText: string | null | undefined, std?: BlockStdScope): string | null;
 /**
  * Everything the morph owes a Wardley composite beyond the props patch — the
  * `afterMorph` half of the spec, run inside the generic module's one
@@ -98,7 +108,9 @@ export declare function wardleyMorphedLabel(from: WardleyMorphKind, to: WardleyM
  * dots crammed into it. So the target's canonical size is applied, CENTRED on
  * where the artefact already stands: the thing does not move, it becomes the
  * size its notation says it is. The label keeps its own place, which is the
- * user's.
+ * user's — with the one exception {@link relocateLabel} states: a name still
+ * standing where creation put it follows the target kind when that kind carries
+ * its name somewhere else, or the new drawing lands on top of the old words.
  *
  * ## And why the rest is here rather than in the patch
  *
@@ -110,7 +122,7 @@ export declare function wardleyMorphedLabel(from: WardleyMorphKind, to: WardleyM
  * LEAVING comes apart before the one it is arriving at is built, so a
  * market → pipeline never has three dots and a handle at once.
  */
-export declare function wardleyMorphComposite(selected: GfxPrimitiveElementModel, from: WardleyMorphKind, to: WardleyMorphKind): void;
+export declare function wardleyMorphComposite(selected: GfxPrimitiveElementModel, from: WardleyMorphKind, to: WardleyMorphKind, std?: BlockStdScope): void;
 /**
  * Wardley's morph declaration, handed to the generic `morphToolbarConfig`.
  *

package/dist/morph.js

@@ -1,7 +1,9 @@
 import { morphLabel, } from '@formicoidea/labre-core/blocks/surface';
 import { ConnectorElementModel, GroupElementModel, TextElementModel, WardleyNodeElementModel, } from '@formicoidea/labre-core/model';
+import { translateKey } from '@formicoidea/labre-core/shared/services';
+import { Bound } from '@formicoidea/labre-core/global/gfx';
 import { wardleyCommandIcons, wardleyCommands } from './commands.js';
-import { wardleyCanonicalBox, wardleyHandleBox, wardleyHandleProps, wardleyMarketDotBoxes, wardleyMarketDotProps, wardleyMarketLinkPairs, wardleyMarketLinkProps, WARDLEY_NODE_LABEL, wardleyMorphClears, wardleyMorphProps, } from './presets.js';
+import { wardleyCanonicalBox, wardleyHandleBox, wardleyHandleProps, WARDLEY_LABEL_H, WARDLEY_LABEL_W, wardleyLabelBoxFor, wardleyMarketDotBoxes, wardleyMarketDotProps, wardleyMarketLinkPairs, wardleyMarketLinkProps, WARDLEY_NODE_LABEL, wardleyMorphClears, wardleyMorphProps, wardleyNodeLabelKey, } from './presets.js';
 import { WARDLEY_ROLE } from './roles.js';
 /**
  * What a Wardley artefact may BECOME — the declaration behind the "Change type"
@@ -148,11 +150,26 @@ export function wardleyNodeOfComponent(model) {
  *
  * Pure and total over every string: the input is a canvas text element somebody
  * may have typed anything into.
+ *
+ * `std` is OPTIONAL: "untouched" means equal to the English prompt OR to the
+ * host's own resolved wording for `from`'s kind, and the target's prompt is
+ * likewise resolved through the host when one is given — mirroring
+ * `c4MorphedTypeLine`'s fix for the identical class of gap. With no `std`
+ * this behaves exactly as it always has (English only). The morph toolbar's
+ * `afterMorph` callback (`MorphSpec`, `packages/affine/blocks/surface`) now
+ * hands its callee the inserting editor's `std`, so `rewriteLabel` below
+ * passes it straight through.
  */
-export function wardleyMorphedLabel(from, to, rawText) {
-    return (rawText ?? '').trim() === WARDLEY_NODE_LABEL[from]
-        ? WARDLEY_NODE_LABEL[to]
-        : null;
+export function wardleyMorphedLabel(from, to, rawText, std) {
+    const text = (rawText ?? '').trim();
+    const fromPrompt = std
+        ? translateKey(std, wardleyNodeLabelKey(from), WARDLEY_NODE_LABEL[from])
+        : WARDLEY_NODE_LABEL[from];
+    if (text !== WARDLEY_NODE_LABEL[from] && text !== fromPrompt)
+        return null;
+    return std
+        ? translateKey(std, wardleyNodeLabelKey(to), WARDLEY_NODE_LABEL[to])
+        : WARDLEY_NODE_LABEL[to];
 }
 /** The centre of an element, from the box it currently occupies. */
 function centreOf(model) {
@@ -309,12 +326,12 @@ function removeHandle(group, carrier) {
  * inside the caller's `captureSync`, so the rewrite is part of the same single
  * ctrl+z as the kind that made it necessary.
  */
-function rewriteLabel(group, from, to) {
+function rewriteLabel(group, from, to, std) {
     const label = labelOfComposite(group);
     if (!label || label.isLocked())
         return;
     const text = label.text.toString().trim();
-    const next = wardleyMorphedLabel(from, to, text);
+    const next = wardleyMorphedLabel(from, to, text, std);
     if (next === null || next === text)
         return;
     label.surface.store.transact(() => {
@@ -322,6 +339,66 @@ function rewriteLabel(group, from, to) {
         label.text.insert(0, next);
     });
 }
+/**
+ * The offset from a label box's left edge to the point its alignment holds
+ * fixed — the edge the words grow from.
+ */
+function anchorOffset(w, textAlign) {
+    return textAlign === 'center' ? w / 2 : textAlign === 'right' ? w : 0;
+}
+/**
+ * Carry the name to where the TARGET kind holds it — and only when it is still
+ * where the SOURCE kind's creation put it.
+ *
+ * ## The bug this repairs
+ *
+ * A component wears its name to the right of an 18-pixel circle. A pipeline is
+ * a 120-wide bar: written onto the same artefact, it is drawn straight OVER
+ * those words, and a filled shape answers the pointer on its whole interior
+ * while a text answers only on its box — so which of the two got the click
+ * depended on where in the label you aimed. The name could not be edited, and
+ * dragging it moved the pipeline. Rule W3 forbids precisely that overlap.
+ *
+ * ## Why only across a change of PLACE
+ *
+ * The timid rule {@link rewriteLabel} states about the words, applied to the
+ * placement: what the author put somewhere is theirs. The three circles all
+ * carry their name beside them, so a component growing into a market leaves the
+ * words exactly where they were — the circle grows underneath them and that is
+ * the documented behaviour. Only the crossing to or from the pipeline changes
+ * the PLACE, and only that moves anything.
+ *
+ * The test is on the point the label's own alignment keeps fixed rather than on
+ * its top-left, because typing into a label resizes its box around exactly that
+ * point (`edgeless-text-editor`): a renamed label is still where creation put
+ * it, and a MOVED one is not.
+ */
+function relocateLabel(group, from, to, cx, cy) {
+    const source = wardleyLabelBoxFor(from, cx, cy);
+    const target = wardleyLabelBoxFor(to, cx, cy);
+    if (source.place === target.place)
+        return;
+    const label = labelOfComposite(group);
+    if (!label || label.isLocked())
+        return;
+    const [x, y, w, h] = label.deserializedXYWH;
+    const sourceAnchorX = source.x + anchorOffset(WARDLEY_LABEL_W, source.textAlign);
+    // A pixel of tolerance on each axis: a renamed label's line is measured from
+    // the font and lands within a hair of the canonical height this compares to.
+    if (Math.abs(x + anchorOffset(w, source.textAlign) - sourceAnchorX) > 1) {
+        return;
+    }
+    if (Math.abs(y + h / 2 - (source.y + WARDLEY_LABEL_H / 2)) > 1)
+        return;
+    label.surface.updateElement(label.id, {
+        // The BOX keeps its own size — the words in it may be the author's, and one
+        // shrunk back to the canonical width would clip them.
+        xywh: new Bound(target.x +
+            anchorOffset(WARDLEY_LABEL_W, target.textAlign) -
+            anchorOffset(w, target.textAlign), target.y + WARDLEY_LABEL_H / 2 - h / 2, w, h).serialize(),
+        textAlign: target.textAlign,
+    });
+}
 /**
  * Everything the morph owes a Wardley composite beyond the props patch — the
  * `afterMorph` half of the spec, run inside the generic module's one
@@ -337,7 +414,9 @@ function rewriteLabel(group, from, to) {
  * dots crammed into it. So the target's canonical size is applied, CENTRED on
  * where the artefact already stands: the thing does not move, it becomes the
  * size its notation says it is. The label keeps its own place, which is the
- * user's.
+ * user's — with the one exception {@link relocateLabel} states: a name still
+ * standing where creation put it follows the target kind when that kind carries
+ * its name somewhere else, or the new drawing lands on top of the old words.
  *
  * ## And why the rest is here rather than in the patch
  *
@@ -349,7 +428,7 @@ function rewriteLabel(group, from, to) {
  * LEAVING comes apart before the one it is arriving at is built, so a
  * market → pipeline never has three dots and a handle at once.
  */
-export function wardleyMorphComposite(selected, from, to) {
+export function wardleyMorphComposite(selected, from, to, std) {
     if (!(selected instanceof GroupElementModel))
         return;
     const carrier = wardleyNodeOfComponent(selected);
@@ -367,7 +446,8 @@ export function wardleyMorphComposite(selected, from, to) {
         addMarketGlyph(selected, cx, cy);
     if (to === 'pipeline')
         addHandle(selected, carrier, cx, cy);
-    rewriteLabel(selected, from, to);
+    relocateLabel(selected, from, to, cx, cy);
+    rewriteLabel(selected, from, to, std);
 }
 /**
  * Wardley's morph declaration, handed to the generic `morphToolbarConfig`.

package/dist/natures.js

@@ -86,11 +86,14 @@ export const WARDLEY_TAG_DEFS = {
     packId: 'wardley-core',
     framework: 'wardley',
     label: 'Wardley',
+    labelKey: 'com.labre.wardley.tag-pack.label',
     tags: [
         {
             id: WARDLEY_NATURE_TAG_ID,
             label: 'Nature',
+            labelKey: 'com.labre.wardley.tag.nature',
             description: 'What kind of thing this component is: an activity, data, a practice or knowledge.',
+            descriptionKey: 'com.labre.wardley.tag.nature.description',
             cardinality: 'single',
             appliesTo: [WARDLEY_ROLE.component],
             // No `order`, on either tag of this pack: an absent order sorts by SEED
@@ -103,29 +106,39 @@ export const WARDLEY_TAG_DEFS = {
                 {
                     id: WARDLEY_NATURE.activity,
                     label: 'Activity',
+                    labelKey: 'com.labre.wardley.tag.nature.activity',
                     description: 'Something that is DONE — a step, a service, a process.',
+                    descriptionKey: 'com.labre.wardley.tag.nature.activity.description',
                 },
                 {
                     id: WARDLEY_NATURE.data,
                     label: 'Data',
+                    labelKey: 'com.labre.wardley.tag.nature.data',
                     description: 'Something that is RECORDED — a dataset, a register.',
+                    descriptionKey: 'com.labre.wardley.tag.nature.data.description',
                 },
                 {
                     id: WARDLEY_NATURE.practice,
                     label: 'Practice',
+                    labelKey: 'com.labre.wardley.tag.nature.practice',
                     description: 'A way of doing — a method, a convention, an operating model.',
+                    descriptionKey: 'com.labre.wardley.tag.nature.practice.description',
                 },
                 {
                     id: WARDLEY_NATURE.knowledge,
                     label: 'Knowledge',
+                    labelKey: 'com.labre.wardley.tag.nature.knowledge',
                     description: 'Something that is KNOWN — a model, a theory, a rule.',
+                    descriptionKey: 'com.labre.wardley.tag.nature.knowledge.description',
                 },
             ],
         },
         {
             id: WARDLEY_COMPETITION_TAG_ID,
             label: 'Competition',
+            labelKey: 'com.labre.wardley.tag.competition',
             description: "Which of Porter's forces this glyph marks: relative competition, a struggle for survival, or a struggle to establish.",
+            descriptionKey: 'com.labre.wardley.tag.competition.description',
             cardinality: 'single',
             appliesTo: [WARDLEY_ROLE.porter],
             values: [
@@ -135,17 +148,23 @@ export const WARDLEY_TAG_DEFS = {
                     // shows: a reader picking a value here is choosing what the circle
                     // will say, not filling in a form about it.
                     label: 'Relative competition (R)',
+                    labelKey: 'com.labre.wardley.tag.competition.relative',
                     description: 'Established players competing against one another on a market that exists.',
+                    descriptionKey: 'com.labre.wardley.tag.competition.relative.description',
                 },
                 {
                     id: WARDLEY_COMPETITION.struggle,
                     label: 'Struggle for survival (L)',
+                    labelKey: 'com.labre.wardley.tag.competition.struggle',
                     description: 'Pressure on a player to stay in a market it is already in.',
+                    descriptionKey: 'com.labre.wardley.tag.competition.struggle.description',
                 },
                 {
                     id: WARDLEY_COMPETITION.establish,
                     label: 'Struggle to establish (E)',
+                    labelKey: 'com.labre.wardley.tag.competition.establish',
                     description: 'Pressure on a newcomer trying to get into a market.',
+                    descriptionKey: 'com.labre.wardley.tag.competition.establish.description',
                 },
             ],
         },

package/dist/node/consts.d.ts

@@ -57,29 +57,31 @@ export declare const LINK_STROKE_WIDTH = 2;
 /**
  * Wardley red ("future"/evolution) — matches the validated arrow icon.
  *
- * An IDENTITY colour: the legend recognises a stored evolution link by it
- * (`legend.ts`, `el.stroke === WARDLEY_RED`). It stays a literal and must never
- * be derived from `NOTATION_NEUTRALS` or any other scale — a change of value
- * would orphan every link already drawn with it.
+ * A STORED colour: every evolution arrow ever drawn carries this exact value,
+ * so it stays a literal and must never be derived from `NOTATION_NEUTRALS` or
+ * any other scale — a change of value would leave the maps already drawn with
+ * it a different red from the ones drawn after. (It is no longer how an arrow
+ * is RECOGNISED: the legend and the rules read `wardley:change-arrow`, so a
+ * connector somebody restyled red is not one.)
  */
 export declare const WARDLEY_RED = "#d6455d";
 /**
  * Dependency link grey.
  *
- * An IDENTITY colour: the legend recognises a stored dependency link by it
- * (`legend.ts`, `el.stroke === LINK_GREY`). It stays a literal and must never
- * be derived from `NOTATION_NEUTRALS` — a change of value would orphan every
- * link already drawn with it.
+ * A STORED colour, like {@link WARDLEY_RED} above and for its reason: every
+ * dependency link ever drawn carries this exact value, so it stays a literal
+ * and must never be derived from `NOTATION_NEUTRALS`. What MAKES a connector a
+ * dependency is its role, not its grey.
  */
 export declare const LINK_GREY = "#666666";
 /**
  * Inertia bar color + size.
  *
- * An IDENTITY colour: the legend recognises a stored inertia bar by it
- * (`legend.ts`, `el.fillColor === INERTIA_COLOR`). It happens to equal the
- * scale's ink today, but it stays a literal and must never be derived from
- * `NOTATION_NEUTRALS`: a change of the shared ink would orphan every inertia bar
- * already on a map.
+ * A STORED colour, like the two above: every inertia bar ever drawn carries
+ * this exact value. It happens to equal the scale's ink today, but it stays a
+ * literal and must never be derived from `NOTATION_NEUTRALS` — a change of the
+ * shared ink would repaint the bars already on a map. A rect somebody tinted
+ * `#1f2328` is NOT an inertia: `wardley:inertia` is.
  */
 export declare const INERTIA_COLOR = "#1f2328";
 export declare const INERTIA_SIZE: {

package/dist/node/consts.js

@@ -55,29 +55,31 @@ export const LINK_STROKE_WIDTH = 2;
 /**
  * Wardley red ("future"/evolution) — matches the validated arrow icon.
  *
- * An IDENTITY colour: the legend recognises a stored evolution link by it
- * (`legend.ts`, `el.stroke === WARDLEY_RED`). It stays a literal and must never
- * be derived from `NOTATION_NEUTRALS` or any other scale — a change of value
- * would orphan every link already drawn with it.
+ * A STORED colour: every evolution arrow ever drawn carries this exact value,
+ * so it stays a literal and must never be derived from `NOTATION_NEUTRALS` or
+ * any other scale — a change of value would leave the maps already drawn with
+ * it a different red from the ones drawn after. (It is no longer how an arrow
+ * is RECOGNISED: the legend and the rules read `wardley:change-arrow`, so a
+ * connector somebody restyled red is not one.)
  */
 export const WARDLEY_RED = '#d6455d';
 /**
  * Dependency link grey.
  *
- * An IDENTITY colour: the legend recognises a stored dependency link by it
- * (`legend.ts`, `el.stroke === LINK_GREY`). It stays a literal and must never
- * be derived from `NOTATION_NEUTRALS` — a change of value would orphan every
- * link already drawn with it.
+ * A STORED colour, like {@link WARDLEY_RED} above and for its reason: every
+ * dependency link ever drawn carries this exact value, so it stays a literal
+ * and must never be derived from `NOTATION_NEUTRALS`. What MAKES a connector a
+ * dependency is its role, not its grey.
  */
 export const LINK_GREY = '#666666';
 /**
  * Inertia bar color + size.
  *
- * An IDENTITY colour: the legend recognises a stored inertia bar by it
- * (`legend.ts`, `el.fillColor === INERTIA_COLOR`). It happens to equal the
- * scale's ink today, but it stays a literal and must never be derived from
- * `NOTATION_NEUTRALS`: a change of the shared ink would orphan every inertia bar
- * already on a map.
+ * A STORED colour, like the two above: every inertia bar ever drawn carries
+ * this exact value. It happens to equal the scale's ink today, but it stays a
+ * literal and must never be derived from `NOTATION_NEUTRALS` — a change of the
+ * shared ink would repaint the bars already on a map. A rect somebody tinted
+ * `#1f2328` is NOT an inertia: `wardley:inertia` is.
  */
 export const INERTIA_COLOR = '#1f2328';
 export const INERTIA_SIZE = { w: 8, h: 44 };

package/dist/node/node-renderer.js

@@ -30,13 +30,24 @@ export const wardleyNode = (model, ctx, matrix, renderer, rc, bound) => {
         return;
     const strokeWidth = model.strokeWidth || 1;
     const R = Math.min(w, h) / 2 - strokeWidth / 2;
+    // A node dragged smaller than its own stroke leaves the glyph no room: every
+    // radius below is a fraction of `R`, and `arc` throws `IndexSizeError` on a
+    // negative one rather than clamping — which, since the surface render loop
+    // wraps no renderer in a `try`, aborts the rest of the frame. The hatch step
+    // is a fraction of `R` too, so `R === 0` would also spin its loop forever.
+    // The native circle underneath is already painted; the glyph simply stops.
+    if (!(R > 0))
+        return;
     const color = renderer.getColorValue(model.strokeColor, DefaultTheme.shapeStrokeColor, true);
     ctx.setTransform(glyphMatrix);
     // ── Anchor: person glyph (clipped to the circle) ────────────────────
     if (model.kind === 'anchor') {
         ctx.save();
         ctx.beginPath();
-        ctx.arc(cx, cy, R - strokeWidth / 2, 0, Math.PI * 2);
+        // The clip is inset by half a stroke again, which can land under zero on a
+        // node barely wider than its border: clipped to nothing, the glyph paints
+        // nothing, which is the honest picture at that size.
+        ctx.arc(cx, cy, Math.max(0, R - strokeWidth / 2), 0, Math.PI * 2);
         ctx.clip();
         ctx.lineWidth = strokeWidth;
         ctx.strokeStyle = color;

package/dist/presets.d.ts

@@ -1,4 +1,4 @@
-import { FontWeight, type WardleyNodeKind } from '@formicoidea/labre-core/model';
+import { FontWeight, PointStyle, StrokeStyle, type WardleyNodeKind } from '@formicoidea/labre-core/model';
 /**
  * What a Wardley artefact IS, as props — the ONE description the creation sites
  * and the morph both read.
@@ -72,6 +72,27 @@ export type WardleyLabelledKind = Exclude<WardleyArtefactKind, 'porter' | 'area'
  * still carries, and the only string a morph is ever allowed to rewrite.
  */
 export declare const WARDLEY_NODE_LABEL: Record<WardleyLabelledKind, string>;
+/**
+ * The i18n key {@link WARDLEY_NODE_LABEL} is the English default of —
+ * resolved at placement (`createWardleyNode` / `createWardleyPipeline` /
+ * `createWardleyMarket`), never afterwards. "Pipeline" is the PO's glossary
+ * term for Wardley: the French proposal IS the English word.
+ *
+ * ## The morph's placeholder detection, translated
+ *
+ * `wardleyMorphedLabel` (`morph.ts`) decides whether to refresh an artefact's
+ * name across a morph, and accepts an OPTIONAL `std`: given one, it
+ * recognises the stored text as "untouched" whether it reads the English
+ * prompt or the host's own resolved wording, and resolves the TARGET kind's
+ * prompt through the host too (the same fix `c4MorphedTypeLine` carries,
+ * `gfx/c4/src/type-line.ts`). `MorphSpec.afterMorph`
+ * (`packages/affine/blocks/surface`) now hands its callee the morph
+ * toolbar's own `std`, so `rewriteLabel` passes it straight through: on a
+ * host running a French catalogue, morphing an untouched TRANSLATED node
+ * rewrites its name to the target kind's own translated prompt, exactly as a
+ * standalone playground already rewrote the English one.
+ */
+export declare const wardleyNodeLabelKey: (kind: WardleyLabelledKind) => string;
 /** A box centred on a point — how every Wardley creation site places a node. */
 export declare function wardleyCenteredBox(cx: number, cy: number, w: number, h: number): string;
 /** The canonical box of one kind, centred where the artefact already stands. */
@@ -108,6 +129,29 @@ export declare const WARDLEY_LABEL_H: number;
  * the words end on a given edge is to start the box a full width before it.
  */
 export declare const WARDLEY_LABEL_W = 120;
+/**
+ * Where a kind carries its NAME, and how the words sit in the box.
+ *
+ * The one description of a placement the four creation sites and the morph all
+ * read. Restated at each site it had already started to drift — and a morph
+ * that rewrites the BOX of an artefact without knowing where that kind holds
+ * its name leaves the words under the new drawing, which is W3's overlap and a
+ * label the pointer can no longer reach.
+ *
+ * `place` is the coarse half of the answer, and the only one a morph acts on:
+ * the three circles and the two arrows all wear their name BESIDE them, so an
+ * artefact that grows from one to the next leaves the words exactly where they
+ * are; the pipeline is the one kind that holds it ABOVE, and crossing between
+ * the two is what has to move something.
+ */
+export type WardleyLabelPlacement = {
+    x: number;
+    y: number;
+    textAlign: 'left' | 'center' | 'right';
+    place: 'beside' | 'above';
+};
+/** Where a node of one kind, centred on (cx, cy), carries its label. */
+export declare function wardleyLabelBoxFor(kind: WardleyLabelledKind, cx: number, cy: number): WardleyLabelPlacement;
 /**
  * The NAME beside an artefact, as props — a native free-text element.
  *
@@ -207,6 +251,32 @@ export declare function wardleyMarketLinkProps(sourceId: string, targetId: strin
 };
 /** The pairs the triangle wires, given the three dots in creation order. */
 export declare function wardleyMarketLinkPairs<T>(dots: readonly T[]): [T, T][];
+/**
+ * How a Wardley connector LOOKS, per tool: the value-chain link is grey, solid
+ * and headless, the evolution arrow red, dashed and tipped with a filled
+ * triangle.
+ *
+ * Here beside the node presets, and for their reason: the style rides on the
+ * tool activation (`activateWardleyConnector`) and is pictured by the legend
+ * row that tool subscribes, so restating it in either place would be two
+ * descriptions of one notation that agreed the day they were written.
+ */
+export declare const WARDLEY_EDGE_STYLE: {
+    readonly link: {
+        readonly stroke: "#666666";
+        readonly strokeStyle: StrokeStyle.Solid;
+        readonly strokeWidth: 2;
+        readonly frontEndpointStyle: PointStyle.None;
+        readonly rearEndpointStyle: PointStyle.None;
+    };
+    readonly arrow: {
+        readonly stroke: "#d6455d";
+        readonly strokeStyle: StrokeStyle.Dash;
+        readonly strokeWidth: 2;
+        readonly frontEndpointStyle: PointStyle.None;
+        readonly rearEndpointStyle: PointStyle.Triangle;
+    };
+};
 /** One of the four arrows: its own axis-aligned box, and the outline in it. */
 export interface WardleyPorterArrow {
     /** Serialized `xywh` of the box the polygon is drawn inside. */

package/dist/presets.js

@@ -1,6 +1,6 @@
 import { ConnectorMode, DEFAULT_POLYGON_VERTICES, FontFamily, FontWeight, PointStyle, ShapeStyle, StrokeStyle, TextFitMode, } from '@formicoidea/labre-core/model';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
-import { ACCELERATOR_FILL, ACCELERATOR_LABEL, ACCELERATOR_SIZE, ACCELERATOR_STROKE_WIDTH, ACCELERATOR_VERTICES, AREA_FILL, AREA_POLYGON_SIZE, AREA_RECT_SIZE, AREA_STROKE, AREA_STROKE_WIDTH, DECELERATOR_LABEL, DECELERATOR_VERTICES, ECOSYSTEM_LABEL, ECOSYSTEM_SIZE, HANDLE_SIZE, INERTIA_COLOR, LABEL_DEFAULT, LABEL_FONT_SIZE, MARKET_DOT_RING, MARKET_DOT_SIZE, MARKET_DOT_STROKE_WIDTH, MARKET_LABEL, MARKET_LINK_COLOR, MARKET_LINK_WIDTH, MARKET_SIZE, METHOD_FILL, METHOD_LABEL, METHOD_SIZE, NODE_FILL, NODE_SIZE, NODE_STROKE, NODE_STROKE_WIDTH, PIPELINE_FILL, PIPELINE_HEIGHT, PIPELINE_LABEL, PIPELINE_WIDTH, PORTER_ARROW, PORTER_LETTER_FONT_SIZE, PORTER_SIZE, WARDLEY_RED, } from './node/consts.js';
+import { ACCELERATOR_FILL, ACCELERATOR_LABEL, ACCELERATOR_SIZE, ACCELERATOR_STROKE_WIDTH, ACCELERATOR_VERTICES, AREA_FILL, AREA_POLYGON_SIZE, AREA_RECT_SIZE, AREA_STROKE, AREA_STROKE_WIDTH, DECELERATOR_LABEL, DECELERATOR_VERTICES, ECOSYSTEM_LABEL, ECOSYSTEM_SIZE, HANDLE_SIZE, INERTIA_COLOR, LABEL_DEFAULT, LABEL_FONT_SIZE, LABEL_GAP, LINK_GREY, LINK_STROKE_WIDTH, MARKET_DOT_RING, MARKET_DOT_SIZE, MARKET_DOT_STROKE_WIDTH, MARKET_LABEL, MARKET_LINK_COLOR, MARKET_LINK_WIDTH, MARKET_SIZE, METHOD_FILL, METHOD_LABEL, METHOD_SIZE, NODE_FILL, NODE_SIZE, NODE_STROKE, NODE_STROKE_WIDTH, PIPELINE_FILL, PIPELINE_HEIGHT, PIPELINE_LABEL, PIPELINE_WIDTH, PORTER_ARROW, PORTER_LETTER_FONT_SIZE, PORTER_SIZE, WARDLEY_RED, } from './node/consts.js';
 import { WARDLEY_ROLE } from './roles.js';
 /**
  * The size a kind is BORN at, which for Wardley is the notation rather than a
@@ -65,6 +65,27 @@ export const WARDLEY_NODE_LABEL = {
     accelerator: ACCELERATOR_LABEL,
     decelerator: DECELERATOR_LABEL,
 };
+/**
+ * The i18n key {@link WARDLEY_NODE_LABEL} is the English default of —
+ * resolved at placement (`createWardleyNode` / `createWardleyPipeline` /
+ * `createWardleyMarket`), never afterwards. "Pipeline" is the PO's glossary
+ * term for Wardley: the French proposal IS the English word.
+ *
+ * ## The morph's placeholder detection, translated
+ *
+ * `wardleyMorphedLabel` (`morph.ts`) decides whether to refresh an artefact's
+ * name across a morph, and accepts an OPTIONAL `std`: given one, it
+ * recognises the stored text as "untouched" whether it reads the English
+ * prompt or the host's own resolved wording, and resolves the TARGET kind's
+ * prompt through the host too (the same fix `c4MorphedTypeLine` carries,
+ * `gfx/c4/src/type-line.ts`). `MorphSpec.afterMorph`
+ * (`packages/affine/blocks/surface`) now hands its callee the morph
+ * toolbar's own `std`, so `rewriteLabel` passes it straight through: on a
+ * host running a French catalogue, morphing an untouched TRANSLATED node
+ * rewrites its name to the target kind's own translated prompt, exactly as a
+ * standalone playground already rewrote the English one.
+ */
+export const wardleyNodeLabelKey = (kind) => `com.labre.wardley.seed.${kind}`;
 /**
  * The fill a kind is born with. White for every circle that means "a thing on
  * the value chain"; the method's grey is the one that carries meaning — it
@@ -177,6 +198,40 @@ export const WARDLEY_LABEL_H = LABEL_FONT_SIZE + 8;
  * the words end on a given edge is to start the box a full width before it.
  */
 export const WARDLEY_LABEL_W = 120;
+/** Where a node of one kind, centred on (cx, cy), carries its label. */
+export function wardleyLabelBoxFor(kind, cx, cy) {
+    const { w } = WARDLEY_NODE_SIZE[kind];
+    // A pipeline is a 120-wide bar, and a name written to the right of it would
+    // stand a bar's length away from the thing it names. So the words go above
+    // the handle, centred on the body.
+    if (kind === 'pipeline') {
+        const top = cy - WARDLEY_NODE_SIZE.pipeline.h / 2;
+        return {
+            x: cx - WARDLEY_LABEL_W / 2,
+            y: top - HANDLE_SIZE / 2 - WARDLEY_LABEL_H - LABEL_GAP,
+            textAlign: 'center',
+            place: 'above',
+        };
+    }
+    // A decelerator points LEFT, and the reference puts the words on the side the
+    // arrow's shaft is on so the reading runs into the arrow rather than across
+    // it. A label box is a fixed width whatever it reads, so a right-aligned one
+    // has to start a box-width before the edge its words must end on.
+    if (kind === 'decelerator') {
+        return {
+            x: cx - w / 2 - LABEL_GAP - WARDLEY_LABEL_W,
+            y: cy - WARDLEY_LABEL_H / 2,
+            textAlign: 'right',
+            place: 'beside',
+        };
+    }
+    return {
+        x: cx + w / 2 + LABEL_GAP,
+        y: cy - WARDLEY_LABEL_H / 2,
+        textAlign: 'left',
+        place: 'beside',
+    };
+}
 /**
  * The NAME beside an artefact, as props — a native free-text element.
  *
@@ -381,6 +436,33 @@ export function wardleyMarketLinkPairs(dots) {
         [dots[2], dots[0]],
     ];
 }
+/* ── The two typed edges ──────────────────────────────────────────────── */
+/**
+ * How a Wardley connector LOOKS, per tool: the value-chain link is grey, solid
+ * and headless, the evolution arrow red, dashed and tipped with a filled
+ * triangle.
+ *
+ * Here beside the node presets, and for their reason: the style rides on the
+ * tool activation (`activateWardleyConnector`) and is pictured by the legend
+ * row that tool subscribes, so restating it in either place would be two
+ * descriptions of one notation that agreed the day they were written.
+ */
+export const WARDLEY_EDGE_STYLE = {
+    link: {
+        stroke: LINK_GREY,
+        strokeStyle: StrokeStyle.Solid,
+        strokeWidth: LINK_STROKE_WIDTH,
+        frontEndpointStyle: PointStyle.None,
+        rearEndpointStyle: PointStyle.None,
+    },
+    arrow: {
+        stroke: WARDLEY_RED,
+        strokeStyle: StrokeStyle.Dash,
+        strokeWidth: LINK_STROKE_WIDTH,
+        frontEndpointStyle: PointStyle.None,
+        rearEndpointStyle: PointStyle.Triangle,
+    },
+};
 /**
  * The four arrow outlines, north first and then clockwise.
  *

package/dist/templates/index.d.ts

@@ -1,2 +1,12 @@
 import { type TemplateCategory } from '@formicoidea/labre-core/gfx/template';
+import type { ChromeWording } from '@formicoidea/labre-core/shared/services';
+/**
+ * The three hand-drawn palette swatches' own tile names (`Template.nameKey`):
+ * none derives from a command, since `linkTool` / `evolutionArrow` /
+ * `addAreaPolygon` activate a tool rather than draw anything (see `tpl` below
+ * and its docstring).
+ */
+export declare const WARDLEY_TEMPLATE_NAME_LINK: ChromeWording;
+export declare const WARDLEY_TEMPLATE_NAME_EVOLUTION_ARROW: ChromeWording;
+export declare const WARDLEY_TEMPLATE_NAME_AREA_POLYGON: ChromeWording;
 export declare const wardleyTemplateCategory: TemplateCategory;