@formicoidea/labre-framework-wardley 0.50.0 → 0.51.0

package/dist/actions.js

@@ -9,7 +9,8 @@ import { Bound } from '@formicoidea/labre-core/global/gfx';
 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 { wardleySafeFilename } from './export.js';
+import { wardleyBoardFrom } from './export-board.js';
 import { WARDLEY_OWM_EXPORT, WARDLEY_OWM_IMPORT } from './interchange.js';
 import { INERTIA_SIZE, PORTER_DEFAULT_LETTER } from './node/consts.js';
 import { wardleyAreaBox, wardleyAreaProps, wardleyCanonicalBox, WARDLEY_EDGE_STYLE, wardleyHandleBox, wardleyHandleProps, wardleyInertiaProps, wardleyLabelBoxFor, wardleyLabelProps, wardleyMarketDotBoxes, wardleyMarketDotProps, wardleyMarketLinkPairs, wardleyMarketLinkProps, WARDLEY_NODE_LABEL, wardleyNodeLabelKey, wardleyNodeProps, wardleyPorterArrowProps, wardleyPorterArrows, wardleyPorterLetterProps, } from './presets.js';

package/dist/consts.js

@@ -1,4 +1,4 @@
-import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
+import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/headless';
 /**
  * Visual constants for the Wardley map background.
  *

package/dist/export-board.d.ts

@@ -0,0 +1,10 @@
+import type { GfxPrimitiveElementModel } from '@formicoidea/labre-core/std/gfx';
+import type { WardleyExportBoard } from './export.js';
+/**
+ * The half of the OWM export that needs LIVE element models: picking the
+ * artefacts out of a surface by `instanceof`. Kept out of `export.ts` so the
+ * serializer and the OWM vocabulary the readers share stay editor-free — the
+ * headless `./interchange` entry imports `export.ts` and must not load an
+ * element class (ADR 0012, P3 as amended 2026-10-14).
+ */
+export declare function wardleyBoardFrom(elements: readonly GfxPrimitiveElementModel[]): WardleyExportBoard;

package/dist/export-board.js

@@ -0,0 +1,31 @@
+import { ConnectorElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, } from '@formicoidea/labre-core/model';
+import { WARDLEY_ROLE } from './roles.js';
+/**
+ * The half of the OWM export that needs LIVE element models: picking the
+ * artefacts out of a surface by `instanceof`. Kept out of `export.ts` so the
+ * serializer and the OWM vocabulary the readers share stay editor-free — the
+ * headless `./interchange` entry imports `export.ts` and must not load an
+ * element class (ADR 0012, P3 as amended 2026-10-14).
+ */
+export function wardleyBoardFrom(elements) {
+    const maps = [];
+    const nodes = [];
+    const labels = [];
+    const notes = [];
+    const connectors = [];
+    for (const element of elements) {
+        if (element instanceof WardleyBackgroundElementModel)
+            maps.push(element);
+        else if (element instanceof WardleyNodeElementModel)
+            nodes.push(element);
+        else if (element instanceof ConnectorElementModel)
+            connectors.push(element);
+        else if (element instanceof TextElementModel) {
+            if (element.role === WARDLEY_ROLE.label)
+                labels.push(element);
+            else if (element.role === undefined)
+                notes.push(element);
+        }
+    }
+    return { maps, nodes, labels, notes, connectors };
+}

package/dist/export.d.ts

@@ -1,5 +1,4 @@
-import { ConnectorElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel } from '@formicoidea/labre-core/model';
-import type { GfxPrimitiveElementModel } from '@formicoidea/labre-core/std/gfx';
+import type { ConnectorElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel } from '@formicoidea/labre-core/model';
 /**
  * A Wardley map as an OnlineWardleyMaps (OWM) DSL document — models in, text
  * out (`docs/adr/0012`, P3).
@@ -170,7 +169,6 @@ export interface WardleyExportBoard {
     notes: TextElementModel[];
     connectors: ConnectorElementModel[];
 }
-export declare function wardleyBoardFrom(elements: readonly GfxPrimitiveElementModel[]): WardleyExportBoard;
 /**
  * A name a file system will accept, minus the extension: the shared
  * `safeFilename` with Wardley's fallback — `map`, because that is what an OWM

package/dist/export.js

@@ -1,6 +1,5 @@
-import { backgroundPlot } from '@formicoidea/labre-core/blocks/surface';
-import { ConnectorElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, } from '@formicoidea/labre-core/model';
-import { safeFilename } from '@formicoidea/labre-core/shared/utils';
+import { backgroundPlot } from '@formicoidea/labre-core/interchange';
+import { safeFilename } from '@formicoidea/labre-core/shared/headless';
 import { WARDLEY_BACKGROUND } from './background.js';
 import { LABEL_FONT_SIZE, LABEL_GAP } from './node/consts.js';
 import { WARDLEY_ROLE } from './roles.js';
@@ -243,28 +242,6 @@ export function owmCoordsOf(plot, x, y) {
         evolution: (x - plot.x0) / plot.width,
     };
 }
-export function wardleyBoardFrom(elements) {
-    const maps = [];
-    const nodes = [];
-    const labels = [];
-    const notes = [];
-    const connectors = [];
-    for (const element of elements) {
-        if (element instanceof WardleyBackgroundElementModel)
-            maps.push(element);
-        else if (element instanceof WardleyNodeElementModel)
-            nodes.push(element);
-        else if (element instanceof ConnectorElementModel)
-            connectors.push(element);
-        else if (element instanceof TextElementModel) {
-            if (element.role === WARDLEY_ROLE.label)
-                labels.push(element);
-            else if (element.role === undefined)
-                notes.push(element);
-        }
-    }
-    return { maps, nodes, labels, notes, connectors };
-}
 /**
  * A name a file system will accept, minus the extension: the shared
  * `safeFilename` with Wardley's fallback — `map`, because that is what an OWM

package/dist/import.js

@@ -1,4 +1,4 @@
-import { ConnectorMode, FontFamily, FontWeight, PointStyle, ShapeStyle, StrokeStyle, TextAlign, } from '@formicoidea/labre-core/model';
+import { ConnectorMode, FontFamily, FontWeight, PointStyle, ShapeStyle, StrokeStyle, TextAlign, } from '@formicoidea/labre-core/model/headless';
 import { WARDLEY_BACKGROUND } from './background.js';
 import { OWM_DEFAULT_MAP_HEIGHT, OWM_DEFAULT_MAP_WIDTH, OWM_LABEL_HEIGHT, OWM_LABEL_WIDTH, OWM_SCOPE, OWM_TAIL_ATTR, OWM_KEYWORDS, OWM_TITLE_ATTR, owmDefaultPlot, owmPointOf, WARDLEY_OWM_FORMAT_ID, } from './export.js';
 import { HANDLE_SIZE, INERTIA_SIZE, LABEL_GAP, LABEL_FONT_SIZE, LINK_GREY, LINK_STROKE_WIDTH, MARKET_DOT_RING, MARKET_DOT_SIZE, MARKET_DOT_STROKE_WIDTH, MARKET_LINK_COLOR, MARKET_LINK_WIDTH, MARKET_SIZE, ECOSYSTEM_SIZE, NODE_FILL, NODE_SIZE, NODE_STROKE, NODE_STROKE_WIDTH, PIPELINE_FILL, PIPELINE_HEIGHT, WARDLEY_RED, } from './node/consts.js';

package/dist/index.d.ts

@@ -25,7 +25,8 @@ export { WARDLEY_BACKGROUND } from './background.js';
  * 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 { exportWardleyOwm, exportWardleyOwmWithWarnings, OWM_SCOPE, type OwmPlot, owmCoordsOf, owmPlotOf, owmPointOf, WARDLEY_OWM_FORMAT_ID, type WardleyExportBoard, wardleySafeFilename, } from './export.js';
+export { wardleyBoardFrom } from './export-board.js';
 export { importWardleyOwm } from './import.js';
 export { importWardleySvg } from './svg-import.js';
 export { wardleyBoardOf, wardleyExportElementsOf, wardleyMapsSelected, } from './actions.js';

package/dist/index.js

@@ -37,7 +37,8 @@ export { WARDLEY_BACKGROUND } from './background.js';
  * 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 { exportWardleyOwm, exportWardleyOwmWithWarnings, OWM_SCOPE, owmCoordsOf, owmPlotOf, owmPointOf, WARDLEY_OWM_FORMAT_ID, wardleySafeFilename, } from './export.js';
+export { wardleyBoardFrom } from './export-board.js';
 export { importWardleyOwm } from './import.js';
 // The SVG reader that recognises a map (ADR 0032), pure for the same reason:
 // labre-mcp calls the very function the command does.

package/dist/interchange-headless.d.ts

@@ -0,0 +1,64 @@
+import type { InterchangeFormat, InterchangeImportCapability } from '@formicoidea/labre-core/interchange';
+/**
+ * `@labre/affine-gfx-wardley/interchange` — Wardley's formats and its two
+ * READERS, with no editor behind them (ADR 0012, P3 as amended 2026-10-14).
+ *
+ * What a server needs to read an `.owm` or an `.svg` as a map: the format
+ * declarations and the import capabilities, whose `run` is a pure function of
+ * text. The OWM EXPORT capability is not here: it picks the artefacts out of
+ * live element models (`wardleyBoardFrom`, by `instanceof`), which is the
+ * editor graph this entry exists to leave out. It stays in `interchange.ts`,
+ * which re-exports everything below. The serializer itself
+ * (`exportWardleyOwm`) is editor-free and stays on the package index.
+ *
+ * Held by `interchange-headless.unit.spec.ts` in `packages/affine/all`.
+ */
+/**
+ * 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: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 the Wardley map it is a picture of, and
+ * whatever else it holds as a sketch (ADR 0032).
+ *
+ * **The heuristics statement this capability owes (ADR 0012, open question 2)
+ * is the module documentation of `./svg-import.ts`**, beside the parser that
+ * makes the guesses: ADR 0032 superseded, for Wardley only, the rule that a
+ * visual capability guesses geometry and nothing else. A picture from a
+ * producer the reader recognises arrives as native Wardley elements; the rest
+ * of it — and the whole of a picture nobody recognises — arrives as the same
+ * level-1 sketch BPMN's reader draws (`parseSvgSketch`, which BPMN still
+ * declares). Still the visual tier: no payload, no round-trip, and
+ * {@link WARDLEY_OWM_IMPORT} beside it stays the reference Wardley import.
+ */
+export declare const WARDLEY_SVG_IMPORT: InterchangeImportCapability;

package/dist/interchange-headless.js

@@ -0,0 +1,91 @@
+import { interchangeCapabilityId, SVG_SKETCH_EXTENSION, SVG_SKETCH_FORMAT_ID, SVG_SKETCH_MIME, } from '@formicoidea/labre-core/interchange';
+import { WARDLEY_OWM_FORMAT_ID } from './export.js';
+import { importWardleyOwm } from './import.js';
+import { importWardleySvg } from './svg-import.js';
+/**
+ * `@labre/affine-gfx-wardley/interchange` — Wardley's formats and its two
+ * READERS, with no editor behind them (ADR 0012, P3 as amended 2026-10-14).
+ *
+ * What a server needs to read an `.owm` or an `.svg` as a map: the format
+ * declarations and the import capabilities, whose `run` is a pure function of
+ * text. The OWM EXPORT capability is not here: it picks the artefacts out of
+ * live element models (`wardleyBoardFrom`, by `instanceof`), which is the
+ * editor graph this entry exists to leave out. It stays in `interchange.ts`,
+ * which re-exports everything below. The serializer itself
+ * (`exportWardleyOwm`) is editor-free and stays on the package index.
+ *
+ * Held by `interchange-headless.unit.spec.ts` in `packages/affine/all`.
+ */
+/* ── 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,
+};
+/** `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 the Wardley map it is a picture of, and
+ * whatever else it holds as a sketch (ADR 0032).
+ *
+ * **The heuristics statement this capability owes (ADR 0012, open question 2)
+ * is the module documentation of `./svg-import.ts`**, beside the parser that
+ * makes the guesses: ADR 0032 superseded, for Wardley only, the rule that a
+ * visual capability guesses geometry and nothing else. A picture from a
+ * producer the reader recognises arrives as native Wardley elements; the rest
+ * of it — and the whole of a picture nobody recognises — arrives as the same
+ * level-1 sketch BPMN's reader draws (`parseSvgSketch`, which BPMN still
+ * declares). Still the visual tier: no payload, no round-trip, and
+ * {@link WARDLEY_OWM_IMPORT} beside it stays the reference Wardley import.
+ */
+export const WARDLEY_SVG_IMPORT = {
+    id: interchangeCapabilityId('wardley', WARDLEY_SVG_FORMAT.id, 'import'),
+    framework: 'wardley',
+    format: WARDLEY_SVG_FORMAT,
+    direction: 'import',
+    run: importWardleySvg,
+};

package/dist/interchange.d.ts

@@ -1,75 +1,6 @@
-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
- * route for a picture, which recognises the map when it knows who drew it and
- * sketches the rest (ADR 0032).
- *
- * The file is laid out as one section per FORMAT, each holding its format
- * object then its capabilities, with {@link WARDLEY_INTERCHANGE} at the bottom
- * 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;
+import type { InterchangeCapability, InterchangeExportCapability } from '@formicoidea/labre-core/blocks/surface';
+export { WARDLEY_OWM_EXTENSION, WARDLEY_OWM_FORMAT, WARDLEY_OWM_IMPORT, WARDLEY_OWM_MIME, WARDLEY_SVG_FORMAT, WARDLEY_SVG_IMPORT, } from './interchange-headless.js';
 /** `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 the Wardley map it is a picture of, and
- * whatever else it holds as a sketch (ADR 0032).
- *
- * **The heuristics statement this capability owes (ADR 0012, open question 2)
- * is the module documentation of `./svg-import.ts`**, beside the parser that
- * makes the guesses: ADR 0032 superseded, for Wardley only, the rule that a
- * visual capability guesses geometry and nothing else. A picture from a
- * producer the reader recognises arrives as native Wardley elements; the rest
- * of it — and the whole of a picture nobody recognises — arrives as the same
- * level-1 sketch BPMN's reader draws (`parseSvgSketch`, which BPMN still
- * declares). Still the visual tier: no payload, no round-trip, and
- * {@link WARDLEY_OWM_IMPORT} beside it stays the reference Wardley import.
- */
-export declare const WARDLEY_SVG_IMPORT: InterchangeImportCapability;
 /** Everything Wardley registers, in one list the view extension hands over. */
 export declare const WARDLEY_INTERCHANGE: readonly InterchangeCapability[];

package/dist/interchange.js

@@ -1,7 +1,8 @@
-import { interchangeCapabilityId, SVG_SKETCH_EXTENSION, SVG_SKETCH_FORMAT_ID, SVG_SKETCH_MIME, } from '@formicoidea/labre-core/blocks/surface';
-import { exportWardleyOwmWithWarnings, WARDLEY_OWM_FORMAT_ID, wardleyBoardFrom, wardleySafeFilename, } from './export.js';
-import { importWardleyOwm } from './import.js';
-import { importWardleySvg } from './svg-import.js';
+import { interchangeCapabilityId } from '@formicoidea/labre-core/blocks/surface';
+import { exportWardleyOwmWithWarnings, wardleySafeFilename } from './export.js';
+import { wardleyBoardFrom } from './export-board.js';
+import { WARDLEY_OWM_EXTENSION, WARDLEY_OWM_FORMAT, WARDLEY_OWM_IMPORT, WARDLEY_OWM_MIME, WARDLEY_SVG_IMPORT, } from './interchange-headless.js';
+export { WARDLEY_OWM_EXTENSION, WARDLEY_OWM_FORMAT, WARDLEY_OWM_IMPORT, WARDLEY_OWM_MIME, WARDLEY_SVG_FORMAT, WARDLEY_SVG_IMPORT, } from './interchange-headless.js';
 /**
  * Wardley's entries in the interchange registry (`docs/adr/0012`, P1).
  *
@@ -15,40 +16,16 @@ import { importWardleySvg } from './svg-import.js';
  * route for a picture, which recognises the map when it knows who drew it and
  * sketches the rest (ADR 0032).
  *
- * The file is laid out as one section per FORMAT, each holding its format
- * object then its capabilities, with {@link WARDLEY_INTERCHANGE} at the bottom
- * collecting them. A format is added by adding a section, not by editing one.
+ * The formats and the two import capabilities live in
+ * `interchange-headless.ts` (the package's editor-free `./interchange` entry)
+ * and are re-exported above; this file adds the export capability, which
+ * reads live element models, and {@link WARDLEY_INTERCHANGE} collecting them.
  *
  * 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.
  *
@@ -78,53 +55,6 @@ export const WARDLEY_OWM_EXPORT = {
     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 the Wardley map it is a picture of, and
- * whatever else it holds as a sketch (ADR 0032).
- *
- * **The heuristics statement this capability owes (ADR 0012, open question 2)
- * is the module documentation of `./svg-import.ts`**, beside the parser that
- * makes the guesses: ADR 0032 superseded, for Wardley only, the rule that a
- * visual capability guesses geometry and nothing else. A picture from a
- * producer the reader recognises arrives as native Wardley elements; the rest
- * of it — and the whole of a picture nobody recognises — arrives as the same
- * level-1 sketch BPMN's reader draws (`parseSvgSketch`, which BPMN still
- * declares). Still the visual tier: no payload, no round-trip, and
- * {@link WARDLEY_OWM_IMPORT} beside it stays the reference Wardley import.
- */
-export const WARDLEY_SVG_IMPORT = {
-    id: interchangeCapabilityId('wardley', WARDLEY_SVG_FORMAT.id, 'import'),
-    framework: 'wardley',
-    format: WARDLEY_SVG_FORMAT,
-    direction: 'import',
-    run: importWardleySvg,
-};
 /* ── The list the view extension registers ────────────────────────────── */
 /** Everything Wardley registers, in one list the view extension hands over. */
 export const WARDLEY_INTERCHANGE = [

package/dist/node/consts.js

@@ -1,4 +1,4 @@
-import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
+import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/headless';
 /**
  * Visual constants for Wardley nodes (component + anchor) and the connector /
  * inertia presets created from the Wardley menu.

package/dist/presets.d.ts

@@ -1,4 +1,5 @@
-import { FontWeight, PointStyle, StrokeStyle, type WardleyNodeKind } from '@formicoidea/labre-core/model';
+import { FontWeight, PointStyle, StrokeStyle } from '@formicoidea/labre-core/model/headless';
+import 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.

package/dist/presets.js

@@ -1,4 +1,4 @@
-import { ConnectorMode, DEFAULT_POLYGON_VERTICES, FontFamily, FontWeight, PointStyle, ShapeStyle, StrokeStyle, TextFitMode, } from '@formicoidea/labre-core/model';
+import { ConnectorMode, DEFAULT_POLYGON_VERTICES, FontFamily, FontWeight, PointStyle, ShapeStyle, StrokeStyle, TextFitMode, } from '@formicoidea/labre-core/model/headless';
 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, 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';

package/dist/svg-import.js

@@ -1,6 +1,6 @@
-import { sanitizeSvg, sketchSvgTree, SVG_SKETCH_EMPTY, SvgSketchNotebook, } from '@formicoidea/labre-core/blocks/surface';
-import { FontFamily, TextAlign } from '@formicoidea/labre-core/model';
-import { fillPlaceholders } from '@formicoidea/labre-core/shared/services';
+import { sanitizeSvg, sketchSvgTree, SVG_SKETCH_EMPTY, SvgSketchNotebook, } from '@formicoidea/labre-core/interchange';
+import { FontFamily, TextAlign } from '@formicoidea/labre-core/model/headless';
+import { fillPlaceholders } from '@formicoidea/labre-core/shared/headless';
 import { OWM_DEFAULT_MAP_WIDTH, owmCoordsOf, owmDefaultPlot, WARDLEY_OWM_FORMAT_ID, } from './export.js';
 import { layoutWardleyStatements } from './import.js';
 import { NODE_STROKE } from './node/consts.js';
@@ -143,13 +143,13 @@ function extentPlot(drawn) {
     ];
     if (xs.length === 0)
         return { x0: 0, y0: 0, width: 1, height: 1 };
-    const x0 = Math.min(...xs);
-    const y0 = Math.min(...ys);
+    const x0 = xs.reduce((a, b) => Math.min(a, b), Infinity);
+    const y0 = ys.reduce((a, b) => Math.min(a, b), Infinity);
     return {
         x0,
         y0,
-        width: Math.max(Math.max(...xs) - x0, 1),
-        height: Math.max(Math.max(...ys) - y0, 1),
+        width: Math.max(xs.reduce((a, b) => Math.max(a, b), -Infinity) - x0, 1),
+        height: Math.max(ys.reduce((a, b) => Math.max(a, b), -Infinity) - y0, 1),
     };
 }
 /**

package/dist/svg-read.d.ts

@@ -1,3 +1,4 @@
+import type { XmlElement } from '@formicoidea/labre-core/interchange';
 import type { InterchangeNote } from '@formicoidea/labre-core/blocks/surface';
 import type { OwmPlot } from './export.js';
 import type { WardleyNodeKeyword } from './import.js';
@@ -63,7 +64,7 @@ export interface DrawnWardleyMap {
         y: number;
     }[];
     /** Every node the recogniser turned into the above; the sketch skips them. */
-    consumed: Set<Element>;
+    consumed: Set<XmlElement>;
     /** What the recogniser has to say about the file (dangling ends, bad numbers). */
     remarks: InterchangeNote[];
 }
@@ -77,7 +78,7 @@ export interface DrawnWardleyMap {
  */
 export declare function startDrawnMap(head: Pick<DrawnWardleyMap, 'producer'> & Partial<Pick<DrawnWardleyMap, 'plot'>>): {
     drawn: DrawnWardleyMap;
-    consume: (element: Element | undefined) => void;
+    consume: (element: XmlElement | undefined) => void;
 };
 /**
  * Every element carrying an `id`, first wins — the index a producer's markers
@@ -86,13 +87,13 @@ export declare function startDrawnMap(head: Pick<DrawnWardleyMap, 'producer'> &
  * A `Map`, never an object: a hostile file's `__proto__` or `constructor` is a
  * key like any other here, and can never reach a prototype (ADR 0032 §7).
  */
-export declare function idIndex(root: Element): Map<string, Element>;
+export declare function idIndex(root: XmlElement): Map<string, XmlElement>;
 /**
  * A text's words, collapsed the way the sketch collapses a label — one span
  * per line joined by a space, so a name a producer wrapped over two `<tspan>`s
  * reads as the name and not as two words glued together.
  */
-export declare function textOf(element: Element | undefined): string;
+export declare function textOf(element: XmlElement | undefined): string;
 /**
  * Where an element's own user-space origin lands, or `undefined` when the
  * file does not give it as numbers.
@@ -103,6 +104,6 @@ export declare function textOf(element: Element | undefined): string;
  * whose own `transform` is anything but a translate of finite numbers is
  * refused here, and the caller sends it to the sketch with a remark.
  */
-export declare function originOf(element: Element): [number, number] | undefined;
+export declare function originOf(element: XmlElement): [number, number] | undefined;
 /** A finite number off an attribute, or `undefined`. */
-export declare function finiteAttr(element: Element, name: string): number | undefined;
+export declare function finiteAttr(element: XmlElement, name: string): number | undefined;

package/dist/svg-read.js

@@ -1,4 +1,4 @@
-import { svgFrameOf } from '@formicoidea/labre-core/blocks/surface';
+import { svgFrameOf } from '@formicoidea/labre-core/interchange';
 /**
  * A recogniser's answer before it has read anything, and the one way it marks
  * an element as turned into a native one (so the sketch skips it).

package/dist/svg-recognise-labre.d.ts

@@ -1,2 +1,3 @@
+import type { XmlElement } from '@formicoidea/labre-core/interchange';
 import { type DrawnWardleyMap } from './svg-read.js';
-export declare function recogniseLabreExport(root: Element): DrawnWardleyMap | undefined;
+export declare function recogniseLabreExport(root: XmlElement): DrawnWardleyMap | undefined;

package/dist/svg-recognise-labre.js

@@ -1,4 +1,4 @@
-import { BOARD_SVG_MARKER_VERSION } from '@formicoidea/labre-core/blocks/surface';
+import { BOARD_SVG_MARKER_VERSION } from '@formicoidea/labre-core/interchange';
 import { matchLabels, owmPlotOf } from './export.js';
 import { WARDLEY_ROLE, WARDLEY_ROLES } from './roles.js';
 import { startDrawnMap } from './svg-read.js';

package/dist/svg-recognise-owm.d.ts

@@ -1,2 +1,3 @@
+import type { XmlElement } from '@formicoidea/labre-core/interchange';
 import { type DrawnWardleyMap } from './svg-read.js';
-export declare function recogniseOnlineWardleyMaps(root: Element): DrawnWardleyMap | undefined;
+export declare function recogniseOnlineWardleyMaps(root: XmlElement): DrawnWardleyMap | undefined;

package/dist/svg-recognise-owm.js

@@ -1,4 +1,4 @@
-import { svgFrameOf } from '@formicoidea/labre-core/blocks/surface';
+import { svgFrameOf } from '@formicoidea/labre-core/interchange';
 import { finiteAttr, idIndex, originOf, startDrawnMap, textOf, } from './svg-read.js';
 import { WARDLEY_SVG_IMPORT_REMARKS } from './svg-remarks.js';
 /**

package/dist/svg-recognise-renderer.d.ts

@@ -1,2 +1,3 @@
+import type { XmlElement } from '@formicoidea/labre-core/interchange';
 import { type DrawnWardleyMap } from './svg-read.js';
-export declare function recogniseWardleyMapRenderer(root: Element): DrawnWardleyMap | undefined;
+export declare function recogniseWardleyMapRenderer(root: XmlElement): DrawnWardleyMap | undefined;

package/dist/svg-recognise-renderer.js

@@ -1,4 +1,4 @@
-import { svgFrameOf } from '@formicoidea/labre-core/blocks/surface';
+import { svgFrameOf } from '@formicoidea/labre-core/interchange';
 import { finiteAttr, startDrawnMap, textOf, } from './svg-read.js';
 import { WARDLEY_SVG_IMPORT_REMARKS } from './svg-remarks.js';
 /**

package/dist/svg-recognise-shapes.d.ts

@@ -1,2 +1,3 @@
+import type { XmlElement } from '@formicoidea/labre-core/interchange';
 import { type DrawnWardleyMap } from './svg-read.js';
-export declare function recogniseByShape(root: Element): DrawnWardleyMap | undefined;
+export declare function recogniseByShape(root: XmlElement): DrawnWardleyMap | undefined;

package/dist/svg-recognise-shapes.js

@@ -1,4 +1,4 @@
-import { svgFrameOf } from '@formicoidea/labre-core/blocks/surface';
+import { svgFrameOf } from '@formicoidea/labre-core/interchange';
 import { finiteAttr, startDrawnMap, textOf, } from './svg-read.js';
 /**
  * An SVG no producer marked, read by shape (ADR 0032 §4.4, §5) — the last
@@ -150,12 +150,30 @@ export function recogniseByShape(root) {
             },
         ];
     });
+    // The first `<tspan>` under each `<text>`, found in one pass: a
+    // `querySelector` per text rebuilt its subtree each time, O(texts × depth) on
+    // nested texts (counter-review of 49aa247ce). Spans come in document order,
+    // so the first to reach an ancestor is its first; an ancestor already
+    // reached has had every ancestor of its own reached too.
+    const firstSpan = new Map();
+    const reached = new Set();
+    for (const span of root.querySelectorAll('tspan')) {
+        for (let at = span.parentElement; at && !reached.has(at); at = at.parentElement) {
+            reached.add(at);
+            if (at.localName === 'text')
+                firstSpan.set(at, span);
+        }
+    }
     const texts = Array.from(root.querySelectorAll('text')).flatMap(element => {
-        const span = element.querySelector('tspan');
+        const span = firstSpan.get(element);
         const x = finiteAttr(element, 'x') ?? (span ? finiteAttr(span, 'x') : undefined);
         const y = finiteAttr(element, 'y') ?? (span ? finiteAttr(span, 'y') : undefined);
+        if (x === undefined || y === undefined)
+            return [];
+        // After the position: a text's content is its whole subtree, and a text
+        // with no position is never read.
         const name = textOf(element);
-        if (x === undefined || y === undefined || name.length === 0)
+        if (name.length === 0)
             return [];
         const frame = svgFrameOf(element);
         return [
@@ -175,8 +193,10 @@ export function recogniseByShape(root) {
     if (xs.length === 0)
         return undefined;
     const extent = {
-        w: Math.max(...xs) - Math.min(...xs),
-        h: Math.max(...ys) - Math.min(...ys),
+        w: xs.reduce((a, b) => Math.max(a, b), -Infinity) -
+            xs.reduce((a, b) => Math.min(a, b), Infinity),
+        h: ys.reduce((a, b) => Math.max(a, b), -Infinity) -
+            ys.reduce((a, b) => Math.min(a, b), Infinity),
     };
     const found = axesOf(segments, extent);
     if (!found)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-framework-wardley",
   "description": "Labre wardley framework for @formicoidea/labre-core.",
-  "version": "0.50.0",
+  "version": "0.51.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -25,13 +25,17 @@
     "./commands-manifest": {
       "types": "./dist/commands-manifest.d.ts",
       "import": "./dist/commands-manifest.js"
+    },
+    "./interchange": {
+      "types": "./dist/interchange-headless.d.ts",
+      "import": "./dist/interchange-headless.js"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.50.0",
+    "@formicoidea/labre-core": "0.51.0",
     "lit": "^3.2.0"
   }
 }