@grafloria/element 0.3.18 → 0.3.20

package/src/libs/engine/src/commands/basic/SetParentCommand.js

@@ -0,0 +1,109 @@
+"use strict";
+// SetParentCommand - Changes a node's parent (Phase 1.6a Part 5)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetParentCommand = void 0;
+const Command_1 = require("../Command");
+class SetParentCommand extends Command_1.Command {
+    constructor(nodeId, newParentId) {
+        super('Set Parent');
+        this.nodeId = nodeId;
+        this.newParentId = newParentId;
+    }
+    execute(context) {
+        const diagram = context.diagram;
+        if (!diagram) {
+            throw new Error('Diagram not found in context');
+        }
+        const node = diagram.getNode(this.nodeId);
+        if (!node) {
+            throw new Error(`Node ${this.nodeId} not found`);
+        }
+        // Check for circular reference
+        if (this.newParentId) {
+            const newParent = diagram.getNode(this.newParentId);
+            if (!newParent) {
+                throw new Error(`Parent node ${this.newParentId} not found`);
+            }
+            // Check if newParent is a descendant of node (would create circular reference)
+            if (newParent.getAncestors().some((ancestor) => ancestor.id === this.nodeId)) {
+                throw new Error('Cannot set parent: would create circular reference');
+            }
+        }
+        // Save old parent for undo
+        this.oldParentId = node.parentId;
+        // Remove from old parent
+        if (node.parentId) {
+            const oldParent = diagram.getNode(node.parentId);
+            if (oldParent) {
+                oldParent.removeChild(node.id);
+            }
+        }
+        // Set new parent
+        node.setParent(this.newParentId);
+        // Add to new parent
+        if (this.newParentId) {
+            const newParent = diagram.getNode(this.newParentId);
+            if (newParent) {
+                newParent.addChild(node.id);
+            }
+        }
+        // Update hierarchy depth
+        node.updateHierarchyDepth();
+    }
+    undo(context) {
+        const diagram = context.diagram;
+        if (!diagram) {
+            throw new Error('Diagram not found in context');
+        }
+        const node = diagram.getNode(this.nodeId);
+        if (!node) {
+            throw new Error(`Node ${this.nodeId} not found`);
+        }
+        // Remove from current parent
+        if (node.parentId) {
+            const currentParent = diagram.getNode(node.parentId);
+            if (currentParent) {
+                currentParent.removeChild(node.id);
+            }
+        }
+        // Restore old parent
+        node.setParent(this.oldParentId);
+        // Add back to old parent
+        if (this.oldParentId) {
+            const oldParent = diagram.getNode(this.oldParentId);
+            if (oldParent) {
+                oldParent.addChild(node.id);
+            }
+        }
+        // Update hierarchy depth
+        node.updateHierarchyDepth();
+    }
+    canExecute(context) {
+        return context.diagram && context.diagram.nodes.has(this.nodeId);
+    }
+    canUndo(context) {
+        return context.diagram && context.diagram.nodes.has(this.nodeId);
+    }
+    serialize() {
+        return {
+            id: this.id,
+            name: this.name,
+            timestamp: this.timestamp,
+            data: {
+                nodeId: this.nodeId,
+                newParentId: this.newParentId,
+                oldParentId: this.oldParentId,
+            },
+        };
+    }
+    getDescription() {
+        if (this.newParentId) {
+            return `Set parent of node ${this.nodeId} to ${this.newParentId}`;
+        }
+        else {
+            return `Detach node ${this.nodeId} from parent`;
+        }
+    }
+}
+exports.SetParentCommand = SetParentCommand;
+//# sourceMappingURL=SetParentCommand.js.map

package/src/libs/engine/src/commands/basic/SetStrokePointsCommand.d.ts

@@ -0,0 +1,34 @@
+import { Command, CommandContext, SerializedCommand } from '../Command';
+import type { StrokePoint } from '../../models/StrokeModel';
+/**
+ * Replace an ink stroke's point list, undoable. The stroke-edit tool's commit:
+ * a drag that translates a stroke ends in exactly ONE of these at pointer-up.
+ *
+ * Mirrors {@link SetLinkPointsCommand}, minus the `hasManualWaypoints` bookkeeping
+ * — a stroke's points are ALWAYS authored content (nothing re-routes them), so
+ * there is no derived/manual flag to keep in step.
+ *
+ * COLLAB: execute()/undo() each call `setPoints` exactly ONCE, and `points` on a
+ * stroke is a per-property register (wave11 scoped the capture's DERIVED set per
+ * target precisely so stroke geometry reaches peers). One gesture therefore puts
+ * ONE op on the wire — never per-pointermove spam, never a class instance.
+ *
+ * The FROM snapshot is taken from the model on first execute() when the caller
+ * did not supply one — but the stroke-edit tool DOES supply it (the gesture-start
+ * geometry), because by commit time a live-feedback path may already have the
+ * model sitting at TO, and a FROM read then would make undo a no-op.
+ */
+export declare class SetStrokePointsCommand extends Command {
+    private strokeId;
+    private readonly newPoints;
+    private oldPoints?;
+    constructor(strokeId: string, newPoints: readonly StrokePoint[], oldPoints?: readonly StrokePoint[]);
+    execute(context: CommandContext): void;
+    undo(context: CommandContext): void;
+    canExecute(context: CommandContext): boolean;
+    canUndo(context: CommandContext): boolean;
+    /** One edit gesture = one undo step; never merge two of them. */
+    canMergeWith(): boolean;
+    serialize(): SerializedCommand;
+    getDescription(): string;
+}

package/src/libs/engine/src/commands/basic/SetStrokePointsCommand.js

@@ -0,0 +1,86 @@
+"use strict";
+// SetStrokePointsCommand - Replaces a stroke's geometry (wave13/stroke-edit)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetStrokePointsCommand = void 0;
+const Command_1 = require("../Command");
+/**
+ * Replace an ink stroke's point list, undoable. The stroke-edit tool's commit:
+ * a drag that translates a stroke ends in exactly ONE of these at pointer-up.
+ *
+ * Mirrors {@link SetLinkPointsCommand}, minus the `hasManualWaypoints` bookkeeping
+ * — a stroke's points are ALWAYS authored content (nothing re-routes them), so
+ * there is no derived/manual flag to keep in step.
+ *
+ * COLLAB: execute()/undo() each call `setPoints` exactly ONCE, and `points` on a
+ * stroke is a per-property register (wave11 scoped the capture's DERIVED set per
+ * target precisely so stroke geometry reaches peers). One gesture therefore puts
+ * ONE op on the wire — never per-pointermove spam, never a class instance.
+ *
+ * The FROM snapshot is taken from the model on first execute() when the caller
+ * did not supply one — but the stroke-edit tool DOES supply it (the gesture-start
+ * geometry), because by commit time a live-feedback path may already have the
+ * model sitting at TO, and a FROM read then would make undo a no-op.
+ */
+class SetStrokePointsCommand extends Command_1.Command {
+    constructor(strokeId, newPoints, oldPoints) {
+        super('Edit Stroke');
+        this.strokeId = strokeId;
+        this.newPoints = newPoints.map((p) => (Object.assign({}, p)));
+        if (oldPoints) {
+            this.oldPoints = oldPoints.map((p) => (Object.assign({}, p)));
+        }
+    }
+    execute(context) {
+        const diagram = context.diagram;
+        if (!diagram) {
+            throw new Error('Diagram not found in context');
+        }
+        const stroke = diagram.getStroke(this.strokeId);
+        if (!stroke) {
+            throw new Error(`Stroke ${this.strokeId} not found`);
+        }
+        if (!this.oldPoints) {
+            this.oldPoints = stroke.getPoints().map((p) => (Object.assign({}, p)));
+        }
+        // ONE setPoints — one change event, one epoch bump, one op for capture.
+        stroke.setPoints(this.newPoints.map((p) => (Object.assign({}, p))));
+    }
+    undo(context) {
+        const diagram = context.diagram;
+        if (!diagram || !this.oldPoints) {
+            throw new Error('Cannot undo: missing diagram or old points');
+        }
+        const stroke = diagram.getStroke(this.strokeId);
+        if (!stroke) {
+            throw new Error(`Stroke ${this.strokeId} not found`);
+        }
+        stroke.setPoints(this.oldPoints.map((p) => (Object.assign({}, p))));
+    }
+    canExecute(context) {
+        return !!context.diagram && context.diagram.getStroke(this.strokeId) !== undefined;
+    }
+    canUndo(context) {
+        return !!context.diagram && !!this.oldPoints;
+    }
+    /** One edit gesture = one undo step; never merge two of them. */
+    canMergeWith() {
+        return false;
+    }
+    serialize() {
+        return {
+            id: this.id,
+            name: this.name,
+            timestamp: this.timestamp,
+            data: {
+                strokeId: this.strokeId,
+                oldPoints: this.oldPoints,
+                newPoints: this.newPoints,
+            },
+        };
+    }
+    getDescription() {
+        return `Edit stroke (${this.newPoints.length} points)`;
+    }
+}
+exports.SetStrokePointsCommand = SetStrokePointsCommand;
+//# sourceMappingURL=SetStrokePointsCommand.js.map

package/src/libs/engine/src/commands/basic/StrokeLifecycleCommands.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Stroke lifecycle as COMMANDS — add (draw) and remove (erase).
+ *
+ * The whiteboard's edit tool always committed through the stack
+ * (SetStrokePointsCommand), but DRAW and ERASE wrote straight into the model:
+ * a visitor draws ink, presses ⌘Z as the demo instructs, and nothing happens
+ * (live audit: `engine.canUndo() === false` after a real draw; an eraser sweep
+ * could not be undone either). One gesture = one command = one undo step, the
+ * same contract every other gesture keeps.
+ */
+import { Command, CommandContext, SerializedCommand } from '../Command';
+import type { StrokeModel } from '../../models/StrokeModel';
+export declare class AddStrokeCommand extends Command {
+    private readonly stroke;
+    private added;
+    constructor(stroke: StrokeModel);
+    execute(context: CommandContext): void;
+    undo(context: CommandContext): void;
+    canExecute(context: CommandContext): boolean;
+    serialize(): SerializedCommand;
+}
+/** One eraser SWEEP — however many strokes it crossed — is ONE undo step. */
+export declare class RemoveStrokesCommand extends Command {
+    private readonly strokeIds;
+    private removed;
+    constructor(strokeIds: readonly string[]);
+    execute(context: CommandContext): void;
+    undo(context: CommandContext): void;
+    canExecute(context: CommandContext): boolean;
+    serialize(): SerializedCommand;
+}

package/src/libs/engine/src/commands/basic/StrokeLifecycleCommands.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Stroke lifecycle as COMMANDS — add (draw) and remove (erase).
+ *
+ * The whiteboard's edit tool always committed through the stack
+ * (SetStrokePointsCommand), but DRAW and ERASE wrote straight into the model:
+ * a visitor draws ink, presses ⌘Z as the demo instructs, and nothing happens
+ * (live audit: `engine.canUndo() === false` after a real draw; an eraser sweep
+ * could not be undone either). One gesture = one command = one undo step, the
+ * same contract every other gesture keeps.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveStrokesCommand = exports.AddStrokeCommand = void 0;
+const Command_1 = require("../Command");
+class AddStrokeCommand extends Command_1.Command {
+    constructor(stroke) {
+        super('Draw Stroke');
+        this.stroke = stroke;
+        this.added = false;
+    }
+    execute(context) {
+        const diagram = context.diagram;
+        if (!diagram)
+            throw new Error('Diagram not found in context');
+        diagram.addStroke(this.stroke);
+        this.added = true;
+    }
+    undo(context) {
+        const diagram = context.diagram;
+        if (!diagram || !this.added)
+            throw new Error('Cannot undo: stroke was not added');
+        diagram.removeStroke(this.stroke.id);
+    }
+    canExecute(context) {
+        return !!context.diagram && this.stroke.pointCount > 0;
+    }
+    serialize() {
+        return {
+            id: this.id,
+            name: this.name,
+            timestamp: this.timestamp,
+            data: { strokeId: this.stroke.id },
+        };
+    }
+}
+exports.AddStrokeCommand = AddStrokeCommand;
+/** One eraser SWEEP — however many strokes it crossed — is ONE undo step. */
+class RemoveStrokesCommand extends Command_1.Command {
+    constructor(strokeIds) {
+        super('Erase Strokes');
+        this.strokeIds = strokeIds;
+        this.removed = [];
+    }
+    execute(context) {
+        const diagram = context.diagram;
+        if (!diagram)
+            throw new Error('Diagram not found in context');
+        this.removed = [];
+        for (const id of this.strokeIds) {
+            const stroke = diagram.getStroke(id);
+            if (stroke) {
+                this.removed.push(stroke);
+                diagram.removeStroke(id);
+            }
+        }
+    }
+    undo(context) {
+        const diagram = context.diagram;
+        if (!diagram)
+            throw new Error('Diagram not found in context');
+        for (const stroke of this.removed) {
+            diagram.addStroke(stroke);
+        }
+    }
+    canExecute(context) {
+        return !!context.diagram && this.strokeIds.length > 0;
+    }
+    serialize() {
+        return {
+            id: this.id,
+            name: this.name,
+            timestamp: this.timestamp,
+            data: { strokeIds: [...this.strokeIds] },
+        };
+    }
+}
+exports.RemoveStrokesCommand = RemoveStrokesCommand;
+//# sourceMappingURL=StrokeLifecycleCommands.js.map

package/src/libs/engine/src/commands/basic/UpdateLinkStyleCommand.d.ts

@@ -0,0 +1,15 @@
+import { Command, CommandContext, SerializedCommand } from '../Command';
+import type { LinkStyle } from '../../types';
+export declare class UpdateLinkStyleCommand extends Command {
+    private readonly linkId;
+    private readonly style;
+    /** The WHOLE style object as it was before execute() — restored verbatim on undo. */
+    private previousStyle?;
+    constructor(linkId: string, style: Partial<LinkStyle>);
+    execute(context: CommandContext): void;
+    undo(context: CommandContext): void;
+    canExecute(context: CommandContext): boolean;
+    canUndo(context: CommandContext): boolean;
+    serialize(): SerializedCommand;
+    getDescription(): string;
+}

package/src/libs/engine/src/commands/basic/UpdateLinkStyleCommand.js

@@ -0,0 +1,72 @@
+"use strict";
+// UpdateLinkStyleCommand — undoable edit of a link's style
+//
+// Wave 4 (Edges & links). `LinkModel.updateStyle()` mutates the model directly
+// and is NOT undoable — which was fine while link style was set once at
+// construction, but Wave 4 turns style into live, user-facing state (self-loop
+// size, parallel spacing, custom markers, a link template). Any of those set
+// from a gesture must land on the undo stack as ONE entry, so they go through
+// this command.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateLinkStyleCommand = void 0;
+const Command_1 = require("../Command");
+class UpdateLinkStyleCommand extends Command_1.Command {
+    constructor(linkId, style) {
+        super('Update Link Style');
+        this.linkId = linkId;
+        this.style = style;
+    }
+    execute(context) {
+        var _a;
+        const link = (_a = context.diagram) === null || _a === void 0 ? void 0 : _a.getLink(this.linkId);
+        if (!link) {
+            throw new Error(`Link ${this.linkId} not found`);
+        }
+        // Snapshot BEFORE merging. Captured on every execute (not just the first),
+        // so an execute → undo → redo → undo round-trip restores the right state.
+        this.previousStyle = Object.assign({}, link.style);
+        link.updateStyle(this.style);
+    }
+    undo(context) {
+        var _a;
+        const link = (_a = context.diagram) === null || _a === void 0 ? void 0 : _a.getLink(this.linkId);
+        if (!link || !this.previousStyle) {
+            throw new Error('Cannot undo: missing link or previous style');
+        }
+        // Assign the snapshot wholesale rather than merging: `updateStyle` cannot
+        // REMOVE a key, so merging would leave behind any property this command
+        // introduced.
+        //
+        // Through `replaceStyle`, NOT the field. This undo used to be
+        // `link.style = restored; link.markDirty('style')`, and a direct field write does
+        // not pass `trackChange()` — the one funnel collab captures from. Execute emitted
+        // an op, undo emitted none, so the author saw the style revert and every other peer
+        // kept it applied forever, with no later edit able to correct it.
+        link.replaceStyle(Object.assign({}, this.previousStyle));
+    }
+    canExecute(context) {
+        var _a;
+        return !!((_a = context.diagram) === null || _a === void 0 ? void 0 : _a.getLink(this.linkId));
+    }
+    canUndo(context) {
+        var _a;
+        return !!((_a = context.diagram) === null || _a === void 0 ? void 0 : _a.getLink(this.linkId)) && !!this.previousStyle;
+    }
+    serialize() {
+        return {
+            id: this.id,
+            name: this.name,
+            timestamp: this.timestamp,
+            data: {
+                linkId: this.linkId,
+                style: this.style,
+                previousStyle: this.previousStyle,
+            },
+        };
+    }
+    getDescription() {
+        return `Update style of link ${this.linkId}`;
+    }
+}
+exports.UpdateLinkStyleCommand = UpdateLinkStyleCommand;
+//# sourceMappingURL=UpdateLinkStyleCommand.js.map

package/src/libs/engine/src/commands/basic/index.d.ts

@@ -0,0 +1,41 @@
+export * from './AddNodeCommand';
+export * from './RemoveNodeCommand';
+export * from './MoveNodeCommand';
+export * from './MoveGroupCommand';
+export * from './ResizeNodeCommand';
+export * from './AddLinkCommand';
+export * from './RemoveLinkCommand';
+export * from './SetParentCommand';
+export * from './AddGroupCommand';
+export * from './RemoveGroupCommand';
+export * from './AddToGroupCommand';
+export * from './RemoveFromGroupCommand';
+export * from './ExpandGroupCommand';
+export * from './CollapseGroupCommand';
+export * from './SetLayoutCommand';
+export * from './SetFlexItemCommand';
+export * from './SetGridItemCommand';
+export * from './CopyCommand';
+export * from './PasteCommand';
+export * from './DuplicateCommand';
+export * from './DeleteSelectionCommand';
+export * from './CutCommand';
+export * from './resolveLinkNodeIds';
+export * from './UpdateLinkStyleCommand';
+export * from './SetNodeStyleCommand';
+export * from './SetLinkLabelsCommand';
+export * from './remapNodePortIds';
+export * from './RotateNodeCommand';
+export * from './SetNodeLabelCommand';
+export * from './SetLinkPointsCommand';
+export * from './SetStrokePointsCommand';
+export * from './StrokeLifecycleCommands';
+export * from './ReconnectLinkCommand';
+export * from './SetLinkLabelCommand';
+export * from './SetLinkDisplayLabelCommand';
+export * from './SetLinkPathTypeCommand';
+export * from './SetNodeShapeConfigCommand';
+export * from './PortCommands';
+export * from './NodeZOrderCommands';
+export * from './SetNodeDataCommand';
+export * from './AlignCommands';

package/src/libs/engine/src/commands/basic/index.js

@@ -0,0 +1,52 @@
+"use strict";
+// Basic commands index
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./AddNodeCommand"), exports);
+tslib_1.__exportStar(require("./RemoveNodeCommand"), exports);
+tslib_1.__exportStar(require("./MoveNodeCommand"), exports);
+tslib_1.__exportStar(require("./MoveGroupCommand"), exports); // wave12/connect-ergonomics (drag subflow → members follow)
+tslib_1.__exportStar(require("./ResizeNodeCommand"), exports);
+tslib_1.__exportStar(require("./AddLinkCommand"), exports);
+tslib_1.__exportStar(require("./RemoveLinkCommand"), exports);
+tslib_1.__exportStar(require("./SetParentCommand"), exports); // Phase 1.6a Part 5
+tslib_1.__exportStar(require("./AddGroupCommand"), exports); // Phase 1.6c Part 3
+tslib_1.__exportStar(require("./RemoveGroupCommand"), exports); // Phase 1.6c Part 3
+tslib_1.__exportStar(require("./AddToGroupCommand"), exports); // Phase 1.6c Part 3
+tslib_1.__exportStar(require("./RemoveFromGroupCommand"), exports); // Phase 1.6c Part 3
+tslib_1.__exportStar(require("./ExpandGroupCommand"), exports); // Phase 1.6c Part 3
+tslib_1.__exportStar(require("./CollapseGroupCommand"), exports); // Phase 1.6c Part 3
+tslib_1.__exportStar(require("./SetLayoutCommand"), exports); // Phase 1.7 Part 2
+tslib_1.__exportStar(require("./SetFlexItemCommand"), exports); // Phase 1.7 Part 2
+tslib_1.__exportStar(require("./SetGridItemCommand"), exports); // Phase 1.7 Part 2
+tslib_1.__exportStar(require("./CopyCommand"), exports); // Phase 1.8
+tslib_1.__exportStar(require("./PasteCommand"), exports); // Phase 1.8
+tslib_1.__exportStar(require("./DuplicateCommand"), exports); // Phase 1.8
+tslib_1.__exportStar(require("./DeleteSelectionCommand"), exports); // Phase 1.8
+tslib_1.__exportStar(require("./CutCommand"), exports); // wave3/interaction
+tslib_1.__exportStar(require("./resolveLinkNodeIds"), exports); // wave3/interaction
+tslib_1.__exportStar(require("./UpdateLinkStyleCommand"), exports); // wave4/edges
+tslib_1.__exportStar(require("./SetNodeStyleCommand"), exports); // node style, undoable + collab-safe
+tslib_1.__exportStar(require("./SetLinkLabelsCommand"), exports); // wave4/edges
+// wave4/interaction: the clone re-id recipe is public now — the Halo's clone/fork
+// tools (in @grafloria/renderer) must mint fresh port ids exactly the way Paste does,
+// and it was only reachable via a deep relative import.
+tslib_1.__exportStar(require("./remapNodePortIds"), exports);
+tslib_1.__exportStar(require("./RotateNodeCommand"), exports); // wave4/interaction (rotate handle)
+tslib_1.__exportStar(require("./SetNodeLabelCommand"), exports); // wave4/interaction (in-place text editing)
+tslib_1.__exportStar(require("./SetLinkPointsCommand"), exports); // wave4/interaction (vertex tools)
+tslib_1.__exportStar(require("./SetStrokePointsCommand"), exports); // wave13/stroke-edit (the edit tool's commit)
+tslib_1.__exportStar(require("./StrokeLifecycleCommands"), exports); // draw + erase as undoable gestures (live audit)
+tslib_1.__exportStar(require("./ReconnectLinkCommand"), exports); // wave12 (reconnect undo)
+tslib_1.__exportStar(require("./SetLinkLabelCommand"), exports); // wave4/interaction (in-place text editing)
+tslib_1.__exportStar(require("./SetLinkDisplayLabelCommand"), exports); // visio-depth (edge display-label editing)
+tslib_1.__exportStar(require("./SetLinkPathTypeCommand"), exports); // visio-panel (undoable route: smooth | orthogonal)
+tslib_1.__exportStar(require("./SetNodeShapeConfigCommand"), exports); // visio-panel (metadata.shape keys, e.g. cornerRadius)
+tslib_1.__exportStar(require("./PortCommands"), exports); // wave6/ports (dynamic auto-ports)
+// C — node stacking order as undoable commands (dashboard z-order).
+tslib_1.__exportStar(require("./NodeZOrderCommands"), exports);
+// T9 — shape data (node.data) as an undoable, per-key edit.
+tslib_1.__exportStar(require("./SetNodeDataCommand"), exports);
+// T3 — Align & Distribute (Visio/Figma-style multi-node arrangement).
+tslib_1.__exportStar(require("./AlignCommands"), exports);
+//# sourceMappingURL=index.js.map

package/src/libs/engine/src/commands/basic/remapNodePortIds.d.ts

@@ -0,0 +1,23 @@
+import type { NodeModel } from '../../models/NodeModel';
+/**
+ * Re-assign fresh ids to every port on a freshly-cloned node.
+ *
+ * Why this is needed: {@link NodeModel.fromJSON} restores each port with its
+ * ORIGINAL serialized id, so a clone would otherwise share port ids with its
+ * source node. Links reference the engine's nanoid port ids directly (they are
+ * NOT `"nodeId:portName"` strings), and node lookup resolves a node by "which
+ * node owns this port id" — duplicate port ids across nodes make that lookup
+ * ambiguous and break pasted/duplicated links.
+ *
+ * For each port this:
+ *  - generates a new port id and records `oldPortId -> newPortId` in `portIdMap`
+ *    so the caller can remap link endpoints,
+ *  - points the port back at its new owning node,
+ *  - rebuilds the node's ports Map (whose KEYS are the port ids) so lookups by
+ *    id keep working.
+ *
+ * @param node        the cloned node (mutated in place)
+ * @param newNodeId   the clone's node id (ports' `nodeId` is set to this)
+ * @param portIdMap   accumulates oldPortId -> newPortId across all cloned nodes
+ */
+export declare function remapNodePortIds(node: NodeModel, newNodeId: string, portIdMap: Map<string, string>): void;

package/src/libs/engine/src/commands/basic/remapNodePortIds.js

@@ -0,0 +1,46 @@
+"use strict";
+// Shared port-id remapping for clone operations (Paste / Duplicate)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remapNodePortIds = remapNodePortIds;
+const id_1 = require("../../utils/id");
+/**
+ * Re-assign fresh ids to every port on a freshly-cloned node.
+ *
+ * Why this is needed: {@link NodeModel.fromJSON} restores each port with its
+ * ORIGINAL serialized id, so a clone would otherwise share port ids with its
+ * source node. Links reference the engine's nanoid port ids directly (they are
+ * NOT `"nodeId:portName"` strings), and node lookup resolves a node by "which
+ * node owns this port id" — duplicate port ids across nodes make that lookup
+ * ambiguous and break pasted/duplicated links.
+ *
+ * For each port this:
+ *  - generates a new port id and records `oldPortId -> newPortId` in `portIdMap`
+ *    so the caller can remap link endpoints,
+ *  - points the port back at its new owning node,
+ *  - rebuilds the node's ports Map (whose KEYS are the port ids) so lookups by
+ *    id keep working.
+ *
+ * @param node        the cloned node (mutated in place)
+ * @param newNodeId   the clone's node id (ports' `nodeId` is set to this)
+ * @param portIdMap   accumulates oldPortId -> newPortId across all cloned nodes
+ */
+function remapNodePortIds(node, newNodeId, portIdMap) {
+    // A clone is a NEW entity: since fromJSON now restores the SAVED uuid
+    // (lossless load), paste/duplicate must mint fresh uuids or two live
+    // entities would share one identity.
+    node.uuid = (0, id_1.generateUUID)();
+    // Snapshot first — we are about to rewrite the very Map we would iterate.
+    const ports = node.getPorts();
+    node.ports.clear();
+    for (const port of ports) {
+        const oldPortId = port.id;
+        const newPortId = (0, id_1.generateId)();
+        portIdMap.set(oldPortId, newPortId);
+        // `id` is readonly on DiagramEntity — same override pattern used for groups.
+        port.id = newPortId;
+        port.uuid = (0, id_1.generateUUID)();
+        port.nodeId = newNodeId;
+        node.ports.set(newPortId, port);
+    }
+}
+//# sourceMappingURL=remapNodePortIds.js.map

package/src/libs/engine/src/commands/basic/resolveLinkNodeIds.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Resolve the ids of the nodes a link is attached to.
+ *
+ * WHY THIS EXISTS: a link's `sourcePortId`/`targetPortId` are PORT ids — engine
+ * nanoids — NOT `"nodeId:portName"` strings. Commands that used
+ * `portId.split(':')[0]` to get a node id therefore resolved nothing for links
+ * created the production way (`diagram.connectNodes()` / the interactive connect
+ * path), which silently:
+ *   - made CopyCommand skip every link between the copied nodes, and
+ *   - made DeleteSelectionCommand leave ORPHAN links behind when it deleted the
+ *     nodes at both ends (`removeNode()` does not cascade to links).
+ *
+ * Resolution order:
+ *   1. the ids LinkModel caches (`sourceNodeId` / `targetNodeId`, backfilled by
+ *      `addLink()` / `restoreLink()` from the port index),
+ *   2. the diagram's O(1) port index (`getNodeByPortId`),
+ *   3. the legacy `"nodeId:portName"` convention — still used by hand-built test
+ *      links and older documents — but only when it names a node that actually
+ *      exists.
+ *
+ * @returns the owning node ids; either may be `undefined` for a dangling endpoint.
+ */
+export declare function resolveLinkNodeIds(diagram: any, link: {
+    sourcePortId: string;
+    targetPortId: string;
+    sourceNodeId?: string;
+    targetNodeId?: string;
+}): {
+    sourceNodeId?: string;
+    targetNodeId?: string;
+};