diff --git a/ModernFormsNext.Designer.Tests/DesignerClipboardTests.cs b/ModernFormsNext.Designer.Tests/DesignerClipboardTests.cs
new file mode 100644
index 0000000..5b8f00f
--- /dev/null
+++ b/ModernFormsNext.Designer.Tests/DesignerClipboardTests.cs
@@ -0,0 +1,1416 @@
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using ModernFormsNext;
+using ModernFormsNext.CodeGeneration.CSharp;
+using ModernFormsNext.CodeGeneration.Reverse;
+using ModernFormsNext.Designer.Clipboard;
+using ModernFormsNext.Designer.History;
+using ModernFormsNext.Designer.Layout;
+using ModernFormsNext.Designer.Properties;
+using ModernFormsNext.Designer.Services;
+using ModernFormsNext.Designer.Surface;
+using ModernFormsNext.Designing;
+using ModernFormsNext.Drawing;
+using SkiaSharp;
+using Xunit;
+
+namespace ModernFormsNext.Designer.Tests;
+
+public sealed class DesignerClipboardTests
+{
+    [Fact]
+    public void CopySimpleButtonStoresVersionedDetachedPayloadWithoutHistoryOrDirtyState()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        session.SelectNode(button);
+        session.MarkSaved();
+
+        Assert.True(session.CopySelectedNode());
+
+        Assert.Contains("\"format\":\"ModernFormsNext.Designer\"", session.Clipboard.Content, StringComparison.Ordinal);
+        Assert.Contains("\"version\":1", session.Clipboard.Content, StringComparison.Ordinal);
+        Assert.False(session.Transactions.CanUndo);
+        Assert.False(session.IsDirty);
+        Assert.Same(button, session.SelectedNode);
+    }
+
+    [Fact]
+    public void PasteSimpleButtonCreatesOneUndoableUnitAndFreshNode()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        session.SelectNode(button);
+        Assert.True(session.CopySelectedNode());
+        session.SelectNode(null);
+
+        Assert.True(session.PasteCopiedNode());
+
+        var pasted = Assert.IsType<DesignControlNode>(session.SelectedNode);
+        Assert.NotSame(button, pasted);
+        Assert.Equal("button2", pasted.Name);
+        Assert.Equal(new DesignBounds(26, 26, 100, 30), pasted.Bounds);
+        Assert.Equal("Paste button2", session.Transactions.UndoDescription);
+        Assert.True(session.Transactions.Undo());
+        Assert.Single(session.Document.Controls);
+        Assert.False(session.Transactions.CanUndo);
+        Assert.True(session.Transactions.Redo());
+        Assert.Same(pasted, session.SelectedNode);
+    }
+
+    [Fact]
+    public void DuplicateSimpleButtonCreatesOneUnitWithoutChangingClipboard()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        session.Clipboard.SetContent("{\"format\":\"unrelated\"}");
+        var previousClipboard = session.Clipboard.Content;
+        session.SelectNode(button);
+
+        Assert.True(session.DuplicateSelectedNode());
+
+        var duplicate = Assert.IsType<DesignControlNode>(session.SelectedNode);
+        Assert.Equal("button2", duplicate.Name);
+        Assert.Equal(previousClipboard, session.Clipboard.Content);
+        Assert.Equal("Duplicate button1", session.Transactions.UndoDescription);
+        Assert.True(session.Transactions.Undo());
+        Assert.Single(session.Document.Controls);
+        Assert.True(session.Transactions.Redo());
+        Assert.Same(duplicate, session.SelectedNode);
+    }
+
+    [Fact]
+    public void CutSimpleButtonIsOneAtomicUndoRedoUnit()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        session.SelectNode(button);
+
+        Assert.True(session.CutSelectedNode());
+
+        Assert.Empty(session.Document.Controls);
+        Assert.Null(session.SelectedNode);
+        Assert.Equal("Cut button1", session.Transactions.UndoDescription);
+        Assert.True(session.CanPasteCopiedNode);
+        Assert.True(session.Transactions.Undo());
+        Assert.Same(button, Assert.Single(session.Document.Controls));
+        Assert.Same(button, session.SelectedNode);
+        Assert.True(session.Transactions.Redo());
+        Assert.Empty(session.Document.Controls);
+        Assert.Null(session.SelectedNode);
+    }
+
+    [Fact]
+    public void CopyAndPastePreserveDeepNestedSubtreeOrderPropertiesAndEvents()
+    {
+        var document = EmptyDocument();
+        var panel = Node("Panel", "panel1", 10, 20, 260, 180);
+        panel.Events["Click"] = "panel1_Click";
+        var inner = Node("Panel", "panel2", 5, 6, 180, 120);
+        var button = Node("Button", "button1", 7, 8, 90, 30);
+        button.Properties["Text"] = DesignPropertyValue.FromString("Nested");
+        inner.Children.Add(button);
+        inner.Children.Add(Node("Label", "label1", 9, 44, 100, 24));
+        panel.Children.Add(inner);
+        document.Controls.Add(panel);
+        using var session = CreateSession(document);
+        session.SelectNode(panel);
+        Assert.True(session.CopySelectedNode());
+        session.SelectNode(null);
+
+        Assert.True(session.PasteCopiedNode());
+
+        var copy = Assert.IsType<DesignControlNode>(session.SelectedNode);
+        Assert.Equal("panel3", copy.Name);
+        Assert.Equal("panel1_Click", copy.Events["Click"]);
+        var copiedInner = Assert.Single(copy.Children);
+        Assert.Equal("panel4", copiedInner.Name);
+        Assert.Equal(["button2", "label2"], copiedInner.Children.Select(child => child.Name));
+        Assert.Equal("Nested", copiedInner.Children[0].Properties["Text"].GetString());
+    }
+
+    [Fact]
+    public void NamingRemapsEveryNodeAndSkipsNamesAlreadyUsedByTarget()
+    {
+        var document = EmptyDocument();
+        var panel = Node("Panel", "panel1", 10, 10, 200, 120);
+        panel.Children.Add(Node("Button", "button1", 5, 5, 80, 25));
+        document.Controls.Add(panel);
+        document.Controls.Add(Node("Button", "button2", 250, 10, 80, 25));
+        document.Controls.Add(Node("Panel", "panel2", 250, 50, 120, 90));
+        using var session = CreateSession(document);
+        session.SelectNode(panel);
+        session.CopySelectedNode();
+        session.SelectNode(null);
+
+        Assert.True(session.PasteCopiedNode());
+
+        var copy = Assert.IsType<DesignControlNode>(session.SelectedNode);
+        Assert.Equal("panel3", copy.Name);
+        Assert.Equal("button3", Assert.Single(copy.Children).Name);
+    }
+
+    [Fact]
+    public void NamingFillsNumericGapsAndSuffixesCustomNamesDeterministically()
+    {
+        var document = EmptyDocument();
+        var first = Node("Button", "button1", 10, 10, 80, 25);
+        document.Controls.Add(first);
+        document.Controls.Add(Node("Button", "button3", 100, 10, 80, 25));
+        var custom = Node("Example.ProjectCard", "projectCard", 10, 50, 160, 80);
+        document.Controls.Add(custom);
+        using var session = CreateSession(document);
+        session.SelectNode(first);
+        Assert.True(session.CopySelectedNode());
+        session.SelectNode(null);
+        Assert.True(session.PasteCopiedNode());
+        Assert.Equal("button2", session.SelectedNode!.Name);
+        session.SelectNode(custom);
+        Assert.True(session.DuplicateSelectedNode());
+        Assert.Equal("projectCard1", session.SelectedNode!.Name);
+    }
+
+    [Fact]
+    public void DuplicateNamesInsideLegacySourceSubtreeAreRemappedUniquely()
+    {
+        var document = EmptyDocument();
+        var panel = Node("Panel", "panel1", 10, 10, 200, 120);
+        panel.Children.Add(Node("Button", "button1", 5, 5, 80, 25));
+        panel.Children.Add(Node("Button", "button1", 5, 40, 80, 25));
+        document.Controls.Add(panel);
+        using var session = CreateSession(document);
+        session.SelectNode(panel);
+
+        Assert.True(session.CopySelectedNode());
+        session.SelectNode(null);
+        Assert.True(session.PasteCopiedNode());
+
+        var copy = Assert.IsType<DesignControlNode>(session.SelectedNode);
+        Assert.Equal(["button2", "button3"], copy.Children.Select(node => node.Name));
+        Assert.Equal(copy.Children.Count, copy.Children.Select(node => node.Name).Distinct(StringComparer.OrdinalIgnoreCase).Count());
+    }
+
+    [Fact]
+    public void RepeatedPasteProducesDeterministicSequentialNamesAndSerialization()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        session.SelectNode(button);
+        session.CopySelectedNode();
+        session.SelectNode(null);
+
+        Assert.True(session.PasteCopiedNode());
+        session.SelectNode(null);
+        Assert.True(session.PasteCopiedNode());
+
+        Assert.Equal(["button1", "button2", "button3"], session.Document.Controls.Select(node => node.Name));
+        var serialized = DesignDocumentSerializer.Default.Serialize(session.Document);
+        Assert.True(session.Transactions.Undo());
+        Assert.True(session.Transactions.Undo());
+        Assert.Equal(["button1"], session.Document.Controls.Select(node => node.Name));
+        Assert.True(session.Transactions.Redo());
+        Assert.True(session.Transactions.Redo());
+        Assert.Equal(["button1", "button2", "button3"], session.Document.Controls.Select(node => node.Name));
+        Assert.Equal(serialized, DesignDocumentSerializer.Default.Serialize(session.Document));
+    }
+
+    [Fact]
+    public void PasteIntoSelectedContainerAddsToItsChildren()
+    {
+        var document = EmptyDocument();
+        var button = Node("Button", "button1", 10, 10, 80, 25);
+        var panel = Node("Panel", "panel1", 120, 30, 220, 140);
+        document.Controls.Add(button);
+        document.Controls.Add(panel);
+        using var session = CreateSession(document);
+        session.SelectNode(button);
+        session.CopySelectedNode();
+        session.SelectNode(panel);
+
+        Assert.True(session.PasteCopiedNode());
+        Assert.Same(session.SelectedNode, Assert.Single(panel.Children));
+    }
+
+    [Fact]
+    public void PasteWithSelectedLeafUsesItsParent()
+    {
+        var document = EmptyDocument();
+        var first = Node("Button", "button1", 10, 10, 80, 25);
+        var selectedLeaf = Node("Label", "label1", 100, 10, 80, 25);
+        document.Controls.Add(first);
+        document.Controls.Add(selectedLeaf);
+        using var session = CreateSession(document);
+        session.SelectNode(first);
+        session.CopySelectedNode();
+        session.SelectNode(selectedLeaf);
+
+        Assert.True(session.PasteCopiedNode());
+        Assert.Equal(3, document.Controls.Count);
+        Assert.Same(session.SelectedNode, document.Controls[2]);
+    }
+
+    [Fact]
+    public void StaleSelectedContainerIsRejectedAsPasteTarget()
+    {
+        using var session = CreateSession(CreateDocument(out var source));
+        session.SelectNode(source);
+        Assert.True(session.CopySelectedNode());
+        var staleContainer = Node("Panel", "stalePanel", 0, 0, 100, 100);
+        session.SelectNode(staleContainer);
+        var before = DesignDocumentSerializer.Default.Serialize(session.Document);
+
+        Assert.False(session.PasteCopiedNode());
+
+        Assert.Equal(before, DesignDocumentSerializer.Default.Serialize(session.Document));
+        Assert.False(session.Transactions.CanUndo);
+    }
+
+    [Fact]
+    public void ParentPayloadCanPasteIntoSourceDescendantWithoutCreatingCycle()
+    {
+        var document = EmptyDocument();
+        var parent = Node("Panel", "panel1", 10, 10, 220, 140);
+        var descendant = Node("Panel", "panel2", 5, 5, 150, 90);
+        parent.Children.Add(descendant);
+        document.Controls.Add(parent);
+        using var session = CreateSession(document);
+        session.SelectNode(parent);
+        session.CopySelectedNode();
+        session.SelectNode(descendant);
+
+        Assert.True(session.PasteCopiedNode());
+
+        var copy = Assert.Single(descendant.Children);
+        Assert.NotSame(parent, copy);
+        Assert.NotSame(descendant, Assert.Single(copy.Children));
+    }
+
+    [Theory]
+    [InlineData(DesignRootKind.Form)]
+    [InlineData(DesignRootKind.UserControl)]
+    public void DesignRootCannotBeCopiedCutOrDuplicated(DesignRootKind rootKind)
+    {
+        var document = EmptyDocument();
+        document.RootKind = rootKind;
+        using var session = CreateSession(document);
+        session.SelectNode(null);
+
+        Assert.False(session.CopySelectedNode());
+        Assert.False(session.CutSelectedNode());
+        Assert.False(session.DuplicateSelectedNode());
+        Assert.Contains("design root", session.OutputLines[^1], StringComparison.OrdinalIgnoreCase);
+        Assert.False(session.Transactions.CanUndo);
+    }
+
+    [Fact]
+    public void StructuralSplitPanelCannotBeCopiedIndependently()
+    {
+        var document = EmptyDocument();
+        var split = Node("SplitContainer", "splitContainer1", 10, 10, 300, 180);
+        document.Controls.Add(split);
+        DesignerSpecialContainers.InitializeNewNode(split);
+        using var session = CreateSession(document);
+        session.SelectNode(Assert.IsType<DesignControlNode>(DesignerSpecialContainers.GetPanel1(split)));
+
+        Assert.False(session.CopySelectedNode());
+        Assert.False(session.CutSelectedNode());
+        Assert.False(session.DuplicateSelectedNode());
+    }
+
+    [Fact]
+    public void SplitContainerSubtreeRemapsOwnedPanelNamesAndDisplayMetadata()
+    {
+        var document = EmptyDocument();
+        var split = Node("SplitContainer", "splitContainer1", 10, 10, 300, 180);
+        document.Controls.Add(split);
+        DesignerSpecialContainers.InitializeNewNode(split);
+        using var session = CreateSession(document);
+        session.SelectNode(split);
+
+        Assert.True(session.DuplicateSelectedNode());
+
+        var copy = Assert.IsType<DesignControlNode>(session.SelectedNode);
+        Assert.Equal("splitContainer2", copy.Name);
+        Assert.Equal(["splitContainer2Panel1", "splitContainer2Panel2"], copy.Children.Select(node => node.Name));
+        Assert.Equal("splitContainer2.Panel1", copy.Children[0].Properties[DesignNodeRoleNames.DisplayNamePropertyName].GetString());
+        Assert.Equal("splitContainer2.Panel2", copy.Children[1].Properties[DesignNodeRoleNames.DisplayNamePropertyName].GetString());
+    }
+
+    [Fact]
+    public void TabPageCannotPasteIntoOrdinaryPanel()
+    {
+        var document = EmptyDocument();
+        var tabControl = Node("TabControl", "tabControl1", 10, 10, 300, 180);
+        DesignerSpecialContainers.InitializeNewNode(tabControl);
+        var panel = Node("Panel", "panel1", 330, 10, 200, 120);
+        document.Controls.Add(tabControl);
+        document.Controls.Add(panel);
+        using var session = CreateSession(document);
+        session.SelectNode(tabControl.Children[0]);
+        session.CopySelectedNode();
+        session.SelectNode(panel);
+
+        Assert.False(session.PasteCopiedNode());
+        Assert.Empty(panel.Children);
+        Assert.False(session.Transactions.CanUndo);
+    }
+
+    [Fact]
+    public void TabPagePastesDirectlyIntoSelectedTabControl()
+    {
+        var document = EmptyDocument();
+        var tabControl = Node("TabControl", "tabControl1", 10, 10, 300, 180);
+        DesignerSpecialContainers.InitializeNewNode(tabControl);
+        document.Controls.Add(tabControl);
+        using var session = CreateSession(document);
+        var sourcePage = tabControl.Children[0];
+        var initialPageCount = tabControl.Children.Count;
+        session.SelectNode(sourcePage);
+        Assert.True(session.CopySelectedNode());
+        session.SelectNode(tabControl);
+
+        Assert.True(session.PasteCopiedNode());
+
+        var pastedPage = Assert.IsType<DesignControlNode>(session.SelectedNode);
+        Assert.Equal(initialPageCount + 1, tabControl.Children.Count);
+        Assert.Same(pastedPage, tabControl.Children[^1]);
+        Assert.True(DesignerSpecialContainers.IsTabPage(pastedPage));
+    }
+
+    [Theory]
+    [InlineData("None", 26, 26)]
+    [InlineData("Fill", 10, 10)]
+    [InlineData("Top", 10, 10)]
+    public void PositioningOffsetsOnlyAbsoluteNonDockedControls(string dock, int expectedX, int expectedY)
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        button.Properties["Dock"] = DesignPropertyValue.FromEnum(typeof(DockStyle).FullName!, dock);
+        button.Properties["Anchor"] = DesignPropertyValue.FromEnum(typeof(AnchorStyles).FullName!, "Top, Left, Right");
+        session.SelectNode(button);
+
+        Assert.True(session.DuplicateSelectedNode());
+
+        var copy = Assert.IsType<DesignControlNode>(session.SelectedNode);
+        Assert.Equal(new DesignBounds(expectedX, expectedY, 100, 30), copy.Bounds);
+        Assert.Equal(dock, copy.Properties["Dock"].GetString());
+        Assert.Equal("Top, Left, Right", copy.Properties["Anchor"].GetString());
+    }
+
+    [Fact]
+    public void PaddingMarginAndSizeConstraintsArePreserved()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        button.Properties["Padding"] = Structured("ModernFormsNext.Padding", ("Left", 1), ("Top", 2), ("Right", 3), ("Bottom", 4));
+        button.Properties["Margin"] = Structured("ModernFormsNext.Padding", ("Left", 4), ("Top", 3), ("Right", 2), ("Bottom", 1));
+        button.Properties["MinimumSize"] = Structured("System.Drawing.Size", ("Width", 40), ("Height", 20));
+        button.Properties["MaximumSize"] = Structured("System.Drawing.Size", ("Width", 200), ("Height", 100));
+        session.SelectNode(button);
+
+        Assert.True(session.DuplicateSelectedNode());
+
+        var copy = Assert.IsType<DesignControlNode>(session.SelectedNode);
+        foreach (var propertyName in new[] { "Padding", "Margin", "MinimumSize", "MaximumSize" })
+        {
+            Assert.True(DesignerPropertyValueComparer.Equals(button.Properties[propertyName], copy.Properties[propertyName]));
+            Assert.NotSame(button.Properties[propertyName], copy.Properties[propertyName]);
+            Assert.NotSame(button.Properties[propertyName].ObjectProperties, copy.Properties[propertyName].ObjectProperties);
+        }
+    }
+
+    [Fact]
+    public void FlowLayoutPastePreservesSequenceWithoutApplyingCoordinateOffset()
+    {
+        var document = EmptyDocument();
+        var source = Node("Button", "button1", 10, 20, 80, 25);
+        var flow = Node("FlowLayoutPanel", "flowLayoutPanel1", 100, 30, 260, 140);
+        document.Controls.Add(source);
+        document.Controls.Add(flow);
+        using var session = CreateSession(document);
+        session.SelectNode(source);
+        session.CopySelectedNode();
+        session.SelectNode(flow);
+
+        Assert.True(session.PasteCopiedNode());
+
+        var copy = Assert.Single(flow.Children);
+        Assert.Equal(source.Bounds, copy.Bounds);
+    }
+
+    [Fact]
+    public void TableLayoutPasteAssignsNextAvailableCellAndResetsSpans()
+    {
+        var document = EmptyDocument();
+        var source = Node("Button", "button1", 10, 20, 80, 25);
+        var table = Node("TableLayoutPanel", "tableLayoutPanel1", 100, 30, 260, 140);
+        DesignerSpecialContainers.InitializeNewNode(table);
+        var existing = Node("Label", "label1", 0, 0, 80, 25);
+        DesignerSpecialContainers.SetInt(existing, DesignerSpecialContainers.TableColumnPropertyName, 0);
+        DesignerSpecialContainers.SetInt(existing, DesignerSpecialContainers.TableRowPropertyName, 0);
+        table.Children.Add(existing);
+        document.Controls.Add(source);
+        document.Controls.Add(table);
+        using var session = CreateSession(document);
+        session.SelectNode(source);
+        session.CopySelectedNode();
+        session.SelectNode(table);
+
+        Assert.True(session.PasteCopiedNode());
+
+        var copy = table.Children[1];
+        Assert.Equal(1, DesignerSpecialContainers.GetInt(copy, DesignerSpecialContainers.TableColumnPropertyName, -1));
+        Assert.Equal(0, DesignerSpecialContainers.GetInt(copy, DesignerSpecialContainers.TableRowPropertyName, -1));
+        Assert.Equal(1, DesignerSpecialContainers.GetInt(copy, DesignerSpecialContainers.TableColumnSpanPropertyName, -1));
+        Assert.Equal(1, DesignerSpecialContainers.GetInt(copy, DesignerSpecialContainers.TableRowSpanPropertyName, -1));
+    }
+
+    [Fact]
+    public void SupportedCollectionsAreDeepCopiedWithoutSharedDesignerValues()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        var effect = DesignPropertyValue.FromStructuredObject(
+            "ModernFormsNext.Animations.ScaleInteractionEffect",
+            new SortedDictionary<string, DesignPropertyValue>(StringComparer.Ordinal)
+            {
+                ["Scale"] = DesignPropertyValue.FromDouble(1.125),
+                ["Duration"] = DesignPropertyValue.FromDouble(120.5)
+            });
+        button.Properties[InteractionEffectDesignValue.PropertyName] = InteractionEffectDesignValue.Create([effect]);
+        button.Properties[LayoutTransitionDesignValue.PropertyName] = LayoutTransitionDesignValue.Create(true, 225.5, "EaseOut");
+        session.SelectNode(button);
+
+        Assert.True(session.DuplicateSelectedNode());
+
+        var copy = Assert.IsType<DesignControlNode>(session.SelectedNode);
+        foreach (var name in new[] { InteractionEffectDesignValue.PropertyName, LayoutTransitionDesignValue.PropertyName })
+        {
+            Assert.True(DesignerPropertyValueComparer.Equals(button.Properties[name], copy.Properties[name]));
+            Assert.NotSame(button.Properties[name].ObjectProperties, copy.Properties[name].ObjectProperties);
+        }
+    }
+
+    [Fact]
+    public void BrushGradientAndGeometryValuesRoundTripWithExactKindsAndIndependentGraphs()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        var brush = new LinearGradientBrush();
+        brush.GradientStops.Add(new GradientStop(new SKColor(10, 20, 30), 0f));
+        brush.GradientStops.Add(new GradientStop(new SKColor(40, 50, 60), 1f));
+        var geometry = new PathGeometry();
+        var figure = new PathFigure(new System.Drawing.PointF(1.5f, 2.5f), isClosed: true);
+        figure.Segments.Add(new LineSegment(new System.Drawing.PointF(30.5f, 40.5f)));
+        geometry.Figures.Add(figure);
+        button.Properties["Background"] = DesignerPropertyValueEditor.ToDesignPropertyValue(brush, typeof(Brush));
+        button.Properties["Data"] = DesignerPropertyValueEditor.ToDesignPropertyValue(geometry, typeof(Geometry));
+        button.Properties["IntegralDouble"] = DesignPropertyValue.FromDouble(2d);
+        session.SelectNode(button);
+
+        Assert.True(session.DuplicateSelectedNode());
+
+        var copy = Assert.IsType<DesignControlNode>(session.SelectedNode);
+        foreach (var name in new[] { "Background", "Data", "IntegralDouble" })
+        {
+            Assert.True(DesignerPropertyValueComparer.Equals(button.Properties[name], copy.Properties[name]));
+            Assert.NotSame(button.Properties[name], copy.Properties[name]);
+        }
+        Assert.Equal(DesignPropertyValueKind.Double, copy.Properties["IntegralDouble"].Kind);
+    }
+
+    [Fact]
+    public void TabControlCopyPreservesTabPagesAndTheirChildrenAsIndependentNodes()
+    {
+        var document = EmptyDocument();
+        var tabs = Node("TabControl", "tabControl1", 10, 10, 300, 180);
+        DesignerSpecialContainers.InitializeNewNode(tabs);
+        tabs.Children[0].Children.Add(Node("Button", "button1", 5, 5, 80, 25));
+        document.Controls.Add(tabs);
+        using var session = CreateSession(document);
+        session.SelectNode(tabs);
+
+        Assert.True(session.DuplicateSelectedNode());
+
+        var copy = Assert.IsType<DesignControlNode>(session.SelectedNode);
+        Assert.Equal(2, copy.Children.Count);
+        Assert.NotSame(tabs.Children[0], copy.Children[0]);
+        Assert.NotSame(tabs.Children[0].Children[0], copy.Children[0].Children[0]);
+        Assert.Equal("button2", copy.Children[0].Children[0].Name);
+    }
+
+    [Theory]
+    [InlineData("UserControl")]
+    [InlineData("Example.ProjectCard")]
+    public void UserControlAndUnavailableCustomTypesPasteAsSafeDataOnlyNodes(string typeName)
+    {
+        ConstructorProbe.ConstructionCount = 0;
+        var document = EmptyDocument();
+        var source = Node(typeName, "projectCard1", 10, 10, 160, 80);
+        source.Properties["Text"] = DesignPropertyValue.FromString("Card");
+        document.Controls.Add(source);
+        using var session = CreateSession(document);
+        session.SelectNode(source);
+
+        Assert.True(session.DuplicateSelectedNode());
+
+        var copy = Assert.IsType<DesignControlNode>(session.SelectedNode);
+        Assert.Equal(typeName, copy.TypeName);
+        Assert.Equal("Card", copy.Properties["Text"].GetString());
+        Assert.Equal(0, ConstructorProbe.ConstructionCount);
+    }
+
+    [Fact]
+    public void ClipboardDoesNotConstructEvenAnAvailableCustomControlType()
+    {
+        ConstructorProbe.ConstructionCount = 0;
+        var document = EmptyDocument();
+        var source = Node(typeof(ConstructorProbe).FullName!, "constructorProbe1", 10, 10, 160, 80);
+        document.Controls.Add(source);
+        using var session = CreateSession(document);
+        session.SelectNode(source);
+
+        Assert.True(session.DuplicateSelectedNode());
+
+        Assert.Equal(typeof(ConstructorProbe).FullName, session.SelectedNode!.TypeName);
+        Assert.Equal(0, ConstructorProbe.ConstructionCount);
+    }
+
+    [Fact]
+    public void CopyPreservesEventHandlerNamesWithoutCreatingDelegatesOrMethods()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        button.Events["Click"] = "HandleButtonClick";
+        button.Events["TextChanged"] = null;
+        session.SelectNode(button);
+
+        Assert.True(session.DuplicateSelectedNode());
+
+        var copy = Assert.IsType<DesignControlNode>(session.SelectedNode);
+        Assert.Equal("HandleButtonClick", copy.Events["Click"]);
+        Assert.Null(copy.Events["TextChanged"]);
+        var code = new CSharpDesignerGenerator().Generate(session.Document).Code;
+        Assert.Contains("button2.Click += this.HandleButtonClick;", code, StringComparison.Ordinal);
+        Assert.DoesNotContain("void HandleButtonClick", code, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void CrossDocumentCopyCreatesIndependentTransactionInTargetDocument()
+    {
+        var first = CreateDocument(out var source);
+        first.ClassName = "FirstForm";
+        var second = EmptyDocument();
+        second.ClassName = "SecondForm";
+        using var session = CreateSession(first, "First.mfdesign");
+        session.SelectNode(source);
+        session.CopySelectedNode();
+        session.OpenDocument(second, "Second.mfdesign");
+        session.SelectNode(null);
+
+        Assert.True(session.PasteCopiedNode());
+        var pasted = Assert.Single(second.Controls);
+        Assert.NotSame(source, pasted);
+        Assert.True(session.Transactions.Undo());
+        Assert.Empty(second.Controls);
+        Assert.Single(first.Controls);
+        session.SwitchDocument(0);
+        Assert.False(session.Transactions.CanUndo);
+    }
+
+    [Fact]
+    public void ClipboardSurvivesSourceDocumentCloseBecauseItContainsNoLiveNodes()
+    {
+        var first = CreateDocument(out var source);
+        first.ClassName = "FirstForm";
+        var second = EmptyDocument();
+        second.ClassName = "SecondForm";
+        using var session = CreateSession(first, "First.mfdesign");
+        session.SelectNode(source);
+        session.CopySelectedNode();
+        session.OpenDocument(second, "Second.mfdesign");
+        session.CloseDocument(0);
+        session.SelectNode(null);
+
+        Assert.True(session.PasteCopiedNode());
+        Assert.Single(second.Controls);
+    }
+
+    [Fact]
+    public void CutInFirstDocumentAndPasteInSecondKeepIndependentHistories()
+    {
+        var first = CreateDocument(out var source);
+        first.ClassName = "FirstForm";
+        var second = EmptyDocument();
+        second.ClassName = "SecondForm";
+        using var session = CreateSession(first, "First.mfdesign");
+        session.SelectNode(source);
+        Assert.True(session.CutSelectedNode());
+        Assert.Empty(first.Controls);
+        session.OpenDocument(second, "Second.mfdesign");
+        session.SelectNode(null);
+        Assert.True(session.PasteCopiedNode());
+
+        Assert.True(session.Transactions.Undo());
+        Assert.Empty(second.Controls);
+        Assert.Empty(first.Controls);
+        session.SwitchDocument(0);
+        Assert.True(session.Transactions.Undo());
+        Assert.Same(source, Assert.Single(first.Controls));
+        Assert.Empty(second.Controls);
+    }
+
+    [Theory]
+    [InlineData("{")]
+    [InlineData("")]
+    [InlineData("null")]
+    public void CorruptedClipboardPayloadIsRejectedWithoutMutationOrHistory(string content)
+    {
+        using var session = CreateSession(CreateDocument(out _));
+        if (string.IsNullOrEmpty(content))
+            session.Clipboard.Clear();
+        else
+            session.Clipboard.SetContent(content);
+        var before = DesignDocumentSerializer.Default.Serialize(session.Document);
+
+        Assert.False(session.PasteCopiedNode());
+
+        Assert.Equal(before, DesignDocumentSerializer.Default.Serialize(session.Document));
+        Assert.False(session.Transactions.CanUndo);
+    }
+
+    [Theory]
+    [InlineData("\"version\":1", "\"version\":99")]
+    [InlineData("ModernFormsNext.Designer", "ModernFormsNext.Unknown")]
+    public void UnsupportedClipboardVersionOrFormatIsRejected(string oldText, string newText)
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        session.SelectNode(button);
+        session.CopySelectedNode();
+        session.Clipboard.SetContent(session.Clipboard.Content!.Replace(oldText, newText, StringComparison.Ordinal));
+        var before = DesignDocumentSerializer.Default.Serialize(session.Document);
+
+        Assert.False(session.PasteCopiedNode());
+        Assert.False(session.CanPasteCopiedNode);
+        Assert.Equal(before, DesignDocumentSerializer.Default.Serialize(session.Document));
+        Assert.False(session.Transactions.CanUndo);
+    }
+
+    [Fact]
+    public void MissingSchemaFieldsInvalidCollectionsAndUnsafeNamesAreRejected()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        session.SelectNode(button);
+        Assert.True(session.CopySelectedNode());
+        var valid = session.Clipboard.Content!;
+        var before = DesignDocumentSerializer.Default.Serialize(session.Document);
+        var invalidPayloads = new[]
+        {
+            valid.Replace($"\"format\":\"{DesignerClipboardPayload.CurrentFormat}\",", string.Empty, StringComparison.Ordinal),
+            $"{{\"format\":\"{DesignerClipboardPayload.CurrentFormat}\",\"version\":1}}",
+            valid.Replace("\"children\":[]", "\"children\":{}", StringComparison.Ordinal),
+            valid.Replace("\"name\":\"button1\"", "\"name\":\"1button\"", StringComparison.Ordinal)
+        };
+
+        foreach (var payload in invalidPayloads)
+        {
+            session.Clipboard.SetContent(payload);
+            Assert.False(session.PasteCopiedNode());
+            Assert.False(session.CanPasteCopiedNode);
+            Assert.Equal(before, DesignDocumentSerializer.Default.Serialize(session.Document));
+            Assert.False(session.Transactions.CanUndo);
+        }
+    }
+
+    [Fact]
+    public void AssemblyQualifiedTypeNamesAreRejectedBeforeDocumentMutation()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        session.SelectNode(button);
+        Assert.True(session.CopySelectedNode());
+        session.Clipboard.SetContent(session.Clipboard.Content!.Replace(
+            "\"typeName\":\"Button\"",
+            "\"typeName\":\"Example.ProjectCard, Example.Project\"",
+            StringComparison.Ordinal));
+
+        Assert.False(session.PasteCopiedNode());
+        Assert.Single(session.Document.Controls);
+        Assert.False(session.Transactions.CanUndo);
+    }
+
+    [Fact]
+    public void MalformedGeometryRepresentationIsRejectedBeforeDocumentMutation()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        button.Properties["Data"] = Structured("ModernFormsNext.Drawing.PathGeometry", ("FigureCount", 1));
+        session.SelectNode(button);
+        Assert.True(session.CopySelectedNode());
+        session.Clipboard.SetContent(session.Clipboard.Content!.Replace(
+            "\"properties\":{\"FigureCount\":{\"kind\":\"int32\",\"int32Value\":1}}",
+            "\"properties\":null",
+            StringComparison.Ordinal));
+
+        Assert.False(session.PasteCopiedNode());
+        Assert.Single(session.Document.Controls);
+        Assert.False(session.Transactions.CanUndo);
+    }
+
+    [Fact]
+    public void PathologicallyDeepPayloadIsRejectedWithoutStackOverflowOrMutation()
+    {
+        using var session = CreateSession(CreateDocument(out _));
+        session.Clipboard.SetContent(CreateDeepClipboardPayload(depth: 2_000));
+
+        Assert.False(session.PasteCopiedNode());
+        Assert.Single(session.Document.Controls);
+        Assert.False(session.Transactions.CanUndo);
+    }
+
+    [Fact]
+    public void MissingControlTypeIsRejectedWithoutHistory()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        session.SelectNode(button);
+        session.CopySelectedNode();
+        session.Clipboard.SetContent(session.Clipboard.Content!.Replace("\"typeName\":\"Button\"", "\"typeName\":null", StringComparison.Ordinal));
+
+        Assert.False(session.PasteCopiedNode());
+        Assert.False(session.Transactions.CanUndo);
+        Assert.Single(session.Document.Controls);
+    }
+
+    [Fact]
+    public void InvalidPropertyRepresentationAndUnknownMembersAreRejected()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        button.Properties["Count"] = DesignPropertyValue.FromInt32(7);
+        session.SelectNode(button);
+        session.CopySelectedNode();
+        var valid = session.Clipboard.Content!;
+        var invalidValue = valid.Replace("\"kind\":\"int32\",\"int32Value\":7", "\"kind\":\"boolean\"", StringComparison.Ordinal);
+        session.Clipboard.SetContent(invalidValue);
+        Assert.False(session.PasteCopiedNode());
+
+        var contradictoryValue = valid.Replace(
+            "\"kind\":\"int32\",\"int32Value\":7",
+            "\"kind\":\"int32\",\"booleanValue\":true,\"int32Value\":7",
+            StringComparison.Ordinal);
+        session.Clipboard.SetContent(contradictoryValue);
+        Assert.False(session.PasteCopiedNode());
+
+        session.Clipboard.SetContent(valid.Replace("\"version\":1,", string.Empty, StringComparison.Ordinal));
+        Assert.False(session.PasteCopiedNode());
+
+        session.Clipboard.SetContent(valid.Replace("\"memberVisibility\":\"private\",", string.Empty, StringComparison.Ordinal));
+        Assert.False(session.PasteCopiedNode());
+
+        session.Clipboard.SetContent($"{valid[..^1]},\"unexpected\":true}}");
+        Assert.False(session.PasteCopiedNode());
+        Assert.False(session.Transactions.CanUndo);
+    }
+
+    [Fact]
+    public void MaliciousEventOrTypeTextIsRejectedAndNeverExecuted()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        button.Events["Click"] = "HandleClick";
+        session.SelectNode(button);
+        session.CopySelectedNode();
+        var valid = session.Clipboard.Content!;
+        var malicious = valid
+            .Replace("\"HandleClick\"", "\"HandleClick();System.IO.File.Delete('x')\"", StringComparison.Ordinal);
+        session.Clipboard.SetContent(malicious);
+
+        Assert.False(session.PasteCopiedNode());
+
+        session.Clipboard.SetContent(valid.Replace(
+            "\"typeName\":\"Button\"",
+            "\"typeName\":\"Button;System.IO.File.Delete\"",
+            StringComparison.Ordinal));
+        Assert.False(session.PasteCopiedNode());
+
+        session.Clipboard.SetContent(valid.Replace(
+            "\"stringValue\":\"None\"",
+            "\"stringValue\":\"None);System.IO.File.Delete('x')\"",
+            StringComparison.Ordinal));
+        Assert.False(session.PasteCopiedNode());
+
+        Assert.Single(session.Document.Controls);
+        Assert.False(session.Transactions.CanUndo);
+    }
+
+    [Fact]
+    public void CommandAvailabilityTracksSelectionClipboardAndInvalidPayload()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        session.SelectNode(button);
+        Assert.True(session.CanCopySelectedNode);
+        Assert.True(session.CanCutSelectedNode);
+        Assert.True(session.CanDuplicateSelectedNode);
+        Assert.False(session.CanPasteCopiedNode);
+
+        session.CopySelectedNode();
+        Assert.True(session.CanPasteCopiedNode);
+        session.SelectNode(null);
+        Assert.False(session.CanCopySelectedNode);
+        Assert.False(session.CanCutSelectedNode);
+        Assert.False(session.CanDuplicateSelectedNode);
+        Assert.True(session.CanPasteCopiedNode);
+
+        session.Clipboard.SetContent("{");
+        Assert.False(session.CanPasteCopiedNode);
+        session.Clipboard.Clear();
+        Assert.False(session.CanPasteCopiedNode);
+    }
+
+    [Fact]
+    public void ToolbarCommandStatesRefreshAfterSelectionClipboardUndoAndDocumentSwitch()
+    {
+        using var shell = new ModernFormsDesignerShell();
+        var first = CreateDocument(out var button);
+        shell.Session.OpenDocument(first, path: null);
+        var toolbar = Assert.Single(shell.Controls.OfType<DesignerToolbar>());
+        var cut = GetToolbarButton(toolbar, "cutButton");
+        var copy = GetToolbarButton(toolbar, "copyButton");
+        var paste = GetToolbarButton(toolbar, "pasteButton");
+        var duplicate = GetToolbarButton(toolbar, "duplicateButton");
+
+        Assert.False(cut.Enabled);
+        Assert.False(copy.Enabled);
+        Assert.False(paste.Enabled);
+        Assert.False(duplicate.Enabled);
+
+        shell.Session.SelectNode(button);
+        Assert.True(cut.Enabled);
+        Assert.True(copy.Enabled);
+        Assert.True(duplicate.Enabled);
+        shell.Session.CopySelectedNode();
+        Assert.True(paste.Enabled);
+
+        Assert.True(shell.Session.CutSelectedNode());
+        Assert.False(cut.Enabled);
+        Assert.False(copy.Enabled);
+        Assert.True(paste.Enabled);
+        Assert.True(shell.Session.Transactions.Undo());
+        Assert.True(copy.Enabled);
+
+        shell.Session.OpenDocument(EmptyDocument(), path: null);
+        Assert.False(copy.Enabled);
+        Assert.True(paste.Enabled);
+        shell.Session.CloseDocument(shell.Session.ActiveDocumentIndex);
+        Assert.False(copy.Enabled);
+        Assert.True(paste.Enabled);
+    }
+
+    [Fact]
+    public void ClipboardChangedFiresOnlyWhenDetachedContentChanges()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        var changed = 0;
+        session.ClipboardChanged += (_, _) => changed++;
+        session.SelectNode(button);
+
+        session.CopySelectedNode();
+        session.CopySelectedNode();
+        session.Clipboard.Clear();
+
+        Assert.Equal(2, changed);
+    }
+
+    [Theory]
+    [InlineData(Keys.C, 1)]
+    [InlineData(Keys.X, 0)]
+    [InlineData(Keys.V, 2)]
+    [InlineData(Keys.D, 2)]
+    public void ShellHandlesDesignerClipboardShortcuts(Keys key, int expectedControlCount)
+    {
+        using var shell = new ModernFormsDesignerShell();
+        var document = CreateDocument(out var button);
+        shell.LoadDocument(document);
+        shell.Session.SelectNode(button);
+        if (key == Keys.V)
+        {
+            shell.Session.CopySelectedNode();
+            shell.Session.SelectNode(null);
+        }
+        var args = new KeyEventArgs(Keys.Control | key);
+
+        Assert.True(shell.ProcessDesignerShortcut(args));
+
+        Assert.True(args.SuppressKeyPress);
+        Assert.Equal(expectedControlCount, document.Controls.Count);
+    }
+
+    [Theory]
+    [InlineData(Keys.C)]
+    [InlineData(Keys.X)]
+    [InlineData(Keys.V)]
+    [InlineData(Keys.D)]
+    public void ShellLeavesClipboardShortcutsToActivePropertyTextEditor(Keys key)
+    {
+        using var shell = new ModernFormsDesignerShell();
+        var document = CreateDocument(out var button);
+        shell.LoadDocument(document);
+        shell.Session.SelectNode(button);
+        Assert.True(shell.Session.CopySelectedNode());
+        var grid = Assert.Single(shell.Controls.OfType<DesignerPropertyGrid>());
+        var stateField = typeof(DesignerPropertyGrid).GetField(
+            "state",
+            System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
+        Assert.NotNull(stateField);
+        var state = Assert.IsType<DesignerPropertyGridState>(stateField.GetValue(grid));
+        var textRow = Assert.Single(state.Rows, row => row.Property?.Name == "Text");
+        grid.BeginEdit(textRow, new System.Drawing.Rectangle(0, 0, 160, 24));
+        Assert.True(grid.IsEditingValue);
+        var before = DesignDocumentSerializer.Default.Serialize(document);
+        var args = new KeyEventArgs(Keys.Control | key);
+
+        Assert.False(shell.ProcessDesignerShortcut(args));
+
+        Assert.False(args.SuppressKeyPress);
+        Assert.Equal(before, DesignDocumentSerializer.Default.Serialize(document));
+        Assert.False(shell.Session.Transactions.CanUndo);
+    }
+
+    [Fact]
+    public void DirtyStateReturnsToSaveMarkerAfterUndoingPaste()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        session.MarkSaved();
+        session.SelectNode(button);
+        session.CopySelectedNode();
+        Assert.False(session.IsDirty);
+        session.SelectNode(null);
+
+        session.PasteCopiedNode();
+        Assert.True(session.IsDirty);
+        session.Transactions.Undo();
+        Assert.False(session.IsDirty);
+        session.Transactions.Redo();
+        Assert.True(session.IsDirty);
+    }
+
+    [Fact]
+    public void PasteUndoRedoRestoresSelectionForPropertyGridAndExistingControl()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        var grid = new DesignerPropertyGridState(session);
+        session.SelectNode(button);
+        session.CopySelectedNode();
+        session.SelectNode(null);
+        session.PasteCopiedNode();
+        var pasted = Assert.IsType<DesignControlNode>(session.SelectedNode);
+        Assert.Equal(pasted.Name, grid.HeaderName);
+
+        session.Transactions.Undo();
+        Assert.Null(session.SelectedNode);
+        Assert.Equal(session.Document.FormName, grid.HeaderName);
+        session.Transactions.Redo();
+        Assert.Same(pasted, session.SelectedNode);
+        Assert.Equal(pasted.Name, grid.HeaderName);
+    }
+
+    [Fact]
+    public void PastePublishesDocumentChangeUsedByOutlineAndPropertyViews()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        var changes = 0;
+        session.DocumentChanged += (_, _) => changes++;
+        session.SelectNode(button);
+        session.CopySelectedNode();
+        session.SelectNode(null);
+
+        session.PasteCopiedNode();
+        session.Transactions.Undo();
+        session.Transactions.Redo();
+
+        Assert.Equal(3, changes);
+        Assert.Equal(2, session.Document.Controls.Count);
+    }
+
+    [Fact]
+    public void GeneratedCodeTracksPasteUndoAndRedoDeterministically()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        var generator = new CSharpDesignerGenerator();
+        session.SelectNode(button);
+        session.CopySelectedNode();
+        session.SelectNode(null);
+        session.PasteCopiedNode();
+        var pastedCode = generator.Generate(session.Document);
+        Assert.True(pastedCode.Succeeded, string.Join(Environment.NewLine, pastedCode.Validation.Errors));
+        Assert.Contains("button2", pastedCode.Code, StringComparison.Ordinal);
+
+        session.Transactions.Undo();
+        Assert.DoesNotContain("button2", generator.Generate(session.Document).Code, StringComparison.Ordinal);
+        session.Transactions.Redo();
+        Assert.Equal(pastedCode.Code, generator.Generate(session.Document).Code);
+    }
+
+    [Fact]
+    public void GeneratedCodePreservesPastedSubtreeHierarchy()
+    {
+        var document = EmptyDocument();
+        var panel = Node("Panel", "panel1", 10, 10, 200, 120);
+        panel.Children.Add(Node("Button", "button1", 5, 5, 80, 25));
+        document.Controls.Add(panel);
+        using var session = CreateSession(document);
+        session.SelectNode(panel);
+        session.DuplicateSelectedNode();
+
+        var result = new CSharpDesignerGenerator().Generate(document);
+
+        Assert.True(result.Succeeded, string.Join(Environment.NewLine, result.Validation.Errors));
+        Assert.Contains("this.panel2.Controls.Add(this.button2);", result.Code, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void SaveReopenAfterPastePreservesTreeAndDoesNotPersistClipboardPayload()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        session.SelectNode(button);
+        session.CopySelectedNode();
+        session.SelectNode(null);
+        session.PasteCopiedNode();
+
+        var json = DesignDocumentSerializer.Default.Serialize(session.Document);
+        var reopened = DesignDocumentSerializer.Default.Deserialize(json);
+
+        Assert.Equal(["button1", "button2"], reopened.Controls.Select(node => node.Name));
+        Assert.DoesNotContain(DesignerClipboardPayload.CurrentFormat, json, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ReverseParsedDocumentSupportsCopyPasteLikeMfdesignDocument()
+    {
+        var original = CreateDocument(out _);
+        var generated = new CSharpDesignerGenerator().Generate(original);
+        Assert.True(generated.Succeeded);
+        var parsed = new CSharpDesignerParser().Parse(generated.Code);
+        Assert.True(parsed.Success, string.Join(Environment.NewLine, parsed.Diagnostics.Select(item => item.Message)));
+        using var session = CreateSession(Assert.IsType<DesignDocument>(parsed.Document));
+        var source = Assert.Single(session.Document.Controls);
+        session.SelectNode(source);
+        session.CopySelectedNode();
+        session.SelectNode(null);
+
+        Assert.True(session.PasteCopiedNode());
+        Assert.Equal(2, session.Document.Controls.Count);
+    }
+
+    [Fact]
+    public void NewPasteAfterUndoClearsRedoWithoutAffectingClipboard()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        session.SelectNode(button);
+        session.CopySelectedNode();
+        session.SelectNode(null);
+        session.PasteCopiedNode();
+        session.Transactions.Undo();
+        Assert.True(session.Transactions.CanRedo);
+
+        session.PasteCopiedNode();
+
+        Assert.False(session.Transactions.CanRedo);
+        Assert.Equal(2, session.Document.Controls.Count);
+    }
+
+    [Fact]
+    public void CopyDoesNotClearRedoOrChangeDirtyState()
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        session.MarkSaved();
+        session.SelectNode(button);
+        Assert.True(session.CopySelectedNode());
+        session.SelectNode(null);
+        Assert.True(session.PasteCopiedNode());
+        Assert.True(session.Transactions.Undo());
+        Assert.True(session.Transactions.CanRedo);
+        Assert.False(session.IsDirty);
+        session.SelectNode(button);
+
+        Assert.True(session.CopySelectedNode());
+
+        Assert.True(session.Transactions.CanRedo);
+        Assert.False(session.Transactions.CanUndo);
+        Assert.False(session.IsDirty);
+    }
+
+    [Fact]
+    public void CutClipboardFailureBeforeMutationLeavesDocumentAndHistoryUntouched()
+    {
+        var clipboard = new ThrowAfterSetDesignerClipboard();
+        using var session = new DesignerSession(
+            environment: null,
+            initialRenderMode: DesignerControlRenderMode.Runtime,
+            historyLimit: 500,
+            clipboard: clipboard);
+        var document = CreateDocument(out var button);
+        session.OpenDocument(document, path: null);
+        session.SelectNode(button);
+
+        Assert.Throws<InvalidOperationException>(() => session.CutSelectedNode());
+
+        Assert.Same(button, Assert.Single(document.Controls));
+        Assert.Same(button, session.SelectedNode);
+        Assert.NotNull(clipboard.Content);
+        Assert.False(session.Transactions.CanUndo);
+        Assert.False(session.Transactions.HasActiveTransaction);
+    }
+
+    [Theory]
+    [InlineData("Cut")]
+    [InlineData("Paste")]
+    [InlineData("Duplicate")]
+    public void ClipboardMutationRollsBackWhenSelectionRefreshFailsAfterTreeChange(string operation)
+    {
+        using var session = CreateSession(CreateDocument(out var button));
+        session.SelectNode(button);
+        Assert.True(session.CopySelectedNode());
+        var clipboardBefore = session.Clipboard.Content;
+        if (operation == "Paste")
+            session.SelectNode(null);
+        var selectionBefore = session.SelectedNode;
+        var treeBefore = DesignDocumentSerializer.Default.Serialize(session.Document);
+        EventHandler? throwOnce = null;
+        throwOnce = (_, _) =>
+        {
+            session.Host.Selection.SelectionChanged -= throwOnce;
+            throw new InvalidOperationException("Expected selection refresh failure.");
+        };
+        session.Host.Selection.SelectionChanged += throwOnce;
+
+        Assert.Throws<InvalidOperationException>(() =>
+        {
+            if (operation == "Cut")
+                session.CutSelectedNode();
+            else if (operation == "Paste")
+                session.PasteCopiedNode();
+            else
+                session.DuplicateSelectedNode();
+        });
+
+        Assert.Equal(treeBefore, DesignDocumentSerializer.Default.Serialize(session.Document));
+        Assert.Same(selectionBefore, session.SelectedNode);
+        Assert.False(session.Transactions.CanUndo);
+        Assert.False(session.Transactions.HasActiveTransaction);
+        Assert.Equal(clipboardBefore, session.Clipboard.Content);
+    }
+
+    [Fact]
+    public void LastCopyWinsAcrossThreeDocuments()
+    {
+        var first = CreateDocument(out var firstButton);
+        firstButton.Properties["Text"] = DesignPropertyValue.FromString("First");
+        var second = CreateDocument(out var secondButton);
+        second.ClassName = "SecondForm";
+        secondButton.Properties["Text"] = DesignPropertyValue.FromString("Second");
+        var third = EmptyDocument();
+        third.ClassName = "ThirdForm";
+        using var session = CreateSession(first, "First.mfdesign");
+        session.SelectNode(firstButton);
+        Assert.True(session.CopySelectedNode());
+        session.OpenDocument(second, "Second.mfdesign");
+        session.SelectNode(secondButton);
+        Assert.True(session.CopySelectedNode());
+        session.OpenDocument(third, "Third.mfdesign");
+        session.SelectNode(null);
+
+        Assert.True(session.PasteCopiedNode());
+
+        Assert.Equal("Second", Assert.Single(third.Controls).Properties["Text"].GetString());
+    }
+
+    [Fact]
+    public void SourceDocumentCanCloseAndCollectBeforePasteAndUndoInTarget()
+    {
+        var (session, target, sourceReference) = CreateClosedSourceClipboardScenario();
+        using (session)
+        {
+            ForceFullCollection();
+            Assert.False(sourceReference.IsAlive);
+            Assert.True(session.PasteCopiedNode());
+            Assert.Single(target.Controls);
+            Assert.True(session.Transactions.Undo());
+            Assert.Empty(target.Controls);
+        }
+    }
+
+    [Fact]
+    public void ClipboardPayloadDoesNotRetainDeletedOriginalSubtreeAfterHistoryClear()
+    {
+        var (session, reference) = CreateClipboardWeakReference();
+        using (session)
+        {
+            ForceFullCollection();
+            Assert.False(reference.IsAlive);
+            Assert.True(session.CanPasteCopiedNode);
+            Assert.True(session.PasteCopiedNode());
+        }
+    }
+
+    [Fact]
+    public void LargeSubtreeCopyPasteUndoRedoIsDeterministicAndBounded()
+    {
+        var document = EmptyDocument();
+        var root = Node("Panel", "panel1", 10, 10, 600, 500);
+        for (var index = 1; index <= 300; index++)
+        {
+            var container = Node("Panel", $"cell{index}", index % 20 * 20, index / 20 * 20, 18, 18);
+            if (index % 10 == 0)
+                container.Children.Add(Node("Label", $"label{index}", 1, 1, 12, 12));
+            root.Children.Add(container);
+        }
+        document.Controls.Add(root);
+        using var session = CreateSession(document);
+        session.SelectNode(root);
+        var stopwatch = Stopwatch.StartNew();
+        Assert.True(session.CopySelectedNode());
+        session.SelectNode(null);
+        Assert.True(session.PasteCopiedNode());
+        var pastedSnapshot = DesignDocumentSerializer.Default.Serialize(session.Document);
+        Assert.True(session.Transactions.Undo());
+        Assert.Single(session.Document.Controls);
+        Assert.True(session.Transactions.Redo());
+        stopwatch.Stop();
+
+        Assert.Equal(pastedSnapshot, DesignDocumentSerializer.Default.Serialize(session.Document));
+        Assert.True(stopwatch.Elapsed < TimeSpan.FromSeconds(10), $"Large subtree clipboard test took {stopwatch.Elapsed}.");
+    }
+
+    [Fact]
+    public void ClipboardSerializationIsDeterministicForSameSubtree()
+    {
+        var document = CreateDocument(out var button);
+        button.Properties["Zeta"] = DesignPropertyValue.FromInt32(1);
+        button.Properties["Alpha"] = DesignPropertyValue.FromDouble(2d);
+
+        Assert.True(DesignerClipboardSerializer.TrySerialize(button, out var first, out _));
+        Assert.True(DesignerClipboardSerializer.TrySerialize(button, out var second, out _));
+        Assert.Equal(first, second);
+    }
+
+    private static DesignerSession CreateSession(DesignDocument document, string? path = null)
+    {
+        var session = new DesignerSession();
+        session.OpenDocument(document, path);
+        return session;
+    }
+
+    private static string CreateDeepClipboardPayload(int depth)
+    {
+        var builder = new System.Text.StringBuilder();
+        builder.Append($"{{\"format\":\"{DesignerClipboardPayload.CurrentFormat}\",\"version\":1,\"root\":");
+        for (var index = 0; index < depth; index++)
+        {
+            builder.Append($"{{\"typeName\":\"Panel\",\"name\":\"panel{index}\",\"x\":0,\"y\":0,\"width\":1,\"height\":1,\"memberVisibility\":\"private\",\"properties\":{{}},\"events\":{{}},\"children\":[");
+        }
+
+        builder.Append($"{{\"typeName\":\"Panel\",\"name\":\"panel{depth}\",\"x\":0,\"y\":0,\"width\":1,\"height\":1,\"memberVisibility\":\"private\",\"properties\":{{}},\"events\":{{}},\"children\":[]}}");
+        for (var index = 0; index < depth; index++)
+            builder.Append("]}");
+        builder.Append('}');
+        return builder.ToString();
+    }
+
+    private static DesignDocument CreateDocument(out DesignControlNode button)
+    {
+        var document = EmptyDocument();
+        button = Node("Button", "button1", 10, 10, 100, 30);
+        document.Controls.Add(button);
+        return document;
+    }
+
+    private static DesignDocument EmptyDocument()
+        => new()
+        {
+            Namespace = "Example",
+            ClassName = "MainForm",
+            FormName = "mainForm",
+            Size = new DesignSize(800, 600)
+        };
+
+    private static DesignControlNode Node(string typeName, string name, int x, int y, int width, int height)
+        => new()
+        {
+            TypeName = typeName,
+            Name = name,
+            Bounds = new DesignBounds(x, y, width, height),
+            Properties =
+            {
+                ["Dock"] = DesignPropertyValue.FromEnum(typeof(DockStyle).FullName!, nameof(DockStyle.None))
+            }
+        };
+
+    private static DesignPropertyValue Structured(string typeName, params (string Name, int Value)[] properties)
+        => DesignPropertyValue.FromStructuredObject(
+            typeName,
+            properties.ToDictionary(item => item.Name, item => DesignPropertyValue.FromInt32(item.Value), StringComparer.Ordinal));
+
+    private static Button GetToolbarButton(DesignerToolbar toolbar, string fieldName)
+    {
+        var field = typeof(DesignerToolbar).GetField(
+            fieldName,
+            System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
+        Assert.NotNull(field);
+        return Assert.IsType<Button>(field.GetValue(toolbar));
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static (DesignerSession Session, WeakReference Reference) CreateClipboardWeakReference()
+    {
+        var document = EmptyDocument();
+        var panel = Node("Panel", "panel1", 10, 10, 200, 120);
+        panel.Children.Add(Node("Button", "button1", 5, 5, 80, 25));
+        document.Controls.Add(panel);
+        var reference = new WeakReference(panel);
+        var session = CreateSession(document);
+        session.SelectNode(panel);
+        session.CopySelectedNode();
+        session.DeleteNode(panel);
+        session.Transactions.ClearHistory();
+        return (session, reference);
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static (DesignerSession Session, DesignDocument Target, WeakReference Reference) CreateClosedSourceClipboardScenario()
+    {
+        var sourceDocument = CreateDocument(out var source);
+        var reference = new WeakReference(source);
+        var target = EmptyDocument();
+        target.ClassName = "TargetForm";
+        var session = CreateSession(sourceDocument, "Source.mfdesign");
+        session.SelectNode(source);
+        session.CopySelectedNode();
+        session.OpenDocument(target, "Target.mfdesign");
+        session.CloseDocument(0);
+        session.SelectNode(null);
+        return (session, target, reference);
+    }
+
+    private static void ForceFullCollection()
+    {
+        for (var attempt = 0; attempt < 3; attempt++)
+        {
+            GC.Collect();
+            GC.WaitForPendingFinalizers();
+            GC.Collect();
+        }
+    }
+
+    private sealed class ConstructorProbe : UserControl
+    {
+        public static int ConstructionCount { get; set; }
+
+        public ConstructorProbe() => ConstructionCount++;
+    }
+
+    private sealed class ThrowAfterSetDesignerClipboard : IDesignerClipboard
+    {
+        public event EventHandler? Changed;
+
+        public string? Content { get; private set; }
+
+        public void SetContent(string content)
+        {
+            Content = content;
+            throw new InvalidOperationException("Expected clipboard notification failure.");
+        }
+
+        public void Clear()
+        {
+            Content = null;
+            Changed?.Invoke(this, EventArgs.Empty);
+        }
+    }
+}
diff --git a/ModernFormsNext.Designer.Tests/DesignerRuntimeLayoutParityTests.cs b/ModernFormsNext.Designer.Tests/DesignerRuntimeLayoutParityTests.cs
index 4d6d248..d8d6161 100644
--- a/ModernFormsNext.Designer.Tests/DesignerRuntimeLayoutParityTests.cs
+++ b/ModernFormsNext.Designer.Tests/DesignerRuntimeLayoutParityTests.cs
@@ -185,6 +185,41 @@ public void ChildReorderRemoveAndAddStayEquivalentToRuntimeOrder()
         DesignerRuntimeLayoutParityHarness.AssertParity("order-added", document, document);
     }
 
+    [Theory]
+    [InlineData(1d)]
+    [InlineData(1.25d)]
+    [InlineData(1.5d)]
+    [InlineData(2d)]
+    public void ClipboardPasteAndDuplicateUseProductionLayoutSemanticsAtDpiScale(double dpiScale)
+    {
+        var document = BasicDocument();
+        var source = Node("source", "Panel", 12, 18, 110, 80);
+        source.Properties["Padding"] = PaddingValue(new Padding(3, 5, 7, 9));
+        source.Children.Add(Node("header", "Panel", 0, 0, 30, 24, DockStyle.Top));
+        source.Children.Add(Node("content", "Panel", 0, 0, 30, 30, DockStyle.Fill));
+        var target = Node("target", "Panel", 140, 10, 140, 170);
+        target.Properties["Padding"] = PaddingValue(new Padding(6));
+        document.Controls.Add(source);
+        document.Controls.Add(target);
+        using var session = new DesignerSession();
+        session.LoadDocument(document);
+
+        session.SelectNode(source);
+        Assert.True(session.CopySelectedNode());
+        session.SelectNode(target);
+        Assert.True(session.PasteCopiedNode());
+        Assert.True(session.DuplicateSelectedNode());
+
+        Assert.Equal(2, target.Children.Count);
+        Assert.Equal("source1", target.Children[0].Name);
+        Assert.Equal("source2", target.Children[1].Name);
+        Assert.Equal(new DesignBounds(28, 34, 110, 80), target.Children[0].Bounds);
+        Assert.Equal(new DesignBounds(44, 50, 110, 80), target.Children[1].Bounds);
+        DesignerRuntimeLayoutParityHarness.AssertDpiParity(
+            new ParityScenario($"clipboard-paste-duplicate-{dpiScale:0.##}x", () => document),
+            dpiScale);
+    }
+
     public static IEnumerable<object[]> CoreParityScenarios()
     {
         yield return Scenario("ordinary-child", () => WithChildren(Node("child", "Panel", 17, 23, 91, 47)));
diff --git a/ModernFormsNext.Designer/Clipboard/DesignerClipboard.cs b/ModernFormsNext.Designer/Clipboard/DesignerClipboard.cs
new file mode 100644
index 0000000..52e9061
--- /dev/null
+++ b/ModernFormsNext.Designer/Clipboard/DesignerClipboard.cs
@@ -0,0 +1,49 @@
+namespace ModernFormsNext.Designer.Clipboard;
+
+/// <summary>
+/// Stores Designer clipboard content without depending on the runtime or operating-system clipboard.
+/// </summary>
+/// <remarks>
+/// Content is an immutable string payload. Keeping the abstraction data-only allows one Designer
+/// session to copy between open documents without retaining controls, selections, histories, or
+/// host services from the source document.
+/// </remarks>
+internal interface IDesignerClipboard
+{
+    event EventHandler? Changed;
+
+    string? Content { get; }
+
+    void SetContent(string content);
+
+    void Clear();
+}
+
+internal sealed class DesignerClipboard : IDesignerClipboard
+{
+    private string? content;
+
+    public event EventHandler? Changed;
+
+    public string? Content => content;
+
+    public void SetContent(string content)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(content);
+
+        if (string.Equals(this.content, content, StringComparison.Ordinal))
+            return;
+
+        this.content = content;
+        Changed?.Invoke(this, EventArgs.Empty);
+    }
+
+    public void Clear()
+    {
+        if (content is null)
+            return;
+
+        content = null;
+        Changed?.Invoke(this, EventArgs.Empty);
+    }
+}
diff --git a/ModernFormsNext.Designer/Clipboard/DesignerClipboardPayload.cs b/ModernFormsNext.Designer/Clipboard/DesignerClipboardPayload.cs
new file mode 100644
index 0000000..f2742bb
--- /dev/null
+++ b/ModernFormsNext.Designer/Clipboard/DesignerClipboardPayload.cs
@@ -0,0 +1,69 @@
+using System.Text.Json.Serialization;
+using ModernFormsNext.Designing;
+
+namespace ModernFormsNext.Designer.Clipboard;
+
+/// <summary>
+/// Defines the private, versioned data contract stored by the Designer clipboard.
+/// </summary>
+/// <remarks>
+/// These DTOs deliberately mirror only persisted design data. They do not contain runtime
+/// controls, CLR type instances, handles, delegates, dispatchers, histories, or selections.
+/// </remarks>
+internal sealed class DesignerClipboardPayload
+{
+    public const string CurrentFormat = "ModernFormsNext.Designer";
+    public const int CurrentVersion = 1;
+
+    public string? Format { get; set; }
+
+    public int? Version { get; set; }
+
+    public DesignerClipboardNode? Root { get; set; }
+}
+
+internal sealed class DesignerClipboardNode
+{
+    public string? TypeName { get; set; }
+
+    public string? Name { get; set; }
+
+    public int? X { get; set; }
+
+    public int? Y { get; set; }
+
+    public int? Width { get; set; }
+
+    public int? Height { get; set; }
+
+    public DesignerMemberVisibility? MemberVisibility { get; set; }
+
+    public SortedDictionary<string, DesignerClipboardValue>? Properties { get; set; }
+
+    public SortedDictionary<string, string?>? Events { get; set; }
+
+    public List<DesignerClipboardNode>? Children { get; set; }
+}
+
+internal sealed class DesignerClipboardValue
+{
+    public DesignPropertyValueKind? Kind { get; set; }
+
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public string? StringValue { get; set; }
+
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public bool? BooleanValue { get; set; }
+
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public int? Int32Value { get; set; }
+
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public double? DoubleValue { get; set; }
+
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public string? TypeName { get; set; }
+
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public SortedDictionary<string, DesignerClipboardValue>? Properties { get; set; }
+}
diff --git a/ModernFormsNext.Designer/Clipboard/DesignerClipboardSerializer.cs b/ModernFormsNext.Designer/Clipboard/DesignerClipboardSerializer.cs
new file mode 100644
index 0000000..8536fe7
--- /dev/null
+++ b/ModernFormsNext.Designer/Clipboard/DesignerClipboardSerializer.cs
@@ -0,0 +1,415 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using ModernFormsNext.Designing;
+
+namespace ModernFormsNext.Designer.Clipboard;
+
+/// <summary>
+/// Converts a single control subtree to and from the private Designer clipboard format.
+/// </summary>
+internal static class DesignerClipboardSerializer
+{
+    internal const int MaximumContentLength = 4 * 1024 * 1024;
+    internal const int MaximumNodeCount = 10_000;
+    internal const int MaximumTreeDepth = 96;
+
+    private static readonly JsonSerializerOptions Options = CreateOptions();
+
+    public static bool TrySerialize(DesignControlNode node, out string? content, out string? error)
+    {
+        ArgumentNullException.ThrowIfNull(node);
+
+        try
+        {
+            var remainingNodes = MaximumNodeCount;
+            var payload = new DesignerClipboardPayload
+            {
+                Format = DesignerClipboardPayload.CurrentFormat,
+                Version = DesignerClipboardPayload.CurrentVersion,
+                Root = ToClipboardNode(node, depth: 0, ref remainingNodes)
+            };
+            content = JsonSerializer.Serialize(payload, Options);
+            if (content.Length > MaximumContentLength)
+                throw new InvalidOperationException("The selected Designer subtree is too large for the internal clipboard.");
+
+            error = null;
+            return true;
+        }
+        catch (Exception exception) when (exception is ArgumentException
+            or InvalidOperationException
+            or NotSupportedException
+            or JsonException)
+        {
+            content = null;
+            error = $"Cannot copy the selected control: {exception.Message}";
+            return false;
+        }
+    }
+
+    public static bool TryDeserialize(string? content, out DesignControlNode? node, out string? error)
+    {
+        node = null;
+
+        if (string.IsNullOrWhiteSpace(content))
+        {
+            error = "The Designer clipboard is empty.";
+            return false;
+        }
+
+        if (content.Length > MaximumContentLength)
+        {
+            error = "The Designer clipboard payload exceeds the supported size limit.";
+            return false;
+        }
+
+        try
+        {
+            var payload = JsonSerializer.Deserialize<DesignerClipboardPayload>(content, Options)
+                ?? throw new JsonException("The Designer clipboard did not contain a payload.");
+
+            if (!string.Equals(payload.Format, DesignerClipboardPayload.CurrentFormat, StringComparison.Ordinal))
+                throw new JsonException($"Unsupported Designer clipboard format '{payload.Format}'.");
+            if (payload.Version != DesignerClipboardPayload.CurrentVersion)
+                throw new JsonException($"Unsupported Designer clipboard version '{payload.Version}'.");
+            if (payload.Root is null)
+                throw new JsonException("The Designer clipboard payload does not contain a control subtree.");
+
+            var remainingNodes = MaximumNodeCount;
+            node = FromClipboardNode(payload.Root, depth: 0, ref remainingNodes);
+            error = null;
+            return true;
+        }
+        catch (Exception exception) when (exception is ArgumentException
+            or InvalidOperationException
+            or NotSupportedException
+            or JsonException)
+        {
+            error = $"Cannot paste the Designer clipboard payload: {exception.Message}";
+            return false;
+        }
+    }
+
+    private static DesignerClipboardNode ToClipboardNode(
+        DesignControlNode node,
+        int depth,
+        ref int remainingNodes)
+    {
+        EnsureNodeBudget(depth, ref remainingNodes);
+
+        var result = new DesignerClipboardNode
+        {
+            TypeName = node.TypeName,
+            Name = node.Name,
+            X = node.Bounds.X,
+            Y = node.Bounds.Y,
+            Width = node.Bounds.Width,
+            Height = node.Bounds.Height,
+            MemberVisibility = node.MemberVisibility,
+            Properties = new SortedDictionary<string, DesignerClipboardValue>(
+                node.Properties.ToDictionary(
+                    property => property.Key,
+                    property => ToClipboardValue(property.Value),
+                    StringComparer.Ordinal),
+                StringComparer.Ordinal),
+            Events = new SortedDictionary<string, string?>(node.Events, StringComparer.Ordinal),
+            Children = []
+        };
+
+        foreach (var child in node.Children)
+            result.Children!.Add(ToClipboardNode(child, depth + 1, ref remainingNodes));
+
+        return result;
+    }
+
+    private static DesignControlNode FromClipboardNode(
+        DesignerClipboardNode source,
+        int depth,
+        ref int remainingNodes)
+    {
+        EnsureNodeBudget(depth, ref remainingNodes);
+        var typeName = RequireSafeTypeName(source.TypeName, "control type");
+        var name = RequireIdentifier(source.Name, "control name");
+
+        if (source.X is null || source.Y is null || source.Width is null || source.Height is null)
+            throw new JsonException($"Control '{name}' has incomplete bounds.");
+        if (source.Width < 0 || source.Height < 0)
+            throw new JsonException($"Control '{name}' has negative bounds.");
+        if (source.MemberVisibility is null || !Enum.IsDefined(source.MemberVisibility.Value))
+            throw new JsonException($"Control '{name}' has an unsupported member visibility.");
+        if (source.Properties is null || source.Events is null || source.Children is null)
+            throw new JsonException($"Control '{name}' has an incomplete clipboard representation.");
+
+        var node = new DesignControlNode
+        {
+            TypeName = typeName,
+            Name = name,
+            Bounds = new DesignBounds(source.X.Value, source.Y.Value, source.Width.Value, source.Height.Value),
+            MemberVisibility = source.MemberVisibility.Value
+        };
+
+        foreach (var property in source.Properties)
+        {
+            var propertyName = RequireMemberPath(property.Key, "property name");
+            node.Properties[propertyName] = FromClipboardValue(property.Value, propertyName);
+        }
+
+        foreach (var eventBinding in source.Events)
+        {
+            var eventName = RequireIdentifier(eventBinding.Key, "event name");
+            if (!string.IsNullOrWhiteSpace(eventBinding.Value)
+                && !DesignDocumentValidator.IsValidCSharpIdentifier(eventBinding.Value))
+            {
+                throw new JsonException($"Event '{eventName}' has an invalid handler name '{eventBinding.Value}'.");
+            }
+
+            node.Events[eventName] = eventBinding.Value;
+        }
+
+        foreach (var child in source.Children)
+            node.Children.Add(FromClipboardNode(child, depth + 1, ref remainingNodes));
+
+        return node;
+    }
+
+    private static DesignerClipboardValue ToClipboardValue(DesignPropertyValue value)
+    {
+        ArgumentNullException.ThrowIfNull(value);
+        var result = new DesignerClipboardValue { Kind = value.Kind };
+
+        switch (value.Kind)
+        {
+            case DesignPropertyValueKind.Null:
+                if (value.Value is not null)
+                    throw new InvalidOperationException("A null Designer value contains unexpected CLR data.");
+                break;
+            case DesignPropertyValueKind.String:
+                result.StringValue = value.Value as string
+                    ?? throw new InvalidOperationException("A string Designer value does not contain a string.");
+                break;
+            case DesignPropertyValueKind.Boolean:
+                result.BooleanValue = value.Value is bool booleanValue
+                    ? booleanValue
+                    : throw new InvalidOperationException("A Boolean Designer value does not contain a Boolean.");
+                break;
+            case DesignPropertyValueKind.Int32:
+                result.Int32Value = value.Value is int intValue
+                    ? intValue
+                    : throw new InvalidOperationException("An Int32 Designer value does not contain an Int32.");
+                break;
+            case DesignPropertyValueKind.Double:
+                result.DoubleValue = value.Value is double doubleValue
+                    ? doubleValue
+                    : throw new InvalidOperationException("A Double Designer value does not contain a Double.");
+                break;
+            case DesignPropertyValueKind.Enum:
+                result.TypeName = RequireSafeTypeName(value.EnumTypeName, "enum type");
+                result.StringValue = RequireEnumMemberText(
+                    value.Value as string
+                        ?? throw new InvalidOperationException("An enum Designer value does not contain a member name."),
+                    "enum member");
+                break;
+            case DesignPropertyValueKind.Object:
+                result.TypeName = RequireSafeTypeName(value.ObjectTypeName, "object type");
+                result.Properties = new SortedDictionary<string, DesignerClipboardValue>(StringComparer.Ordinal);
+                foreach (var property in value.ObjectProperties
+                    ?? throw new InvalidOperationException("A structured Designer value has no properties."))
+                {
+                    result.Properties[RequireMemberPath(property.Key, "structured property name")] = ToClipboardValue(property.Value);
+                }
+                break;
+            default:
+                throw new NotSupportedException($"Designer value kind '{value.Kind}' is not supported by clipboard version 1.");
+        }
+
+        return result;
+    }
+
+    private static DesignPropertyValue FromClipboardValue(DesignerClipboardValue? value, string path)
+    {
+        if (value?.Kind is null || !Enum.IsDefined(value.Kind.Value))
+            throw new JsonException($"Property '{path}' has an unsupported value kind.");
+
+        EnsureCanonicalValueRepresentation(value, path);
+        return value.Kind.Value switch
+        {
+            DesignPropertyValueKind.Null => DesignPropertyValue.FromNull(),
+            DesignPropertyValueKind.String when value.StringValue is not null => DesignPropertyValue.FromString(value.StringValue),
+            DesignPropertyValueKind.Boolean when value.BooleanValue is not null => DesignPropertyValue.FromBoolean(value.BooleanValue.Value),
+            DesignPropertyValueKind.Int32 when value.Int32Value is not null => DesignPropertyValue.FromInt32(value.Int32Value.Value),
+            DesignPropertyValueKind.Double when value.DoubleValue is not null => DesignPropertyValue.FromDouble(value.DoubleValue.Value),
+            DesignPropertyValueKind.Enum when value.StringValue is not null => DesignPropertyValue.FromEnum(
+                RequireSafeTypeName(value.TypeName, $"enum type for '{path}'"),
+                RequireEnumMemberText(value.StringValue, $"enum member for '{path}'")),
+            DesignPropertyValueKind.Object when value.Properties is not null => DesignPropertyValue.FromStructuredObject(
+                RequireSafeTypeName(value.TypeName, $"object type for '{path}'"),
+                value.Properties.ToDictionary(
+                    property => RequireMemberPath(property.Key, "structured property name"),
+                    property => FromClipboardValue(property.Value, $"{path}.{property.Key}"),
+                    StringComparer.Ordinal)),
+            _ => throw new JsonException($"Property '{path}' has an incomplete value representation for kind '{value.Kind}'.")
+        };
+    }
+
+    private static void EnsureCanonicalValueRepresentation(DesignerClipboardValue value, string path)
+    {
+        var valid = value.Kind switch
+        {
+            DesignPropertyValueKind.Null => value.StringValue is null
+                && value.BooleanValue is null
+                && value.Int32Value is null
+                && value.DoubleValue is null
+                && value.TypeName is null
+                && value.Properties is null,
+            DesignPropertyValueKind.String => value.StringValue is not null
+                && value.BooleanValue is null
+                && value.Int32Value is null
+                && value.DoubleValue is null
+                && value.TypeName is null
+                && value.Properties is null,
+            DesignPropertyValueKind.Boolean => value.StringValue is null
+                && value.BooleanValue is not null
+                && value.Int32Value is null
+                && value.DoubleValue is null
+                && value.TypeName is null
+                && value.Properties is null,
+            DesignPropertyValueKind.Int32 => value.StringValue is null
+                && value.BooleanValue is null
+                && value.Int32Value is not null
+                && value.DoubleValue is null
+                && value.TypeName is null
+                && value.Properties is null,
+            DesignPropertyValueKind.Double => value.StringValue is null
+                && value.BooleanValue is null
+                && value.Int32Value is null
+                && value.DoubleValue is not null
+                && value.TypeName is null
+                && value.Properties is null,
+            DesignPropertyValueKind.Enum => value.StringValue is not null
+                && value.BooleanValue is null
+                && value.Int32Value is null
+                && value.DoubleValue is null
+                && value.TypeName is not null
+                && value.Properties is null,
+            DesignPropertyValueKind.Object => value.StringValue is null
+                && value.BooleanValue is null
+                && value.Int32Value is null
+                && value.DoubleValue is null
+                && value.TypeName is not null
+                && value.Properties is not null,
+            _ => false
+        };
+
+        if (!valid)
+            throw new JsonException($"Property '{path}' has a non-canonical representation for kind '{value.Kind}'.");
+    }
+
+    private static void EnsureNodeBudget(int depth, ref int remainingNodes)
+    {
+        if (depth > MaximumTreeDepth)
+            throw new JsonException($"The Designer clipboard subtree exceeds the supported depth of {MaximumTreeDepth}.");
+        if (--remainingNodes < 0)
+            throw new JsonException($"The Designer clipboard subtree exceeds {MaximumNodeCount} controls.");
+    }
+
+    private static string RequireIdentifier(string? value, string description)
+    {
+        if (string.IsNullOrWhiteSpace(value) || !DesignDocumentValidator.IsValidCSharpIdentifier(value))
+            throw new JsonException($"The clipboard {description} '{value}' is not a valid C# identifier.");
+
+        return value;
+    }
+
+    private static string RequireMemberPath(string? value, string description)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+            throw new JsonException($"The clipboard {description} '{value}' is invalid.");
+
+        var parts = value.Split('.');
+        if (parts.Any(part => string.IsNullOrWhiteSpace(part)
+            || !DesignDocumentValidator.IsValidCSharpIdentifier(part)))
+        {
+            throw new JsonException($"The clipboard {description} '{value}' is invalid.");
+        }
+
+        return value;
+    }
+
+    private static string RequireEnumMemberText(string value, string description)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+            throw new JsonException($"The clipboard {description} is missing.");
+
+        var normalized = value.Trim();
+        if (long.TryParse(normalized, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out _)
+            || ulong.TryParse(normalized, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out _))
+        {
+            return value;
+        }
+
+        var members = normalized.Split(',', StringSplitOptions.TrimEntries);
+        if (members.Length == 0
+            || members.Any(member => string.IsNullOrWhiteSpace(member)
+                || !DesignDocumentValidator.IsValidCSharpIdentifier(member)))
+        {
+            throw new JsonException($"The clipboard {description} '{value}' is invalid.");
+        }
+
+        return value;
+    }
+
+    private static string RequireSafeTypeName(string? value, string description)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+            throw new JsonException($"The clipboard {description} is missing.");
+
+        var normalized = value.StartsWith("global::", StringComparison.Ordinal) ? value[8..] : value;
+        var segments = normalized.Split(['.', '+']);
+        if (normalized.Length > 1024
+            || segments.Any(segment => !IsSafeTypeNameSegment(segment)))
+        {
+            throw new JsonException($"The clipboard {description} '{value}' is invalid.");
+        }
+
+        return value;
+    }
+
+    private static bool IsSafeTypeNameSegment(string segment)
+    {
+        if (string.IsNullOrWhiteSpace(segment))
+            return false;
+
+        var identifier = segment;
+        var genericAritySeparator = segment.IndexOf('`');
+        if (genericAritySeparator >= 0)
+        {
+            if (genericAritySeparator == 0
+                || segment.IndexOf('`', genericAritySeparator + 1) >= 0
+                || !int.TryParse(segment[(genericAritySeparator + 1)..], out var arity)
+                || arity < 1)
+            {
+                return false;
+            }
+
+            identifier = segment[..genericAritySeparator];
+        }
+
+        // Assembly-qualified and constructed generic names can trigger CLR assembly resolution
+        // when another Designer service later inspects the node. Clipboard v1 accepts only the
+        // namespace/nested-type form emitted by the design model and keeps custom controls data-only.
+        return DesignDocumentValidator.IsValidCSharpIdentifier(identifier);
+    }
+
+    private static JsonSerializerOptions CreateOptions()
+    {
+        var options = new JsonSerializerOptions
+        {
+            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+            WriteIndented = false,
+            MaxDepth = MaximumTreeDepth + 16,
+            PropertyNameCaseInsensitive = false,
+            UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow
+        };
+        options.Converters.Add(new JsonStringEnumConverter(JsonNamingPolicy.CamelCase));
+        return options;
+    }
+}
diff --git a/ModernFormsNext.Designer/Layout/DesignerToolbar.cs b/ModernFormsNext.Designer/Layout/DesignerToolbar.cs
index d291f4e..33f9341 100644
--- a/ModernFormsNext.Designer/Layout/DesignerToolbar.cs
+++ b/ModernFormsNext.Designer/Layout/DesignerToolbar.cs
@@ -14,6 +14,10 @@ internal sealed class DesignerToolbar : Panel
     private readonly List<(Button Button, string Key)> localizedButtons = [];
     private Button? undoButton;
     private Button? redoButton;
+    private Button? cutButton;
+    private Button? copyButton;
+    private Button? pasteButton;
+    private Button? duplicateButton;
 
     public DesignerToolbar(DesignerCommandService commands, DesignerSession session, ModernFormsDesignerOptions options)
     {
@@ -23,9 +27,12 @@ public DesignerToolbar(DesignerCommandService commands, DesignerSession session,
         Height = 42;
         Style.BackgroundColor = new SKColor(34, 39, 45);
         CreateButtons();
-        session.Transactions.HistoryChanged += (_, _) => RefreshHistoryButtons();
-        session.DocumentTabsChanged += (_, _) => RefreshHistoryButtons();
-        RefreshHistoryButtons();
+        session.Transactions.HistoryChanged += (_, _) => RefreshCommandButtons();
+        session.DocumentTabsChanged += (_, _) => RefreshCommandButtons();
+        session.DocumentChanged += (_, _) => RefreshCommandButtons();
+        session.SelectionChanged += (_, _) => RefreshCommandButtons();
+        session.ClipboardChanged += (_, _) => RefreshCommandButtons();
+        RefreshCommandButtons();
     }
 
     protected override void OnPaint(PaintEventArgs e)
@@ -53,6 +60,14 @@ private void CreateButtons()
         x += 84;
         redoButton = AddButton("Redo", x, () => commands.Redo(), 76);
         x += 84;
+        cutButton = AddButton("Cut", x, () => commands.Cut(), 62);
+        x += 70;
+        copyButton = AddButton("Copy", x, () => commands.Copy(), 68);
+        x += 76;
+        pasteButton = AddButton("Paste", x, () => commands.Paste(), 70);
+        x += 78;
+        duplicateButton = AddButton("Duplicate", x, () => commands.Duplicate(), 92);
+        x += 100;
         AddButton("AddPanel", x, commands.AddPanel, 100);
         x += 108;
         AddButton("AddButton", x, commands.AddButton, 105);
@@ -73,7 +88,7 @@ public void RefreshTexts()
         foreach (var (button, key) in localizedButtons)
             button.Text = T(key);
 
-        RefreshHistoryButtons();
+        RefreshCommandButtons();
         Invalidate();
     }
 
@@ -97,12 +112,20 @@ private Button AddButton(string key, int left, Action action, int width)
         return button;
     }
 
-    private void RefreshHistoryButtons()
+    private void RefreshCommandButtons()
     {
         if (undoButton is not null)
             undoButton.Enabled = session.Transactions.CanUndo;
         if (redoButton is not null)
             redoButton.Enabled = session.Transactions.CanRedo;
+        if (cutButton is not null)
+            cutButton.Enabled = commands.CanCut;
+        if (copyButton is not null)
+            copyButton.Enabled = commands.CanCopy;
+        if (pasteButton is not null)
+            pasteButton.Enabled = commands.CanPaste;
+        if (duplicateButton is not null)
+            duplicateButton.Enabled = commands.CanDuplicate;
 
         Invalidate();
     }
diff --git a/ModernFormsNext.Designer/Localization/DesignerText.cs b/ModernFormsNext.Designer/Localization/DesignerText.cs
index 031ef71..b4cb85e 100644
--- a/ModernFormsNext.Designer/Localization/DesignerText.cs
+++ b/ModernFormsNext.Designer/Localization/DesignerText.cs
@@ -23,6 +23,10 @@ public static class DesignerText
         ["Open"] = "Open",
         ["Undo"] = "Undo",
         ["Redo"] = "Redo",
+        ["Cut"] = "Cut",
+        ["Copy"] = "Copy",
+        ["Paste"] = "Paste",
+        ["Duplicate"] = "Duplicate",
         ["AddPanel"] = "Add Panel",
         ["AddButton"] = "Add Button",
         ["AddLabel"] = "Add Label",
@@ -71,6 +75,10 @@ public static class DesignerText
         ["Open"] = "Otworz",
         ["Undo"] = "Cofnij",
         ["Redo"] = "Ponow",
+        ["Cut"] = "Wytnij",
+        ["Copy"] = "Kopiuj",
+        ["Paste"] = "Wklej",
+        ["Duplicate"] = "Duplikuj",
         ["AddPanel"] = "Dodaj panel",
         ["AddButton"] = "Dodaj przycisk",
         ["AddLabel"] = "Dodaj etykiete",
diff --git a/ModernFormsNext.Designer/ModernFormsDesignerShell.cs b/ModernFormsNext.Designer/ModernFormsDesignerShell.cs
index bc2048e..0971276 100644
--- a/ModernFormsNext.Designer/ModernFormsDesignerShell.cs
+++ b/ModernFormsNext.Designer/ModernFormsDesignerShell.cs
@@ -154,6 +154,7 @@ public bool ProcessDesignerShortcut(KeyEventArgs e)
                 (Keys.Y, false) => Session.Transactions.CanRedo && Session.Transactions.Redo(),
                 (Keys.Z, true) => Session.Transactions.CanRedo && Session.Transactions.Redo(),
                 (Keys.C, false) => Session.CopySelectedNode(),
+                (Keys.X, false) => Session.CutSelectedNode(),
                 (Keys.V, false) => Session.PasteCopiedNode(),
                 (Keys.D, false) => Session.DuplicateSelectedNode(),
                 _ => false
diff --git a/ModernFormsNext.Designer/Services/DesignerCommandService.cs b/ModernFormsNext.Designer/Services/DesignerCommandService.cs
index a757a94..787bdbc 100644
--- a/ModernFormsNext.Designer/Services/DesignerCommandService.cs
+++ b/ModernFormsNext.Designer/Services/DesignerCommandService.cs
@@ -68,6 +68,22 @@ public async void OpenDesignDocument(Form? owner)
 
     public bool Redo() => state.Transactions.Redo();
 
+    public bool Cut() => state.CutSelectedNode();
+
+    public bool Copy() => state.CopySelectedNode();
+
+    public bool Paste() => state.PasteCopiedNode();
+
+    public bool Duplicate() => state.DuplicateSelectedNode();
+
+    public bool CanCut => state.CanCutSelectedNode;
+
+    public bool CanCopy => state.CanCopySelectedNode;
+
+    public bool CanPaste => state.CanPasteCopiedNode;
+
+    public bool CanDuplicate => state.CanDuplicateSelectedNode;
+
     public void AddControlType(string typeName)
     {
         try
diff --git a/ModernFormsNext.Designer/Services/DesignerSession.cs b/ModernFormsNext.Designer/Services/DesignerSession.cs
index 71d18e3..3daf491 100644
--- a/ModernFormsNext.Designer/Services/DesignerSession.cs
+++ b/ModernFormsNext.Designer/Services/DesignerSession.cs
@@ -1,4 +1,5 @@
 using ModernFormsNext;
+using ModernFormsNext.Designer.Clipboard;
 using ModernFormsNext.Designer.History;
 using ModernFormsNext.Designer.Properties;
 using ModernFormsNext.Designer.Surface;
@@ -25,7 +26,7 @@ public sealed class DesignerSession : IDisposable
     private readonly IDesignerHostEnvironment? environment;
     private readonly IReadOnlyList<DesignerProjectUserControlInfo> projectUserControls;
     private readonly DesignerHistory detachedHistory;
-    private DesignControlNode? clipboardNode;
+    private readonly IDesignerClipboard clipboard;
     private DesignerOpenDocument? activeDocument;
     private int historyLimit;
     private bool disposed;
@@ -53,11 +54,21 @@ public DesignerSession(
         IDesignerHostEnvironment? environment,
         DesignerControlRenderMode initialRenderMode,
         int historyLimit)
+        : this(environment, initialRenderMode, historyLimit, new DesignerClipboard())
+    {
+    }
+
+    internal DesignerSession(
+        IDesignerHostEnvironment? environment,
+        DesignerControlRenderMode initialRenderMode,
+        int historyLimit,
+        IDesignerClipboard clipboard)
     {
         if (historyLimit < 1)
             throw new ArgumentOutOfRangeException(nameof(historyLimit), "Designer history limit must be at least one entry.");
 
         this.environment = environment;
+        this.clipboard = clipboard ?? throw new ArgumentNullException(nameof(clipboard));
         this.historyLimit = historyLimit;
         detachedHistory = new DesignerHistory(historyLimit, initiallyDirty: false);
         projectUserControls = DesignerProjectUserControlDiscovery.Discover(environment?.CurrentProjectPath);
@@ -65,6 +76,7 @@ public DesignerSession(
         Host = new DesignerHost(CreateDefaultDocument());
         Transactions = new DesignerTransactionManager(this);
         Host.Selection.SelectionChanged += HostSelection_SelectionChanged;
+        clipboard.Changed += Clipboard_Changed;
         Log("Designer session ready.");
         Log($"Designer diagnostics log: {DesignerDiagnosticLog.Path}");
         Log($"Initial designer surface render mode: {ControlRenderMode}.");
@@ -80,6 +92,8 @@ public DesignerSession(
     /// </summary>
     public event EventHandler? SelectionChanged;
 
+    internal event EventHandler? ClipboardChanged;
+
     /// <summary>
     /// Occurs when the output log changes.
     /// </summary>
@@ -163,6 +177,8 @@ internal IReadOnlyList<DesignAnimationDefinitionDescriptor> AnimationDefinitions
 
     internal int HistoryLimit => historyLimit;
 
+    internal IDesignerClipboard Clipboard => clipboard;
+
     /// <summary>
     /// Replaces the active document and resets the dirty state.
     /// </summary>
@@ -835,18 +851,68 @@ public bool DeleteSelectedNode()
     /// <summary>
     /// Copies the currently selected control node into the designer clipboard.
     /// </summary>
+    /// <remarks>
+    /// Copy stores a detached, versioned data payload. It does not mutate the document, change the
+    /// dirty state, create history, or retain the selected live control tree.
+    /// </remarks>
     /// <returns><see langword="true"/> when a control was copied; otherwise, <see langword="false"/>.</returns>
     public bool CopySelectedNode()
     {
         ThrowIfDisposed();
-        if (SelectedNode is null)
+        if (!TryGetClipboardSource(out var source, out var error))
         {
-            Log("No control is selected to copy.");
+            Log(error!);
             return false;
         }
 
-        clipboardNode = CloneNode(SelectedNode, preserveName: true, usedNames: new HashSet<string>(StringComparer.OrdinalIgnoreCase));
-        Log($"Copied {SelectedNode.Name}.");
+        if (!DesignerClipboardSerializer.TrySerialize(source, out var content, out error))
+        {
+            Log(error!);
+            return false;
+        }
+
+        clipboard.SetContent(content!);
+        Log($"Copied {source.Name}.");
+        return true;
+    }
+
+    /// <summary>
+    /// Cuts the currently selected control subtree into the Designer clipboard.
+    /// </summary>
+    /// <remarks>
+    /// The detached payload is prepared before the model changes. Removing the subtree and updating
+    /// selection are then committed as exactly one undo unit through the shared transaction manager.
+    /// </remarks>
+    /// <returns><see langword="true"/> when a control was cut; otherwise, <see langword="false"/>.</returns>
+    public bool CutSelectedNode()
+    {
+        ThrowIfDisposed();
+        if (!TryGetClipboardSource(out var source, out var error))
+        {
+            Log(error!);
+            return false;
+        }
+
+        if (!TryFindNodeWithParent(source, Document.Controls, parent: null, out var parent, out var collection, out var index))
+        {
+            Log($"Cannot cut {source.Name}: the node is not in the active document.");
+            return false;
+        }
+
+        if (!DesignerClipboardSerializer.TrySerialize(source, out var content, out error))
+        {
+            Log(error!);
+            return false;
+        }
+
+        // Store the data-only copy first. If a clipboard observer fails, no document mutation has
+        // begun; the operation safely degrades to Copy instead of losing the selected subtree.
+        clipboard.SetContent(content!);
+        using var transaction = Transactions.Begin($"Cut {source.Name}");
+        Transactions.ExecuteChange(new DesignerTreeRemoveChange(collection, source, index));
+        Host.Selection.Select(parent);
+        transaction.Commit();
+        Log($"Cut {source.Name}.");
         return true;
     }
 
@@ -857,22 +923,31 @@ public bool CopySelectedNode()
     public bool DuplicateSelectedNode()
     {
         ThrowIfDisposed();
-        if (SelectedNode is null)
+        if (!TryGetClipboardSource(out var source, out var error))
+        {
+            Log(error!);
+            return false;
+        }
+
+        if (!TryFindNodeWithParent(source, Document.Controls, parent: null, out var parent, out var collection, out var index))
         {
-            Log("No control is selected to duplicate.");
+            Log($"Cannot duplicate {source.Name}: the node is not in the active document.");
             return false;
         }
 
-        if (!TryFindNodeWithParent(SelectedNode, Document.Controls, parent: null, out _, out var collection, out var index))
+        if (!TryCreateDetachedClone(source, out var clone, out error)
+            || !TryPrepareInsertion(clone!, new DesignerPasteTarget(collection, parent, parent?.Name ?? Document.FormName, index + 1), out error))
+        {
+            Log(error!);
             return false;
+        }
 
-        var sourceName = SelectedNode.Name;
-        var clone = CloneForPaste(SelectedNode, offsetRoot: true);
-        using var transaction = Transactions.Begin($"Duplicate {sourceName}");
-        Transactions.ExecuteChange(new DesignerTreeInsertChange(collection, clone, index + 1));
-        Host.Selection.Select(clone);
+        var duplicate = clone!;
+        using var transaction = Transactions.Begin($"Duplicate {source.Name}");
+        Transactions.ExecuteChange(new DesignerTreeInsertChange(collection, duplicate, index + 1));
+        Host.Selection.Select(duplicate);
         transaction.Commit();
-        Log($"Duplicated {sourceName} as {clone.Name}.");
+        Log($"Duplicated {source.Name} as {duplicate.Name}.");
         return true;
     }
 
@@ -883,29 +958,64 @@ public bool DuplicateSelectedNode()
     public bool PasteCopiedNode()
     {
         ThrowIfDisposed();
-        if (clipboardNode is null)
+        if (!DesignerClipboardSerializer.TryDeserialize(clipboard.Content, out var clone, out var error))
         {
-            Log("No copied control is available to paste.");
+            Log(error!);
             return false;
         }
 
-        var clone = CloneForPaste(clipboardNode, offsetRoot: true);
-
-        if (!DesignerControlReferenceGuard.CanReferenceTree(Document, clone, CurrentProjectPath, out var error))
+        if (!TryResolvePasteTarget(clone!, out var target, out error)
+            || !TryPrepareInsertion(clone!, target, out error))
         {
-            Log(error ?? "The copied control would create an invalid design reference.");
+            Log(error!);
             return false;
         }
 
-        var destination = GetPasteDestination(out var targetName);
-        using var transaction = Transactions.Begin($"Paste {clone.Name}");
-        Transactions.ExecuteChange(new DesignerTreeInsertChange(destination, clone, destination.Count));
-        Host.Selection.Select(clone);
+        var pasted = clone!;
+        using var transaction = Transactions.Begin($"Paste {pasted.Name}");
+        Transactions.ExecuteChange(new DesignerTreeInsertChange(target.Collection, pasted, target.Index));
+        Host.Selection.Select(pasted);
         transaction.Commit();
-        Log($"Pasted {clone.Name} into {targetName}.");
+        Log($"Pasted {pasted.Name} into {target.DisplayName}.");
         return true;
     }
 
+    internal bool CanCopySelectedNode => CanUseSelectedNodeAsClipboardSource();
+
+    internal bool CanCutSelectedNode => CanUseSelectedNodeAsClipboardSource();
+
+    internal bool CanDuplicateSelectedNode
+    {
+        get
+        {
+            if (!CanUseSelectedNodeAsClipboardSource()
+                || SelectedNode is not { } source
+                || !TryFindNodeWithParent(source, Document.Controls, parent: null, out var parent, out var collection, out var index)
+                || !TryCreateDetachedClone(source, out var clone, out _))
+            {
+                return false;
+            }
+
+            return CanInsertNode(clone!, new DesignerPasteTarget(collection, parent, parent?.Name ?? Document.FormName, index + 1), out _);
+        }
+    }
+
+    internal bool CanPasteCopiedNode
+    {
+        get
+        {
+            if (disposed
+                || !DesignerClipboardSerializer.TryDeserialize(clipboard.Content, out var node, out _)
+                || !TryResolvePasteTarget(node!, out var target, out _))
+            {
+                return false;
+            }
+
+            return CanInsertNode(node!, target, out _)
+                && DesignerControlReferenceGuard.CanReferenceTree(Document, node!, CurrentProjectPath, out _);
+        }
+    }
+
     private bool MoveSelectedNodeWithinCurrentContainer(int delta)
     {
         ThrowIfDisposed();
@@ -1592,22 +1702,63 @@ private static bool ContainsDescendant(DesignControlNode root, DesignControlNode
         return false;
     }
 
-    private DesignControlCollection GetPasteDestination(out string targetName)
+    private bool TryResolvePasteTarget(
+        DesignControlNode clipboardRoot,
+        out DesignerPasteTarget target,
+        out string? error)
     {
         if (IsContainerNode(SelectedNode))
         {
-            return GetChildCollectionForNewControl(SelectedNode, out targetName) ?? SelectedNode!.Children;
+            var selectedContainer = SelectedNode!;
+            DesignControlCollection? collection;
+
+            if (DesignerSpecialContainers.IsTabControl(selectedContainer))
+            {
+                collection = DesignerSpecialContainers.IsTabPage(clipboardRoot)
+                    ? selectedContainer.Children
+                    : DesignerSpecialContainers.GetSelectedTabPage(selectedContainer)?.Children;
+            }
+            else if (DesignerSpecialContainers.IsSplitContainer(selectedContainer))
+                collection = DesignerSpecialContainers.GetPanel1(selectedContainer)?.Children;
+            else
+                collection = selectedContainer.Children;
+
+            if (collection is null || !TryFindParentForCollection(collection, out var actualParent))
+            {
+                target = default;
+                error = $"Cannot paste into {selectedContainer.Name}: its structural child container is unavailable.";
+                return false;
+            }
+
+            target = new DesignerPasteTarget(
+                collection,
+                actualParent,
+                actualParent is null ? Document.FormName : DesignerSpecialContainers.GetOutlineName(actualParent),
+                collection.Count);
+            return CanInsertNode(clipboardRoot, target, out error);
         }
 
-        if (SelectedNode is not null
-            && TryFindNodeWithParent(SelectedNode, Document.Controls, parent: null, out var parent, out var collection, out _))
+        if (SelectedNode is not null)
         {
-            targetName = parent?.Name ?? Document.FormName;
-            return collection;
+            if (!TryFindNodeWithParent(
+                SelectedNode,
+                Document.Controls,
+                parent: null,
+                out var parent,
+                out var collection,
+                out _))
+            {
+                target = default;
+                error = "The selected paste target is not attached to the active document.";
+                return false;
+            }
+
+            target = new DesignerPasteTarget(collection, parent, parent?.Name ?? Document.FormName, collection.Count);
+            return CanInsertNode(clipboardRoot, target, out error);
         }
 
-        targetName = Document.FormName;
-        return Document.Controls;
+        target = new DesignerPasteTarget(Document.Controls, Parent: null, Document.FormName, Document.Controls.Count);
+        return CanInsertNode(clipboardRoot, target, out error);
     }
 
     private DesignControlCollection? GetChildCollectionForNewControl(DesignControlNode? parent, out string targetName)
@@ -1695,49 +1846,155 @@ private static void AssignTableLayoutPositionFromPoint(
         DesignerSpecialContainers.SetInt(node, DesignerSpecialContainers.TableRowSpanPropertyName, 1);
     }
 
-    private DesignControlNode CloneForPaste(DesignControlNode source, bool offsetRoot)
+    private bool CanUseSelectedNodeAsClipboardSource()
+        => !disposed
+        && SelectedNode is { } selected
+        && !DesignerSpecialContainers.IsSpecialGeneratedPart(selected)
+        && TryFindNode(selected, out _, out _);
+
+    private bool TryGetClipboardSource(out DesignControlNode source, out string? error)
     {
-        var usedNames = GetUsedControlNames();
-        var clone = CloneNode(source, preserveName: false, usedNames);
+        if (SelectedNode is null)
+        {
+            source = null!;
+            error = "The Form or UserControl design root cannot be copied as a child control.";
+            return false;
+        }
+
+        source = SelectedNode;
+        if (DesignerSpecialContainers.IsSpecialGeneratedPart(source))
+        {
+            error = $"{DesignerSpecialContainers.GetOutlineName(source)} is structural SplitContainer data and cannot be copied independently.";
+            return false;
+        }
 
-        if (offsetRoot)
+        if (!TryFindNode(source, out _, out _))
         {
-            clone.Bounds = new DesignBounds(
-                clone.Bounds.X + 16,
-                clone.Bounds.Y + 16,
-                clone.Bounds.Width,
-                clone.Bounds.Height);
+            error = $"Cannot copy {source.Name}: the node is not in the active document.";
+            return false;
         }
 
-        return clone;
+        error = null;
+        return true;
     }
 
-    private DesignControlNode CloneNode(
+    private bool TryCreateDetachedClone(
         DesignControlNode source,
-        bool preserveName,
-        HashSet<string> usedNames)
+        out DesignControlNode? clone,
+        out string? error)
     {
-        var clone = new DesignControlNode
-        {
-            TypeName = source.TypeName,
-            Name = preserveName ? source.Name : CreateUniqueControlName(source.Name, source.TypeName, usedNames),
-            Bounds = source.Bounds,
-            MemberVisibility = source.MemberVisibility,
-            Properties = new SortedDictionary<string, DesignPropertyValue>(
-                source.Properties.ToDictionary(property => property.Key, property => ClonePropertyValue(property.Value), StringComparer.Ordinal),
-                StringComparer.Ordinal),
-            Events = new SortedDictionary<string, string?>(
-                source.Events.ToDictionary(eventBinding => eventBinding.Key, eventBinding => eventBinding.Value, StringComparer.Ordinal),
-                StringComparer.Ordinal)
-        };
+        if (!DesignerClipboardSerializer.TrySerialize(source, out var content, out error))
+        {
+            clone = null;
+            return false;
+        }
+
+        return DesignerClipboardSerializer.TryDeserialize(content, out clone, out error);
+    }
+
+    private bool TryPrepareInsertion(
+        DesignControlNode node,
+        DesignerPasteTarget target,
+        out string? error)
+    {
+        if (!CanInsertNode(node, target, out error))
+            return false;
+
+        if (!DesignerControlReferenceGuard.CanReferenceTree(Document, node, CurrentProjectPath, out error))
+            return false;
+
+        var usedNames = GetUsedControlNames();
+        RemapClipboardNames(node, parent: null, usedNames);
+        ApplyClipboardPositioning(node, target.Parent);
+        return true;
+    }
+
+    private bool CanInsertNode(
+        DesignControlNode node,
+        DesignerPasteTarget target,
+        out string? error)
+    {
+        if (DesignerSpecialContainers.IsSpecialGeneratedPart(node))
+        {
+            error = "SplitContainer panel nodes are structural Designer data and cannot be pasted independently.";
+            return false;
+        }
+
+        if (target.Parent is not null && !IsContainerNode(target.Parent))
+        {
+            error = $"Cannot paste into {target.DisplayName}: the target does not accept child controls.";
+            return false;
+        }
+
+        if (DesignerSpecialContainers.IsTabPage(node)
+            && (target.Parent is null || !DesignerSpecialContainers.IsTabControl(target.Parent)))
+        {
+            error = "A TabPage can only be duplicated inside its owning TabControl.";
+            return false;
+        }
 
-        if (!preserveName)
-            usedNames.Add(clone.Name);
+        if (target.Parent is not null
+            && DesignerSpecialContainers.IsTabControl(target.Parent)
+            && !DesignerSpecialContainers.IsTabPage(node))
+        {
+            error = "Only TabPage nodes can be direct children of a TabControl.";
+            return false;
+        }
+
+        if (target.Parent is not null && DesignerSpecialContainers.IsSplitContainer(target.Parent))
+        {
+            error = "Controls must be pasted into a SplitContainer panel rather than directly into the SplitContainer.";
+            return false;
+        }
+
+        error = null;
+        return true;
+    }
 
-        foreach (var child in source.Children)
-            clone.Children.Add(CloneNode(child, preserveName, usedNames));
+    private void ApplyClipboardPositioning(DesignControlNode node, DesignControlNode? parent)
+    {
+        if (parent is not null && DesignerSpecialContainers.IsTableLayoutPanel(parent))
+        {
+            AssignDefaultTableLayoutPosition(node, parent);
+            return;
+        }
+
+        // Flow, table, and tab containers own child placement. Docked controls likewise derive
+        // their final position from layout, so applying a visual nudge would only persist noise.
+        if (parent is not null && PreservesSequentialChildOrder(parent))
+            return;
+        if (DesignerSpecialContainers.GetEnum(node, "Dock", DockStyle.None) != DockStyle.None)
+            return;
 
-        return clone;
+        node.Bounds = new DesignBounds(
+            node.Bounds.X + 16,
+            node.Bounds.Y + 16,
+            node.Bounds.Width,
+            node.Bounds.Height);
+    }
+
+    private void RemapClipboardNames(
+        DesignControlNode node,
+        DesignControlNode? parent,
+        HashSet<string> usedNames)
+    {
+        if (parent is not null
+            && DesignerSpecialContainers.IsSplitContainer(parent)
+            && DesignerSpecialContainers.IsSpecialGeneratedPart(node))
+        {
+            var panelNumber = DesignerSpecialContainers.IsSplitPanel1(node) ? 1 : 2;
+            node.Name = ReservePreferredName($"{parent.Name}Panel{panelNumber}", node.TypeName, usedNames);
+            node.Properties[DesignNodeRoleNames.DisplayNamePropertyName] =
+                DesignPropertyValue.FromString($"{parent.Name}.Panel{panelNumber}");
+        }
+        else
+        {
+            node.Name = CreateUniqueControlName(node.Name, node.TypeName, usedNames);
+            usedNames.Add(node.Name);
+        }
+
+        foreach (var child in node.Children)
+            RemapClipboardNames(child, node, usedNames);
     }
 
     private HashSet<string> GetUsedControlNames()
@@ -1746,23 +2003,23 @@ private HashSet<string> GetUsedControlNames()
             .Where(name => !string.IsNullOrWhiteSpace(name))
             .ToHashSet(StringComparer.OrdinalIgnoreCase);
 
-    private static DesignPropertyValue ClonePropertyValue(DesignPropertyValue value)
-        => value.Kind == DesignPropertyValueKind.Object && value.ObjectProperties is not null
-            ? DesignPropertyValue.FromStructuredObject(
-                value.ObjectTypeName ?? "System.Object",
-                value.ObjectProperties.ToDictionary(
-                    property => property.Key,
-                    property => ClonePropertyValue(property.Value),
-                    StringComparer.Ordinal))
-            : new DesignPropertyValue(value.Kind, value.Value, value.EnumTypeName, value.ObjectTypeName, value.ObjectProperties);
-
     private static string CreateUniqueControlName(string currentName, string typeName, HashSet<string> usedNames)
     {
-        var baseName = SanitizeIdentifierBase(string.IsNullOrWhiteSpace(currentName)
-            ? char.ToLowerInvariant(typeName[0]) + typeName[1..]
+        var fallbackTypeName = GetShortTypeName(typeName);
+        var sanitized = SanitizeIdentifierBase(string.IsNullOrWhiteSpace(currentName)
+            ? char.ToLowerInvariant(fallbackTypeName[0]) + fallbackTypeName[1..]
             : currentName);
+        var digitStart = sanitized.Length;
+        while (digitStart > 0 && char.IsDigit(sanitized[digitStart - 1]))
+            digitStart--;
 
-        for (var suffix = 1; suffix < int.MaxValue; suffix++)
+        var baseName = digitStart == 0 ? "control" : sanitized[..digitStart];
+        var firstSuffix = digitStart < sanitized.Length
+            && int.TryParse(sanitized[digitStart..], out var existingSuffix)
+                ? Math.Max(1, existingSuffix + 1)
+                : 1;
+
+        for (var suffix = firstSuffix; suffix < int.MaxValue; suffix++)
         {
             var candidate = $"{baseName}{suffix}";
 
@@ -1773,6 +2030,20 @@ private static string CreateUniqueControlName(string currentName, string typeNam
         throw new InvalidOperationException($"Cannot create a unique designer name for '{currentName}'.");
     }
 
+    private static string ReservePreferredName(string preferredName, string typeName, HashSet<string> usedNames)
+    {
+        var sanitized = SanitizeIdentifierBase(preferredName);
+        if (!usedNames.Contains(sanitized))
+        {
+            usedNames.Add(sanitized);
+            return sanitized;
+        }
+
+        var unique = CreateUniqueControlName(sanitized, typeName, usedNames);
+        usedNames.Add(unique);
+        return unique;
+    }
+
     private static string SanitizeIdentifierBase(string value)
     {
         var text = string.IsNullOrWhiteSpace(value) ? "control" : value.Trim();
@@ -1902,15 +2173,17 @@ public void Dispose()
 
         Transactions.ReleaseObservers();
         Host.Selection.SelectionChanged -= HostSelection_SelectionChanged;
+        clipboard.Changed -= Clipboard_Changed;
         detachedHistory.Clear(preserveDirtyState: false);
         foreach (var document in openDocuments)
             document.History.Clear(preserveDirtyState: false);
 
         openDocuments.Clear();
-        clipboardNode = null;
+        clipboard.Clear();
         activeDocument = null;
         DocumentChanged = null;
         SelectionChanged = null;
+        ClipboardChanged = null;
         OutputChanged = null;
         PointerPositionChanged = null;
         SettingsChanged = null;
@@ -1933,6 +2206,15 @@ private void HostSelection_SelectionChanged(object? sender, EventArgs e)
         SelectionChanged?.Invoke(this, EventArgs.Empty);
     }
 
+    private void Clipboard_Changed(object? sender, EventArgs e)
+        => ClipboardChanged?.Invoke(this, EventArgs.Empty);
+
+    private readonly record struct DesignerPasteTarget(
+        DesignControlCollection Collection,
+        DesignControlNode? Parent,
+        string DisplayName,
+        int Index);
+
     private void ThrowIfDisposed()
         => ObjectDisposedException.ThrowIf(disposed, this);
 }
diff --git a/ModernFormsNext.Designer/Surface/DesignerSurface.cs b/ModernFormsNext.Designer/Surface/DesignerSurface.cs
index d51bcfc..41b0d35 100644
--- a/ModernFormsNext.Designer/Surface/DesignerSurface.cs
+++ b/ModernFormsNext.Designer/Surface/DesignerSurface.cs
@@ -60,6 +60,13 @@ protected override void OnKeyDown(KeyEventArgs e)
             return;
         }
 
+        if (e.KeyCode == Keys.X)
+        {
+            e.Handled = state.CutSelectedNode();
+            Invalidate();
+            return;
+        }
+
         if (e.KeyCode == Keys.V)
         {
             e.Handled = state.PasteCopiedNode();
diff --git a/docs-site/toc.yml b/docs-site/toc.yml
index f1baa6b..0492334 100644
--- a/docs-site/toc.yml
+++ b/docs-site/toc.yml
@@ -8,6 +8,8 @@
   href: content/docs/installation.md
 - name: Designer transactions and undo
   href: content/docs/designer-transactions-and-undo.md
+- name: Designer copy and paste
+  href: content/docs/designer-copy-paste.md
 - name: Samples
   href: content/docs/samples.md
 - name: Headless testing
diff --git a/docs/designer-architecture.md b/docs/designer-architecture.md
index 3c8b048..4bcad3d 100644
--- a/docs/designer-architecture.md
+++ b/docs/designer-architecture.md
@@ -287,9 +287,12 @@ overwriting the `.mfdesign` document.
   ([#35](https://github.com/ProGraMajster/ModernFormsNext/issues/35)) and the complete
   smart-guide/equal-spacing/baseline workflow
   ([#36](https://github.com/ProGraMajster/ModernFormsNext/issues/36)) remain separate work.
-- Copy, paste, and duplicate exist for an in-session single-control workflow and participate in
-  Designer history. Cut, a system clipboard contract, and complete cross-document behavior remain in
-  [#34](https://github.com/ProGraMajster/ModernFormsNext/issues/34).
+- Detached, versioned Copy/Cut/Paste/Duplicate supports a safe in-session single-control workflow,
+  including documents open in the same Designer session, and participates atomically in Designer
+  history. See [Designer copy and paste](designer-copy-paste.md). Multi-selection
+  ([#35](https://github.com/ProGraMajster/ModernFormsNext/issues/35)) and an operating-system
+  clipboard contract ([#57](https://github.com/ProGraMajster/ModernFormsNext/issues/57)) remain
+  separate work.
 - The Events view persists bindings and can generate a handler method. Default-event double-click,
   compatible-method selection, robust navigation, and rename diagnostics remain in
   [#37](https://github.com/ProGraMajster/ModernFormsNext/issues/37).
diff --git a/docs/designer-copy-paste.md b/docs/designer-copy-paste.md
new file mode 100644
index 0000000..c5dddc4
--- /dev/null
+++ b/docs/designer-copy-paste.md
@@ -0,0 +1,115 @@
+# Designer copy, cut, paste, and duplicate
+
+The ModernFormsNext Designer supports detached, in-session editing of one selected control subtree.
+Copy, Cut, Paste, and Duplicate operate on the design model and reuse the same typed transaction
+manager as all other authored Designer changes. They do not introduce a second mutation or undo
+system.
+
+## Commands and history
+
+| Command | Shortcut | Model effect | History effect |
+| --- | --- | --- | --- |
+| Copy | `Ctrl+C` | Stores a detached subtree; the document is unchanged. | None; dirty state and save revision are unchanged. |
+| Cut | `Ctrl+X` | Stores the subtree, then removes it. | Exactly one undo unit. |
+| Paste | `Ctrl+V` | Validates and inserts a new subtree. | Exactly one undo unit. |
+| Duplicate | `Ctrl+D` | Creates and inserts a detached copy next to the selected node. | Exactly one undo unit; the clipboard is unchanged. |
+
+Undo and redo restore the tree, selected node, dirty state, generated-code input, Document Outline,
+Property Grid, and Designer surface through the normal transaction notifications. Copy remains
+available only for an attached control node. The Form or UserControl design root and generated
+`SplitContainer` panel nodes cannot be copied as independent child controls.
+
+The shell leaves `Ctrl+C`, `Ctrl+X`, `Ctrl+V`, and `Ctrl+D` unhandled while a Property Grid value
+editor is active. The focused text editor therefore keeps its normal text-selection clipboard
+semantics instead of mutating the selected Designer control.
+
+## Private versioned payload
+
+The internal clipboard stores deterministic JSON with format identifier `ModernFormsNext.Designer`
+and version `1`. The payload contains only persisted design data:
+
+- the root control and ordered descendant tree;
+- type and control names, bounds, and member visibility;
+- sorted property values and event-handler names;
+- null, string, Boolean, `Int32`, `Double`, enum, and recursively structured property values.
+
+This is a private Designer interchange contract, not `.mfdesign` and not a public serialization API.
+It deliberately contains no live `Control` or `DesignControlNode` reference, runtime handle,
+selection, history, dispatcher, delegate, event subscription, or project service. Deserialization
+does not resolve types, load assemblies, construct controls, or execute project code. It uses
+`System.Text.Json`; unsafe general object serialization such as `BinaryFormatter` is not used.
+
+Before any transaction starts, the reader verifies the exact format and version, required fields,
+known JSON members, C# identifiers, safe non-assembly-qualified type-name text, canonical property
+representations, non-negative sizes, and resource bounds. Payloads larger than 4 MiB,
+deeper than 96 levels, or containing more than 10,000 controls are rejected. Empty, corrupt,
+unsupported, incomplete, ambiguous, or malicious payloads leave the model, selection, history, and
+dirty state unchanged.
+
+The payload is a tree only: it has no object IDs, back-references, or parent links, so a serialized
+self-cycle cannot be expressed. Duplicate legacy control names are accepted as detached data and
+are remapped to distinct document-wide names before insertion. Arrays, assembly-qualified type
+names, constructed generic type text, and non-canonical collection/value representations are not
+part of clipboard version 1.
+
+The clipboard belongs to one `DesignerSession`. It therefore works between documents open in the
+same session and remains valid after the source document is closed, but it is not persisted into
+`.mfdesign` and does not use the operating-system clipboard. Closing the Designer session clears it.
+
+## Paste target policy
+
+The insertion target is resolved before mutation:
+
+1. When the selected node is a container, Paste inserts inside that container.
+2. When the selected node is a leaf, Paste inserts into the selected node's parent collection.
+3. When the design root is selected, Paste inserts into the root control collection.
+4. An unattached, structural, or incompatible target is rejected without history.
+
+`TabControl` and `SplitContainer` use their Designer-owned child collections: controls paste into
+the selected tab page or first split panel, while a `TabPage` can only be pasted or duplicated
+directly within a `TabControl`. This preserves hierarchy invariants rather than creating a cyclic or
+corrupt tree.
+
+## Names, layout, and complex data
+
+Every pasted or duplicated node receives a document-wide, case-insensitively unique C# identifier.
+The remap covers the entire subtree, including structural split-panel names and display metadata.
+Existing numeric suffixes advance naturally (`button1` becomes `button2`), and occupied names are
+skipped deterministically. Event bindings preserve handler names; the operation neither creates a
+delegate nor generates a handler method. There is currently no general control-reference property
+schema to rewrite beyond the structural metadata represented by the design model.
+
+Absolute, non-docked roots receive a 16-logical-pixel offset. Docked controls keep their bounds
+because runtime layout owns their final position. `FlowLayoutPanel` and tab containers preserve
+sequence without an artificial coordinate offset. `TableLayoutPanel` assigns the next available
+cell and resets copied row/column spans to one while retaining the rest of the subtree data.
+Padding, Margin, minimum/maximum sizes, gradients, geometry, interaction effects, layout
+transitions, tab pages, children, event bindings, and supported structured collections are deep
+copied with no shared mutable Designer value graph.
+
+Project UserControls and unavailable custom control type names cross the clipboard as data-only
+nodes. This preserves the existing safe-preview boundary: copy/paste never instantiates them or
+loads executable project code. Normal reference-cycle validation still runs before insertion.
+
+Cut writes its detached payload before opening the removal transaction. If a later tree or observer
+failure rolls the transaction back, the original subtree and selection are restored with no history
+entry while the clipboard intentionally retains that detached payload (equivalent to a completed
+Copy). Paste and Duplicate prepare their complete data-only subtree before insertion; any failure
+after insertion rolls the one transaction back, and Duplicate never changes the clipboard.
+
+## Current boundaries
+
+- Selection remains single-control; multi-selection and group editing are tracked separately in
+  [#35](https://github.com/ProGraMajster/ModernFormsNext/issues/35).
+- The operating-system/runtime clipboard contract is separate work tracked in
+  [#57](https://github.com/ProGraMajster/ModernFormsNext/issues/57).
+- Non-visual components cannot be pasted into a component tray because the tray is not implemented.
+- General cross-property control-reference remapping will require an explicit reference schema;
+  clipboard code does not guess from arbitrary strings.
+- Complete Flow/Table right-to-left behavior remains part of
+  [#89](https://github.com/ProGraMajster/ModernFormsNext/issues/89).
+- Default-event method creation and richer event workflows remain part of
+  [#37](https://github.com/ProGraMajster/ModernFormsNext/issues/37).
+
+See [Designer transactions and undo/redo](designer-transactions-and-undo.md) for atomicity,
+save-marker, retention, and replay semantics.
diff --git a/docs/designer-transactions-and-undo.md b/docs/designer-transactions-and-undo.md
index 32a638c..342b080 100644
--- a/docs/designer-transactions-and-undo.md
+++ b/docs/designer-transactions-and-undo.md
@@ -139,5 +139,6 @@ selection alone.
 
 Inherited design remains tracked separately. The typed transaction boundary is ready for a future
 change validator to reject writes to base-owned/read-only nodes before `Apply`; this issue does not
-implement inherited controls. Multi-selection, system clipboard/cut, smart guides, and a general
-command framework also remain separate features.
+implement inherited controls. Detached Designer Copy/Cut/Paste/Duplicate reuses this boundary as
+documented in [Designer copy and paste](designer-copy-paste.md). Multi-selection, an operating-system
+clipboard contract, smart guides, and a general command framework remain separate features.
diff --git a/docs/installation.md b/docs/installation.md
index ec1b2af..8203123 100644
--- a/docs/installation.md
+++ b/docs/installation.md
@@ -133,6 +133,7 @@ the Visual Studio-hosted designer:
 | --- | --- |
 | `Delete` | Deletes the selected control from the design document. |
 | `Ctrl+C` | Copies the selected control into the designer clipboard. |
+| `Ctrl+X` | Copies and removes the selected control as one undoable Designer transaction. |
 | `Ctrl+V` | Pastes the copied control into the active container. |
 | `Ctrl+D` | Duplicates the selected control next to the original with a unique field name. |
 | `Ctrl+Z` | Undoes the most recent committed Designer transaction. |
@@ -141,10 +142,11 @@ the Visual Studio-hosted designer:
 
 The shortcuts operate on the selected design control, not on generated C# text. When a property
 value editor is active in the Property Grid, text editing keeps normal keyboard behavior so
-`Delete`, `Ctrl+C`, `Ctrl+V`, and text-editor undo/redo apply to the edited value instead. Outside an
+`Delete`, `Ctrl+C`, `Ctrl+X`, `Ctrl+V`, and text-editor undo/redo apply to the edited value instead. Outside an
 active value editor, Undo and Redo use the active document's Designer history. See
-[Designer transactions and undo/redo](designer-transactions-and-undo.md) for transaction and save
-semantics.
+[Designer copy, cut, paste, and duplicate](designer-copy-paste.md) for clipboard targeting and
+safety, and [Designer transactions and undo/redo](designer-transactions-and-undo.md) for transaction
+and save semantics.
 
 ## Add a New Form in Visual Studio
 
diff --git a/docs/known-limitations.md b/docs/known-limitations.md
index b244705..a992098 100644
--- a/docs/known-limitations.md
+++ b/docs/known-limitations.md
@@ -35,7 +35,7 @@ not active limitations.
 | ID | Area | Limitation | Type | Severity | Status / issue | Details |
 | --- | --- | --- | --- | --- | --- | --- |
 | DES-01 | Designer | The previous lack of Designer-wide atomic transactions and undo/redo history is resolved with per-document typed changes, rollback, replay suppression, saved revisions, and bounded retention. | Resolved after 1.10.0 | Low | Implementation and regression coverage [#33](https://github.com/ProGraMajster/ModernFormsNext/issues/33) | [Transactions and undo](designer-transactions-and-undo.md) |
-| DES-02 | Designer | Clipboard editing is an in-session, single-control copy/paste/duplicate path; cut, a system clipboard contract, and complete cross-document behavior are absent. Existing paste/duplicate now participate in transactions. | Missing feature | High | [Tracked #34](https://github.com/ProGraMajster/ModernFormsNext/issues/34) | [Installation](installation.md#designer-keyboard-shortcuts) |
+| DES-02 | Designer | The previous ad-hoc clipboard path is replaced by detached, versioned, deterministic Copy/Cut/Paste/Duplicate with safe same-session cross-document behavior and one-unit transactions. Multi-selection and the operating-system clipboard remain separate boundaries. | Resolved after 1.10.0 | Low | Implementation and regression coverage [#34](https://github.com/ProGraMajster/ModernFormsNext/issues/34); OS clipboard [#57](https://github.com/ProGraMajster/ModernFormsNext/issues/57) | [Designer copy and paste](designer-copy-paste.md) |
 | DES-03 | Designer | No multi-selection, marquee selection, or group editing. | Missing feature | High | [Tracked #35](https://github.com/ProGraMajster/ModernFormsNext/issues/35) | [Designer architecture](designer-architecture.md#current-designer-limitations) |
 | DES-04 | Designer | Existing grid/snapping math is not a complete smart-guide, equal-spacing, baseline, or configurable-grid workflow. | Missing feature | Medium | [Tracked #36](https://github.com/ProGraMajster/ModernFormsNext/issues/36) | [Designer architecture](designer-architecture.md#current-designer-limitations) |
 | DES-05 | Designer | The Events view can persist bindings and generate a method, but default-event double-click, compatible-method selection, robust code navigation, and rename diagnostics are incomplete. | Missing feature | Medium | [Tracked #37](https://github.com/ProGraMajster/ModernFormsNext/issues/37) | [Designer architecture](designer-architecture.md#current-designer-limitations) |