@formicoidea/labre-framework-bpmn 0.50.0 → 0.52.0

package/dist/consts.d.ts

@@ -1,5 +1,5 @@
 import type { BpmnNodeKind } from '@formicoidea/labre-core/model';
-import { PointStyle, StrokeStyle } from '@formicoidea/labre-core/model';
+import { PointStyle, StrokeStyle } from '@formicoidea/labre-core/model/headless';
 /**
  * Visual constants for the BPMN basics. Style "C" (hybrid): spec-accurate
  * shapes and line weights, with accent colour only on the event rings — the
@@ -240,7 +240,7 @@ export declare const POOL_LANE_NAME_FONT_SIZE = 13;
  * so this file stays the one place a reader looks for a pool's metrics, and so
  * the declaration keeps reading them from where it always did.
  */
-export { POOL_BAND_WIDTH, POOL_LANE_BAND_WIDTH } from '@formicoidea/labre-core/model';
+export { POOL_BAND_WIDTH, POOL_LANE_BAND_WIDTH, } from '@formicoidea/labre-core/model/headless';
 /**
  * How close to an internal lane boundary a pointer has to be, in MODEL units,
  * for the gesture to be a separator drag rather than a click on the pool.

package/dist/consts.js

@@ -1,5 +1,5 @@
-import { PointStyle, StrokeStyle } from '@formicoidea/labre-core/model';
-import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
+import { PointStyle, StrokeStyle } from '@formicoidea/labre-core/model/headless';
+import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/headless';
 /**
  * Visual constants for the BPMN basics. Style "C" (hybrid): spec-accurate
  * shapes and line weights, with accent colour only on the event rings — the
@@ -296,7 +296,7 @@ export const POOL_LANE_NAME_FONT_SIZE = 13;
  * so this file stays the one place a reader looks for a pool's metrics, and so
  * the declaration keeps reading them from where it always did.
  */
-export { POOL_BAND_WIDTH, POOL_LANE_BAND_WIDTH } from '@formicoidea/labre-core/model';
+export { POOL_BAND_WIDTH, POOL_LANE_BAND_WIDTH, } from '@formicoidea/labre-core/model/headless';
 /**
  * How close to an internal lane boundary a pointer has to be, in MODEL units,
  * for the gesture to be a separator drag rather than a click on the pool.

package/dist/export.js

@@ -1,4 +1,4 @@
-import { backgroundInstanceZones, backgroundPlot, } from '@formicoidea/labre-core/blocks/surface';
+import { backgroundInstanceZones, backgroundPlot, } from '@formicoidea/labre-core/interchange';
 import { BPMN_POOL_BACKGROUND } from './background.js';
 import { bpmnLaneOf, bpmnPoolOf } from './facts.js';
 import { BPMN_ROLE } from './roles.js';

package/dist/facts.js

@@ -1,4 +1,4 @@
-import { backgroundInstanceZones, backgroundPlot, containingFrame, } from '@formicoidea/labre-core/blocks/surface';
+import { backgroundInstanceZones, backgroundPlot, containingFrame, } from '@formicoidea/labre-core/interchange';
 import { BPMN_POOL_BACKGROUND } from './background.js';
 /**
  * Where a BPMN artefact SITS — the facts, answerable without a `BlockStdScope`.

package/dist/import.d.ts

@@ -1,4 +1,4 @@
-import { type InterchangeImportContext, type InterchangeImportResult } from '@formicoidea/labre-core/blocks/surface';
+import type { InterchangeImportContext, InterchangeImportResult } from '@formicoidea/labre-core/blocks/surface';
 import type { BpmnNodeKind } from '@formicoidea/labre-core/model';
 /**
  * The remarks whose wording is FIXED, as `[key, English]` pairs — one entry

package/dist/import.js

@@ -1,5 +1,5 @@
-import { InterchangeImportError, } from '@formicoidea/labre-core/blocks/surface';
-import { ConnectorMode, PointStyle, StrokeStyle } from '@formicoidea/labre-core/model';
+import { InterchangeImportError, readXmlElement, } from '@formicoidea/labre-core/interchange';
+import { ConnectorMode, PointStyle, StrokeStyle, } from '@formicoidea/labre-core/model/headless';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
 import { ASSOCIATION_STROKE, ASSOCIATION_WIDTH, bpmnLabelMode, MESSAGE_STROKE, MESSAGE_WIDTH, NODE_SIZE, POOL_BAND_WIDTH, POOL_REF_HEIGHT, POOL_REF_WIDTH, SEQUENCE_STROKE, SEQUENCE_WIDTH, } from './consts.js';
 import { BPMN_FORMAT_ID, BPMN_NS, BPMN_OWN_DECLARATIONS, BPMN_SCOPE, BPMN_XML_OF_KIND, escapeAttr, escapeText, } from './export.js';
@@ -191,15 +191,13 @@ export const BPMN_IMPORT_ERRORS = {
  *
  * ## Reading XML by hand, and why
  *
- * The tree is walked child by child rather than through
- * `getElementsByTagNameNS`, which happy-dom does not implement for a parsed XML
- * document: it answers an empty list for every namespaced query, so a unit
- * suite built on it would pass by asserting nothing. The same environment
- * decodes neither numeric character references nor `'` in an attribute
- * value, which is why the escaped-label round trip is pinned in chromium
- * (`integration-test/src/__tests__/edgeless/bpmn.spec.ts`) and not in the unit
- * spec. Both traps are `export.unit.spec.ts`'s findings, inherited rather than
- * rediscovered.
+ * The file is read by the platform's `readXml` and walked through its
+ * DOM-shaped view (`xml-element.ts` in the surface package), child by child,
+ * namespaces resolved. Not `DOMParser`: the P0 import spike measured this
+ * reader on a server, where it needed a DOM installed (jsdom) and grew
+ * quadratically with the file — 5.1 s of CPU at 2 000 tasks. Without a DOM it
+ * runs in a server function, in labre-mcp and in a unit test alike (ADR 0012,
+ * P3 as amended 2026-10-14), in time linear in the file.
  *
  * ## Failure is an exception, not a report
  *
@@ -293,11 +291,13 @@ export const BPMN_KIND_OF_XML = new Map(Object.entries(BPMN_XML_OF_KIND).map(([k
  * there is no such thing in BPMN, where every connecting object is one of
  * these three.
  */
-const EDGE_ROLE_OF_ELEMENT = {
+// No prototype: it is read by a name the file chose, and `<constructor>` is
+// one (security review, 2026-10-14).
+const EDGE_ROLE_OF_ELEMENT = Object.assign(Object.create(null), {
     sequenceFlow: BPMN_ROLE.sequenceFlow,
     messageFlow: BPMN_ROLE.messageFlow,
     association: BPMN_ROLE.association,
-};
+});
 /**
  * The colour extensions D5 quarantines (case 1), by namespace and by prefix.
  *
@@ -368,20 +368,14 @@ const NOT_A_BODY = new Set([
     'multiInstanceLoopCharacteristics',
     'standardLoopCharacteristics',
 ]);
-/* ── Reading the DOM by hand ──────────────────────────────────────────── */
-/** The `Node.nodeType`s a fragment can be made of, spelled rather than numbered. */
-const ELEMENT_NODE = 1;
-const TEXT_NODE = 3;
-const CDATA_NODE = 4;
-const PI_NODE = 7;
-const COMMENT_NODE = 8;
+/* ── Reading the tree by hand ─────────────────────────────────────────── */
 /** The element children of `node`, in document order. */
 function childrenOf(node) {
-    return Array.from(node.children);
+    return node.children;
 }
 /** Every element under `node`, at any depth, in document order. */
 function descendantsOf(node) {
-    return childrenOf(node).flatMap(child => [child, ...descendantsOf(child)]);
+    return node.descendants();
 }
 /** Is this element in the BPMN MODEL namespace, whatever prefix it wears? */
 function isModel(element) {
@@ -428,53 +422,71 @@ function isColourAttr(attr) {
  * (XML 1.0 §3.3.3 — only a character reference survives normalization).
  */
 function fragmentOf(element) {
-    const attrs = Array.from(element.attributes)
-        .map(attr => ` ${attr.name}="${escapeAttr(attr.value)}"`)
-        .join('');
-    const parts = [];
-    for (const child of Array.from(element.childNodes)) {
-        if (child.nodeType === ELEMENT_NODE) {
-            parts.push(fragmentOf(child));
-        }
-        else if (child.nodeType === TEXT_NODE || child.nodeType === CDATA_NODE) {
-            parts.push(escapeText(child.nodeValue ?? ''));
-        }
-        else if (child.nodeType === COMMENT_NODE) {
-            // A comment inside a vendor extension is documentation somebody wrote by
-            // hand, and dropping it while promising the fragment back "character for
-            // character" would make that promise false in the one place a human
-            // would notice.
-            parts.push(`<!--${child.nodeValue ?? ''}-->`);
-        }
-        else if (child.nodeType === PI_NODE) {
-            const instruction = child;
-            parts.push(`<?${instruction.target} ${instruction.data}?>`);
+    const head = (node) => `<${node.name}${Object.entries(node.attrs)
+        .map(([name, value]) => ` ${name}="${escapeAttr(value)}"`)
+        .join('')}`;
+    // An explicit stack: a quarantined fragment is as deep as the file made it.
+    const stack = [
+        { node: element.node, parts: [], next: 0 },
+    ];
+    let written = '';
+    while (stack.length > 0) {
+        const frame = stack[stack.length - 1];
+        const content = frame.node.content ?? frame.node.children;
+        if (frame.next < content.length) {
+            const entry = content[frame.next];
+            frame.next += 1;
+            if (!('kind' in entry)) {
+                stack.push({ node: entry, parts: [], next: 0 });
+            }
+            else if (entry.kind === 'text') {
+                frame.parts.push(escapeText(entry.value));
+            }
+            else if (entry.kind === 'comment') {
+                // A comment inside a vendor extension is documentation somebody wrote
+                // by hand, and dropping it while promising the fragment back
+                // "character for character" would make that promise false in the one
+                // place a human would notice.
+                frame.parts.push(`<!--${entry.value}-->`);
+            }
+            else {
+                frame.parts.push(`<?${entry.target} ${entry.data}?>`);
+            }
+            continue;
         }
+        stack.pop();
+        const { node, parts } = frame;
+        const text = parts.length === 0
+            ? `${head(node)} />`
+            : `${head(node)}>${parts.join('')}</${node.name}>`;
+        const parent = stack[stack.length - 1];
+        if (parent)
+            parent.parts.push(text);
+        else
+            written = text;
     }
-    const name = element.nodeName;
-    if (parts.length === 0)
-        return `<${name}${attrs} />`;
-    return `<${name}${attrs}>${parts.join('')}</${name}>`;
+    return written;
 }
 /**
  * The document, or an exception naming what is wrong with it.
  *
- * `DOMParser` reports a malformed document as a `parsererror` element rather
- * than by throwing, which is a well-formedness answer nobody asked for in the
- * shape of a document — so it is turned into the exception the caller can
- * actually act on.
+ * `readXml` never throws: it reads what it can and says what it had to
+ * recover from. Anything it recovered from is refused here, with its first
+ * remark as the detail, as `DOMParser` refused it before. A `DOCTYPE` is not
+ * an error: it is skipped, and no entity it declares is ever expanded, so a
+ * `&name;` it declares stays those characters (the spike's billion-laughs and
+ * XXE files, `__tests__/import-hostile.unit.spec.ts`).
  */
 function parseDefinitions(source) {
-    const doc = new DOMParser().parseFromString(source, 'application/xml');
-    const error = doc.querySelector('parsererror');
-    if (error) {
-        const detail = (error.textContent ?? '').trim().slice(0, 200);
+    const { document, root } = readXmlElement(source, { conformant: true });
+    const [complaint] = document.notes;
+    if (complaint !== undefined) {
+        const detail = complaint.slice(0, 200);
         throw new InterchangeImportError(`This file is not well-formed XML, so no BPMN can be read out of it: ${detail}`, {
             messageKey: BPMN_IMPORT_ERRORS.malformedXml[0],
             messageParams: { detail },
         });
     }
-    const root = doc.documentElement;
     if (!root || root.localName !== 'definitions') {
         const tag = root?.localName ?? 'nothing';
         throw new InterchangeImportError(`A BPMN file opens on <definitions>; this one opens on <${tag}>.`, {
@@ -581,8 +593,16 @@ function diagramIndex(definitions) {
  * everywhere in this format, and everything else on an element Labre draws is
  * something Labre does not model and must not lose.
  */
-const READ_ATTRS = {
-    definitions: ['id', 'name', 'targetNamespace', 'exporter', 'exporterVersion'],
+// No prototype, like `EDGE_ROLE_OF_ELEMENT`: `READ_ATTRS.constructor` was a
+// function, and `.includes` on it the untyped TypeError the review found.
+const READ_ATTRS = Object.assign(Object.create(null), {
+    definitions: [
+        'id',
+        'name',
+        'targetNamespace',
+        'exporter',
+        'exporterVersion',
+    ],
     participant: ['id', 'name', 'processRef'],
     process: ['id', 'name', 'isExecutable'],
     lane: ['id', 'name'],
@@ -594,9 +614,15 @@ const READ_ATTRS = {
     messageFlow: ['id', 'name', 'sourceRef', 'targetRef'],
     // `associationDirection` is read only when it says what the exporter would
     // write anyway; see the edge reader for the other values.
-    association: ['id', 'name', 'sourceRef', 'targetRef', 'associationDirection'],
+    association: [
+        'id',
+        'name',
+        'sourceRef',
+        'targetRef',
+        'associationDirection',
+    ],
     '': ['id', 'name'],
-};
+});
 /** What a `BPMNShape` says that the drawing already carries. */
 const READ_SHAPE_ATTRS = [
     'id',
@@ -685,8 +711,14 @@ function layOutTheUndrawn(drafts, minted) {
         draft.kind !== 'edge' &&
         draft.kind !== 'group');
     const boxes = placed.map(boundOf);
-    const maxX = boxes.length > 0 ? Math.max(...boxes.map(box => box.x + box.w)) : 0;
-    const minY = boxes.length > 0 ? Math.min(...boxes.map(box => box.y)) : 0;
+    const maxX = boxes.length > 0
+        ? boxes
+            .map(box => box.x + box.w)
+            .reduce((a, b) => Math.max(a, b), -Infinity)
+        : 0;
+    const minY = boxes.length > 0
+        ? boxes.map(box => box.y).reduce((a, b) => Math.min(a, b), Infinity)
+        : 0;
     let seat = 0;
     for (const draft of drafts) {
         if (!draft.needsLayout)
@@ -718,10 +750,16 @@ function layOutTheUndrawn(drafts, minted) {
         .map(boundOf);
     if (inside.length === 0)
         return;
-    const left = Math.min(...inside.map(box => box.x)) - MINTED_POOL_PADDING;
-    const top = Math.min(...inside.map(box => box.y)) - MINTED_POOL_PADDING;
-    const right = Math.max(...inside.map(box => box.x + box.w)) + MINTED_POOL_PADDING;
-    const bottom = Math.max(...inside.map(box => box.y + box.h)) + MINTED_POOL_PADDING;
+    const left = inside.map(box => box.x).reduce((a, b) => Math.min(a, b), Infinity) -
+        MINTED_POOL_PADDING;
+    const top = inside.map(box => box.y).reduce((a, b) => Math.min(a, b), Infinity) -
+        MINTED_POOL_PADDING;
+    const right = inside
+        .map(box => box.x + box.w)
+        .reduce((a, b) => Math.max(a, b), -Infinity) + MINTED_POOL_PADDING;
+    const bottom = inside
+        .map(box => box.y + box.h)
+        .reduce((a, b) => Math.max(a, b), -Infinity) + MINTED_POOL_PADDING;
     minted.props.xywh = new Bound(
     // The name band is drawn INSIDE the frame and is not part of the plot, so
     // the frame starts a band's width further left than the work does.
@@ -814,12 +852,17 @@ export function importBpmnXml(source, context = {}) {
         }
         seenSourceIds.add(sourceId);
     };
+    /*
+     * The four keep-helpers fill their bags IN PLACE: a copy of the bag per entry
+     * made 20 000 carried children 7.4 s and 20 000 unknown attributes over a
+     * minute (security review, 2026-10-14). The bags have no prototype, because
+     * their keys are names and ids the file chose (`__proto__` among them).
+     */
     /** One attribute, kept under the scope of the element that carried it. */
     const carryAttr = (payload, scope, name, value) => {
-        payload.attrs = {
-            ...payload.attrs,
-            [scope]: { ...payload.attrs?.[scope], [name]: value },
-        };
+        const attrs = (payload.attrs ??= Object.create(null));
+        (attrs[scope] ??= Object.create(null))[name] =
+            value;
         carried++;
     };
     /**
@@ -830,10 +873,8 @@ export function importBpmnXml(source, context = {}) {
      * one flow, one of them generic, is a worse report than one that is precise.
      */
     const carryChild = (payload, scope, child, sourceId, announce = true) => {
-        payload.children = {
-            ...payload.children,
-            [scope]: [...(payload.children?.[scope] ?? []), fragmentOf(child)],
-        };
+        const children = (payload.children ??= Object.create(null));
+        (children[scope] ??= []).push(fragmentOf(child));
         carried++;
         if (!announce)
             return;
@@ -848,10 +889,8 @@ export function importBpmnXml(source, context = {}) {
     };
     /** One diagram fragment, kept under the scope of what it DRAWS. */
     const carryDi = (payload, scope, fragment) => {
-        payload.di = {
-            ...payload.di,
-            [scope]: [...(payload.di?.[scope] ?? []), fragment],
-        };
+        const di = (payload.di ??= Object.create(null));
+        (di[scope] ??= []).push(fragment);
         carried++;
     };
     const quarantine = (payload, fragment, reason, entry, 
@@ -860,10 +899,7 @@ export function importBpmnXml(source, context = {}) {
     // `payload.quarantined[].reason` (data, never translated); only the
     // REPORT note below carries the key.
     reasonKey) => {
-        payload.quarantined = [
-            ...(payload.quarantined ?? []),
-            { fragment, reason },
-        ];
+        (payload.quarantined ??= []).push({ fragment, reason });
         quarantined++;
         note({
             kind: 'quarantined',
@@ -1298,13 +1334,10 @@ export function importBpmnXml(source, context = {}) {
                     const drawn = shapes.get(inner)?.element ?? diEdges.get(inner)?.element;
                     if (!drawn)
                         continue;
-                    payload.quarantined = [
-                        ...(payload.quarantined ?? []),
-                        {
-                            fragment: fragmentOf(drawn),
-                            reason: BPMN_QUARANTINE_REASON.expanded,
-                        },
-                    ];
+                    (payload.quarantined ??= []).push({
+                        fragment: fragmentOf(drawn),
+                        reason: BPMN_QUARANTINE_REASON.expanded,
+                    });
                 }
                 continue;
             }

package/dist/interchange-headless.d.ts

@@ -0,0 +1,74 @@
+import type { InterchangeFormat, InterchangeImportCapability } from '@formicoidea/labre-core/interchange';
+/**
+ * `@labre/affine-gfx-bpmn/interchange` — BPMN'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 a `.bpmn` or an `.svg` as a BPMN board: the
+ * format declarations and the import capabilities, whose `run` is a pure
+ * function of text. The EXPORT capability is not here and cannot be: it picks
+ * the artefacts out of live element models (`bpmnBoardFrom`, by `instanceof`),
+ * which is the editor graph this entry exists to leave out. It stays in
+ * `interchange.ts`, which re-exports everything below.
+ *
+ * Held by `interchange-headless.unit.spec.ts` in `packages/affine/all`.
+ */
+/**
+ * BPMN 2.0 XML. **Semantic** — the file carries a model, not a picture, so it
+ * takes the whole preservation contract the day an importer is written.
+ *
+ * `application/xml` and not `text/xml`: the file is not meant to be read as
+ * text by whatever opens it, and `.bpmn` is the extension every BPMN tool
+ * watches for.
+ *
+ * `.xml` rides along BEHIND it, and the order is the whole of the difference:
+ * the first extension is the one a download is given, so Labre still writes
+ * `.bpmn`, and the rest are what a picker offers and what an auto-detecting
+ * host indexes on. Half the tools in the wild write the same bytes under the
+ * generic extension, and a filter that refused them would refuse a valid
+ * process for the sake of a filename — the same argument the shared `FileTypes`
+ * table made when this filter lived there, kept now that the filter is built
+ * from the format itself. What the file actually IS is decided by the reader,
+ * which throws on anything that is not a BPMN `<definitions>`.
+ */
+export declare const BPMN_XML_EXTENSION = ".bpmn";
+export declare const BPMN_XML_MIME = "application/xml";
+export declare const BPMN_XML_FORMAT: InterchangeFormat;
+/**
+ * `bpmn:bpmn:import` — a `.bpmn` file as a board.
+ *
+ * A thin adapter over {@link importBpmnXml} and nothing else, which is the
+ * whole of what a capability is: the parser is a pure function of a string, so
+ * the registry entry has nothing to add to it and deliberately adds nothing.
+ * A reader that threw its arms around a surface here would be a reader
+ * labre-mcp could not call.
+ */
+export declare const BPMN_XML_IMPORT: InterchangeImportCapability;
+/**
+ * SVG. **Visual** — the file carries a rendering, not a model.
+ *
+ * A separate format object from `BPMN_XML_FORMAT` and deliberately not a shared
+ * singleton with Wardley's: ADR 0012's unit is the TRIPLE, and the ADR
+ * explicitly rejects "one capability per format, with the framework inferred
+ * from the file" — a `.svg` is read by several frameworks and the inference is
+ * exactly the guess the ADR forbids everywhere else. The three constants come
+ * from the parser's own package so the two declarations cannot drift into
+ * disagreeing about the extension or the mime a picker filters on.
+ */
+export declare const BPMN_SVG_FORMAT: InterchangeFormat;
+/**
+ * `bpmn: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`.** They are
+ * written once, there, because BPMN and Wardley wrap the SAME parser and
+ * therefore make the same guesses; a framework that ever wants narrower or
+ * wider recognition writes its own parser and its own paragraph beside it.
+ *
+ * What lands is a level-1 sketch (ADR 0007) — plain shapes, brush strokes and
+ * editable free text — that the author then PROMOTES into BPMN artefacts.
+ * Nothing here decides that a rounded rectangle in somebody's picture was a
+ * task, and no `interchange` payload is written, because a visual round-trip
+ * would be a re-render (P2).
+ */
+export declare const BPMN_SVG_IMPORT: InterchangeImportCapability;

package/dist/interchange-headless.js

@@ -0,0 +1,100 @@
+import { interchangeCapabilityId, parseSvgSketch, SVG_SKETCH_EXTENSION, SVG_SKETCH_FORMAT_ID, SVG_SKETCH_MIME, } from '@formicoidea/labre-core/interchange';
+import { BPMN_FORMAT_ID } from './export.js';
+import { importBpmnXml } from './import.js';
+/**
+ * `@labre/affine-gfx-bpmn/interchange` — BPMN'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 a `.bpmn` or an `.svg` as a BPMN board: the
+ * format declarations and the import capabilities, whose `run` is a pure
+ * function of text. The EXPORT capability is not here and cannot be: it picks
+ * the artefacts out of live element models (`bpmnBoardFrom`, by `instanceof`),
+ * which is the editor graph this entry exists to leave out. It stays in
+ * `interchange.ts`, which re-exports everything below.
+ *
+ * Held by `interchange-headless.unit.spec.ts` in `packages/affine/all`.
+ */
+/* ── The format ───────────────────────────────────────────────────────── */
+/**
+ * BPMN 2.0 XML. **Semantic** — the file carries a model, not a picture, so it
+ * takes the whole preservation contract the day an importer is written.
+ *
+ * `application/xml` and not `text/xml`: the file is not meant to be read as
+ * text by whatever opens it, and `.bpmn` is the extension every BPMN tool
+ * watches for.
+ *
+ * `.xml` rides along BEHIND it, and the order is the whole of the difference:
+ * the first extension is the one a download is given, so Labre still writes
+ * `.bpmn`, and the rest are what a picker offers and what an auto-detecting
+ * host indexes on. Half the tools in the wild write the same bytes under the
+ * generic extension, and a filter that refused them would refuse a valid
+ * process for the sake of a filename — the same argument the shared `FileTypes`
+ * table made when this filter lived there, kept now that the filter is built
+ * from the format itself. What the file actually IS is decided by the reader,
+ * which throws on anything that is not a BPMN `<definitions>`.
+ */
+export const BPMN_XML_EXTENSION = '.bpmn';
+export const BPMN_XML_MIME = 'application/xml';
+export const BPMN_XML_FORMAT = {
+    id: BPMN_FORMAT_ID,
+    tier: 'semantic',
+    extensions: [BPMN_XML_EXTENSION, '.xml'],
+    mime: BPMN_XML_MIME,
+};
+/**
+ * `bpmn:bpmn:import` — a `.bpmn` file as a board.
+ *
+ * A thin adapter over {@link importBpmnXml} and nothing else, which is the
+ * whole of what a capability is: the parser is a pure function of a string, so
+ * the registry entry has nothing to add to it and deliberately adds nothing.
+ * A reader that threw its arms around a surface here would be a reader
+ * labre-mcp could not call.
+ */
+export const BPMN_XML_IMPORT = {
+    id: interchangeCapabilityId('bpmn', BPMN_XML_FORMAT.id, 'import'),
+    framework: 'bpmn',
+    format: BPMN_XML_FORMAT,
+    direction: 'import',
+    run: importBpmnXml,
+};
+/* ── The visual tier ──────────────────────────────────────────────────── */
+/**
+ * SVG. **Visual** — the file carries a rendering, not a model.
+ *
+ * A separate format object from `BPMN_XML_FORMAT` and deliberately not a shared
+ * singleton with Wardley's: ADR 0012's unit is the TRIPLE, and the ADR
+ * explicitly rejects "one capability per format, with the framework inferred
+ * from the file" — a `.svg` is read by several frameworks and the inference is
+ * exactly the guess the ADR forbids everywhere else. The three constants come
+ * from the parser's own package so the two declarations cannot drift into
+ * disagreeing about the extension or the mime a picker filters on.
+ */
+export const BPMN_SVG_FORMAT = {
+    id: SVG_SKETCH_FORMAT_ID,
+    tier: 'visual',
+    extensions: [SVG_SKETCH_EXTENSION],
+    mime: SVG_SKETCH_MIME,
+};
+/**
+ * `bpmn: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`.** They are
+ * written once, there, because BPMN and Wardley wrap the SAME parser and
+ * therefore make the same guesses; a framework that ever wants narrower or
+ * wider recognition writes its own parser and its own paragraph beside it.
+ *
+ * What lands is a level-1 sketch (ADR 0007) — plain shapes, brush strokes and
+ * editable free text — that the author then PROMOTES into BPMN artefacts.
+ * Nothing here decides that a rounded rectangle in somebody's picture was a
+ * task, and no `interchange` payload is written, because a visual round-trip
+ * would be a re-render (P2).
+ */
+export const BPMN_SVG_IMPORT = {
+    id: interchangeCapabilityId('bpmn', BPMN_SVG_FORMAT.id, 'import'),
+    framework: 'bpmn',
+    format: BPMN_SVG_FORMAT,
+    direction: 'import',
+    run: parseSvgSketch,
+};

package/dist/interchange.d.ts

@@ -1,45 +1,7 @@
-import type { InterchangeCapability, InterchangeExportCapability, InterchangeFormat, InterchangeImportCapability } from '@formicoidea/labre-core/blocks/surface';
+import type { InterchangeCapability, InterchangeExportCapability } from '@formicoidea/labre-core/blocks/surface';
 import type { GfxPrimitiveElementModel } from '@formicoidea/labre-core/std/gfx';
 import { type BpmnExportBoard } from './export.js';
-/**
- * BPMN's entries in the interchange registry (`docs/adr/0012`, P1).
- *
- * Both directions of one format, declared as two capabilities and not as one
- * symmetric thing: `.bpmn` OUT shipped in #149, `.bpmn` IN is the worked
- * example D1–D6 specifies, and each makes its own promises. The registry says
- * so in the only way it can — a row per triple.
- *
- * They share the FORMAT object, deliberately. `bpmn` 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; there is
- * one `BPMN_XML_FORMAT` and both point at it.
- *
- * Everything here is pure. Neither serializer nor parser has ever had a `std`
- * in sight, and this file adds no editor to either: it picks the artefacts the
- * writer speaks about out of a surface's elements, and hands the reader's
- * output straight back to whoever asked for it.
- */
-/**
- * BPMN 2.0 XML. **Semantic** — the file carries a model, not a picture, so it
- * takes the whole preservation contract the day an importer is written.
- *
- * `application/xml` and not `text/xml`: the file is not meant to be read as
- * text by whatever opens it, and `.bpmn` is the extension every BPMN tool
- * watches for.
- *
- * `.xml` rides along BEHIND it, and the order is the whole of the difference:
- * the first extension is the one a download is given, so Labre still writes
- * `.bpmn`, and the rest are what a picker offers and what an auto-detecting
- * host indexes on. Half the tools in the wild write the same bytes under the
- * generic extension, and a filter that refused them would refuse a valid
- * process for the sake of a filename — the same argument the shared `FileTypes`
- * table made when this filter lived there, kept now that the filter is built
- * from the format itself. What the file actually IS is decided by the reader,
- * which throws on anything that is not a BPMN `<definitions>`.
- */
-export declare const BPMN_XML_EXTENSION = ".bpmn";
-export declare const BPMN_XML_MIME = "application/xml";
-export declare const BPMN_XML_FORMAT: InterchangeFormat;
+export { BPMN_SVG_FORMAT, BPMN_SVG_IMPORT, BPMN_XML_EXTENSION, BPMN_XML_FORMAT, BPMN_XML_IMPORT, BPMN_XML_MIME, } from './interchange-headless.js';
 /**
  * The artefacts the exporter speaks about, picked out of a surface's elements
  * and kept in the order they were given.
@@ -95,44 +57,5 @@ export declare function bpmnBoardFrom(elements: readonly GfxPrimitiveElementMode
 export declare function bpmnSafeFilename(raw: string | undefined): string;
 /** `bpmn:bpmn:export` — the registry's first capability. */
 export declare const BPMN_XML_EXPORT: InterchangeExportCapability;
-/**
- * `bpmn:bpmn:import` — a `.bpmn` file as a board.
- *
- * A thin adapter over {@link importBpmnXml} and nothing else, which is the
- * whole of what a capability is: the parser is a pure function of a string, so
- * the registry entry has nothing to add to it and deliberately adds nothing.
- * A reader that threw its arms around a surface here would be a reader
- * labre-mcp could not call.
- */
-export declare const BPMN_XML_IMPORT: InterchangeImportCapability;
-/**
- * SVG. **Visual** — the file carries a rendering, not a model.
- *
- * A separate format object from `BPMN_XML_FORMAT` and deliberately not a shared
- * singleton with Wardley's: ADR 0012's unit is the TRIPLE, and the ADR
- * explicitly rejects "one capability per format, with the framework inferred
- * from the file" — a `.svg` is read by several frameworks and the inference is
- * exactly the guess the ADR forbids everywhere else. The three constants come
- * from the parser's own package so the two declarations cannot drift into
- * disagreeing about the extension or the mime a picker filters on.
- */
-export declare const BPMN_SVG_FORMAT: InterchangeFormat;
-/**
- * `bpmn: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`.** They are
- * written once, there, because BPMN and Wardley wrap the SAME parser and
- * therefore make the same guesses; a framework that ever wants narrower or
- * wider recognition writes its own parser and its own paragraph beside it.
- *
- * What lands is a level-1 sketch (ADR 0007) — plain shapes, brush strokes and
- * editable free text — that the author then PROMOTES into BPMN artefacts.
- * Nothing here decides that a rounded rectangle in somebody's picture was a
- * task, and no `interchange` payload is written, because a visual round-trip
- * would be a re-render (P2).
- */
-export declare const BPMN_SVG_IMPORT: InterchangeImportCapability;
 /** Everything BPMN registers, in one list the view extension can hand over. */
 export declare const BPMN_INTERCHANGE: readonly InterchangeCapability[];

package/dist/interchange.js

@@ -1,11 +1,12 @@
-import { interchangeCapabilityId, LEGEND_ROLE, parseSvgSketch, SVG_SKETCH_EXTENSION, SVG_SKETCH_FORMAT_ID, SVG_SKETCH_MIME, } from '@formicoidea/labre-core/blocks/surface';
+import { interchangeCapabilityId, LEGEND_ROLE, } from '@formicoidea/labre-core/blocks/surface';
 import { BpmnNodeElementModel, BpmnPoolElementModel, ConnectorElementModel, GroupElementModel, TextElementModel, } from '@formicoidea/labre-core/model';
 import { fillPlaceholders } from '@formicoidea/labre-core/shared/services';
 import { safeFilename } from '@formicoidea/labre-core/shared/utils';
-import { BPMN_FORMAT_ID, exportBpmnXmlWithWarnings, } from './export.js';
+import { exportBpmnXmlWithWarnings } from './export.js';
 import { bpmnPoolOf } from './facts.js';
-import { importBpmnXml } from './import.js';
+import { BPMN_SVG_IMPORT, BPMN_XML_EXTENSION, BPMN_XML_FORMAT, BPMN_XML_IMPORT, BPMN_XML_MIME, } from './interchange-headless.js';
 import { BPMN_ROLE, BPMN_ROLE_OF_KIND } from './roles.js';
+export { BPMN_SVG_FORMAT, BPMN_SVG_IMPORT, BPMN_XML_EXTENSION, BPMN_XML_FORMAT, BPMN_XML_IMPORT, BPMN_XML_MIME, } from './interchange-headless.js';
 /**
  * BPMN's entries in the interchange registry (`docs/adr/0012`, P1).
  *
@@ -24,33 +25,6 @@ import { BPMN_ROLE, BPMN_ROLE_OF_KIND } from './roles.js';
  * writer speaks about out of a surface's elements, and hands the reader's
  * output straight back to whoever asked for it.
  */
-/* ── The format ───────────────────────────────────────────────────────── */
-/**
- * BPMN 2.0 XML. **Semantic** — the file carries a model, not a picture, so it
- * takes the whole preservation contract the day an importer is written.
- *
- * `application/xml` and not `text/xml`: the file is not meant to be read as
- * text by whatever opens it, and `.bpmn` is the extension every BPMN tool
- * watches for.
- *
- * `.xml` rides along BEHIND it, and the order is the whole of the difference:
- * the first extension is the one a download is given, so Labre still writes
- * `.bpmn`, and the rest are what a picker offers and what an auto-detecting
- * host indexes on. Half the tools in the wild write the same bytes under the
- * generic extension, and a filter that refused them would refuse a valid
- * process for the sake of a filename — the same argument the shared `FileTypes`
- * table made when this filter lived there, kept now that the filter is built
- * from the format itself. What the file actually IS is decided by the reader,
- * which throws on anything that is not a BPMN `<definitions>`.
- */
-export const BPMN_XML_EXTENSION = '.bpmn';
-export const BPMN_XML_MIME = 'application/xml';
-export const BPMN_XML_FORMAT = {
-    id: BPMN_FORMAT_ID,
-    tier: 'semantic',
-    extensions: [BPMN_XML_EXTENSION, '.xml'],
-    mime: BPMN_XML_MIME,
-};
 /* ── Pure board helpers ───────────────────────────────────────────────── */
 /**
  * Everything a generated legend is made of: the group the legend gesture stamps
@@ -269,63 +243,6 @@ export const BPMN_XML_EXPORT = {
     direction: 'export',
     run: runBpmnXmlExport,
 };
-/**
- * `bpmn:bpmn:import` — a `.bpmn` file as a board.
- *
- * A thin adapter over {@link importBpmnXml} and nothing else, which is the
- * whole of what a capability is: the parser is a pure function of a string, so
- * the registry entry has nothing to add to it and deliberately adds nothing.
- * A reader that threw its arms around a surface here would be a reader
- * labre-mcp could not call.
- */
-export const BPMN_XML_IMPORT = {
-    id: interchangeCapabilityId('bpmn', BPMN_XML_FORMAT.id, 'import'),
-    framework: 'bpmn',
-    format: BPMN_XML_FORMAT,
-    direction: 'import',
-    run: importBpmnXml,
-};
-/* ── The visual tier ──────────────────────────────────────────────────── */
-/**
- * SVG. **Visual** — the file carries a rendering, not a model.
- *
- * A separate format object from `BPMN_XML_FORMAT` and deliberately not a shared
- * singleton with Wardley's: ADR 0012's unit is the TRIPLE, and the ADR
- * explicitly rejects "one capability per format, with the framework inferred
- * from the file" — a `.svg` is read by several frameworks and the inference is
- * exactly the guess the ADR forbids everywhere else. The three constants come
- * from the parser's own package so the two declarations cannot drift into
- * disagreeing about the extension or the mime a picker filters on.
- */
-export const BPMN_SVG_FORMAT = {
-    id: SVG_SKETCH_FORMAT_ID,
-    tier: 'visual',
-    extensions: [SVG_SKETCH_EXTENSION],
-    mime: SVG_SKETCH_MIME,
-};
-/**
- * `bpmn: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`.** They are
- * written once, there, because BPMN and Wardley wrap the SAME parser and
- * therefore make the same guesses; a framework that ever wants narrower or
- * wider recognition writes its own parser and its own paragraph beside it.
- *
- * What lands is a level-1 sketch (ADR 0007) — plain shapes, brush strokes and
- * editable free text — that the author then PROMOTES into BPMN artefacts.
- * Nothing here decides that a rounded rectangle in somebody's picture was a
- * task, and no `interchange` payload is written, because a visual round-trip
- * would be a re-render (P2).
- */
-export const BPMN_SVG_IMPORT = {
-    id: interchangeCapabilityId('bpmn', BPMN_SVG_FORMAT.id, 'import'),
-    framework: 'bpmn',
-    format: BPMN_SVG_FORMAT,
-    direction: 'import',
-    run: parseSvgSketch,
-};
 /** Everything BPMN registers, in one list the view extension can hand over. */
 export const BPMN_INTERCHANGE = [
     BPMN_XML_EXPORT,

package/dist/presets.d.ts

@@ -1,5 +1,5 @@
 import type { BpmnNodeKind } from '@formicoidea/labre-core/model';
-import { StrokeStyle, TextAlign, TextFitMode, TextVerticalAlign } from '@formicoidea/labre-core/model';
+import { StrokeStyle, TextAlign, TextFitMode, TextVerticalAlign } from '@formicoidea/labre-core/model/headless';
 /**
  * What a BPMN artefact is BORN as — the one description of a node's props, read
  * by every site that creates one.

package/dist/presets.js

@@ -1,4 +1,4 @@
-import { FontFamily, SHAPE_TEXT_PADDING, SHAPE_TEXT_VERTICAL_PADDING, ShapeStyle, StrokeStyle, TextAlign, TextFitMode, TextVerticalAlign, } from '@formicoidea/labre-core/model';
+import { FontFamily, SHAPE_TEXT_PADDING, SHAPE_TEXT_VERTICAL_PADDING, ShapeStyle, StrokeStyle, TextAlign, TextFitMode, TextVerticalAlign, } from '@formicoidea/labre-core/model/headless';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
 import { ACTIVITY_FIT_REF, BPMN_LABEL_GAP, BPMN_LABEL_H, BPMN_LABEL_W, CALL_ACTIVITY_WIDTH, END_WIDTH, EVENT_END, EVENT_START, GROUP_RADIUS, GROUP_STROKE, INNER_FONT_SIZE, isBpmnActivityKind, LABEL_FONT_SIZE, LABEL_INSET_RATIO, LABEL_MIN_FONT_SIZE, NEUTRAL_STROKE, NODE_FILL, NODE_SIZE, NODE_STROKE_WIDTH, START_WIDTH, TASK_RADIUS, } from './consts.js';
 import { BPMN_ROLE, BPMN_ROLE_OF_KIND } from './roles.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-framework-bpmn",
   "description": "Labre bpmn framework for @formicoidea/labre-core.",
-  "version": "0.50.0",
+  "version": "0.52.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.52.0",
     "lit": "^3.2.0"
   }
 }