@formicoidea/labre-framework-uml 0.42.0

package/dist/node/compartment-watcher.d.ts

@@ -0,0 +1,107 @@
+import { InteractivityExtension } from '@formicoidea/labre-core/std/gfx';
+/**
+ * Keeps a classifier's BOX big enough for the words in it.
+ *
+ * ## The overflow, and why a pure layout cannot fix it
+ *
+ * `umlCompartmentBoxes` lays a divided rectangle out from the rectangle alone:
+ * a margin, the name, a gap, THE LINE, three lines of attributes, THE SECOND
+ * LINE, and the operations take the rest (§11.4.4). Three attribute lines is
+ * what a fresh 200 × 120 class is sized for, and it is right until somebody
+ * types a fourth — at which point the fourth line is drawn over the separator
+ * under it, the fifth over the operations, and the box says nothing about it.
+ * Nothing in a rectangle can say otherwise: how many lines a tier holds is a
+ * fact about the TEXT.
+ *
+ * So the text is measured once, when an edit commits, and the two facts that
+ * follow from it are written: the node grows to the height the stack now needs
+ * (`umlStackHeight`), and the tiers move to the boxes that height yields. The
+ * separators follow for free — the renderer reads them off the tiers
+ * (`node-renderer.ts`), so the rule is drawn between the compartments as they
+ * ARE rather than where a default-sized stack would have put them. The measuring
+ * and the writing are {@link umlFitComponent}'s, shared with the morph.
+ *
+ * ## Why the seam is the SELECTION and not `elementUpdated`
+ *
+ * The same reason `C4TypeLineWatcher` gives, and it bites harder here. A canvas
+ * text editor binds its inline editor straight onto the element's `Y.Text`, so
+ * `surface.elementUpdated` fires once per KEYSTROKE: a re-layout on it would
+ * move the box under the caret on the way to the fourth line and again on the
+ * way back from it. The text editor holds an EDITING selection for as long as
+ * it is mounted and drops it when it closes, so an id LEAVING that set is a
+ * commit and nothing else is. One re-layout per edit, after the editor is gone,
+ * and a single undo entry for it.
+ *
+ * It is also the seam that puts the tier BACK. The canvas text editor
+ * shrink-wraps the element it is mounted on while the author types — it measures
+ * the rich text on every render and writes the element's `xywh` from it — so a
+ * tier left to itself ends an edit as a box the size of its words rather than as
+ * a compartment. Writing the layout after the editor has closed is what makes
+ * the compartment the last word.
+ *
+ * ## It grows, and never shrinks
+ *
+ * A box an author has dragged taller has dragged it taller FOR the operations
+ * (`component.ts`), and §11.4.4 hands the bottom compartment whatever is left on
+ * purpose — an author leaves themselves room to type. A watcher that reclaimed
+ * it the moment a line was deleted would be undoing a gesture nobody asked it to
+ * judge, and it would do so while the author was still working. So the height
+ * only ever goes UP; deleting lines moves the separators up (the tiers are
+ * re-laid either way) and leaves the box where it was put.
+ *
+ * ## Always-on, and local-only
+ *
+ * Registered by the RENDER half, not the flag-gated one (`docs/adr/0009`): it
+ * authors nothing — no element created, no field added — it keeps words that are
+ * ALREADY in the document readable, and a diagram drawn while the UML button was
+ * on must stay editable when it goes off.
+ *
+ * It is also inherently local, which is what stands in for the `local` guard
+ * every `elementUpdated` cascade needs (`docs/contribute/07-dev-practices.md`):
+ * the only input is THIS peer's selection. A remote peer typing five lines into
+ * a tier moves no editing selection here, so no re-layout is attempted on their
+ * behalf and the fleet cannot re-apply one write each. An undo is the same story
+ * from the other side: it mounts no editor and closes none, so nothing leaves
+ * the editing set and the restored box stays restored.
+ */
+export declare class UmlCompartmentWatcher extends InteractivityExtension {
+    static key: string;
+    private _subscription;
+    private _editing;
+    mounted(): void;
+    unmounted(): void;
+    /**
+     * Re-fit the classifier the committed tier belongs to.
+     *
+     * This is the TRIGGER and nothing else: what was committed has to be one of
+     * the tiers a classifier's stack is made of, or there is nothing about the
+     * layout for an edit to have changed. Everything past that — resolving the
+     * component, measuring the words, growing the box — is {@link umlFitComponent},
+     * which the morph reaches for too (`morph.ts`) so a keyword line written by a
+     * "Change type" lands in a compartment as surely as a typed one does.
+     */
+    private _fit;
+}
+/**
+ * Which ids just stopped being edited, and what is being edited now.
+ *
+ * Deliberately a copy of `c4EditingTransition` rather than a shared helper: the
+ * framework packs are independent by design (`docs/adr/0015`), this is nine
+ * lines of set arithmetic, and a framework module importing another framework
+ * module for it would be the first such edge in the library. If a third pack
+ * needs it, `std/gfx` is where it moves — not into whichever pack wrote it
+ * first.
+ *
+ * Pure, and exported, because it is the whole of the seam's logic and the only
+ * part of it worth being wrong about: an id that appears in the new editing set
+ * has merely STARTED, an id in both is still going, and only one that has LEFT
+ * is a commit. Total over an empty selection, which is what arrives when the
+ * editor closes onto bare canvas.
+ */
+export declare function umlEditingTransition(previous: ReadonlySet<string>, selections: readonly {
+    elements: readonly string[];
+    editing?: boolean;
+}[]): {
+    editing: Set<string>;
+    left: string[];
+};

package/dist/node/compartment-watcher.js

@@ -0,0 +1,163 @@
+import { InteractivityExtension } from '@formicoidea/labre-core/std/gfx';
+import { UML_ROLE } from '../roles.js';
+import { umlFitComponent } from './fit.js';
+/**
+ * The four tier roles an edit can commit into.
+ *
+ * `uml:lifeline-ident` is deliberately NOT among them, and it is the one tier
+ * this set leaves out: §17.3.4's head is painted at a fixed size across the top
+ * of a 16-wide column (`consts.ts`, `UML_LIFELINE_HEAD`), so no amount of typing
+ * in it can change the element's box — a lifeline resizes in HEIGHT and that is
+ * the spine's length, not the words'. Accepting it as a trigger would mean
+ * asking `umlStackHeight` a question it answers `null` to on every keystroke,
+ * which is the work this set exists to avoid.
+ */
+const TIER_ROLES = new Set([
+    UML_ROLE.name,
+    UML_ROLE.attributes,
+    UML_ROLE.operations,
+    // A glyph's single word. Accepted as a TRIGGER and almost always rejected a
+    // step later: a label belongs to a picture — an actor, a use case, a port —
+    // and `umlStackHeight` answers `null` for every one of them. It is in the set
+    // so a hand-built group (a label regrouped with a class box) is asked the
+    // question rather than silently skipped.
+    UML_ROLE.label,
+]);
+/**
+ * Keeps a classifier's BOX big enough for the words in it.
+ *
+ * ## The overflow, and why a pure layout cannot fix it
+ *
+ * `umlCompartmentBoxes` lays a divided rectangle out from the rectangle alone:
+ * a margin, the name, a gap, THE LINE, three lines of attributes, THE SECOND
+ * LINE, and the operations take the rest (§11.4.4). Three attribute lines is
+ * what a fresh 200 × 120 class is sized for, and it is right until somebody
+ * types a fourth — at which point the fourth line is drawn over the separator
+ * under it, the fifth over the operations, and the box says nothing about it.
+ * Nothing in a rectangle can say otherwise: how many lines a tier holds is a
+ * fact about the TEXT.
+ *
+ * So the text is measured once, when an edit commits, and the two facts that
+ * follow from it are written: the node grows to the height the stack now needs
+ * (`umlStackHeight`), and the tiers move to the boxes that height yields. The
+ * separators follow for free — the renderer reads them off the tiers
+ * (`node-renderer.ts`), so the rule is drawn between the compartments as they
+ * ARE rather than where a default-sized stack would have put them. The measuring
+ * and the writing are {@link umlFitComponent}'s, shared with the morph.
+ *
+ * ## Why the seam is the SELECTION and not `elementUpdated`
+ *
+ * The same reason `C4TypeLineWatcher` gives, and it bites harder here. A canvas
+ * text editor binds its inline editor straight onto the element's `Y.Text`, so
+ * `surface.elementUpdated` fires once per KEYSTROKE: a re-layout on it would
+ * move the box under the caret on the way to the fourth line and again on the
+ * way back from it. The text editor holds an EDITING selection for as long as
+ * it is mounted and drops it when it closes, so an id LEAVING that set is a
+ * commit and nothing else is. One re-layout per edit, after the editor is gone,
+ * and a single undo entry for it.
+ *
+ * It is also the seam that puts the tier BACK. The canvas text editor
+ * shrink-wraps the element it is mounted on while the author types — it measures
+ * the rich text on every render and writes the element's `xywh` from it — so a
+ * tier left to itself ends an edit as a box the size of its words rather than as
+ * a compartment. Writing the layout after the editor has closed is what makes
+ * the compartment the last word.
+ *
+ * ## It grows, and never shrinks
+ *
+ * A box an author has dragged taller has dragged it taller FOR the operations
+ * (`component.ts`), and §11.4.4 hands the bottom compartment whatever is left on
+ * purpose — an author leaves themselves room to type. A watcher that reclaimed
+ * it the moment a line was deleted would be undoing a gesture nobody asked it to
+ * judge, and it would do so while the author was still working. So the height
+ * only ever goes UP; deleting lines moves the separators up (the tiers are
+ * re-laid either way) and leaves the box where it was put.
+ *
+ * ## Always-on, and local-only
+ *
+ * Registered by the RENDER half, not the flag-gated one (`docs/adr/0009`): it
+ * authors nothing — no element created, no field added — it keeps words that are
+ * ALREADY in the document readable, and a diagram drawn while the UML button was
+ * on must stay editable when it goes off.
+ *
+ * It is also inherently local, which is what stands in for the `local` guard
+ * every `elementUpdated` cascade needs (`docs/contribute/07-dev-practices.md`):
+ * the only input is THIS peer's selection. A remote peer typing five lines into
+ * a tier moves no editing selection here, so no re-layout is attempted on their
+ * behalf and the fleet cannot re-apply one write each. An undo is the same story
+ * from the other side: it mounts no editor and closes none, so nothing leaves
+ * the editing set and the restored box stays restored.
+ */
+export class UmlCompartmentWatcher extends InteractivityExtension {
+    constructor() {
+        super(...arguments);
+        this._subscription = null;
+        this._editing = new Set();
+    }
+    static { this.key = 'uml-compartment-watcher'; }
+    mounted() {
+        this._subscription = this.gfx.selection.slots.updated.subscribe(selections => {
+            const { editing, left } = umlEditingTransition(this._editing, selections);
+            this._editing = editing;
+            for (const id of left)
+                this._fit(id);
+        });
+    }
+    unmounted() {
+        this._subscription?.unsubscribe();
+        this._subscription = null;
+        this._editing = new Set();
+        super.unmounted();
+    }
+    /**
+     * Re-fit the classifier the committed tier belongs to.
+     *
+     * This is the TRIGGER and nothing else: what was committed has to be one of
+     * the tiers a classifier's stack is made of, or there is nothing about the
+     * layout for an edit to have changed. Everything past that — resolving the
+     * component, measuring the words, growing the box — is {@link umlFitComponent},
+     * which the morph reaches for too (`morph.ts`) so a keyword line written by a
+     * "Change type" lands in a compartment as surely as a typed one does.
+     */
+    _fit(elementId) {
+        const surface = this.gfx.surface;
+        if (!surface)
+            return;
+        const tier = surface.getElementById(elementId);
+        if (!tier || tier.type !== 'text')
+            return;
+        if (tier.role === undefined || !TIER_ROLES.has(tier.role))
+            return;
+        umlFitComponent(surface, this.std.store, elementId);
+    }
+}
+/**
+ * Which ids just stopped being edited, and what is being edited now.
+ *
+ * Deliberately a copy of `c4EditingTransition` rather than a shared helper: the
+ * framework packs are independent by design (`docs/adr/0015`), this is nine
+ * lines of set arithmetic, and a framework module importing another framework
+ * module for it would be the first such edge in the library. If a third pack
+ * needs it, `std/gfx` is where it moves — not into whichever pack wrote it
+ * first.
+ *
+ * Pure, and exported, because it is the whole of the seam's logic and the only
+ * part of it worth being wrong about: an id that appears in the new editing set
+ * has merely STARTED, an id in both is still going, and only one that has LEFT
+ * is a commit. Total over an empty selection, which is what arrives when the
+ * editor closes onto bare canvas.
+ */
+export function umlEditingTransition(previous, selections) {
+    const editing = new Set();
+    for (const selection of selections) {
+        if (!selection.editing)
+            continue;
+        for (const id of selection.elements)
+            editing.add(id);
+    }
+    const left = [];
+    for (const id of previous)
+        if (!editing.has(id))
+            left.push(id);
+    return { editing, left };
+}

package/dist/node/fit.d.ts

@@ -0,0 +1,85 @@
+import type { UmlNodeKind } from '@formicoidea/labre-core/model';
+import { type SerializedXYWH, type XYWH } from '@formicoidea/labre-core/global/gfx';
+import { type UmlTierFace } from './tier-metrics.js';
+/**
+ * The little a fit needs of a canvas TEXT element.
+ *
+ * Structural, and not `TextElementModel`, for the reason `component.ts` states
+ * about `UmlComponentElement`: what is read here is an id, a role, a face,
+ * whatever the tier says and where it is — facts a fixture can state as plainly
+ * as a model can, which is what lets the decision below be tested without a Yjs
+ * document standing behind every box.
+ */
+export interface UmlTierElement extends UmlTierFace {
+    id: string;
+    type: string;
+    role?: string;
+    text?: unknown;
+    xywh: SerializedXYWH;
+    isLocked(): boolean;
+}
+/** …and of the SHAPE those words are about. */
+export interface UmlNodeShape {
+    id: string;
+    type: string;
+    kind: UmlNodeKind;
+    xywh: SerializedXYWH;
+    deserializedXYWH: XYWH;
+    isLocked(): boolean;
+}
+/** The surface a fit reads its elements off and writes its boxes back to. */
+export interface UmlFitSurface {
+    elementModels: readonly unknown[];
+    getElementById(id: string): unknown;
+}
+/**
+ * …and the store it writes THROUGH.
+ *
+ * Passed beside the surface rather than read off it because the two callers hold
+ * it differently — the watcher has `std.store`, the morph has the element's own
+ * `surface.store` — and because it is the whole of what a fit does to a
+ * document: one checkpoint, one transaction.
+ */
+export interface UmlFitStore {
+    readonly: boolean;
+    captureSync(): void;
+    transact(fn: () => void): void;
+}
+/**
+ * Re-fit the classifier a member belongs to: grow the node to the stack its
+ * tiers now need, and put the tiers into the compartments that height yields.
+ *
+ * ## One function, two callers, and why they are the same act
+ *
+ * `UmlCompartmentWatcher` calls it when an edit commits — the author typed a
+ * fourth attribute line and the box has to grow. `rewriteName` (`morph.ts`)
+ * calls it when a morph writes a KEYWORD LINE into the name compartment, which
+ * is the same overflow arriving by a different hand: morphing a class called
+ * `Ligne` to an interface turns one name line into two (`«interface»` over the
+ * name, §9.5.4) and, until the PO's recette of 14/09/2026, nothing re-laid the
+ * component — so the second line was painted straight through the rule under it.
+ *
+ * ## It grows, and never shrinks
+ *
+ * A box an author has dragged taller has dragged it taller FOR the operations
+ * (`component.ts`), and §11.4.4 hands the bottom compartment whatever is left on
+ * purpose — an author leaves themselves room to type. A fit that reclaimed it
+ * the moment a line was deleted would be undoing a gesture nobody asked it to
+ * judge. So the height only ever goes UP; deleting lines moves the separators up
+ * (the tiers are re-laid either way) and leaves the box where it was put.
+ *
+ * Every early return is a case where there is nothing honest to do, and writing
+ * nothing is the answer to all of them: a read-only document, a tier whose group
+ * was released, a group with no shape in it, a shape that is a picture rather
+ * than a divided box, a locked component, and — the common one — a stack that
+ * already fits, which is what every edit that did not change the painted line
+ * count produces.
+ *
+ * @param capture whether to open the fit's OWN undo entry. The watcher does
+ * (the layout is a consequence of an edit that has already been captured); the
+ * morph does not, because its re-layout belongs in the same single ctrl+z as the
+ * kind that made it necessary.
+ */
+export declare function umlFitComponent(surface: UmlFitSurface, store: UmlFitStore, memberId: string, { capture }?: {
+    capture?: boolean;
+}): void;

package/dist/node/fit.js

@@ -0,0 +1,129 @@
+import { Bound } from '@formicoidea/labre-core/global/gfx';
+import { umlCompartmentBoxes, umlComponentSiblings, umlGroupOf, umlStackHeight, UML_TIER_SIDE_INSET, umlTierLineCount, } from '../component.js';
+import { umlTierWrapper } from './tier-metrics.js';
+/**
+ * Re-fit the classifier a member belongs to: grow the node to the stack its
+ * tiers now need, and put the tiers into the compartments that height yields.
+ *
+ * ## One function, two callers, and why they are the same act
+ *
+ * `UmlCompartmentWatcher` calls it when an edit commits — the author typed a
+ * fourth attribute line and the box has to grow. `rewriteName` (`morph.ts`)
+ * calls it when a morph writes a KEYWORD LINE into the name compartment, which
+ * is the same overflow arriving by a different hand: morphing a class called
+ * `Ligne` to an interface turns one name line into two (`«interface»` over the
+ * name, §9.5.4) and, until the PO's recette of 14/09/2026, nothing re-laid the
+ * component — so the second line was painted straight through the rule under it.
+ *
+ * ## It grows, and never shrinks
+ *
+ * A box an author has dragged taller has dragged it taller FOR the operations
+ * (`component.ts`), and §11.4.4 hands the bottom compartment whatever is left on
+ * purpose — an author leaves themselves room to type. A fit that reclaimed it
+ * the moment a line was deleted would be undoing a gesture nobody asked it to
+ * judge. So the height only ever goes UP; deleting lines moves the separators up
+ * (the tiers are re-laid either way) and leaves the box where it was put.
+ *
+ * Every early return is a case where there is nothing honest to do, and writing
+ * nothing is the answer to all of them: a read-only document, a tier whose group
+ * was released, a group with no shape in it, a shape that is a picture rather
+ * than a divided box, a locked component, and — the common one — a stack that
+ * already fits, which is what every edit that did not change the painted line
+ * count produces.
+ *
+ * @param capture whether to open the fit's OWN undo entry. The watcher does
+ * (the layout is a consequence of an edit that has already been captured); the
+ * morph does not, because its re-layout belongs in the same single ctrl+z as the
+ * kind that made it necessary.
+ */
+export function umlFitComponent(surface, store, memberId, { capture = true } = {}) {
+    // A read-only document is READ: every write below would be refused, and
+    // nobody can have typed the line that would need one.
+    if (store.readonly)
+        return;
+    const element = (id) => (surface.getElementById(id) ?? null);
+    const groups = surface.elementModels.filter(model => model.type === 'group');
+    const group = umlGroupOf(memberId, groups);
+    if (!group)
+        return;
+    // The same pure resolution the exporter and the node view use — group
+    // membership, then roles — so the tiers moved here are the tiers the file
+    // comes out with.
+    const component = umlComponentSiblings(group, surface.elementModels);
+    const node = component.node && element(component.node.id);
+    if (!node || node.type !== 'umlNode')
+        return;
+    // `isLocked` walks the ancestors too, so this covers a locked GROUP as well
+    // as a locked shape — the two ways a reviewer freezes a component.
+    if (node.isLocked())
+        return;
+    const { kind } = node;
+    const [x, y, w, h] = node.deserializedXYWH;
+    // The width the tiers will be laid out at, which is the width their words are
+    // WRAPPED at — never the box a tier happens to wear right now, because the
+    // text editor shrink-wraps the element it is mounted on while the author
+    // types.
+    const tierWidth = w - w * UML_TIER_SIDE_INSET * 2;
+    const lines = (member) => {
+        if (!member)
+            return undefined;
+        const tier = element(member.id);
+        if (!tier || tier.type !== 'text')
+            return undefined;
+        return umlTierLineCount(tier.text, umlTierWrapper(tier, tierWidth));
+    };
+    const tiers = {
+        name: lines(component.name),
+        attributes: lines(component.attributes),
+        operations: lines(component.operations),
+    };
+    const required = umlStackHeight(kind, tiers);
+    // A picture, not a divided box: an actor's label has no stack to overflow,
+    // and there is no height at which a stick figure "fits" its name.
+    if (required === null)
+        return;
+    const height = Math.max(h, required);
+    const boxes = umlCompartmentBoxes(kind, x, y, w, height, tiers);
+    // Which tier goes in which box. `undefined` on either side is a component
+    // somebody took apart by hand, and it is simply skipped.
+    const moves = [
+        [component.name?.id, boxes.name],
+        [component.attributes?.id, boxes.attributes],
+        [component.operations?.id, boxes.operations],
+    ];
+    const writes = [];
+    if (height !== h) {
+        const xywh = new Bound(x, y, w, height).serialize();
+        writes.push(() => (node.xywh = xywh));
+    }
+    for (const [id, box] of moves) {
+        if (!id || !box)
+            continue;
+        const tier = element(id);
+        if (!tier || tier.type !== 'text' || tier.isLocked())
+            continue;
+        const xywh = new Bound(box.x, box.y, box.w, box.h).serialize();
+        if (tier.xywh === xywh)
+            continue;
+        writes.push(() => (tier.xywh = xywh));
+    }
+    // Nothing grew and nothing moved: the stack already fits, which is what most
+    // edits produce. An unchanged write would push an empty undo entry and cost
+    // the author a ctrl-Z for nothing.
+    if (writes.length === 0)
+        return;
+    // Its OWN undo entry when the caller asks for one, deliberately. The
+    // alternative — letting the writes merge into whatever the author last typed
+    // — makes the entry's contents depend on how long they paused before clicking
+    // away, and a layout that sometimes comes back with the words and sometimes
+    // does not is worse than one that always behaves the same.
+    if (capture)
+        store.captureSync();
+    // ONE transaction, so the growth and every move are ONE undo entry: an author
+    // who undoes it gets the whole layout back, rather than walking it back a tier
+    // at a time past a broken picture at every stop.
+    store.transact(() => {
+        for (const write of writes)
+            write();
+    });
+}

package/dist/node/node-renderer.d.ts

@@ -0,0 +1,49 @@
+import { type ElementRenderer } from '@formicoidea/labre-core/blocks/surface';
+import { type UmlNodeElementModel } from '@formicoidea/labre-core/model';
+import { type UmlCompartmentBoxes } from '../component.js';
+/**
+ * The half of {@link UmlCompartmentBoxes} the glyph layer draws from: where the
+ * separators go, and where the name is.
+ *
+ * The other two boxes are the TEXT ELEMENTS' business — they are the tiers, and
+ * they are already on the canvas — so a renderer holding them would be holding a
+ * second opinion about where words it does not draw ought to be.
+ */
+type UmlSeparators = Pick<UmlCompartmentBoxes, 'name' | 'splits'>;
+/**
+ * The compartment layout to stroke this node's separators from: the one its
+ * TIERS describe if they can be reached, and the default stack otherwise.
+ *
+ * ## Why the tiers and not the line counts
+ *
+ * `UmlCompartmentWatcher` grows a classifier whose attributes tier has
+ * overflowed and moves the three texts to the boxes the taller stack yields —
+ * so after an edit the compartments are no longer the default three-line stack a
+ * rectangle implies, and a renderer still drawing that stack would rule a line
+ * straight through the fourth attribute.
+ *
+ * It could be told the LINE COUNTS and recompute the same walk. It reads the
+ * tiers' own boxes instead, for two reasons. It is cheaper — `deserializedXYWH`
+ * is cached on the element, while a line count means materializing every tier's
+ * `Y.Text` into a string on every frame of every pan — and it cannot disagree
+ * with what the reader sees: a separator IS the boundary between two
+ * compartments, and reading the boundary off the compartments is the shortest
+ * possible route to that. An author who nudges a tier by hand takes the rule
+ * with them, which is the same answer.
+ *
+ * ## The ceiling
+ *
+ * ponytail: the tiers are read in the node's own unrotated frame, so a ROTATED
+ * `umlNode` falls back to the default stack. A UML group cannot be rotated
+ * (`GroupElementModel.rotate` is a constant 0), so this only reaches a shape
+ * somebody rotated out of its own group — at which point the words are not
+ * turning with it either and the picture is already the author's problem.
+ * Raising it means projecting each tier's box through `-rotate` about the
+ * node's centre, which is four lines nobody has asked for yet.
+ */
+export declare function umlNodeCompartments(model: UmlNodeElementModel, w: number, h: number): UmlSeparators;
+export declare const umlNode: ElementRenderer<UmlNodeElementModel>;
+export declare const UmlNodeRendererExtension: import("@formicoidea/labre-core/store/index.js").ExtensionType & {
+    identifier: import("@formicoidea/labre-core/_pkgs/global/di/types.js").ServiceIdentifier<ElementRenderer<UmlNodeElementModel>>;
+};
+export {};