@focus.matters/diagrams 0.0.10 → 0.1.0

package/dist/src/Diagrams/components/Canvas.d.ts

@@ -1,4 +1,5 @@
 import { ReactNode } from 'react';
+/** Renders the interactive diagram surface and coordinates application pointer state. */
 export declare const Canvas: (({ children }: {
     children?: ReactNode;
 }) => import("react").JSX.Element) & {

package/dist/src/Diagrams/components/extensions/RenderDiagramExtensions.d.ts

@@ -0,0 +1,4 @@
+/** Renders every diagram-aware visual layer contributed by registered extensions. */
+export declare const RenderDiagramExtensions: (() => (import("react").JSX.Element | null)[]) & {
+    displayName: string;
+};

package/dist/src/Diagrams/components/extensions/RenderUIExtensions.d.ts

@@ -0,0 +1,4 @@
+/** Renders every fixed user-interface layer contributed by registered extensions. */
+export declare const RenderUIExtensions: (() => import("react").JSX.Element) & {
+    displayName: string;
+};

package/dist/src/Diagrams/components/extra/AlignmentSuggestions.d.ts

@@ -1,3 +1,4 @@
+/** Renders transient alignment guides produced by drag and resize interactions. */
 export declare const AlignmentSuggestions: (() => import("react").JSX.Element) & {
     displayName: string;
 };

package/dist/src/Diagrams/components/extra/GatewayRender.d.ts

@@ -1,5 +1,6 @@
 import { ReactElement } from 'react';
 import { Gateway } from '../../store/elements/Gateway';
+/** Renders one interactive gateway while preserving its owning node's hover state. */
 export declare const GatewayRender: ({ gateway, }: {
     gateway: Gateway;
 }) => ReactElement;

package/dist/src/Diagrams/components/extra/NodeGatewayRender.d.ts

@@ -0,0 +1,6 @@
+import { ReactElement } from 'react';
+import { Node } from '../../store/elements/Node';
+/** Renders an invisible perimeter hit target for nodes using edges as gateways. */
+export declare const NodeGatewayRender: ((props: {
+    node: Node<any>;
+}) => ReactElement);

package/dist/src/Diagrams/components/objects/EdgeLabels.d.ts

@@ -0,0 +1,7 @@
+import { Edge } from '../../store/elements/Edge';
+/** Renders every edge label in the unscaled screen layer for crisp zoomed text. */
+export declare const EdgeLabels: (({ edge }: {
+    edge: Edge;
+}) => import("react").JSX.Element[]) & {
+    displayName: string;
+};

package/dist/src/Diagrams/components/objects/RenderEdge/EdgeMarker.d.ts

@@ -8,5 +8,6 @@ interface EdgeMarkerProps {
     arrowSize: number;
     flip?: boolean;
 }
+/** Renders one reusable SVG endpoint marker with route-relative orientation. */
 export declare const EdgeMarker: React.FC<EdgeMarkerProps>;
 export {};

package/dist/src/Diagrams/components/objects/RenderEdge/buildEdgePath.d.ts

@@ -0,0 +1,5 @@
+import { Edge } from '../../../store/elements/Edge';
+import { EdgePathType } from '../../../store/types';
+import { Coordinates } from '../../../store/primitives/Coordinates';
+/** Builds the SVG path matching an edge's straight, curved, or orthogonal mode. */
+export declare function buildEdgePath(points: Coordinates[], edge?: Edge, pathType?: EdgePathType): string;

package/dist/src/Diagrams/components/objects/RenderEdge/index.d.ts

@@ -1,4 +1,5 @@
 import { default as React } from 'react';
 import { RenderEdgeProps } from './types';
 export type * from './types';
+/** Renders an interactive routed edge with markers, editable label, and handles. */
 export declare const RenderEdge: React.FC<RenderEdgeProps>;

package/dist/src/Diagrams/components/objects/RenderEdge/types.d.ts

@@ -1,6 +1,6 @@
 import { default as React } from 'react';
 import { Coordinates } from '../../../store/primitives/Coordinates';
-import { EdgeArrowHead, EdgeLineStyle } from '../../../store/types';
+import { EdgeArrowHead, EdgeLineStyle, EdgePathType } from '../../../store/types';
 import { EdgePoint } from '../../../store/elements/EdgePoint';
 import { Edge } from '../../../store/elements/Edge';
 import { AnyMouseEvent } from '../../../store/elements/Events';
@@ -16,6 +16,7 @@ export interface RenderEdgeProps {
     startType?: EdgeArrowHead;
     endType?: EdgeArrowHead;
     lineStyle?: EdgeLineStyle;
+    pathType?: EdgePathType;
     draggable?: boolean;
     onMidpointMouseDown?: (p: Midpoint, ev: React.MouseEvent) => void;
     onEndpointMouseDown?: (endpoint: "from" | "to", ev: React.MouseEvent) => void;

package/dist/src/Diagrams/components/objects/Shapes.d.ts

@@ -1 +1,2 @@
+/** Returns the scalable diagram layers used for nodes, edges, and custom overlays. */
 export declare function shapes(): import("react").JSX.Element[];

package/dist/src/Diagrams/components/objects/edgeLabelPlacement.d.ts

@@ -0,0 +1,4 @@
+import { Edge } from '../../store/elements/Edge';
+import { Coordinates } from '../../store/primitives/Coordinates';
+/** Places a new label beside the clicked route segment instead of over its stroke. */
+export declare function positionEdgeLabelBesideRoute(edge: Edge, clicked: Coordinates, clearance?: number): Coordinates;

package/dist/src/Diagrams/custom/agent/edges/AgentEdge.d.ts

@@ -19,7 +19,25 @@ export declare class AgentEdge extends Edge {
         displacementEnd: [number, number] | undefined;
         displacementStart: [number, number] | undefined;
         lineStyle: import('../../../store/types').EdgeLineStyle | undefined;
-        pathType: import('../../../store/types').EdgePathType | undefined;
+        labels: {
+            alignment: "right" | "left" | "center";
+            id: string;
+            size: {
+                height: number;
+                width: number;
+            };
+            text: string;
+            position: [number, number];
+        }[];
+        pathType: import('../../../store/types').EdgePathType;
+        startAnchor: {
+            mode: import('../../../store/types').EdgeAnchorMode;
+            position: [number, number] | undefined;
+        };
+        endAnchor: {
+            mode: import('../../../store/types').EdgeAnchorMode;
+            position: [number, number] | undefined;
+        };
         steps: import('../../../store/elements/EdgePoint').TSerializedEdgePoint[];
         stroke: string | undefined;
         strokeWidth: number | undefined;

package/dist/src/Diagrams/custom/agent/nodes/AgentNode.d.ts

@@ -36,7 +36,25 @@ export declare abstract class AgentNode<TPayload> extends EditableNode {
                 displacementEnd: [number, number] | undefined;
                 displacementStart: [number, number] | undefined;
                 lineStyle: import('../../../store/types').EdgeLineStyle | undefined;
-                pathType: import('../../../store/types').EdgePathType | undefined;
+                labels: {
+                    alignment: "right" | "left" | "center";
+                    id: string;
+                    size: {
+                        height: number;
+                        width: number;
+                    };
+                    text: string;
+                    position: [number, number];
+                }[];
+                pathType: import('../../../store/types').EdgePathType;
+                startAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                endAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
                 steps: import('../../../store/elements/EdgePoint').TSerializedEdgePoint[];
                 stroke: string | undefined;
                 strokeWidth: number | undefined;
@@ -48,6 +66,7 @@ export declare abstract class AgentNode<TPayload> extends EditableNode {
         }[];
         fill: string | undefined;
         labelFontSize: number | undefined;
+        labelOffset: [number, number] | undefined;
         stroke: string | undefined;
         strokewWidth: number | undefined;
         class: string;

package/dist/src/Diagrams/custom/bpmn/BPMDiagram.d.ts

@@ -1,5 +1,14 @@
 import { TDiagramSettings } from '../../store/Diagram';
 import { EditableDiagram } from '../editable/EditableDiagram';
+import { BPMNLabelOverrides, BPMNLabels } from './config/BPMNLabels';
+export type BPMDiagramSettings = TDiagramSettings & {
+    labels?: BPMNLabelOverrides;
+};
+/** Configures the editable diagram with all supported BPMN nodes and extensions. */
 export declare class BPMDiagram extends EditableDiagram {
-    constructor(settings?: TDiagramSettings);
+    constructor(settings?: BPMDiagramSettings);
+    /** Exposes the isolated complete labels currently used by this BPMN diagram. */
+    get bpmnLabels(): BPMNLabels;
+    /** Replaces selected labels for this diagram while preserving prior overrides. */
+    configureLabels(overrides: BPMNLabelOverrides): void;
 }

package/dist/src/Diagrams/custom/bpmn/bpmnEvents.d.ts

@@ -1,3 +1,4 @@
 import { DChangeEvent } from '../../store/elements/Events';
-export declare class AddLaneEvent extends DChangeEvent {
+/** Records BPMN lane mutations so history can undo and redo each completed gesture. */
+export declare class BPMNLaneChangeEvent extends DChangeEvent {
 }

package/dist/src/Diagrams/custom/bpmn/config/BPMNElementCatalog.d.ts

@@ -0,0 +1,26 @@
+import { Node } from '../../../store/elements/Node';
+import { BPMNIconId } from '../ui/BPMNIcon';
+export type BPMNElementFamily = "task" | "event" | "gateway" | "lane" | "data" | "artifact";
+export type BPMNElementId = Exclude<BPMNIconId, "transform" | "connect" | "settings">;
+export type BPMNElementDefinition = {
+    id: BPMNElementId;
+    family: BPMNElementFamily;
+    section: "activities" | "events" | "gateways" | "support";
+    priority: number;
+    enabled: boolean;
+    connectable: boolean;
+};
+export declare const BPMN_ELEMENTS: readonly BPMNElementDefinition[];
+/** Provides the shared BPMN element registry, construction, and type mutation API. */
+export declare class BPMNElementCatalog {
+    /** Returns enabled definitions in configured priority and declaration order. */
+    static enabled(): BPMNElementDefinition[];
+    /** Resolves the stable catalog definition represented by a concrete diagram node. */
+    static forNode(node: Node): BPMNElementDefinition | undefined;
+    /** Resolves the stable catalog identifier represented by a concrete diagram node. */
+    static idForNode(node: Node): BPMNElementId | undefined;
+    /** Creates an unmounted node for the requested catalog element identifier. */
+    static create(id: BPMNElementId, nodeId: string, label: string): Node;
+    /** Mutates a node to another enabled variant in the same semantic family. */
+    static transform(node: Node, targetId: BPMNElementId): boolean;
+}

package/dist/src/Diagrams/custom/bpmn/config/BPMNLabels.d.ts

@@ -0,0 +1,27 @@
+export type BPMNLabels = {
+    sections: Record<"activities" | "events" | "gateways" | "support", string>;
+    elements: Record<string, string>;
+    eventOptions: Record<"none" | "start" | "intermediate" | "end" | "catch" | "throw", string>;
+    actions: Record<"transform" | "connect" | "settings" | "close" | "delete" | "reverseDirection" | "resize" | "resizeElement", string>;
+    properties: Record<"title" | "name" | "type" | "condition" | "defaultFlow" | "directed" | "edgeType" | "routingType" | "eventType" | "eventStage" | "eventDirection" | "interrupting" | "subprocessStart" | "eventSubprocessStartType" | "loop" | "multiInstance", string>;
+    edges: Record<string, string>;
+    routing: Record<"orthogonal" | "straight" | "curved", string>;
+    inputs: Record<"blackBoxPoolName" | "documentAnnotationText" | "elementSearch" | "laneName", string>;
+    resizeDirections: Record<"n" | "ne" | "e" | "se" | "s" | "sw" | "w" | "nw", string>;
+    lanes: Record<"defaultLane" | "pool" | "rename" | "insertBefore" | "subdivide" | "removeSubdivision" | "removeLane" | "insertAfter", string>;
+};
+export type BPMNLabelOverrides = {
+    sections?: Partial<BPMNLabels["sections"]>;
+    elements?: Record<string, string>;
+    eventOptions?: Partial<BPMNLabels["eventOptions"]>;
+    actions?: Partial<BPMNLabels["actions"]>;
+    properties?: Partial<BPMNLabels["properties"]>;
+    edges?: Record<string, string>;
+    routing?: Partial<BPMNLabels["routing"]>;
+    inputs?: Partial<BPMNLabels["inputs"]>;
+    resizeDirections?: Partial<BPMNLabels["resizeDirections"]>;
+    lanes?: Partial<BPMNLabels["lanes"]>;
+};
+export declare const BPMN_LABELS: BPMNLabels;
+/** Creates an isolated complete label object without mutating shared defaults. */
+export declare function configureBPMNLabels(overrides?: BPMNLabelOverrides, base?: BPMNLabels): BPMNLabels;

package/dist/src/Diagrams/custom/bpmn/edges/BPMNEdge.d.ts

@@ -0,0 +1,77 @@
+import { Edge } from '../../../store/elements/Edge';
+import { EdgeRouterAnchor } from '../../../store/routers/EdgesRouter';
+import { TEdgeState } from '../../../store/types';
+export type BPMNEdgeKind = "sequenceFlow" | "messageFlow" | "inputDataAssociation" | "outputDataAssociation" | "association";
+type BPMNEdgeState = TEdgeState & {
+    kind?: BPMNEdgeKind;
+    condition?: string;
+    isDefault?: boolean;
+    isDirected?: boolean;
+};
+/** Stores BPMN connection semantics independently from generic edge routing. */
+export declare class BPMNEdge extends Edge {
+    kind: BPMNEdgeKind;
+    condition: string;
+    private defaultFlow;
+    private directedFlow;
+    get isDefault(): boolean;
+    get isDirected(): boolean;
+    /** Reports whether this BPMN connection exposes an editable direction marker. */
+    get supportsDirection(): boolean;
+    get supportsDefaultFlow(): boolean;
+    constructor(parent: ConstructorParameters<typeof Edge>[0], state: BPMNEdgeState);
+    /** Infers the legal BPMN connection type for two concrete endpoint nodes. */
+    static inferKind(from: unknown, to: unknown): BPMNEdgeKind | null;
+    /** Updates connection semantics and reapplies the standard BPMN edge styling. */
+    setKind(kind: BPMNEdgeKind): void;
+    /** Applies a legal default marker and clears every sibling default branch. */
+    setDefault(isDefault: boolean): boolean;
+    /** Toggles the target marker for every BPMN connection supporting direction. */
+    setDirected(isDirected: boolean): boolean;
+    /** Revalidates default-flow legality after either endpoint is reconnected. */
+    applyResolvedAnchors(start: EdgeRouterAnchor, end: EdgeRouterAnchor): void;
+    /** Reverses both BPMN endpoints while preserving the complete routed path geometry. */
+    reverseDirection(): void;
+    private clearOtherDefaultFlows;
+    private applyStyle;
+    /** Serializes BPMN-specific properties in addition to generic routed edge state. */
+    serialize(): {
+        kind: BPMNEdgeKind;
+        condition: string;
+        isDefault: boolean;
+        isDirected: boolean;
+        arrowHeadEnd: import('../../../store/types').EdgeArrowHead | undefined;
+        arrowHeadStart: import('../../../store/types').EdgeArrowHead | undefined;
+        displacementEnd: [number, number] | undefined;
+        displacementStart: [number, number] | undefined;
+        lineStyle: import('../../../store/types').EdgeLineStyle | undefined;
+        labels: {
+            alignment: "right" | "left" | "center";
+            id: string;
+            size: {
+                height: number;
+                width: number;
+            };
+            text: string;
+            position: [number, number];
+        }[];
+        pathType: import('../../../store/types').EdgePathType;
+        startAnchor: {
+            mode: import('../../../store/types').EdgeAnchorMode;
+            position: [number, number] | undefined;
+        };
+        endAnchor: {
+            mode: import('../../../store/types').EdgeAnchorMode;
+            position: [number, number] | undefined;
+        };
+        steps: import('../../../store/elements/EdgePoint').TSerializedEdgePoint[];
+        stroke: string | undefined;
+        strokeWidth: number | undefined;
+        to: string;
+        toParentId: string;
+        class: string;
+    };
+    /** Restores the required current BPMN edge contract without legacy fallbacks. */
+    deserialize(o: ReturnType<this["serialize"]>): void;
+}
+export {};

package/dist/src/Diagrams/custom/bpmn/extensions/BPMNArtifactTransformer.d.ts

@@ -0,0 +1,5 @@
+import { Diagram } from '../../../store/Diagram';
+import { Node } from '../../../store/elements/Node';
+import { BPMNElementId } from '../config/BPMNElementCatalog';
+/** Replaces an annotation node while retaining its identity, state, and connected edges. */
+export declare function transformBPMNArtifact(diagram: Diagram, node: Node, targetId: BPMNElementId): Node | null;

package/dist/src/Diagrams/custom/bpmn/extensions/BPMNEventAttachments.d.ts

@@ -0,0 +1,19 @@
+import { DiagramExtension } from '../../../store/extensions/DiagramExtension';
+/** Constrains attached and subprocess-start events throughout their lifecycle. */
+export declare class BPMNEventAttachments extends DiagramExtension {
+    private draggedEventIds;
+    /** Registers attachment projection after generic alignment and grid constraints. */
+    init(): void;
+    private attachedEvents;
+    private subprocessEvents;
+    private handleDrag;
+    private clearDropPresentations;
+    private presentDropTarget;
+    private findInternalDropTarget;
+    private findAttachmentDropTarget;
+    private constrainAttachedEvent;
+    private constrainSubprocessEvent;
+    private moveAttachedEvents;
+    private finishEventDrags;
+    private findDropTask;
+}

package/dist/src/Diagrams/custom/bpmn/extensions/BPMNGridSnap.d.ts

@@ -7,13 +7,15 @@ type TBPMNResize = {
     height: number;
 };
 /**
- * Applies BPMN-specific grid constraints to lane width and height resizing.
+ * Applies BPMN-specific node positioning and lane resizing constraints to the grid.
  */
 export declare class BPMNGridSnap extends DiagramExtension {
     /** Initializes the extension, whose resize constraints are invoked by BPMN tools. */
     init(): void;
+    private snapOneGridNodes;
     /** Applies minimum sizes and optional grid snapping to a BPMN lane resize. */
-    resize(lanes: Lanes, resize: TBPMNResize): void;
+    resize(lanes: Lanes, resize: TBPMNResize): boolean;
+    private snapGrowingEdge;
     private constrain;
     private getLaneSuggestions;
     private getHorizontalLaneSuggestions;

package/dist/src/Diagrams/custom/bpmn/extensions/BPMNLaneResizer.d.ts

@@ -11,7 +11,7 @@ export declare class BPMNLaneResizer extends DiagramExtension {
     init(): void;
     /** Starts resizing the complete lane container from its right-side handle. */
     resizeWidth(lanes: Lanes, event: MouseEvent): void;
-    /** Starts resizing one BPMN lane from its horizontal lower-edge handle. */
+    /** Starts resizing one BPMN lane from its horizontal lower-edge drag handle. */
     resizeHeight(lanes: Lanes, laneId: string, initialHeight: number, event: MouseEvent): void;
     private startSession;
     private handleMouseMove;

package/dist/src/Diagrams/custom/bpmn/extensions/BPMNModelerExtension.d.ts

@@ -0,0 +1,97 @@
+import { MouseEvent as ReactMouseEvent } from 'react';
+import { Edge } from '../../../store/elements/Edge';
+import { Node } from '../../../store/elements/Node';
+import { DiagramExtension } from '../../../store/extensions/DiagramExtension';
+import { EdgePathType } from '../../../store/types';
+import { BPMNElementDefinition, BPMNElementId } from '../config/BPMNElementCatalog';
+import { BPMNLabelOverrides, BPMNLabels } from '../config/BPMNLabels';
+import { BPMNEdge, BPMNEdgeKind } from '../edges/BPMNEdge';
+import { EventNode, EventDirection, EventKind, EventStage } from '../nodes/EventNode';
+import { TaskNode, TaskMultiInstance } from '../nodes/TaskNode';
+/** Coordinates BPMN catalog transformations, inferred edges, and extension UI. */
+export declare class BPMNModelerExtension extends DiagramExtension {
+    dragging: boolean;
+    propertiesPanelOpen: boolean;
+    RenderDiagram: (({ diagram, extension }: import('../../../store/extensions/DiagramExtension').TDiagramExtensionRenderProps<BPMNModelerExtension>) => import("react").JSX.Element | null) & {
+        displayName: string;
+    };
+    RenderUI: (({ diagram, extension }: import('../../../store/extensions/DiagramExtension').TDiagramExtensionRenderProps<BPMNModelerExtension>) => import("react").JSX.Element) & {
+        displayName: string;
+    };
+    private labelConfiguration;
+    /** Returns this diagram's isolated labels, or defaults for legacy probes. */
+    get labels(): BPMNLabels;
+    /** Merges label overrides into this diagram without changing global defaults. */
+    configureLabels(overrides: BPMNLabelOverrides): void;
+    /** Registers semantic edge support and guards invalid drag-created connections. */
+    init(): void;
+    /** Returns legal enabled transformations that preserve current connections. */
+    transformTargets(node: Node): BPMNElementDefinition[];
+    /** Returns transform choices in stable catalog order including the current type. */
+    shapeOptions(node: Node): BPMNElementDefinition[];
+    /** Changes a node variant through the shared catalog and emits history state. */
+    transform(node: Node, targetId: BPMNElementId): boolean;
+    /** Returns enabled target elements that form a legal outgoing BPMN connection. */
+    connectionTargets(node: Node): BPMNElementDefinition[];
+    private inferDefinitionKind;
+    /** Creates and connects a catalog node at the nearest collision-free position. */
+    appendConnected(node: Node, targetId: BPMNElementId): Node | null;
+    private nearestAvailablePosition;
+    private placementDirectionRank;
+    /** Starts an automatic outgoing connection from the toolbar of a selected node. */
+    startToolbarConnection(node: Node, event: ReactMouseEvent): void;
+    /** Reports whether the interactive connector should replace selection UI. */
+    get connecting(): boolean;
+    /** Updates a selected node label and records the mutation in diagram history. */
+    renameNode(node: Node, label: string): void;
+    private acceptsEventDefinition;
+    /** Lists event kinds available without invalidating an existing attachment. */
+    eventKindOptions(node: EventNode): EventKind[];
+    private eventDefinitionForKind;
+    /** Changes only the kind and normalizes independently unsupported dimensions. */
+    changeEventKind(node: EventNode, kind: EventKind): boolean;
+    /** Lists valid stages while preserving the independently selected direction. */
+    eventStageOptions(node: EventNode): EventStage[];
+    /** Lists valid directions while preserving the independently selected stage. */
+    eventDirectionOptions(node: EventNode): EventDirection[];
+    /** Changes an event stage without modifying the independently chosen direction. */
+    changeEventStage(node: EventNode, stage: EventStage): boolean;
+    /** Changes whether the current event catches or throws its configured trigger. */
+    changeEventDirection(node: EventNode, direction: EventDirection): boolean;
+    /** Toggles whether an attached boundary event interrupts its owning task. */
+    changeEventInterrupting(node: EventNode, interrupting: boolean): void;
+    private eventSubprocessStart;
+    private containedEventCandidate;
+    /** Returns the concrete start-event kind configured by an event subprocess. */
+    eventSubprocessStartKind(node: TaskNode): EventKind | "";
+    /** Creates or updates the movable internal start event selected on its owner. */
+    changeEventSubprocessStartKind(node: TaskNode, kind: EventKind): EventNode | null;
+    /** Changes the activity multi-instance marker while recording one property mutation. */
+    changeTaskMultiInstance(node: TaskNode, multiInstance: TaskMultiInstance): boolean;
+    /** Toggles a task's standard conditional loop and records the property change. */
+    changeTaskLoop(node: TaskNode, loop: boolean): boolean;
+    /** Updates a selected edge label and records the mutation in diagram history. */
+    renameEdge(edge: Edge, label: string): void;
+    /** Returns only edge kinds that preserve all endpoint-specific BPMN constraints. */
+    edgeKindOptions(edge: BPMNEdge): BPMNEdgeKind[];
+    /** Updates a BPMN edge kind and refreshes its visual connection convention. */
+    changeEdgeKind(edge: BPMNEdge, kind: BPMNEdgeKind): void;
+    /** Reverses one BPMN edge while retaining its route and emitting a history change. */
+    reverseEdge(edge: BPMNEdge): void;
+    /** Changes one BPMN edge routing strategy while preserving history integration. */
+    changeEdgePathType(edge: BPMNEdge, pathType: EdgePathType): void;
+    /** Updates the conditional expression associated with a sequence flow edge. */
+    changeEdgeCondition(edge: BPMNEdge, condition: string): void;
+    /** Toggles a legal gateway default while preserving source-wide exclusivity. */
+    changeEdgeDefault(edge: BPMNEdge, isDefault: boolean): boolean;
+    /** Toggles an eligible edge target marker and records the semantic history change. */
+    changeEdgeDirected(edge: BPMNEdge, isDirected: boolean): void;
+    /** Returns whether this edge can be the default of an exclusive or inclusive gateway. */
+    supportsDefaultFlow(edge: BPMNEdge): boolean;
+    /** Returns whether sequence-flow conditions are meaningful for this source. */
+    supportsCondition(edge: BPMNEdge): boolean;
+    /** Toggles the properties inspector and persists its current preference locally. */
+    togglePropertiesPanel(): void;
+    /** Closes the properties inspector and persists its disabled preference locally. */
+    closePropertiesPanel(): void;
+}

package/dist/src/Diagrams/custom/bpmn/extensions/BPMNNodeResizer.d.ts

@@ -0,0 +1,31 @@
+import { DiagramExtension } from '../../../store/extensions/DiagramExtension';
+import { Coordinates } from '../../../store/primitives/Coordinates';
+import { Dimensions } from '../../../store/primitives/Dimensions';
+import { BPMNode } from '../nodes/BPMNode';
+export type BPMNResizableNode = BPMNode & {
+    readonly minimumResizeSize: Coordinates;
+};
+export type BPMNResizeDirection = "n" | "ne" | "e" | "se" | "s" | "sw" | "w" | "nw";
+/** Owns opt-in BPMN node resize sessions with grid, bounds, and edge updates. */
+export declare class BPMNNodeResizer extends DiagramExtension {
+    private readonly autopan;
+    private session;
+    private unbindSession;
+    /** Initializes the imperative extension consumed by resizable BPMN renderers. */
+    init(): void;
+    /** Starts a directional resize gesture safely from any side or corner handle. */
+    startResize(node: BPMNResizableNode, event: PointerEvent, direction: BPMNResizeDirection): void;
+    /** Applies a constrained size immediately and reroutes every connected edge. */
+    resizeNode(node: BPMNResizableNode, size: Coordinates | [number, number]): boolean;
+    /** Resizes from one handle while keeping the opposite sides anchored in place. */
+    resizeNodeFromDirection(node: BPMNResizableNode, initialBox: Dimensions, direction: BPMNResizeDirection, delta: Coordinates): boolean;
+    private snapDirectionalBoxToGrid;
+    private snapCoordinate;
+    private applyBox;
+    private constrain;
+    private rerouteConnectedEdges;
+    private handlePointerMove;
+    private handleAutopan;
+    private resizeFromPointer;
+    private endSession;
+}

package/dist/src/Diagrams/custom/bpmn/extensions/BPMNPropertyChangeEvent.d.ts

@@ -0,0 +1,4 @@
+import { DChangeEvent } from '../../../store/elements/Events';
+/** Marks inspector-driven BPMN property mutations as history-aware changes. */
+export declare class BPMNPropertyChangeEvent extends DChangeEvent {
+}

package/dist/src/Diagrams/custom/bpmn/extensions/BPMNResizeSuggester.d.ts

@@ -0,0 +1,23 @@
+import { DiagramExtension } from '../../../store/extensions/DiagramExtension';
+import { AlignmentGuide } from '../../../store/extensions/NodesAligner';
+import { Coordinates } from '../../../store/primitives/Coordinates';
+import { Dimensions } from '../../../store/primitives/Dimensions';
+import { BPMNode } from '../nodes/BPMNode';
+import { BPMNResizeDirection } from './BPMNNodeResizer';
+/** Suggests BPMN resize stops that match peer dimensions and corresponding sides. */
+export declare class BPMNResizeSuggester extends DiagramExtension {
+    alignmentProposals: AlignmentGuide[];
+    /** Initializes the observable guide collection used by the diagram overlay. */
+    init(): void;
+    /** Removes all transient guides when a resize gesture finishes or restarts. */
+    clear(): void;
+    /** Returns the best snapped box while publishing every associated visual guide. */
+    suggest(node: BPMNode, box: Dimensions, direction: BPMNResizeDirection, fallback?: Dimensions, minimumResizeSize?: Coordinates): Dimensions;
+    private sideCandidate;
+    private widthCandidate;
+    private candidate;
+    private isValid;
+    private verticalGuide;
+    private horizontalGuide;
+    private widthGuides;
+}

package/dist/src/Diagrams/custom/bpmn/nodes/BPMNEventDefinition.d.ts

@@ -0,0 +1,28 @@
+/** Stable compatibility codes used by persisted diagrams and catalog transforms. */
+export declare enum EventTypes {
+    start = 0,
+    end = 1,
+    intermediate = 2,
+    timer = 3,
+    messageCatch = 4,
+    messageThrow = 5,
+    signalCatch = 6,
+    signalThrow = 7,
+    compensationCatch = 8,
+    compensationThrow = 9,
+    errorCatch = 10,
+    errorThrow = 11,
+    conditional = 12,
+    terminate = 13
+}
+export type EventStage = "start" | "intermediate" | "end";
+export type EventKind = "none" | "timer" | "message" | "signal" | "compensation" | "error" | "conditional" | "terminate";
+export type EventDirection = "catch" | "throw";
+export type EventDefinition = Readonly<{
+    stage: EventStage;
+    kind: EventKind;
+    direction: EventDirection;
+}>;
+export declare const EVENT_DEFINITION_BY_TYPE: Readonly<Record<EventTypes, EventDefinition>>;
+/** Validates the complete event tuple against the supported BPMN combinations. */
+export declare function isValidEventDefinition(value: unknown): value is EventDefinition;

package/dist/src/Diagrams/custom/bpmn/nodes/BPMNode.d.ts

@@ -1,6 +1,15 @@
+import { Diagram } from '../../../store/Diagram';
 import { Element } from '../../../store/elements/Element';
 import { TNodeConstructorProps } from '../../../store/elements/Node';
 import { EditableNode } from '../../editable/EditableNode';
+/** Provides shared BPMN sizing, typography, and connection-boundary behavior. */
 export declare abstract class BPMNode extends EditableNode {
+    edgesAsGateways: boolean;
+    protected occupiesGridSquare: boolean;
     constructor(parent: Element | null, state: TNodeConstructorProps);
+    protected fitToGridSquare(): void;
+    /** Attaches the node and reapplies any geometry tied to the active grid size. */
+    setDiagram(diagram: Diagram): void;
+    /** Restores shared state while enforcing current typography and grid geometry. */
+    deserialize(o: ReturnType<this["serialize"]>): void;
 }

package/dist/src/Diagrams/custom/bpmn/nodes/BlackBoxPoolNode.d.ts

@@ -0,0 +1,17 @@
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps, TNodeScreenRenderProps } from '../../../store/elements/Node';
+import { Coordinates } from '../../../store/primitives/Coordinates';
+import { BPMNResizableNode } from '../extensions/BPMNNodeResizer';
+import { BPMNode } from './BPMNode';
+/** Models an external BPMN participant whose internal process remains hidden. */
+export declare class BlackBoxPoolNode extends BPMNode implements BPMNResizableNode {
+    readonly minimumResizeSize: Coordinates;
+    edgesAsGateways: boolean;
+    constructor(parent: Element | null, state: TNodeConstructorProps);
+    RenderScreen: (({ node }: TNodeScreenRenderProps<BlackBoxPoolNode>) => import("react").JSX.Element) & {
+        displayName: string;
+    };
+    RenderOverlay: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+}

package/dist/src/Diagrams/custom/bpmn/nodes/DataStoreNode.d.ts

@@ -0,0 +1,14 @@
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { Dimensions } from '../../../store/primitives/Dimensions';
+import { BPMNode } from './BPMNode';
+/** Models persistent information storage used through directional BPMN associations. */
+export declare class DataStoreNode extends BPMNode {
+    requiredEdgePathType: "straight";
+    protected occupiesGridSquare: boolean;
+    constructor(parent: Element | null, state: TNodeConstructorProps);
+    protected get screenLabelBox(): Dimensions;
+    RenderOverlay: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+}