@formicoidea/labre-framework-uml 0.49.0 → 0.51.0

package/dist/consts.d.ts

@@ -96,7 +96,7 @@ export declare const UML_DIAGRAM_MARGIN = 24;
  * pack's metrics, exactly as `consts.ts` in the C4 pack re-exports
  * `C4_BOARD_TITLE_BAND_HEIGHT`.
  */
-export { UML_FRAME_BAND_HEIGHT } from '@formicoidea/labre-core/model';
+export { UML_FRAME_BAND_HEIGHT } from '@formicoidea/labre-core/model/headless';
 /** The size a fresh diagram frame is created at — a Context Map sheet's own. */
 export declare const UML_DIAGRAM_BOX: {
     readonly w: 1400;
@@ -246,7 +246,7 @@ export declare const UML_REGION_RADIUS = 16;
  * Re-exported here so this file stays the one place a reader looks for the
  * pack's metrics, exactly as {@link UML_FRAME_BAND_HEIGHT} is.
  */
-export { UML_PARTITION_BAND, UML_REGION_BAND } from '@formicoidea/labre-core/model';
+export { UML_PARTITION_BAND, UML_REGION_BAND, } from '@formicoidea/labre-core/model/headless';
 /**
  * The lifeline's head box and the height of its column, owned by
  * `@labre/affine-model` because the ELEMENT's own `elementBound` and
@@ -257,7 +257,7 @@ export { UML_PARTITION_BAND, UML_REGION_BAND } from '@formicoidea/labre-core/mod
  * Re-exported here so this file stays the one place a reader looks for the
  * pack's metrics, exactly as {@link UML_FRAME_BAND_HEIGHT} is.
  */
-export { UML_LIFELINE_HEAD, UML_LIFELINE_SPINE } from '@formicoidea/labre-core/model';
+export { UML_LIFELINE_HEAD, UML_LIFELINE_SPINE, } from '@formicoidea/labre-core/model/headless';
 /**
  * The dash pattern of a lifeline's SPINE, in model units (§17.3.4).
  *
@@ -304,7 +304,7 @@ export declare const UML_FRAGMENT_OPERAND_DASH: readonly [10, 6];
  *
  * Re-exported for the reason every other band is.
  */
-export { UML_FRAGMENT_BAND } from '@formicoidea/labre-core/model';
+export { UML_FRAGMENT_BAND } from '@formicoidea/labre-core/model/headless';
 /**
  * The guard written in an operand's own corner, and its inset from the
  * operand's top-left.

package/dist/consts.js

@@ -1,8 +1,8 @@
 // The lifeline's column height is a MODEL constant (the element's own bound
 // override reads it), and it is also this file's footprint for the kind — so it
 // is imported as well as re-exported below.
-import { UML_LIFELINE_SPINE } from '@formicoidea/labre-core/model';
-import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
+import { UML_LIFELINE_SPINE } from '@formicoidea/labre-core/model/headless';
+import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/headless';
 /**
  * Visual constants for the UML pack.
  *
@@ -104,7 +104,7 @@ export const UML_DIAGRAM_MARGIN = 24;
  * pack's metrics, exactly as `consts.ts` in the C4 pack re-exports
  * `C4_BOARD_TITLE_BAND_HEIGHT`.
  */
-export { UML_FRAME_BAND_HEIGHT } from '@formicoidea/labre-core/model';
+export { UML_FRAME_BAND_HEIGHT } from '@formicoidea/labre-core/model/headless';
 /** The size a fresh diagram frame is created at — a Context Map sheet's own. */
 export const UML_DIAGRAM_BOX = { w: 1400, h: 900 };
 /**
@@ -345,7 +345,7 @@ export const UML_REGION_RADIUS = 16;
  * Re-exported here so this file stays the one place a reader looks for the
  * pack's metrics, exactly as {@link UML_FRAME_BAND_HEIGHT} is.
  */
-export { UML_PARTITION_BAND, UML_REGION_BAND } from '@formicoidea/labre-core/model';
+export { UML_PARTITION_BAND, UML_REGION_BAND, } from '@formicoidea/labre-core/model/headless';
 /* ── The interaction artefacts (phase 3) ───────────────────────────────── */
 /**
  * The lifeline's head box and the height of its column, owned by
@@ -357,7 +357,7 @@ export { UML_PARTITION_BAND, UML_REGION_BAND } from '@formicoidea/labre-core/mod
  * Re-exported here so this file stays the one place a reader looks for the
  * pack's metrics, exactly as {@link UML_FRAME_BAND_HEIGHT} is.
  */
-export { UML_LIFELINE_HEAD, UML_LIFELINE_SPINE } from '@formicoidea/labre-core/model';
+export { UML_LIFELINE_HEAD, UML_LIFELINE_SPINE, } from '@formicoidea/labre-core/model/headless';
 /**
  * The dash pattern of a lifeline's SPINE, in model units (§17.3.4).
  *
@@ -401,7 +401,7 @@ export const UML_FRAGMENT_OPERAND_DASH = [10, 6];
  *
  * Re-exported for the reason every other band is.
  */
-export { UML_FRAGMENT_BAND } from '@formicoidea/labre-core/model';
+export { UML_FRAGMENT_BAND } from '@formicoidea/labre-core/model/headless';
 /**
  * The guard written in an operand's own corner, and its inset from the
  * operand's top-left.

package/dist/drawio-decode.d.ts

@@ -1,3 +1,34 @@
+/**
+ * The most a `<diagram>` payload may inflate to: 20 MiB.
+ *
+ * A raw deflate stream compresses a run of one byte about a thousand to one,
+ * so the size of the FILE says nothing about the size of what it holds: the
+ * P0 import spike (labre `docs/spikes/2026-10-p0-import-edge-function.md`)
+ * inflated a 398 KiB `.drawio` to 300 MiB and lost the isolate to it, and an
+ * 85 KiB one to 64 MiB in 624 ms. The real corpus is three orders of magnitude
+ * below the ceiling (`drawio-class-iwlayer` inflates to 12 KiB), and a drawing
+ * twenty megabytes of XML long is already more than the canvas draws usefully.
+ *
+ * Counted on the INFLATED BYTES as they stream out, never on the payload: the
+ * compressed size is the attacker's number, the inflated one is ours. The
+ * stream is cancelled the moment the count passes the ceiling, so the memory
+ * the decode can take is bounded by the ceiling plus one chunk.
+ */
+export declare const DRAWIO_MAX_INFLATED_BYTES: number;
+/**
+ * The decoder's four refusals, as `[key, English]` pairs (ADR 0023): every one
+ * is thrown as an {@link InterchangeImportError} carrying the key, so a host
+ * that must not echo a reader's sentence (an HTTP response, a log) has a
+ * STATIC identifier to hand on instead, and the editor's catch site translates
+ * it exactly as it translates a reader's own refusal. None takes a parameter:
+ * nothing out of the file is ever put into one.
+ */
+export declare const UML_DRAWIO_DECODE_ERRORS: {
+    readonly noDecompression: readonly ["com.labre.uml.import.drawio.error.no-decompression", "This runtime cannot read a compressed .drawio file (DecompressionStream is unavailable). Re-save it from draw.io with File › Properties › Compressed turned off."];
+    readonly emptyDiagram: readonly ["com.labre.uml.import.drawio.error.empty-diagram", "This .drawio file holds no <diagram> to read."];
+    readonly badPayload: readonly ["com.labre.uml.import.drawio.error.bad-payload", "This .drawio file’s <diagram> is neither XML nor a payload this reader could inflate."];
+    readonly tooLarge: readonly ["com.labre.uml.import.drawio.error.too-large", "This .drawio file’s <diagram> inflates past the size this reader accepts."];
+};
 /**
  * The sentence a host sees when the runtime cannot inflate.
  *
@@ -5,9 +36,10 @@
  * of it, and so a host that wants to offer "open it in draw.io and save it
  * uncompressed" has something to match on.
  */
-export declare const DRAWIO_NO_DECOMPRESSION = "This runtime cannot read a compressed .drawio file (DecompressionStream is unavailable). Re-save it from draw.io with File \u203A Properties \u203A Compressed turned off.";
-export declare const DRAWIO_EMPTY_DIAGRAM = "This .drawio file holds no <diagram> to read.";
-export declare const DRAWIO_BAD_PAYLOAD = "This .drawio file\u2019s <diagram> is neither XML nor a payload this reader could inflate.";
+export declare const DRAWIO_NO_DECOMPRESSION: "This runtime cannot read a compressed .drawio file (DecompressionStream is unavailable). Re-save it from draw.io with File › Properties › Compressed turned off.";
+export declare const DRAWIO_EMPTY_DIAGRAM: "This .drawio file holds no <diagram> to read.";
+export declare const DRAWIO_BAD_PAYLOAD: "This .drawio file’s <diagram> is neither XML nor a payload this reader could inflate.";
+export declare const DRAWIO_TOO_LARGE: "This .drawio file’s <diagram> inflates past the size this reader accepts.";
 /**
  * An `.drawio` file's text as the `<mxGraphModel>` XML inside it.
  *
@@ -23,7 +55,9 @@ export declare const DRAWIO_BAD_PAYLOAD = "This .drawio file\u2019s <diagram> is
  * page ever was. The remaining pages are what a second import of the same file
  * is for.
  *
- * Throws, with one of the three sentences above, when it cannot. That is the
+ * Throws an {@link InterchangeImportError}, with one of the four refusals
+ * above, when it cannot — the fourth being a payload that inflates past
+ * {@link DRAWIO_MAX_INFLATED_BYTES}. That is the
  * contract the import pipeline already has for a file it cannot read
  * (`importInterchangeFile` shows the thrown sentence as the failure
  * notification), and it is the right one here: an empty board with a `warning`

package/dist/drawio-decode.js

@@ -1,3 +1,4 @@
+import { InterchangeImportError } from '@formicoidea/labre-core/interchange';
 import { isCompressedDrawio } from './drawio-import.js';
 /**
  * The one impure step of the draw.io import: inflating an `<mxfile>`'s payload
@@ -34,8 +35,69 @@ import { isCompressedDrawio } from './drawio-import.js';
  * Where the API is genuinely absent the failure is NAMED — see below — rather
  * than left as a `TypeError` about an undefined constructor.
  */
-/** `<diagram …>PAYLOAD</diagram>` — the first page of an `mxfile`. */
-const DIAGRAM = /<diagram\b[^>]*>([\s\S]*?)<\/diagram>/i;
+/**
+ * `PAYLOAD` in `<diagram …>PAYLOAD</diagram>`, the first page of an `mxfile`.
+ *
+ * Two linear searches rather than one lazy regex: `[\s\S]*?` re-scanned the
+ * rest of the file from every `<diagram` that never closed, 13.7 s for 352 KiB
+ * (security review, 2026-10-14). Only the first open tag can match: when it
+ * has no `>` or no close after it, no later one has either.
+ */
+function diagramPayload(text) {
+    const open = /<diagram\b/i.exec(text);
+    if (!open)
+        return undefined;
+    const start = text.indexOf('>', open.index);
+    if (start < 0)
+        return undefined;
+    const close = /<\/diagram>/gi;
+    close.lastIndex = start + 1;
+    const end = close.exec(text);
+    return end ? text.slice(start + 1, end.index) : undefined;
+}
+/**
+ * The most a `<diagram>` payload may inflate to: 20 MiB.
+ *
+ * A raw deflate stream compresses a run of one byte about a thousand to one,
+ * so the size of the FILE says nothing about the size of what it holds: the
+ * P0 import spike (labre `docs/spikes/2026-10-p0-import-edge-function.md`)
+ * inflated a 398 KiB `.drawio` to 300 MiB and lost the isolate to it, and an
+ * 85 KiB one to 64 MiB in 624 ms. The real corpus is three orders of magnitude
+ * below the ceiling (`drawio-class-iwlayer` inflates to 12 KiB), and a drawing
+ * twenty megabytes of XML long is already more than the canvas draws usefully.
+ *
+ * Counted on the INFLATED BYTES as they stream out, never on the payload: the
+ * compressed size is the attacker's number, the inflated one is ours. The
+ * stream is cancelled the moment the count passes the ceiling, so the memory
+ * the decode can take is bounded by the ceiling plus one chunk.
+ */
+export const DRAWIO_MAX_INFLATED_BYTES = 20 * 1024 * 1024;
+/**
+ * The decoder's four refusals, as `[key, English]` pairs (ADR 0023): every one
+ * is thrown as an {@link InterchangeImportError} carrying the key, so a host
+ * that must not echo a reader's sentence (an HTTP response, a log) has a
+ * STATIC identifier to hand on instead, and the editor's catch site translates
+ * it exactly as it translates a reader's own refusal. None takes a parameter:
+ * nothing out of the file is ever put into one.
+ */
+export const UML_DRAWIO_DECODE_ERRORS = {
+    noDecompression: [
+        'com.labre.uml.import.drawio.error.no-decompression',
+        'This runtime cannot read a compressed .drawio file (DecompressionStream is unavailable). Re-save it from draw.io with File › Properties › Compressed turned off.',
+    ],
+    emptyDiagram: [
+        'com.labre.uml.import.drawio.error.empty-diagram',
+        'This .drawio file holds no <diagram> to read.',
+    ],
+    badPayload: [
+        'com.labre.uml.import.drawio.error.bad-payload',
+        'This .drawio file’s <diagram> is neither XML nor a payload this reader could inflate.',
+    ],
+    tooLarge: [
+        'com.labre.uml.import.drawio.error.too-large',
+        'This .drawio file’s <diagram> inflates past the size this reader accepts.',
+    ],
+};
 /**
  * The sentence a host sees when the runtime cannot inflate.
  *
@@ -43,9 +105,48 @@ const DIAGRAM = /<diagram\b[^>]*>([\s\S]*?)<\/diagram>/i;
  * of it, and so a host that wants to offer "open it in draw.io and save it
  * uncompressed" has something to match on.
  */
-export const DRAWIO_NO_DECOMPRESSION = 'This runtime cannot read a compressed .drawio file (DecompressionStream is unavailable). Re-save it from draw.io with File › Properties › Compressed turned off.';
-export const DRAWIO_EMPTY_DIAGRAM = 'This .drawio file holds no <diagram> to read.';
-export const DRAWIO_BAD_PAYLOAD = 'This .drawio file’s <diagram> is neither XML nor a payload this reader could inflate.';
+export const DRAWIO_NO_DECOMPRESSION = UML_DRAWIO_DECODE_ERRORS.noDecompression[1];
+export const DRAWIO_EMPTY_DIAGRAM = UML_DRAWIO_DECODE_ERRORS.emptyDiagram[1];
+export const DRAWIO_BAD_PAYLOAD = UML_DRAWIO_DECODE_ERRORS.badPayload[1];
+export const DRAWIO_TOO_LARGE = UML_DRAWIO_DECODE_ERRORS.tooLarge[1];
+const refusal = (which) => {
+    const [key, message] = UML_DRAWIO_DECODE_ERRORS[which];
+    return new InterchangeImportError(message, { messageKey: key });
+};
+/** The ceiling was passed — a sentinel, so the `catch` below can tell it apart. */
+class InflateCeiling extends Error {
+}
+/**
+ * Read a byte stream to its end, refusing past `limit` bytes.
+ *
+ * `new Response(stream).text()` buffers whatever the stream yields, which is
+ * the unbounded read the ceiling exists to replace.
+ */
+async function readCapped(stream, limit) {
+    const reader = stream.getReader();
+    const chunks = [];
+    let total = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        total += value.byteLength;
+        if (total > limit) {
+            // Stops the inflater, rather than letting it run to the end of a stream
+            // nobody will read.
+            await reader.cancel().catch(() => undefined);
+            throw new InflateCeiling();
+        }
+        chunks.push(value);
+    }
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}
 /**
  * An `.drawio` file's text as the `<mxGraphModel>` XML inside it.
  *
@@ -61,7 +162,9 @@ export const DRAWIO_BAD_PAYLOAD = 'This .drawio file’s <diagram> is neither XM
  * page ever was. The remaining pages are what a second import of the same file
  * is for.
  *
- * Throws, with one of the three sentences above, when it cannot. That is the
+ * Throws an {@link InterchangeImportError}, with one of the four refusals
+ * above, when it cannot — the fourth being a payload that inflates past
+ * {@link DRAWIO_MAX_INFLATED_BYTES}. That is the
  * contract the import pipeline already has for a file it cannot read
  * (`importInterchangeFile` shows the thrown sentence as the failure
  * notification), and it is the right one here: an empty board with a `warning`
@@ -70,12 +173,12 @@ export const DRAWIO_BAD_PAYLOAD = 'This .drawio file’s <diagram> is neither XM
 export async function decodeDrawio(text) {
     if (!isCompressedDrawio(text))
         return text;
-    const payload = DIAGRAM.exec(text)?.[1]?.trim();
+    const payload = diagramPayload(text)?.trim();
     if (!payload)
-        throw new Error(DRAWIO_EMPTY_DIAGRAM);
+        throw refusal('emptyDiagram');
     const Decompression = globalThis.DecompressionStream;
     if (!Decompression)
-        throw new Error(DRAWIO_NO_DECOMPRESSION);
+        throw refusal('noDecompression');
     let inflated;
     try {
         const binary = atob(payload);
@@ -85,12 +188,14 @@ export async function decodeDrawio(text) {
             .pipeThrough(new Decompression('deflate-raw'));
         // draw.io deflates the URI-ENCODED xml, so this is percent-escaped text and
         // not the document yet.
-        inflated = decodeURIComponent(await new Response(stream).text());
+        inflated = decodeURIComponent(new TextDecoder().decode(await readCapped(stream, DRAWIO_MAX_INFLATED_BYTES)));
     }
-    catch {
-        throw new Error(DRAWIO_BAD_PAYLOAD);
+    catch (error) {
+        if (error instanceof InflateCeiling)
+            throw refusal('tooLarge');
+        throw refusal('badPayload');
     }
     if (!inflated.includes('<mxGraphModel'))
-        throw new Error(DRAWIO_BAD_PAYLOAD);
+        throw refusal('badPayload');
     return inflated;
 }

package/dist/drawio-import.d.ts

@@ -1,5 +1,5 @@
 import type { InterchangeNote } from '@formicoidea/labre-core/blocks/surface';
-import type { UmlBox } from './component.js';
+import { type UmlBox } from './component.js';
 import type { UmlModel } from './model.js';
 /**
  * A draw.io drawing, read as a UML model — the **visual** tier of

package/dist/drawio-import.js

@@ -1,9 +1,11 @@
-import { UML_DIAGRAM_KIND_TAG } from '@formicoidea/labre-core/model';
+import { UML_DIAGRAM_KIND_TAG } from '@formicoidea/labre-core/model/headless';
+import { umlComponentSiblings, } from './component.js';
 import { UML_NODE_BOX } from './consts.js';
 import { parseEndLabel, parseLifelineIdent, parseOperation, parseProperty, } from './grammar.js';
 import { umlSequenceSlot } from './import.js';
 import { stereotypesOf } from './keywords.js';
-import { ADORNED_RELATION_KINDS, umlLifelineAt } from './model.js';
+import { ADORNED_RELATION_KINDS, umlLifelineAt, umlRelationKindOfRole, } from './model.js';
+import { UML_ROLE } from './roles.js';
 import { decodeXmlText, readXml, xmlDescendants, } from './xml-reader.js';
 /** The format id foreign draw.io matter rides under (`docs/adr/0012` D2). */
 export const UML_DRAWIO_FORMAT_ID = 'drawio';
@@ -52,7 +54,6 @@ function parseStyle(raw) {
 /* ── The label HTML ───────────────────────────────────────────────────── */
 const HR = /<hr\s*\/?>/i;
 const LINE_BREAK = /<br\s*\/?>|<\/p>|<\/div>|<\/li>|<\/tr>/gi;
-const TAGS = /<[^>]*>/g;
 /**
  * Annex C's ASCII guillemets, rescued before the markup strip runs.
  *
@@ -64,6 +65,26 @@ const TAGS = /<[^>]*>/g;
  * the string the tag strip then walks.
  */
 const ASCII_GUILLEMETS = /<<([^<>]{0,64})>>/g;
+/**
+ * The text with every `<…>` taken out — what `/<[^>]*>/g` did, without its
+ * re-scan of the rest of the label from every `<` that never closes (quadratic
+ * on a label of repeated `<`, counter-review of 49aa247ce). An unclosed `<`
+ * stays, as it did.
+ */
+function stripTags(text) {
+    const kept = [];
+    let from = 0;
+    for (;;) {
+        const open = text.indexOf('<', from);
+        const close = open < 0 ? -1 : text.indexOf('>', open);
+        if (close < 0)
+            break;
+        kept.push(text.slice(from, open));
+        from = close + 1;
+    }
+    kept.push(text.slice(from));
+    return kept.join('');
+}
 /** The one entity `decodeXmlText` leaves standing that a LABEL routinely has. */
 const NBSP = /&nbsp;/gi;
 /**
@@ -92,11 +113,7 @@ export function drawioCompartments(value) {
         return [];
     return raw
         .split(HR)
-        .map(part => decodeXmlText(part
-        .replaceAll(LINE_BREAK, '\n')
-        .replaceAll(ASCII_GUILLEMETS, '«$1»')
-        .replaceAll(TAGS, '')
-        .replaceAll(NBSP, ' '))
+        .map(part => decodeXmlText(stripTags(part.replaceAll(LINE_BREAK, '\n').replaceAll(ASCII_GUILLEMETS, '«$1»')).replaceAll(NBSP, ' '))
         .split('\n')
         .map(line => line.trim())
         .filter(line => line.length > 0 && line !== '...' && line !== '…'))
@@ -314,6 +331,37 @@ function labelEndOf(geometry) {
         return 'centre';
     return x < 0 ? 'source' : 'target';
 }
+/* ── What Labre's own writer says ─────────────────────────────────────── */
+/**
+ * The UML node roles a drawing written by Labre's canvas (`canvas:drawio:export`,
+ * `docs/adr/0019` amendment of 2026-10-14) names in its `labre-role`
+ * attributes, and what each one is drawn as here.
+ *
+ * That writer is GENERIC: a classifier leaves as a draw.io group holding the
+ * shape and one text per compartment, each cell carrying the role it had on
+ * the canvas — exactly the arrangement `component.ts` builds, resolved by
+ * {@link umlComponentSiblings}, the function that reads it off the canvas. So
+ * where a role says what a cell IS, it is read instead of guessed from a style
+ * string; everywhere else (a role this table does not list, or a file another
+ * tool wrote) the style heuristics below answer as before. Still the visual
+ * tier: a role is a claim the file makes, and a hand-edited file can make a
+ * false one at no cost but its own drawing (ADR 0032's argument for the SVG
+ * markers).
+ *
+ * Only the kinds this reader already materialises: anything else a role names
+ * is left to the style and, failing that, carried.
+ */
+const LABRE_NODE_KINDS = Object.assign(Object.create(null), {
+    [UML_ROLE.class]: { kind: 'classifier', classifier: 'class' },
+    [UML_ROLE.interface]: { kind: 'classifier', classifier: 'interface' },
+    [UML_ROLE.enumeration]: { kind: 'classifier', classifier: 'enumeration' },
+    [UML_ROLE.actor]: { kind: 'actor' },
+    [UML_ROLE['use-case']]: { kind: 'use-case' },
+    [UML_ROLE.note]: { kind: 'note' },
+    [UML_ROLE.package]: { kind: 'package' },
+});
+/** A cell's label as plain lines — the compartments, flattened. */
+const plainLines = (value) => drawioCompartments(value).flat();
 /**
  * The `<mxCell>`s of a document, flattened, `<object>` wrappers folded in.
  *
@@ -341,6 +389,7 @@ function cellsOf(graph) {
         return {
             id: wrapper?.attrs.id ?? node.attrs.id ?? '',
             value: wrapper?.attrs.label ?? node.attrs.value ?? '',
+            labreRole: wrapper?.attrs['labre-role'] ?? '',
             style: parseStyle(rawStyle),
             rawStyle,
             parent: node.attrs.parent ?? '',
@@ -430,6 +479,74 @@ export function importDrawio(xml, options = {}) {
         else
             childrenOf.set(cell.parent, [cell]);
     }
+    // ── A draw.io `group`'s children sit in its coordinates ──────────────
+    //
+    // The one nesting this reader resolves for every cell: draw.io writes a
+    // grouped cell relative to its group, and Labre's own writer groups every
+    // framework artefact. (A lifeline's bar is resolved below, by its own rule.)
+    const groupOffset = (cell) => {
+        let x = 0;
+        let y = 0;
+        let at = byId.get(cell.parent);
+        for (let hops = 0; at?.vertex && 'group' in at.style && hops < 64; hops++) {
+            const parsed = (name) => Number.parseFloat(at?.geometry?.attrs[name] ?? '0');
+            if (Number.isFinite(parsed('x')))
+                x += parsed('x');
+            if (Number.isFinite(parsed('y')))
+                y += parsed('y');
+            at = byId.get(at.parent);
+        }
+        return { x, y };
+    };
+    // ── Labre's own components: a group, a roled shape, its roled words ────
+    //
+    // Read with the canvas's own resolution (`umlComponentSiblings`): the shape
+    // says what the artefact IS, the texts say what is written in which
+    // compartment, and the group and the texts are absorbed into the one
+    // artefact rather than carried as three unknown shapes.
+    const labreComponents = new Map();
+    const absorbed = new Set();
+    for (const cell of cells) {
+        if (!cell.vertex || !cell.id || !('group' in cell.style))
+            continue;
+        const members = (childrenOf.get(cell.id) ?? []).filter(child => child.vertex && child.id);
+        const component = umlComponentSiblings({ id: cell.id, childIds: members.map(member => member.id) }, members.map(member => ({
+            id: member.id,
+            ...(member.labreRole ? { role: member.labreRole } : {}),
+            text: plainLines(member.value).join('\n'),
+        })));
+        const node = component.node;
+        const recognised = node?.role ? LABRE_NODE_KINDS[node.role] : undefined;
+        if (!node || !recognised)
+            continue;
+        const linesOf = (tier) => tier
+            ? String(tier.text ?? '')
+                .split('\n')
+                .filter(Boolean)
+            : [];
+        const heading = linesOf(component.name ?? component.label ?? component.ident);
+        labreComponents.set(node.id, {
+            ...recognised,
+            compartments: [
+                heading.length > 0
+                    ? heading
+                    : plainLines(byId.get(node.id)?.value ?? ''),
+                linesOf(component.attributes),
+                linesOf(component.operations),
+            ],
+        });
+        absorbed.add(cell.id);
+        for (const tier of [
+            component.name,
+            component.attributes,
+            component.operations,
+            component.label,
+            component.ident,
+        ]) {
+            if (tier)
+                absorbed.add(tier.id);
+        }
+    }
     const classifiers = [];
     const actors = [];
     const useCases = [];
@@ -457,17 +574,25 @@ export function importDrawio(xml, options = {}) {
         // draw.io's two invisible roots — the model and its default layer.
         if (cell.id === '0' || cell.id === '1')
             continue;
+        // A Labre component's group and words: read with its shape, below.
+        if (absorbed.has(cell.id))
+            continue;
         // A member row of a stack-laid swimlane belongs to its lane, not the sheet.
         const host = byId.get(cell.parent);
         if (host?.vertex && 'swimlane' in host.style)
             continue;
         const children = (childrenOf.get(cell.id) ?? []).filter(child => child.vertex);
-        const compartments = drawioCompartments(cell.value);
+        const labre = labreComponents.get(cell.id);
+        const compartments = labre?.compartments ?? drawioCompartments(cell.value);
         // §17.2.4's bar is drawn INSIDE the participant's container, so its
         // geometry is relative to it — the one place in this format where a box is
         // not already in sheet coordinates.
         const onLifeline = Boolean(host?.vertex) && spineOf.has(cell.parent);
-        const own = geometryOf(cell);
+        const offset = groupOffset(cell);
+        const drawn = geometryOf(cell);
+        const own = drawn
+            ? { ...drawn, x: drawn.x + offset.x, y: drawn.y + offset.y }
+            : undefined;
         // The PARENT's own `mxGeometry`, not the box this reader gave it: a
         // lifeline's box is rewritten below to the narrow column our element is,
         // and a child's coordinates are relative to the CELL draw.io drew.
@@ -479,11 +604,12 @@ export function importDrawio(xml, options = {}) {
         const geometry = own && parentBox
             ? { ...own, x: own.x + parentBox.x, y: own.y + parentBox.y }
             : own;
-        const kind = vertexKindOf(cell.style, compartments, children.length > 0, {
-            value: cell.value,
-            onLifeline,
-            width: own?.w ?? 0,
-        });
+        const kind = labre?.kind ??
+            vertexKindOf(cell.style, compartments, children.length > 0, {
+                value: cell.value,
+                onLifeline,
+                width: own?.w ?? 0,
+            });
         if (geometry)
             boxes[cell.id] = geometry;
         if (kind === 'unknown') {
@@ -609,7 +735,7 @@ export function importDrawio(xml, options = {}) {
                     operations.push(...(compartments[2] ?? []));
                 classifiers.push({
                     ...base,
-                    kind: classifierKindOf(header.keywords),
+                    kind: labre?.classifier ?? classifierKindOf(header.keywords),
                     attributes: attributes.map(line => parseProperty(line)),
                     operations: operations.map(line => parseOperation(line)),
                     slots: [],
@@ -656,9 +782,14 @@ export function importDrawio(xml, options = {}) {
             continue;
         }
         const label = stereotypesOf(drawioCompartments(cell.value).flat().join('\n'));
-        const flip = wholeIsTarget(cell.style);
+        // A role Labre's writer stamped states the relationship, and its ends in
+        // the canvas's own direction (ADR 0010) — so it is read as stated and
+        // never flipped. A message role off a spine is not a relation here.
+        const roled = umlRelationKindOfRole(cell.labreRole || undefined);
+        const stated = roled && !roled.startsWith('message-') ? roled : undefined;
+        const flip = stated ? false : wholeIsTarget(cell.style);
         const relation = {
-            kind: relationKindOf(cell.style, label.keywords),
+            kind: stated ?? relationKindOf(cell.style, label.keywords),
             sourceId: flip ? cell.target : cell.source,
             targetId: flip ? cell.source : cell.target,
             ...(label.name ? { label: label.name } : {}),
@@ -666,7 +797,7 @@ export function importDrawio(xml, options = {}) {
         relations.push(relation);
         // A SOLID block head: read as the relationship it is, and named because the
         // file draws it wrong — see {@link isAmbiguousBlockHead}.
-        if (isAmbiguousBlockHead(cell.style)) {
+        if (!stated && isAmbiguousBlockHead(cell.style)) {
             notes.push({
                 kind: 'warning',
                 sourceId: cell.id,
@@ -836,8 +967,12 @@ function translate(boxes) {
     const entries = Object.entries(boxes);
     if (entries.length === 0)
         return boxes;
-    const minX = Math.min(...entries.map(([, box]) => box.x));
-    const minY = Math.min(...entries.map(([, box]) => box.y));
+    const minX = entries
+        .map(([, box]) => box.x)
+        .reduce((a, b) => Math.min(a, b), Infinity);
+    const minY = entries
+        .map(([, box]) => box.y)
+        .reduce((a, b) => Math.min(a, b), Infinity);
     // `Object.fromEntries` would give the moved bag a prototype back, and the ids
     // in it are still the file's — so it is filled by hand instead.
     const moved = Object.create(null);

package/dist/edge-styles.d.ts

@@ -1,4 +1,4 @@
-import { PointStyle, StrokeStyle } from '@formicoidea/labre-core/model';
+import { PointStyle, StrokeStyle } from '@formicoidea/labre-core/model/headless';
 /**
  * The UML line notation, as data — read by the TOOL that arms a fresh connector
  * (`actions.ts`) and by the MORPH that retypes one already drawn

package/dist/edge-styles.js

@@ -1,4 +1,4 @@
-import { PointStyle, StrokeStyle } from '@formicoidea/labre-core/model';
+import { PointStyle, StrokeStyle } from '@formicoidea/labre-core/model/headless';
 /**
  * The whole UML line notation, in one table — §11.5.4 (association, aggregation
  * and composition), §9.2.4 (generalization), §10.4.4 (interface realization),

package/dist/filename.js

@@ -1,4 +1,4 @@
-import { safeFilename } from '@formicoidea/labre-core/shared/utils';
+import { safeFilename } from '@formicoidea/labre-core/shared/headless';
 /**
  * A name a file system will accept, minus the extension: the shared
  * `safeFilename`, held to it by `safe-filename-parity.unit.spec.ts`.