@tumaet/apollon 4.7.0 → 4.9.0

package/dist/internals.d.ts

@@ -24,6 +24,21 @@ declare function ActivityMergeNode({ id, width, height, data, parentId, }: NodeP
 
 declare function ActivityObjectNode({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX.Element | null;
 
+declare function ActivitySwimlane({ id, width, height, data, parentId, }: NodeProps<Node_2<ActivitySwimlaneProps>>): JSX.Element | null;
+
+/**
+ * Activity-partition (swimlane) container. Lanes are equal divisions along the
+ * primary axis (columns when vertical, rows when horizontal). Elements dropped
+ * into the swimlane become its children and move with it; which lane an element
+ * belongs to is expressed by where the modeller places it, matching the UML
+ * activity-partition notation where partition membership is positional rather
+ * than stored per element.
+ */
+declare type ActivitySwimlaneProps = DefaultNodeProps & {
+    orientation: "vertical" | "horizontal";
+    lanes: SwimlaneLane[];
+};
+
 declare type ApollonEdge = {
     id: string;
     source: string;
@@ -174,6 +189,7 @@ declare type CollaborationState = {
     viewport?: CollaborationViewport | null;
     followingClientId?: number | null;
     selectedElementId?: string | null;
+    draggingNodes?: DraggingNode[] | null;
 };
 
 declare type CollaborationUser = {
@@ -359,6 +375,7 @@ declare const diagramNodeTypes: {
     activityMergeNode: typeof ActivityMergeNode;
     activityForkNode: typeof ActivityForkNode;
     activityForkNodeHorizontal: typeof ActivityForkNodeHorizontal;
+    activitySwimlane: typeof ActivitySwimlane;
     useCase: typeof UseCase;
     useCaseActor: typeof UseCaseActor;
     useCaseSystem: typeof UseCaseSystem;
@@ -411,8 +428,24 @@ declare type DiagramStore = {
     canUndo: boolean;
     canRedo: boolean;
     undoManager: Y.UndoManager | null;
+    collaborationEnabled: boolean;
     previewMode: boolean;
     setDiagramId: (diagramId: string) => void;
+    setCollaborationEnabled: (enabled: boolean) => void;
+    /**
+     * Inject the sink that forwards transient drag/resize frames onto the
+     * ephemeral awareness channel (wired by `YjsSync` for every editor). Kept as
+     * runtime wiring rather than diagram state so a `reset()` never clears it.
+     * The broadcast itself is gated by `collaborationEnabled`, not by this sink;
+     * `null` (headless, where no `YjsSync` runs) just leaves it unwired.
+     */
+    setDraggingNodesPublisher: (publisher: ((draggingNodes: DraggingNode[] | null) => void) | null) => void;
+    /**
+     * Clear the peers' live-drag overlay once a gesture's settled value is
+     * committed. Called from `onNodeDragStop` (after the doc write) and on
+     * collaboration teardown; a no-op when nothing is being broadcast.
+     */
+    endTransientNodeBroadcast: () => void;
     setNodes: (payload: Node_2[] | ((nodes: Node_2[]) => Node_2[])) => void;
     setEdges: (payload: Edge[] | ((edges: Edge[]) => Edge[])) => void;
     setNodesAndEdges: (nodes: Node_2[], edges: Edge[]) => void;
@@ -445,6 +478,23 @@ declare type DiagramStore = {
     setPreviewMode: (active: boolean) => void;
 };
 
+/**
+ * One node a peer is actively dragging or resizing. Broadcast over the
+ * ephemeral awareness channel — never written to the Yjs document — so peers
+ * can render the in-progress gesture live without growing the CRDT or entering
+ * anyone's undo history. The settled position/size is committed once on
+ * drop/release through the document like any other edit.
+ */
+declare type DraggingNode = {
+    id: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    width?: number | null;
+    height?: number | null;
+};
+
 declare type ExtendedEdgeProps = EdgeProps<Edge<CustomEdgeProps>> & {
     markerEnd?: string;
     markerPadding?: number;
@@ -607,6 +657,19 @@ declare type SfcTransitionBranchNodeProps = DefaultNodeProps & {
     showHint?: boolean;
 };
 
+/** A single partition (lane) inside an activity swimlane. */
+declare type SwimlaneLane = {
+    id: string;
+    name: string;
+    /**
+     * Lane's extent along the swimlane's primary axis, in absolute flow px. The
+     * last lane is elastic (fills the remainder), so resizing the swimlane only
+     * changes the last lane. Optional: lanes without it divide the space equally,
+     * so existing saved swimlanes render as equal lanes until a separator moves.
+     */
+    size?: number;
+};
+
 declare function SyntaxTreeNonterminal({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX.Element | null;
 
 declare function SyntaxTreeTerminal({ id, width, height, data, parentId, }: NodeProps<Node_2<DefaultNodeProps>>): JSX.Element | null;
@@ -849,6 +912,7 @@ export declare class YjsSync {
     setLocalAwarenessViewport: (viewport: CollaborationViewport | null) => void;
     setLocalAwarenessFollowing: (followingClientId: number | null) => void;
     setLocalAwarenessSelectedElement: (selectedElementId: string | null) => void;
+    setLocalAwarenessDraggingNodes: (draggingNodes: DraggingNode[] | null) => void;
     setLocalAwarenessState: (state: Partial<CollaborationState>) => void;
     subscribeToAwarenessChanges: (callback: (states: Map<number, CollaborationState>) => void) => () => void;
     getAwarenessStates: () => Map<number, CollaborationState>;
@@ -870,7 +934,7 @@ export declare class YjsSync {
     /**
      * Convert Base64 string to Uint8Array
      */
-    private base64ToUint8;
+    static base64ToUint8(base64: string): Uint8Array;
 }
 
 export { }

package/dist/internals.js

@@ -1,6 +1,7 @@
-import { W as n, aE as r } from "./yjsSync-aPxjWNdZ.js";
-import { ab as p, aU as i, aV as u, aW as S, aX as g, aY as T, aZ as b, bo as F, bp as l, bq as v } from "./yjsSync-aPxjWNdZ.js";
-function V(t = new n()) {
+import { aD as r } from "./yjsSync-BCNFF_EI.js";
+import { a8 as m, aT as p, aU as g, aV as u, aW as S, aX as T, aY as b, bo as l, bp as F, bq as Y } from "./yjsSync-BCNFF_EI.js";
+import * as n from "yjs";
+function d(t = new n.Doc()) {
   const e = () => {
   }, a = {
     getState: () => ({
@@ -8,6 +9,7 @@ function V(t = new n()) {
       updateEdgesFromYjs: e,
       updateAssessmentFromYjs: e,
       updateUndoRedoState: e,
+      setDraggingNodesPublisher: e,
       undoManager: null
       // Other DiagramStore fields are typed but never accessed by
       // YjsSync; cast through `unknown` keeps the helper from
@@ -30,16 +32,16 @@ function V(t = new n()) {
   };
 }
 export {
-  p as MessageType,
+  m as MessageType,
   r as YjsSync,
-  i as convertV2ToV4,
-  u as convertV3EdgeTypeToV4,
-  S as convertV3HandleToV4,
-  g as convertV3MessagesToV4,
+  p as convertV2ToV4,
+  g as convertV3EdgeTypeToV4,
+  u as convertV3HandleToV4,
+  S as convertV3MessagesToV4,
   T as convertV3NodeTypeToV4,
   b as convertV3ToV4,
-  V as createHeadlessSync,
-  F as isV2Format,
-  l as isV3Format,
-  v as isV4Format
+  d as createHeadlessSync,
+  l as isV2Format,
+  F as isV3Format,
+  Y as isV4Format
 };

package/dist/react/apollon-editor.d.ts

@@ -1,5 +1,6 @@
 import { Node, Edge } from '@xyflow/react';
 import { UMLDiagramType } from './types';
+import { OverlayControlInput, OverlayRegion, OverlaySide } from './overlay/types';
 import { SendBroadcastMessage } from './sync/yjsSync';
 import * as Apollon from "./typings";
 export declare class ApollonEditor {
@@ -11,8 +12,8 @@ export declare class ApollonEditor {
     private readonly metadataStore;
     private readonly popoverStore;
     private readonly assessmentSelectionStore;
-    private readonly alignmentGuidesStore;
-    private readonly edgeGeometryStore;
+    private readonly overlayStore;
+    private readonly hostRegionEls;
     private subscribers;
     constructor(element: HTMLElement, options?: Apollon.ApollonOptions);
     private setReactFlowInstance;
@@ -31,10 +32,62 @@ export declare class ApollonEditor {
         x: number;
         y: number;
     }): import('@xyflow/react').XYPosition | null;
+    /**
+     * Zoom/pan so the whole diagram fits, capped at `maxZoom: 1.0`. Retries up to
+     * 10 animation frames until every node is measured.
+     * @param options.padding - Scalar fraction (default `0.15`), or per-side px
+     *   that adds to a 16px gutter. A per-side object forces the inset-aware path.
+     * @param options.duration - Animation duration in ms (default `200`).
+     * @param options.respectInsets - Pad the fit by reserved overlay insets
+     *   (header, rails, …). Default `true`.
+     */
     fitView(options?: {
-        padding?: number;
+        padding?: number | Partial<Record<OverlaySide, number>>;
         duration?: number;
+        /** Pad the fit by the reserved overlay insets (header, rails, …). */
+        respectInsets?: boolean;
     }): void;
+    /**
+     * Register a floating control, returning a disposer. Re-using an id replaces
+     * (idempotent / StrictMode-safe). Pick a façade: a React host →
+     * `<ApollonControl>`; a non-React host (or one that needs its own React
+     * root/context) → `getRegionElement` + `createPortal`; a one-off imperative
+     * widget → `addControl`.
+     * @param control - id, target region, a `render` thunk, and optional layout
+     *   options ({@link OverlayControlInput}).
+     * @returns A disposer that unregisters this control; safe to call twice.
+     * @throws If `id` is empty or `region` is not a known region — mistakes fail
+     *   loudly at the edge, not silently in the renderer.
+     */
+    addControl(control: OverlayControlInput): () => void;
+    /**
+     * Patch a registered control's options/renderer (a no-op if absent).
+     * @param id - The control's immutable id (an `id` in `patch` is ignored).
+     * @param patch - Partial options/renderer merged over the existing control.
+     */
+    updateControl(id: string, patch: Partial<OverlayControlInput>): void;
+    /**
+     * @param id - A control id.
+     * @returns `true` if a control with this id is currently registered.
+     */
+    hasControl(id: string): boolean;
+    /**
+     * A stable DOM node anchored in `region`, for hosts that render their own
+     * React into it (via `createPortal`) to keep host context. Auto-measured, so
+     * the diagram makes room for whatever the host mounts. Lifetime = the editor;
+     * `releaseRegionElement` unregisters it. Reserved id: `apollon:host:<region>`.
+     * @param region - The region to anchor the node in.
+     * @returns The same node for the lifetime of one acquire; `releaseRegionElement`
+     *   drops it and the next call returns a fresh node.
+     * @throws If `region` is not a known region.
+     */
+    getRegionElement(region: OverlayRegion): HTMLElement;
+    /**
+     * Release a region acquired via {@link getRegionElement} (unregister + drop
+     * the cached node); a later `getRegionElement(region)` creates a fresh node.
+     * @param region - The region whose host node to release.
+     */
+    releaseRegionElement(region: OverlayRegion): void;
     set diagramType(type: UMLDiagramType);
     destroy(): void;
     /** Renders a model to SVG via a hidden, off-screen mount. */

package/dist/react/components/AlignmentGuides.d.ts

@@ -1 +1 @@
-export declare const AlignmentGuides: () => import("react").JSX.Element | null;
+export declare const AlignmentGuides: () => import("react").JSX.Element;

package/dist/react/components/CustomControls.d.ts

@@ -1 +1,8 @@
+/**
+ * Bottom-left control cluster. Every button shares one idiom
+ * (`apollon-chrome-iconbtn`): borderless on the glass pane, state shown as a
+ * surface-layer fill. Reads left→right as view (zoom-out/in, fit, a clickable
+ * %-reset) then, past a hairline, history (undo/redo). React Flow renders its
+ * built-in zoom/fit buttons first; our children follow.
+ */
 export declare const CustomControls: () => import("react").JSX.Element;

package/dist/react/components/DraggableGhost.d.ts

@@ -3,6 +3,11 @@ import { DropElementConfig } from '../constants';
 interface DraggableGhostProps {
     children: React.ReactNode;
     dropElementConfig: DropElementConfig;
+    /**
+     * Visual scale of the palette preview.
+     * Used to convert pointer offsets into node-placement offsets.
+     */
+    previewScale?: number;
 }
 export declare const DraggableGhost: React.FC<DraggableGhostProps>;
 export {};

package/dist/react/components/popovers/PopoverManager.d.ts

@@ -1,4 +1,4 @@
-type NodePopoverType = "class" | "objectName" | "communicationObjectName" | "default" | "Component" | "ComponentSubsystem" | "FlowchartTerminal" | "FlowchartProcess" | "FlowchartDecision" | "FlowchartInputOutput" | "FlowchartFunctionCall" | "DeploymentComponent" | "DeploymentNode" | "SyntaxTreeNonterminal" | "SyntaxTreeTerminal" | "PetriNetPlace" | "BPMNTask" | "BPMNStartEvent" | "BPMNIntermediateEvent" | "BPMNEndEvent" | "BPMNGateway" | "BPMNSubprocess" | "BPMNTransaction" | "BPMNCallActivity" | "BPMNAnnotation" | "BPMNDataObject" | "BPMNDataStore" | "BPMNPool" | "BPMNGroup" | "ReachabilityGraphMarking" | "Sfc" | "SfcActionTable";
+type NodePopoverType = "class" | "objectName" | "communicationObjectName" | "default" | "Component" | "ComponentSubsystem" | "FlowchartTerminal" | "FlowchartProcess" | "FlowchartDecision" | "FlowchartInputOutput" | "FlowchartFunctionCall" | "DeploymentComponent" | "DeploymentNode" | "SyntaxTreeNonterminal" | "SyntaxTreeTerminal" | "PetriNetPlace" | "BPMNTask" | "BPMNStartEvent" | "BPMNIntermediateEvent" | "BPMNEndEvent" | "BPMNGateway" | "BPMNSubprocess" | "BPMNTransaction" | "BPMNCallActivity" | "BPMNAnnotation" | "BPMNDataObject" | "BPMNDataStore" | "BPMNPool" | "BPMNGroup" | "ReachabilityGraphMarking" | "Sfc" | "SfcActionTable" | "ActivitySwimlane";
 type EdgePopoverType = "ClassAggregation" | "ClassInheritance" | "ClassRealization" | "ClassComposition" | "ClassBidirectional" | "ClassUnidirectional" | "ClassDependency" | "ActivityControlFlow" | "ObjectLink" | "CommunicationLink" | "UseCaseAssociation" | "UseCaseInclude" | "UseCaseExtend" | "UseCaseGeneralization" | "ComponentDependency" | "ComponentProvidedInterface" | "ComponentRequiredInterface" | "ComponentRequiredThreeQuarterInterface" | "ComponentRequiredQuarterInterface" | "BPMNSequenceFlow" | "BPMNMessageFlow" | "BPMNAssociationFlow" | "BPMNDataAssociationFlow" | "DeploymentAssociation" | "DeploymentDependency" | "DeploymentProvidedInterface" | "DeploymentRequiredInterface" | "DeploymentRequiredThreeQuarterInterface" | "DeploymentRequiredQuarterInterface" | "FlowChartFlowline" | "SyntaxTreeLink" | "SfcDiagramEdge" | "ReachabilityGraphArc" | "PetriNetArc";
 type PopoverType = NodePopoverType | EdgePopoverType;
 interface PopoverManagerProps {

package/dist/react/components/popovers/activityDiagram/ActivitySwimlaneEditPopover.d.ts

@@ -0,0 +1,2 @@
+import { PopoverProps } from '../types';
+export declare const ActivitySwimlaneEditPopover: React.FC<PopoverProps>;

package/dist/react/components/popovers/activityDiagram/index.d.ts

@@ -0,0 +1 @@
+export { ActivitySwimlaneEditPopover } from './ActivitySwimlaneEditPopover';

package/dist/react/components/react/ApollonControl.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+import { OverlayControlOptions } from '../../overlay/types';
+/** Props for {@link ApollonControl}: every {@link OverlayControlOptions} field
+ *  (id, region, inset, order, …) plus the children to render in-canvas. */
+export type ApollonControlProps = OverlayControlOptions & {
+    /** Portaled into the control's host node inside the chosen region. Children
+     *  changes never re-register the control; only real option changes do. */
+    children: ReactNode;
+};
+/**
+ * Declarative façade over `editor.addControl`. Registers a control that renders
+ * a stable host node into the chosen region, and portals `children` into that
+ * node — so children render INSIDE the canvas while React owns their
+ * reconciliation. Children changes therefore never touch the overlay store; only
+ * real option changes (region/inset/order/…) push an update. Returns null in the
+ * host tree.
+ */
+export declare function ApollonControl({ children, ...options }: ApollonControlProps): ReactNode;

package/dist/react/components/svgs/nodes/InterfaceLabel.d.ts

@@ -0,0 +1,26 @@
+import { FC } from 'react';
+import { InterfaceLabelSide } from '../../../utils/geometry/interfaceLabelLayout';
+interface Props {
+    name?: string | null;
+    /** Interface circle bounds (always square — INTERFACE.SIZE). */
+    width: number;
+    height: number;
+    fill?: string;
+    /** Which side of the circle the name sits on. Defaults to "bottom"; the node
+     * component flips it away from sides a connecting edge attaches to (including
+     * a diagonal corner when every side is taken). */
+    side?: InterfaceLabelSide;
+}
+/**
+ * The provided/required interface name. Sits centered below the ball/socket by
+ * default; the node component moves it to whichever side — or, when all four
+ * sides have an edge, whichever diagonal corner — is clear of connecting edges.
+ * The name is rendered as real multi-line text (honouring line breaks) and is
+ * never auto-wrapped.
+ *
+ * Renders as SVG <text>/<tspan> in the node's overflow:visible region. The
+ * PNG/PDF/SVG export pipeline captures it via its node-text bbox scan
+ * (utils/exportUtils.ts), so it exports correctly without enlarging the viewBox.
+ */
+export declare const InterfaceLabel: FC<Props>;
+export {};

package/dist/react/components/svgs/nodes/activityDiagram/ActivitySwimlaneSVG.d.ts

@@ -0,0 +1,9 @@
+import { SVGComponentProps } from '../../../../types/SVG';
+import { ActivitySwimlaneProps } from '../../../../types';
+/** Thickness of the band that holds the lane name labels. */
+export declare const SWIMLANE_HEADER_SIZE = 30;
+interface ActivitySwimlaneSVGProps extends SVGComponentProps {
+    data: ActivitySwimlaneProps;
+}
+export declare const ActivitySwimlaneSVG: React.FC<ActivitySwimlaneSVGProps>;
+export {};

package/dist/react/components/svgs/nodes/activityDiagram/index.d.ts

@@ -6,3 +6,4 @@ export * from './ActivityObjectNodeSVG';
 export * from './ActivityMergeNodeSVG';
 export * from './ActivityForkNodeSVG';
 export * from './ActivityForkNodeHorizontalSVG';
+export * from './ActivitySwimlaneSVG';

package/dist/react/components/svgs/nodes/componentDiagram/ComponentInterfaceNodeSVG.d.ts

@@ -1,7 +1,9 @@
 import { SVGComponentProps } from '../../../../types/SVG';
 import { DefaultNodeProps } from '../../../../types';
+import { InterfaceLabelSide } from '../../../../utils/geometry/interfaceLabelLayout';
 interface Props extends SVGComponentProps {
     data: DefaultNodeProps;
+    labelSide?: InterfaceLabelSide;
 }
 export declare const ComponentInterfaceNodeSVG: React.FC<Props>;
 export {};

package/dist/react/components/svgs/nodes/deploymentDiagram/DeploymentInterfaceSVG.d.ts

@@ -1,7 +1,9 @@
 import { SVGComponentProps } from '../../../../types/SVG';
 import { DefaultNodeProps } from '../../../../types';
+import { InterfaceLabelSide } from '../../../../utils/geometry/interfaceLabelLayout';
 interface Props extends SVGComponentProps {
     data: DefaultNodeProps;
+    labelSide?: InterfaceLabelSide;
 }
 export declare const DeploymentInterfaceSVG: React.FC<Props>;
 export {};

package/dist/react/constants.d.ts

@@ -39,6 +39,16 @@ export declare const LAYOUT: Readonly<{
     readonly STEREOTYPE_LINE_HEIGHT: 15;
     readonly STEREOTYPE_NAME_GAP: 4;
 }>;
+/**
+ * Treat narrow portrait viewports and short phone-landscape viewports as
+ * mobile. The portrait bound stops just below 768px so iPads (768px portrait)
+ * keep the regular desktop layout; the second clause catches phones in
+ * landscape, where the short height distinguishes them from tablets.
+ *
+ * NOTE: mirrored in standalone/webapp/src/constants/responsive.ts (the webapp
+ * can't import the library's curated public surface). Keep both in sync.
+ */
+export declare const MOBILE_VIEW_QUERY = "(max-width: 767.95px), (max-width: 950px) and (max-height: 500px)";
 export declare const INTERFACE: Readonly<{
     readonly SIZE: 30;
     readonly RADIUS: number;
@@ -97,6 +107,19 @@ export declare const EDGES: Readonly<{
      * U-turn is never a deliberate edit, so this stays at the visual-merge
      * threshold rather than the per-step threshold. */
     readonly ORTHOGONAL_ARM_OVERLAP_PX: 10;
+    /** Perpendicular gap (flow px) between an edge's mid-segment line and the
+     * near edge of its relationship/stereotype label. The label sits this far
+     * off the line on whichever side is clearer. */
+    readonly LABEL_GAP: 14;
+    /** Nominal label line height (flow px) used as the across-text depth of the
+     * candidate box when scoring which side a label sits on. Constant by
+     * construction — placement never measures the rendered text (mirrors the
+     * messageLayout.ts invariant). */
+    readonly LABEL_LINE_HEIGHT: 14;
+    /** Nominal half-width (flow px) of a label along its text axis, used only to
+     * build the candidate box for side scoring. Coarse on purpose: we choose a
+     * side, not a pixel-perfect fit. */
+    readonly LABEL_NOMINAL_HALF_EXTENT: 40;
 }>;
 export declare const ZINDEX: Readonly<{
     readonly BASE: 0;
@@ -225,6 +248,11 @@ export type DropElementConfig = {
     readonly type: DiagramNodeType;
     readonly width: number;
     readonly height: number;
+    /** Size of the node when dropped on the canvas, if it should differ from the
+     * sidebar preview size (`width`/`height`). Lets a large element preview small
+     * in the palette without shrinking the rest of the picker. */
+    readonly dropWidth?: number;
+    readonly dropHeight?: number;
     readonly defaultData?: Record<string, unknown>;
     readonly svg: React.FC<any>;
     readonly marginTop?: number;

package/dist/react/edges/labelTypes/EdgeIncludeExtendLabel.d.ts

@@ -1,13 +1,10 @@
 import { IPoint } from '../Connection';
 interface EdgeIncludeExtendLabelsProps {
-    label?: string | null;
-    pathMiddlePosition: IPoint;
     sourcePoint?: IPoint;
     targetPoint?: IPoint;
-    isUseCasePath?: boolean;
     showRelationshipLabels?: boolean;
     relationshipType?: "include" | "extend";
     textColor?: string;
 }
-export declare const EdgeIncludeExtendLabel: ({ sourcePoint, targetPoint, showRelationshipLabels, relationshipType, textColor, }: EdgeIncludeExtendLabelsProps) => import("react").JSX.Element;
+export declare const EdgeIncludeExtendLabel: ({ sourcePoint, targetPoint, showRelationshipLabels, relationshipType, textColor, }: EdgeIncludeExtendLabelsProps) => import("react").JSX.Element | null;
 export {};

package/dist/react/edges/labelTypes/EdgeMiddleLabels.d.ts

@@ -1,15 +1,18 @@
 import { IPoint } from '../Connection';
+import { Rect } from '../../utils/geometry/edgeLabelLayout';
 interface EdgeMiddleLabelsProps {
     label?: string | null;
-    pathMiddlePosition: IPoint;
-    isMiddlePathHorizontal: boolean;
+    /** The edge's full rendered polyline (orthogonal edges). */
+    activePoints?: IPoint[];
     sourcePoint?: IPoint;
     targetPoint?: IPoint;
+    /** Every node the edge routes near, so the label avoids all of them. */
+    nodeRects?: Rect[];
+    neighborGeometry?: IPoint[][];
     showRelationshipLabels?: boolean;
     isUseCasePath?: boolean;
     isPetriNet?: boolean;
-    avoidToolbarOverlap?: boolean;
     textColor: string;
 }
-export declare const EdgeMiddleLabels: ({ label, pathMiddlePosition, isMiddlePathHorizontal, sourcePoint, targetPoint, showRelationshipLabels, isUseCasePath, isPetriNet, avoidToolbarOverlap, textColor, }: EdgeMiddleLabelsProps) => import("react").JSX.Element | null;
+export declare const EdgeMiddleLabels: ({ label, activePoints, sourcePoint, targetPoint, nodeRects, neighborGeometry, showRelationshipLabels, isUseCasePath, isPetriNet, textColor, }: EdgeMiddleLabelsProps) => import("react").JSX.Element | null;
 export {};

package/dist/react/edges/labelTypes/EdgeMultipleLabels.d.ts

@@ -7,9 +7,8 @@ interface EdgeMultipleLabelsProps {
     isReconnecting?: boolean;
     sourcePosition: IPoint;
     targetPosition: IPoint;
-    edgePoints?: IPoint[];
-    isHorizontalEdge?: boolean;
+    isHorizontalEdge: boolean;
     textColor: string;
 }
-export declare const EdgeMultipleLabels: ({ messages, pathMiddlePosition, showRelationshipLabels, isReconnecting, sourcePosition, targetPosition, edgePoints, isHorizontalEdge, textColor, }: EdgeMultipleLabelsProps) => import("react").JSX.Element | null;
+export declare const EdgeMultipleLabels: ({ messages, pathMiddlePosition, showRelationshipLabels, isReconnecting, sourcePosition, targetPosition, isHorizontalEdge, textColor, }: EdgeMultipleLabelsProps) => import("react").JSX.Element | null;
 export {};

package/dist/react/edges/labelTypes/messageLayout.d.ts

@@ -0,0 +1,51 @@
+import { MessageData } from '../EdgeProps';
+import { IPoint } from '../Connection';
+/**
+ * Geometry for communication-edge message labels, relative to the middle-segment
+ * midpoint (position-independent, hence unit-testable on its own).
+ *
+ * Invariant: a group's SIDE is fixed by the segment orientation; flow direction
+ * is encoded ONLY by the arrow rotation, never by the side. Gaps are constant by
+ * construction — nothing measures text width.
+ */
+export interface MessageHostSegment {
+    /** Rounded midpoint of the chosen arm (flow space). */
+    point: IPoint;
+    /** Orientation of the chosen arm. */
+    isHorizontal: boolean;
+    /** The arm's endpoints in source->target order (for arrow direction). */
+    start: IPoint;
+    end: IPoint;
+}
+/**
+ * The arm of a (possibly stepped) communication edge that should HOST the
+ * message stack. The naive mid-segment can land on a tiny jog between two long
+ * arms — classifying a dominantly-vertical edge as "horizontal" so the labels
+ * centre on the jog and straddle BOTH neighbouring arms. Instead we host on the
+ * LONGEST arm (tie-broken toward the edge's middle), so the stack sits beside a
+ * long straight run: it never crosses the line and, in vertical mode, all
+ * same-direction messages share a leading edge. Pure geometry — identical in the
+ * editor and in headless export.
+ */
+export declare const getMessageHostSegment: (renderPoints: IPoint[], fallbackSource: IPoint, fallbackTarget: IPoint) => MessageHostSegment;
+export type LabelTextAnchor = "start" | "middle" | "end";
+export declare const ARROW_SIZE = 16;
+export declare const ARROW_TEXT_GAP = 4;
+export declare const LINE_GAP = 8;
+export declare const STACK_SPACING = 22;
+export interface MessageGroupLayout {
+    messages: MessageData[];
+    arrowRotation: number;
+    textAnchor: LabelTextAnchor;
+    /** Top-left of the arrow icon for the first message, relative to the segment midpoint. */
+    arrowOrigin: IPoint;
+    /** Text anchor point for the first message, relative to the segment midpoint. */
+    textOrigin: IPoint;
+    /** Offset added per stacked message (multiplied by the message index). */
+    stackStep: IPoint;
+}
+export interface MessageLayout {
+    forward: MessageGroupLayout;
+    backward: MessageGroupLayout;
+}
+export declare const computeMessageLayout: (messages: MessageData[], sourcePosition: IPoint, targetPosition: IPoint, isHorizontalEdge: boolean) => MessageLayout;

package/dist/react/export/exportErrors.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Typed error for the raster (PNG) export path so callers can show an
+ * actionable "diagram too large" message instead of the silent 0-byte file the
+ * old canvas path produced (#667).
+ */
+export declare class RasterTooLargeError extends Error {
+    readonly canvasWidth: number;
+    readonly canvasHeight: number;
+    constructor(message: string, canvasWidth: number, canvasHeight: number);
+}

package/dist/react/export/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `@tumaet/apollon/export` — reliable browser raster/vector export of a
+ * compat-mode Apollon SVG. PNG via resvg (wasm); PDF via svg2pdf.js on jsPDF.
+ * Both fix the canvas-area-cap silent failure of the old client path (#667).
+ *
+ * The heavy renderers (`@resvg/resvg-wasm`, `jspdf`, `svg2pdf.js`) are optional
+ * dependencies, loaded lazily, so importing the editor never pulls them in.
+ */
+export { svgToPng, computeAppliedScale } from './svgToPng';
+export type { SvgToPngOptions, SvgToPngResult } from './svgToPng';
+export { svgToPdf } from './svgToPdf';
+export type { SvgToPdfOptions } from './svgToPdf';
+export { RasterTooLargeError } from './exportErrors';

package/dist/react/export/normalizeExportSvg.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Drop `font-style="italic"` from every element of an export SVG.
+ *
+ * Apollon emits italic for abstract-class headers, but the editor itself ships
+ * only upright Inter (Regular + Bold) — on screen the slant is the browser's
+ * *synthetic* oblique, and text width is measured with the upright metrics.
+ * The raster (resvg) and PDF (jsPDF) paths carry the same two upright faces, so
+ * a real italic face would change advance widths and break the editor↔export
+ * determinism guarantee (and risk overflowing label boxes). We therefore render
+ * abstract names upright by design — matching the server export — and strip the
+ * attribute so the SVG no longer *claims* an italic it doesn't deliver. Abstract
+ * classes stay distinguishable by their «Abstract» stereotype label.
+ *
+ * Mutates `root` in place.
+ */
+export declare function normalizeExportSvg(root: Element): void;

package/dist/react/export/preProcessSvgForPdf.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Adapt a compat-mode Apollon SVG to the three svg2pdf.js limitations that the
+ * library's own compat passes (in exportUtils.ts) do NOT already cover.
+ * Relative font-sizes, `tspan` `dy` and `dominant-baseline` are resolved
+ * upstream by `getSVG`, so they are intentionally absent here.
+ *
+ *  1. Nested `<svg>` clips its content despite `overflow="visible"` — svg2pdf
+ *     treats the intrinsic size as a clip rect. Apollon wraps each node in
+ *     `<svg width viewBox>`; replace those with `<g>` (layout-equivalent since
+ *     the viewBox is always `0 0 w h`), translating any non-zero origin.
+ *  2. A `<text>` with 2+ `<tspan>` children renders with wrong glyph widths in
+ *     svg2pdf; split it into independent `<text>` elements. Each tspan already
+ *     carries an absolute `y` (resolved by `resolveTspanDy`).
+ *  3. svg2pdf looks up `font-family` as a literal string, so the CSS list
+ *     `"Inter, system-ui, …"` misses the registered "Inter" and falls back to a
+ *     standard font; collapse any Inter-led list to plain `"Inter"`.
+ *
+ * Mutates `root` in place and returns it.
+ */
+export declare function preProcessSvgForPdf(root: Element): Element;

package/dist/react/export/svgToPdf.d.ts

@@ -0,0 +1,17 @@
+export type SvgToPdfOptions = {
+    /** Document title metadata; does not affect layout. */
+    title?: string;
+    /**
+     * Inter Regular + Bold as ttf/otf bytes, for hosts without `fetch` of the
+     * bundled `?url` font asset (e.g. tests, headless Node). Defaults to the
+     * bundled Inter.
+     */
+    fonts?: {
+        regular: Uint8Array;
+        bold: Uint8Array;
+    };
+};
+export declare function svgToPdf(svg: string, clip: {
+    width: number;
+    height: number;
+}, opts?: SvgToPdfOptions): Promise<Blob>;