@foblex/flow 19.0.0 → 19.1.0

package/fesm2022/foblex-flow.mjs

@@ -4,7 +4,7 @@ import { TransformModelExtensions, PointExtensions, RectExtensions, GetIntersect
 import { __decorate } from 'tslib';
 import { FExecutionRegister, FMediator } from '@foblex/mediator';
 import { BrowserService, PlatformService, EOperationSystem } from '@foblex/platform';
-import { castToEnum, normalizeDomElementId, isClosestElementHasClass, flatMap, getOrCreateRootNodeForViewRef, deepCloneNode, disableDragInteractions, extendStyles, getDataAttrValueFromClosestElementWithClass } from '@foblex/utils';
+import { castToEnum, normalizeDomElementId, isClosestElementHasClass, flatMap, getOrCreateRootNodeForViewRef, deepCloneNode, disableDragInteractions, extendStyles, getDataAttrValueFromClosestElementWithClass, generateGuid } from '@foblex/utils';
 import { DOCUMENT, CommonModule } from '@angular/common';
 
 const F_BACKGROUND_PATTERN = new InjectionToken('F_BACKGROUND_PATTERN');
@@ -26,6 +26,14 @@ class AddPatternToBackgroundRequest {
 class FIdRegistryBase {
     _items = [];
     _byId = new Map();
+    /**
+     * Removals are collected here and compacted out of `_items` in one pass on
+     * the next ordered read. A large teardown is O(n) total instead of the
+     * O(n^2) that per-removal indexOf+splice cost; `_byId` reflects removals
+     * immediately, so id lookups never see removed instances.
+     */
+    _pendingRemovals = new Set();
+    _isCompactionScheduled = false;
     get(id) {
         return this._byId.get(id);
     }
@@ -40,10 +48,11 @@ class FIdRegistryBase {
         return this._byId.has(id);
     }
     getAll() {
+        this._compact();
         return this._items;
     }
     size() {
-        return this._items.length;
+        return this._byId.size;
     }
     /**
      * Adds an instance.
@@ -54,6 +63,11 @@ class FIdRegistryBase {
         if (this._byId.has(id)) {
             throw new Error(`${this.kind} already exists: ${id}`);
         }
+        // Re-adding an instance whose removal is still pending would leave two
+        // copies in the ordered list; settle the pending removal first.
+        if (this._pendingRemovals.has(instance)) {
+            this._compact();
+        }
         this._items.push(instance);
         this._byId.set(id, instance);
     }
@@ -75,10 +89,8 @@ class FIdRegistryBase {
         // Defensive: if another instance with same id is in registry (shouldn't happen),
         // we remove by id anyway.
         this._byId.delete(id);
-        const index = this._items.indexOf(existing);
-        if (index >= 0) {
-            this._items.splice(index, 1);
-        }
+        this._pendingRemovals.add(existing);
+        this._scheduleCompaction();
         return true;
     }
     /**
@@ -91,10 +103,8 @@ class FIdRegistryBase {
             return undefined;
         }
         this._byId.delete(id);
-        const index = this._items.indexOf(existing);
-        if (index >= 0) {
-            this._items.splice(index, 1);
-        }
+        this._pendingRemovals.add(existing);
+        this._scheduleCompaction();
         return existing;
     }
     /**
@@ -103,6 +113,32 @@ class FIdRegistryBase {
     clear() {
         this._items.length = 0;
         this._byId.clear();
+        this._pendingRemovals.clear();
+    }
+    /** Compacts in place so `getAll()` keeps one array identity across reads. */
+    _compact() {
+        if (!this._pendingRemovals.size) {
+            return;
+        }
+        let writeIndex = 0;
+        for (const item of this._items) {
+            if (!this._pendingRemovals.has(item)) {
+                this._items[writeIndex++] = item;
+            }
+        }
+        this._items.length = writeIndex;
+        this._pendingRemovals.clear();
+    }
+    /** Settles a removal batch before coalesced registry notifications run. */
+    _scheduleCompaction() {
+        if (this._isCompactionScheduled) {
+            return;
+        }
+        this._isCompactionScheduled = true;
+        queueMicrotask(() => {
+            this._isCompactionScheduled = false;
+            this._compact();
+        });
     }
 }
 
@@ -482,13 +518,22 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
         }] });
 
 class EmitConnectionsChangesRequest {
+    dirtyNodeId;
     static fToken = Symbol('EmitConnectionsChangesRequest');
+    /**
+     * When set, only connections touching this node need a redraw; omitted
+     * means "redraw everything" — the safe default every caller keeps unless
+     * it knows the change is local to one node.
+     */
+    constructor(dirtyNodeId) {
+        this.dirtyNodeId = dirtyNodeId;
+    }
 }
 
 let EmitConnectionsChanges = class EmitConnectionsChanges {
     _store = inject(FComponentsStore);
-    handle(_) {
-        this._store.emitConnectionChanges();
+    handle({ dirtyNodeId }) {
+        this._store.emitConnectionChanges(dirtyNodeId);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: EmitConnectionsChanges, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: EmitConnectionsChanges });
@@ -557,13 +602,54 @@ class FComponentsStore {
     connectors = new FConnectorRegistry('Connector');
     instances = new FSingleRegistryBase();
     fDraggable;
+    _isNodesNotifyScheduled = false;
+    _isConnectionsNotifyScheduled = false;
+    /**
+     * Change notifications are coalesced to one per microtask: mounting a node
+     * with K connectors used to fire K+1 synchronous notifications, each running
+     * every listener (semantics rebuild, layout, minimap) — O(N^2) work across
+     * an N-node initial render. Revisions still increment synchronously, so code
+     * comparing revisions never observes stale values.
+     */
     emitNodeChanges() {
         this._nodesRevision++;
-        this.nodesChanges$.notify();
+        if (this._isNodesNotifyScheduled) {
+            return;
+        }
+        this._isNodesNotifyScheduled = true;
+        queueMicrotask(() => {
+            this._isNodesNotifyScheduled = false;
+            this.nodesChanges$.notify();
+        });
     }
-    emitConnectionChanges() {
+    /**
+     * Node ids whose connections need a redraw; `null` means "everything".
+     * Only the single-node resize/state path narrows the scope — every other
+     * emitter keeps today's full-redraw semantics.
+     */
+    _dirtyConnectionNodeIds = null;
+    emitConnectionChanges(dirtyNodeId) {
+        if (dirtyNodeId === undefined) {
+            this._dirtyConnectionNodeIds = null;
+        }
+        else {
+            this._dirtyConnectionNodeIds?.add(dirtyNodeId);
+        }
         this._connectionsRevision++;
-        this.connectionsChanges$.notify();
+        if (this._isConnectionsNotifyScheduled) {
+            return;
+        }
+        this._isConnectionsNotifyScheduled = true;
+        queueMicrotask(() => {
+            this._isConnectionsNotifyScheduled = false;
+            this.connectionsChanges$.notify();
+        });
+    }
+    /** Returns the accumulated scope and starts collecting a fresh one. */
+    takeConnectionsDirtyScope() {
+        const scope = this._dirtyConnectionNodeIds;
+        this._dirtyConnectionNodeIds = new Set();
+        return scope;
     }
     completeConnectionsRender(revision, nodesRevision) {
         if (revision < this._connectionsRenderedRevision ||
@@ -813,10 +899,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
 class CenterGroupOrNodeRequest {
     id;
     animated;
+    emitCanvasChange;
     static fToken = Symbol('CenterGroupOrNodeRequest');
-    constructor(id, animated) {
+    constructor(id, animated, emitCanvasChange = true) {
         this.id = id;
         this.animated = animated;
+        this.emitCanvasChange = emitCanvasChange;
     }
 }
 
@@ -829,13 +917,13 @@ let CenterGroupOrNode = class CenterGroupOrNode {
     get _transform() {
         return this._store.transform;
     }
-    handle({ id, animated }) {
+    handle({ id, animated, emitCanvasChange }) {
         const node = this._store.nodes.get(id);
         if (!node) {
             return;
         }
         this._toCenter(this._getNodeRect(node), this._getFlowRect(), node._position);
-        this._mediator.execute(new RedrawCanvasWithAnimationRequest(animated, ECanvasRedrawContext.VIEWPORT_ONLY));
+        this._mediator.execute(new RedrawCanvasWithAnimationRequest(animated, ECanvasRedrawContext.VIEWPORT_ONLY, emitCanvasChange));
     }
     _toCenter(fNodeRect, fFlowRect, position) {
         this._transform.scaledPosition = PointExtensions.initialize();
@@ -860,10 +948,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
 class FitToFlowRequest {
     toCenter;
     animated;
+    emitCanvasChange;
     static fToken = Symbol('FitToFlowRequest');
-    constructor(toCenter, animated) {
+    constructor(toCenter, animated, emitCanvasChange = true) {
         this.toCenter = toCenter;
         this.animated = animated;
+        this.emitCanvasChange = emitCanvasChange;
     }
 }
 
@@ -876,14 +966,14 @@ let FitToFlow = class FitToFlow {
         return this._store.transform;
     }
     _mediator = inject(FMediator);
-    handle({ toCenter, animated }) {
+    handle({ toCenter, animated, emitCanvasChange }) {
         const fNodesRect = this._mediator.execute(new CalculateNodesBoundingBoxRequest()) ||
             RectExtensions.initialize();
         if (fNodesRect.width === 0 || fNodesRect.height === 0) {
             return;
         }
         this.fitToParent(fNodesRect, RectExtensions.fromElement(this._store.flowHost), this._store.nodes.getAll().map((x) => x._position), toCenter);
-        this._mediator.execute(new RedrawCanvasWithAnimationRequest(animated, ECanvasRedrawContext.VIEWPORT_ONLY));
+        this._mediator.execute(new RedrawCanvasWithAnimationRequest(animated, ECanvasRedrawContext.VIEWPORT_ONLY, emitCanvasChange));
     }
     fitToParent(rect, parentRect, points, toCenter) {
         this._transform.scaledPosition = PointExtensions.initialize();
@@ -996,21 +1086,63 @@ var ECanvasRedrawContext;
 class RedrawCanvasWithAnimationRequest {
     animated;
     context;
+    emitCanvasChange;
     static fToken = Symbol('RedrawCanvasWithAnimationRequest');
-    constructor(animated, context = ECanvasRedrawContext.WITH_CONNECTION_CHANGES) {
+    constructor(animated, context = ECanvasRedrawContext.WITH_CONNECTION_CHANGES, emitCanvasChange = true) {
         this.animated = animated;
         this.context = context;
+        this.emitCanvasChange = emitCanvasChange;
     }
 }
 
+const TRANSITION_END_GRACE_MS = 50;
 function transitionEnd(element, callback) {
-    const onTransitionEnd = (event) => {
-        if (event.propertyName === 'transform') {
-            element.removeEventListener('transitionend', onTransitionEnd);
-            callback(event);
+    let completed = false;
+    let fallbackTimer = null;
+    const complete = () => {
+        if (completed) {
+            return;
+        }
+        completed = true;
+        element.removeEventListener('transitionend', onTransitionFinished);
+        element.removeEventListener('transitioncancel', onTransitionFinished);
+        if (fallbackTimer !== null) {
+            clearTimeout(fallbackTimer);
+        }
+        callback();
+    };
+    const onTransitionFinished = (event) => {
+        if (event.target === element && event.propertyName === 'transform') {
+            complete();
         }
     };
-    element.addEventListener('transitionend', onTransitionEnd);
+    element.addEventListener('transitionend', onTransitionFinished);
+    element.addEventListener('transitioncancel', onTransitionFinished);
+    fallbackTimer = setTimeout(complete, _transitionTimeout(element) + TRANSITION_END_GRACE_MS);
+}
+function _transitionTimeout(element) {
+    const view = element.ownerDocument.defaultView;
+    if (!view) {
+        return 0;
+    }
+    const styles = view.getComputedStyle(element);
+    const durations = _transitionTimes(styles.transitionDuration);
+    const delays = _transitionTimes(styles.transitionDelay);
+    const count = Math.max(durations.length, delays.length);
+    let result = 0;
+    for (let index = 0; index < count; index++) {
+        result = Math.max(result, durations[index % durations.length] + delays[index % delays.length]);
+    }
+    return result;
+}
+function _transitionTimes(value) {
+    const times = value.split(',').map((part) => {
+        const time = part.trim();
+        const multiplier = time.endsWith('ms') ? 1 : 1000;
+        const parsed = Number.parseFloat(time);
+        return Number.isFinite(parsed) ? parsed * multiplier : 0;
+    });
+    return times.length ? times : [0];
 }
 
 /**
@@ -1025,9 +1157,16 @@ let RedrawCanvasWithAnimation = class RedrawCanvasWithAnimation {
     }
     handle(request) {
         request.animated ? this._redrawWithAnimation(request.context) : this._redraw(request.context);
-        this._canvas?.emitCanvasChangeEvent();
+        if (request.emitCanvasChange) {
+            this._canvas?.emitCanvasChangeEvent();
+        }
     }
     _redrawWithAnimation(context) {
+        const targetTransform = TransformModelExtensions.toString(this._canvas.transform);
+        if (this._canvas.hostElement.style.transform === targetTransform) {
+            this._redraw(context);
+            return;
+        }
         this._store.beginViewportAnimation();
         this._canvas?.redrawWithAnimation();
         transitionEnd(this._canvas.hostElement, () => {
@@ -1103,9 +1242,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
 
 class ResetScaleAndCenterRequest {
     animated;
+    emitCanvasChange;
     static fToken = Symbol('ResetScaleAndCenterRequest');
-    constructor(animated) {
+    constructor(animated, emitCanvasChange = true) {
         this.animated = animated;
+        this.emitCanvasChange = emitCanvasChange;
     }
 }
 
@@ -1118,14 +1259,14 @@ let ResetScaleAndCenter = class ResetScaleAndCenter {
     get _transform() {
         return this._store.transform;
     }
-    handle({ animated }) {
+    handle({ animated, emitCanvasChange }) {
         const nodesRect = this._mediator.execute(new CalculateNodesBoundingBoxRequest()) ||
             RectExtensions.initialize();
         if (nodesRect.width === 0 || nodesRect.height === 0) {
             return;
         }
         this._oneToOneCentering(nodesRect, RectExtensions.fromElement(this._store.flowHost), this._store.nodes.getAll().map((x) => x._position));
-        this._mediator.execute(new RedrawCanvasWithAnimationRequest(animated, ECanvasRedrawContext.VIEWPORT_ONLY));
+        this._mediator.execute(new RedrawCanvasWithAnimationRequest(animated, ECanvasRedrawContext.VIEWPORT_ONLY, emitCanvasChange));
     }
     _oneToOneCentering(rect, parentRect, points) {
         this._transform.scaledPosition = PointExtensions.initialize();
@@ -3526,8 +3667,16 @@ function createSVGElement$1(tag, fBrowser) {
 
 class ConnectionRedrawState {
     renderTicket = 0;
+    /**
+     * False while a (possibly sliced/worker-async) pass is still running. A
+     * scoped redraw starting now would invalidate that pass mid-flight and leave
+     * its remaining connections undrawn, so pending scopes escalate to a full
+     * pass until the previous one completed.
+     */
+    isPassCompleted = true;
     _connectedInPreviousRender = new Set();
     beginRender() {
+        this.isPassCompleted = false;
         return ++this.renderTicket;
     }
     resetConnectedConnectors() {
@@ -4462,27 +4611,48 @@ let GetNormalizedConnectorRect = class GetNormalizedConnectorRect {
         this._mediator.execute(new UpdateFCacheRectByElementRequest(element, rect));
         return rect;
     }
+    /**
+     * Border radii are read through getComputedStyle — by far the priciest part
+     * of a connector measurement — yet they practically never change. They are
+     * cached per element and re-read only after the resize signal every node's
+     * ResizeObserver already bumps, which also covers font-size/percentage-based
+     * radii (those can only change alongside a layout change).
+     */
+    _rawRadiiCache = new WeakMap();
+    _radiiRevision = -1;
     _getElementRoundedRect(element) {
-        return this._getRoundedRect(RectExtensions.fromElement(element), element, this._getComputedStyle(element));
-    }
-    _getRoundedRect(rect, element, styles) {
-        const [radius1, radius2, radius3, radius4] = this._normalizeCircularBorderRadii(rect.width, rect.height, [
-            this._getSystemRadius(styles.borderTopLeftRadius, element, styles.fontSize),
-            this._getSystemRadius(styles.borderTopRightRadius, element, styles.fontSize),
-            this._getSystemRadius(styles.borderBottomRightRadius, element, styles.fontSize),
-            this._getSystemRadius(styles.borderBottomLeftRadius, element, styles.fontSize),
-        ]);
+        return this._getRoundedRect(RectExtensions.fromElement(element), element);
+    }
+    _getRoundedRect(rect, element) {
+        const { scale } = this._transform;
+        const rawRadii = this._resolveRawRadii(element);
+        const [radius1, radius2, radius3, radius4] = this._normalizeCircularBorderRadii(rect.width, rect.height, [rawRadii[0] * scale, rawRadii[1] * scale, rawRadii[2] * scale, rawRadii[3] * scale]);
         return new RoundedRect(rect.x, rect.y, rect.width, rect.height, radius1, radius2, radius3, radius4);
     }
+    _resolveRawRadii(element) {
+        if (this._radiiRevision !== this._store.connectionsRevision) {
+            this._radiiRevision = this._store.connectionsRevision;
+            this._rawRadiiCache = new WeakMap();
+        }
+        let radii = this._rawRadiiCache.get(element);
+        if (!radii) {
+            const styles = this._getComputedStyle(element);
+            radii = [
+                this._toPixels(styles.borderTopLeftRadius, element, styles.fontSize),
+                this._toPixels(styles.borderTopRightRadius, element, styles.fontSize),
+                this._toPixels(styles.borderBottomRightRadius, element, styles.fontSize),
+                this._toPixels(styles.borderBottomLeftRadius, element, styles.fontSize),
+            ];
+            this._rawRadiiCache.set(element, radii);
+        }
+        return radii;
+    }
     _getComputedStyle(element) {
         return this._browser.window.getComputedStyle(element);
     }
     _toPixels(value, element, fontSize) {
         return this._browser.toPixels(value, element.clientWidth, element.clientHeight, fontSize) || 0;
     }
-    _getSystemRadius(value, element, fontSize) {
-        return this._toPixels(value, element, fontSize) * this._transform.scale;
-    }
     /**
      * Mirrors CSS border-radius normalization so oversized values like `999px`
      * collapse to the largest valid circular radii for the current rect.
@@ -4718,6 +4888,13 @@ class FNodeBase extends MIXIN_BASE {
             this.setStyle('width', '' + this._size.width + 'px');
             this.setStyle('height', '' + this._size.height + 'px');
         }
+        else {
+            // Size was cleared (e.g. an undo restoring an auto-fit node back to its
+            // undefined, content-driven size) — drop the stale explicit dimensions
+            // instead of leaving the last measured box frozen on the element.
+            this.removeStyle('width');
+            this.removeStyle('height');
+        }
         this.setStyle('transform', `translate(${this._position.x}px,${this._position.y}px) rotate(${this._rotate}deg)`);
     }
     resetSize() {
@@ -4753,11 +4930,10 @@ class FNodeBase extends MIXIN_BASE {
 }
 
 let uniqueId$c = 0;
-const _DEBOUNCE_TIME$1 = 3;
 class FGroupDirective extends FNodeBase {
-    _debounceTimer = null;
     _destroyRef = inject(DestroyRef);
     _mediator = inject(FMediator);
+    _sidesScheduler = inject(ConnectableSidesScheduler);
     fId = input(`f-group-${uniqueId$c++}`, ...(ngDevMode ? [{ debugName: "fId", alias: 'fGroupId' }] : [{ alias: 'fGroupId' }]));
     fParentId = input(null, ...(ngDevMode ? [{ debugName: "fParentId", alias: 'fGroupParentId' }] : [{
             alias: 'fGroupParentId',
@@ -4823,13 +4999,7 @@ class FGroupDirective extends FNodeBase {
         if (!this.connectors.length) {
             return;
         }
-        if (this._debounceTimer) {
-            clearTimeout(this._debounceTimer);
-        }
-        this._debounceTimer = setTimeout(() => this._calculateNodeConnectorsConnectableSides(), _DEBOUNCE_TIME$1);
-    }
-    _calculateNodeConnectorsConnectableSides() {
-        this._mediator.execute(new CalculateConnectorsConnectableSidesRequest(this));
+        this._sidesScheduler.schedule(this);
     }
     ngAfterViewInit() {
         if (!this.browser.isBrowser()) {
@@ -4867,11 +5037,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
         }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { fId: [{ type: i0.Input, args: [{ isSignal: true, alias: "fGroupId", required: false }] }], fParentId: [{ type: i0.Input, args: [{ isSignal: true, alias: "fGroupParentId", required: false }] }], position: [{ type: i0.Input, args: [{ isSignal: true, alias: "fGroupPosition", required: false }] }, { type: i0.Output, args: ["fGroupPositionChange"] }], size: [{ type: i0.Input, args: [{ isSignal: true, alias: "fGroupSize", required: false }] }], sizeChange: [{ type: i0.Output, args: ["fGroupSizeChange"] }], rotate: [{ type: i0.Input, args: [{ isSignal: true, alias: "fGroupRotate", required: false }] }, { type: i0.Output, args: ["fGroupRotateChange"] }], fConnectOnNode: [{ type: i0.Input, args: [{ isSignal: true, alias: "fConnectOnNode", required: false }] }], fMinimapClass: [{ type: i0.Input, args: [{ isSignal: true, alias: "fMinimapClass", required: false }] }], fDraggingDisabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "fGroupDraggingDisabled", required: false }] }], fSelectionDisabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "fGroupSelectionDisabled", required: false }] }], fIncludePadding: [{ type: i0.Input, args: [{ isSignal: true, alias: "fIncludePadding", required: false }] }], fAutoExpandOnChildHit: [{ type: i0.Input, args: [{ isSignal: true, alias: "fAutoExpandOnChildHit", required: false }] }], fAutoSizeToFitChildren: [{ type: i0.Input, args: [{ isSignal: true, alias: "fAutoSizeToFitChildren", required: false }] }] } });
 
 let uniqueId$b = 0;
-const _DEBOUNCE_TIME = 3;
 class FNodeDirective extends FNodeBase {
-    _debounceTimer = null;
     _destroyRef = inject(DestroyRef);
     _mediator = inject(FMediator);
+    _sidesScheduler = inject(ConnectableSidesScheduler);
     fId = input(`f-node-${uniqueId$b++}`, ...(ngDevMode ? [{ debugName: "fId", alias: 'fNodeId',
             transform: (value) => stringAttribute(value) || `f-node-${uniqueId$b++}` }] : [{
             alias: 'fNodeId',
@@ -4941,13 +5110,7 @@ class FNodeDirective extends FNodeBase {
         if (!this.connectors.length) {
             return;
         }
-        if (this._debounceTimer) {
-            clearTimeout(this._debounceTimer);
-        }
-        this._debounceTimer = setTimeout(() => this._calculateNodeConnectorsConnectableSides(), _DEBOUNCE_TIME);
-    }
-    _calculateNodeConnectorsConnectableSides() {
-        this._mediator.execute(new CalculateConnectorsConnectableSidesRequest(this));
+        this._sidesScheduler.schedule(this);
     }
     ngAfterViewInit() {
         if (!this.browser.isBrowser()) {
@@ -4984,6 +5147,29 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
                 }]
         }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { fId: [{ type: i0.Input, args: [{ isSignal: true, alias: "fNodeId", required: false }] }], fParentId: [{ type: i0.Input, args: [{ isSignal: true, alias: "fNodeParentId", required: false }] }], position: [{ type: i0.Input, args: [{ isSignal: true, alias: "fNodePosition", required: false }] }, { type: i0.Output, args: ["fNodePositionChange"] }], size: [{ type: i0.Input, args: [{ isSignal: true, alias: "fNodeSize", required: false }] }], sizeChange: [{ type: i0.Output, args: ["fNodeSizeChange"] }], rotate: [{ type: i0.Input, args: [{ isSignal: true, alias: "fNodeRotate", required: false }] }, { type: i0.Output, args: ["fNodeRotateChange"] }], fConnectOnNode: [{ type: i0.Input, args: [{ isSignal: true, alias: "fConnectOnNode", required: false }] }], fMinimapClass: [{ type: i0.Input, args: [{ isSignal: true, alias: "fMinimapClass", required: false }] }], fDraggingDisabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "fNodeDraggingDisabled", required: false }] }], fSelectionDisabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "fNodeSelectionDisabled", required: false }] }], fIncludePadding: [{ type: i0.Input, args: [{ isSignal: true, alias: "fIncludePadding", required: false }] }], fAutoExpandOnChildHit: [{ type: i0.Input, args: [{ isSignal: true, alias: "fAutoExpandOnChildHit", required: false }] }], fAutoSizeToFitChildren: [{ type: i0.Input, args: [{ isSignal: true, alias: "fAutoSizeToFitChildren", required: false }] }] } });
 
+const NODE_OR_GROUP_HOST_SELECTOR = '[data-f-node-id], [data-f-group-id]';
+/**
+ * Resolves the node or group whose host contains the given element in
+ * O(DOM depth) via the host id attributes, instead of scanning every
+ * registered node with `hostElement.contains` on each pointerdown.
+ *
+ * Node and group hosts are siblings inside their layer containers, so an
+ * element belongs to at most one host; the instance check keeps the lookup
+ * correct when several flows share the page and reuse ids.
+ */
+function findNodeOrGroupContaining(store, element) {
+    const host = element.closest(NODE_OR_GROUP_HOST_SELECTOR);
+    if (!host) {
+        return undefined;
+    }
+    const id = host.getAttribute('data-f-node-id') ?? host.getAttribute('data-f-group-id');
+    if (id === null) {
+        return undefined;
+    }
+    const node = store.nodes.get(id);
+    return node?.hostElement === host ? node : undefined;
+}
+
 function isNode(element) {
     return !!element.closest('[fNode]');
 }
@@ -5031,7 +5217,11 @@ class FConnectorBase {
     }
     setConnected(toConnector) {
         this._isConnected = true;
-        this.toConnector.push(toConnector);
+        // Idempotent so scoped connection redraws can re-mark endpoints without
+        // resetting the whole graph's connected state first.
+        if (!this.toConnector.includes(toConnector)) {
+            this.toConnector.push(toConnector);
+        }
     }
     resetConnected() {
         this._isConnected = false;
@@ -5960,10 +6150,12 @@ class CompleteConnectionRedrawRequest {
 let CompleteConnectionRedraw = class CompleteConnectionRedraw {
     _mediator = inject(FMediator);
     _store = inject(FComponentsStore);
+    _state = inject(ConnectionRedrawState);
     handle({ session }) {
         if (!this._mediator.execute(new IsConnectionRedrawCurrentRequest(session))) {
             return;
         }
+        this._state.isPassCompleted = true;
         this._store.completeConnectionsRender(session.connectionsRevision, session.nodesRevision);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: CompleteConnectionRedraw, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
@@ -6104,14 +6296,24 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
         }] });
 
 class StartConnectionRedrawRequest {
+    resetConnectedState;
     static fToken = Symbol('StartConnectionRedrawRequest');
+    /**
+     * Scoped passes keep the connected state of untouched connections intact,
+     * so they must not reset the whole graph's connected connectors.
+     */
+    constructor(resetConnectedState = true) {
+        this.resetConnectedState = resetConnectedState;
+    }
 }
 
 let StartConnectionRedraw = class StartConnectionRedraw {
     _store = inject(FComponentsStore);
     _state = inject(ConnectionRedrawState);
-    handle(_) {
-        this._state.resetConnectedConnectors();
+    handle({ resetConnectedState }) {
+        if (resetConnectedState) {
+            this._state.resetConnectedConnectors();
+        }
         return {
             renderTicket: this._state.beginRender(),
             connectionsRevision: this._store.connectionsRevision,
@@ -6579,11 +6781,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
 let RedrawConnections = class RedrawConnections {
     _mediator = inject(FMediator);
     _store = inject(FComponentsStore);
+    _state = inject(ConnectionRedrawState);
     handle(_) {
-        const session = this._mediator.execute(new StartConnectionRedrawRequest());
+        const scope = this._resolveScope();
+        const session = this._mediator.execute(new StartConnectionRedrawRequest(scope === null));
         this._createMarkersForCreate();
         this._createMarkersForSnap();
-        const connections = [...this._store.connections.getAll()];
+        const connections = scope === null ? [...this._store.connections.getAll()] : this._connectionsTouching(scope);
         const connectorRectCache = new Map();
         if (!connections.length) {
             this._mediator.execute(new CompleteConnectionRedrawRequest(session));
@@ -6596,6 +6800,64 @@ let RedrawConnections = class RedrawConnections {
             this._redrawWithoutWorker(connections, connectorRectCache, session);
         }
     }
+    /**
+     * A pass narrowed to the nodes whose geometry actually changed (single-node
+     * resizes/state changes); `null` = redraw everything. Escalates to a full
+     * pass while a previous pass is still in flight, because starting a new
+     * session aborts the running one mid-slice.
+     */
+    _resolveScope() {
+        const scope = this._store.takeConnectionsDirtyScope();
+        if (scope === null || !this._state.isPassCompleted) {
+            return null;
+        }
+        return scope;
+    }
+    _connectionsTouching(nodeIds) {
+        if (!nodeIds.size) {
+            return [];
+        }
+        const hierarchyDirtyCache = new Map();
+        return this._store.connections.getAll().filter((connection) => {
+            const source = findSourceConnector(this._store, connection.sourceId());
+            const target = findTargetConnector(this._store, connection.targetId());
+            // Unresolved endpoints keep full-pass behavior for this connection.
+            if (!source || !target) {
+                return true;
+            }
+            return (this._isNodeHierarchyDirty(source.fNodeId, nodeIds, hierarchyDirtyCache) ||
+                this._isNodeHierarchyDirty(target.fNodeId, nodeIds, hierarchyDirtyCache));
+        });
+    }
+    /** A group geometry change also moves every endpoint owned by its descendants. */
+    _isNodeHierarchyDirty(nodeId, dirtyNodeIds, cache) {
+        const cached = cache.get(nodeId);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const path = [];
+        const visited = new Set();
+        let currentId = nodeId;
+        let isDirty = false;
+        while (currentId && !visited.has(currentId)) {
+            const currentCached = cache.get(currentId);
+            if (currentCached !== undefined) {
+                isDirty = currentCached;
+                break;
+            }
+            path.push(currentId);
+            visited.add(currentId);
+            if (dirtyNodeIds.has(currentId)) {
+                isDirty = true;
+                break;
+            }
+            currentId = this._store.nodes.get(currentId)?.fParentId();
+        }
+        for (const id of path) {
+            cache.set(id, isDirty);
+        }
+        return isDirty;
+    }
     _createMarkersForCreate() {
         const instance = this._store.connections.getForCreate();
         if (instance) {
@@ -7332,14 +7594,31 @@ class DragCanvasFinalizeRequest {
     }
 }
 
+/** Returns `event.target`, falling back to its composed path only after Shadow DOM retargeting. */
+function getEventTargetElement(event, boundarySelector) {
+    const target = event.target;
+    const targetElement = target instanceof HTMLElement || target instanceof SVGElement ? target : null;
+    if (targetElement && (!boundarySelector || targetElement.closest(boundarySelector))) {
+        return targetElement;
+    }
+    const path = typeof event.composedPath === 'function' ? event.composedPath() : [];
+    for (const pathTarget of path) {
+        if (pathTarget instanceof HTMLElement || pathTarget instanceof SVGElement) {
+            if (!boundarySelector || pathTarget.closest(boundarySelector)) {
+                return pathTarget;
+            }
+        }
+    }
+    return targetElement;
+}
+
 class IPointerEvent {
     _event;
-    _target;
     get originalEvent() {
         return this._event;
     }
     get targetElement() {
-        return this._target || this.originalEvent.target;
+        return this._target;
     }
     get touchEvent() {
         return this._event;
@@ -7347,9 +7626,12 @@ class IPointerEvent {
     get touches() {
         return this.touchEvent.touches;
     }
-    constructor(_event, _target) {
+    _target;
+    constructor(_event, target) {
         this._event = _event;
-        this._target = _target;
+        // Drag preparation may run after dispatch, when composedPath() is already empty.
+        this._target =
+            target ?? getEventTargetElement(_event, 'f-flow, .f-external-item');
     }
     setTarget(target) {
         this._target = target;
@@ -8411,7 +8693,7 @@ let CreateConnectionPreparation = class CreateConnectionPreparation {
         }
     }
     _findOwnerNode(target) {
-        return this._store.nodes.getAll().find((n) => n.isContains(target));
+        return findNodeOrGroupContaining(this._store, target);
     }
     _isValidConditions() {
         // A session armed by another gesture (e.g. click-to-connect) must not be
@@ -9514,6 +9796,12 @@ class DragNodeItemHandler extends DragHandlerBase {
                 continue;
             }
             const soft = this._constraints.soft[i];
+            // When the group also auto-sizes to its children, the post-drop fit
+            // emits the settled size — skip this transient expanded rect so the
+            // consumer sees one final `sizeChange` per drag, not expand-then-fit.
+            if (soft.nodeOrGroup.fAutoSizeToFitChildren()) {
+                continue;
+            }
             const expandedRect = expandRectByOverflow(soft.boundingRect, r.overflow, r.edges);
             soft.nodeOrGroup.sizeChange.emit(expandedRect);
         }
@@ -11163,16 +11451,8 @@ let DragNodePreparation = class DragNodePreparation {
         return isClosestElementHasClass(element, '.f-drag-handle');
     }
     _findDraggableNode(target) {
-        const nodes = this._store.nodes.getAll();
-        for (const node of nodes) {
-            if (node.fDraggingDisabled()) {
-                continue;
-            }
-            if (node.isContains(target)) {
-                return node;
-            }
-        }
-        return undefined;
+        const node = findNodeOrGroupContaining(this._store, target);
+        return node && !node.fDraggingDisabled() ? node : undefined;
     }
     _storePointerDownContext(event) {
         this._dragSession.onPointerDownScale = this._store.transform.scale;
@@ -11541,6 +11821,33 @@ function isDragExternalItemHandler(value) {
         value.getEvent().fEventType === DRAG_EXTERNAL_ITEM_HANDLER_TYPE);
 }
 
+/**
+ * Returns hit-test results across nested open shadow roots, ordered from the
+ * deepest matching element to the outermost one.
+ */
+function getDeepElementsFromPoint(root, x, y) {
+    const result = [];
+    const visitedElements = new Set();
+    const visitedRoots = new Set();
+    const collect = (currentRoot) => {
+        if (visitedRoots.has(currentRoot)) {
+            return;
+        }
+        visitedRoots.add(currentRoot);
+        for (const element of currentRoot.elementsFromPoint(x, y)) {
+            if (element.shadowRoot) {
+                collect(element.shadowRoot);
+            }
+            if (!visitedElements.has(element)) {
+                visitedElements.add(element);
+                result.push(element);
+            }
+        }
+    };
+    collect(root);
+    return result;
+}
+
 let DragExternalItemFinalize = class DragExternalItemFinalize {
     _result = inject(FDragHandlerResult);
     _mediator = inject(FMediator);
@@ -11577,9 +11884,7 @@ let DragExternalItemFinalize = class DragExternalItemFinalize {
         return result;
     }
     _getElementsFromPoint(position) {
-        return this._browser.document
-            .elementsFromPoint(position.x, position.y)
-            .filter((x) => !x.closest('.f-external-item') && !x.closest('.f-external-item-preview'));
+        return getDeepElementsFromPoint(this._browser.document, position.x, position.y).filter((x) => !x.closest('.f-external-item') && !x.closest('.f-external-item-preview'));
     }
     _emitEvent(elements, destinationNodeOrGroupId, eventPosition) {
         if (this._isPointerInCanvasRect(elements)) {
@@ -12096,7 +12401,17 @@ let DropToGroupPreparation = class DropToGroupPreparation {
         if (!this._canPrepare()) {
             return;
         }
-        const dragTargetNode = this._allNodes.find((n) => n.isContains(event.targetElement));
+        // Drop-to-group can be switched off (`fDropToGroup` = false). We still
+        // register the handler — the external-item finalize asks it for a target
+        // container and throws if none exists — but with no candidates it never
+        // activates a target, so nothing is reparented and no highlight appears.
+        if (!this._isDropToGroupEnabled()) {
+            const handler = this._dragInjector.get(DropToGroupHandler);
+            handler.initialize([]);
+            this._dragContext.draggableItems.push(handler);
+            return;
+        }
+        const dragTargetNode = findNodeOrGroupContaining(this._store, event.targetElement);
         // If this is not an external drag and we can't resolve a target node — it's an invalid state.
         if (!dragTargetNode && !this._hasExternalDrag()) {
             throw new Error('Drag target node not found');
@@ -12114,6 +12429,9 @@ let DropToGroupPreparation = class DropToGroupPreparation {
         handler.initialize(targets);
         this._dragContext.draggableItems.push(handler);
     }
+    _isDropToGroupEnabled() {
+        return this._store.fDraggable?.dropToGroup() !== false;
+    }
     _canPrepare() {
         return this._hasMoveDrag() || this._hasExternalDrag();
     }
@@ -14245,6 +14563,7 @@ var EFFlowFeatureKind;
     EFFlowFeatureKind["CONTROL_SCHEME"] = "control-scheme";
     EFFlowFeatureKind["CONNECTION_FLOW"] = "connection-flow";
     EFFlowFeatureKind["A11Y"] = "a11y";
+    EFFlowFeatureKind["STATE"] = "state";
 })(EFFlowFeatureKind || (EFFlowFeatureKind = {}));
 
 function provideFFlow(configOrFeature, ...rest) {
@@ -14654,7 +14973,7 @@ let ResizeNodePreparation = class ResizeNodePreparation {
         return isClosestElementHasClass(target, '.f-resize-handle');
     }
     _findResizableNode(target) {
-        const nodeOrGroup = this._store.nodes.getAll().find((x) => x.isContains(target));
+        const nodeOrGroup = findNodeOrGroupContaining(this._store, target);
         if (!nodeOrGroup) {
             return undefined;
         }
@@ -14874,15 +15193,8 @@ let RotateNodePreparation = class RotateNodePreparation {
             isValidEventTrigger(event.originalEvent, fTrigger));
     }
     _findRotatableNode(target) {
-        for (const node of this._store.nodes.getAll()) {
-            if (node.fDraggingDisabled()) {
-                continue;
-            }
-            if (node.isContains(target)) {
-                return node;
-            }
-        }
-        return undefined;
+        const node = findNodeOrGroupContaining(this._store, target);
+        return node && !node.fDraggingDisabled() ? node : undefined;
     }
     _selectBeforeRotate(node) {
         queueMicrotask(() => {
@@ -15330,7 +15642,7 @@ let DragCanvasPreparation = class DragCanvasPreparation {
         return this._store.flowHost.contains(targetElement) && !this._getNode(targetElement);
     }
     _getNode(targetElement) {
-        let result = this._store.nodes.getAll().find((x) => x.isContains(targetElement));
+        let result = findNodeOrGroupContaining(this._store, targetElement);
         if (result && result.fDraggingDisabled()) {
             result = undefined;
         }
@@ -15433,7 +15745,7 @@ let SelectByPointer = class SelectByPointer {
         return this._findNodeOrGroupAt(target) ?? this._findConnectionAt(target);
     }
     _findNodeOrGroupAt(target) {
-        return this._store.nodes.getAll().find((x) => x.isContains(target));
+        return findNodeOrGroupContaining(this._store, target);
     }
     _findConnectionAt(target) {
         return this._store.connections.getAll().find((x) => x.isContains(target));
@@ -15560,7 +15872,7 @@ const F_DEFAULT_CONTROL_SCHEME = {
  * while a left-drag on a node still moves it.
  */
 function isOnFlowBackground(event) {
-    const target = event.target;
+    const target = getEventTargetElement(event, 'f-flow');
     return (!!target && !isNode(target) && !target.closest('[fGroup]') && !target.closest('.f-connection'));
 }
 
@@ -15728,7 +16040,10 @@ class FClickConnectFlow {
         if (traveled > CLICK_MOVE_TOLERANCE) {
             return;
         }
-        const target = event.target;
+        const target = getEventTargetElement(event, 'f-flow');
+        if (!target) {
+            return;
+        }
         if (!this._store.flowHost?.contains(target)) {
             return;
         }
@@ -15778,10 +16093,11 @@ class FClickConnectFlow {
             return;
         }
         // Clicking another source connector re-arms from it; anything else cancels.
-        const nextSource = this._resolveSource(event.target);
+        const target = getEventTargetElement(event, 'f-flow');
+        const nextSource = target ? this._resolveSource(target) : undefined;
         this._cancel();
-        if (nextSource) {
-            this._arm(event, event.target);
+        if (nextSource && target) {
+            this._arm(event, target);
         }
     }
     _cancel() {
@@ -15910,6 +16226,12 @@ class FDraggableDirective extends FDraggableBase {
     _nodeMoveTrigger;
     _canvasMoveTrigger;
     disabled = false;
+    /** Turns the drop-to-group gesture on/off. See `FDraggableBase.dropToGroup`. */
+    dropToGroup = input(true, ...(ngDevMode ? [{ debugName: "dropToGroup", transform: (value) => booleanAttribute(value),
+            alias: 'fDropToGroup' }] : [{
+            transform: (value) => booleanAttribute(value),
+            alias: 'fDropToGroup',
+        }]));
     fMultiSelectTrigger = (event) => {
         return this._platform.getOS() === EOperationSystem.MAC_OS ? event.metaKey : event.ctrlKey;
     };
@@ -16010,6 +16332,46 @@ class FDraggableDirective extends FDraggableBase {
             this._connectionFlow.initialize();
         }
     }
+    /**
+     * Gesture claim chain, phase by phase. WITHIN EACH LIST THE ORDER IS THE
+     * PRIORITY CONTRACT: every preparation guards itself with
+     * `FDraggableDataContext.isEmpty()`, so the first entry that claims the
+     * pointer wins and everything after it backs off. The three phases are
+     * intentionally ordered independently — finalization is not a mirror of
+     * preparation (e.g. pinch-to-zoom finalizes last so slower gestures settle
+     * first).
+     */
+    _pointerDownClaimants = [
+        (event) => this._mediator.execute(new SelectionAreaPreparationRequest(event)),
+        (event) => this._mediator.execute(new DragMinimapPreparationRequest(event)),
+        (event) => this._mediator.execute(new PinchToZoomPreparationRequest(event)),
+        (event) => this._mediator.execute(new SelectByPointerRequest(event, this.fMultiSelectTrigger)),
+        (event) => this._mediator.execute(new ReassignConnectionPreparationRequest(event, this.fReassignConnectionTrigger)),
+        (event) => this._mediator.execute(new CreateConnectionPreparationRequest(event, this.fCreateConnectionTrigger)),
+        (event) => this._mediator.execute(new DragConnectionWaypointPreparationRequest(event, this.fConnectionWaypointsTrigger())),
+    ];
+    _thresholdClaimants = [
+        (event) => this._mediator.execute(new ResizeNodePreparationRequest(event, this.fNodeResizeTrigger)),
+        (event) => this._mediator.execute(new RotateNodePreparationRequest(event, this.fNodeRotateTrigger)),
+        (event) => this._mediator.execute(new DragNodePreparationRequest(event, this.fNodeMoveTrigger)),
+        (event) => this._mediator.execute(new DragExternalItemPreparationRequest(event, this.fExternalItemTrigger)),
+        (event) => this._mediator.execute(new DropToGroupPreparationRequest(event)),
+        (event) => this._mediator.execute(new DragCanvasPreparationRequest(event, this.fCanvasMoveTrigger)),
+    ];
+    _pointerUpFinalizers = [
+        (event) => this._mediator.execute(new DragMinimapFinalizeRequest(event)),
+        (event) => this._mediator.execute(new SelectionAreaFinalizeRequest(event)),
+        (event) => this._mediator.execute(new ReassignConnectionFinalizeRequest(event)),
+        (event) => this._mediator.execute(new CreateConnectionFinalizeRequest(event)),
+        (event) => this._mediator.execute(new ResizeNodeFinalizeRequest(event)),
+        (event) => this._mediator.execute(new RotateNodeFinalizeRequest(event)),
+        (event) => this._mediator.execute(new DragNodeFinalizeRequest(event)),
+        (event) => this._mediator.execute(new DragExternalItemFinalizeRequest(event)),
+        (event) => this._mediator.execute(new DropToGroupFinalizeRequest(event)),
+        (event) => this._mediator.execute(new DragCanvasFinalizeRequest(event)),
+        (event) => this._mediator.execute(new PinchToZoomFinalizeRequest(event)),
+        (event) => this._mediator.execute(new DragConnectionWaypointFinalizeRequest(event)),
+    ];
     onPointerDown(event) {
         if (isDragBlocker(event.targetElement)) {
             return false;
@@ -16017,13 +16379,7 @@ class FDraggableDirective extends FDraggableBase {
         this._dragHandlerInjector.create();
         this._result.clear();
         this._mediator.execute(new InitializeDragSequenceRequest());
-        this._mediator.execute(new SelectionAreaPreparationRequest(event));
-        this._mediator.execute(new DragMinimapPreparationRequest(event));
-        this._mediator.execute(new PinchToZoomPreparationRequest(event));
-        this._mediator.execute(new SelectByPointerRequest(event, this.fMultiSelectTrigger));
-        this._mediator.execute(new ReassignConnectionPreparationRequest(event, this.fReassignConnectionTrigger));
-        this._mediator.execute(new CreateConnectionPreparationRequest(event, this.fCreateConnectionTrigger));
-        this._mediator.execute(new DragConnectionWaypointPreparationRequest(event, this.fConnectionWaypointsTrigger()));
+        this._pointerDownClaimants.forEach((claim) => claim(event));
         // The left button and touch drive every interaction. The middle button joins only
         // when the active scheme's `canvasMove` gesture claims it (e.g. middle-drag pan in
         // the scroll-pan / drag-select schemes); with the default scheme it stays inert.
@@ -16035,12 +16391,7 @@ class FDraggableDirective extends FDraggableBase {
         return isDraggableButton;
     }
     prepareDragSequence(event) {
-        this._mediator.execute(new ResizeNodePreparationRequest(event, this.fNodeResizeTrigger));
-        this._mediator.execute(new RotateNodePreparationRequest(event, this.fNodeRotateTrigger));
-        this._mediator.execute(new DragNodePreparationRequest(event, this.fNodeMoveTrigger));
-        this._mediator.execute(new DragExternalItemPreparationRequest(event, this.fExternalItemTrigger));
-        this._mediator.execute(new DropToGroupPreparationRequest(event));
-        this._mediator.execute(new DragCanvasPreparationRequest(event, this.fCanvasMoveTrigger));
+        this._thresholdClaimants.forEach((claim) => claim(event));
         this._mediator.execute(new PrepareDragSequenceRequest());
     }
     onSelect(event) {
@@ -16051,18 +16402,7 @@ class FDraggableDirective extends FDraggableBase {
         this._mediator.execute(new ScheduleAutoPanFrameRequest());
     }
     onPointerUp(event) {
-        this._mediator.execute(new DragMinimapFinalizeRequest(event));
-        this._mediator.execute(new SelectionAreaFinalizeRequest(event));
-        this._mediator.execute(new ReassignConnectionFinalizeRequest(event));
-        this._mediator.execute(new CreateConnectionFinalizeRequest(event));
-        this._mediator.execute(new ResizeNodeFinalizeRequest(event));
-        this._mediator.execute(new RotateNodeFinalizeRequest(event));
-        this._mediator.execute(new DragNodeFinalizeRequest(event));
-        this._mediator.execute(new DragExternalItemFinalizeRequest(event));
-        this._mediator.execute(new DropToGroupFinalizeRequest(event));
-        this._mediator.execute(new DragCanvasFinalizeRequest(event));
-        this._mediator.execute(new PinchToZoomFinalizeRequest(event));
-        this._mediator.execute(new DragConnectionWaypointFinalizeRequest(event));
+        this._pointerUpFinalizers.forEach((finalize) => finalize(event));
         this._mediator.execute(new EmitEndDragSequenceEventRequest());
     }
     finalizeDragSequence() {
@@ -16078,7 +16418,7 @@ class FDraggableDirective extends FDraggableBase {
         super.unsubscribe();
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: FDraggableDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.9", type: FDraggableDirective, isStandalone: false, selector: "f-flow[fDraggable]", inputs: { disabled: { classPropertyName: "disabled", publicName: "fDraggableDisabled", isSignal: false, isRequired: false, transformFunction: booleanAttribute }, fMultiSelectTrigger: { classPropertyName: "fMultiSelectTrigger", publicName: "fMultiSelectTrigger", isSignal: false, isRequired: false, transformFunction: null }, fReassignConnectionTrigger: { classPropertyName: "fReassignConnectionTrigger", publicName: "fReassignConnectionTrigger", isSignal: false, isRequired: false, transformFunction: null }, fCreateConnectionTrigger: { classPropertyName: "fCreateConnectionTrigger", publicName: "fCreateConnectionTrigger", isSignal: false, isRequired: false, transformFunction: null }, fConnectionWaypointsTrigger: { classPropertyName: "fConnectionWaypointsTrigger", publicName: "fConnectionWaypointsTrigger", isSignal: true, isRequired: false, transformFunction: null }, fMoveControlPointTrigger: { classPropertyName: "fMoveControlPointTrigger", publicName: "fMoveControlPointTrigger", isSignal: false, isRequired: false, transformFunction: null }, fNodeResizeTrigger: { classPropertyName: "fNodeResizeTrigger", publicName: "fNodeResizeTrigger", isSignal: false, isRequired: false, transformFunction: null }, fNodeRotateTrigger: { classPropertyName: "fNodeRotateTrigger", publicName: "fNodeRotateTrigger", isSignal: false, isRequired: false, transformFunction: null }, fNodeMoveTrigger: { classPropertyName: "fNodeMoveTrigger", publicName: "fNodeMoveTrigger", isSignal: false, isRequired: false, transformFunction: null }, fCanvasMoveTrigger: { classPropertyName: "fCanvasMoveTrigger", publicName: "fCanvasMoveTrigger", isSignal: false, isRequired: false, transformFunction: null }, fExternalItemTrigger: { classPropertyName: "fExternalItemTrigger", publicName: "fExternalItemTrigger", isSignal: false, isRequired: false, transformFunction: null }, fEmitOnNodeIntersect: { classPropertyName: "fEmitOnNodeIntersect", publicName: "fEmitOnNodeIntersect", isSignal: false, isRequired: false, transformFunction: booleanAttribute }, vCellSize: { classPropertyName: "vCellSize", publicName: "vCellSize", isSignal: true, isRequired: false, transformFunction: null }, hCellSize: { classPropertyName: "hCellSize", publicName: "hCellSize", isSignal: true, isRequired: false, transformFunction: null }, fCellSizeWhileDragging: { classPropertyName: "fCellSizeWhileDragging", publicName: "fCellSizeWhileDragging", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { fSelectionChange: "fSelectionChange", fDeleteSelected: "fDeleteSelected", fNodeIntersectedWithConnections: "fNodeIntersectedWithConnections", fNodeConnectionsIntersection: "fNodeConnectionsIntersection", fCreateNode: "fCreateNode", fMoveNodes: "fMoveNodes", fReassignConnection: "fReassignConnection", fCreateConnection: "fCreateConnection", fConnectionWaypointsChanged: "fConnectionWaypointsChanged", fDropToGroup: "fDropToGroup", fDragStarted: "fDragStarted", fDragEnded: "fDragEnded" }, providers: [FDragHandlerResult, DragHandlerInjector], exportAs: ["fDraggable"], usesInheritance: true, ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.9", type: FDraggableDirective, isStandalone: false, selector: "f-flow[fDraggable]", inputs: { disabled: { classPropertyName: "disabled", publicName: "fDraggableDisabled", isSignal: false, isRequired: false, transformFunction: booleanAttribute }, dropToGroup: { classPropertyName: "dropToGroup", publicName: "fDropToGroup", isSignal: true, isRequired: false, transformFunction: null }, fMultiSelectTrigger: { classPropertyName: "fMultiSelectTrigger", publicName: "fMultiSelectTrigger", isSignal: false, isRequired: false, transformFunction: null }, fReassignConnectionTrigger: { classPropertyName: "fReassignConnectionTrigger", publicName: "fReassignConnectionTrigger", isSignal: false, isRequired: false, transformFunction: null }, fCreateConnectionTrigger: { classPropertyName: "fCreateConnectionTrigger", publicName: "fCreateConnectionTrigger", isSignal: false, isRequired: false, transformFunction: null }, fConnectionWaypointsTrigger: { classPropertyName: "fConnectionWaypointsTrigger", publicName: "fConnectionWaypointsTrigger", isSignal: true, isRequired: false, transformFunction: null }, fMoveControlPointTrigger: { classPropertyName: "fMoveControlPointTrigger", publicName: "fMoveControlPointTrigger", isSignal: false, isRequired: false, transformFunction: null }, fNodeResizeTrigger: { classPropertyName: "fNodeResizeTrigger", publicName: "fNodeResizeTrigger", isSignal: false, isRequired: false, transformFunction: null }, fNodeRotateTrigger: { classPropertyName: "fNodeRotateTrigger", publicName: "fNodeRotateTrigger", isSignal: false, isRequired: false, transformFunction: null }, fNodeMoveTrigger: { classPropertyName: "fNodeMoveTrigger", publicName: "fNodeMoveTrigger", isSignal: false, isRequired: false, transformFunction: null }, fCanvasMoveTrigger: { classPropertyName: "fCanvasMoveTrigger", publicName: "fCanvasMoveTrigger", isSignal: false, isRequired: false, transformFunction: null }, fExternalItemTrigger: { classPropertyName: "fExternalItemTrigger", publicName: "fExternalItemTrigger", isSignal: false, isRequired: false, transformFunction: null }, fEmitOnNodeIntersect: { classPropertyName: "fEmitOnNodeIntersect", publicName: "fEmitOnNodeIntersect", isSignal: false, isRequired: false, transformFunction: booleanAttribute }, vCellSize: { classPropertyName: "vCellSize", publicName: "vCellSize", isSignal: true, isRequired: false, transformFunction: null }, hCellSize: { classPropertyName: "hCellSize", publicName: "hCellSize", isSignal: true, isRequired: false, transformFunction: null }, fCellSizeWhileDragging: { classPropertyName: "fCellSizeWhileDragging", publicName: "fCellSizeWhileDragging", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { fSelectionChange: "fSelectionChange", fDeleteSelected: "fDeleteSelected", fNodeIntersectedWithConnections: "fNodeIntersectedWithConnections", fNodeConnectionsIntersection: "fNodeConnectionsIntersection", fCreateNode: "fCreateNode", fMoveNodes: "fMoveNodes", fReassignConnection: "fReassignConnection", fCreateConnection: "fCreateConnection", fConnectionWaypointsChanged: "fConnectionWaypointsChanged", fDropToGroup: "fDropToGroup", fDragStarted: "fDragStarted", fDragEnded: "fDragEnded" }, host: { properties: { "class.f-drop-to-group": "dropToGroup()" } }, providers: [FDragHandlerResult, DragHandlerInjector], exportAs: ["fDraggable"], usesInheritance: true, ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: FDraggableDirective, decorators: [{
             type: Directive,
@@ -16087,11 +16427,16 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
                     selector: 'f-flow[fDraggable]',
                     exportAs: 'fDraggable',
                     providers: [FDragHandlerResult, DragHandlerInjector],
+                    host: {
+                        // On by default: marks the flow so the grouping styles (drop-target
+                        // highlight) apply. Cleared reactively when `fDropToGroup` is set to false.
+                        '[class.f-drop-to-group]': 'dropToGroup()',
+                    },
                 }]
         }], propDecorators: { disabled: [{
                 type: Input,
                 args: [{ transform: booleanAttribute, alias: 'fDraggableDisabled' }]
-            }], fMultiSelectTrigger: [{
+            }], dropToGroup: [{ type: i0.Input, args: [{ isSignal: true, alias: "fDropToGroup", required: false }] }], fMultiSelectTrigger: [{
                 type: Input
             }], fReassignConnectionTrigger: [{
                 type: Input
@@ -16437,7 +16782,7 @@ let FindConnectableConnectorUsingPriorityAndPosition = class FindConnectableConn
             .find((x) => !!x);
     }
     _getElementsFromPoint(position) {
-        return this._browser.document.elementsFromPoint(position.x, position.y);
+        return getDeepElementsFromPoint(this._browser.document, position.x, position.y);
     }
     _findConnectableNode(element) {
         return this._fNodes.find((x) => x.isContains(element) && x.fConnectOnNode());
@@ -16836,8 +17181,11 @@ let OnPointerMove = class OnPointerMove {
         this._setDifferenceToDraggableItems(this._getDifferenceBetweenPointerAndPointerDown(event), event);
     }
     _setDifferenceToDraggableItems(difference, event) {
+        // One object per event, shared read-only by every handler: spreading a copy
+        // per handler allocated hundreds of points per pointermove on multi-select
+        // drags, and no handler mutates the difference.
         this._dragContext.draggableItems.forEach((item) => {
-            item.onPointerMove({ ...difference }, event);
+            item.onPointerMove(difference, event);
         });
     }
     _getDifferenceBetweenPointerAndPointerDown(event) {
@@ -17157,6 +17505,44 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
             type: Injectable
         }] });
 
+const DEBOUNCE_TIME_MS = 3;
+/**
+ * Debounces connectable-side recalculation for all nodes through ONE timer.
+ * Every node used to own a clearTimeout+setTimeout pair re-armed on each
+ * redraw — a multi-node drag churned N timers per pointer event. Nodes are
+ * collected into a set and flushed together 3ms after the last redraw.
+ */
+class ConnectableSidesScheduler {
+    _mediator = inject(FMediator);
+    _store = inject(FComponentsStore);
+    _pending = new Set();
+    _timer = null;
+    schedule(node) {
+        this._pending.add(node);
+        if (this._timer !== null) {
+            clearTimeout(this._timer);
+        }
+        this._timer = setTimeout(() => {
+            this._timer = null;
+            this._flush();
+        }, DEBOUNCE_TIME_MS);
+    }
+    _flush() {
+        for (const node of this._pending) {
+            // A node destroyed while queued must not be recalculated.
+            if (this._store.nodes.get(node.fId()) === node) {
+                this._mediator.execute(new CalculateConnectorsConnectableSidesRequest(node));
+            }
+        }
+        this._pending.clear();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: ConnectableSidesScheduler, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: ConnectableSidesScheduler });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: ConnectableSidesScheduler, decorators: [{
+            type: Injectable
+        }] });
+
 class CalculateNodesBoundingBoxRequest {
     static fToken = Symbol('CalculateNodesBoundingBoxRequest');
 }
@@ -17333,10 +17719,24 @@ let FitToChildNodesAndGroups = class FitToChildNodesAndGroups {
             if (directChildren.length) {
                 const currentBounding = this._boundingRect(nodeOrGroup);
                 const childrenBounding = this._calculateChildrenBounding(directChildren, this._paddings(nodeOrGroup, currentBounding));
+                // Capture the node's OWN stored rect before applying the fit. The DOM
+                // measurement (`currentBounding`) lags a frame behind `redraw`, so the
+                // convergence pass (redraw → ResizeObserver → fit again) would still
+                // see the old measurement and re-emit the same size — a duplicate.
+                const previousRect = this._storedRect(nodeOrGroup);
                 nodeOrGroup.updatePosition(childrenBounding);
                 nodeOrGroup.updateSize(childrenBounding);
                 nodeOrGroup.redraw();
+                // Auto-size is a resize like any other: notify `fNodeSizeChange` /
+                // `fGroupSizeChange`, but only when the fit actually changed the box,
+                // so a settled fit stays silent and can't feed a resize loop.
+                if (!previousRect || !this._isSameRect(previousRect, childrenBounding)) {
+                    nodeOrGroup.sizeChange.emit(childrenBounding);
+                }
             }
+            // No children: nothing to fit to. The group keeps whatever size it was
+            // told to have via `fGroupSize` — the binding (e.g. restored by undo)
+            // is the source of truth; the fit must not invent a size here.
         }
         const parent = nodeOrGroup.fParentId();
         if (!parent) {
@@ -17366,6 +17766,17 @@ let FitToChildNodesAndGroups = class FitToChildNodesAndGroups {
         childrenBounding = RectExtensions.initialize(childrenBounding.x - left, childrenBounding.y - top, childrenBounding.width + left + right, childrenBounding.height + top + bottom);
         return childrenBounding;
     }
+    _storedRect(nodeOrGroup) {
+        return nodeOrGroup._size
+            ? RectExtensions.initialize(nodeOrGroup._position.x, nodeOrGroup._position.y, nodeOrGroup._size.width, nodeOrGroup._size.height)
+            : null;
+    }
+    _isSameRect(a, b) {
+        return (Math.round(a.x) === Math.round(b.x) &&
+            Math.round(a.y) === Math.round(b.y) &&
+            Math.round(a.width) === Math.round(b.width) &&
+            Math.round(a.height) === Math.round(b.height));
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: FitToChildNodesAndGroups, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: FitToChildNodesAndGroups });
 };
@@ -17484,6 +17895,7 @@ class UpdateNodeWhenStateOrSizeChangedRequest {
 let UpdateNodeWhenStateOrSizeChanged = class UpdateNodeWhenStateOrSizeChanged {
     _mediator = inject(FMediator);
     _reflowOrchestrator = inject(FReflowOrchestrator);
+    _injector = inject(Injector);
     /**
      * Handles the request to update the node's connectors based on state or size changes.
      * It listens for resize events and recalculates the connectable sides of the connectors.
@@ -17494,11 +17906,25 @@ let UpdateNodeWhenStateOrSizeChanged = class UpdateNodeWhenStateOrSizeChanged {
         new FChannelHub(new FResizeChannel(hostElement), stateChanges)
             // .pipe(afterNextPaint()) // Removed: caused ~32ms lag on resize/toggle. Debounce is sufficient for DOM stability.
             .listen(destroyRef, () => {
-            this._mediator.execute(new EmitConnectionsChangesRequest());
+            // Scoped: a single node's resize/state change only needs its own
+            // connections redrawn, not a whole-graph pass.
+            this._mediator.execute(new EmitConnectionsChangesRequest(nodeOrGroup.fId()));
             if (!this._isDragging()) {
                 this._mediator.execute(new InvalidateFCacheNodeRequest(nodeOrGroup.fId(), 'UpdateNodeWhenStateOrSizeChanged'));
                 this._mediator.execute(new CalculateConnectorsConnectableSidesRequest(nodeOrGroup));
-                this._mediator.execute(new FitToChildNodesAndGroupsRequest(nodeOrGroup));
+                // Auto-fit must read FRESH child parentage. On a state-driven change
+                // (e.g. undo re-parenting a child out), the fit would otherwise run
+                // inside this same synchronous tick — before Angular propagates the
+                // new `[fNodeParentId]` into the child directives — and count a
+                // just-removed child, re-shrinking the group. Deferring only the fit
+                // to the next render hook (same CD cycle, before paint) lets it see
+                // the settled parentage. Content/plain resizes keep today's sync path.
+                if (nodeOrGroup.fAutoSizeToFitChildren()) {
+                    afterNextRender(() => this._mediator.execute(new FitToChildNodesAndGroupsRequest(nodeOrGroup)), { injector: this._injector });
+                }
+                else {
+                    this._mediator.execute(new FitToChildNodesAndGroupsRequest(nodeOrGroup));
+                }
                 this._reflowOrchestrator.handleResize(nodeOrGroup);
             }
         });
@@ -17554,6 +17980,7 @@ const F_NODE_FEATURES = [
     CalculateConnectableSideByInternalPosition,
     CalculateInputConnections,
     CalculateConnectorsConnectableSides,
+    ConnectableSidesScheduler,
     CalculateNodesBoundingBox,
     CalculateNodesBoundingBoxNormalizedPosition,
     CalculateOutputConnections,
@@ -19379,40 +19806,194 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
 const F_ZOOM_FEATURES = [ResetZoom, SetZoom];
 
 class MinimapDrawNodesRequest {
+    hostElement;
     static fToken = Symbol('MinimapDrawNodesRequest');
+    constructor(hostElement) {
+        this.hostElement = hostElement;
+    }
+}
+
+/**
+ * Flow-space node rects for the minimap, computed from the model instead of
+ * per-frame DOM measurement.
+ *
+ * Positions come straight from `node._position`; sizes are read from layout
+ * once (offsetWidth/offsetHeight are unaffected by the canvas CSS transform)
+ * and cached until a node resize invalidates them via `connectionsRevision` —
+ * the same signal every node's ResizeObserver already bumps. Pan/zoom therefore
+ * costs zero DOM reads per node, which is what previously forced the minimap
+ * to bail out above `fNodeRenderLimit`.
+ */
+class MinimapNodeRects {
+    _store = inject(FComponentsStore);
+    _sizes = new WeakMap();
+    _sizesRevision = -1;
+    /** Drops stale cached sizes when any node resized since the last pass. */
+    ensureFresh() {
+        const revision = this._store.connectionsRevision;
+        if (revision !== this._sizesRevision) {
+            this._sizesRevision = revision;
+            this._sizes = new WeakMap();
+        }
+    }
+    /**
+     * The minimap draws nodes in flow coordinates and shifts the whole layer by
+     * this offset, so panning moves one `<g>` transform instead of every rect.
+     */
+    viewOffset() {
+        const transform = this._store.transform;
+        if (!transform) {
+            return { x: 0, y: 0 };
+        }
+        const scale = transform.scale || 1;
+        return {
+            x: (transform.position.x + transform.scaledPosition.x) / scale,
+            y: (transform.position.y + transform.scaledPosition.y) / scale,
+        };
+    }
+    /** Rotation-aware AABB of a node in flow coordinates. */
+    rectOf(node) {
+        const size = this._sizeOf(node);
+        const { x, y } = node._position;
+        if (!node._rotate) {
+            return RectExtensions.initialize(x, y, size.width, size.height);
+        }
+        // transform: translate(p) rotate(deg) spins the node around its center;
+        // mirror that math so rotated nodes keep the same minimap footprint the
+        // old getBoundingClientRect path produced.
+        const radians = (node._rotate * Math.PI) / 180;
+        const cos = Math.abs(Math.cos(radians));
+        const sin = Math.abs(Math.sin(radians));
+        const width = size.width * cos + size.height * sin;
+        const height = size.width * sin + size.height * cos;
+        return RectExtensions.initialize(x + size.width / 2 - width / 2, y + size.height / 2 - height / 2, width, height);
+    }
+    /** Union of all node rects in flow coordinates; null when there are no nodes. */
+    contentRect() {
+        const nodes = this._store.nodes.getAll();
+        if (!nodes.length) {
+            return null;
+        }
+        let minX = Infinity;
+        let minY = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+        for (const node of nodes) {
+            const rect = this.rectOf(node);
+            minX = Math.min(minX, rect.x);
+            minY = Math.min(minY, rect.y);
+            maxX = Math.max(maxX, rect.x + rect.width);
+            maxY = Math.max(maxY, rect.y + rect.height);
+        }
+        return RectExtensions.initialize(minX, minY, maxX - minX, maxY - minY);
+    }
+    _sizeOf(node) {
+        if (node._size) {
+            return node._size;
+        }
+        const cached = this._sizes.get(node);
+        if (cached) {
+            return cached;
+        }
+        const measured = this._measure(node);
+        this._sizes.set(node, measured);
+        return measured;
+    }
+    _measure(node) {
+        const host = node.hostElement;
+        if (typeof host.offsetWidth === 'number') {
+            return { width: host.offsetWidth, height: host.offsetHeight };
+        }
+        // SVG hosts have no offset geometry; fall back to one unscaled gBCR.
+        const rect = host.getBoundingClientRect();
+        const scale = this._store.transform?.scale || 1;
+        return { width: rect.width / scale, height: rect.height / scale };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: MinimapNodeRects, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: MinimapNodeRects });
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: MinimapNodeRects, decorators: [{
+            type: Injectable
+        }] });
 
+/**
+ * Keeps one `<rect>` per node and updates it in place. Rects live in flow
+ * coordinates; panning/zooming only moves the group transform, so a transform
+ * change writes ONE attribute instead of rebuilding N elements — the previous
+ * implementation re-measured (2 x getBoundingClientRect) and re-created every
+ * node rect on every animation frame.
+ */
 let MinimapDrawNodes = class MinimapDrawNodes {
     _browser = inject(BrowserService);
     _store = inject(FComponentsStore);
-    handle(_) {
-        const flow = this._store.fFlow;
-        const canvas = this._store.fCanvas;
-        if (!flow || !canvas) {
-            return [];
-        }
+    _rects = inject(MinimapNodeRects);
+    _entries = new Map();
+    _membershipRevision = -1;
+    handle({ hostElement }) {
+        this._rects.ensureFresh();
         const nodes = this._store.nodes.getAll();
-        return nodes.map((node) => this._renderNode(node, flow, canvas));
-    }
-    _renderNode(node, flow, canvas) {
-        const rect = createSVGElement('rect', this._browser);
-        setRectToElement(this._nodeRect(node, flow, canvas), rect);
-        const isNode = node instanceof FNodeDirective;
-        rect.classList.add('f-component', isNode ? 'f-minimap-node' : 'f-minimap-group');
-        rect.classList.add(...this._minimapClasses(node));
-        if (node.isSelected()) {
-            rect.classList.add('f-selected');
+        if (this._membershipRevision !== this._store.nodesRevision) {
+            this._membershipRevision = this._store.nodesRevision;
+            this._removeStaleEntries(nodes);
+        }
+        const offset = this._rects.viewOffset();
+        hostElement.setAttribute('transform', `translate(${offset.x} ${offset.y})`);
+        for (const node of nodes) {
+            this._updateNode(node, hostElement);
         }
-        return rect;
     }
-    _nodeRect(node, flow, canvas) {
-        const inFlow = RectExtensions.elementTransform(RectExtensions.fromElement(node.hostElement), flow.hostElement);
-        return RectExtensions.div(inFlow, canvas.transform.scale);
+    _updateNode(node, hostElement) {
+        let entry = this._entries.get(node);
+        if (!entry) {
+            entry = {
+                element: createSVGElement('rect', this._browser),
+                lastRect: RectExtensions.initialize(NaN, NaN),
+                lastClassName: '',
+            };
+            this._entries.set(node, entry);
+        }
+        const rect = this._rects.rectOf(node);
+        if (!this._isSameRect(rect, entry.lastRect)) {
+            setRectToElement(rect, entry.element);
+            entry.lastRect = rect;
+        }
+        const className = this._className(node);
+        if (className !== entry.lastClassName) {
+            entry.element.setAttribute('class', className);
+            entry.lastClassName = className;
+        }
+        // Also self-heals after an external clear() (e.g. the render-limit bailout).
+        if (entry.element.parentNode !== hostElement) {
+            hostElement.appendChild(entry.element);
+        }
+    }
+    _removeStaleEntries(nodes) {
+        const alive = new Set(nodes);
+        for (const [node, entry] of this._entries) {
+            if (!alive.has(node)) {
+                entry.element.remove();
+                this._entries.delete(node);
+            }
+        }
+    }
+    _className(node) {
+        const parts = [
+            'f-component',
+            node instanceof FNodeDirective ? 'f-minimap-node' : 'f-minimap-group',
+            ...this._minimapClasses(node),
+        ];
+        if (node.isSelected()) {
+            parts.push('f-selected');
+        }
+        return parts.join(' ');
     }
     _minimapClasses(node) {
         const classes = node.fMinimapClass();
         return Array.isArray(classes) ? classes : [classes];
     }
+    _isSameRect(a, b) {
+        return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: MinimapDrawNodes, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: MinimapDrawNodes });
 };
@@ -19434,30 +20015,32 @@ class MinimapCalculateViewportRequest {
 }
 
 let MinimapCalculateViewport = class MinimapCalculateViewport {
-    _mediator = inject(FMediator);
     _store = inject(FComponentsStore);
+    _rects = inject(MinimapNodeRects);
     handle({ svg, minSize }) {
         const flow = this._store.fFlow;
         const canvas = this._store.fCanvas;
         if (!flow || !canvas) {
             return { scale: 1, viewBox: RectExtensions.initialize(0, 0, 0, 0) };
         }
-        const contentRect = this._contentRectInMinimapSpace(flow, canvas, minSize);
+        const contentRect = this._contentRectInMinimapSpace(minSize);
         const minimapRect = this._minimapRectInFlowSpace(svg, flow);
         const scale = this._viewportScale(contentRect, minimapRect);
         const viewBox = this._viewportViewBox(contentRect, minimapRect, scale);
         return { scale, viewBox };
     }
-    _contentRectInMinimapSpace(flow, canvas, minSize) {
-        const global = this._nodesBoundingBox();
-        const inFlow = RectExtensions.elementTransform(global, flow.hostElement);
-        const inMinimap = RectExtensions.div(inFlow, canvas.transform.scale);
+    /**
+     * Model-space union of node rects shifted by the view offset — numerically
+     * the same rect the old DOM path produced (screen union normalized into the
+     * flow and divided by scale), without measuring a single element.
+     */
+    _contentRectInMinimapSpace(minSize) {
+        this._rects.ensureFresh();
+        const content = this._rects.contentRect() ?? RectExtensions.initialize(0, 0, 0, 0);
+        const offset = this._rects.viewOffset();
+        const inMinimap = RectExtensions.initialize(content.x + offset.x, content.y + offset.y, content.width, content.height);
         return adjustRectToMinSize(inMinimap, minSize);
     }
-    _nodesBoundingBox() {
-        return (this._mediator.execute(new CalculateNodesBoundingBoxRequest()) ??
-            RectExtensions.initialize(0, 0, 0, 0));
-    }
     _minimapRectInFlowSpace(svg, flow) {
         return RectExtensions.elementTransform(RectExtensions.fromElement(svg), flow.hostElement);
     }
@@ -19529,6 +20112,7 @@ const F_MINIMAP_FEATURES = [
     MinimapDrawNodes,
     MinimapCalculateViewport,
     MinimapCalculateViewRect,
+    MinimapNodeRects,
 ];
 
 class GetNormalizedPointRequest {
@@ -20387,6 +20971,7 @@ class FCanvasComponent extends FCanvasBase {
      * Centers the specified group or node on the canvas.
      * @param groupOrNodeId - The ID of the group or node to center.
      * @param animated - If true, the centering will be animated; otherwise, it will be instantaneous.
+     * @param emitCanvasChange - If false, does not emit `fCanvasChange` for this programmatic move.
      */
     /**
      * FF1009 — viewport helpers compute from the nodes bounding box, so calling them
@@ -20399,21 +20984,22 @@ class FCanvasComponent extends FCanvasBase {
             fWarnOnce('FF1009', method, `${method} was called before the nodes were rendered, so it computes against an incomplete node set. Call it from the (fNodesRendered) or (fFullRendered) output of <f-flow>.`);
         }
     }
-    centerGroupOrNode(groupOrNodeId, animated = true) {
+    centerGroupOrNode(groupOrNodeId, animated = true, emitCanvasChange = true) {
         this._warnWhenCalledBeforeNodesRender('centerGroupOrNode()');
         this._afterRedraw(() => {
-            this._mediator.execute(new CenterGroupOrNodeRequest(groupOrNodeId, animated));
+            this._mediator.execute(new CenterGroupOrNodeRequest(groupOrNodeId, animated, emitCanvasChange));
         });
     }
     /**
      * Fits the canvas to the screen by adjusting the scale and position.
      * @param padding - paddings from the bounds of the canvas
      * @param animated - If true, the fit will be animated; otherwise, it will be instantaneous.
+     * @param emitCanvasChange - If false, does not emit `fCanvasChange` for this programmatic move.
      */
-    fitToScreen(padding = PointExtensions.initialize(), animated = true) {
+    fitToScreen(padding = PointExtensions.initialize(), animated = true, emitCanvasChange = true) {
         this._warnWhenCalledBeforeNodesRender('fitToScreen()');
         this._afterRedraw(() => {
-            this._mediator.execute(new FitToFlowRequest(padding, animated));
+            this._mediator.execute(new FitToFlowRequest(padding, animated, emitCanvasChange));
         });
     }
     /**
@@ -20421,12 +21007,13 @@ class FCanvasComponent extends FCanvasBase {
      * This method is used to restore the canvas to its default scale and position,
      * allowing users to quickly return to a standard view of the canvas content.
      * @param animated - If true, the reset will be animated; otherwise, it will be instantaneous.
+     * @param emitCanvasChange - If false, does not emit `fCanvasChange` for this programmatic move.
      * This is useful for providing a smooth user experience when resetting the view.
      */
-    resetScaleAndCenter(animated = true) {
+    resetScaleAndCenter(animated = true, emitCanvasChange = true) {
         this._warnWhenCalledBeforeNodesRender('resetScaleAndCenter()');
         this._afterRedraw(() => {
-            this._mediator.execute(new ResetScaleAndCenterRequest(animated));
+            this._mediator.execute(new ResetScaleAndCenterRequest(animated, emitCanvasChange));
         });
     }
     /**
@@ -21898,18 +22485,1041 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
 
 const F_MAGNETIC_RECTS_PROVIDERS = [FMagneticRects];
 
-class FMinimapFlowDirective {
-    fMinSize = input(1000, ...(ngDevMode ? [{ debugName: "fMinSize" }] : []));
-    _mediator = inject(FMediator);
-    hostElement = inject((ElementRef)).nativeElement;
-    model = new FMinimapState(this.hostElement);
-    redraw() {
-        const { scale, viewBox } = this._mediator.execute(new MinimapCalculateViewportRequest(this.hostElement, this.fMinSize()));
-        this.model = new FMinimapState(this.hostElement, scale, viewBox);
-        setRectToViewBox(viewBox, this.hostElement);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: FMinimapFlowDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.9", type: FMinimapFlowDirective, isStandalone: true, selector: "svg[fMinimapFlow]", inputs: { fMinSize: { classPropertyName: "fMinSize", publicName: "fMinSize", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+function mergeFlowStateConfig(config) {
+    return {
+        historyLimit: 50,
+        selectionInHistory: true,
+        canvasTransformInHistory: true,
+        canvasTransformDebounce: 0,
+        dropToGroup: false,
+        ...config,
+    };
+}
+/**
+ * Resolved state-plugin configuration. Present in the injector only when
+ * `withFlowState()` is installed — its absence keeps `FFlowStateController`
+ * inert.
+ */
+const F_FLOW_STATE_CONFIG = new InjectionToken('F_FLOW_STATE_CONFIG');
+
+const EMPTY_SELECTION = Object.freeze({
+    nodeIds: [],
+    groupIds: [],
+    connectionIds: [],
+});
+const DEFAULT_TRANSFORM = Object.freeze({
+    position: undefined,
+    scale: 1,
+});
+/**
+ * The data store of the state plugin (`provideFFlow(withFlowState())`).
+ *
+ * Holds the whole graph as plain records behind the signals `nodes`,
+ * `groups` and `connections` that the template renders with `@for`. Records
+ * are your own shape — extend `IFStateNode`/`IFStateGroup`/`IFStateConnection`
+ * with any fields and type them through `injectFlowState<MyNode>()`; the store
+ * only reads the framework keys and carries the rest through untouched.
+ *
+ * Every mutation — its own methods or the gestures `FFlowStateController`
+ * forwards into the `apply*` handlers — is ONE undoable history step: records
+ * are updated immutably, so a history entry is just the previous shape
+ * reference. `undo`/`redo` with `canUndo`/`canRedo` signals come built in;
+ * `changes` ticks once when a standalone mutation or outer batch settles, so a
+ * single effect can persist the graph. Load data with `load(...)`, take it back
+ * with `snapshot()`.
+ *
+ * EVERY method is designed for overriding. Subclass the store, override any
+ * CRUD method, any `apply*` gesture handler or any protected building block,
+ * and install the subclass via `withFlowState({ stateClass: MyFlowState })` —
+ * the auto-wiring and the templates then use your behavior.
+ */
+class FFlowState {
+    config = inject(F_FLOW_STATE_CONFIG, { optional: true });
+    /**
+     * Resolves the node owning a connector; installed by the controller from
+     * the live registries so node removal can cascade to attached connections.
+     */
+    _connectorOwnerResolver = null;
+    _shape = signal({
+        nodes: {},
+        groups: {},
+        connections: {},
+        selection: EMPTY_SELECTION,
+        transform: DEFAULT_TRANSFORM,
+    }, ...(ngDevMode ? [{ debugName: "_shape" }] : []));
+    _undoStack = [];
+    _redoStack = [];
+    _canUndo = signal(false, ...(ngDevMode ? [{ debugName: "_canUndo" }] : []));
+    _canRedo = signal(false, ...(ngDevMode ? [{ debugName: "_canRedo" }] : []));
+    _changes = signal(0, ...(ngDevMode ? [{ debugName: "_changes" }] : []));
+    /** Live selection when `selectionInHistory` is off (kept out of history). */
+    _liveSelection = signal(EMPTY_SELECTION, ...(ngDevMode ? [{ debugName: "_liveSelection" }] : []));
+    /** Live transform when `canvasTransformInHistory` is off (kept out of history). */
+    _liveTransform = signal(DEFAULT_TRANSFORM, ...(ngDevMode ? [{ debugName: "_liveTransform" }] : []));
+    /** Called when `undo` empties the history; the controller may reset the view. */
+    _onUndoToStart = null;
+    /**
+     * Establishes the actual canvas transform before its first user-driven
+     * change. Programmatic centering can intentionally suppress fCanvasChange,
+     * so the state may still hold an unset transform while the rendered canvas
+     * is already centered. This updates that baseline without history or a
+     * changes() tick.
+     */
+    _initializeTransform(transform) {
+        const next = _copyTransform(transform);
+        if (!this.config?.canvasTransformInHistory) {
+            if (this._liveTransform().position === undefined) {
+                this._liveTransform.set(next);
+            }
+            return;
+        }
+        const shape = this._shape();
+        if (shape.transform.position !== undefined) {
+            return;
+        }
+        this._shape.set({ ...shape, transform: next });
+        if (this._batchOpen && this._undoStack.length) {
+            const index = this._undoStack.length - 1;
+            const baseline = this._undoStack[index];
+            if (baseline.transform.position === undefined) {
+                this._undoStack[index] = { ...baseline, transform: _copyTransform(next) };
+            }
+        }
+    }
+    /** Open-transaction depth; commits inside a batch collapse into one step. */
+    _batchDepth = 0;
+    _batchOpen = false;
+    /** A mutation occurred inside the current outer batch. */
+    _batchDirty = false;
+    // Records are memoized so a selection-only change never re-emits the graph.
+    _nodesRecord = computed(() => this._shape().nodes, ...(ngDevMode ? [{ debugName: "_nodesRecord" }] : []));
+    _groupsRecord = computed(() => this._shape().groups, ...(ngDevMode ? [{ debugName: "_groupsRecord" }] : []));
+    _connectionsRecord = computed(() => this._shape().connections, ...(ngDevMode ? [{ debugName: "_connectionsRecord" }] : []));
+    /** All nodes, re-emitted after every mutation, undo and redo. */
+    nodes = computed(() => Object.values(this._nodesRecord()), ...(ngDevMode ? [{ debugName: "nodes" }] : []));
+    /** All groups, re-emitted after every mutation, undo and redo. */
+    groups = computed(() => Object.values(this._groupsRecord()), ...(ngDevMode ? [{ debugName: "groups" }] : []));
+    /** All connections, re-emitted after every mutation, undo and redo. */
+    connections = computed(() => Object.values(this._connectionsRecord()), ...(ngDevMode ? [{ debugName: "connections" }] : []));
+    /** The current selection; historized only when `selectionInHistory` is on. */
+    selection = computed(() => this.config?.selectionInHistory ? this._shape().selection : this._liveSelection(), ...(ngDevMode ? [{ debugName: "selection" }] : []));
+    /** The current canvas transform; historized only when `canvasTransformInHistory` is on. */
+    transform = computed(() => this.config?.canvasTransformInHistory ? this._shape().transform : this._liveTransform(), ...(ngDevMode ? [{ debugName: "transform" }] : []));
+    /** Ticks when a standalone mutation or outer batch settles, and on `load`. */
+    changes = this._changes.asReadonly();
+    canUndo = this._canUndo.asReadonly();
+    canRedo = this._canRedo.asReadonly();
+    // ------------------------------------------------------------------
+    // Data in / data out
+    // ------------------------------------------------------------------
+    /** Replaces the whole graph and resets the undo history. */
+    load(data) {
+        this._undoStack.length = 0;
+        this._redoStack.length = 0;
+        this._batchDirty = false;
+        const transform = _copyTransform(data.transform ?? DEFAULT_TRANSFORM);
+        this._liveSelection.set(EMPTY_SELECTION);
+        this._liveTransform.set(transform);
+        this._shape.set({
+            nodes: _byId(data.nodes ?? []),
+            groups: _byId(data.groups ?? []),
+            connections: _byId(data.connections ?? []),
+            selection: EMPTY_SELECTION,
+            transform,
+        });
+        this._syncHistorySignals();
+        this._bumpChanges();
+    }
+    /**
+     * The whole graph as plain arrays — safe to persist. Records and their
+     * geometry are copied; nested payloads stay yours by reference.
+     */
+    snapshot() {
+        const { nodes, groups, connections } = this._shape();
+        return {
+            nodes: Object.values(nodes).map(_copyBox),
+            groups: Object.values(groups).map(_copyBox),
+            connections: Object.values(connections).map((connection) => ({ ...connection })),
+            transform: _copyTransform(this.transform()),
+        };
+    }
+    getNode(id) {
+        return this._shape().nodes[id];
+    }
+    getGroup(id) {
+        return this._shape().groups[id];
+    }
+    getConnection(id) {
+        return this._shape().connections[id];
+    }
+    // ------------------------------------------------------------------
+    // Mutations — each call is ONE undoable history step
+    // ------------------------------------------------------------------
+    addNodes(...nodes) {
+        if (!nodes.length) {
+            return;
+        }
+        const shape = this.currentShape();
+        this.commit({ ...shape, nodes: { ...shape.nodes, ..._byId(nodes) } });
+    }
+    /** Shallow-merges the patch into the node: provided keys replace as a whole. */
+    updateNode(id, patch) {
+        const shape = this.currentShape();
+        const existing = shape.nodes[id];
+        if (!existing) {
+            return;
+        }
+        this.commit({
+            ...shape,
+            nodes: { ...shape.nodes, [id]: { ...existing, ...patch, id } },
+        });
+    }
+    /**
+     * Applies new positions to known nodes and groups as ONE history step. A
+     * dragged group arrives here alongside nodes, so both maps are updated.
+     */
+    moveNodes(positions) {
+        const shape = this.currentShape();
+        let nodes = shape.nodes;
+        let groups = shape.groups;
+        let changed = false;
+        for (const { id, position } of positions) {
+            if (shape.nodes[id]) {
+                if (nodes === shape.nodes) {
+                    nodes = { ...shape.nodes };
+                }
+                nodes[id] = { ...nodes[id], position: { ...position } };
+                changed = true;
+            }
+            else if (shape.groups[id]) {
+                if (groups === shape.groups) {
+                    groups = { ...shape.groups };
+                }
+                groups[id] = { ...groups[id], position: { ...position } };
+                changed = true;
+            }
+        }
+        if (!changed) {
+            return;
+        }
+        this.commit({ ...shape, nodes, groups });
+    }
+    /**
+     * Removes nodes and, when the connector-owner resolver is available (the
+     * plugin is attached to a rendered flow), every connection attached to them
+     * — all as ONE history step.
+     */
+    removeNodes(ids) {
+        this.applyRemoval({ nodeIds: ids });
+    }
+    addGroups(...groups) {
+        if (!groups.length) {
+            return;
+        }
+        const shape = this.currentShape();
+        this.commit({ ...shape, groups: { ...shape.groups, ..._byId(groups) } });
+    }
+    /** Shallow-merges the patch into the group. */
+    updateGroup(id, patch) {
+        const shape = this.currentShape();
+        const existing = shape.groups[id];
+        if (!existing) {
+            return;
+        }
+        this.commit({
+            ...shape,
+            groups: { ...shape.groups, [id]: { ...existing, ...patch, id } },
+        });
+    }
+    /** Removes groups (with connection cascade and child un-parenting) as ONE step. */
+    removeGroups(ids) {
+        this.applyRemoval({ groupIds: ids });
+    }
+    addConnections(...connections) {
+        if (!connections.length) {
+            return;
+        }
+        const shape = this.currentShape();
+        this.commit({
+            ...shape,
+            connections: { ...shape.connections, ..._byId(connections) },
+        });
+    }
+    /** Shallow-merges the patch into the connection. */
+    updateConnection(id, patch) {
+        const shape = this.currentShape();
+        const existing = shape.connections[id];
+        if (!existing) {
+            return;
+        }
+        this.commit({
+            ...shape,
+            connections: { ...shape.connections, [id]: { ...existing, ...patch, id } },
+        });
+    }
+    removeConnections(ids) {
+        this.applyRemoval({ connectionIds: ids });
+    }
+    /** Removes nodes (with connection cascade) and explicit connections as ONE history step. */
+    removeItems(nodeIds, connectionIds) {
+        this.applyRemoval({ nodeIds, connectionIds });
+    }
+    // ------------------------------------------------------------------
+    // History
+    // ------------------------------------------------------------------
+    undo() {
+        const previous = this._undoStack.pop();
+        if (!previous) {
+            return;
+        }
+        this._redoStack.push(this._shape());
+        this._shape.set(previous);
+        this._syncHistorySignals();
+        this._bumpChanges();
+        if (!this._canUndo()) {
+            this._onUndoToStart?.();
+        }
+    }
+    redo() {
+        const next = this._redoStack.pop();
+        if (!next) {
+            return;
+        }
+        this._undoStack.push(this._shape());
+        this._shape.set(next);
+        this._syncHistorySignals();
+        this._bumpChanges();
+    }
+    clearHistory() {
+        this._undoStack.length = 0;
+        this._redoStack.length = 0;
+        this._syncHistorySignals();
+    }
+    // ------------------------------------------------------------------
+    // Transactions — collapse several mutations into ONE undoable step
+    // ------------------------------------------------------------------
+    /**
+     * Opens a transaction: every `commit` until the matching `endBatch` records
+     * only ONE history step (the shape before the batch). Used by the controller
+     * to fold the events of a single drag session (e.g. move + drop-to-group, or
+     * a historized selection + move) into one undoable action. Nestable.
+     */
+    beginBatch() {
+        this._batchDepth++;
+    }
+    /** Closes the transaction opened by `beginBatch`. */
+    endBatch() {
+        if (this._batchDepth > 0) {
+            this._batchDepth--;
+        }
+        if (this._batchDepth === 0) {
+            this._batchOpen = false;
+            if (this._batchDirty) {
+                this._batchDirty = false;
+                this._bumpChanges();
+            }
+        }
+    }
+    /** Runs `work` inside a transaction so all its mutations are one step. */
+    batch(work) {
+        this.beginBatch();
+        try {
+            return work();
+        }
+        finally {
+            this.endBatch();
+        }
+    }
+    // ------------------------------------------------------------------
+    // Gesture handlers — the controller forwards finished gestures here.
+    // Override any of them to change what a gesture means for your data.
+    // ------------------------------------------------------------------
+    /** A create-connection gesture finished. Default: add unless dropped to nowhere. */
+    applyCreateConnection(event) {
+        if (!event.targetId) {
+            return;
+        }
+        const connection = this.config?.connectionFactory
+            ? this.config.connectionFactory(event)
+            : this.createConnectionRecord(event);
+        if (connection) {
+            this.addConnections(connection);
+        }
+    }
+    /** A reassign gesture finished. Default: update the moved endpoint. */
+    applyReassignConnection(event) {
+        if (event.endpoint === 'source' && event.nextSourceId) {
+            this.updateConnection(event.connectionId, {
+                sourceId: event.nextSourceId,
+            });
+        }
+        else if (event.endpoint === 'target' && event.nextTargetId) {
+            this.updateConnection(event.connectionId, {
+                targetId: event.nextTargetId,
+            });
+        }
+    }
+    /** A node drag finished. Default: apply all positions as one step. */
+    applyMoveNodes(event) {
+        this.moveNodes(event.nodes);
+    }
+    /** The user requested removal of the selection. Default: remove with cascade. */
+    applyDeleteSelected(event) {
+        this.applyRemoval({
+            nodeIds: event.nodeIds,
+            groupIds: event.groupIds,
+            connectionIds: event.connectionIds,
+        });
+    }
+    /**
+     * Nodes/groups were dropped into a group. Reparents them as one step when
+     * `dropToGroup` is enabled; a no-op otherwise (it's off by default). This
+     * only touches items that already exist — a brand-new item from a palette is
+     * created by `applyCreateNode`, not here.
+     */
+    applyDropToGroup(event) {
+        if (this.config?.dropToGroup === false) {
+            return;
+        }
+        const shape = this.currentShape();
+        let nodes = shape.nodes;
+        let groups = shape.groups;
+        let changed = false;
+        for (const id of event.nodeIds) {
+            if (shape.nodes[id]) {
+                if (nodes === shape.nodes) {
+                    nodes = { ...shape.nodes };
+                }
+                nodes[id] = { ...nodes[id], parentId: event.targetGroupId };
+                changed = true;
+            }
+            else if (shape.groups[id]) {
+                if (groups === shape.groups) {
+                    groups = { ...shape.groups };
+                }
+                groups[id] = { ...groups[id], parentId: event.targetGroupId };
+                changed = true;
+            }
+        }
+        if (!changed) {
+            return;
+        }
+        this.commit({ ...shape, nodes, groups });
+    }
+    /** An external item was dropped onto the canvas. Default: add a node for it. */
+    applyCreateNode(event) {
+        const node = this.config?.nodeFactory
+            ? this.config.nodeFactory(event)
+            : this.createNodeRecord(event);
+        if (node) {
+            this.addNodes(node);
+        }
+    }
+    /** The flow selection changed. Historized only when `selectionInHistory` is on. */
+    applySelectionChange(event) {
+        const next = {
+            nodeIds: [...event.nodeIds],
+            groupIds: [...event.groupIds],
+            connectionIds: [...event.connectionIds],
+        };
+        if (this.config?.selectionInHistory) {
+            this.commit({ ...this.currentShape(), selection: next });
+        }
+        else {
+            this._liveSelection.set(next);
+        }
+    }
+    /**
+     * The canvas was panned or zoomed (`fCanvasChange`). Historized as its own
+     * step when `canvasTransformInHistory` is on; otherwise tracked live, out of
+     * history. A no-op when the transform is unchanged, so a binding pushing the
+     * current value back can't create a redundant step.
+     */
+    applyTransform(transform) {
+        const next = _copyTransform(transform);
+        if (this.config?.canvasTransformInHistory) {
+            if (_isSameTransform(this.currentShape().transform, next)) {
+                return;
+            }
+            this.commit({ ...this.currentShape(), transform: next });
+        }
+        else {
+            if (_isSameTransform(this._liveTransform(), next)) {
+                return;
+            }
+            this._liveTransform.set(next);
+        }
+    }
+    /**
+     * A node or group reported a new measured rect (`fNodeSizeChange` /
+     * `fGroupSizeChange`) — e.g. a group auto-fitting after a child was added.
+     * Folded into the CURRENT shape WITHOUT its own history step, so the resize
+     * rides along with the action that triggered it (one `undo` reverts both).
+     */
+    applyResize(id, rect) {
+        const shape = this.currentShape();
+        const patch = {
+            position: { x: rect.x, y: rect.y },
+            size: { width: rect.width, height: rect.height },
+        };
+        if (shape.nodes[id]) {
+            if (_isSameGeometry(shape.nodes[id], patch)) {
+                return;
+            }
+            this.amendCurrent({
+                ...shape,
+                nodes: { ...shape.nodes, [id]: { ...shape.nodes[id], ...patch } },
+            });
+        }
+        else if (shape.groups[id]) {
+            if (_isSameGeometry(shape.groups[id], patch)) {
+                return;
+            }
+            this.amendCurrent({
+                ...shape,
+                groups: { ...shape.groups, [id]: { ...shape.groups[id], ...patch } },
+            });
+        }
+    }
+    // ------------------------------------------------------------------
+    // Overridable building blocks
+    // ------------------------------------------------------------------
+    /** Builds the record for a gesture-created connection. */
+    createConnectionRecord(event) {
+        return {
+            id: generateGuid(),
+            sourceId: event.sourceId,
+            targetId: event.targetId,
+        };
+    }
+    /**
+     * Builds the record for an external-item drop. The item's `fData` is spread
+     * onto the node, so a palette payload becomes the node's own fields. The
+     * drop target nests the node only when `dropToGroup` is enabled (off by
+     * default); otherwise the node lands at the top level.
+     *
+     * Position comes from `externalItemRect`, which is already in flow
+     * coordinates (pan/zoom corrected) for every drop — over empty canvas or
+     * over a node/group alike. (`dropPosition` is the raw pointer position and
+     * only present on container drops, so it isn't used here.)
+     */
+    createNodeRecord(event) {
+        return {
+            ...event.data,
+            id: generateGuid(),
+            position: { x: event.externalItemRect.x, y: event.externalItemRect.y },
+            parentId: this.config?.dropToGroup === false ? null : (event.targetContainerId ?? null),
+        };
+    }
+    /**
+     * Removes nodes, groups and connections as ONE history step: cascades the
+     * connections attached to removed nodes/groups, un-parents any child that
+     * pointed at a removed group, and prunes the removed ids from the selection.
+     */
+    applyRemoval(items) {
+        const shape = this.currentShape();
+        const removedNodes = new Set((items.nodeIds ?? []).filter((id) => shape.nodes[id]));
+        const removedGroups = new Set((items.groupIds ?? []).filter((id) => shape.groups[id]));
+        const removedConnections = new Set((items.connectionIds ?? []).filter((id) => shape.connections[id]));
+        for (const id of this.cascadeConnectionIds([...removedNodes, ...removedGroups], shape)) {
+            removedConnections.add(id);
+        }
+        if (!removedNodes.size && !removedGroups.size && !removedConnections.size) {
+            return;
+        }
+        const nodes = _clearParent(_without(shape.nodes, removedNodes), removedGroups);
+        const groups = _clearParent(_without(shape.groups, removedGroups), removedGroups);
+        const connections = _without(shape.connections, removedConnections);
+        const selection = _pruneSelection(shape.selection, removedNodes, removedGroups, removedConnections);
+        this.commit({ nodes, groups, connections, selection, transform: shape.transform });
+        if (!this.config?.selectionInHistory) {
+            this._liveSelection.set(_pruneSelection(this._liveSelection(), removedNodes, removedGroups, removedConnections));
+        }
+    }
+    /** The current shape, for custom mutations in subclasses. */
+    currentShape() {
+        return this._shape();
+    }
+    /**
+     * Records the current shape into the history and applies the next one.
+     * Route custom subclass mutations through here to make them undoable.
+     * Inside a `beginBatch`/`endBatch` transaction only the first commit records
+     * a history step, so the whole batch undoes in one go.
+     */
+    commit(next) {
+        if (this._batchDepth === 0 || !this._batchOpen) {
+            this._undoStack.push(this._shape());
+            const limit = this.config?.historyLimit ?? 50;
+            if (this._undoStack.length > limit) {
+                this._undoStack.shift();
+            }
+            this._redoStack.length = 0;
+            if (this._batchDepth > 0) {
+                this._batchOpen = true;
+            }
+        }
+        this._shape.set(next);
+        this._syncHistorySignals();
+        this._markChanged();
+    }
+    /**
+     * Replaces the current shape WITHOUT recording a history step, so the change
+     * folds into the last committed step. Used by `applyResize`.
+     */
+    amendCurrent(next) {
+        this._shape.set(next);
+        this._markChanged();
+    }
+    /** Connections attached to the given nodes/groups, per the connector-owner resolver. */
+    cascadeConnectionIds(ownerIds, shape) {
+        const resolver = this._connectorOwnerResolver;
+        if (!resolver || !ownerIds.length) {
+            return [];
+        }
+        const removed = new Set(ownerIds);
+        return Object.values(shape.connections)
+            .filter((connection) => {
+            const sourceNode = resolver(connection.sourceId);
+            const targetNode = resolver(connection.targetId);
+            return ((sourceNode !== undefined && removed.has(sourceNode)) ||
+                (targetNode !== undefined && removed.has(targetNode)));
+        })
+            .map((connection) => connection.id);
+    }
+    _syncHistorySignals() {
+        this._canUndo.set(this._undoStack.length > 0);
+        this._canRedo.set(this._redoStack.length > 0);
+    }
+    _markChanged() {
+        if (this._batchDepth > 0) {
+            this._batchDirty = true;
+            return;
+        }
+        this._bumpChanges();
+    }
+    _bumpChanges() {
+        this._changes.update((value) => value + 1);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: FFlowState, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: FFlowState });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: FFlowState, decorators: [{
+            type: Injectable
+        }] });
+function _byId(items) {
+    return Object.fromEntries(items.map((item) => [item.id, item]));
+}
+function _without(records, ids) {
+    if (!ids.size) {
+        return records;
+    }
+    return Object.fromEntries(Object.entries(records).filter(([id]) => !ids.has(id)));
+}
+/** Copies a transform so the stored value can't be mutated from outside. */
+function _copyTransform(transform) {
+    return {
+        position: transform.position ? { x: transform.position.x, y: transform.position.y } : undefined,
+        scale: transform.scale,
+    };
+}
+function _isSameTransform(a, b) {
+    return _isSamePoint(a.position, b.position) && a.scale === b.scale;
+}
+function _isSamePoint(a, b) {
+    if (!a || !b) {
+        // Both unset → same; exactly one set → different.
+        return a === b;
+    }
+    return a.x === b.x && a.y === b.y;
+}
+/** Copies a box record with fresh geometry; nested payloads stay by reference. */
+function _copyBox(box) {
+    return {
+        ...box,
+        position: { ...box.position },
+        size: box.size ? { ...box.size } : undefined,
+    };
+}
+/** Clears `parentId` on records that pointed at a removed group. */
+function _clearParent(records, removedGroups) {
+    if (!removedGroups.size) {
+        return records;
+    }
+    let next = records;
+    for (const [id, record] of Object.entries(records)) {
+        if (record.parentId != null && removedGroups.has(record.parentId)) {
+            if (next === records) {
+                next = { ...records };
+            }
+            next[id] = { ...record, parentId: null };
+        }
+    }
+    return next;
+}
+/** Drops removed ids from a selection; returns the same reference if unchanged. */
+function _pruneSelection(selection, removedNodes, removedGroups, removedConnections) {
+    const nodeIds = selection.nodeIds.filter((id) => !removedNodes.has(id));
+    const groupIds = selection.groupIds.filter((id) => !removedGroups.has(id));
+    const connectionIds = selection.connectionIds.filter((id) => !removedConnections.has(id));
+    if (nodeIds.length === selection.nodeIds.length &&
+        groupIds.length === selection.groupIds.length &&
+        connectionIds.length === selection.connectionIds.length) {
+        return selection;
+    }
+    return { nodeIds, groupIds, connectionIds };
+}
+function _isSameGeometry(record, patch) {
+    return (record.position.x === patch.position.x &&
+        record.position.y === patch.position.y &&
+        record.size?.width === patch.size.width &&
+        record.size?.height === patch.size.height);
+}
+/**
+ * Typed accessor for the state store provided by `withFlowState()`.
+ *
+ * ```typescript
+ * protected readonly state = injectFlowState<MyNode, MyConnection>();
+ * ```
+ */
+function injectFlowState() {
+    return inject(FFlowState);
+}
+
+/**
+ * Auto-wiring between the flow's gesture events and `FFlowState` (active only
+ * when `withFlowState()` is installed).
+ *
+ * This is what removes the handler boilerplate: every finished gesture is
+ * forwarded into the state's overridable `apply*` methods — the application
+ * only loads data and reads it back. Subclass `FFlowState` to change what any
+ * gesture means for your data; this controller stays a thin dispatcher.
+ */
+class FFlowStateController {
+    _config = inject(F_FLOW_STATE_CONFIG, { optional: true });
+    _state = inject(FFlowState, { optional: true });
+    _store = inject(FComponentsStore);
+    _browser = inject(BrowserService);
+    _injector = inject(Injector);
+    _disposers = [];
+    _subscriptions = [];
+    /** Per-node/group `sizeChange` subscriptions, keyed by id. */
+    _sizeSubscriptions = new Map();
+    _isWired = false;
+    /** The canvas `fCanvasChange` subscription is in place. */
+    _isCanvasWired = false;
+    /** A state transaction is currently open (beginBatch without endBatch). */
+    _batchActive = false;
+    /** Inside a drag session (fDragStarted → fDragEnded). */
+    _dragActive = false;
+    /** Canvas transform captured at drag start, to detect a change during the drag. */
+    _dragStartTransform = null;
+    /** Latest canvas transform awaiting a (possibly debounced) capture. */
+    _pendingTransform = null;
+    _transformDebounceTimer = null;
+    /** A microtask is queued to close a non-drag batch at the end of the tick. */
+    _closeScheduled = false;
+    /** Called once by `FFlowComponent` after content init (browser only). */
+    initialize() {
+        if (!this._config || !this._state || !this._browser.isBrowser()) {
+            return;
+        }
+        this._state._connectorOwnerResolver = (connectorId) => this._resolveOwnerNode(connectorId);
+        this._state._onUndoToStart = () => this._resetAndRenderFlow();
+        this._wireDraggableEvents();
+        this._wireCanvasEvents();
+        this._wireSizeChanges();
+        // The draggable directive, canvas and nodes/groups register over time;
+        // re-wire on every registry change (`_wire*` are idempotent).
+        this._disposers.push(this._store.nodesChanges$.listen(() => {
+            this._wireDraggableEvents();
+            this._wireCanvasEvents();
+            this._wireSizeChanges();
+        }));
+        if (this._config.selectionInHistory) {
+            this._wireSelectionRestore();
+        }
+    }
+    destroy() {
+        this._disposers.forEach((dispose) => dispose());
+        this._disposers.length = 0;
+        this._subscriptions.forEach((subscription) => subscription.unsubscribe());
+        this._subscriptions.length = 0;
+        this._sizeSubscriptions.forEach((subscription) => subscription.unsubscribe());
+        this._sizeSubscriptions.clear();
+        if (this._transformDebounceTimer !== null) {
+            clearTimeout(this._transformDebounceTimer);
+            this._transformDebounceTimer = null;
+        }
+        this._pendingTransform = null;
+        this._isWired = false;
+        this._isCanvasWired = false;
+        this._dragActive = false;
+        this._closeScheduled = false;
+        this._closeBatch();
+        if (this._state) {
+            this._state._connectorOwnerResolver = null;
+            this._state._onUndoToStart = null;
+        }
+    }
+    _wireDraggableEvents() {
+        const draggable = this._store.fDraggable;
+        if (this._isWired || !draggable) {
+            return;
+        }
+        this._isWired = true;
+        const state = this._state;
+        this._subscriptions.push(draggable.fCreateConnection.subscribe((event) => this._dispatch(() => state.applyCreateConnection(event))), draggable.fReassignConnection.subscribe((event) => this._dispatch(() => state.applyReassignConnection(event))), draggable.fMoveNodes.subscribe((event) => this._dispatch(() => state.applyMoveNodes(event))), draggable.fDeleteSelected.subscribe((event) => this._dispatch(() => state.applyDeleteSelected(event))), draggable.fDropToGroup.subscribe((event) => this._dispatch(() => state.applyDropToGroup(event))), draggable.fCreateNode.subscribe((event) => this._dispatch(() => state.applyCreateNode(event))), draggable.fSelectionChange.subscribe((event) => this._dispatch(() => state.applySelectionChange(event))), 
+        // Drag lifecycle brackets the batch across ticks: the drag-start
+        // selection and the pointer-up move live in different ticks, so the
+        // batch must survive the gap between them.
+        draggable.fDragStarted.subscribe(() => this._onDragStarted()), draggable.fDragEnded.subscribe(() => this._onDragEnded()));
+    }
+    /**
+     * Captures canvas pan/zoom (`fCanvasChange`) into the state. Routed through
+     * `_dispatch` so a pan-drag folds into one step. Restore is binding-driven:
+     * bind the canvas `[position]`/`[scale]` to `state.transform()` and undo/redo
+     * flows back through the guarded input path — no imperative push needed.
+     */
+    _wireCanvasEvents() {
+        const canvas = this._store.fCanvas;
+        if (this._isCanvasWired || !canvas) {
+            return;
+        }
+        this._isCanvasWired = true;
+        this._subscriptions.push(canvas.fCanvasChange.subscribe((event) => this._onCanvasChange(event)));
+    }
+    /**
+     * Records a canvas pan/zoom, optionally debounced (`canvasTransformDebounce`)
+     * so a zoom/pan burst collapses into one step once it settles.
+     */
+    _onCanvasChange(event) {
+        this._pendingTransform = { position: event.position, scale: event.scale };
+        const debounce = this._config?.canvasTransformDebounce ?? 0;
+        if (debounce <= 0) {
+            if (this._transformDebounceTimer !== null) {
+                clearTimeout(this._transformDebounceTimer);
+                this._transformDebounceTimer = null;
+            }
+            this._flushCanvasChange();
+            return;
+        }
+        if (this._transformDebounceTimer !== null) {
+            clearTimeout(this._transformDebounceTimer);
+        }
+        this._transformDebounceTimer = setTimeout(() => {
+            this._transformDebounceTimer = null;
+            this._flushCanvasChange();
+        }, debounce);
+    }
+    _flushCanvasChange() {
+        const transform = this._pendingTransform;
+        this._pendingTransform = null;
+        if (!transform) {
+            return;
+        }
+        this._dispatch(() => this._state.applyTransform(transform));
+    }
+    /**
+     * Subscribes to every node's and group's `sizeChange` (a per-directive
+     * output, not a draggable event) so a resize — most often a group
+     * auto-fitting after a child was added — is folded into the last history
+     * step via `applyResize`. Re-runs as nodes/groups register; drops removed.
+     */
+    _wireSizeChanges() {
+        const state = this._state;
+        const alive = new Set();
+        for (const node of this._store.nodes.getAll()) {
+            const id = node.fId();
+            alive.add(id);
+            if (!this._sizeSubscriptions.has(id)) {
+                this._sizeSubscriptions.set(id, node.sizeChange.subscribe((rect) => state.applyResize(id, rect)));
+            }
+        }
+        for (const [id, subscription] of this._sizeSubscriptions) {
+            if (!alive.has(id)) {
+                subscription.unsubscribe();
+                this._sizeSubscriptions.delete(id);
+            }
+        }
+    }
+    /**
+     * Folds every event of one drag session into a single undoable step.
+     *
+     * The events don't share a tick: the selection change is emitted at drag
+     * START (before `fDragStarted`), while the move / drop-to-group land at drag
+     * END (pointer-up). So the batch opens on the first event of the tick and,
+     * once `fDragStarted` marks a drag in progress, stays open until `fDragEnded`
+     * — spanning the whole drag. Outside a drag (e.g. a keyboard delete) it
+     * closes on the next microtask, so unrelated same-tick bursts still collapse.
+     * Programmatic app mutations don't run through here, so they stay separate.
+     */
+    _dispatch(apply) {
+        this._openBatch();
+        if (!this._dragActive && !this._closeScheduled) {
+            this._closeScheduled = true;
+            queueMicrotask(() => {
+                this._closeScheduled = false;
+                if (!this._dragActive) {
+                    this._closeBatch();
+                }
+            });
+        }
+        apply();
+    }
+    _onDragStarted() {
+        this._dragActive = true;
+        // The leading selection has usually opened the batch already; if not
+        // (e.g. dragging an already-selected node), open it now.
+        this._openBatch();
+        this._dragStartTransform = this._readCanvasTransform();
+    }
+    _onDragEnded() {
+        this._dragActive = false;
+        // Fold any canvas transform change from this drag (auto-pan, or a mid-drag
+        // zoom) into the same step. `fCanvasChange` is debounced onto a macrotask,
+        // so it arrives AFTER this handler has closed the batch — read the settled
+        // transform straight from the canvas now instead. The later `fCanvasChange`
+        // carrying the same value is a no-op (`applyTransform` skips it).
+        this._captureCanvasTransform();
+        this._closeBatch();
+        this._dragStartTransform = null;
+    }
+    /** The canvas transform right now, or `null` when there is no canvas. */
+    _readCanvasTransform() {
+        const canvas = this._store.fCanvas;
+        if (!canvas) {
+            return null;
+        }
+        const transform = canvas.transform;
+        return {
+            position: PointExtensions.sum(transform.position, transform.scaledPosition),
+            scale: transform.scale,
+        };
+    }
+    /**
+     * Folds a drag's canvas transform into its step, but only when the transform
+     * actually moved during the drag. A plain node drag leaves the canvas alone,
+     * so we must NOT capture it — that would solidify an as-yet-unset (undefined)
+     * position to the origin.
+     */
+    _captureCanvasTransform() {
+        const state = this._state;
+        const current = this._readCanvasTransform();
+        const start = this._dragStartTransform;
+        if (!current ||
+            !start ||
+            (current.position.x === start.position.x &&
+                current.position.y === start.position.y &&
+                current.scale === start.scale)) {
+            return;
+        }
+        state._initializeTransform(start);
+        state.applyTransform(current);
+    }
+    _openBatch() {
+        if (!this._batchActive) {
+            this._batchActive = true;
+            this._state.beginBatch();
+        }
+    }
+    _closeBatch() {
+        if (this._batchActive) {
+            this._batchActive = false;
+            this._state.endBatch();
+        }
+    }
+    /**
+     * When selection is part of the history, `undo`/`redo` land on a shape with
+     * its own selection — push it back into the flow so the highlight follows.
+     * `isSelectedChanged: false` keeps this from re-emitting a selection change.
+     */
+    _wireSelectionRestore() {
+        const state = this._state;
+        const ref = effect(() => {
+            const selection = state.selection();
+            this._restoreSelection(selection);
+        }, ...(ngDevMode ? [{ debugName: "ref", injector: this._injector }] : [{ injector: this._injector }]));
+        this._disposers.push(() => ref.destroy());
+    }
+    _restoreSelection(selection) {
+        this._store.fFlow?.select([...selection.nodeIds, ...selection.groupIds], selection.connectionIds, false);
+    }
+    /** Resets lifecycle flags and starts a render pass for the restored initial state. */
+    _resetAndRenderFlow() {
+        const flow = this._store.fFlow;
+        if (!flow) {
+            return;
+        }
+        flow.reset();
+        this._store.emitNodeChanges();
+    }
+    _resolveOwnerNode(connectorId) {
+        const connector = this._store.connectors.get(connectorId) ??
+            this._store.outputs.get(connectorId) ??
+            this._store.inputs.get(connectorId) ??
+            this._store.outlets.get(connectorId);
+        return connector?.fNodeId;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: FFlowStateController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: FFlowStateController });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: FFlowStateController, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Turns on the managed graph state inside `provideFFlow(...)`.
+ *
+ * ```typescript
+ * @Component({
+ *   providers: [provideFFlow(withFlowState())],
+ * })
+ * export class MyFlow {
+ *   protected readonly state = injectFlowState<MyNodeData>();
+ *
+ *   constructor() {
+ *     this.state.load({ nodes: [...], connections: [...] });
+ *   }
+ * }
+ * ```
+ *
+ * The template renders `state.nodes()` / `state.connections()` with `@for`,
+ * and that is the whole integration: finished gestures (create/reassign
+ * connection, node moves, drops into groups, external-item drops, delete
+ * requests) are applied to the state automatically, each as one undoable
+ * step. `undo()`/`redo()` with `canUndo`/`canRedo` signals come built in;
+ * `snapshot()` returns the graph as plain arrays for persistence.
+ *
+ * Every store behavior is overridable: subclass `FFlowState` (any CRUD
+ * method, any `apply*` gesture handler, any protected building block) and
+ * install it via `withFlowState({ stateClass: MyFlowState })`.
+ *
+ * The classic event-driven API keeps working unchanged — this plugin is for
+ * apps that would rather hand the data bookkeeping to the library.
+ */
+function withFlowState(config) {
+    const resolved = mergeFlowStateConfig(config);
+    return {
+        kind: EFFlowFeatureKind.STATE,
+        providers: [
+            { provide: FFlowState, useClass: resolved.stateClass ?? FFlowState },
+            { provide: F_FLOW_STATE_CONFIG, useValue: resolved },
+        ],
+    };
+}
+
+class FMinimapFlowDirective {
+    fMinSize = input(1000, ...(ngDevMode ? [{ debugName: "fMinSize" }] : []));
+    _mediator = inject(FMediator);
+    hostElement = inject((ElementRef)).nativeElement;
+    model = new FMinimapState(this.hostElement);
+    redraw() {
+        const { scale, viewBox } = this._mediator.execute(new MinimapCalculateViewportRequest(this.hostElement, this.fMinSize()));
+        this.model = new FMinimapState(this.hostElement, scale, viewBox);
+        setRectToViewBox(viewBox, this.hostElement);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: FMinimapFlowDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.9", type: FMinimapFlowDirective, isStandalone: true, selector: "svg[fMinimapFlow]", inputs: { fMinSize: { classPropertyName: "fMinSize", publicName: "fMinSize", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: FMinimapFlowDirective, decorators: [{
             type: Directive,
@@ -21924,12 +23534,7 @@ class FMinimapCanvasDirective {
     _elementRef = inject((ElementRef));
     hostElement = this._elementRef.nativeElement;
     redraw() {
-        this.clear();
-        const fragment = this._elementRef.nativeElement.ownerDocument.createDocumentFragment();
-        this._mediator.execute(new MinimapDrawNodesRequest()).forEach((x) => {
-            fragment.appendChild(x);
-        });
-        this.hostElement.appendChild(fragment);
+        this._mediator.execute(new MinimapDrawNodesRequest(this.hostElement));
     }
     clear() {
         this.hostElement.replaceChildren();
@@ -21984,7 +23589,14 @@ class FMinimapComponent extends FMinimapBase {
     _flow = viewChild.required(FMinimapFlowDirective);
     _minimapView = viewChild.required(FMinimapViewDirective);
     fMinSize = input(1000, ...(ngDevMode ? [{ debugName: "fMinSize" }] : []));
-    fNodeRenderLimit = input(1500, ...(ngDevMode ? [{ debugName: "fNodeRenderLimit", transform: numberAttribute }] : [{ transform: numberAttribute }]));
+    /**
+     * Above this node count the minimap stops rendering node rects. The limit
+     * guards against extreme graphs; since node rects are now computed from the
+     * model and reused between frames (no per-frame DOM measurement), the
+     * default is an order of magnitude higher than the old DOM-measured path
+     * allowed.
+     */
+    fNodeRenderLimit = input(10000, ...(ngDevMode ? [{ debugName: "fNodeRenderLimit", transform: numberAttribute }] : [{ transform: numberAttribute }]));
     get state() {
         return this._flow().model;
     }
@@ -22097,6 +23709,7 @@ class FFlowComponent extends FFlowBase {
     _injector = inject(Injector);
     _flowConfig = inject(F_FLOW_CONFIG, { optional: true });
     _a11y = inject(FA11yController);
+    _flowState = inject(FFlowStateController);
     fId = input(this._flowConfig?.id ?? `f-flow-${uniqueId++}`, ...(ngDevMode ? [{ debugName: "fId", alias: 'fFlowId' }] : [{
             alias: 'fFlowId',
         }]));
@@ -22119,6 +23732,7 @@ class FFlowComponent extends FFlowBase {
         this._listenNodesChanges();
         this._listenConnectionsChanges();
         this._a11y.initialize();
+        this._flowState.initialize();
         this._warnWhenHostHasNoHeight();
     }
     /**
@@ -22223,6 +23837,7 @@ class FFlowComponent extends FFlowBase {
     }
     ngOnDestroy() {
         this._a11y.destroy();
+        this._flowState.destroy();
         this._mediator.execute(new RemoveFlowFromStoreRequest(this));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: FFlowComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
@@ -22237,6 +23852,7 @@ class FFlowComponent extends FFlowBase {
             ...F_REFLOW_PROVIDERS,
             FA11yAnnouncer,
             FA11yController,
+            FFlowStateController,
             { provide: F_FLOW, useExisting: FFlowComponent },
         ], usesInheritance: true, ngImport: i0, template: "<ng-container>\n  <ng-content select=\"[fDefinitions]\"/>\n\n  <ng-content select=\"f-background\"/>\n\n  <ng-content select=\"f-line-alignment\"/>\n\n  <ng-content select=\"f-canvas\"/>\n\n  <ng-content select=\"f-selection-area\"/>\n\n  <ng-content/>\n</ng-container>\n", styles: [":host{display:block;position:relative;width:100%;height:100%;overflow:hidden;pointer-events:all;-webkit-user-select:none;user-select:none;touch-action:none}:host:focus,:host:focus-visible{outline:2px solid transparent}:host(.f-dragging) ::ng-deep .f-connection .f-connection-group,:host(.f-dragging) ::ng-deep .f-connection .f-connection-content,:host(.f-dragging) ::ng-deep .f-connection svg *,:host(.f-connections-dragging) ::ng-deep .f-connection .f-connection-group,:host(.f-connections-dragging) ::ng-deep .f-connection .f-connection-content,:host(.f-connections-dragging) ::ng-deep .f-connection svg *{pointer-events:none!important}::ng-deep .f-connection-content{position:absolute;left:0;top:0;inline-size:max-content;pointer-events:all;transform-origin:50% 50%}::ng-deep .f-node,::ng-deep .f-group{position:absolute!important;transform-origin:center;-webkit-user-select:none;user-select:none;pointer-events:all;left:0!important;top:0!important;box-sizing:border-box}::ng-deep .f-group{z-index:1}::ng-deep .f-connection-content{z-index:3}::ng-deep .f-node{z-index:4}.hidden{opacity:0}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
@@ -22256,6 +23872,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
                         ...F_REFLOW_PROVIDERS,
                         FA11yAnnouncer,
                         FA11yController,
+                        FFlowStateController,
                         { provide: F_FLOW, useExisting: FFlowComponent },
                     ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container>\n  <ng-content select=\"[fDefinitions]\"/>\n\n  <ng-content select=\"f-background\"/>\n\n  <ng-content select=\"f-line-alignment\"/>\n\n  <ng-content select=\"f-canvas\"/>\n\n  <ng-content select=\"f-selection-area\"/>\n\n  <ng-content/>\n</ng-container>\n", styles: [":host{display:block;position:relative;width:100%;height:100%;overflow:hidden;pointer-events:all;-webkit-user-select:none;user-select:none;touch-action:none}:host:focus,:host:focus-visible{outline:2px solid transparent}:host(.f-dragging) ::ng-deep .f-connection .f-connection-group,:host(.f-dragging) ::ng-deep .f-connection .f-connection-content,:host(.f-dragging) ::ng-deep .f-connection svg *,:host(.f-connections-dragging) ::ng-deep .f-connection .f-connection-group,:host(.f-connections-dragging) ::ng-deep .f-connection .f-connection-content,:host(.f-connections-dragging) ::ng-deep .f-connection svg *{pointer-events:none!important}::ng-deep .f-connection-content{position:absolute;left:0;top:0;inline-size:max-content;pointer-events:all;transform-origin:50% 50%}::ng-deep .f-node,::ng-deep .f-group{position:absolute!important;transform-origin:center;-webkit-user-select:none;user-select:none;pointer-events:all;left:0!important;top:0!important;box-sizing:border-box}::ng-deep .f-group{z-index:1}::ng-deep .f-connection-content{z-index:3}::ng-deep .f-node{z-index:4}.hidden{opacity:0}\n"] }]
         }], propDecorators: { fId: [{ type: i0.Input, args: [{ isSignal: true, alias: "fFlowId", required: false }] }], fCache: [{ type: i0.Input, args: [{ isSignal: true, alias: "fCache", required: false }] }], fNodesRendered: [{ type: i0.Output, args: ["fNodesRendered"] }], fFullRendered: [{ type: i0.Output, args: ["fFullRendered"] }], fLoaded: [{ type: i0.Output, args: ["fLoaded"] }] } });
@@ -22693,5 +24310,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AddCanvasToStore, AddCanvasToStoreRequest, AddConnectionForCreateToStore, AddConnectionForCreateToStoreRequest, AddConnectionMarkerToStore, AddConnectionMarkerToStoreRequest, AddConnectionToStore, AddConnectionToStoreRequest, AddConnectorToStore, AddConnectorToStoreRequest, AddDndToStore, AddDndToStoreRequest, AddFlowToStore, AddFlowToStoreRequest, AddNodeToStore, AddNodeToStoreRequest, AddPatternToBackground, AddPatternToBackgroundRequest, AddSnapConnectionToStore, AddSnapConnectionToStoreRequest, ApplyChildResizeConstraints, ApplyChildResizeConstraintsRequest, ApplyConnectionRender, ApplyConnectionRenderRequest, ApplyConnectionWorkerResult, ApplyConnectionWorkerResultRequest, ApplyParentResizeConstraints, ApplyParentResizeConstraintsRequest, AttachDragNodeHandlerFromSelection, AttachDragNodeHandlerFromSelectionRequest, AttachResizeConnectionDragHandlersToNode, AttachResizeConnectionDragHandlersToNodeRequest, AttachSoftParentConnectionDragHandlersToNode, AttachSoftParentConnectionDragHandlersToNodeRequest, AttachSourceConnectionDragHandlersToNode, AttachSourceConnectionDragHandlersToNodeRequest, AttachTargetConnectionDragHandlersToNode, AttachTargetConnectionDragHandlersToNodeRequest, BuildConnectionLine, BuildConnectionLineRequest, BuildConnectionWorkerBatch, BuildConnectionWorkerBatchRequest, BuildConnectionWorkerPayloadItem, BuildConnectionWorkerPayloadItemRequest, BuildDragNodeConstraints, BuildDragNodeConstraintsRequest, CALCULATABLE_SIDES, COMMON_PROVIDERS, CONNECTABLE_SIDE_EPSILON, CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS, CalculateAdaptiveCurveData, CalculateBezierCurveData, CalculateChangedRectFromDifference, CalculateChangedRectFromDifferenceRequest, CalculateClosestConnector, CalculateClosestConnectorRequest, CalculateConnectableSideByConnectedPositions, CalculateConnectableSideByConnectedPositionsRequest, CalculateConnectableSideByInternalPosition, CalculateConnectableSideByInternalPositionRequest, CalculateConnectionsState, CalculateConnectionsStateRequest, CalculateConnectorsConnectableSides, CalculateConnectorsConnectableSidesRequest, CalculateDirectChildrenUnionRect, CalculateDirectChildrenUnionRectRequest, CalculateFlowPointFromMinimapPoint, CalculateFlowPointFromMinimapPointRequest, CalculateFlowState, CalculateFlowStateRequest, CalculateInputConnections, CalculateInputConnectionsRequest, CalculateNodesBoundingBox, CalculateNodesBoundingBoxNormalizedPosition, CalculateNodesBoundingBoxNormalizedPositionRequest, CalculateNodesBoundingBoxRequest, CalculateNodesState, CalculateNodesStateRequest, CalculateOutputConnections, CalculateOutputConnectionsRequest, CalculateResizeLimits, CalculateResizeLimitsRequest, CalculateSegmentLineData, CalculateSelectableItems, CalculateSelectableItemsRequest, CalculateSourceConnectorsToConnect, CalculateSourceConnectorsToConnectRequest, CalculateStraightLineData, CalculateTargetConnectorsToConnect, CalculateTargetConnectorsToConnectRequest, CenterBasedDeltaCalculator, CenterGroupOrNode, CenterGroupOrNodeRequest, CenterOfMassSelectionStrategy, ChainPushCollisionResolver, ClearSelection, ClearSelectionRequest, CompleteConnectionRedraw, CompleteConnectionRedrawRequest, ConnectedSubgraphScopeFilter, ConnectionBehaviourBuilder, ConnectionBehaviourBuilderRequest, ConnectionContentLayoutEngine, ConnectionLineBuilder, ConnectionLineBuilderRequest, ConnectionRedrawState, ConnectionWorkerState, CreateConnectionCreateDragHandler, CreateConnectionCreateDragHandlerRequest, CreateConnectionFinalize, CreateConnectionFinalizeRequest, CreateConnectionFromConnectorPreparation, CreateConnectionFromConnectorPreparationRequest, CreateConnectionFromOutletPreparation, CreateConnectionFromOutletPreparationRequest, CreateConnectionFromOutputPreparation, CreateConnectionFromOutputPreparationRequest, CreateConnectionHandler, CreateConnectionMarkers, CreateConnectionMarkersRequest, CreateConnectionPreparation, CreateConnectionPreparationRequest, CreateDragNodeHandler, CreateDragNodeHandlerRequest, CreateDragNodeHierarchy, CreateDragNodeHierarchyRequest, DRAG_AND_DROP_COMMON_PROVIDERS, DRAG_AUTO_PAN_PROVIDERS, DRAG_CANVAS_PROVIDERS, DRAG_CONNECTIONS_PROVIDERS, DRAG_DROP_TO_GROUP_PROVIDERS, DRAG_EXTERNAL_ITEM_HANDLER_KIND, DRAG_EXTERNAL_ITEM_HANDLER_TYPE, DRAG_EXTERNAL_ITEM_PROVIDERS, DRAG_MINIMAP_HANDLER_KIND, DRAG_MINIMAP_HANDLER_TYPE, DRAG_MINIMAP_PROVIDERS, DRAG_NODE_HANDLER_KIND, DRAG_NODE_HANDLER_TYPE, DRAG_SELECTION_AREA_PROVIDERS, DRAG_SELECT_BY_POINTER_PROVIDERS, DeltaClamp, Deprecated, DetectConnectionsUnderDragNode, DetectConnectionsUnderDragNodeRequest, DisableConnectionWorker, DisableConnectionWorkerRequest, DownstreamConnectionsSelectionStrategy, DragAndDropBase, DragCanvasFinalize, DragCanvasFinalizeRequest, DragCanvasHandler, DragCanvasPreparation, DragCanvasPreparationRequest, DragConnectionWaypointFinalize, DragConnectionWaypointFinalizeRequest, DragConnectionWaypointHandler, DragConnectionWaypointPreparation, DragConnectionWaypointPreparationRequest, DragExternalItemCreatePlaceholder, DragExternalItemCreatePlaceholderRequest, DragExternalItemCreatePreview, DragExternalItemCreatePreviewRequest, DragExternalItemFinalize, DragExternalItemFinalizeRequest, DragExternalItemHandler, DragExternalItemPreparation, DragExternalItemPreparationRequest, DragHandlerBase, DragHandlerInjector, DragMinimapFinalize, DragMinimapFinalizeRequest, DragMinimapHandler, DragMinimapPreparation, DragMinimapPreparationRequest, DragNodeConnectionBothSidesHandler, DragNodeConnectionHandlerBase, DragNodeConnectionSourceHandler, DragNodeConnectionTargetHandler, DragNodeDeltaConstraints, DragNodeFinalize, DragNodeFinalizeRequest, DragNodeHandler, DragNodeHierarchy, DragNodeItemHandler, DragNodePreparation, DragNodePreparationRequest, DropToGroupFinalize, DropToGroupFinalizeRequest, DropToGroupHandler, DropToGroupPreparation, DropToGroupPreparationRequest, ECanvasRedrawContext, EFCanvasLayer, EFConnectableSide, EFConnectionBehavior, EFConnectionConnectableSide, EFConnectionType, EFFlowFeatureKind, EFLayoutDirection, EFLayoutMode, EFMarkerType, EFReflowAxis, EFReflowCollision, EFReflowDeltaSource, EFReflowMode, EFReflowScope, EFResizeHandleType, EFZoomDirection, EMPTY_REFLOW_PLAN, EdgeBasedDeltaCalculator, EmitConnectionsChanges, EmitConnectionsChangesRequest, EmitEndDragSequenceEvent, EmitEndDragSequenceEventRequest, EmitSelectionChangeEvent, EmitSelectionChangeEventRequest, EmitStartDragSequenceEvent, EmitStartDragSequenceEventRequest, EnsureConnectionWorker, EnsureConnectionWorkerRequest, EventExtensions, ExternalRectConstraint, FA11yAnnouncer, FA11yController, FAutoPan, FAutoPanBase, FBackgroundBase, FBackgroundComponent, FCache, FCacheConnector, FCacheConnectorKeyFactory, FCacheNode, FCanvasBase, FCanvasChangeEvent, FCanvasComponent, FChannel, FChannelHub, FCirclePatternComponent, FClickConnectFlow, FComponentsStore, FConnectionBase, FConnectionComponent, FConnectionComponentsParent, FConnectionContent, FConnectionContentBase, FConnectionDragHandleBase, FConnectionDragHandleEnd, FConnectionDragHandleStart, FConnectionForCreateComponent, FConnectionGradient, FConnectionGradientBase, FConnectionGradientRenderer, FConnectionGradientRendererBase, FConnectionMarker, FConnectionMarkerArrow, FConnectionMarkerBase, FConnectionMarkerCircle, FConnectionMarkerRegistry, FConnectionPath, FConnectionPathBase, FConnectionRegistry, FConnectionSelection, FConnectionSelectionBase, FConnectionWaypoints, FConnectionWaypointsBase, FConnectionWaypointsChangedEvent, FConnectorBase, FConnectorDirective, FConnectorRegistry, FControlSchemeController, FCreateConnectionEvent, FCreateConnectionSession, FCreateNodeEvent, FDeleteSelectedEvent, FDragBlockerDirective, FDragExternalItemStartEventData, FDragHandleDirective, FDragHandlerResult, FDragNodeStartEventData, FDragStartedEvent, FDraggableBase, FDraggableDataContext, FDraggableDirective, FDropToGroupEvent, FExternalItem, FExternalItemBase, FExternalItemPlaceholder, FExternalItemPreview, FExternalItemService, FFlowBase, FFlowComponent, FFlowModule, FGroupDirective, FIdRegistryBase, FLayoutController, FLayoutEngine, FLineAlignmentComponent, FMagneticLines, FMagneticLinesBase, FMagneticRects, FMagneticRectsBase, FMinimapBase, FMinimapCanvasDirective, FMinimapComponent, FMinimapFlowDirective, FMinimapState, FMinimapViewDirective, FMoveNodesEvent, FNodeBase, FNodeConnectionsIntersectionEvent, FNodeDirective, FNodeInputBase, FNodeInputDirective, FNodeIntersectedWithConnections, FNodeOutletBase, FNodeOutletDirective, FNodeOutputBase, FNodeOutputDirective, FNodeRegistry, FReassignConnectionEvent, FRectPatternComponent, FReflowBaselineTracker, FReflowController, FReflowCycleGuard, FReflowIgnore, FReflowIgnoreRegistry, FReflowOrchestrator, FReflowPlanner, FResizeChannel, FResizeHandleDirective, FResizeNodeStartEventData, FRotateHandleDirective, FRotateNodeStartEventData, FSelectionArea, FSelectionAreaBase, FSelectionChangeEvent, FSingleRegistryBase, FSnapConnectionComponent, FSourceConnectorBase, FVirtualFor, FZoomBase, FZoomDirective, F_A11Y_CONFIG, F_AUTO_PAN_PROVIDERS, F_BACKGROUND, F_BACKGROUND_FEATURES, F_BACKGROUND_PATTERN, F_BACKGROUND_PROVIDERS, F_CACHE_FEATURES, F_CACHE_OPTIONS, F_CANVAS, F_CANVAS_CONFIG, F_CANVAS_FEATURES, F_CANVAS_PROVIDERS, F_CONNECTION_BUILDERS, F_CONNECTION_COMPONENTS_PARENT, F_CONNECTION_CONTENT, F_CONNECTION_DRAG_HANDLE_END, F_CONNECTION_DRAG_HANDLE_START, F_CONNECTION_FEATURES, F_CONNECTION_FLOW, F_CONNECTION_GRADIENT, F_CONNECTION_IMPORTS_EXPORTS, F_CONNECTION_MARKER, F_CONNECTION_PATH, F_CONNECTION_PROVIDERS, F_CONNECTION_SELECTION, F_CONNECTION_WAYPOINTS, F_CONNECTOR, F_CONNECTORS_FEATURES, F_CONNECTORS_PROVIDERS, F_CONTROL_SCHEME_CONFIG, F_CSS_CLASS, F_DEFAULT_A11Y_CONFIG, F_DEFAULT_A11Y_KEYS, F_DEFAULT_A11Y_MESSAGES, F_DEFAULT_CONTROL_SCHEME, F_DEFAULT_LAYER_ORDER, F_DRAGGABLE_FEATURES, F_DRAGGABLE_PROVIDERS, F_DRAG_SELECT_CONTROL_SCHEME, F_EXTERNAL_ITEM, F_EXTERNAL_ITEM_PROVIDERS, F_FLOW, F_FLOW_CONFIG, F_FLOW_FEATURES, F_FLOW_PROVIDERS, F_LAYOUT, F_LAYOUT_OPTIONS, F_LINE_ALIGNMENT_PROVIDERS, F_MAGNETIC_LINES, F_MAGNETIC_LINES_PROVIDERS, F_MAGNETIC_RECTS, F_MAGNETIC_RECTS_PROVIDERS, F_MINIMAP_BASE, F_MINIMAP_FEATURES, F_MINIMAP_PROVIDERS, F_NODE, F_NODE_FEATURES, F_NODE_INPUT, F_NODE_OUTLET, F_NODE_OUTPUT, F_NODE_PROVIDERS, F_REFLOW_CONFIG, F_REFLOW_PROVIDERS, F_SCROLL_PAN_CONTROL_SCHEME, F_SELECTED_CLASS, F_SELECTION_AREA_PROVIDERS, F_SELECTION_FEATURES, F_STORAGE_PROVIDERS, F_VIRTUAL_FOR_PROVIDERS, F_ZOOM, F_ZOOM_FEATURES, F_ZOOM_PROVIDERS, FindConnectableConnectorUsingPriorityAndPosition, FindConnectableConnectorUsingPriorityAndPositionRequest, FitToChildNodesAndGroups, FitToChildNodesAndGroupsRequest, FitToFlow, FitToFlowRequest, GET_FLOW_STATE_PROVIDERS, GetCachedFCacheRect, GetCachedFCacheRectRequest, GetChildNodeIds, GetChildNodeIdsRequest, GetConnectorRectReference, GetConnectorRectReferenceRequest, GetCurrentSelection, GetCurrentSelectionRequest, GetDeepChildrenNodesAndGroups, GetDeepChildrenNodesAndGroupsRequest, GetFlow, GetFlowRequest, GetNodePadding, GetNodePaddingRequest, GetNormalizedConnectorRect, GetNormalizedConnectorRectRequest, GetNormalizedElementRect, GetNormalizedElementRectRequest, GetNormalizedParentNodeRect, GetNormalizedParentNodeRectRequest, GetNormalizedPoint, GetNormalizedPointRequest, GetParentNodes, GetParentNodesRequest, GlobalScopeFilter, GridSnapper, GroupScopeFilter, HandleConnectionWorkerMessage, HandleConnectionWorkerMessageRequest, IMouseEvent, INSTANCES, IPointerEvent, IPointerUpEvent, ITouchDownEvent, ITouchMoveEvent, InitializeDragSequence, InitializeDragSequenceRequest, InputCanvasPosition, InputCanvasPositionRequest, InputCanvasScale, InputCanvasScaleRequest, InvalidateFCacheNode, InvalidateFCacheNodeRequest, IsArrayHasParentNode, IsArrayHasParentNodeRequest, IsConnectionRedrawCurrent, IsConnectionRedrawCurrentRequest, IsConnectionWorkerEnabled, IsConnectionWorkerEnabledRequest, IsDragStarted, IsDragStartedRequest, ListenConnectionsChanges, ListenConnectionsChangesRequest, ListenNodesChanges, ListenNodesChangesRequest, ListenTransformChanges, ListenTransformChangesRequest, LogExecutionTime, MOUSE_EVENT_IGNORE_TIME, MagneticLineElement, MagneticLineRenderer, MagneticLinesHandler, MagneticLinesPreparation, MagneticLinesPreparationRequest, MagneticRectElement, MagneticRectsHandler, MagneticRectsPreparation, MagneticRectsPreparationRequest, MagneticRectsRenderer, MarkConnectableConnectors, MarkConnectableConnectorsRequest, MarkConnectionConnectorsAsConnected, MarkConnectionConnectorsAsConnectedRequest, MinimapCalculateViewRect, MinimapCalculateViewRectRequest, MinimapCalculateViewport, MinimapCalculateViewportRequest, MinimapDrawNodes, MinimapDrawNodesRequest, MoveFrontElementsBeforeTargetElement, MoveFrontElementsBeforeTargetElementRequest, NODE_PROVIDERS, NODE_RESIZE_PROVIDERS, NODE_ROTATE_PROVIDERS, NotifyFullRendered, NotifyFullRenderedRequest, NotifyNodesRendered, NotifyNodesRenderedRequest, NotifyTransformChanged, NotifyTransformChangedRequest, OnPointerMove, OnPointerMoveRequest, PINCH_TO_ZOOM_PROVIDERS, PinchToZoomFinalize, PinchToZoomFinalizeRequest, PinchToZoomHandler, PinchToZoomPreparation, PinchToZoomPreparationRequest, Polyline, PolylineContentAlign, PolylineContentPlace, PolylineSampler, PrepareDragSequence, PrepareDragSequenceRequest, PreventDefaultIsExternalItem, PreventDefaultIsExternalItemRequest, QueueConnectionRedraw, QueueConnectionRedrawRequest, QueueConnectionRedrawState, RESIZE_DIRECTIONS, RESIZE_NODE_HANDLER_KIND, RESIZE_NODE_HANDLER_TYPE, ROTATE_NODE_HANDLER_KIND, ROTATE_NODE_HANDLER_TYPE, ReadNodeBoundsWithPaddings, ReadNodeBoundsWithPaddingsRequest, ReadNodeBoundsWithPaddingsResponse, ReassignConnectionFinalize, ReassignConnectionFinalizeRequest, ReassignConnectionHandler, ReassignConnectionPreparation, ReassignConnectionPreparationRequest, ReassignConnectionSourceHandler, ReassignConnectionTargetHandler, RedrawCanvasWithAnimation, RedrawCanvasWithAnimationRequest, RedrawConnections, RedrawConnectionsRequest, RegisterFCacheConnector, RegisterFCacheConnectorRequest, RegisterFCacheNode, RegisterFCacheNodeRequest, RegisterPluginInstance, RegisterPluginInstanceRequest, RemoveCanvasFromStore, RemoveCanvasFromStoreRequest, RemoveConnectionForCreateFromStore, RemoveConnectionForCreateFromStoreRequest, RemoveConnectionFromStore, RemoveConnectionFromStoreRequest, RemoveConnectionMarkerFromStore, RemoveConnectionMarkerFromStoreRequest, RemoveConnectionWaypoint, RemoveConnectionWaypointRequest, RemoveConnectorFromStore, RemoveConnectorFromStoreRequest, RemoveDndFromStore, RemoveDndFromStoreRequest, RemoveFlowFromStore, RemoveFlowFromStoreRequest, RemoveNodeFromStore, RemoveNodeFromStoreRequest, RemovePluginInstance, RemovePluginInstanceRequest, RemoveSnapConnectionFromStore, RemoveSnapConnectionFromStoreRequest, RenderConnection, RenderConnectionFromGeometry, RenderConnectionFromGeometryRequest, RenderConnectionRequest, RenderConnectionWithLine, RenderConnectionWithLineRequest, RenderLifecycleState, ResetConnectionWorkerRuntime, ResetConnectionWorkerRuntimeRequest, ResetRenderLifecycle, ResetRenderLifecycleRequest, ResetScale, ResetScaleAndCenter, ResetScaleAndCenterRequest, ResetScaleRequest, ResetZoom, ResetZoomRequest, ResizeNodeConnectionBothSidesHandler, ResizeNodeConnectionHandlerBase, ResizeNodeConnectionSourceHandler, ResizeNodeConnectionTargetHandler, ResizeNodeFinalize, ResizeNodeFinalizeRequest, ResizeNodeHandler, ResizeNodePreparation, ResizeNodePreparationRequest, ResolveConnectableOutputForOutlet, ResolveConnectableOutputForOutletRequest, ResolveConnectionEndpointRect, ResolveConnectionEndpointRectRequest, ResolveConnectionEndpointRotationContext, ResolveConnectionEndpointRotationContextRequest, ResolveConnectionEndpoints, ResolveConnectionEndpointsRequest, ResolveConnectionGeometry, ResolveConnectionGeometryRequest, RotateNodeFinalize, RotateNodeFinalizeRequest, RotateNodeHandler, RotateNodePreparation, RotateNodePreparationRequest, RunAutoPanFrame, RunAutoPanFrameRequest, RunConnectionRedrawSlice, RunConnectionRedrawSliceRequest, RunConnectionWorker, RunConnectionWorkerBatch, RunConnectionWorkerBatchRequest, RunConnectionWorkerRequest, RunDevDiagnostics, RunDevDiagnosticsRequest, ScheduleAutoPanFrame, ScheduleAutoPanFrameRequest, ScrollCanvas, ScrollCanvasRequest, Select, SelectAll, SelectAllRequest, SelectAndUpdateNodeLayer, SelectAndUpdateNodeLayerRequest, SelectByPointer, SelectByPointerRequest, SelectRequest, SelectionAreaFinalize, SelectionAreaFinalizeRequest, SelectionAreaHandler, SelectionAreaPreparation, SelectionAreaPreparationRequest, SetBackgroundTransform, SetBackgroundTransformRequest, SetFCacheConnectorRect, SetFCacheConnectorRectRequest, SetFCacheNodeRect, SetFCacheNodeRectRequest, SetZoom, SetZoomRequest, ShouldUseConnectionWorker, ShouldUseConnectionWorkerRequest, SortDropCandidatesByLayer, SortDropCandidatesByLayerRequest, SortItemLayers, SortItemLayersRequest, SortItemsByParent, SortItemsByParentRequest, SortNodeLayers, SortNodeLayersRequest, StartConnectionRedraw, StartConnectionRedrawRequest, StartConnectionWorkerRedraw, StartConnectionWorkerRedrawRequest, StopAutoPan, StopAutoPanRequest, StopCollisionResolver, UnmarkConnectableConnectors, UnmarkConnectableConnectorsRequest, UnregisterFCacheConnector, UnregisterFCacheConnectorRequest, UnregisterFCacheNode, UnregisterFCacheNodeRequest, UpdateFCacheRectByElement, UpdateFCacheRectByElementRequest, UpdateItemAndChildrenLayers, UpdateItemAndChildrenLayersRequest, UpdateNodeWhenStateOrSizeChanged, UpdateNodeWhenStateOrSizeChangedRequest, UpdateScale, UpdateScaleRequest, WaitForConnectionsRendered, WaitForConnectionsRenderedRequest, XRangeSelectionStrategy, afterNextPaint, buildConnectionAnchors, buildCornerMidPointsAndApplyOffsets, calculateAutoPanAxisDelta, calculateAutoPanDelta, calculateCenterBetweenPoints, calculateCurveCandidates, calculateDifferenceAfterRotation, calculateMagneticGuides, calculateMagneticRects, calculatePointerInFlow, calculatePolylineCandidates, calculatePositionAfterRotation, castToConnectorType, coerceMarkerType, computeEdgeDeltas, createConnectionDomIdentifier, createConnectionSelectionDomIdentifier, createConnectionWorkerUrl, createGradientDomIdentifier, createGradientDomUrl, createMultiCubicPath, createSVGElement, createSegmentLinePath, cubicBezierAtT, debounceAnimationFrame, debounceMicrotask, debounceTime, defaultEventTrigger, determineSide, expandRectByOverflow, fDiagnosticMessage, fInstanceKey, fProvideCache, fSuppressDevWarnings, fWarnOnce, filterConnectableTargets, findExistingWaypoint, findSourceConnector, findSpatialNeighbor, findTargetConnector, findWaypointCandidate, fixedCenterBehavior, fixedOutboundBehavior, floatingBehavior, getAllSourceConnectors, getAllTargetConnectors, getExternalItemHost, infinityMinMax, isCalculateMode, isConnectionWorkerRuntimeSupported, isConnector, isDragBlocker, isDragExternalItemHandler, isDragHandleEnd, isDragHandleStart, isDragMinimapHandler, isDragNodeHandler, isExternalItem, isFDevMode, isMobile, isNode, isNodeOutlet, isNodeOutput, isOnFlowBackground, isOutletConnector, isPointerInsidePoint, isPointerInsideStartOrEndDragHandles, isResizeNodeHandler, isRotateHandle, isRotateNodeHandler, isSourceConnector, isTargetConnector, isValidEventTrigger, mergeA11yConfig, mergeControlSchemeConfig, mergeFCanvasConfig, mergeLayoutNodes, mergePointChains, mergeReflowConfig, middleButtonEventTrigger, mixinChangeSelection, mixinChangeVisibility, normalizeFlowLayoutData, normalizePolyline, notifyOnStart, pickWaypoint, primaryButtonEventTrigger, provideFFlow, provideFLayout, rebaseAutoPanPointerDownPosition, rectFromPoint, requireSourceConnector, requireTargetConnector, resolveAutoPanMode, resolveConnectionWorkerRuntime, resolveLayerOrder, revokeConnectionWorkerUrl, sampleCubicBezierUniform, sampleMultiCubicUniform, stringAttribute, takeOne, transitionEnd, withA11y, withConnectionFlow, withControlScheme, withFCanvas, withReflowOnResize, withinSnapThreshold };
+export { AddCanvasToStore, AddCanvasToStoreRequest, AddConnectionForCreateToStore, AddConnectionForCreateToStoreRequest, AddConnectionMarkerToStore, AddConnectionMarkerToStoreRequest, AddConnectionToStore, AddConnectionToStoreRequest, AddConnectorToStore, AddConnectorToStoreRequest, AddDndToStore, AddDndToStoreRequest, AddFlowToStore, AddFlowToStoreRequest, AddNodeToStore, AddNodeToStoreRequest, AddPatternToBackground, AddPatternToBackgroundRequest, AddSnapConnectionToStore, AddSnapConnectionToStoreRequest, ApplyChildResizeConstraints, ApplyChildResizeConstraintsRequest, ApplyConnectionRender, ApplyConnectionRenderRequest, ApplyConnectionWorkerResult, ApplyConnectionWorkerResultRequest, ApplyParentResizeConstraints, ApplyParentResizeConstraintsRequest, AttachDragNodeHandlerFromSelection, AttachDragNodeHandlerFromSelectionRequest, AttachResizeConnectionDragHandlersToNode, AttachResizeConnectionDragHandlersToNodeRequest, AttachSoftParentConnectionDragHandlersToNode, AttachSoftParentConnectionDragHandlersToNodeRequest, AttachSourceConnectionDragHandlersToNode, AttachSourceConnectionDragHandlersToNodeRequest, AttachTargetConnectionDragHandlersToNode, AttachTargetConnectionDragHandlersToNodeRequest, BuildConnectionLine, BuildConnectionLineRequest, BuildConnectionWorkerBatch, BuildConnectionWorkerBatchRequest, BuildConnectionWorkerPayloadItem, BuildConnectionWorkerPayloadItemRequest, BuildDragNodeConstraints, BuildDragNodeConstraintsRequest, CALCULATABLE_SIDES, COMMON_PROVIDERS, CONNECTABLE_SIDE_EPSILON, CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS, CalculateAdaptiveCurveData, CalculateBezierCurveData, CalculateChangedRectFromDifference, CalculateChangedRectFromDifferenceRequest, CalculateClosestConnector, CalculateClosestConnectorRequest, CalculateConnectableSideByConnectedPositions, CalculateConnectableSideByConnectedPositionsRequest, CalculateConnectableSideByInternalPosition, CalculateConnectableSideByInternalPositionRequest, CalculateConnectionsState, CalculateConnectionsStateRequest, CalculateConnectorsConnectableSides, CalculateConnectorsConnectableSidesRequest, CalculateDirectChildrenUnionRect, CalculateDirectChildrenUnionRectRequest, CalculateFlowPointFromMinimapPoint, CalculateFlowPointFromMinimapPointRequest, CalculateFlowState, CalculateFlowStateRequest, CalculateInputConnections, CalculateInputConnectionsRequest, CalculateNodesBoundingBox, CalculateNodesBoundingBoxNormalizedPosition, CalculateNodesBoundingBoxNormalizedPositionRequest, CalculateNodesBoundingBoxRequest, CalculateNodesState, CalculateNodesStateRequest, CalculateOutputConnections, CalculateOutputConnectionsRequest, CalculateResizeLimits, CalculateResizeLimitsRequest, CalculateSegmentLineData, CalculateSelectableItems, CalculateSelectableItemsRequest, CalculateSourceConnectorsToConnect, CalculateSourceConnectorsToConnectRequest, CalculateStraightLineData, CalculateTargetConnectorsToConnect, CalculateTargetConnectorsToConnectRequest, CenterBasedDeltaCalculator, CenterGroupOrNode, CenterGroupOrNodeRequest, CenterOfMassSelectionStrategy, ChainPushCollisionResolver, ClearSelection, ClearSelectionRequest, CompleteConnectionRedraw, CompleteConnectionRedrawRequest, ConnectableSidesScheduler, ConnectedSubgraphScopeFilter, ConnectionBehaviourBuilder, ConnectionBehaviourBuilderRequest, ConnectionContentLayoutEngine, ConnectionLineBuilder, ConnectionLineBuilderRequest, ConnectionRedrawState, ConnectionWorkerState, CreateConnectionCreateDragHandler, CreateConnectionCreateDragHandlerRequest, CreateConnectionFinalize, CreateConnectionFinalizeRequest, CreateConnectionFromConnectorPreparation, CreateConnectionFromConnectorPreparationRequest, CreateConnectionFromOutletPreparation, CreateConnectionFromOutletPreparationRequest, CreateConnectionFromOutputPreparation, CreateConnectionFromOutputPreparationRequest, CreateConnectionHandler, CreateConnectionMarkers, CreateConnectionMarkersRequest, CreateConnectionPreparation, CreateConnectionPreparationRequest, CreateDragNodeHandler, CreateDragNodeHandlerRequest, CreateDragNodeHierarchy, CreateDragNodeHierarchyRequest, DRAG_AND_DROP_COMMON_PROVIDERS, DRAG_AUTO_PAN_PROVIDERS, DRAG_CANVAS_PROVIDERS, DRAG_CONNECTIONS_PROVIDERS, DRAG_DROP_TO_GROUP_PROVIDERS, DRAG_EXTERNAL_ITEM_HANDLER_KIND, DRAG_EXTERNAL_ITEM_HANDLER_TYPE, DRAG_EXTERNAL_ITEM_PROVIDERS, DRAG_MINIMAP_HANDLER_KIND, DRAG_MINIMAP_HANDLER_TYPE, DRAG_MINIMAP_PROVIDERS, DRAG_NODE_HANDLER_KIND, DRAG_NODE_HANDLER_TYPE, DRAG_SELECTION_AREA_PROVIDERS, DRAG_SELECT_BY_POINTER_PROVIDERS, DeltaClamp, Deprecated, DetectConnectionsUnderDragNode, DetectConnectionsUnderDragNodeRequest, DisableConnectionWorker, DisableConnectionWorkerRequest, DownstreamConnectionsSelectionStrategy, DragAndDropBase, DragCanvasFinalize, DragCanvasFinalizeRequest, DragCanvasHandler, DragCanvasPreparation, DragCanvasPreparationRequest, DragConnectionWaypointFinalize, DragConnectionWaypointFinalizeRequest, DragConnectionWaypointHandler, DragConnectionWaypointPreparation, DragConnectionWaypointPreparationRequest, DragExternalItemCreatePlaceholder, DragExternalItemCreatePlaceholderRequest, DragExternalItemCreatePreview, DragExternalItemCreatePreviewRequest, DragExternalItemFinalize, DragExternalItemFinalizeRequest, DragExternalItemHandler, DragExternalItemPreparation, DragExternalItemPreparationRequest, DragHandlerBase, DragHandlerInjector, DragMinimapFinalize, DragMinimapFinalizeRequest, DragMinimapHandler, DragMinimapPreparation, DragMinimapPreparationRequest, DragNodeConnectionBothSidesHandler, DragNodeConnectionHandlerBase, DragNodeConnectionSourceHandler, DragNodeConnectionTargetHandler, DragNodeDeltaConstraints, DragNodeFinalize, DragNodeFinalizeRequest, DragNodeHandler, DragNodeHierarchy, DragNodeItemHandler, DragNodePreparation, DragNodePreparationRequest, DropToGroupFinalize, DropToGroupFinalizeRequest, DropToGroupHandler, DropToGroupPreparation, DropToGroupPreparationRequest, ECanvasRedrawContext, EFCanvasLayer, EFConnectableSide, EFConnectionBehavior, EFConnectionConnectableSide, EFConnectionType, EFFlowFeatureKind, EFLayoutDirection, EFLayoutMode, EFMarkerType, EFReflowAxis, EFReflowCollision, EFReflowDeltaSource, EFReflowMode, EFReflowScope, EFResizeHandleType, EFZoomDirection, EMPTY_REFLOW_PLAN, EdgeBasedDeltaCalculator, EmitConnectionsChanges, EmitConnectionsChangesRequest, EmitEndDragSequenceEvent, EmitEndDragSequenceEventRequest, EmitSelectionChangeEvent, EmitSelectionChangeEventRequest, EmitStartDragSequenceEvent, EmitStartDragSequenceEventRequest, EnsureConnectionWorker, EnsureConnectionWorkerRequest, EventExtensions, ExternalRectConstraint, FA11yAnnouncer, FA11yController, FAutoPan, FAutoPanBase, FBackgroundBase, FBackgroundComponent, FCache, FCacheConnector, FCacheConnectorKeyFactory, FCacheNode, FCanvasBase, FCanvasChangeEvent, FCanvasComponent, FChannel, FChannelHub, FCirclePatternComponent, FClickConnectFlow, FComponentsStore, FConnectionBase, FConnectionComponent, FConnectionComponentsParent, FConnectionContent, FConnectionContentBase, FConnectionDragHandleBase, FConnectionDragHandleEnd, FConnectionDragHandleStart, FConnectionForCreateComponent, FConnectionGradient, FConnectionGradientBase, FConnectionGradientRenderer, FConnectionGradientRendererBase, FConnectionMarker, FConnectionMarkerArrow, FConnectionMarkerBase, FConnectionMarkerCircle, FConnectionMarkerRegistry, FConnectionPath, FConnectionPathBase, FConnectionRegistry, FConnectionSelection, FConnectionSelectionBase, FConnectionWaypoints, FConnectionWaypointsBase, FConnectionWaypointsChangedEvent, FConnectorBase, FConnectorDirective, FConnectorRegistry, FControlSchemeController, FCreateConnectionEvent, FCreateConnectionSession, FCreateNodeEvent, FDeleteSelectedEvent, FDragBlockerDirective, FDragExternalItemStartEventData, FDragHandleDirective, FDragHandlerResult, FDragNodeStartEventData, FDragStartedEvent, FDraggableBase, FDraggableDataContext, FDraggableDirective, FDropToGroupEvent, FExternalItem, FExternalItemBase, FExternalItemPlaceholder, FExternalItemPreview, FExternalItemService, FFlowBase, FFlowComponent, FFlowModule, FFlowState, FFlowStateController, FGroupDirective, FIdRegistryBase, FLayoutController, FLayoutEngine, FLineAlignmentComponent, FMagneticLines, FMagneticLinesBase, FMagneticRects, FMagneticRectsBase, FMinimapBase, FMinimapCanvasDirective, FMinimapComponent, FMinimapFlowDirective, FMinimapState, FMinimapViewDirective, FMoveNodesEvent, FNodeBase, FNodeConnectionsIntersectionEvent, FNodeDirective, FNodeInputBase, FNodeInputDirective, FNodeIntersectedWithConnections, FNodeOutletBase, FNodeOutletDirective, FNodeOutputBase, FNodeOutputDirective, FNodeRegistry, FReassignConnectionEvent, FRectPatternComponent, FReflowBaselineTracker, FReflowController, FReflowCycleGuard, FReflowIgnore, FReflowIgnoreRegistry, FReflowOrchestrator, FReflowPlanner, FResizeChannel, FResizeHandleDirective, FResizeNodeStartEventData, FRotateHandleDirective, FRotateNodeStartEventData, FSelectionArea, FSelectionAreaBase, FSelectionChangeEvent, FSingleRegistryBase, FSnapConnectionComponent, FSourceConnectorBase, FVirtualFor, FZoomBase, FZoomDirective, F_A11Y_CONFIG, F_AUTO_PAN_PROVIDERS, F_BACKGROUND, F_BACKGROUND_FEATURES, F_BACKGROUND_PATTERN, F_BACKGROUND_PROVIDERS, F_CACHE_FEATURES, F_CACHE_OPTIONS, F_CANVAS, F_CANVAS_CONFIG, F_CANVAS_FEATURES, F_CANVAS_PROVIDERS, F_CONNECTION_BUILDERS, F_CONNECTION_COMPONENTS_PARENT, F_CONNECTION_CONTENT, F_CONNECTION_DRAG_HANDLE_END, F_CONNECTION_DRAG_HANDLE_START, F_CONNECTION_FEATURES, F_CONNECTION_FLOW, F_CONNECTION_GRADIENT, F_CONNECTION_IMPORTS_EXPORTS, F_CONNECTION_MARKER, F_CONNECTION_PATH, F_CONNECTION_PROVIDERS, F_CONNECTION_SELECTION, F_CONNECTION_WAYPOINTS, F_CONNECTOR, F_CONNECTORS_FEATURES, F_CONNECTORS_PROVIDERS, F_CONTROL_SCHEME_CONFIG, F_CSS_CLASS, F_DEFAULT_A11Y_CONFIG, F_DEFAULT_A11Y_KEYS, F_DEFAULT_A11Y_MESSAGES, F_DEFAULT_CONTROL_SCHEME, F_DEFAULT_LAYER_ORDER, F_DRAGGABLE_FEATURES, F_DRAGGABLE_PROVIDERS, F_DRAG_SELECT_CONTROL_SCHEME, F_EXTERNAL_ITEM, F_EXTERNAL_ITEM_PROVIDERS, F_FLOW, F_FLOW_CONFIG, F_FLOW_FEATURES, F_FLOW_PROVIDERS, F_FLOW_STATE_CONFIG, F_LAYOUT, F_LAYOUT_OPTIONS, F_LINE_ALIGNMENT_PROVIDERS, F_MAGNETIC_LINES, F_MAGNETIC_LINES_PROVIDERS, F_MAGNETIC_RECTS, F_MAGNETIC_RECTS_PROVIDERS, F_MINIMAP_BASE, F_MINIMAP_FEATURES, F_MINIMAP_PROVIDERS, F_NODE, F_NODE_FEATURES, F_NODE_INPUT, F_NODE_OUTLET, F_NODE_OUTPUT, F_NODE_PROVIDERS, F_REFLOW_CONFIG, F_REFLOW_PROVIDERS, F_SCROLL_PAN_CONTROL_SCHEME, F_SELECTED_CLASS, F_SELECTION_AREA_PROVIDERS, F_SELECTION_FEATURES, F_STORAGE_PROVIDERS, F_VIRTUAL_FOR_PROVIDERS, F_ZOOM, F_ZOOM_FEATURES, F_ZOOM_PROVIDERS, FindConnectableConnectorUsingPriorityAndPosition, FindConnectableConnectorUsingPriorityAndPositionRequest, FitToChildNodesAndGroups, FitToChildNodesAndGroupsRequest, FitToFlow, FitToFlowRequest, GET_FLOW_STATE_PROVIDERS, GetCachedFCacheRect, GetCachedFCacheRectRequest, GetChildNodeIds, GetChildNodeIdsRequest, GetConnectorRectReference, GetConnectorRectReferenceRequest, GetCurrentSelection, GetCurrentSelectionRequest, GetDeepChildrenNodesAndGroups, GetDeepChildrenNodesAndGroupsRequest, GetFlow, GetFlowRequest, GetNodePadding, GetNodePaddingRequest, GetNormalizedConnectorRect, GetNormalizedConnectorRectRequest, GetNormalizedElementRect, GetNormalizedElementRectRequest, GetNormalizedParentNodeRect, GetNormalizedParentNodeRectRequest, GetNormalizedPoint, GetNormalizedPointRequest, GetParentNodes, GetParentNodesRequest, GlobalScopeFilter, GridSnapper, GroupScopeFilter, HandleConnectionWorkerMessage, HandleConnectionWorkerMessageRequest, IMouseEvent, INSTANCES, IPointerEvent, IPointerUpEvent, ITouchDownEvent, ITouchMoveEvent, InitializeDragSequence, InitializeDragSequenceRequest, InputCanvasPosition, InputCanvasPositionRequest, InputCanvasScale, InputCanvasScaleRequest, InvalidateFCacheNode, InvalidateFCacheNodeRequest, IsArrayHasParentNode, IsArrayHasParentNodeRequest, IsConnectionRedrawCurrent, IsConnectionRedrawCurrentRequest, IsConnectionWorkerEnabled, IsConnectionWorkerEnabledRequest, IsDragStarted, IsDragStartedRequest, ListenConnectionsChanges, ListenConnectionsChangesRequest, ListenNodesChanges, ListenNodesChangesRequest, ListenTransformChanges, ListenTransformChangesRequest, LogExecutionTime, MOUSE_EVENT_IGNORE_TIME, MagneticLineElement, MagneticLineRenderer, MagneticLinesHandler, MagneticLinesPreparation, MagneticLinesPreparationRequest, MagneticRectElement, MagneticRectsHandler, MagneticRectsPreparation, MagneticRectsPreparationRequest, MagneticRectsRenderer, MarkConnectableConnectors, MarkConnectableConnectorsRequest, MarkConnectionConnectorsAsConnected, MarkConnectionConnectorsAsConnectedRequest, MinimapCalculateViewRect, MinimapCalculateViewRectRequest, MinimapCalculateViewport, MinimapCalculateViewportRequest, MinimapDrawNodes, MinimapDrawNodesRequest, MinimapNodeRects, MoveFrontElementsBeforeTargetElement, MoveFrontElementsBeforeTargetElementRequest, NODE_PROVIDERS, NODE_RESIZE_PROVIDERS, NODE_ROTATE_PROVIDERS, NotifyFullRendered, NotifyFullRenderedRequest, NotifyNodesRendered, NotifyNodesRenderedRequest, NotifyTransformChanged, NotifyTransformChangedRequest, OnPointerMove, OnPointerMoveRequest, PINCH_TO_ZOOM_PROVIDERS, PinchToZoomFinalize, PinchToZoomFinalizeRequest, PinchToZoomHandler, PinchToZoomPreparation, PinchToZoomPreparationRequest, Polyline, PolylineContentAlign, PolylineContentPlace, PolylineSampler, PrepareDragSequence, PrepareDragSequenceRequest, PreventDefaultIsExternalItem, PreventDefaultIsExternalItemRequest, QueueConnectionRedraw, QueueConnectionRedrawRequest, QueueConnectionRedrawState, RESIZE_DIRECTIONS, RESIZE_NODE_HANDLER_KIND, RESIZE_NODE_HANDLER_TYPE, ROTATE_NODE_HANDLER_KIND, ROTATE_NODE_HANDLER_TYPE, ReadNodeBoundsWithPaddings, ReadNodeBoundsWithPaddingsRequest, ReadNodeBoundsWithPaddingsResponse, ReassignConnectionFinalize, ReassignConnectionFinalizeRequest, ReassignConnectionHandler, ReassignConnectionPreparation, ReassignConnectionPreparationRequest, ReassignConnectionSourceHandler, ReassignConnectionTargetHandler, RedrawCanvasWithAnimation, RedrawCanvasWithAnimationRequest, RedrawConnections, RedrawConnectionsRequest, RegisterFCacheConnector, RegisterFCacheConnectorRequest, RegisterFCacheNode, RegisterFCacheNodeRequest, RegisterPluginInstance, RegisterPluginInstanceRequest, RemoveCanvasFromStore, RemoveCanvasFromStoreRequest, RemoveConnectionForCreateFromStore, RemoveConnectionForCreateFromStoreRequest, RemoveConnectionFromStore, RemoveConnectionFromStoreRequest, RemoveConnectionMarkerFromStore, RemoveConnectionMarkerFromStoreRequest, RemoveConnectionWaypoint, RemoveConnectionWaypointRequest, RemoveConnectorFromStore, RemoveConnectorFromStoreRequest, RemoveDndFromStore, RemoveDndFromStoreRequest, RemoveFlowFromStore, RemoveFlowFromStoreRequest, RemoveNodeFromStore, RemoveNodeFromStoreRequest, RemovePluginInstance, RemovePluginInstanceRequest, RemoveSnapConnectionFromStore, RemoveSnapConnectionFromStoreRequest, RenderConnection, RenderConnectionFromGeometry, RenderConnectionFromGeometryRequest, RenderConnectionRequest, RenderConnectionWithLine, RenderConnectionWithLineRequest, RenderLifecycleState, ResetConnectionWorkerRuntime, ResetConnectionWorkerRuntimeRequest, ResetRenderLifecycle, ResetRenderLifecycleRequest, ResetScale, ResetScaleAndCenter, ResetScaleAndCenterRequest, ResetScaleRequest, ResetZoom, ResetZoomRequest, ResizeNodeConnectionBothSidesHandler, ResizeNodeConnectionHandlerBase, ResizeNodeConnectionSourceHandler, ResizeNodeConnectionTargetHandler, ResizeNodeFinalize, ResizeNodeFinalizeRequest, ResizeNodeHandler, ResizeNodePreparation, ResizeNodePreparationRequest, ResolveConnectableOutputForOutlet, ResolveConnectableOutputForOutletRequest, ResolveConnectionEndpointRect, ResolveConnectionEndpointRectRequest, ResolveConnectionEndpointRotationContext, ResolveConnectionEndpointRotationContextRequest, ResolveConnectionEndpoints, ResolveConnectionEndpointsRequest, ResolveConnectionGeometry, ResolveConnectionGeometryRequest, RotateNodeFinalize, RotateNodeFinalizeRequest, RotateNodeHandler, RotateNodePreparation, RotateNodePreparationRequest, RunAutoPanFrame, RunAutoPanFrameRequest, RunConnectionRedrawSlice, RunConnectionRedrawSliceRequest, RunConnectionWorker, RunConnectionWorkerBatch, RunConnectionWorkerBatchRequest, RunConnectionWorkerRequest, RunDevDiagnostics, RunDevDiagnosticsRequest, ScheduleAutoPanFrame, ScheduleAutoPanFrameRequest, ScrollCanvas, ScrollCanvasRequest, Select, SelectAll, SelectAllRequest, SelectAndUpdateNodeLayer, SelectAndUpdateNodeLayerRequest, SelectByPointer, SelectByPointerRequest, SelectRequest, SelectionAreaFinalize, SelectionAreaFinalizeRequest, SelectionAreaHandler, SelectionAreaPreparation, SelectionAreaPreparationRequest, SetBackgroundTransform, SetBackgroundTransformRequest, SetFCacheConnectorRect, SetFCacheConnectorRectRequest, SetFCacheNodeRect, SetFCacheNodeRectRequest, SetZoom, SetZoomRequest, ShouldUseConnectionWorker, ShouldUseConnectionWorkerRequest, SortDropCandidatesByLayer, SortDropCandidatesByLayerRequest, SortItemLayers, SortItemLayersRequest, SortItemsByParent, SortItemsByParentRequest, SortNodeLayers, SortNodeLayersRequest, StartConnectionRedraw, StartConnectionRedrawRequest, StartConnectionWorkerRedraw, StartConnectionWorkerRedrawRequest, StopAutoPan, StopAutoPanRequest, StopCollisionResolver, UnmarkConnectableConnectors, UnmarkConnectableConnectorsRequest, UnregisterFCacheConnector, UnregisterFCacheConnectorRequest, UnregisterFCacheNode, UnregisterFCacheNodeRequest, UpdateFCacheRectByElement, UpdateFCacheRectByElementRequest, UpdateItemAndChildrenLayers, UpdateItemAndChildrenLayersRequest, UpdateNodeWhenStateOrSizeChanged, UpdateNodeWhenStateOrSizeChangedRequest, UpdateScale, UpdateScaleRequest, WaitForConnectionsRendered, WaitForConnectionsRenderedRequest, XRangeSelectionStrategy, afterNextPaint, buildConnectionAnchors, buildCornerMidPointsAndApplyOffsets, calculateAutoPanAxisDelta, calculateAutoPanDelta, calculateCenterBetweenPoints, calculateCurveCandidates, calculateDifferenceAfterRotation, calculateMagneticGuides, calculateMagneticRects, calculatePointerInFlow, calculatePolylineCandidates, calculatePositionAfterRotation, castToConnectorType, coerceMarkerType, computeEdgeDeltas, createConnectionDomIdentifier, createConnectionSelectionDomIdentifier, createConnectionWorkerUrl, createGradientDomIdentifier, createGradientDomUrl, createMultiCubicPath, createSVGElement, createSegmentLinePath, cubicBezierAtT, debounceAnimationFrame, debounceMicrotask, debounceTime, defaultEventTrigger, determineSide, expandRectByOverflow, fDiagnosticMessage, fInstanceKey, fProvideCache, fSuppressDevWarnings, fWarnOnce, filterConnectableTargets, findExistingWaypoint, findNodeOrGroupContaining, findSourceConnector, findSpatialNeighbor, findTargetConnector, findWaypointCandidate, fixedCenterBehavior, fixedOutboundBehavior, floatingBehavior, getAllSourceConnectors, getAllTargetConnectors, getExternalItemHost, infinityMinMax, injectFlowState, isCalculateMode, isConnectionWorkerRuntimeSupported, isConnector, isDragBlocker, isDragExternalItemHandler, isDragHandleEnd, isDragHandleStart, isDragMinimapHandler, isDragNodeHandler, isExternalItem, isFDevMode, isMobile, isNode, isNodeOutlet, isNodeOutput, isOnFlowBackground, isOutletConnector, isPointerInsidePoint, isPointerInsideStartOrEndDragHandles, isResizeNodeHandler, isRotateHandle, isRotateNodeHandler, isSourceConnector, isTargetConnector, isValidEventTrigger, mergeA11yConfig, mergeControlSchemeConfig, mergeFCanvasConfig, mergeFlowStateConfig, mergeLayoutNodes, mergePointChains, mergeReflowConfig, middleButtonEventTrigger, mixinChangeSelection, mixinChangeVisibility, normalizeFlowLayoutData, normalizePolyline, notifyOnStart, pickWaypoint, primaryButtonEventTrigger, provideFFlow, provideFLayout, rebaseAutoPanPointerDownPosition, rectFromPoint, requireSourceConnector, requireTargetConnector, resolveAutoPanMode, resolveConnectionWorkerRuntime, resolveLayerOrder, revokeConnectionWorkerUrl, sampleCubicBezierUniform, sampleMultiCubicUniform, stringAttribute, takeOne, transitionEnd, withA11y, withConnectionFlow, withControlScheme, withFCanvas, withFlowState, withReflowOnResize, withinSnapThreshold };
 //# sourceMappingURL=foblex-flow.mjs.map