@formicoidea/labre-framework-wardley 0.31.0 → 0.33.0

package/dist/actions.d.ts

@@ -1,16 +1,7 @@
-import { type WardleyBgVariant } from '@formicoidea/labre-core/model';
-import type { GfxController } from '@formicoidea/labre-core/std/gfx';
-/**
- * Standalone creation/activation actions for the Wardley toolbox. They are
- * invoked from both the toolbar menu ({@link EdgelessWardleyMenu}) and the
- * wardley keyboard shortcuts, so they only depend on the {@link GfxController}.
- */
-/** Where the action was triggered from — feeds the telemetry payload. */
-export interface WardleyActionSource {
-    segment: string;
-    module: string;
-}
-export declare const WARDLEY_SHORTCUT_SOURCE: WardleyActionSource;
+import { WardleyBackgroundElementModel, type WardleyBgVariant } from '@formicoidea/labre-core/model';
+import type { BlockStdScope } from '@formicoidea/labre-core/std';
+import { type GfxController } from '@formicoidea/labre-core/std/gfx';
+import { type WardleyExportBoard } from './export.js';
 /**
  * The single-circle node flavours: one connectable ellipse + a label to its
  * right, grouped. The glyph itself (anchor silhouette, ecosystem hatching,
@@ -38,17 +29,24 @@ declare const NODE_PRESETS: {
         readonly label: "Component";
     };
 };
-export type WardleyNodeKind = keyof typeof NODE_PRESETS;
+/**
+ * The subset of {@link WardleyNodeKind} that the single-circle presets above
+ * cover. Renamed away from `WardleyNodeKind` on purpose: the model declares a
+ * type of that name with SEVEN values, and two homonyms of different
+ * cardinality — one of them now the source of the semantic vocabulary — is a
+ * trap. `WARDLEY_ROLE[kind]` below only compiles while this stays a subset.
+ */
+export type WardleySingleCircleKind = keyof typeof NODE_PRESETS;
 /** Create a wardley map background of the given variant, viewport-centered. */
-export declare function createWardleyBackground(gfx: GfxController, variant?: WardleyBgVariant, source?: WardleyActionSource): void;
+export declare function createWardleyBackground(gfx: GfxController, variant?: WardleyBgVariant): void;
 /**
  * Create a single-circle node (component / anchor / ecosystem / method):
  * one connectable native ellipse + a label to its right, grouped so they
  * move together (enter the group to reposition / edit the label).
  */
-export declare function createWardleyNode(gfx: GfxController, kind: WardleyNodeKind, source?: WardleyActionSource): void;
+export declare function createWardleyNode(gfx: GfxController, kind: WardleySingleCircleKind): void;
 /** Create an inertia bar (filled black rect). */
-export declare function createWardleyInertia(gfx: GfxController, source?: WardleyActionSource): void;
+export declare function createWardleyInertia(gfx: GfxController): void;
 /**
  * Create a pipeline: a wide thin native rect body (white semi-transparent,
  * NON-connectable) + a node-sized square handle straddling its top edge (the
@@ -56,7 +54,7 @@ export declare function createWardleyInertia(gfx: GfxController, source?: Wardle
  * label are grouped, then grouped again with the body so the whole pipeline
  * moves as one. Pure composition of native elements — no custom type / view.
  */
-export declare function createWardleyPipeline(gfx: GfxController, source?: WardleyActionSource): void;
+export declare function createWardleyPipeline(gfx: GfxController): void;
 /**
  * Create a market: a large thin-bordered circle (the connectable market node)
  * containing 3 small thick-bordered component nodes wired into a triangle by
@@ -64,11 +62,56 @@ export declare function createWardleyPipeline(gfx: GfxController, source?: Wardl
  * the node centers and follow on move/resize). A label sits to the right and
  * everything is grouped into one object.
  */
-export declare function createWardleyMarket(gfx: GfxController, source?: WardleyActionSource): void;
+export declare function createWardleyMarket(gfx: GfxController): void;
+/**
+ * Read an SVG the user picks as a SKETCH, and say what it cost.
+ *
+ * Wardley's first interchange command, and its whole implementation: the four
+ * steps live in {@link runInterchangeImportFile} and the reading lives in the
+ * declared capability, so this framework contributes a declaration and a
+ * label rather than a pipeline (`docs/adr/0012`, P1 and P3).
+ *
+ * It takes a `BlockStdScope` and not the `GfxController` the rest of this file
+ * runs on, because an import is not a drawing gesture: it opens a picker,
+ * writes a whole board in one undo step, moves the viewport and notifies —
+ * none of which a `GfxController` alone can do.
+ */
+export declare function importWardleySvgFile(std: BlockStdScope): Promise<void>;
 /**
  * Activate the native connector tool, pre-styled for a Wardley link (grey,
  * solid, no arrow) or evolution arrow (red, dashed, FILLED triangle). The
  * user then draws from one node to another (endpoints attach to centers).
  */
-export declare function activateWardleyConnector(gfx: GfxController, kind: 'link' | 'arrow', source?: WardleyActionSource): void;
+export declare function activateWardleyConnector(gfx: GfxController, kind: 'link' | 'arrow'): void;
+/** The maps on the surface — what the export command is offered against. */
+export declare function wardleyMapsOnBoard(std: BlockStdScope): WardleyBackgroundElementModel[];
+/**
+ * Everything on the surface the exporter speaks about, in document order.
+ *
+ * The half that needs an editor, and only that half: reading the surface. The
+ * picking is {@link wardleyBoardFrom}, which the interchange capability calls
+ * with the same elements and no `std` at all (`docs/adr/0012`, P3).
+ */
+export declare function wardleyBoardOf(std: BlockStdScope): WardleyExportBoard;
+/**
+ * Serialize the board as an OWM document and hand it to the browser.
+ *
+ * Three steps, and only the first and the last know what an editor is: read the
+ * surface, run the DECLARED capability, download what it produced. The middle
+ * step is not re-implemented here — the document, the filename and the content
+ * type all come out of `WARDLEY_OWM_EXPORT.run`, so the command and the
+ * registry cannot describe the same map differently. There is one door, and the
+ * registry is the label on it.
+ */
+export declare function exportOwmFile(std: BlockStdScope): void;
+/**
+ * Read an `.owm` the user picks, draw it, and say what it cost.
+ *
+ * The whole of the import glue, and it is one line: the generic pipeline picks
+ * the file from the format's own declaration, runs the capability, mints the
+ * surface ids and repairs the link endpoints that named the file's names,
+ * brings the map into view and reports. Nothing in it is about Wardley except
+ * the capability handed to it.
+ */
+export declare function importOwmFile(std: BlockStdScope): Promise<void>;
 export {};

package/dist/actions.js

@@ -1,23 +1,45 @@
-import { DefaultTool } from '@formicoidea/labre-core/blocks/surface';
+import { backgroundSize, DefaultTool, runInterchangeImportFile, } from '@formicoidea/labre-core/blocks/surface';
 import { ConnectorTool } from '@formicoidea/labre-core/gfx/connector';
 import { createGroupCommand } from '@formicoidea/labre-core/gfx/group';
-import { ConnectorMode, FontFamily, PointStyle, ShapeStyle, StrokeStyle, TextFitMode, } from '@formicoidea/labre-core/model';
-import { EditPropsStore, TelemetryProvider, } from '@formicoidea/labre-core/shared/services';
+import { ConnectorMode, FontFamily, PointStyle, ShapeStyle, StrokeStyle, TextFitMode, WardleyBackgroundElementModel, } from '@formicoidea/labre-core/model';
+import { NotificationProvider, translateKey, } from '@formicoidea/labre-core/shared/services';
+import { downloadBlob } from '@formicoidea/labre-core/shared/utils';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
-import { REF_WIDTH } from './consts.js';
+import { GfxControllerIdentifier } from '@formicoidea/labre-core/std/gfx';
+import { WARDLEY_BACKGROUND } from './background.js';
+import { WARDLEY_SVG_IMPORT } from './interchange.js';
+import { wardleyBoardFrom, wardleySafeFilename, } from './export.js';
+import { WARDLEY_OWM_EXPORT, WARDLEY_OWM_IMPORT } from './interchange.js';
 import { ECOSYSTEM_LABEL, ECOSYSTEM_SIZE, HANDLE_SIZE, INERTIA_COLOR, INERTIA_SIZE, 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, WARDLEY_RED, } from './node/consts.js';
-const TOOLBOX_SOURCE = {
-    segment: 'wardley toolbox',
-    module: 'wardley menu',
-};
-export const WARDLEY_SHORTCUT_SOURCE = {
-    segment: 'wardley toolbox',
-    module: 'keyboard shortcut',
-};
+import { WARDLEY_ROLE } from './roles.js';
+/**
+ * Standalone creation/activation actions for the Wardley toolbox — the
+ * BEHAVIOUR layer, shared by every surface. They only depend on the
+ * {@link GfxController}.
+ *
+ * They no longer emit telemetry: since PF3 the single emission point is the
+ * command registry's `runCommand` (`docs/adr/0008`), which is the only function
+ * every surface goes through. `WardleyActionSource` is gone with it — the
+ * segment/module discrimination it carried is now `CommandInvocation.surface`.
+ */
 /**
  * Per-variant default label overrides applied at creation (all remain editable
  * afterwards via the inline editor / toggles). The gradient itself is driven by
  * `variant` in the renderer.
+ *
+ * TODO(PF2 follow-up): these write ENGLISH PROSE into the document. Since PF2
+ * the ten label props default to `undefined` precisely so the declaration's
+ * i18n keys are reachable — but a map created as `opportunity` or `benefit`
+ * lands with "Opportunity" / "Benefit" / "Investment" already persisted as if
+ * the user had typed them, so those three are un-localisable for the life of
+ * the document. Only `classic` and `evolution-gradient` are fully localisable
+ * today.
+ *
+ * The fix is to make the variant part of the declaration — one axis/end-label
+ * set per variant, each naming its own `labelKey` — rather than a bag of prop
+ * overrides applied at creation. Out of scope here (it changes what a variant
+ * IS); duplicated verbatim in `templates/index.ts`, and both copies go away
+ * together.
  */
 const BACKGROUND_VARIANT_DEFAULTS = {
     classic: {},
@@ -55,14 +77,6 @@ const NODE_PRESETS = {
     // Method: the FILL color encodes the chosen method (editable).
     method: { d: METHOD_SIZE, fill: METHOD_FILL, label: METHOD_LABEL },
 };
-function track(gfx, source, event, element) {
-    gfx.std.getOptional(TelemetryProvider)?.track(event, {
-        framework: 'wardley',
-        element,
-        page: 'whiteboard editor',
-        ...source,
-    });
-}
 function finish(gfx, id) {
     gfx.doc.captureSync();
     gfx.tool.setTool(DefaultTool);
@@ -78,10 +92,18 @@ function group(gfx, ids) {
     return result.groupId || ids[0];
 }
 /** Add a native ellipse wardley node centred on (cx, cy). */
-function addEllipseNode(surface, kind, cx, cy, d, fillColor, strokeWidth = NODE_STROKE_WIDTH) {
+function addEllipseNode(surface, kind, cx, cy, d, fillColor, strokeWidth = NODE_STROKE_WIDTH, 
+// The market's three inner dots are the GLYPH's own wiring, not artefacts the
+// user placed — the same reason its triangle connectors carry no role. They
+// sit inside the market circle by construction, so a role would make every
+// market composite report an overlap with itself (W3).
+neutral = false) {
     return surface.addElement({
         type: 'wardleyNode',
         kind,
+        // Semantic identity (PF1): posted next to `kind`, which stays untouched
+        // and keeps driving the rendering.
+        role: neutral ? undefined : WARDLEY_ROLE[kind],
         shapeType: 'ellipse',
         filled: true,
         fillColor,
@@ -97,6 +119,11 @@ function addLabel(surface, text, x, y, textAlign = 'left') {
     return surface.addElement({
         type: 'text',
         text,
+        // Semantic identity (PF1, revised in PF13.4): a Wardley label is a free
+        // text element like any other, so its ROLE is the only thing that tells W3
+        // it must not land on top of a node. A free text the user typed elsewhere
+        // stays neutral and is never evaluated.
+        role: WARDLEY_ROLE.label,
         fontFamily: FontFamily.Inter,
         fontSize: LABEL_FONT_SIZE,
         color: NODE_STROKE,
@@ -105,23 +132,34 @@ function addLabel(surface, text, x, y, textAlign = 'left') {
     });
 }
 /** Create a wardley map background of the given variant, viewport-centered. */
-export function createWardleyBackground(gfx, variant = 'classic', source = TOOLBOX_SOURCE) {
+export function createWardleyBackground(gfx, variant = 'classic') {
     if (!gfx.surface)
         return;
-    let width = REF_WIDTH;
+    // A second map matches the biggest one already on the board rather than
+    // shrinking beside it. The reference size and the locked 16:9 proportion are
+    // the declaration's (`geometry`), not this function's.
+    let atLeastWidth = 0;
+    let atLeastHeight = 0;
     for (const el of gfx.surface.getElementsByType('wardley')) {
         const [, , ew, eh] = el.deserializedXYWH;
-        width = Math.max(width, ew, (eh * 16) / 9);
+        atLeastWidth = Math.max(atLeastWidth, ew);
+        atLeastHeight = Math.max(atLeastHeight, eh);
     }
-    const height = (width * 9) / 16;
+    const { width, height } = backgroundSize(WARDLEY_BACKGROUND, atLeastWidth, atLeastHeight);
     const { centerX, centerY } = gfx.viewport;
     const id = gfx.surface.addElement({
-        type: 'wardley',
+        type: WARDLEY_BACKGROUND.type,
+        // The map is a first-class role: validation rules position artefacts
+        // against `wardley:map`, never against the `wardley` element type. The
+        // declaration owns it, so a templated map and a hand-drawn one agree.
+        role: WARDLEY_BACKGROUND.role,
+        // A map is a frame you place things on, not a shape you nudge — the
+        // declaration decides, and the toolbar toggle takes over from there.
+        resizeEnabled: WARDLEY_BACKGROUND.geometry.resizable,
         variant,
         ...BACKGROUND_VARIANT_DEFAULTS[variant],
         xywh: new Bound(centerX - width / 2, centerY - height / 2, width, height).serialize(),
     });
-    track(gfx, source, 'FrameworkElementAdded', `background:${variant}`);
     finish(gfx, id);
 }
 /**
@@ -129,7 +167,7 @@ export function createWardleyBackground(gfx, variant = 'classic', source = TOOLB
  * one connectable native ellipse + a label to its right, grouped so they
  * move together (enter the group to reposition / edit the label).
  */
-export function createWardleyNode(gfx, kind, source = TOOLBOX_SOURCE) {
+export function createWardleyNode(gfx, kind) {
     const surface = gfx.surface;
     if (!surface)
         return;
@@ -137,11 +175,10 @@ export function createWardleyNode(gfx, kind, source = TOOLBOX_SOURCE) {
     const { centerX: cx, centerY: cy } = gfx.viewport;
     const nodeId = addEllipseNode(surface, kind, cx, cy, d, fill);
     const labelId = addLabel(surface, label, cx + d / 2 + LABEL_GAP, cy - LABEL_H / 2);
-    track(gfx, source, 'FrameworkElementAdded', `node:${kind}`);
     finish(gfx, group(gfx, [nodeId, labelId]));
 }
 /** Create an inertia bar (filled black rect). */
-export function createWardleyInertia(gfx, source = TOOLBOX_SOURCE) {
+export function createWardleyInertia(gfx) {
     if (!gfx.surface)
         return;
     const { w, h } = INERTIA_SIZE;
@@ -149,6 +186,9 @@ export function createWardleyInertia(gfx, source = TOOLBOX_SOURCE) {
     const id = gfx.surface.addElement({
         type: 'shape',
         shapeType: 'rect',
+        // The inertia bar has no element type of its own — it IS a plain filled
+        // rect — so the role is the whole of its semantics (PF13.5).
+        role: WARDLEY_ROLE.inertia,
         filled: true,
         fillColor: INERTIA_COLOR,
         strokeColor: INERTIA_COLOR,
@@ -160,7 +200,6 @@ export function createWardleyInertia(gfx, source = TOOLBOX_SOURCE) {
         textFitMode: TextFitMode.Overflow,
         xywh: new Bound(centerX - w / 2, centerY - h / 2, w, h).serialize(),
     });
-    track(gfx, source, 'FrameworkElementAdded', 'node:inertia');
     finish(gfx, id);
 }
 /**
@@ -170,7 +209,7 @@ export function createWardleyInertia(gfx, source = TOOLBOX_SOURCE) {
  * label are grouped, then grouped again with the body so the whole pipeline
  * moves as one. Pure composition of native elements — no custom type / view.
  */
-export function createWardleyPipeline(gfx, source = TOOLBOX_SOURCE) {
+export function createWardleyPipeline(gfx) {
     if (!gfx.surface)
         return;
     const { centerX: cx, centerY: cy } = gfx.viewport;
@@ -182,6 +221,7 @@ export function createWardleyPipeline(gfx, source = TOOLBOX_SOURCE) {
     const bodyId = gfx.surface.addElement({
         type: 'wardleyNode',
         kind: 'pipeline',
+        role: WARDLEY_ROLE.pipeline,
         shapeType: 'rect',
         filled: true,
         fillColor: PIPELINE_FILL,
@@ -197,6 +237,7 @@ export function createWardleyPipeline(gfx, source = TOOLBOX_SOURCE) {
     const handleId = gfx.surface.addElement({
         type: 'wardleyNode',
         kind: 'handle',
+        role: WARDLEY_ROLE.handle,
         shapeType: 'rect',
         filled: true,
         fillColor: NODE_FILL,
@@ -211,7 +252,6 @@ export function createWardleyPipeline(gfx, source = TOOLBOX_SOURCE) {
     const labelId = addLabel(gfx.surface, PIPELINE_LABEL, cx - 60, top - d / 2 - LABEL_H - LABEL_GAP, 'center');
     // Nested groups: (handle + label), then (body + that group).
     const innerId = group(gfx, [handleId, labelId]);
-    track(gfx, source, 'FrameworkElementAdded', 'node:pipeline');
     finish(gfx, group(gfx, [bodyId, innerId]));
 }
 /**
@@ -221,7 +261,7 @@ export function createWardleyPipeline(gfx, source = TOOLBOX_SOURCE) {
  * the node centers and follow on move/resize). A label sits to the right and
  * everything is grouped into one object.
  */
-export function createWardleyMarket(gfx, source = TOOLBOX_SOURCE) {
+export function createWardleyMarket(gfx) {
     const surface = gfx.surface;
     if (!surface)
         return;
@@ -237,7 +277,7 @@ export function createWardleyMarket(gfx, source = TOOLBOX_SOURCE) {
         [rho * sin60, rho / 2],
         [-rho * sin60, rho / 2],
     ];
-    const dotIds = verts.map(([vx, vy]) => addEllipseNode(surface, 'component', cx + vx, cy + vy, MARKET_DOT_SIZE, NODE_FILL, MARKET_DOT_STROKE_WIDTH));
+    const dotIds = verts.map(([vx, vy]) => addEllipseNode(surface, 'component', cx + vx, cy + vy, MARKET_DOT_SIZE, NODE_FILL, MARKET_DOT_STROKE_WIDTH, true));
     // Triangle: 3 attached connectors (auto-route center-to-center, clipped).
     const connIds = [
         [dotIds[0], dotIds[1]],
@@ -255,35 +295,128 @@ export function createWardleyMarket(gfx, source = TOOLBOX_SOURCE) {
         rearEndpointStyle: PointStyle.None,
     }));
     const labelId = addLabel(surface, MARKET_LABEL, cx + R + LABEL_GAP, cy - LABEL_H / 2);
-    track(gfx, source, 'FrameworkElementAdded', 'node:market');
     finish(gfx, group(gfx, [circleId, ...dotIds, ...connIds, labelId]));
 }
+/**
+ * Read an SVG the user picks as a SKETCH, and say what it cost.
+ *
+ * Wardley's first interchange command, and its whole implementation: the four
+ * steps live in {@link runInterchangeImportFile} and the reading lives in the
+ * declared capability, so this framework contributes a declaration and a
+ * label rather than a pipeline (`docs/adr/0012`, P1 and P3).
+ *
+ * It takes a `BlockStdScope` and not the `GfxController` the rest of this file
+ * runs on, because an import is not a drawing gesture: it opens a picker,
+ * writes a whole board in one undo step, moves the viewport and notifies —
+ * none of which a `GfxController` alone can do.
+ */
+export async function importWardleySvgFile(std) {
+    await runInterchangeImportFile(std, WARDLEY_SVG_IMPORT);
+}
 /**
  * Activate the native connector tool, pre-styled for a Wardley link (grey,
  * solid, no arrow) or evolution arrow (red, dashed, FILLED triangle). The
  * user then draws from one node to another (endpoints attach to centers).
  */
-export function activateWardleyConnector(gfx, kind, source = TOOLBOX_SOURCE) {
-    const props = kind === 'arrow'
-        ? {
-            mode: ConnectorMode.Straight,
-            stroke: WARDLEY_RED,
-            strokeStyle: StrokeStyle.Dash,
-            strokeWidth: LINK_STROKE_WIDTH,
-            frontEndpointStyle: PointStyle.None,
-            rearEndpointStyle: PointStyle.Triangle,
-        }
-        : {
-            mode: ConnectorMode.Straight,
-            stroke: LINK_GREY,
-            strokeStyle: StrokeStyle.Solid,
-            strokeWidth: LINK_STROKE_WIDTH,
-            frontEndpointStyle: PointStyle.None,
-            rearEndpointStyle: PointStyle.None,
-        };
-    gfx.std.get(EditPropsStore).recordLastProps('connector', props);
-    track(gfx, source, 'FrameworkToolPicked', `connector:${kind}`);
-    gfx.tool.setTool(ConnectorTool, { mode: ConnectorMode.Straight });
+export function activateWardleyConnector(gfx, kind) {
+    gfx.tool.setTool(ConnectorTool, {
+        mode: ConnectorMode.Straight,
+        // The value-chain link IS the "depends on" edge of a Wardley map; the
+        // change arrow is a movement annotation and gets a role OF ITS OWN
+        // (PF13.4, reversing #71 — see `roles.ts`). Two roles, never one
+        // specialising the other: W1 is about where an arrow points and must never
+        // fall on a dependency.
+        role: kind === 'link' ? WARDLEY_ROLE.dependency : WARDLEY_ROLE.changeArrow,
+        // The look rides on the activation, never through the last-props store:
+        // the plain connector tool must keep the user's own style (#144 M1).
+        style: kind === 'arrow'
+            ? {
+                stroke: WARDLEY_RED,
+                strokeStyle: StrokeStyle.Dash,
+                strokeWidth: LINK_STROKE_WIDTH,
+                frontEndpointStyle: PointStyle.None,
+                rearEndpointStyle: PointStyle.Triangle,
+            }
+            : {
+                stroke: LINK_GREY,
+                strokeStyle: StrokeStyle.Solid,
+                strokeWidth: LINK_STROKE_WIDTH,
+                frontEndpointStyle: PointStyle.None,
+                rearEndpointStyle: PointStyle.None,
+            },
+    });
     // The wardley palette stays open (native sub-menu behaviour): it only
     // closes on re-click of the senior button, another senior tool, or Escape.
 }
+/* ── Interchange: the OWM DSL, out and in (`docs/adr/0012`) ───────────── */
+/**
+ * The one wording this file owns: what a WRITER could not say.
+ *
+ * The import's wordings live in the pipeline that writes them
+ * (`affine-block-surface`, `extensions/interchange-import.ts`) — one set of
+ * keys for every format, with the format's own name composed into them, so
+ * "OWM file imported" needs no key of its own. An export's losses are the
+ * capability's own sentences and have nowhere else to go.
+ */
+const EXPORT_WARNINGS_KEY = 'com.labre.commands.wardley.exportOwm.warnings';
+const EXPORT_WARNINGS_FALLBACK = 'What this export could not write down';
+/** The maps on the surface — what the export command is offered against. */
+export function wardleyMapsOnBoard(std) {
+    const surface = std.get(GfxControllerIdentifier).surface;
+    return (surface?.elementModels ?? []).filter((model) => model instanceof WardleyBackgroundElementModel);
+}
+/**
+ * Everything on the surface the exporter speaks about, in document order.
+ *
+ * The half that needs an editor, and only that half: reading the surface. The
+ * picking is {@link wardleyBoardFrom}, which the interchange capability calls
+ * with the same elements and no `std` at all (`docs/adr/0012`, P3).
+ */
+export function wardleyBoardOf(std) {
+    return wardleyBoardFrom(std.get(GfxControllerIdentifier).surface?.elementModels ?? []);
+}
+/**
+ * Serialize the board as an OWM document and hand it to the browser.
+ *
+ * Three steps, and only the first and the last know what an editor is: read the
+ * surface, run the DECLARED capability, download what it produced. The middle
+ * step is not re-implemented here — the document, the filename and the content
+ * type all come out of `WARDLEY_OWM_EXPORT.run`, so the command and the
+ * registry cannot describe the same map differently. There is one door, and the
+ * registry is the label on it.
+ */
+export function exportOwmFile(std) {
+    const elements = std.get(GfxControllerIdentifier).surface?.elementModels ?? [];
+    const title = std.store.workspace.meta.getDocMeta(std.store.id)?.title;
+    const { text, filename, mime, warnings } = WARDLEY_OWM_EXPORT.run(elements, {
+        name: wardleySafeFilename(title),
+    });
+    // The charset is the browser's business, not the format's: `mime` is what an
+    // `.owm` IS, and this is how a blob is told to carry it.
+    downloadBlob(new Blob([text], { type: `${mime};charset=utf-8` }), filename);
+    // A warning is never an error: the file downloaded, and it is valid; what it
+    // could not say is what this names. A board with two maps on it, a component
+    // with no name, an evolution arrow that also climbs the value chain — each is
+    // a sentence the format has no way to write down, and the person who clicked
+    // Export is the one entitled to hear about it.
+    if (!warnings || warnings.length === 0)
+        return;
+    std.getOptional(NotificationProvider)?.notify({
+        title: translateKey(std, EXPORT_WARNINGS_KEY, EXPORT_WARNINGS_FALLBACK),
+        message: warnings.join('\n'),
+        accent: 'warning',
+        duration: 8000,
+    });
+}
+/**
+ * Read an `.owm` the user picks, draw it, and say what it cost.
+ *
+ * The whole of the import glue, and it is one line: the generic pipeline picks
+ * the file from the format's own declaration, runs the capability, mints the
+ * surface ids and repairs the link endpoints that named the file's names,
+ * brings the map into view and reports. Nothing in it is about Wardley except
+ * the capability handed to it.
+ */
+export async function importOwmFile(std) {
+    await runInterchangeImportFile(std, WARDLEY_OWM_IMPORT);
+}

package/dist/audit-criteria.d.ts

@@ -0,0 +1,31 @@
+import type { AuditCriterion } from '@formicoidea/labre-core/shared/services';
+/**
+ * The three Wardley audit criteria, A1–A3, as DATA (PF14.1).
+ *
+ * ## Why these three are criteria and not rules
+ *
+ * A validation rule is decided by geometry: an element is inside a frame or it
+ * is not, an arrow runs with an axis or against it. The engine can settle it in
+ * microseconds and be right every time, so it does — that is levels 1 and 2.
+ *
+ * These three cannot be settled that way, and no amount of engineering will
+ * change that. "Is this component positioned for the right reason" is a
+ * question about the author's argument; "does this map do its job" is a question
+ * about a conversation. They are the questions a Wardley coach asks in a review,
+ * and they are exactly what an assistant with the map's facts in hand can have
+ * an opinion about — an OPINION, hence `audit` severity, hence invisible on the
+ * canvas and never a wall.
+ *
+ * They are versioned like a rule and shipped like one, because the day a
+ * criterion's wording changes is a day the answers before and after are no
+ * longer comparable, and a host pinning behaviour needs to be able to say so.
+ *
+ * ## The prompts
+ *
+ * The prompt is the criterion, in words, addressed to the assistant and never
+ * rendered — see {@link AuditCriterion.prompt}. They are written as review
+ * instructions: what to look at, and what would make the map fail. They name no
+ * model, no vendor and no output format: the assistant owns how it answers, the
+ * library owns what is asked.
+ */
+export declare const WARDLEY_AUDIT_CRITERIA: readonly AuditCriterion[];

package/dist/audit-criteria.js

@@ -0,0 +1,90 @@
+/**
+ * The three Wardley audit criteria, A1–A3, as DATA (PF14.1).
+ *
+ * ## Why these three are criteria and not rules
+ *
+ * A validation rule is decided by geometry: an element is inside a frame or it
+ * is not, an arrow runs with an axis or against it. The engine can settle it in
+ * microseconds and be right every time, so it does — that is levels 1 and 2.
+ *
+ * These three cannot be settled that way, and no amount of engineering will
+ * change that. "Is this component positioned for the right reason" is a
+ * question about the author's argument; "does this map do its job" is a question
+ * about a conversation. They are the questions a Wardley coach asks in a review,
+ * and they are exactly what an assistant with the map's facts in hand can have
+ * an opinion about — an OPINION, hence `audit` severity, hence invisible on the
+ * canvas and never a wall.
+ *
+ * They are versioned like a rule and shipped like one, because the day a
+ * criterion's wording changes is a day the answers before and after are no
+ * longer comparable, and a host pinning behaviour needs to be able to say so.
+ *
+ * ## The prompts
+ *
+ * The prompt is the criterion, in words, addressed to the assistant and never
+ * rendered — see {@link AuditCriterion.prompt}. They are written as review
+ * instructions: what to look at, and what would make the map fail. They name no
+ * model, no vendor and no output format: the assistant owns how it answers, the
+ * library owns what is asked.
+ */
+export const WARDLEY_AUDIT_CRITERIA = [
+    {
+        id: 'wardley.A1',
+        framework: 'wardley',
+        labelKey: 'com.labre.wardley.audit.A1',
+        fallback: 'Positioning is justified',
+        version: 1,
+        prompt: [
+            'Assess whether each component is placed on the evolution axis for the',
+            'right reason. Evolution measures how CONTEXTUALLY UBIQUITOUS and',
+            'well-understood a component is to the users of THIS value chain — not',
+            'how modern, sophisticated or technically mature the technology behind',
+            'it is. A component built on cutting-edge technology can be a commodity',
+            'to its users; a component built on decades-old technology can still be',
+            'in genesis for this organisation. Flag components whose position looks',
+            'argued from technical maturity, vendor age, or how recently the team',
+            'adopted them, rather than from how their users perceive and consume',
+            'them. Use the zone each component sits in, the roles it carries and the',
+            'components it depends on. Say which component, in which zone, and what',
+            'about its position does not follow from the value chain around it.',
+        ].join(' '),
+    },
+    {
+        id: 'wardley.A2',
+        framework: 'wardley',
+        labelKey: 'com.labre.wardley.audit.A2',
+        fallback: 'The value chain is legible',
+        version: 1,
+        prompt: [
+            'Assess whether the value chain can actually be read. The map exists to',
+            'be discussed, agreed on and decided from, by people who did not draw',
+            'it. Follow the dependency edges from the anchor (the user and their',
+            'need) down through the chain: does every component have a reason to be',
+            'there that the chain itself states? Look for anchors that are missing or',
+            'that name a system rather than a user need, components that hang off no',
+            'chain, chains that fork into detail nobody would decide from, and',
+            'dependencies whose direction says the opposite of what the layout',
+            'implies. Say what a reader would fail to understand, and where.',
+        ].join(' '),
+    },
+    {
+        id: 'wardley.A3',
+        framework: 'wardley',
+        labelKey: 'com.labre.wardley.audit.A3',
+        fallback: 'The model applies here',
+        version: 1,
+        prompt: [
+            'Assess whether Wardley mapping is the right instrument for what this map',
+            'describes. The model assumes a COMPETITIVE landscape: evolution is',
+            'driven by supply and demand competition, and the strategic play is',
+            'against other actors who could serve the same need. It says little about',
+            'a domain with no competitive pressure — an internal process nobody else',
+            'could supply, a regulatory obligation with a single possible',
+            'implementation, an organisational chart. Judge from the anchor, the user',
+            'need it names, and the nature of the components in the chain. If the',
+            'subject is not a competitive landscape, say so plainly and say which',
+            'other instrument would fit — that is more useful than three careful',
+            'observations about a map that should not exist.',
+        ].join(' '),
+    },
+];

package/dist/background.d.ts

@@ -0,0 +1,14 @@
+import type { FrameworkBackgroundDef } from '@formicoidea/labre-core/blocks/surface';
+export declare const WARDLEY_BACKGROUND: FrameworkBackgroundDef;
+/**
+ * The props the in-place label editor is allowed to write.
+ *
+ * A closed list, not `string`: the hit test reports whatever `prop` a
+ * declaration names, and since #73 an element preserves keys it does not
+ * declare — so a typo in the declaration would happily persist a junk key onto
+ * every map it was double-clicked on. This is the gate between "the
+ * declaration says so" and "the document gets it".
+ */
+export declare const WARDLEY_LABEL_PROPS: readonly ["xAxisTitle", "yAxisTitle", "evolutionStart", "evolutionEnd", "visibilityHigh", "visibilityLow", "phase0", "phase1", "phase2", "phase3"];
+export type WardleyLabelProp = (typeof WARDLEY_LABEL_PROPS)[number];
+export declare function isWardleyLabelProp(prop: string): prop is WardleyLabelProp;