@grafloria/element 0.3.18 → 0.3.20

package/src/libs/engine/src/interaction/GroupCollapseService.js

@@ -0,0 +1,274 @@
+"use strict";
+// GroupCollapseService — Wave-5 Card 4: real collapse / expand.
+//
+// Collapse hides a group's members, shrinks the group to a titled placeholder,
+// saves child positions, and RE-HOMES every member-incident edge to the group
+// boundary — aggregating parallel same-direction crossings between the group
+// and a given external node into ONE labelled proxy link.
+//
+// OWNERSHIP: this is a MODEL-level operation. The group is presented as an
+// ordinary node endpoint by spawning a hidden placeholder NodeModel (the
+// "group-as-node") through the public DiagramModel/NodeModel/LinkModel APIs, so
+// proxy links are ordinary node↔node links the router handles with ZERO router
+// changes. No obstacle/path geometry lives here.
+//
+// The whole operation is reversible from the snapshot stored on the group
+// (GroupModel.collapsedState), which serializes — so a collapsed diagram
+// round-trips and can still be expanded after a save/load. Commands wrap
+// collapse()/expand() to make it a single undo step.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupCollapseService = exports.PROXY_LINK_GROUP_KEY = exports.PROXY_NODE_GROUP_KEY = void 0;
+const NodeModel_1 = require("../models/NodeModel");
+/** Metadata key stamped on a placeholder node so it can be recognised/filtered. */
+exports.PROXY_NODE_GROUP_KEY = '__collapsedGroupId';
+/** Metadata key stamped on a re-homed proxy link. */
+exports.PROXY_LINK_GROUP_KEY = '__proxyForGroup';
+/** Default placeholder box the group shrinks to when collapsed. */
+const PLACEHOLDER_WIDTH = 180;
+const PLACEHOLDER_HEIGHT = 44;
+class GroupCollapseService {
+    constructor(diagram) {
+        this.diagram = diagram;
+    }
+    /**
+     * Collapse `group`: hide members, save layout, re-home boundary edges to an
+     * aggregated proxy, and shrink the group to a placeholder. No-op if the group
+     * is already collapsed. Members-less groups collapse "lightly" (flag only, no
+     * placeholder) so trivial groups don't spawn stray nodes.
+     */
+    collapse(group, options) {
+        if (group.isCollapsed) {
+            return;
+        }
+        const memberNodeIds = this.collectMemberNodeIds(group);
+        // Nothing to hide → keep it lightweight (old flag-only behaviour), but still
+        // record an (empty) snapshot so expand() knows this was a managed collapse.
+        if (memberNodeIds.size === 0) {
+            group.collapse();
+            this.setCollapsedState(group, {
+                proxyNodeId: '',
+                savedPositions: {},
+                hiddenNodes: [],
+                removedLinks: [],
+                proxyLinks: [],
+            });
+            return;
+        }
+        const savedGeometry = {
+            position: { x: group.position.x, y: group.position.y },
+            size: group.size ? Object.assign({}, group.size) : undefined,
+            bounds: group.bounds ? Object.assign({}, group.bounds) : undefined,
+        };
+        // 1) Save member positions (restored verbatim on expand).
+        const savedPositions = {};
+        for (const id of memberNodeIds) {
+            const node = this.diagram.getNode(id);
+            if (node) {
+                savedPositions[id] = { x: node.position.x, y: node.position.y };
+            }
+        }
+        // 2) Spawn the placeholder "group-as-node" at the group's top-left.
+        const frame = group.getOuterBounds();
+        const placeholder = new NodeModel_1.NodeModel({
+            type: 'group-collapsed',
+            position: { x: frame.x, y: frame.y },
+            size: { width: PLACEHOLDER_WIDTH, height: PLACEHOLDER_HEIGHT },
+        });
+        placeholder.setMetadata(exports.PROXY_NODE_GROUP_KEY, group.id);
+        placeholder.setMetadata('__isGroupProxy', true);
+        placeholder.setData('label', group.name);
+        this.diagram.addNode(placeholder);
+        // 3) Partition member-incident links and aggregate boundary crossings.
+        const { removedLinks, proxyLinks } = this.rehomeIncidentLinks(group, memberNodeIds, placeholder, options);
+        // 4) Hide members (they keep their absolute positions, just invisible).
+        const hiddenNodes = [];
+        for (const id of memberNodeIds) {
+            const node = this.diagram.getNode(id);
+            if (node) {
+                hiddenNodes.push({ nodeId: id, prevVisible: node.state.visible !== false });
+                node.setState({ visible: false });
+            }
+        }
+        // 5) Flag + shrink the group to the placeholder rectangle.
+        group.collapse();
+        group.setFrame({
+            x: frame.x,
+            y: frame.y,
+            width: PLACEHOLDER_WIDTH,
+            height: PLACEHOLDER_HEIGHT,
+        });
+        this.setCollapsedState(group, {
+            proxyNodeId: placeholder.id,
+            savedGeometry,
+            savedPositions,
+            hiddenNodes,
+            removedLinks,
+            proxyLinks,
+        });
+        // Derived port registries changed (removed/re-homed links).
+        this.diagram.reconcilePortConnections();
+    }
+    /**
+     * Expand `group` back to exactly its pre-collapse state using the snapshot on
+     * the group. No-op if the group is not collapsed / has no snapshot.
+     */
+    expand(group) {
+        var _a, _b, _c;
+        const state = group.collapsedState;
+        if (!state) {
+            // Collapsed via the bare flag (no managed snapshot) — just unflag.
+            if (group.isCollapsed) {
+                group.expand();
+            }
+            return;
+        }
+        // 1) Restore the boundary survivors' original endpoints + strip proxy label.
+        for (const entry of state.proxyLinks) {
+            const link = this.diagram.getLink(entry.linkId);
+            if (!link)
+                continue;
+            if (entry.end === 'source') {
+                link.setSourcePort(entry.originalPortId, entry.originalNodeId);
+            }
+            else {
+                link.setTargetPort(entry.originalPortId, entry.originalNodeId);
+            }
+            // Remove the synthetic aggregate label(s) we added.
+            for (const label of [...link.labels]) {
+                if ((_a = label.id) === null || _a === void 0 ? void 0 : _a.startsWith('proxy-agg-')) {
+                    link.removeLabel(label.id);
+                }
+            }
+            link.deleteMetadata(exports.PROXY_LINK_GROUP_KEY);
+            link.deleteMetadata('__proxyAggregateCount');
+        }
+        // 2) Re-create the links removed at collapse time (internal + aggregated).
+        for (const data of state.removedLinks) {
+            this.diagram.restoreLink(data);
+        }
+        // 3) Remove the placeholder node (its incident survivors were re-homed off it).
+        if (state.proxyNodeId) {
+            this.diagram.removeNode(state.proxyNodeId);
+        }
+        // 4) Restore member positions + visibility.
+        for (const [nodeId, pos] of Object.entries(state.savedPositions)) {
+            (_b = this.diagram.getNode(nodeId)) === null || _b === void 0 ? void 0 : _b.setPosition(pos.x, pos.y);
+        }
+        for (const { nodeId, prevVisible } of state.hiddenNodes) {
+            (_c = this.diagram.getNode(nodeId)) === null || _c === void 0 ? void 0 : _c.setState({ visible: prevVisible });
+        }
+        // 5) Restore the group's exact prior geometry.
+        if (state.savedGeometry) {
+            group.restoreGeometry(state.savedGeometry);
+        }
+        group.expand();
+        this.setCollapsedState(group, undefined);
+        this.diagram.reconcilePortConnections();
+    }
+    /**
+     * Re-home every member-incident link. Internal links (both ends inside the
+     * group) are removed (saved for restore). Boundary links are bucketed by
+     * (external node, direction); each bucket keeps ONE survivor re-pointed to the
+     * placeholder and labelled with the crossing count, and the rest are removed.
+     */
+    rehomeIncidentLinks(group, memberNodeIds, placeholder, options) {
+        var _a, _b, _c, _d, _e, _f;
+        const removedLinks = [];
+        const buckets = new Map();
+        for (const link of this.diagram.getLinks()) {
+            const srcId = (_a = link.sourceNodeId) !== null && _a !== void 0 ? _a : (_b = this.diagram.getNodeByPortId(link.sourcePortId)) === null || _b === void 0 ? void 0 : _b.id;
+            const tgtId = (_c = link.targetNodeId) !== null && _c !== void 0 ? _c : (_d = this.diagram.getNodeByPortId(link.targetPortId)) === null || _d === void 0 ? void 0 : _d.id;
+            const srcIn = !!srcId && memberNodeIds.has(srcId);
+            const tgtIn = !!tgtId && memberNodeIds.has(tgtId);
+            if (!srcIn && !tgtIn) {
+                continue; // untouched
+            }
+            if (srcIn && tgtIn) {
+                // Internal link — hidden with the group; remove and remember.
+                removedLinks.push(link.serialize());
+                this.diagram.removeLink(link.id);
+                continue;
+            }
+            // Boundary link: exactly one end is a member.
+            const direction = srcIn ? 'out' : 'in';
+            const externalNodeId = (srcIn ? tgtId : srcId);
+            const key = `${externalNodeId}|${direction}`;
+            let bucket = buckets.get(key);
+            if (!bucket) {
+                bucket = { direction, externalNodeId, links: [] };
+                buckets.set(key, bucket);
+            }
+            bucket.links.push(link);
+        }
+        // Collapse each bucket into a single labelled proxy survivor.
+        const proxyLinks = [];
+        for (const { direction, externalNodeId, links } of buckets.values()) {
+            const survivor = links[0];
+            const memberEnd = direction === 'out' ? 'source' : 'target';
+            const originalPortId = memberEnd === 'source' ? survivor.sourcePortId : survivor.targetPortId;
+            const originalNodeId = memberEnd === 'source' ? survivor.sourceNodeId : survivor.targetNodeId;
+            // Placeholder attachment: source side for outgoing, target side for incoming.
+            const placeholderPort = direction === 'out'
+                ? placeholder.getPortBySide('right')
+                : placeholder.getPortBySide('left');
+            const portId = (_e = placeholderPort === null || placeholderPort === void 0 ? void 0 : placeholderPort.id) !== null && _e !== void 0 ? _e : (_f = placeholder.getPorts()[0]) === null || _f === void 0 ? void 0 : _f.id;
+            if (memberEnd === 'source') {
+                survivor.setSourcePort(portId, placeholder.id);
+            }
+            else {
+                survivor.setTargetPort(portId, placeholder.id);
+            }
+            // Remove the aggregated-away parallels (saved for restore).
+            for (let i = 1; i < links.length; i++) {
+                removedLinks.push(links[i].serialize());
+                this.diagram.removeLink(links[i].id);
+            }
+            // Label = count (or user hook).
+            const labelText = (options === null || options === void 0 ? void 0 : options.proxyLabel)
+                ? options.proxyLabel({ group, externalNodeId, direction, count: links.length })
+                : links.length > 1
+                    ? String(links.length)
+                    : '';
+            survivor.setMetadata(exports.PROXY_LINK_GROUP_KEY, group.id);
+            survivor.setMetadata('__proxyAggregateCount', links.length);
+            if (labelText) {
+                survivor.addLabel({ id: `proxy-agg-${survivor.id}`, text: labelText, position: 0.5 });
+            }
+            proxyLinks.push({
+                linkId: survivor.id,
+                end: memberEnd,
+                originalPortId,
+                originalNodeId,
+                aggregatedCount: links.length,
+            });
+        }
+        return { removedLinks, proxyLinks };
+    }
+    /**
+     * All NODE ids contained (transitively) in `group`: direct node members plus
+     * every node inside nested member-groups.
+     */
+    collectMemberNodeIds(group) {
+        const out = new Set();
+        const walk = (g) => {
+            for (const id of g.members) {
+                if (this.diagram.getNode(id)) {
+                    out.add(id);
+                }
+                else {
+                    const child = this.diagram.getGroup(id);
+                    if (child)
+                        walk(child);
+                }
+            }
+        };
+        walk(group);
+        return out;
+    }
+    /** Set/clear the snapshot and track it so the change is captured (diff/undo). */
+    setCollapsedState(group, state) {
+        group.setCollapsedState(state);
+    }
+}
+exports.GroupCollapseService = GroupCollapseService;
+//# sourceMappingURL=GroupCollapseService.js.map

package/src/libs/engine/src/interaction/GroupMembershipService.d.ts

@@ -0,0 +1,107 @@
+import type { Point } from '../types/geometry.types';
+import type { DiagramModel } from '../models/DiagramModel';
+import type { GroupModel } from '../models/GroupModel';
+import { Command } from '../commands/Command';
+/**
+ * Minimal command dispatcher contract (satisfied by CommandManager). Injecting
+ * this keeps membership changes on the shared undo stack.
+ */
+export interface CommandDispatcher {
+    execute(command: Command): Promise<void> | void;
+}
+export interface GroupMembershipServiceOptions {
+    diagram: DiagramModel;
+    /**
+     * Dispatcher for undoable membership changes (typically a CommandManager).
+     * When omitted, commands are executed directly against the diagram (still
+     * correct, but not tracked for undo/redo).
+     */
+    dispatcher?: CommandDispatcher;
+    /** Grid cell size for the group spatial index (default 100). */
+    cellSize?: number;
+}
+/** Options for a single hit-test. */
+export interface HitTestOptions {
+    /** Group ids to skip (e.g. the group being dragged + its descendants). */
+    excludeGroupIds?: Set<string>;
+}
+/** Outcome of a node drag-end reparent attempt. */
+export interface DropResult {
+    nodeId: string;
+    /** Group the node left (if it was a member of one). */
+    fromGroupId?: string;
+    /** Group the node joined (undefined when dropped outside all groups). */
+    toGroupId?: string;
+    /** Commands dispatched, in order (empty when nothing changed). */
+    commands: Command[];
+    /** Whether membership actually changed. */
+    changed: boolean;
+    /** A target group was under the cursor but rejected the node. */
+    rejected: boolean;
+}
+export declare class GroupMembershipService {
+    private readonly diagram;
+    private readonly dispatcher?;
+    private readonly index;
+    private hoveredGroupId?;
+    constructor(options: GroupMembershipServiceOptions);
+    /**
+     * Rebuild the spatial index from the diagram's current groups. Group counts
+     * are small relative to nodes, so a full refresh per interaction is cheap and
+     * always reflects freshly-dragged geometry.
+     */
+    refresh(): void;
+    /**
+     * Hit-test a point against group rectangles using the spatial index and
+     * return the innermost matching group (deepest nesting, then smallest area),
+     * so a nested child wins over its parent. Returns undefined when the point is
+     * outside every group.
+     */
+    hitTestGroup(point: Point, options?: HitTestOptions): GroupModel | undefined;
+    /**
+     * Return the first group that currently contains `entityId` as a direct
+     * member, or undefined. (Membership check over the small group set — this is
+     * not the spatial hit-test.)
+     */
+    getContainingGroup(entityId: string): GroupModel | undefined;
+    /**
+     * Highlight the group under the cursor during a drag and clear any previously
+     * hovered group. Returns the hovered group (or undefined). Drives the group's
+     * 'hover:changed' emitter so a renderer can outline the drop target.
+     */
+    updateHover(point: Point, options?: HitTestOptions): GroupModel | undefined;
+    /** Clear any active hover highlight (call on drag-end / cancel). */
+    clearHover(): void;
+    /**
+     * Handle a node drag-end at `point`: re-parent the node into the group under
+     * the cursor, or unembed it when dropped outside every group. No-op when the
+     * node is already in the target group. Rejected (no change) when the target
+     * group's validation/cycle rules veto the node.
+     */
+    handleNodeDragEnd(nodeId: string, point: Point): Promise<DropResult>;
+    /**
+     * Coordinate translation seam for reparenting. In the engine's ABSOLUTE model
+     * a node keeps its world position across a reparent (it stays where it was
+     * dropped), so this is the identity for `node.position`. Group bounds are
+     * derived from absolute member positions and are recomputed by the caller.
+     * Isolated here so a future relative-coordinate model has one place to change.
+     */
+    private translateOnReparent;
+    private dispatch;
+    /**
+     * Resolve a group's screen rectangle for spatial indexing / hit-testing.
+     *
+     * The PAINTED frame (explicit position + size) must win over the derived
+     * member `bounds`, exactly as GroupModel.getOuterBounds() orders them. This
+     * method used to prefer `bounds` — which handleNodeDragEnd overwrites with
+     * the tight member bbox after every membership change — so once anything was
+     * dragged in or out, the drop target silently shrank from the frame the user
+     * SEES to an invisible box around the remaining members, and drops in the
+     * frame's empty margin stopped adopting (visio audit, empirically
+     * reproduced: drag-out worked, the next drag-in near the frame edge did
+     * nothing).
+     */
+    private groupRect;
+    private rectContains;
+    private rectArea;
+}

package/src/libs/engine/src/interaction/GroupMembershipService.js

@@ -0,0 +1,245 @@
+"use strict";
+// GroupMembershipService - interactive drag-in / drag-out group membership (Wave-2)
+//
+// Engine-side service the canvas can call on node drag-end. It hit-tests the
+// pointer against group bounds using the shared SpatialIndex (never a linear
+// scan) and re-parents the dragged node into the group under the cursor,
+// unembedding it when dropped outside every group. Membership changes are
+// dispatched as AddToGroupCommand / RemoveFromGroupCommand so undo works, and
+// a per-group `memberValidation` predicate can veto a drop.
+//
+// Coordinate model: the whole engine stores ABSOLUTE coordinates (Wave-2
+// containment decision). Re-parenting therefore leaves a node's stored position
+// untouched — it stays exactly where the user dropped it — and we only recompute
+// the affected groups' derived bounds. `translateOnReparent` is the single seam
+// where a relative-coordinate model would translate; here it is the identity.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupMembershipService = void 0;
+const tslib_1 = require("tslib");
+const SpatialIndex_1 = require("../performance/SpatialIndex");
+const AddToGroupCommand_1 = require("../commands/basic/AddToGroupCommand");
+const RemoveFromGroupCommand_1 = require("../commands/basic/RemoveFromGroupCommand");
+class GroupMembershipService {
+    constructor(options) {
+        var _a;
+        this.diagram = options.diagram;
+        this.dispatcher = options.dispatcher;
+        this.index = new SpatialIndex_1.SpatialIndex({
+            cellSize: (_a = options.cellSize) !== null && _a !== void 0 ? _a : 100,
+            getBounds: (group) => this.groupRect(group),
+        });
+    }
+    /**
+     * Rebuild the spatial index from the diagram's current groups. Group counts
+     * are small relative to nodes, so a full refresh per interaction is cheap and
+     * always reflects freshly-dragged geometry.
+     */
+    refresh() {
+        this.index.clear();
+        for (const group of this.diagram.getGroups()) {
+            // Ensure a usable rectangle exists before indexing.
+            if (!group.bounds && !group.size && group.members.size > 0) {
+                group.calculateBounds(this.diagram);
+            }
+            const rect = this.groupRect(group);
+            if (rect.width > 0 || rect.height > 0) {
+                this.index.add(group);
+            }
+        }
+    }
+    /**
+     * Hit-test a point against group rectangles using the spatial index and
+     * return the innermost matching group (deepest nesting, then smallest area),
+     * so a nested child wins over its parent. Returns undefined when the point is
+     * outside every group.
+     */
+    hitTestGroup(point, options) {
+        this.refresh();
+        // Query a degenerate 1x1 region at the point; SpatialIndex returns every
+        // group whose cell overlaps, then we confirm true containment.
+        const candidates = this.index.queryRegion({ x: point.x, y: point.y, width: 0, height: 0 }, {
+            filter: (group) => {
+                var _a;
+                return !((_a = options === null || options === void 0 ? void 0 : options.excludeGroupIds) === null || _a === void 0 ? void 0 : _a.has(group.id)) &&
+                    this.rectContains(this.groupRect(group), point);
+            },
+        });
+        if (candidates.length === 0) {
+            return undefined;
+        }
+        // Innermost wins: sort by depth desc, then area asc.
+        candidates.sort((a, b) => {
+            const depthDiff = this.diagram.getDepth(b.id) - this.diagram.getDepth(a.id);
+            if (depthDiff !== 0) {
+                return depthDiff;
+            }
+            return this.rectArea(this.groupRect(a)) - this.rectArea(this.groupRect(b));
+        });
+        return candidates[0];
+    }
+    /**
+     * Return the first group that currently contains `entityId` as a direct
+     * member, or undefined. (Membership check over the small group set — this is
+     * not the spatial hit-test.)
+     */
+    getContainingGroup(entityId) {
+        for (const group of this.diagram.getGroups()) {
+            if (group.members.has(entityId)) {
+                return group;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Highlight the group under the cursor during a drag and clear any previously
+     * hovered group. Returns the hovered group (or undefined). Drives the group's
+     * 'hover:changed' emitter so a renderer can outline the drop target.
+     */
+    updateHover(point, options) {
+        var _a;
+        const target = this.hitTestGroup(point, options);
+        if ((target === null || target === void 0 ? void 0 : target.id) === this.hoveredGroupId) {
+            return target;
+        }
+        // Clear previous highlight.
+        if (this.hoveredGroupId) {
+            (_a = this.diagram.getGroup(this.hoveredGroupId)) === null || _a === void 0 ? void 0 : _a.setHovered(false);
+        }
+        this.hoveredGroupId = target === null || target === void 0 ? void 0 : target.id;
+        target === null || target === void 0 ? void 0 : target.setHovered(true);
+        return target;
+    }
+    /** Clear any active hover highlight (call on drag-end / cancel). */
+    clearHover() {
+        var _a;
+        if (this.hoveredGroupId) {
+            (_a = this.diagram.getGroup(this.hoveredGroupId)) === null || _a === void 0 ? void 0 : _a.setHovered(false);
+            this.hoveredGroupId = undefined;
+        }
+    }
+    /**
+     * Handle a node drag-end at `point`: re-parent the node into the group under
+     * the cursor, or unembed it when dropped outside every group. No-op when the
+     * node is already in the target group. Rejected (no change) when the target
+     * group's validation/cycle rules veto the node.
+     */
+    handleNodeDragEnd(nodeId, point) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const result = {
+                nodeId,
+                commands: [],
+                changed: false,
+                rejected: false,
+            };
+            const node = this.diagram.getNode(nodeId);
+            if (!node) {
+                this.clearHover();
+                return result;
+            }
+            const currentGroup = this.getContainingGroup(nodeId);
+            const target = this.hitTestGroup(point);
+            result.fromGroupId = currentGroup === null || currentGroup === void 0 ? void 0 : currentGroup.id;
+            result.toGroupId = target === null || target === void 0 ? void 0 : target.id;
+            // Dropped back into the same group (or stayed ungrouped): nothing to do.
+            if (((_a = target === null || target === void 0 ? void 0 : target.id) !== null && _a !== void 0 ? _a : undefined) === ((_b = currentGroup === null || currentGroup === void 0 ? void 0 : currentGroup.id) !== null && _b !== void 0 ? _b : undefined)) {
+                this.clearHover();
+                return result;
+            }
+            // Validate the destination before mutating anything.
+            if (target && !target.canAddMember(nodeId, this.diagram)) {
+                result.rejected = true;
+                this.clearHover();
+                return result;
+            }
+            // Leave the current group first so undo replays cleanly.
+            if (currentGroup) {
+                const remove = new RemoveFromGroupCommand_1.RemoveFromGroupCommand(currentGroup.id, nodeId);
+                yield this.dispatch(remove);
+                result.commands.push(remove);
+            }
+            // Join the target group (if any), translating coordinates on reparent.
+            if (target) {
+                this.translateOnReparent(node, currentGroup, target);
+                const add = new AddToGroupCommand_1.AddToGroupCommand(target.id, nodeId);
+                yield this.dispatch(add);
+                result.commands.push(add);
+                target.calculateBounds(this.diagram);
+            }
+            // Refresh the source group's derived bounds now that it lost a member.
+            if (currentGroup) {
+                currentGroup.calculateBounds(this.diagram);
+            }
+            result.changed = result.commands.length > 0;
+            this.clearHover();
+            return result;
+        });
+    }
+    /**
+     * Coordinate translation seam for reparenting. In the engine's ABSOLUTE model
+     * a node keeps its world position across a reparent (it stays where it was
+     * dropped), so this is the identity for `node.position`. Group bounds are
+     * derived from absolute member positions and are recomputed by the caller.
+     * Isolated here so a future relative-coordinate model has one place to change.
+     */
+    translateOnReparent(_node, _fromGroup, _toGroup) {
+        // Absolute storage: no position change on reparent (documented decision).
+    }
+    dispatch(command) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.dispatcher) {
+                yield this.dispatcher.execute(command);
+            }
+            else {
+                // Fallback: execute directly (not undoable) against a minimal context.
+                yield command.execute({ diagram: this.diagram, eventBus: undefined });
+            }
+        });
+    }
+    /**
+     * Resolve a group's screen rectangle for spatial indexing / hit-testing.
+     *
+     * The PAINTED frame (explicit position + size) must win over the derived
+     * member `bounds`, exactly as GroupModel.getOuterBounds() orders them. This
+     * method used to prefer `bounds` — which handleNodeDragEnd overwrites with
+     * the tight member bbox after every membership change — so once anything was
+     * dragged in or out, the drop target silently shrank from the frame the user
+     * SEES to an invisible box around the remaining members, and drops in the
+     * frame's empty margin stopped adopting (visio audit, empirically
+     * reproduced: drag-out worked, the next drag-in near the frame edge did
+     * nothing).
+     */
+    groupRect(group) {
+        if (typeof group.getOuterBounds === 'function') {
+            return group.getOuterBounds();
+        }
+        if (group.size) {
+            return {
+                x: group.position.x,
+                y: group.position.y,
+                width: group.size.width,
+                height: group.size.height,
+            };
+        }
+        if (group.bounds) {
+            return {
+                x: group.bounds.x,
+                y: group.bounds.y,
+                width: group.bounds.width,
+                height: group.bounds.height,
+            };
+        }
+        return { x: group.position.x, y: group.position.y, width: 0, height: 0 };
+    }
+    rectContains(rect, point) {
+        return (point.x >= rect.x &&
+            point.x <= rect.x + rect.width &&
+            point.y >= rect.y &&
+            point.y <= rect.y + rect.height);
+    }
+    rectArea(rect) {
+        return rect.width * rect.height;
+    }
+}
+exports.GroupMembershipService = GroupMembershipService;
+//# sourceMappingURL=GroupMembershipService.js.map

package/src/libs/engine/src/interaction/SemanticMembershipService.d.ts

@@ -0,0 +1,28 @@
+import type { DiagramModel } from '../models/DiagramModel';
+import type { GroupModel, MembershipRule } from '../models/GroupModel';
+import type { NodeModel } from '../models/NodeModel';
+/** Evaluate a declarative rule against a node's `data`. Pure + serializable. */
+export declare function matchesRule(rule: MembershipRule, node: NodeModel): boolean;
+export declare class SemanticMembershipService {
+    private readonly diagram;
+    private readonly managed;
+    private readonly diagramDisposers;
+    private evaluating;
+    constructor(diagram: DiagramModel);
+    /**
+     * Start managing `group`'s auto-membership from its serialized
+     * `membershipRule`. Runs an initial sweep and then keeps in sync reactively.
+     * No-op if the group has no rule. Returns a disposer that stops managing it.
+     */
+    register(group: GroupModel): () => void;
+    /** Stop managing every group and detach all model listeners. */
+    dispose(): void;
+    /** Re-evaluate a single node against every managed rule-group. */
+    evaluateNode(node: NodeModel): void;
+    /** Re-evaluate every node against one group's rule. */
+    evaluateGroup(group: GroupModel): void;
+    private applyMembership;
+    private autoGroups;
+    private tagAuto;
+    private ensureSubscribed;
+}