@grafloria/element 0.3.18 → 0.3.20

package/src/libs/renderer/src/svg/LabelRenderer.d.ts

@@ -0,0 +1,76 @@
+import { type LinkLabel, type LinkModel, type Point } from '@grafloria/engine';
+import type { VNode } from '../types/vnode.types';
+import type { Theme } from '../types/theme.types';
+/** Default box for an HTML / template label (a `foreignObject` needs a size). */
+export declare const DEFAULT_HTML_LABEL_WIDTH = 120;
+export declare const DEFAULT_HTML_LABEL_HEIGHT = 28;
+/** Extra, per-frame context — none of it belongs on the persisted model. */
+export interface LabelRenderContext {
+    /**
+     * Card 7: the offset the edge optimizer settled on. Overrides `label.offset`
+     * when present (it IS `label.offset` for any label that did not opt into
+     * `autoOffset`).
+     */
+    offset?: Point;
+    theme?: Theme;
+}
+/**
+ * LabelRenderer generates SVG (or HTML) VNodes for link labels.
+ *
+ * Features:
+ * - Position labels at any point along path (0-1), or in one of three slots
+ * - Auto-rotation with path or fixed angle
+ * - Text wrapping with maxWidth
+ * - Multiple labels per link
+ * - Rich styling support
+ * - HTML content and author templates (Card 5)
+ *
+ * Architecture:
+ * Uses LinkModel utilities (getPointAtPosition, getAngleAt) for positioning.
+ * Returns VNode tree compatible with framework-agnostic rendering.
+ */
+export declare class LabelRenderer {
+    private readonly defaultFontSize;
+    private readonly defaultColor;
+    private readonly defaultPadding;
+    /**
+     * Render a label on a link
+     *
+     * @param label Label configuration
+     * @param link Link model for positioning calculations
+     * @param context Per-frame extras (optimizer offset, theme)
+     * @returns VNode representing the label, or null if invalid
+     */
+    renderLabel(label: LinkLabel, link: LinkModel, context?: LabelRenderContext): VNode | null;
+    /**
+     * Estimated on-screen box of a label, in LOCAL units (before the path anchor
+     * and offset are applied). The edge optimizer needs a box to test collisions
+     * against; HTML/template labels declare their own, and text labels are
+     * measured with the same estimator the background rect already uses.
+     */
+    labelBox(label: LinkLabel): {
+        width: number;
+        height: number;
+    };
+    /** Resolve `rotation: 'auto' | number` against the path, honouring keepUpright. */
+    private resolveRotation;
+    /**
+     * Render the label's text element (single-line or wrapped).
+     *
+     * Delegates to the shared, link-agnostic {@link renderTextBlock} engine —
+     * the same code path node labels use — so wrapping / multi-line / vertical
+     * alignment behave identically for both. The link label is drawn at the group
+     * origin (0,0); the enclosing <g> carries the position + rotation transform.
+     */
+    private renderText;
+    /**
+     * Estimate text width (approximate)
+     * For accurate measurement, this would need canvas measureText,
+     * but approximation is sufficient for most cases
+     */
+    private estimateTextWidth;
+    /**
+     * Calculate background X position based on text anchor
+     */
+    private getBackgroundX;
+}

package/src/libs/renderer/src/svg/LabelRenderer.js

@@ -0,0 +1,273 @@
+"use strict";
+// LabelRenderer.ts
+// Renders labels on link paths (Phase 1.2)
+//
+// Wave 4 (Edges & links), Card 5 — this used to be SVG-`<text>`-ONLY. It can now
+// also emit:
+//   • ARBITRARY HTML, in a `foreignObject` (the same seam nodes already use),
+//   • a registered LABEL TEMPLATE (author code returning VNodes),
+// and it understands the three edge SLOTS (start / center / end) that ngx-vflow
+// ships, so authors stop hand-computing `position` fractions.
+//
+// Wave 4, Card 7 — the label's OFFSET may be overridden by the diagram-wide edge
+// optimizer, which moves `autoOffset` labels off nodes/labels/links. The
+// override is passed in rather than read from the model, because it is a
+// per-frame placement decision, not persisted state.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LabelRenderer = exports.DEFAULT_HTML_LABEL_HEIGHT = exports.DEFAULT_HTML_LABEL_WIDTH = void 0;
+const engine_1 = require("@grafloria/engine");
+const text_block_1 = require("./text-block");
+const edge_templates_1 = require("./edge-templates");
+/** Default box for an HTML / template label (a `foreignObject` needs a size). */
+exports.DEFAULT_HTML_LABEL_WIDTH = 120;
+exports.DEFAULT_HTML_LABEL_HEIGHT = 28;
+/**
+ * LabelRenderer generates SVG (or HTML) VNodes for link labels.
+ *
+ * Features:
+ * - Position labels at any point along path (0-1), or in one of three slots
+ * - Auto-rotation with path or fixed angle
+ * - Text wrapping with maxWidth
+ * - Multiple labels per link
+ * - Rich styling support
+ * - HTML content and author templates (Card 5)
+ *
+ * Architecture:
+ * Uses LinkModel utilities (getPointAtPosition, getAngleAt) for positioning.
+ * Returns VNode tree compatible with framework-agnostic rendering.
+ */
+class LabelRenderer {
+    constructor() {
+        this.defaultFontSize = 12;
+        this.defaultColor = '#000000';
+        this.defaultPadding = 4;
+    }
+    /**
+     * Render a label on a link
+     *
+     * @param label Label configuration
+     * @param link Link model for positioning calculations
+     * @param context Per-frame extras (optimizer offset, theme)
+     * @returns VNode representing the label, or null if invalid
+     */
+    renderLabel(label, link, context = {}) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        const position = (0, engine_1.linkLabelPosition)(label);
+        // Get position on path
+        const point = link.getPointAtPosition(position);
+        if (!point) {
+            return null; // No valid position
+        }
+        // Apply offset — the optimizer's, when it placed this label (Card 7).
+        const offset = (_b = (_a = context.offset) !== null && _a !== void 0 ? _a : label.offset) !== null && _b !== void 0 ? _b : { x: 0, y: 0 };
+        const finalX = point.x + offset.x;
+        const finalY = point.y + offset.y;
+        // Calculate rotation
+        const rotation = this.resolveRotation(label, link, position);
+        // --- Card 5: an author TEMPLATE replaces everything below ---------------
+        if (label.template) {
+            const template = (0, edge_templates_1.getLabelTemplate)(label.template);
+            if (template) {
+                const ctx = {
+                    label,
+                    link,
+                    anchor: { x: finalX, y: finalY },
+                    rotation,
+                    // The theme is optional on this path only because renderLabel is a
+                    // public API older than themes-on-labels; the renderer always passes it.
+                    theme: context.theme,
+                };
+                const produced = template(ctx);
+                if (!produced)
+                    return null;
+                const children = Array.isArray(produced) ? produced : [produced];
+                return {
+                    type: 'g',
+                    key: `link-label-${label.id}`,
+                    props: { className: 'link-label-group link-label-template' },
+                    children,
+                };
+            }
+            // Unregistered template name: fall through to the built-in rendering
+            // rather than silently dropping the label.
+        }
+        // --- Card 5: raw HTML in a foreignObject --------------------------------
+        if (label.html !== undefined) {
+            const width = (_c = label.width) !== null && _c !== void 0 ? _c : exports.DEFAULT_HTML_LABEL_WIDTH;
+            const height = (_d = label.height) !== null && _d !== void 0 ? _d : exports.DEFAULT_HTML_LABEL_HEIGHT;
+            const fo = (0, edge_templates_1.htmlLabelVNode)({
+                id: label.id,
+                html: label.html,
+                anchor: { x: finalX, y: finalY },
+                width,
+                height,
+            });
+            // Rotation rides on a wrapper <g>: a foreignObject positions itself with
+            // x/y, so rotating it directly would rotate about the SVG origin.
+            return {
+                type: 'g',
+                key: `link-label-${label.id}`,
+                props: Object.assign({ className: 'link-label-group link-label-html-group' }, (rotation !== undefined
+                    ? { transform: `rotate(${rotation}, ${finalX}, ${finalY})` }
+                    : {})),
+                children: [fo],
+            };
+        }
+        // --- built-in SVG text --------------------------------------------------
+        // Build transform
+        let transform = `translate(${finalX}, ${finalY})`;
+        if (rotation !== undefined) {
+            transform += ` rotate(${rotation})`;
+        }
+        // Get style properties
+        const fontSize = (_f = (_e = label.style) === null || _e === void 0 ? void 0 : _e.fontSize) !== null && _f !== void 0 ? _f : this.defaultFontSize;
+        const fontFamily = (_g = label.style) === null || _g === void 0 ? void 0 : _g.fontFamily;
+        const color = (_j = (_h = label.style) === null || _h === void 0 ? void 0 : _h.color) !== null && _j !== void 0 ? _j : this.defaultColor;
+        // A label rides ON the stroke — without a chip the line strikes straight
+        // through the text (the screenshot audit caught exactly that). Default to
+        // the theme's canvas surface so the chip reads as "the line passes behind";
+        // `background: 'none'` opts back out.
+        const themedSurface = (_k = context.theme) === null || _k === void 0 ? void 0 : _k.colors.background.surface;
+        const rawBackground = (_m = (_l = label.style) === null || _l === void 0 ? void 0 : _l.background) !== null && _m !== void 0 ? _m : themedSurface;
+        const background = rawBackground === 'none' ? undefined : rawBackground;
+        const padding = (_p = (_o = label.style) === null || _o === void 0 ? void 0 : _o.padding) !== null && _p !== void 0 ? _p : this.defaultPadding;
+        const borderRadius = (_r = (_q = label.style) === null || _q === void 0 ? void 0 : _q.borderRadius) !== null && _r !== void 0 ? _r : 3;
+        // Build children array
+        const children = [];
+        // Add background if specified
+        if (background) {
+            // Estimate text dimensions for background
+            const textWidth = this.estimateTextWidth(label.text, fontSize);
+            const textHeight = fontSize;
+            const bgRect = {
+                type: 'rect',
+                props: {
+                    x: this.getBackgroundX(label.textAnchor, textWidth, padding),
+                    y: -textHeight / 2 - padding,
+                    width: textWidth + padding * 2,
+                    height: textHeight + padding * 2,
+                    fill: background,
+                    stroke: (_s = label.style) === null || _s === void 0 ? void 0 : _s.border,
+                    rx: borderRadius,
+                    className: 'link-label-bg'
+                }
+            };
+            children.push(bgRect);
+        }
+        // Build text element
+        const textVNode = this.renderText(label, fontSize, fontFamily, color);
+        children.push(textVNode);
+        // Return group container
+        return {
+            type: 'g',
+            key: `link-label-${label.id}`,
+            props: {
+                transform,
+                className: 'link-label-group'
+            },
+            children
+        };
+    }
+    /**
+     * Estimated on-screen box of a label, in LOCAL units (before the path anchor
+     * and offset are applied). The edge optimizer needs a box to test collisions
+     * against; HTML/template labels declare their own, and text labels are
+     * measured with the same estimator the background rect already uses.
+     */
+    labelBox(label) {
+        var _a, _b, _c, _d, _e, _f;
+        if (label.html !== undefined || label.template) {
+            return {
+                width: (_a = label.width) !== null && _a !== void 0 ? _a : exports.DEFAULT_HTML_LABEL_WIDTH,
+                height: (_b = label.height) !== null && _b !== void 0 ? _b : exports.DEFAULT_HTML_LABEL_HEIGHT,
+            };
+        }
+        const fontSize = (_d = (_c = label.style) === null || _c === void 0 ? void 0 : _c.fontSize) !== null && _d !== void 0 ? _d : this.defaultFontSize;
+        const padding = (_f = (_e = label.style) === null || _e === void 0 ? void 0 : _e.padding) !== null && _f !== void 0 ? _f : this.defaultPadding;
+        return {
+            width: this.estimateTextWidth(label.text, fontSize) + padding * 2,
+            height: fontSize + padding * 2,
+        };
+    }
+    /** Resolve `rotation: 'auto' | number` against the path, honouring keepUpright. */
+    resolveRotation(label, link, position) {
+        if (label.rotation === 'auto') {
+            const angle = link.getAngleAt(position);
+            if (angle === null)
+                return undefined;
+            let rotation = angle;
+            // Apply rotation offset
+            if (label.rotationOffset) {
+                rotation += label.rotationOffset;
+            }
+            // Keep upright logic
+            if (label.keepUpright) {
+                // Normalize angle to -180 to 180
+                while (rotation > 180)
+                    rotation -= 360;
+                while (rotation < -180)
+                    rotation += 360;
+                // Flip if upside down (angle > 90 or < -90)
+                if (rotation > 90) {
+                    rotation -= 180;
+                }
+                else if (rotation < -90) {
+                    rotation += 180;
+                }
+            }
+            return rotation;
+        }
+        if (typeof label.rotation === 'number') {
+            return label.rotation;
+        }
+        return undefined;
+    }
+    /**
+     * Render the label's text element (single-line or wrapped).
+     *
+     * Delegates to the shared, link-agnostic {@link renderTextBlock} engine —
+     * the same code path node labels use — so wrapping / multi-line / vertical
+     * alignment behave identically for both. The link label is drawn at the group
+     * origin (0,0); the enclosing <g> carries the position + rotation transform.
+     */
+    renderText(label, fontSize, fontFamily, color) {
+        var _a, _b;
+        return (0, text_block_1.renderTextBlock)({
+            text: label.text,
+            x: 0,
+            y: 0,
+            maxWidth: label.textWrap ? label.maxWidth : undefined,
+            align: (_a = label.textAnchor) !== null && _a !== void 0 ? _a : 'middle',
+            valign: (_b = label.textBaseline) !== null && _b !== void 0 ? _b : 'middle',
+            fontSize,
+            fontFamily,
+            color,
+            className: 'link-label-text',
+        });
+    }
+    /**
+     * Estimate text width (approximate)
+     * For accurate measurement, this would need canvas measureText,
+     * but approximation is sufficient for most cases
+     */
+    estimateTextWidth(text, fontSize) {
+        // Rough estimate: average character width is ~0.6 of fontSize
+        return text.length * fontSize * 0.6;
+    }
+    /**
+     * Calculate background X position based on text anchor
+     */
+    getBackgroundX(textAnchor, textWidth, padding) {
+        switch (textAnchor) {
+            case 'start':
+                return -padding;
+            case 'end':
+                return -textWidth - padding;
+            case 'middle':
+            default:
+                return -textWidth / 2 - padding;
+        }
+    }
+}
+exports.LabelRenderer = LabelRenderer;
+//# sourceMappingURL=LabelRenderer.js.map

package/src/libs/renderer/src/svg/auto-size.d.ts

@@ -0,0 +1,76 @@
+import type { NodeModel } from '@grafloria/engine';
+import { type ShapeDefinition } from './shape-registry';
+/** The intrinsic content box a node needs (before shape-inset expansion). */
+export interface ContentSize {
+    width: number;
+    height: number;
+}
+export interface MeasureLabelOptions {
+    fontSize?: number;
+    /** Line-height multiplier. Default 1.2. */
+    lineHeight?: number;
+    /** Wrap the label to this content width; omit to measure it on one line. */
+    wrapWidth?: number;
+}
+/**
+ * The content box a label occupies: the widest wrapped line × the line count.
+ * Uses the same `estimateTextWidth` heuristic the label renderer wraps with, so
+ * the measured box and the rendered text agree about where lines break.
+ */
+export declare function measureLabelContent(text: string, opts?: MeasureLabelOptions): ContentSize;
+/**
+ * Invert a shape's `innerRect`: the OUTER width/height whose label box is at
+ * least `contentW × contentH`. `innerRect` is a monotone function of the outer
+ * size (fractional insets for curved shapes, additive padding for the rect
+ * default), so a few fixed-point steps converge — one step for the fractional
+ * shapes, a handful for additive padding.
+ */
+export declare function outerSizeForInner(def: ShapeDefinition, contentW: number, contentH: number, seed?: {
+    width: number;
+    height: number;
+}): {
+    width: number;
+    height: number;
+};
+export interface AutoSizeOptions {
+    fontSize?: number;
+    lineHeight?: number;
+    /**
+     * Global resizer minimums, applied only where the node declares no per-node
+     * min. Keeps auto-size and the interactive resizer on the same floor.
+     */
+    floorWidth?: number;
+    floorHeight?: number;
+    /**
+     * Extra content a composite panel reserves around the label (Card 5). `top`
+     * stacks above the label (header band + image), `width` widens the content box
+     * to fit a horizontal row (icon + label + badge).
+     */
+    reserve?: {
+        top?: number;
+        bottom?: number;
+        width?: number;
+    };
+}
+/**
+ * Compute the desired OUTER size of an auto-sized node from its label + reserved
+ * panel content, clamped to the node's sizing constraints and any aspect lock.
+ * Pure — returns the size, mutates nothing.
+ */
+export declare function desiredNodeSize(node: NodeModel, opts?: AutoSizeOptions): {
+    width: number;
+    height: number;
+};
+/**
+ * Auto-size ONE node in place. No-op (returns false) when the node hasn't opted
+ * in, or is already within half a pixel of its desired size — the idempotence
+ * that keeps this safe to call every frame. Mutates strictly via `setSize`, so
+ * the spatial index + routing observe the new bounds.
+ */
+export declare function autoSizeNode(node: NodeModel, opts?: AutoSizeOptions): boolean;
+/**
+ * Auto-size every opted-in node in a diagram. Returns the count that changed —
+ * a host can skip a re-route when it is 0. Intended to run just before a frame
+ * so routing consumes the settled bounds.
+ */
+export declare function autoSizeDiagram(nodes: Iterable<NodeModel>, opts?: AutoSizeOptions): number;

package/src/libs/renderer/src/svg/auto-size.js

@@ -0,0 +1,142 @@
+"use strict";
+// Content-aware auto-sizing (Wave 5 / Nodes & shapes — Card 7)
+//
+// A node opted into auto-sizing (`metadata.sizing.auto`) reports a DESIRED size
+// that grows to fit its content: the wrapped label, plus any reserved space a
+// composite panel declares (Card 5 — header band, image, badges). The desired
+// content box is then expanded through the shape's `innerRect` inversion, so a
+// diamond/ellipse/cylinder gets enough OUTER size for the text to clear its
+// sloped/curved silhouette — not just a tight rectangle.
+//
+// The one hard rule (stated by the card): bounds changes go through the NORMAL
+// `node.setSize()` path, so the spatial index and the routing orchestrator that
+// reads it stay honest. `autoSizeNode` never pokes `node.size` directly and is
+// idempotent — once a node is at its target size it reports "no change" and
+// makes no mutation, so it cannot spin the render/route loop.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureLabelContent = measureLabelContent;
+exports.outerSizeForInner = outerSizeForInner;
+exports.desiredNodeSize = desiredNodeSize;
+exports.autoSizeNode = autoSizeNode;
+exports.autoSizeDiagram = autoSizeDiagram;
+const shape_registry_1 = require("./shape-registry");
+const text_block_1 = require("./text-block");
+const node_sizing_1 = require("./node-sizing");
+const DEFAULT_FONT_SIZE = 14;
+const DEFAULT_LINE_HEIGHT = 1.2;
+/**
+ * The content box a label occupies: the widest wrapped line × the line count.
+ * Uses the same `estimateTextWidth` heuristic the label renderer wraps with, so
+ * the measured box and the rendered text agree about where lines break.
+ */
+function measureLabelContent(text, opts = {}) {
+    var _a, _b;
+    const fontSize = (_a = opts.fontSize) !== null && _a !== void 0 ? _a : DEFAULT_FONT_SIZE;
+    const lineHeightPx = fontSize * ((_b = opts.lineHeight) !== null && _b !== void 0 ? _b : DEFAULT_LINE_HEIGHT);
+    if (!text)
+        return { width: 0, height: 0 };
+    const lines = (0, text_block_1.wrapText)(text, opts.wrapWidth, fontSize);
+    let widest = 0;
+    for (const line of lines)
+        widest = Math.max(widest, (0, text_block_1.estimateTextWidth)(line, fontSize));
+    return { width: widest, height: lines.length * lineHeightPx };
+}
+/**
+ * Invert a shape's `innerRect`: the OUTER width/height whose label box is at
+ * least `contentW × contentH`. `innerRect` is a monotone function of the outer
+ * size (fractional insets for curved shapes, additive padding for the rect
+ * default), so a few fixed-point steps converge — one step for the fractional
+ * shapes, a handful for additive padding.
+ */
+function outerSizeForInner(def, contentW, contentH, seed) {
+    var _a, _b;
+    let w = Math.max(1, (_a = seed === null || seed === void 0 ? void 0 : seed.width) !== null && _a !== void 0 ? _a : contentW, contentW);
+    let h = Math.max(1, (_b = seed === null || seed === void 0 ? void 0 : seed.height) !== null && _b !== void 0 ? _b : contentH, contentH);
+    for (let i = 0; i < 6; i++) {
+        const ir = (0, shape_registry_1.getInnerRect)(def, w, h);
+        const rw = ir.w > 0.01 ? contentW / ir.w : 1;
+        const rh = ir.h > 0.01 ? contentH / ir.h : 1;
+        if (rw <= 1.0001 && rh <= 1.0001)
+            break;
+        if (rw > 1)
+            w *= rw;
+        if (rh > 1)
+            h *= rh;
+    }
+    return { width: Math.ceil(w), height: Math.ceil(h) };
+}
+/**
+ * Compute the desired OUTER size of an auto-sized node from its label + reserved
+ * panel content, clamped to the node's sizing constraints and any aspect lock.
+ * Pure — returns the size, mutates nothing.
+ */
+function desiredNodeSize(node, opts = {}) {
+    var _a, _b, _c, _d, _e;
+    const sizing = (0, node_sizing_1.getNodeSizing)(node);
+    const def = (0, shape_registry_1.getShape)((node.getMetadata('shape') || { type: 'rect' }).type);
+    const pad = (_a = sizing.padding) !== null && _a !== void 0 ? _a : 8;
+    const label = node.getLabel();
+    const labelText = label === undefined || label === null ? '' : String(label);
+    // Wrap width: if a max width is set, wrap the label to fit inside it.
+    const wrapWidth = typeof sizing.maxWidth === 'number' ? Math.max(1, sizing.maxWidth - 2 * pad) : undefined;
+    const content = measureLabelContent(labelText, {
+        fontSize: opts.fontSize,
+        lineHeight: opts.lineHeight,
+        wrapWidth,
+    });
+    const reserve = (_b = opts.reserve) !== null && _b !== void 0 ? _b : {};
+    const contentW = Math.max(content.width, (_c = reserve.width) !== null && _c !== void 0 ? _c : 0) + 2 * pad;
+    const contentH = content.height + ((_d = reserve.top) !== null && _d !== void 0 ? _d : 0) + ((_e = reserve.bottom) !== null && _e !== void 0 ? _e : 0) + 2 * pad;
+    let { width, height } = outerSizeForInner(def, contentW, contentH, node.size);
+    // Aspect lock (grow the deficient axis so content still fits).
+    const aspect = (0, node_sizing_1.resolveAspectRatio)(sizing, node.size);
+    if (aspect && aspect > 0) {
+        if (width / height > aspect)
+            height = width / aspect;
+        else
+            width = height * aspect;
+    }
+    const clamped = (0, node_sizing_1.clampSizeToConstraints)(width, height, sizing, {
+        floorWidth: opts.floorWidth,
+        floorHeight: opts.floorHeight,
+    });
+    return { width: Math.ceil(clamped.width), height: Math.ceil(clamped.height) };
+}
+/**
+ * Auto-size ONE node in place. No-op (returns false) when the node hasn't opted
+ * in, or is already within half a pixel of its desired size — the idempotence
+ * that keeps this safe to call every frame. Mutates strictly via `setSize`, so
+ * the spatial index + routing observe the new bounds.
+ */
+function autoSizeNode(node, opts = {}) {
+    if (!(0, node_sizing_1.isAutoSized)(node))
+        return false;
+    const { width, height } = desiredNodeSize(node, opts);
+    if (Math.abs(width - node.size.width) < 0.5 &&
+        Math.abs(height - node.size.height) < 0.5) {
+        return false;
+    }
+    // Wave 9 — Card 7: a SYSTEM write. Auto-sizing measures the node's own content
+    // and writes the size the document ALREADY implies — it is not a user edit. A
+    // read-only/presentation diagram must still auto-size or it renders at the wrong
+    // dimensions, so this write is explicitly exempted from the read-only lock.
+    // (Detached nodes have no `diagram`; they are unlocked anyway.)
+    const write = () => node.setSize(width, height, node.size.depth);
+    node.diagram ? node.diagram.runSystemWrite(write) : write();
+    node.markDirty('auto-sized');
+    return true;
+}
+/**
+ * Auto-size every opted-in node in a diagram. Returns the count that changed —
+ * a host can skip a re-route when it is 0. Intended to run just before a frame
+ * so routing consumes the settled bounds.
+ */
+function autoSizeDiagram(nodes, opts = {}) {
+    let changed = 0;
+    for (const node of nodes) {
+        if (autoSizeNode(node, opts))
+            changed++;
+    }
+    return changed;
+}
+//# sourceMappingURL=auto-size.js.map

package/src/libs/renderer/src/svg/channel-nudging.d.ts

@@ -0,0 +1,34 @@
+/** Structural point — same shape link-fanout uses; no cross-lib import needed. */
+export interface NudgePoint {
+    x: number;
+    y: number;
+}
+export interface ChannelNudgeOptions {
+    /** Segments closer than this cluster into one corridor. */
+    trigger: number;
+    /** Distance between adjacent lanes after separation. */
+    spacing: number;
+}
+export interface ChannelNudgeResult {
+    /** linkId → (segment start index → ordinate delta) */
+    deltas: Map<string, Map<number, number>>;
+    /** corridors that produced lane assignments */
+    clustersNudged: number;
+    /** corridors skipped because two pinned members conflicted */
+    clustersSkipped: number;
+}
+/**
+ * Compute lane deltas for every corridor in the frame.
+ *
+ * `routes` are the frame's routed polylines (post same-pair fan-out); only
+ * links present in the map participate. The caller applies the deltas by
+ * sliding each segment along its normal — both endpoints move, the
+ * perpendicular neighbours stretch, orthogonality is preserved.
+ */
+export declare function computeChannelNudges(routes: ReadonlyMap<string, readonly NudgePoint[]>, options: ChannelNudgeOptions): ChannelNudgeResult;
+/**
+ * Apply a link's segment deltas to its polyline: each nudged segment's BOTH
+ * endpoints move along the ordinate axis, the perpendicular neighbours stretch.
+ * Returns a new array; the input is not mutated.
+ */
+export declare function applyChannelNudges(points: readonly NudgePoint[], deltas: ReadonlyMap<number, number> | undefined): NudgePoint[];