@formicoidea/labre-framework-wardley 0.32.0 → 0.33.0

package/dist/index.d.ts

@@ -7,3 +7,21 @@ export { WARDLEY_PROFILES } from './profiles.js';
 export { WARDLEY_NUDGES } from './nudges.js';
 export { WARDLEY_NAMING_CONVENTIONS, WARDLEY_READING } from './reading.js';
 export { WARDLEY_RULES } from './rules.js';
+/**
+ * The map's own frame, declared. Public because a host that lays elements out
+ * against the plot — labre-mcp does, and so does anything that generates a map
+ * without an editor — needs the margins the renderer actually uses, and a
+ * second copy of four numbers is a copy that drifts (`templates/maps.ts` says
+ * how that went the first time). P3's packaging obligation: a value both
+ * consumers read is reachable from the index, never by deep import.
+ */
+export { WARDLEY_BACKGROUND } from './background.js';
+/**
+ * The OWM DSL, both directions — pure functions of text and models, exported
+ * for the reason ADR 0012 § P3 gives: the editor command and labre-mcp call the
+ * SAME function, and no serialization logic for a Labre framework lives outside
+ * this repo. `exportWardleyOwm` is what replaces labre-mcp's own serializer.
+ */
+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 { 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

@@ -7,3 +7,25 @@ export { WARDLEY_PROFILES } from './profiles.js';
 export { WARDLEY_NUDGES } from './nudges.js';
 export { WARDLEY_NAMING_CONVENTIONS, WARDLEY_READING } from './reading.js';
 export { WARDLEY_RULES } from './rules.js';
+/**
+ * The map's own frame, declared. Public because a host that lays elements out
+ * against the plot — labre-mcp does, and so does anything that generates a map
+ * without an editor — needs the margins the renderer actually uses, and a
+ * second copy of four numbers is a copy that drifts (`templates/maps.ts` says
+ * how that went the first time). P3's packaging obligation: a value both
+ * consumers read is reachable from the index, never by deep import.
+ */
+export { WARDLEY_BACKGROUND } from './background.js';
+/**
+ * The OWM DSL, both directions — pure functions of text and models, exported
+ * for the reason ADR 0012 § P3 gives: the editor command and labre-mcp call the
+ * SAME function, and no serialization logic for a Labre framework lives outside
+ * this repo. `exportWardleyOwm` is what replaces labre-mcp's own serializer.
+ */
+export { exportWardleyOwm, exportWardleyOwmWithWarnings, OWM_SCOPE, owmCoordsOf, owmPlotOf, owmPointOf, WARDLEY_OWM_FORMAT_ID, wardleyBoardFrom, wardleySafeFilename, } from './export.js';
+export { importWardleyOwm } from './import.js';
+// Wardley's entries in the interchange registry (`docs/adr/0012`) — the OWM
+// 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';

package/dist/interchange.d.ts

@@ -0,0 +1,80 @@
+import type { InterchangeCapability, InterchangeExportCapability, InterchangeFormat, InterchangeImportCapability } from '@formicoidea/labre-core/blocks/surface';
+/**
+ * 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
+ * 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),
+ * 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.
+ *
+ * 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
+ * collecting them. A format is added by adding a section, not by editing one.
+ *
+ * Everything here is pure. No half has ever had a `std` in sight, and this file
+ * adds no editor to any of them: it picks the artefacts the writer speaks about
+ * out of a surface's elements, and hands a reader's output straight back.
+ */
+/**
+ * The OnlineWardleyMaps DSL. **Semantic** — the file carries a model, not a
+ * picture: a `[visibility, evolution]` pair IS a position on the value chain
+ * and on the evolution axis, so the whole preservation contract applies and the
+ * import needs no invented axis (P2, and D4's "a format that carries
+ * coordinates but no pixels").
+ *
+ * `text/plain`, because that is what a DSL is, and `.owm` first — it is the
+ * extension a download is given. `.wm` rides behind it: the same bytes are
+ * written under both in the wild, and a picker that refused one would refuse a
+ * valid map for the sake of a filename. What the file actually IS is decided by
+ * the reader.
+ *
+ * The two directions share the FORMAT object, deliberately. `owm` is the id
+ * under which foreign matter rides on an element (D2), so a reader and a writer
+ * that disagreed about it would write payloads the other could not find.
+ */
+export declare const WARDLEY_OWM_EXTENSION = ".owm";
+export declare const WARDLEY_OWM_MIME = "text/plain";
+export declare const WARDLEY_OWM_FORMAT: InterchangeFormat;
+/** `wardley:owm:export` — the row that replaces labre-mcp's own serializer. */
+export declare const WARDLEY_OWM_EXPORT: InterchangeExportCapability;
+/** `wardley:owm:import` — an `.owm` file as a map. */
+export declare const WARDLEY_OWM_IMPORT: InterchangeImportCapability;
+/**
+ * SVG. **Visual** — the file carries a rendering, not a model, so it makes
+ * exactly one promise: the picture arrives as editable elements.
+ *
+ * Wardley's own format object, and NOT one shared with BPMN's, because ADR 0012
+ * rejects "one capability per format, with the framework inferred from the
+ * file": a `.svg` is read by several frameworks, and deciding which one a
+ * picture is a picture OF is the guess this platform refuses everywhere else.
+ * The three constants are the parser package's, so the declarations cannot
+ * drift into filtering a picker on different extensions.
+ */
+export declare const WARDLEY_SVG_FORMAT: InterchangeFormat;
+/**
+ * `wardley:svg:import` — an SVG as a sketch, best effort.
+ *
+ * **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.
+ */
+export declare const WARDLEY_SVG_IMPORT: InterchangeImportCapability;
+/** Everything Wardley registers, in one list the view extension hands over. */
+export declare const WARDLEY_INTERCHANGE: readonly InterchangeCapability[];

package/dist/interchange.js

@@ -0,0 +1,138 @@
+import { interchangeCapabilityId, parseSvgSketch, 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';
+/**
+ * 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
+ * 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),
+ * 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.
+ *
+ * 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
+ * collecting them. A format is added by adding a section, not by editing one.
+ *
+ * Everything here is pure. No half has ever had a `std` in sight, and this file
+ * adds no editor to any of them: it picks the artefacts the writer speaks about
+ * out of a surface's elements, and hands a reader's output straight back.
+ */
+/* ── OWM (semantic) ───────────────────────────────────────────────────── */
+/**
+ * The OnlineWardleyMaps DSL. **Semantic** — the file carries a model, not a
+ * picture: a `[visibility, evolution]` pair IS a position on the value chain
+ * and on the evolution axis, so the whole preservation contract applies and the
+ * import needs no invented axis (P2, and D4's "a format that carries
+ * coordinates but no pixels").
+ *
+ * `text/plain`, because that is what a DSL is, and `.owm` first — it is the
+ * extension a download is given. `.wm` rides behind it: the same bytes are
+ * written under both in the wild, and a picker that refused one would refuse a
+ * valid map for the sake of a filename. What the file actually IS is decided by
+ * the reader.
+ *
+ * The two directions share the FORMAT object, deliberately. `owm` is the id
+ * under which foreign matter rides on an element (D2), so a reader and a writer
+ * that disagreed about it would write payloads the other could not find.
+ */
+export const WARDLEY_OWM_EXTENSION = '.owm';
+export const WARDLEY_OWM_MIME = 'text/plain';
+export const WARDLEY_OWM_FORMAT = {
+    id: WARDLEY_OWM_FORMAT_ID,
+    tier: 'semantic',
+    extensions: [WARDLEY_OWM_EXTENSION, '.wm'],
+    mime: WARDLEY_OWM_MIME,
+};
+/**
+ * The board as an OWM document.
+ *
+ * A thin adapter and nothing else: it picks the Wardley artefacts out of the
+ * surface, names the file, and passes the writer's losses straight through.
+ * There is no second door — `wardley.exportOwm` calls THIS, so the command and
+ * the registry cannot produce different bytes, filenames or warnings.
+ *
+ * `warnings` is omitted rather than empty when the map came out whole, so a
+ * caller can ask `if (result.warnings)` and mean it.
+ */
+const runWardleyOwmExport = (elements, context) => {
+    const name = wardleySafeFilename(context.name);
+    const { text, warnings } = exportWardleyOwmWithWarnings(wardleyBoardFrom(elements), { name });
+    return {
+        text,
+        filename: `${name}${WARDLEY_OWM_EXTENSION}`,
+        mime: WARDLEY_OWM_MIME,
+        ...(warnings.length > 0 ? { warnings } : {}),
+    };
+};
+/** `wardley:owm:export` — the row that replaces labre-mcp's own serializer. */
+export const WARDLEY_OWM_EXPORT = {
+    id: interchangeCapabilityId('wardley', WARDLEY_OWM_FORMAT.id, 'export'),
+    framework: 'wardley',
+    format: WARDLEY_OWM_FORMAT,
+    direction: 'export',
+    run: runWardleyOwmExport,
+};
+/** `wardley:owm:import` — an `.owm` file as a map. */
+export const WARDLEY_OWM_IMPORT = {
+    id: interchangeCapabilityId('wardley', WARDLEY_OWM_FORMAT.id, 'import'),
+    framework: 'wardley',
+    format: WARDLEY_OWM_FORMAT,
+    direction: 'import',
+    run: importWardleyOwm,
+};
+/* ── SVG (visual) ─────────────────────────────────────────────────────── */
+/**
+ * SVG. **Visual** — the file carries a rendering, not a model, so it makes
+ * exactly one promise: the picture arrives as editable elements.
+ *
+ * Wardley's own format object, and NOT one shared with BPMN's, because ADR 0012
+ * rejects "one capability per format, with the framework inferred from the
+ * file": a `.svg` is read by several frameworks, and deciding which one a
+ * picture is a picture OF is the guess this platform refuses everywhere else.
+ * The three constants are the parser package's, so the declarations cannot
+ * drift into filtering a picker on different extensions.
+ */
+export const WARDLEY_SVG_FORMAT = {
+    id: SVG_SKETCH_FORMAT_ID,
+    tier: 'visual',
+    extensions: [SVG_SKETCH_EXTENSION],
+    mime: SVG_SKETCH_MIME,
+};
+/**
+ * `wardley:svg:import` — an SVG as a sketch, best effort.
+ *
+ * **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.
+ */
+export const WARDLEY_SVG_IMPORT = {
+    id: interchangeCapabilityId('wardley', WARDLEY_SVG_FORMAT.id, 'import'),
+    framework: 'wardley',
+    format: WARDLEY_SVG_FORMAT,
+    direction: 'import',
+    run: parseSvgSketch,
+};
+/* ── The list the view extension registers ────────────────────────────── */
+/** Everything Wardley registers, in one list the view extension hands over. */
+export const WARDLEY_INTERCHANGE = [
+    WARDLEY_OWM_EXPORT,
+    WARDLEY_OWM_IMPORT,
+    WARDLEY_SVG_IMPORT,
+];

package/dist/node/node-renderer.js

@@ -1,6 +1,6 @@
 import { ElementRendererExtension, } from '@formicoidea/labre-core/blocks/surface';
 import { shape as shapeRenderer } from '@formicoidea/labre-core/gfx/shape';
-import { DefaultTheme } from '@formicoidea/labre-core/model';
+import { DefaultTheme, } from '@formicoidea/labre-core/model';
 import { ANCHOR, ECOSYSTEM, METHOD, NODE_FILL } from './consts.js';
 /**
  * Renderer for a Wardley node. The circle is drawn by REUSING the native shape

package/dist/rules.js

@@ -56,6 +56,10 @@ const changeArrowAgainstEvolution = {
     suggestionKey: 'com.labre.wardley.validation.change-arrow-against-evolution.suggestion',
     suggestionFallback: 'Evolution runs left to right — turn the arrow towards the commodity end, or draw a dependency instead.',
     version: 1,
+    provenance: {
+        source: 'recommendation',
+        reference: 'Wardley mapping — the evolution axis runs left to right, and a component moves with it',
+    },
     backgroundRole: WARDLEY_ROLE.map,
     // The frame's own declaration, carried as data exactly like `roles` is: it is
     // where "which way does evolution run" is written, and the engine reads it
@@ -117,6 +121,10 @@ const inertiaOffTransition = {
     // 3: the carrier condition is gone and the position is judged on the bar's
     // extent — a different verdict on the same map, so a new version.
     version: 3,
+    provenance: {
+        source: 'labre-convention',
+        reference: 'Labre convention (PO, recette of 02/08/2026) — Wardley names the zone, not the rule',
+    },
     backgroundRole: WARDLEY_ROLE.map,
     background: WARDLEY_BACKGROUND,
     attachment: {
@@ -186,6 +194,10 @@ const overlappingArtefacts = {
     // calibrated with a penetration threshold — the same mistakes, fewer of the
     // things that were never mistakes.
     version: 2,
+    provenance: {
+        source: 'labre-convention',
+        reference: 'Labre readability convention — no Wardley mapping rule speaks of overlapping ink',
+    },
     // Not a frame the rule measures against — an overlap is an overlap wherever
     // it happens — but the map a finding is ATTRIBUTED to, so the arbitration
     // "ignore this rule on the whole map" has one map to be written on.
@@ -251,6 +263,10 @@ const providerAboveConsumer = {
     suggestionKey: 'com.labre.wardley.validation.provider-above-consumer.suggestion',
     suggestionFallback: 'Needs run downwards on a Wardley map: move the provider below its consumer — or, if the link was drawn the wrong way round, reverse it.',
     version: 1,
+    provenance: {
+        source: 'recommendation',
+        reference: 'Wardley mapping — the value-chain grammar of the map',
+    },
     backgroundRole: WARDLEY_ROLE.map,
     background: WARDLEY_BACKGROUND,
     relativeOrder: {

package/dist/templates/index.js

@@ -27,7 +27,12 @@ const VARIANT_DEFAULTS = {
 };
 const bg = (variant, w = REF_WIDTH) => {
     const h = Math.round((w * 9) / 16);
-    return { type: 'wardley', variant, ...VARIANT_DEFAULTS[variant], xywh: `[0,0,${w},${h}]` };
+    return {
+        type: 'wardley',
+        variant,
+        ...VARIANT_DEFAULTS[variant],
+        xywh: `[0,0,${w},${h}]`,
+    };
 };
 /** A wardley node ellipse positioned by top-left. */
 function node(kind, x, y, d = NODE_SIZE, fill = NODE_FILL, strokeWidth = NODE_STROKE_WIDTH, 
@@ -178,7 +183,9 @@ function market() {
         label: label(MARKET_SIZE + 8, 2, 'Market'),
     };
 }
-const single = (el) => ({ a: el });
+const single = (el) => ({
+    a: el,
+});
 const nodeWithLabel = (kind, d, fill, name) => ({
     n: node(kind, 0, 0, d, fill),
     l: label(d + 8, d / 2 - 13, name),
@@ -187,7 +194,12 @@ const ATTRS = 'width="100%" height="100%" viewBox="0 0 135 80" xmlns="http://www
 const bgPreview = (extra = '') => `<svg ${ATTRS} fill="none"><path d="M22 12 V64 H120" stroke="#3b3d42" stroke-width="2"/><path d="M44 12 V64 M68 12 V64 M94 12 V64" stroke="#9aa0a6" stroke-width="0.8"/>${extra}</svg>`;
 const dotPreview = (fill, sw = 2) => `<svg ${ATTRS} fill="none"><circle cx="67" cy="40" r="13" fill="${fill}" stroke="#1f2328" stroke-width="${sw}"/></svg>`;
 function tpl(name, preview, elements) {
-    return { name, type: 'template', preview, content: makeTemplateSnapshot(elements, name) };
+    return {
+        name,
+        type: 'template',
+        preview,
+        content: makeTemplateSnapshot(elements, name),
+    };
 }
 export const wardleyTemplateCategory = {
     name: 'Wardley',

package/dist/templates/maps.js

@@ -125,7 +125,11 @@ function lbl(e, v, text, o = {}) {
         color: o.color ?? NODE_STROKE,
         fontFamily: FontFamily.Inter,
         fontSize: o.size ?? LABEL_FONT_SIZE,
-        textAlign: align === 'right' ? TextAlign.Right : align === 'center' ? TextAlign.Center : TextAlign.Left,
+        textAlign: align === 'right'
+            ? TextAlign.Right
+            : align === 'center'
+                ? TextAlign.Center
+                : TextAlign.Left,
         xywh: `[${x},${cy + dy},${w},26]`,
     };
 }
@@ -222,7 +226,12 @@ function title(str) {
 const ATTRS = 'width="100%" height="100%" viewBox="0 0 135 80" xmlns="http://www.w3.org/2000/svg"';
 const mapPreview = (extra) => `<svg ${ATTRS} fill="none"><path d="M22 12 V64 H120" stroke="#3b3d42" stroke-width="2"/>${extra}</svg>`;
 function tpl(name, preview, elements) {
-    return { name, type: 'template', preview, content: makeTemplateSnapshot(elements, name) };
+    return {
+        name,
+        type: 'template',
+        preview,
+        content: makeTemplateSnapshot(elements, name),
+    };
 }
 function ann(e, v) {
     const cx = ex(e);
@@ -260,7 +269,11 @@ function teaShop() {
         annBox: panel(120, 200, 420, 64),
         annText: freeText(132, 208, 400, 'Annotations:\n1. Standardising power lets kettles evolve faster\n2. Hot water is obvious and well known', 13),
         business: stake(0.62, 0.93),
-        businessL: lbl(0.62, 0.93, 'Business', { align: 'center', dy: -28, w: 120 }),
+        businessL: lbl(0.62, 0.93, 'Business', {
+            align: 'center',
+            dy: -28,
+            w: 120,
+        }),
         public: stake(0.78, 0.93),
         publicL: lbl(0.78, 0.93, 'Public', { align: 'center', dy: -28, w: 120 }),
         cupOfTea: comp(0.62, 0.74),
@@ -284,9 +297,16 @@ function teaShop() {
         // ABOVE the link it annotates, not across it. Written on the line it reads
         // as a label nobody can read — which is the finding W3 raises, and it was
         // raising it on the map that ships as the canonical example.
-        limitedBy: lbl(0.56, 0.43, 'limited by', { align: 'center', w: 120, size: 13, dy: -34 }),
-        ann1a: ann(0.5, 0.385), ann1t: annTxt(0.5, 0.385, '1'),
-        ann2a: ann(0.84, 0.45), ann2t: annTxt(0.84, 0.45, '2'),
+        limitedBy: lbl(0.56, 0.43, 'limited by', {
+            align: 'center',
+            w: 120,
+            size: 13,
+            dy: -34,
+        }),
+        ann1a: ann(0.5, 0.385),
+        ann1t: annTxt(0.5, 0.385, '1'),
+        ann2a: ann(0.84, 0.45),
+        ann2t: annTxt(0.84, 0.45, '2'),
         l1: link('business', 'cupOfTea'),
         l2: link('public', 'cupOfTea'),
         l3: link('cupOfTea', 'cup'),

package/dist/toolbar/config.js

@@ -187,7 +187,9 @@ export const wardleyToolbarConfig = {
                 if (!bg)
                     return;
                 createWardleyLegend(ctx.std, bg);
-                ctx.std.getOptional(TelemetryProvider)?.track('FrameworkLegendCreated', {
+                ctx.std
+                    .getOptional(TelemetryProvider)
+                    ?.track('FrameworkLegendCreated', {
                     framework: 'wardley',
                     element: 'legend',
                     page: 'whiteboard editor',

package/dist/toolbar/icons.d.ts

@@ -24,7 +24,27 @@ export declare const wardleyMethodIcon: import("lit-html").TemplateResult<2>;
 export declare const wardleyLegendIcon: import("lit-html").TemplateResult<2>;
 /** Opportunity gradient background: axes + green differential hump + red operational bump. */
 export declare const wardleyOpportunityIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Import an SVG sketch — a framed picture with an arrow coming IN.
+ *
+ * Deliberately the same glyph BPMN gives the same command: the two wrap ONE
+ * parser and make one promise, and a reader who has met one should recognise
+ * the other without reading its label.
+ */
+export declare const wardleyImportSvgIcon: import("lit-html").TemplateResult<2>;
 /** Benefit/Investment gradient background: axes + zero line + green J-curve. */
 export declare const wardleyBenefitIcon: import("lit-html").TemplateResult<2>;
 /** Evolution-gradient background (Wardley's S-curve presentation): grey at both edges fading to white center. */
 export declare const wardleyEvolutionGradientIcon: import("lit-html").TemplateResult<2>;
+/**
+ * Export the map as an OWM document — a page with the map's own axes drawn on
+ * it, and an arrow going OUT.
+ *
+ * The page and the arrow are BPMN's, deliberately: interchange is a platform
+ * capability, and a reader who has met one framework's pair should recognise
+ * the next without reading its label. What differs is what is drawn ON the page
+ * — the value-chain corner, which is what makes it a map rather than a process.
+ */
+export declare const wardleyExportOwmIcon: import("lit-html").TemplateResult<2>;
+/** Import an OWM document — the same page and the same arrow, mirrored back IN. */
+export declare const wardleyImportOwmIcon: import("lit-html").TemplateResult<2>;

package/dist/toolbar/icons.js

@@ -114,6 +114,18 @@ export const wardleyOpportunityIcon = svg `<svg width="24" height="24" viewBox="
   <path d="M5 12 C6 7, 8.5 7, 9.5 11 C11 17, 14 19, 18 20" stroke="${GREEN}" stroke-width="1.7" fill="none" stroke-linecap="round"/>
   <path d="M14.5 19.5 C15.5 16.5, 17 16.5, 18 19" stroke="${RED}" stroke-width="1.7" fill="none" stroke-linecap="round"/>
 </svg>`;
+/**
+ * Import an SVG sketch — a framed picture with an arrow coming IN.
+ *
+ * Deliberately the same glyph BPMN gives the same command: the two wrap ONE
+ * parser and make one promise, and a reader who has met one should recognise
+ * the other without reading its label.
+ */
+export const wardleyImportSvgIcon = svg `<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <rect x="3" y="5" width="14" height="11" rx="1.5" stroke="currentColor" stroke-width="1.5"/>
+  <path d="M3.5 13 7 9.5l3 3 2-2 3.5 3.5" stroke="currentColor" stroke-width="1.3" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M19 14.5v6M16.5 17l2.5-2.5 2.5 2.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>`;
 /** Benefit/Investment gradient background: axes + zero line + green J-curve. */
 export const wardleyBenefitIcon = svg `<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
   <path d="M4 20V4M4 20h16" stroke="currentColor" stroke-width="1.4" stroke-linecap="round"/>
@@ -132,3 +144,25 @@ export const wardleyEvolutionGradientIcon = svg `<svg width="24" height="24" vie
   </defs>
   <rect x="4" y="4.5" width="16" height="15" rx="2" fill="url(#wardleyGreyU)" stroke="currentColor" stroke-width="1.2"/>
 </svg>`;
+/**
+ * Export the map as an OWM document — a page with the map's own axes drawn on
+ * it, and an arrow going OUT.
+ *
+ * The page and the arrow are BPMN's, deliberately: interchange is a platform
+ * capability, and a reader who has met one framework's pair should recognise
+ * the next without reading its label. What differs is what is drawn ON the page
+ * — the value-chain corner, which is what makes it a map rather than a process.
+ */
+export const wardleyExportOwmIcon = svg `<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="M13.5 3.5H7a1.5 1.5 0 0 0-1.5 1.5v14A1.5 1.5 0 0 0 7 20.5h3" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
+  <path d="M13.5 3.5 18.5 8.5V12" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M8.5 7v6.5H13" stroke="currentColor" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round" opacity="0.6"/>
+  <path d="M16 20.5v-6M13.5 18l2.5 2.5 2.5-2.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>`;
+/** Import an OWM document — the same page and the same arrow, mirrored back IN. */
+export const wardleyImportOwmIcon = svg `<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="M13.5 3.5H7a1.5 1.5 0 0 0-1.5 1.5v14A1.5 1.5 0 0 0 7 20.5h3" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
+  <path d="M13.5 3.5 18.5 8.5V12" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M8.5 7v6.5H13" stroke="currentColor" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round" opacity="0.6"/>
+  <path d="M16 14.5v6M13.5 17l2.5-2.5 2.5 2.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>`;

package/dist/toolbar/senior-tool.js

@@ -3,6 +3,7 @@ import { html } from 'lit';
 export const wardleySeniorTool = SeniorToolExtension('wardley', ({ block }) => {
     return {
         name: 'Wardley map',
+        labelKey: 'com.labre.framework.wardley',
         content: html `<edgeless-wardley-senior-button
       .edgeless=${block}
     ></edgeless-wardley-senior-button>`,

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

@@ -1,5 +1,6 @@
 import { DefaultTool } from '@formicoidea/labre-core/blocks/surface';
 import { EmptyTool } from '@formicoidea/labre-core/gfx/pointer';
+import { translateKey } from '@formicoidea/labre-core/shared/services';
 import { EdgelessToolbarToolMixin } from '@formicoidea/labre-core/widgets/edgeless-toolbar';
 import { SignalWatcher } from '@formicoidea/labre-core/global/lit';
 import { css, html, LitElement } from 'lit';
@@ -46,12 +47,15 @@ export class EdgelessWardleySeniorButton extends EdgelessToolbarToolMixin(Signal
       bottom: 0;
       width: 54px;
       height: 54px;
-      transform: translateY(var(--y)) scale(var(--s));   /* base */
-      translate: var(--active-x, 0) var(--active-y, 0);   /* actif */
+      transform: translateY(var(--y)) scale(var(--s)); /* base */
+      translate: var(--active-x, 0) var(--active-y, 0); /* actif */
       rotate: var(--active-r, -2deg);
-        scale: var(--active-s, 1);
-      transition: transform 0.3s ease, translate 0.3s ease,
-        rotate 0.3s ease, scale 0.3s ease;
+      scale: var(--active-s, 1);
+      transition:
+        transform 0.3s ease,
+        translate 0.3s ease,
+        rotate 0.3s ease,
+        scale 0.3s ease;
     }
     .wardley-card svg {
       display: block;
@@ -79,7 +83,9 @@ export class EdgelessWardleySeniorButton extends EdgelessToolbarToolMixin(Signal
     render() {
         return html `<edgeless-toolbar-button
       class="wardley-button"
-      .tooltip=${this.popper ? '' : 'Wardley map'}
+      .tooltip=${this.popper
+            ? ''
+            : translateKey(this.edgeless.std, 'com.labre.framework.wardley', 'Wardley map')}
       .tooltipOffset=${4}
       .active=${!!this.popper}
       @click=${this._toggleMenu}

package/dist/view.js

@@ -1,4 +1,4 @@
-import { ReadingProfileExtension, tagsToolbarConfig, validationToolbarConfig, QualityNudgeExtension, ValidationProfileExtension, ValidationRuleExtension, } from '@formicoidea/labre-core/blocks/surface';
+import { InterchangeExtension, ReadingProfileExtension, tagsToolbarConfig, validationToolbarConfig, QualityNudgeExtension, ValidationProfileExtension, ValidationRuleExtension, } from '@formicoidea/labre-core/blocks/surface';
 import { AuditCriterionExtension, ToolbarModuleExtension, UniverseTagDefsExtension, } from '@formicoidea/labre-core/shared/services';
 import { ViewExtensionProvider, } from '@formicoidea/labre-core/ext-loader';
 import { extendTemplateCategory } from '@formicoidea/labre-core/gfx/template';
@@ -7,6 +7,7 @@ import { RoleVocabularyExtension } from '@formicoidea/labre-core/std/gfx';
 import { WARDLEY_AUDIT_CRITERIA } from './audit-criteria.js';
 import { wardleyCommandIcons, wardleyCommands } from './commands.js';
 import { effects } from './effects.js';
+import { WARDLEY_INTERCHANGE } from './interchange.js';
 import { WARDLEY_TAG_DEFS } from './natures.js';
 import { WARDLEY_PROFILES } from './profiles.js';
 import { WARDLEY_NUDGES } from './nudges.js';
@@ -75,6 +76,15 @@ export class WardleyViewExtension extends ViewExtensionProvider {
         if (this.isEdgeless(context.scope)) {
             context.register(ValidationRuleExtension(WARDLEY_RULES));
             context.register(ValidationProfileExtension(WARDLEY_PROFILES));
+            // Both directions of the OWM DSL, and the SVG fallback that reads a
+            // picture of a map (`docs/adr/0012`, P1) — ONE registration, because the
+            // unit of declaration is the capability and `WARDLEY_INTERCHANGE` is the
+            // list of them. HERE, beside the rules, because offering to read or write
+            // a file is TOOLING: turning the wardley flag off removes the three
+            // commands and leaves every element a past import created — and every
+            // byte of `interchange` they carry — exactly where it is
+            // (`docs/adr/0009`).
+            context.register(InterchangeExtension(WARDLEY_INTERCHANGE));
             // Map quality (PF13.9): the four nudges the tool cannot judge, and
             // nothing else — the on-demand check-up Wardley used to expose beside
             // them was dropped on the PO recette of 02/08/2026. The engine keeps the
@@ -132,7 +142,8 @@ export class WardleyViewExtension extends ViewExtensionProvider {
             // the flag without either side naming the other.
             context.register(ReadingProfileExtension(WARDLEY_READING));
             context.register(wardleySeniorTool);
-            // The 13 Wardley commands, ONE registration for both faces: the
+            // The Wardley commands — thirteen artefacts plus the two directions of
+            // the OWM DSL — ONE registration for both faces: the
             // enumerable registry the sub-menu renders from, and — through
             // `toShortcutDescriptor` — the edgeless chords (w+c, w+l, ...).
             // Registering here inherits both the wardley flag gating and the

package/package.json

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