diff --git a/.github/workflows/leak-tests.yml b/.github/workflows/leak-tests.yml
new file mode 100644
index 000000000..3829f18ae
--- /dev/null
+++ b/.github/workflows/leak-tests.yml
@@ -0,0 +1,36 @@
+name: Leak Tests
+permissions:
+  contents: read
+
+on:
+  push:
+    branches:
+    - master
+    - release/*
+  pull_request:
+    branches:
+    - master
+    - release/*
+
+env:
+  DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
+  DOTNET_CLI_TELEMETRY_OPTOUT: 1
+
+jobs:
+  leak-tests:
+    name: Leak Tests (Release)
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        global-json-file: global.json
+    - name: Install workloads
+      run: dotnet workload install wasm-tools wasm-experimental
+    - name: Run Dock.Avalonia leak tests
+      run: dotnet test -c Release tests/Dock.Avalonia.LeakTests/Dock.Avalonia.LeakTests.csproj
+    - name: Run Dock.Model.Mvvm leak tests
+      run: dotnet test -c Release tests/Dock.Model.Mvvm.LeakTests/Dock.Model.Mvvm.LeakTests.csproj
+    - name: Run Dock.Model.ReactiveUI leak tests
+      run: dotnet test -c Release tests/Dock.Model.ReactiveUI.LeakTests/Dock.Model.ReactiveUI.LeakTests.csproj
diff --git a/Dock.slnx b/Dock.slnx
index f6fee9e55..d71b08421 100644
--- a/Dock.slnx
+++ b/Dock.slnx
@@ -99,6 +99,7 @@
   </Folder>
   <Folder Name="/tests/">
     <Project Path="tests/Dock.Avalonia.Diagnostics.UnitTests/Dock.Avalonia.Diagnostics.UnitTests.csproj" />
+    <Project Path="tests/Dock.Avalonia.LeakTests/Dock.Avalonia.LeakTests.csproj" />
     <Project Path="tests/Dock.Avalonia.HeadlessTests/Dock.Avalonia.HeadlessTests.csproj" />
     <Project Path="tests/Dock.Avalonia.Themes.UnitTests/Dock.Avalonia.Themes.UnitTests.csproj" />
     <Project Path="tests/Dock.Avalonia.UnitTests/Dock.Avalonia.UnitTests.csproj" />
@@ -107,9 +108,11 @@
     <Project Path="tests/Dock.MarkupExtension.UnitTests/Dock.MarkupExtension.UnitTests.csproj" />
     <Project Path="tests/Dock.Model.Avalonia.UnitTests/Dock.Model.Avalonia.UnitTests.csproj" />
     <Project Path="tests/Dock.Model.CaliburMicro.UnitTests/Dock.Model.CaliburMicro.UnitTests.csproj" />
+    <Project Path="tests/Dock.Model.Mvvm.LeakTests/Dock.Model.Mvvm.LeakTests.csproj" />
     <Project Path="tests/Dock.Model.Mvvm.UnitTests/Dock.Model.Mvvm.UnitTests.csproj" />
     <Project Path="tests/Dock.Model.Prism.UnitTests/Dock.Model.Prism.UnitTests.csproj" />
     <Project Path="tests/Dock.Model.ReactiveProperty.UnitTests/Dock.Model.ReactiveProperty.UnitTests.csproj" />
+    <Project Path="tests/Dock.Model.ReactiveUI.LeakTests/Dock.Model.ReactiveUI.LeakTests.csproj" />
     <Project Path="tests/Dock.Model.ReactiveUI.UnitTests/Dock.Model.ReactiveUI.UnitTests.csproj" />
     <Project Path="tests/Dock.Model.UnitTests/Dock.Model.UnitTests.csproj" />
     <Project Path="tests/Dock.Serializer.UnitTests/Dock.Serializer.UnitTests.csproj" />
diff --git a/samples/DockFigmaSample/Views/Documents/DesignCanvasView.axaml b/samples/DockFigmaSample/Views/Documents/DesignCanvasView.axaml
index 2402f72a6..0bb06ebea 100644
--- a/samples/DockFigmaSample/Views/Documents/DesignCanvasView.axaml
+++ b/samples/DockFigmaSample/Views/Documents/DesignCanvasView.axaml
@@ -34,8 +34,11 @@
 
         <Grid Grid.Row="1" ColumnDefinitions="2*,*" ColumnSpacing="32">
           <StackPanel Spacing="16">
-            <TextBlock Text="Design tools with
-real-time momentum" Classes="hero-title" />
+            <TextBlock Classes="hero-title">
+              <Run Text="Design tools with" />
+              <LineBreak />
+              <Run Text="real-time momentum" />
+            </TextBlock>
             <TextBlock Text="Build interactive flows faster with components, tokens, and smart docking." Classes="hero-body" />
             <StackPanel Orientation="Horizontal" Spacing="12">
               <Border Background="{DynamicResource AccentBrush}" CornerRadius="14" Padding="16,10">
@@ -85,7 +88,11 @@ real-time momentum" Classes="hero-title" />
             Padding="10,6"
             CornerRadius="12"
             Background="{DynamicResource CanvasOverlayBrush}">
-      <TextBlock Text="{Binding FrameName}  |  {Binding FrameSize}" Classes="muted" />
+      <TextBlock Classes="muted">
+        <Run Text="{Binding FrameName}" />
+        <Run Text="  |  " />
+        <Run Text="{Binding FrameSize}" />
+      </TextBlock>
     </Border>
   </Grid>
 </UserControl>
diff --git a/samples/DockReactiveUIWindowRelationsSample/Views/MainView.axaml b/samples/DockReactiveUIWindowRelationsSample/Views/MainView.axaml
index 817ca80a0..e9d95b6e6 100644
--- a/samples/DockReactiveUIWindowRelationsSample/Views/MainView.axaml
+++ b/samples/DockReactiveUIWindowRelationsSample/Views/MainView.axaml
@@ -15,15 +15,16 @@
   <DockPanel>
     <StackPanel DockPanel.Dock="Top" Orientation="Horizontal" Margin="8" Spacing="8">
       <Button Content="Reset Layout" Command="{Binding ResetLayout}" />
-      <StackPanel DataContext="{Binding Layout}" Orientation="Horizontal" Spacing="8" x:DataType="dmc:IRootDock">
-        <Button Content="Show Windows" Command="{Binding ShowWindows}" />
-        <Button Content="Exit Windows" Command="{Binding ExitWindows}" />
+      <StackPanel DataContext="{Binding Layout}">
+        <StackPanel Orientation="Horizontal" Spacing="8" x:DataType="dmc:IRootDock">
+          <Button Content="Show Windows" Command="{Binding ShowWindows}" />
+          <Button Content="Exit Windows" Command="{Binding ExitWindows}" />
+        </StackPanel>
       </StackPanel>
     </StackPanel>
     <DockControl Layout="{Binding Layout}" Margin="8" />
-    <Border DockPanel.Dock="Bottom" Padding="8" Background="#1F000000">
-      <TextBlock DataContext="{Binding Layout}"
-                 Text="{Binding FocusedDockable, FallbackValue=''}"
+    <Border DockPanel.Dock="Bottom" Padding="8" Background="#1F000000" DataContext="{Binding Layout}">
+      <TextBlock Text="{Binding FocusedDockable, FallbackValue=''}"
                  x:DataType="dm:IDock" />
     </Border>
   </DockPanel>
diff --git a/src/Dock.Avalonia.Themes.Fluent/Controls/HostWindow.axaml b/src/Dock.Avalonia.Themes.Fluent/Controls/HostWindow.axaml
index b4569a2c9..e08f3c76c 100644
--- a/src/Dock.Avalonia.Themes.Fluent/Controls/HostWindow.axaml
+++ b/src/Dock.Avalonia.Themes.Fluent/Controls/HostWindow.axaml
@@ -53,7 +53,7 @@
 
     <Setter Property="Content" Value="{Binding}" />
     <Setter Property="ContentTemplate">
-      <DataTemplate>
+      <DataTemplate x:DataType="controls:IRootDock">
         <Panel Margin="{Binding $parent[HostWindow].OffScreenMargin}">
           <Panel Margin="{Binding $parent[HostWindow].WindowDecorationMargin}">
             <OverlayHost VisualTreeLifecycleBehavior.IsEnabled="True">
@@ -107,7 +107,7 @@
 
       <Setter Property="Content" Value="{Binding}" />
       <Setter Property="ContentTemplate">
-        <DataTemplate>
+        <DataTemplate x:DataType="controls:IRootDock">
           <Panel Margin="{Binding $parent[HostWindow].OffScreenMargin}">
             <OverlayHost VisualTreeLifecycleBehavior.IsEnabled="True">
               <DockControl Layout="{Binding}" />
diff --git a/src/Dock.Avalonia/Controls/DockControl.axaml.cs b/src/Dock.Avalonia/Controls/DockControl.axaml.cs
index 5455d987e..a4c32a80b 100644
--- a/src/Dock.Avalonia/Controls/DockControl.axaml.cs
+++ b/src/Dock.Avalonia/Controls/DockControl.axaml.cs
@@ -3,11 +3,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Runtime.CompilerServices;
 using Avalonia;
 using Avalonia.Controls;
-using Avalonia.Controls.Recycling;
-using Avalonia.Controls.Recycling.Model;
 using Avalonia.Controls.Metadata;
 using Avalonia.Controls.Primitives;
 using Avalonia.Controls.Templates;
@@ -21,6 +18,7 @@
 using Dock.Avalonia.Diagnostics;
 using Dock.Avalonia.Internal;
 using Dock.Avalonia.Selectors;
+using Dock.Avalonia.Services;
 using Dock.Model;
 using Dock.Model.Controls;
 using Dock.Model.Core;
@@ -38,10 +36,10 @@ namespace Dock.Avalonia.Controls;
 [TemplatePart("PART_ManagedWindowLayer", typeof(ManagedWindowLayer))]
 public class DockControl : TemplatedControl, IDockControl, IDockSelectorService
 {
-    private static readonly ConditionalWeakTable<IFactory, IControlRecycling> s_controlRecycling = new();
     private readonly DockManagerOptions _dockManagerOptions;
     private readonly DockManager _dockManager;
     private readonly DockControlState _dockControlState;
+    private readonly IDockControlFactoryService _factoryService;
     private bool _isInitialized;
     private ContentControl? _contentControl;
     private ManagedWindowLayer? _managedWindowLayer;
@@ -238,6 +236,7 @@ public DockControl()
         _dockManagerOptions = new DockManagerOptions();
         _dockManager = new DockManager(new DockService(), _dockManagerOptions);
         _dockControlState = new DockControlState(_dockManager, _dragOffsetCalculator);
+        _factoryService = new DockControlFactoryService();
         AddHandler(PointerPressedEvent, PressedHandler, RoutingStrategies.Direct | RoutingStrategies.Tunnel | RoutingStrategies.Bubble);
         AddHandler(PointerReleasedEvent, ReleasedHandler, RoutingStrategies.Direct | RoutingStrategies.Tunnel | RoutingStrategies.Bubble);
         AddHandler(PointerMovedEvent, MovedHandler, RoutingStrategies.Direct | RoutingStrategies.Tunnel | RoutingStrategies.Bubble);
@@ -259,7 +258,7 @@ protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
         _selectorOverlay = e.NameScope.Find<DockSelectorOverlay>("PART_SelectorOverlay");
         _managedWindowLayer = e.NameScope.Find<ManagedWindowLayer>("PART_ManagedWindowLayer");
 
-        InitializeControlRecycling();
+        _factoryService.InitializeControlRecycling(this);
         
         if (_contentControl is not null)
         {
@@ -270,57 +269,6 @@ protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
         InitializeCommandBars();
     }
 
-    private void InitializeControlRecycling()
-    {
-        if (Layout?.Factory is not { } factory)
-        {
-            return;
-        }
-
-        var controlRecycling = ControlRecyclingDataTemplate.GetControlRecycling(this);
-        if (controlRecycling is null)
-        {
-            return;
-        }
-
-        if (s_controlRecycling.TryGetValue(factory, out var shared))
-        {
-            if (ReferenceEquals(shared, controlRecycling))
-            {
-                return;
-            }
-
-            if (shared is ControlRecycling sharedRecycling && controlRecycling is ControlRecycling localRecycling)
-            {
-                if (sharedRecycling.TryToUseIdAsKey != localRecycling.TryToUseIdAsKey)
-                {
-                    sharedRecycling.TryToUseIdAsKey = localRecycling.TryToUseIdAsKey;
-                }
-
-                ControlRecyclingDataTemplate.SetControlRecycling(this, sharedRecycling);
-                return;
-            }
-
-            if (controlRecycling is ControlRecycling)
-            {
-                ControlRecyclingDataTemplate.SetControlRecycling(this, shared);
-            }
-
-            return;
-        }
-
-        if (controlRecycling is ControlRecycling defaultRecycling)
-        {
-            controlRecycling = new ControlRecycling
-            {
-                TryToUseIdAsKey = defaultRecycling.TryToUseIdAsKey
-            };
-            ControlRecyclingDataTemplate.SetControlRecycling(this, controlRecycling);
-        }
-
-        s_controlRecycling.Add(factory, controlRecycling);
-    }
-
     private void InitializeDefaultDataTemplates()
     {
         if (_contentControl?.DataTemplates is null)
@@ -386,38 +334,30 @@ private void Initialize(IDock? layout)
 
         layout.Factory.DockControls.Add(this);
 
-        InitializeControlRecycling();
+        _factoryService.InitializeControlRecycling(this);
         UpdateManagedWindowLayer(layout);
 
         if (InitializeFactory)
         {
             layout.Factory.ContextLocator ??= new Dictionary<string, Func<object?>>();
             layout.Factory.DockableLocator ??= new Dictionary<string, Func<IDockable?>>();
-            layout.Factory.DefaultContextLocator ??= GetContext;
-            layout.Factory.DefaultHostWindowLocator ??= GetHostWindow;
+            if (layout.Factory.DefaultContextLocator is null)
+            {
+                layout.Factory.DefaultContextLocator = ResolveDefaultContext;
+            }
 
-            if (layout.Factory.HostWindowLocator is null)
+            if (layout.Factory.DefaultHostWindowLocator is null)
             {
-                layout.Factory.HostWindowLocator = new Dictionary<string, Func<IHostWindow?>>
-                {
-                    [nameof(IDockWindow)] = GetHostWindow
-                };
+                layout.Factory.DefaultHostWindowLocator = ResolveDefaultHostWindow;
             }
 
-            IHostWindow GetHostWindow()
+            if (layout.Factory.HostWindowLocator is null)
             {
-                if (HostWindowFactory is { } factory)
+                layout.Factory.HostWindowLocator = new Dictionary<string, Func<IHostWindow?>>
                 {
-                    return factory();
-                }
-
-                var hostMode = DockSettings.ResolveFloatingWindowHostMode(layout as IRootDock);
-                return hostMode == DockFloatingWindowHostMode.Managed
-                    ? new ManagedHostWindow(_dockManagerOptions)
-                    : new HostWindow(_dockManagerOptions);
+                    [nameof(IDockWindow)] = ResolveDefaultHostWindow
+                };
             }
-
-            object? GetContext() => DefaultContext;
         }
 
         if (InitializeLayout)
@@ -446,6 +386,11 @@ private void DeInitialize(IDock? layout)
 
         layout.Factory.DockControls.Remove(this);
 
+        _activationOrder.Clear();
+        _activationCounter = 0;
+
+        _factoryService.CleanupFactory(this, layout);
+
         if (InitializeLayout)
         {
             if (layout.Close.CanExecute(null))
@@ -477,6 +422,21 @@ private void InitializeCommandBars()
         }
     }
 
+    internal object? ResolveDefaultContext() => DefaultContext;
+
+    internal IHostWindow? ResolveDefaultHostWindow()
+    {
+        if (HostWindowFactory is { } factory)
+        {
+            return factory();
+        }
+
+        var hostMode = DockSettings.ResolveFloatingWindowHostMode(Layout as IRootDock);
+        return hostMode == DockFloatingWindowHostMode.Managed
+            ? new ManagedHostWindow(_dockManagerOptions)
+            : new HostWindow(_dockManagerOptions);
+    }
+
     private void AttachFactoryEvents(IFactory? factory)
     {
         if (ReferenceEquals(_subscribedFactory, factory))
diff --git a/src/Dock.Avalonia/Controls/ManagedWindowLayer.cs b/src/Dock.Avalonia/Controls/ManagedWindowLayer.cs
index 701111b24..2d9b37362 100644
--- a/src/Dock.Avalonia/Controls/ManagedWindowLayer.cs
+++ b/src/Dock.Avalonia/Controls/ManagedWindowLayer.cs
@@ -9,6 +9,7 @@
 using Avalonia.Controls.Metadata;
 using Avalonia.Controls.Primitives;
 using Avalonia.VisualTree;
+using Dock.Avalonia.Internal;
 using Dock.Avalonia.Mdi;
 using Dock.Model.Controls;
 using Dock.Model.Core;
@@ -78,6 +79,19 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
         }
     }
 
+    /// <inheritdoc />
+    protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e)
+    {
+        base.OnDetachedFromVisualTree(e);
+
+        DetachDock();
+
+        if (Dock?.Factory is { } factory)
+        {
+            ManagedWindowRegistry.UnregisterLayer(factory, this);
+        }
+    }
+
     /// <summary>
     /// Attempts to locate the managed window layer for a visual.
     /// </summary>
diff --git a/src/Dock.Avalonia/Controls/Overlays/OverlayHost.cs b/src/Dock.Avalonia/Controls/Overlays/OverlayHost.cs
index 3c20a2895..9299d9298 100644
--- a/src/Dock.Avalonia/Controls/Overlays/OverlayHost.cs
+++ b/src/Dock.Avalonia/Controls/Overlays/OverlayHost.cs
@@ -9,6 +9,7 @@
 using Avalonia.Controls.Templates;
 using Avalonia.Metadata;
 using Avalonia.Styling;
+using Avalonia.Threading;
 using Avalonia.VisualTree;
 
 namespace Dock.Avalonia.Controls.Overlays;
@@ -51,6 +52,7 @@ public sealed class OverlayHost : Decorator
     private IList<Control> _overlays = new List<Control>();
     private OverlayLayerCollection _overlayLayers = new();
     private OverlayLayerCollection? _serviceLayers;
+    private bool _isAttached;
 
     static OverlayHost()
     {
@@ -67,12 +69,6 @@ static OverlayHost()
     public OverlayHost()
     {
         Overlays = new AvaloniaList<Control>();
-        if (_overlayLayers is INotifyCollectionChanged list)
-        {
-            list.CollectionChanged += OnOverlayLayersCollectionChanged;
-        }
-
-        SubscribeLayerChanges(_overlayLayers);
     }
 
     /// <summary>
@@ -126,6 +122,8 @@ public bool UseServiceLayers
     protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
     {
         base.OnAttachedToVisualTree(e);
+        _isAttached = true;
+        AttachOverlayCollections();
         OverlayLayerRegistry.ProviderChanged += OnOverlayLayerProviderChanged;
         ResetServiceLayers();
         RebuildPipeline();
@@ -135,7 +133,9 @@ protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
     protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e)
     {
         base.OnDetachedFromVisualTree(e);
+        _isAttached = false;
         OverlayLayerRegistry.ProviderChanged -= OnOverlayLayerProviderChanged;
+        DetachOverlayCollections();
         ResetServiceLayers();
     }
 
@@ -148,7 +148,7 @@ private void OnOverlaysChanged(AvaloniaPropertyChangedEventArgs args)
 
         _overlays = args.NewValue as IList<Control> ?? new List<Control>();
 
-        if (_overlays is INotifyCollectionChanged newList)
+        if (_isAttached && _overlays is INotifyCollectionChanged newList)
         {
             newList.CollectionChanged += OnOverlaysCollectionChanged;
         }
@@ -170,9 +170,12 @@ private void OnOverlayLayersChanged(AvaloniaPropertyChangedEventArgs args)
 
         UnsubscribeLayerChanges(_overlayLayers);
         _overlayLayers = args.NewValue as OverlayLayerCollection ?? new OverlayLayerCollection();
-        SubscribeLayerChanges(_overlayLayers);
+        if (_isAttached)
+        {
+            SubscribeLayerChanges(_overlayLayers);
+        }
 
-        if (_overlayLayers is INotifyCollectionChanged newList)
+        if (_isAttached && _overlayLayers is INotifyCollectionChanged newList)
         {
             newList.CollectionChanged += OnOverlayLayersCollectionChanged;
         }
@@ -218,10 +221,60 @@ private void OnUseServiceLayersChanged()
 
     private void OnOverlayLayerProviderChanged(object? sender, EventArgs e)
     {
+        if (!_isAttached)
+        {
+            return;
+        }
+
+        if (!Dispatcher.UIThread.CheckAccess())
+        {
+            Dispatcher.UIThread.Post(() =>
+            {
+                if (!_isAttached)
+                {
+                    return;
+                }
+
+                ResetServiceLayers();
+                RebuildPipeline();
+            });
+            return;
+        }
+
         ResetServiceLayers();
         RebuildPipeline();
     }
 
+    private void AttachOverlayCollections()
+    {
+        if (_overlays is INotifyCollectionChanged overlaysList)
+        {
+            overlaysList.CollectionChanged += OnOverlaysCollectionChanged;
+        }
+
+        if (_overlayLayers is INotifyCollectionChanged layersList)
+        {
+            layersList.CollectionChanged += OnOverlayLayersCollectionChanged;
+        }
+
+        SubscribeLayerChanges(_overlayLayers);
+    }
+
+    private void DetachOverlayCollections()
+    {
+        if (_overlays is INotifyCollectionChanged overlaysList)
+        {
+            overlaysList.CollectionChanged -= OnOverlaysCollectionChanged;
+        }
+
+        if (_overlayLayers is INotifyCollectionChanged layersList)
+        {
+            layersList.CollectionChanged -= OnOverlayLayersCollectionChanged;
+        }
+
+        UnsubscribeLayerChanges(_overlayLayers);
+    }
+
     private void SubscribeLayerChanges(IEnumerable<IOverlayLayer> layers)
     {
         foreach (var layer in layers)
diff --git a/src/Dock.Avalonia/Internal/ItemDragHelper.cs b/src/Dock.Avalonia/Internal/ItemDragHelper.cs
index d0c4973f9..ccc2e9a37 100644
--- a/src/Dock.Avalonia/Internal/ItemDragHelper.cs
+++ b/src/Dock.Avalonia/Internal/ItemDragHelper.cs
@@ -297,25 +297,7 @@ private void StartAutoScroll(ScrollViewer scrollViewer, Vector velocity)
             Interval = TimeSpan.FromMilliseconds(AutoScrollTimerInterval)
         };
 
-        _autoScrollTimer.Tick += (_, _) =>
-        {
-            if (_currentScrollViewer == null)
-            {
-                StopAutoScroll();
-                return;
-            }
-
-            var deltaTime = AutoScrollTimerInterval / 1000.0; // Convert to seconds
-            var deltaX = _autoScrollVelocity.X * deltaTime;
-            var deltaY = _autoScrollVelocity.Y * deltaTime;
-
-            var newOffsetX = Math.Max(0, Math.Min(_currentScrollViewer.Extent.Width - _currentScrollViewer.Viewport.Width, 
-                _currentScrollViewer.Offset.X + deltaX));
-            var newOffsetY = Math.Max(0, Math.Min(_currentScrollViewer.Extent.Height - _currentScrollViewer.Viewport.Height, 
-                _currentScrollViewer.Offset.Y + deltaY));
-
-            _currentScrollViewer.Offset = new Vector(newOffsetX, newOffsetY);
-        };
+        _autoScrollTimer.Tick += OnAutoScrollTick;
 
         _autoScrollTimer.Start();
     }
@@ -324,13 +306,35 @@ private void StopAutoScroll()
     {
         if (_autoScrollTimer != null)
         {
+            _autoScrollTimer.Tick -= OnAutoScrollTick;
             _autoScrollTimer.Stop();
             _autoScrollTimer = null;
         }
+
         _currentScrollViewer = null;
         _autoScrollVelocity = default;
     }
 
+    private void OnAutoScrollTick(object? sender, EventArgs e)
+    {
+        if (_currentScrollViewer == null)
+        {
+            StopAutoScroll();
+            return;
+        }
+
+        var deltaTime = AutoScrollTimerInterval / 1000.0; // Convert to seconds
+        var deltaX = _autoScrollVelocity.X * deltaTime;
+        var deltaY = _autoScrollVelocity.Y * deltaTime;
+
+        var newOffsetX = Math.Max(0, Math.Min(_currentScrollViewer.Extent.Width - _currentScrollViewer.Viewport.Width,
+            _currentScrollViewer.Offset.X + deltaX));
+        var newOffsetY = Math.Max(0, Math.Min(_currentScrollViewer.Extent.Height - _currentScrollViewer.Viewport.Height,
+            _currentScrollViewer.Offset.Y + deltaY));
+
+        _currentScrollViewer.Offset = new Vector(newOffsetX, newOffsetY);
+    }
+
     private Vector CalculateAutoScrollVelocity(Point position, ScrollViewer scrollViewer)
     {
         var viewport = new Rect(scrollViewer.Viewport);
diff --git a/src/Dock.Avalonia/Internal/WindowDragHelper.cs b/src/Dock.Avalonia/Internal/WindowDragHelper.cs
index 7afad2b0c..7b36dbf52 100644
--- a/src/Dock.Avalonia/Internal/WindowDragHelper.cs
+++ b/src/Dock.Avalonia/Internal/WindowDragHelper.cs
@@ -60,6 +60,21 @@ public void Detach()
             }
             _disposables = null;
         }
+
+        _releasedEventDisposable?.Dispose();
+        _releasedEventDisposable = null;
+
+        if (_dragWindow is not null && _positionChangedHandler is not null)
+        {
+            _dragWindow.PositionChanged -= _positionChangedHandler;
+            _positionChangedHandler = null;
+        }
+
+        _dragWindow = null;
+        _pointerPressed = false;
+        _isDragging = false;
+        _handledPointerPressed = false;
+        _lastPointerPressedArgs = null;
     }
 
     private void OnPointerPressed(object? sender, PointerPressedEventArgs e)
diff --git a/src/Dock.Avalonia/Services/DockControlFactoryService.cs b/src/Dock.Avalonia/Services/DockControlFactoryService.cs
new file mode 100644
index 000000000..a109926c4
--- /dev/null
+++ b/src/Dock.Avalonia/Services/DockControlFactoryService.cs
@@ -0,0 +1,259 @@
+// Copyright (c) Wiesław Šoltés. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for details.
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using Avalonia.Controls.Recycling;
+using Avalonia.Controls.Recycling.Model;
+using Dock.Avalonia.Controls;
+using Dock.Model.Controls;
+using Dock.Model.Core;
+
+namespace Dock.Avalonia.Services;
+
+internal sealed class DockControlFactoryService : IDockControlFactoryService
+{
+    private static readonly ConditionalWeakTable<IFactory, IControlRecycling> s_controlRecycling = new();
+
+    public void InitializeControlRecycling(DockControl control)
+    {
+        if (control.Layout?.Factory is not { } factory)
+        {
+            return;
+        }
+
+        var controlRecycling = ControlRecyclingDataTemplate.GetControlRecycling(control);
+        if (controlRecycling is null)
+        {
+            return;
+        }
+
+        if (s_controlRecycling.TryGetValue(factory, out var shared))
+        {
+            if (ReferenceEquals(shared, controlRecycling))
+            {
+                return;
+            }
+
+            if (shared is ControlRecycling sharedRecycling && controlRecycling is ControlRecycling localRecycling)
+            {
+                if (sharedRecycling.TryToUseIdAsKey != localRecycling.TryToUseIdAsKey)
+                {
+                    sharedRecycling.TryToUseIdAsKey = localRecycling.TryToUseIdAsKey;
+                }
+
+                ControlRecyclingDataTemplate.SetControlRecycling(control, sharedRecycling);
+                return;
+            }
+
+            if (controlRecycling is ControlRecycling)
+            {
+                ControlRecyclingDataTemplate.SetControlRecycling(control, shared);
+            }
+
+            return;
+        }
+
+        if (controlRecycling is ControlRecycling defaultRecycling)
+        {
+            controlRecycling = new ControlRecycling
+            {
+                TryToUseIdAsKey = defaultRecycling.TryToUseIdAsKey
+            };
+            ControlRecyclingDataTemplate.SetControlRecycling(control, controlRecycling);
+        }
+
+        s_controlRecycling.Add(factory, controlRecycling);
+    }
+
+    public void CleanupFactory(DockControl control, IDock layout)
+    {
+        if (layout.Factory is not { } factory)
+        {
+            return;
+        }
+
+        if (!HasOtherDockControlForLayout(factory, layout))
+        {
+            PruneFactoryCaches(factory, layout);
+        }
+
+        ReleaseFactoryDefaults(factory, control);
+    }
+
+    private static bool HasOtherDockControlForLayout(IFactory factory, IDock layout)
+    {
+        foreach (var control in factory.DockControls.OfType<DockControl>())
+        {
+            if (!ReferenceEquals(control.Layout, layout))
+            {
+                continue;
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    private static void PruneFactoryCaches(IFactory factory, IDock layout)
+    {
+        var dockables = new HashSet<IDockable>();
+        CollectAllDockables(layout, dockables);
+
+        PruneDictionary(factory.VisibleDockableControls, dockables);
+        PruneDictionary(factory.PinnedDockableControls, dockables);
+        PruneDictionary(factory.TabDockableControls, dockables);
+        PruneDictionary(factory.VisibleRootControls, dockables);
+        PruneDictionary(factory.PinnedRootControls, dockables);
+        PruneDictionary(factory.TabRootControls, dockables);
+        PruneDictionary(factory.ToolControls, dockables);
+        PruneDictionary(factory.DocumentControls, dockables);
+        PruneControlRecycling(factory, dockables);
+    }
+
+    private static void PruneDictionary<TValue>(IDictionary<IDockable, TValue> dictionary, HashSet<IDockable> dockables)
+    {
+        if (dictionary.Count == 0)
+        {
+            return;
+        }
+
+        var keys = dictionary.Keys.Where(dockables.Contains).ToList();
+        foreach (var key in keys)
+        {
+            dictionary.Remove(key);
+        }
+    }
+
+    private static void PruneControlRecycling(IFactory factory, HashSet<IDockable> dockables)
+    {
+        if (!s_controlRecycling.TryGetValue(factory, out var recycling))
+        {
+            return;
+        }
+
+        if (recycling is not ControlRecycling controlRecycling)
+        {
+            return;
+        }
+
+        foreach (var dockable in dockables)
+        {
+            controlRecycling.Remove(dockable);
+        }
+    }
+
+    private static void CollectAllDockables(IDockable dockable, HashSet<IDockable> dockables)
+    {
+        if (!dockables.Add(dockable))
+        {
+            return;
+        }
+
+        if (dockable is IRootDock root)
+        {
+            AddDockablesAll(root.HiddenDockables, dockables);
+            AddDockablesAll(root.LeftPinnedDockables, dockables);
+            AddDockablesAll(root.RightPinnedDockables, dockables);
+            AddDockablesAll(root.TopPinnedDockables, dockables);
+            AddDockablesAll(root.BottomPinnedDockables, dockables);
+
+            if (root.PinnedDock is { } pinnedDock)
+            {
+                CollectAllDockables(pinnedDock, dockables);
+            }
+
+            if (root.Windows is { })
+            {
+                foreach (var window in root.Windows)
+                {
+                    if (window.Layout is { } layout)
+                    {
+                        CollectAllDockables(layout, dockables);
+                    }
+                }
+            }
+        }
+
+        if (dockable is IDock dock && dock.VisibleDockables is { })
+        {
+            foreach (var child in dock.VisibleDockables)
+            {
+                CollectAllDockables(child, dockables);
+            }
+        }
+
+        if (dockable is ISplitViewDock splitViewDock)
+        {
+            if (splitViewDock.PaneDockable is { } paneDockable)
+            {
+                CollectAllDockables(paneDockable, dockables);
+            }
+
+            if (splitViewDock.ContentDockable is { } contentDockable
+                && !ReferenceEquals(contentDockable, splitViewDock.PaneDockable))
+            {
+                CollectAllDockables(contentDockable, dockables);
+            }
+        }
+
+        if (dockable is IDockWindow dockWindow && dockWindow.Layout is { } dockLayout)
+        {
+            CollectAllDockables(dockLayout, dockables);
+        }
+    }
+
+    private static void AddDockablesAll(IList<IDockable>? source, HashSet<IDockable> dockables)
+    {
+        if (source is null)
+        {
+            return;
+        }
+
+        foreach (var dockable in source)
+        {
+            CollectAllDockables(dockable, dockables);
+        }
+    }
+
+    private static void ReleaseFactoryDefaults(IFactory factory, DockControl owner)
+    {
+        var remaining = factory.DockControls
+            .OfType<DockControl>()
+            .FirstOrDefault(control => !ReferenceEquals(control, owner));
+
+        if (ReferenceEquals(factory.DefaultContextLocator?.Target, owner))
+        {
+            factory.DefaultContextLocator = remaining is null ? null : remaining.ResolveDefaultContext;
+        }
+
+        if (ReferenceEquals(factory.DefaultHostWindowLocator?.Target, owner))
+        {
+            factory.DefaultHostWindowLocator = remaining is null ? null : remaining.ResolveDefaultHostWindow;
+        }
+
+        var hostWindowLocator = factory.HostWindowLocator;
+        if (hostWindowLocator is null)
+        {
+            return;
+        }
+
+        if (hostWindowLocator.TryGetValue(nameof(IDockWindow), out var locator)
+            && ReferenceEquals(locator?.Target, owner))
+        {
+            if (remaining is null)
+            {
+                hostWindowLocator.Remove(nameof(IDockWindow));
+                if (hostWindowLocator.Count == 0 && ReferenceEquals(factory.HostWindowLocator, hostWindowLocator))
+                {
+                    factory.HostWindowLocator = null;
+                }
+            }
+            else
+            {
+                hostWindowLocator[nameof(IDockWindow)] = remaining.ResolveDefaultHostWindow;
+            }
+        }
+    }
+}
diff --git a/src/Dock.Avalonia/Services/IDockControlFactoryService.cs b/src/Dock.Avalonia/Services/IDockControlFactoryService.cs
new file mode 100644
index 000000000..08d7cdba2
--- /dev/null
+++ b/src/Dock.Avalonia/Services/IDockControlFactoryService.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Wiesław Šoltés. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for details.
+using Dock.Avalonia.Controls;
+using Dock.Model.Core;
+
+namespace Dock.Avalonia.Services;
+
+internal interface IDockControlFactoryService
+{
+    void InitializeControlRecycling(DockControl control);
+    void CleanupFactory(DockControl control, IDock layout);
+}
diff --git a/src/Dock.Controls.Recycling/ControlRecycling.cs b/src/Dock.Controls.Recycling/ControlRecycling.cs
index 5cb698f44..1c30ef9e7 100644
--- a/src/Dock.Controls.Recycling/ControlRecycling.cs
+++ b/src/Dock.Controls.Recycling/ControlRecycling.cs
@@ -68,19 +68,12 @@ public void Add(object data, object control)
     /// <returns></returns>
     public object? Build(object? data, object? existing, object? parent)
     {
-        var key = data;
-        if (key is null)
+        if (data is null)
         {
             return null;
         }
 
-        if (TryToUseIdAsKey && key is IControlRecyclingIdProvider idProvider)
-        {
-            if (!string.IsNullOrWhiteSpace(idProvider.GetControlRecyclingId()))
-            {
-                key = idProvider.GetControlRecyclingId();
-            }
-        }
+        var key = GetCacheKey(data);
 
         var parentControl = parent as Control;
 
@@ -161,6 +154,21 @@ public void Add(object data, object control)
         return control;
     }
 
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="data"></param>
+    public bool Remove(object data)
+    {
+        if (data is null)
+        {
+            return false;
+        }
+
+        var key = GetCacheKey(data);
+        return _cache.Remove(key);
+    }
+
     /// <summary>
     /// 
     /// </summary>
@@ -169,6 +177,21 @@ public void Clear()
         _cache.Clear();
     }
 
+    private object GetCacheKey(object data)
+    {
+        var key = data;
+        if (TryToUseIdAsKey && data is IControlRecyclingIdProvider idProvider)
+        {
+            var id = idProvider.GetControlRecyclingId();
+            if (!string.IsNullOrWhiteSpace(id))
+            {
+                key = id;
+            }
+        }
+
+        return key;
+    }
+
     /// <summary>
     /// Removes a visual control from its current parent in the visual tree.
     /// </summary>
diff --git a/tests/Dock.Avalonia.LeakTests/AvaloniaViewLeakTests.cs b/tests/Dock.Avalonia.LeakTests/AvaloniaViewLeakTests.cs
new file mode 100644
index 000000000..2f0b9dd6a
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/AvaloniaViewLeakTests.cs
@@ -0,0 +1,91 @@
+using System;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Controls.Recycling;
+using Avalonia.VisualTree;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Avalonia;
+using Dock.Model.Avalonia.Controls;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class AvaloniaViewLeakTests
+{
+    [ReleaseFact]
+    public void AvaloniaModel_WithViews_InputInteractions_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var factory = new Factory();
+            var document = new Document { Factory = factory };
+            var tool = new Tool { Factory = factory };
+
+            var documentView = new Border
+            {
+                Child = new TextBlock { Text = "Document View" }
+            };
+            var toolView = new Border
+            {
+                Child = new TextBlock { Text = "Tool View" }
+            };
+
+            document.Content = documentView;
+            tool.Content = toolView;
+
+            var documentHost = new ContentControl { Content = document };
+            documentHost.ContentTemplate = new ControlRecyclingDataTemplate { Parent = documentHost };
+            var toolHost = new ContentControl { Content = tool };
+            toolHost.ContentTemplate = new ControlRecyclingDataTemplate { Parent = toolHost };
+
+            var panel = new StackPanel();
+            panel.Children.Add(documentHost);
+            panel.Children.Add(toolHost);
+
+            var window = new Window { Content = panel };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+
+            var hasDocumentView = panel.GetVisualDescendants().Any(visual => ReferenceEquals(visual, documentView));
+            var hasToolView = panel.GetVisualDescendants().Any(visual => ReferenceEquals(visual, toolView));
+
+            Assert.True(hasDocumentView);
+            Assert.True(hasToolView);
+
+            ExerciseInputInteractions(documentHost, includeDoubleTap: true, includeMiddlePress: true);
+
+            var leakResult = new AvaloniaViewLeakResult(
+                new WeakReference(document),
+                new WeakReference(tool),
+                new WeakReference(documentHost),
+                new WeakReference(toolHost),
+                new WeakReference(documentView),
+                new WeakReference(toolView));
+
+            CleanupWindow(window);
+            return leakResult;
+        });
+
+        AssertCollected(
+            result.DocumentRef,
+            result.ToolRef,
+            result.DocumentHostRef,
+            result.ToolHostRef,
+            result.DocumentViewRef,
+            result.ToolViewRef);
+    }
+
+    private sealed record AvaloniaViewLeakResult(
+        WeakReference DocumentRef,
+        WeakReference ToolRef,
+        WeakReference DocumentHostRef,
+        WeakReference ToolHostRef,
+        WeakReference DocumentViewRef,
+        WeakReference ToolViewRef);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/BindingLeakTests.cs b/tests/Dock.Avalonia.LeakTests/BindingLeakTests.cs
new file mode 100644
index 000000000..7444cb2a9
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/BindingLeakTests.cs
@@ -0,0 +1,70 @@
+using System;
+using System.ComponentModel;
+using Avalonia.Controls;
+using Avalonia.Data;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class BindingLeakTests
+{
+    private sealed class BindingViewModel : INotifyPropertyChanged
+    {
+        private bool _isGlobalDockActive;
+
+        public bool IsGlobalDockActive
+        {
+            get => _isGlobalDockActive;
+            set
+            {
+                if (_isGlobalDockActive == value)
+                {
+                    return;
+                }
+
+                _isGlobalDockActive = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsGlobalDockActive)));
+            }
+        }
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+    }
+
+    private sealed record BindingLeakResult(WeakReference ViewModelRef, DockTarget Target);
+
+    [ReleaseFact]
+    public void Binding_Clears_DataContext_DoesNotLeak_ViewModel()
+    {
+        var result = RunInSession(() =>
+        {
+            var viewModel = new BindingViewModel { IsGlobalDockActive = true };
+
+            var target = new DockTarget();
+            target.Bind(DockTargetBase.IsGlobalDockActiveProperty,
+                new Binding(nameof(BindingViewModel.IsGlobalDockActive)) { Mode = BindingMode.TwoWay });
+            target.DataContext = viewModel;
+
+            var window = new Window { Content = target };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+
+            target.DataContext = null;
+            DrainDispatcher();
+
+            var result = new BindingLeakResult(new WeakReference(viewModel), target);
+            CleanupWindow(window);
+            return result;
+        });
+
+        AssertCollected(result.ViewModelRef);
+        System.GC.KeepAlive(result.Target);
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/ContentControlDetachLeakTests.cs b/tests/Dock.Avalonia.LeakTests/ContentControlDetachLeakTests.cs
new file mode 100644
index 000000000..d8fd8dcd9
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/ContentControlDetachLeakTests.cs
@@ -0,0 +1,122 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Core;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class ContentControlDetachLeakTests
+{
+    [ReleaseFact]
+    public void DocumentContentControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+
+            var control = new DocumentContentControl
+            {
+                DataContext = context.Document
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            var wasRegistered = context.Factory.DocumentControls.ContainsKey(context.Document);
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var stillRegistered = context.Factory.DocumentControls.ContainsKey(context.Document);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new ContentControlLeakResult(controlRef, window, context.Factory, context.Document, wasRegistered, stillRegistered, detached);
+        });
+
+        Assert.True(result.WasRegistered, "DocumentContentControl did not register with the factory.");
+        Assert.False(result.StillRegistered, "DocumentContentControl remained registered after detach.");
+        Assert.True(result.DetachedFromVisualTree, "DocumentContentControl did not detach from visual tree.");
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.ControlRef);
+        }
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+        GC.KeepAlive(result.DockableKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void ToolContentControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+
+            var control = new ToolContentControl
+            {
+                DataContext = context.Tool
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            var wasRegistered = context.Factory.ToolControls.ContainsKey(context.Tool);
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var stillRegistered = context.Factory.ToolControls.ContainsKey(context.Tool);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new ContentControlLeakResult(controlRef, window, context.Factory, context.Tool, wasRegistered, stillRegistered, detached);
+        });
+
+        Assert.True(result.WasRegistered, "ToolContentControl did not register with the factory.");
+        Assert.False(result.StillRegistered, "ToolContentControl remained registered after detach.");
+        Assert.True(result.DetachedFromVisualTree, "ToolContentControl did not detach from visual tree.");
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.ControlRef);
+        }
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+        GC.KeepAlive(result.DockableKeepAlive);
+    }
+
+    private sealed record ContentControlLeakResult(
+        WeakReference ControlRef,
+        Window WindowKeepAlive,
+        IFactory FactoryKeepAlive,
+        IDockable DockableKeepAlive,
+        bool WasRegistered,
+        bool StillRegistered,
+        bool DetachedFromVisualTree);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/ControlDetachLeakTests.cs b/tests/Dock.Avalonia.LeakTests/ControlDetachLeakTests.cs
new file mode 100644
index 000000000..bb2b18282
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/ControlDetachLeakTests.cs
@@ -0,0 +1,474 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Core;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestCaseHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class ControlDetachLeakTests
+{
+    [ReleaseFact]
+    public void DocumentControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            context.DocumentDock.CanCreateDocument = true;
+
+            var control = new DocumentControl
+            {
+                DataContext = context.DocumentDock
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            RaisePointerPressed(control, MouseButton.Left);
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new ControlDetachLeakResult(controlRef, window, context.DocumentDock, context.Factory, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "DocumentControl did not detach from visual tree.");
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.ControlRef);
+        }
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void ToolControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+
+            var control = new ToolControl
+            {
+                DataContext = context.ToolDock
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            RaisePointerPressed(control, MouseButton.Left);
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new ControlDetachLeakResult(controlRef, window, context.ToolDock, context.Factory, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "ToolControl did not detach from visual tree.");
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.ControlRef);
+        }
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void RootDockControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+
+            var control = new RootDockControl
+            {
+                DataContext = context.Root
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            var mainContent = FindTemplateChild<ContentControl>(control, "PART_MainContent");
+            if (mainContent is not null)
+            {
+                RaisePointerPressed(mainContent, MouseButton.Left);
+            }
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new RootControlDetachLeakResult(controlRef, window, context.Root, context.Factory, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "RootDockControl did not detach from visual tree.");
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.RootKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void DocumentDockControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+
+            var control = new DocumentDockControl
+            {
+                DataContext = context.DocumentDock
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            var wasRegistered = context.Factory.VisibleDockableControls.ContainsKey(context.DocumentDock);
+
+            window.Content = null;
+            DrainDispatcher();
+            window.UpdateLayout();
+            DrainDispatcher();
+            ClearInputState(window);
+            ResetDispatcherForUnitTests();
+
+            var stillRegistered = context.Factory.VisibleDockableControls.ContainsKey(context.DocumentDock);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new DockableDockDetachLeakResult(
+                controlRef,
+                window,
+                context.DocumentDock,
+                context.Factory,
+                wasRegistered,
+                stillRegistered,
+                detached);
+        });
+
+        Assert.True(result.WasRegistered, "DocumentDockControl did not register with the factory.");
+        Assert.False(result.StillRegistered, "DocumentDockControl remained registered after detach.");
+        Assert.True(result.DetachedFromVisualTree, "DocumentDockControl did not detach from visual tree.");
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.ControlRef);
+        }
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void ToolDockControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+
+            var control = new ToolDockControl
+            {
+                DataContext = context.ToolDock
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            var wasRegistered = context.Factory.VisibleDockableControls.ContainsKey(context.ToolDock);
+
+            window.Content = null;
+            DrainDispatcher();
+            window.UpdateLayout();
+            DrainDispatcher();
+            ClearInputState(window);
+            ResetDispatcherForUnitTests();
+
+            var stillRegistered = context.Factory.VisibleDockableControls.ContainsKey(context.ToolDock);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new DockableDockDetachLeakResult(
+                controlRef,
+                window,
+                context.ToolDock,
+                context.Factory,
+                wasRegistered,
+                stillRegistered,
+                detached);
+        });
+
+        Assert.True(result.WasRegistered, "ToolDockControl did not register with the factory.");
+        Assert.False(result.StillRegistered, "ToolDockControl remained registered after detach.");
+        Assert.True(result.DetachedFromVisualTree, "ToolDockControl did not detach from visual tree.");
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.ControlRef);
+        }
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void DocumentDockControl_DetachWhileWindowAlive_DoesNotLeak_InnerControls()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+
+            var control = new DocumentDockControl
+            {
+                DataContext = context.DocumentDock
+            };
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            var documentControl = FindVisualDescendant<DocumentControl>(control);
+            var mdiControl = FindVisualDescendant<MdiDocumentControl>(control);
+
+            var documentDetached = false;
+            var mdiDetached = false;
+
+            if (documentControl is not null)
+            {
+                documentControl.DetachedFromVisualTree += (_, _) => documentDetached = true;
+            }
+
+            if (mdiControl is not null)
+            {
+                mdiControl.DetachedFromVisualTree += (_, _) => mdiDetached = true;
+            }
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+            ResetDispatcherForUnitTests();
+
+            var documentRef = documentControl is null ? null : new WeakReference(documentControl);
+            var mdiRef = mdiControl is null ? null : new WeakReference(mdiControl);
+            documentControl = null;
+            mdiControl = null;
+
+            return new DocumentDockInnerControlLeakResult(
+                documentRef,
+                mdiRef,
+                window,
+                documentDetached,
+                mdiDetached);
+        });
+
+        if (result.DocumentControlRef is not null)
+        {
+            Assert.True(result.DocumentDetached, "DocumentControl did not detach from visual tree.");
+        }
+
+        if (result.MdiControlRef is not null)
+        {
+            Assert.True(result.MdiDetached, "MdiDocumentControl did not detach from visual tree.");
+        }
+
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            if (result.DocumentControlRef is not null)
+            {
+                AssertCollected(result.DocumentControlRef);
+            }
+
+            if (result.MdiControlRef is not null)
+            {
+                AssertCollected(result.MdiControlRef);
+            }
+        }
+
+        GC.KeepAlive(result.WindowKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void ToolDockControl_DetachWhileWindowAlive_DoesNotLeak_InnerControls()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+
+            var control = new ToolDockControl
+            {
+                DataContext = context.ToolDock
+            };
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            var chromeControl = FindVisualDescendant<ToolChromeControl>(control);
+            var toolControl = FindVisualDescendant<ToolControl>(control);
+
+            var chromeDetached = false;
+            var toolDetached = false;
+
+            if (chromeControl is not null)
+            {
+                chromeControl.DetachedFromVisualTree += (_, _) => chromeDetached = true;
+            }
+
+            if (toolControl is not null)
+            {
+                toolControl.DetachedFromVisualTree += (_, _) => toolDetached = true;
+            }
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+            ResetDispatcherForUnitTests();
+
+            var chromeRef = chromeControl is null ? null : new WeakReference(chromeControl);
+            var toolRef = toolControl is null ? null : new WeakReference(toolControl);
+            chromeControl = null;
+            toolControl = null;
+
+            return new ToolDockInnerControlLeakResult(
+                chromeRef,
+                toolRef,
+                window,
+                chromeDetached,
+                toolDetached);
+        });
+
+        if (result.ChromeControlRef is not null)
+        {
+            Assert.True(result.ChromeDetached, "ToolChromeControl did not detach from visual tree.");
+        }
+
+        if (result.ToolControlRef is not null)
+        {
+            Assert.True(result.ToolDetached, "ToolControl did not detach from visual tree.");
+        }
+
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            if (result.ChromeControlRef is not null)
+            {
+                AssertCollected(result.ChromeControlRef);
+            }
+
+            if (result.ToolControlRef is not null)
+            {
+                AssertCollected(result.ToolControlRef);
+            }
+        }
+
+        GC.KeepAlive(result.WindowKeepAlive);
+    }
+
+    private sealed record ControlDetachLeakResult(
+        WeakReference ControlRef,
+        Window WindowKeepAlive,
+        IDock DockKeepAlive,
+        IFactory FactoryKeepAlive,
+        bool DetachedFromVisualTree);
+
+    private sealed record RootControlDetachLeakResult(
+        WeakReference ControlRef,
+        Window WindowKeepAlive,
+        IDock RootKeepAlive,
+        IFactory FactoryKeepAlive,
+        bool DetachedFromVisualTree);
+
+    private sealed record DockableDockDetachLeakResult(
+        WeakReference ControlRef,
+        Window WindowKeepAlive,
+        IDock DockKeepAlive,
+        IFactory FactoryKeepAlive,
+        bool WasRegistered,
+        bool StillRegistered,
+        bool DetachedFromVisualTree);
+
+    private sealed record DocumentDockInnerControlLeakResult(
+        WeakReference? DocumentControlRef,
+        WeakReference? MdiControlRef,
+        Window WindowKeepAlive,
+        bool DocumentDetached,
+        bool MdiDetached);
+
+    private sealed record ToolDockInnerControlLeakResult(
+        WeakReference? ChromeControlRef,
+        WeakReference? ToolControlRef,
+        Window WindowKeepAlive,
+        bool ChromeDetached,
+        bool ToolDetached);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/ControlInputLeakTests.cs b/tests/Dock.Avalonia.LeakTests/ControlInputLeakTests.cs
new file mode 100644
index 000000000..fc65bbb60
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/ControlInputLeakTests.cs
@@ -0,0 +1,17 @@
+using Xunit;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class ControlInputLeakTests
+{
+    [ReleaseFact]
+    public void AllControls_InputInteractions_DoesNotLeak()
+    {
+        foreach (var testCase in LeakTestCases.ControlCases)
+        {
+            var result = LeakTestCaseRunner.RunControlCase(testCase, exerciseInput: true);
+            LeakTestCaseRunner.AssertCollectedForCase(result, keepAlive: true);
+        }
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/ControlLifecycleLeakTests.cs b/tests/Dock.Avalonia.LeakTests/ControlLifecycleLeakTests.cs
new file mode 100644
index 000000000..707024aab
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/ControlLifecycleLeakTests.cs
@@ -0,0 +1,113 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Controls.Overlays;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Avalonia;
+using Dock.Model.Core;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class ControlLifecycleLeakTests
+{
+    [ReleaseFact]
+    public void DockControl_AttachDetach_DoesNotLeak()
+    {
+        var factory = new Factory();
+
+        var (controlRef, layoutRef) = RunInSession(() =>
+        {
+            var layout = factory.CreateLayout();
+            layout.Factory = factory;
+
+            var dockControl = new DockControl
+            {
+                Factory = factory,
+                Layout = layout
+            };
+
+            var window = new Window { Content = dockControl };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+
+            var result = (new WeakReference(dockControl), new WeakReference(layout));
+            CleanupWindow(window);
+            return result;
+        });
+
+        AssertCollected(controlRef, layoutRef);
+        System.GC.KeepAlive(factory);
+    }
+
+    [ReleaseFact]
+    public void DockableControl_Detach_DoesNotLeak_Dockable()
+    {
+        var factory = new Factory();
+
+        var (controlRef, dockableRef) = RunInSession(() =>
+        {
+            var dockable = factory.CreateDocument();
+            dockable.Factory = factory;
+
+            var control = new DockableControl
+            {
+                TrackingMode = TrackingMode.Visible,
+                DataContext = dockable
+            };
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+
+            var result = (new WeakReference(control), new WeakReference(dockable));
+            CleanupWindow(window);
+            return result;
+        });
+
+        AssertCollected(controlRef, dockableRef);
+        System.GC.KeepAlive(factory);
+    }
+
+    [ReleaseFact]
+    public void OverlayHost_Detach_DoesNotLeak_StaticRegistry()
+    {
+        var hostRef = RunInSession(() =>
+        {
+            var host = new OverlayHost
+            {
+                Content = new Border()
+            };
+
+            var window = new Window { Content = host };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+
+            var reference = new WeakReference(host);
+            CleanupWindow(window);
+            return reference;
+        });
+
+        AssertCollected(hostRef);
+    }
+
+    [ReleaseFact]
+    public void AllControls_AttachDetach_DoesNotLeak()
+    {
+        foreach (var testCase in LeakTestCases.ControlCases)
+        {
+            var result = LeakTestCaseRunner.RunControlCase(testCase, exerciseInput: false);
+            LeakTestCaseRunner.AssertCollectedForCase(result, keepAlive: true);
+        }
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/Dock.Avalonia.LeakTests.csproj b/tests/Dock.Avalonia.LeakTests/Dock.Avalonia.LeakTests.csproj
new file mode 100644
index 000000000..c72c82641
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/Dock.Avalonia.LeakTests.csproj
@@ -0,0 +1,34 @@
+<Project Sdk="Microsoft.NET.Sdk" ToolsVersion="15.0">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <OutputType>Library</OutputType>
+    <IsPackable>False</IsPackable>
+    <IsTestProject>True</IsTestProject>
+    <GenerateAssemblyInfo>False</GenerateAssemblyInfo>
+    <GenerateRuntimeConfigurationFiles>True</GenerateRuntimeConfigurationFiles>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <Import Project="..\..\build\Avalonia.props" />
+  <Import Project="..\..\build\Avalonia.Headless.props" />
+  <Import Project="..\..\build\XUnit.props" />
+  <Import Project="..\..\build\SignAssembly.props" />
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Dock.Avalonia\Dock.Avalonia.csproj" />
+    <ProjectReference Include="..\..\src\Dock.Avalonia.Themes.Fluent\Dock.Avalonia.Themes.Fluent.csproj" />
+    <ProjectReference Include="..\..\src\Dock.Avalonia.Themes.Simple\Dock.Avalonia.Themes.Simple.csproj" />
+    <ProjectReference Include="..\..\src\Dock.Model.Avalonia\Dock.Model.Avalonia.csproj" />
+    <ProjectReference Include="..\..\src\Dock.Model.Mvvm\Dock.Model.Mvvm.csproj" />
+    <ProjectReference Include="..\..\src\Dock.Model.ReactiveUI\Dock.Model.ReactiveUI.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/Dock.Avalonia.LeakTests/DockCommandBarManagerLeakTests.cs b/tests/Dock.Avalonia.LeakTests/DockCommandBarManagerLeakTests.cs
new file mode 100644
index 000000000..755333291
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/DockCommandBarManagerLeakTests.cs
@@ -0,0 +1,184 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.CommandBars;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Avalonia;
+using Dock.Model.Avalonia.Controls;
+using Dock.Model.CommandBars;
+using Dock.Model.Controls;
+using Dock.Model.Core;
+using Dock.Settings;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestCaseHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class DockCommandBarManagerLeakTests
+{
+    [ReleaseFact]
+    public void DockCommandBarManager_Detach_DoesNotLeak_WhenFactoryAlive()
+    {
+        var result = RunInSession(() =>
+        {
+            var previousMerging = DockSettings.CommandBarMergingEnabled;
+            var previousScope = DockSettings.CommandBarMergingScope;
+            DockSettings.CommandBarMergingEnabled = true;
+            DockSettings.CommandBarMergingScope = DockCommandBarMergingScope.ActiveDockable;
+
+            try
+            {
+                var factory = new Factory();
+                var root = (IRootDock)factory.CreateRootDock();
+                root.Factory = factory;
+                root.VisibleDockables = factory.CreateList<IDockable>();
+
+                var document = (Document)factory.CreateDocument();
+                document.Factory = factory;
+
+                var provider = new TestCommandBarProvider();
+                document.Context = provider;
+
+                var documentDock = (DocumentDock)factory.CreateDocumentDock();
+                documentDock.Factory = factory;
+                documentDock.VisibleDockables = factory.CreateList<IDockable>(document);
+                documentDock.ActiveDockable = document;
+                document.Owner = documentDock;
+
+                root.VisibleDockables.Add(documentDock);
+                root.ActiveDockable = documentDock;
+                root.DefaultDockable = documentDock;
+
+                var host = new DockCommandBarHost();
+                var manager = new DockCommandBarManager(host);
+                manager.Attach(root);
+
+                factory.SetActiveDockable(document);
+                provider.RaiseChanged();
+                DrainDispatcher();
+
+                manager.Detach();
+
+                var managerRef = new WeakReference(manager);
+                manager = null;
+
+                return new DockCommandBarManagerLeakResult(managerRef, host, factory, root, provider);
+            }
+            finally
+            {
+                DockSettings.CommandBarMergingEnabled = previousMerging;
+                DockSettings.CommandBarMergingScope = previousScope;
+            }
+        });
+
+        AssertCollected(result.ManagerRef);
+        GC.KeepAlive(result.HostKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+        GC.KeepAlive(result.LayoutKeepAlive);
+        GC.KeepAlive(result.ProviderKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void DockCommandBarHost_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var command = new NoOpCommand();
+            var menuItem = new MenuItem { Header = "File" };
+            var openItem = new MenuItem { Header = "Open", Command = command };
+            var exitItem = new MenuItem { Header = "Exit", Command = command };
+            menuItem.ItemsSource = new object[]
+            {
+                openItem,
+                new Separator(),
+                exitItem
+            };
+
+            var menu = new Menu
+            {
+                ItemsSource = new object[]
+                {
+                    menuItem
+                }
+            };
+
+            var toolButton = new Button { Content = "Action", Command = command };
+            var toolBar = new StackPanel { Orientation = global::Avalonia.Layout.Orientation.Horizontal };
+            toolBar.Children.Add(toolButton);
+
+            var ribbonButton = new Button { Content = "Ribbon", Command = command };
+            var ribbonBar = new StackPanel { Orientation = global::Avalonia.Layout.Orientation.Horizontal };
+            ribbonBar.Children.Add(ribbonButton);
+
+            var host = new DockCommandBarHost
+            {
+                MenuBars = new Control[] { menu },
+                ToolBars = new Control[] { toolBar },
+                RibbonBars = new Control[] { ribbonBar },
+                IsVisible = true
+            };
+            var detached = false;
+            host.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = host };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            host.ApplyTemplate();
+            host.UpdateLayout();
+            DrainDispatcher();
+
+            ExerciseButtonInteractions(toolButton);
+            ExerciseButtonInteractions(ribbonButton);
+
+            window.Content = null;
+            DrainDispatcher();
+            window.UpdateLayout();
+            DrainDispatcher();
+            ClearInputState(window);
+            ResetDispatcherForUnitTests();
+
+            var hostRef = new WeakReference(host);
+            host = null;
+
+            return new DockCommandBarHostLeakResult(hostRef, window, command, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "DockCommandBarHost did not detach from visual tree.");
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.HostRef);
+        }
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.CommandKeepAlive);
+    }
+
+    private sealed class TestCommandBarProvider : IDockCommandBarProvider
+    {
+        public event EventHandler? CommandBarsChanged;
+
+        public IReadOnlyList<DockCommandBarDefinition> GetCommandBars() =>
+            Array.Empty<DockCommandBarDefinition>();
+
+        public void RaiseChanged() => CommandBarsChanged?.Invoke(this, EventArgs.Empty);
+    }
+
+    private sealed record DockCommandBarManagerLeakResult(
+        WeakReference ManagerRef,
+        DockCommandBarHost HostKeepAlive,
+        IFactory FactoryKeepAlive,
+        IDock LayoutKeepAlive,
+        TestCommandBarProvider ProviderKeepAlive);
+
+    private sealed record DockCommandBarHostLeakResult(
+        WeakReference HostRef,
+        Window WindowKeepAlive,
+        NoOpCommand CommandKeepAlive,
+        bool DetachedFromVisualTree);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/DockControlDragLeakTests.cs b/tests/Dock.Avalonia.LeakTests/DockControlDragLeakTests.cs
new file mode 100644
index 000000000..5fd4fd25e
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/DockControlDragLeakTests.cs
@@ -0,0 +1,107 @@
+using System;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class DockControlDragLeakTests
+{
+    [ReleaseFact]
+    public void DockControl_DragDockable_ShowsAndCleansOverlays_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            context.Document.CanDrag = true;
+            context.Document.CanFloat = true;
+            context.Root.ActiveDockable = context.DocumentDock;
+            context.Root.DefaultDockable = context.DocumentDock;
+
+            var dockControl = new DockControl
+            {
+                Factory = context.Factory,
+                Layout = context.Root,
+                InitializeFactory = true,
+                InitializeLayout = true
+            };
+            var window = new Window { Content = dockControl };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            DrainDispatcher();
+            dockControl.ApplyTemplate();
+            dockControl.UpdateLayout();
+            DrainDispatcher();
+
+            var documentDockControl = FindVisualDescendant<DocumentDockControl>(dockControl);
+            if (documentDockControl is not null)
+            {
+                documentDockControl.ApplyTemplate();
+                documentDockControl.UpdateLayout();
+                DrainDispatcher();
+            }
+
+            var documentControl = FindVisualDescendant<DocumentControl>(dockControl);
+            if (documentControl is not null)
+            {
+                documentControl.ApplyTemplate();
+                documentControl.UpdateLayout();
+                DrainDispatcher();
+            }
+
+            var tabStrip = FindVisualDescendant<DocumentTabStrip>(dockControl);
+            if (tabStrip is not null)
+            {
+                tabStrip.ApplyTemplate();
+                tabStrip.UpdateLayout();
+                DrainDispatcher();
+            }
+
+            var tabItem = tabStrip?.ContainerFromIndex(0) as DocumentTabStripItem
+                          ?? FindVisualDescendant<DocumentTabStripItem>(dockControl);
+            if (tabStrip is null)
+            {
+                TraceVisualTree(dockControl, "DockControl_DragDockable/visuals");
+            }
+            Assert.NotNull(tabStrip);
+            Assert.NotNull(tabItem);
+
+            var startPoint = new Point(tabItem!.Bounds.Width / 2, tabItem.Bounds.Height / 2);
+            var outsideInItems = new Point(tabStrip!.Bounds.Width + 100, tabStrip.Bounds.Height + 100);
+            var outsideInTab = tabStrip.TranslatePoint(outsideInItems, tabItem)
+                               ?? new Point(startPoint.X + tabStrip.Bounds.Width + 100,
+                                   startPoint.Y + tabStrip.Bounds.Height + 100);
+
+            RaisePointerPressed(tabItem, startPoint, MouseButton.Left);
+            RaisePointerMoved(tabItem, outsideInTab, leftPressed: true);
+            DrainDispatcher();
+
+            var dragStarted = dockControl.IsDraggingDock || dockControl.IsOpen;
+
+            var dockPoint = new Point(dockControl.Bounds.Width / 2, dockControl.Bounds.Height / 2);
+            RaisePointerMoved(dockControl, dockPoint, leftPressed: true);
+            RaisePointerReleased(dockControl, dockPoint, MouseButton.Left);
+            DrainDispatcher();
+
+            var result = new DragLeakResult(
+                new WeakReference(dockControl),
+                new WeakReference(context.Root),
+                dragStarted);
+
+            CleanupWindow(window);
+            return result;
+        });
+
+        Assert.True(result.DragStarted, "Dock drag did not start.");
+        AssertCollected(result.ControlRef, result.LayoutRef);
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/DockControlEventLeakTests.cs b/tests/Dock.Avalonia.LeakTests/DockControlEventLeakTests.cs
new file mode 100644
index 000000000..a0942b7f2
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/DockControlEventLeakTests.cs
@@ -0,0 +1,54 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class DockControlEventLeakTests
+{
+    private sealed record FactoryEventLeakResult(WeakReference ControlRef, object FactoryKeepAlive);
+
+    [ReleaseFact]
+    public void DockControl_FactoryEventSubscription_DoesNotLeak_WhenFactoryAlive()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            context.Root.ActiveDockable = context.DocumentDock;
+            context.Root.DefaultDockable = context.DocumentDock;
+
+            var dockControl = new DockControl
+            {
+                Factory = context.Factory,
+                Layout = context.Root,
+                InitializeFactory = true,
+                InitializeLayout = true
+            };
+
+            var window = new Window { Content = dockControl };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            context.Factory.SetActiveDockable(context.Document);
+            DrainDispatcher();
+
+            var result = new FactoryEventLeakResult(
+                new WeakReference(dockControl),
+                context.Factory);
+
+            CleanupWindow(window);
+            ClearFactoryCaches(context.Factory);
+            return result;
+        });
+
+        AssertCollected(result.ControlRef);
+        System.GC.KeepAlive(result.FactoryKeepAlive);
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/DockControlFloatingLeakTests.cs b/tests/Dock.Avalonia.LeakTests/DockControlFloatingLeakTests.cs
new file mode 100644
index 000000000..09c86f329
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/DockControlFloatingLeakTests.cs
@@ -0,0 +1,168 @@
+using System;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Core;
+using Dock.Settings;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class DockControlFloatingLeakTests
+{
+    [ReleaseFact]
+    public void DockControl_FloatDockable_NativeHost_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var previousMode = DockSettings.FloatingWindowHostMode;
+            DockSettings.FloatingWindowHostMode = DockFloatingWindowHostMode.Native;
+
+            try
+            {
+                var context = LeakContext.Create();
+                context.Document.CanFloat = true;
+                context.Root.ActiveDockable = context.DocumentDock;
+                context.Root.DefaultDockable = context.DocumentDock;
+
+                var dockControl = new DockControl
+                {
+                    Factory = context.Factory,
+                    Layout = context.Root,
+                    InitializeFactory = true,
+                    InitializeLayout = true
+                };
+                var window = new Window { Content = dockControl };
+                window.Styles.Add(new FluentTheme());
+                window.Styles.Add(new DockFluentTheme());
+
+                ShowWindow(window);
+
+                context.Factory.FloatDockable(context.Document);
+                DrainDispatcher();
+
+                var dockWindow = context.Root.Windows?.FirstOrDefault();
+                Assert.NotNull(dockWindow);
+
+                var host = dockWindow!.Host;
+                var hostWindow = host as Window;
+
+                var result = new FloatLeakResult(
+                    new WeakReference(dockControl),
+                    new WeakReference(context.Root),
+                    dockWindow is null ? null : new WeakReference(dockWindow),
+                    host is null ? null : new WeakReference(host),
+                    hostWindow is null ? null : new WeakReference(hostWindow));
+
+                context.Factory.RemoveWindow(dockWindow!);
+                DrainDispatcher();
+
+                if (hostWindow is not null)
+                {
+                    CleanupWindow(hostWindow);
+                }
+
+                CleanupWindow(window);
+                return result;
+            }
+            finally
+            {
+                DockSettings.FloatingWindowHostMode = previousMode;
+            }
+        });
+
+        AssertCollected(result.ControlRef, result.LayoutRef);
+        if (result.DockWindowRef is not null)
+        {
+            AssertCollected(result.DockWindowRef);
+        }
+        if (result.HostRef is not null)
+        {
+            AssertCollected(result.HostRef);
+        }
+        if (result.HostWindowRef is not null)
+        {
+            AssertCollected(result.HostWindowRef);
+        }
+    }
+
+    [ReleaseFact]
+    public void DockControl_FloatDockable_ManagedHost_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var previousMode = DockSettings.FloatingWindowHostMode;
+            DockSettings.FloatingWindowHostMode = DockFloatingWindowHostMode.Managed;
+
+            try
+            {
+                var context = LeakContext.Create();
+                context.Document.CanFloat = true;
+                context.Root.ActiveDockable = context.DocumentDock;
+                context.Root.DefaultDockable = context.DocumentDock;
+
+                var dockControl = new DockControl
+                {
+                    Factory = context.Factory,
+                    Layout = context.Root,
+                    InitializeFactory = true,
+                    InitializeLayout = true
+                };
+                var window = new Window { Content = dockControl };
+                window.Styles.Add(new FluentTheme());
+                window.Styles.Add(new DockFluentTheme());
+
+                ShowWindow(window);
+
+                context.Factory.FloatDockable(context.Document);
+                DrainDispatcher();
+
+                var dockWindow = context.Root.Windows?.FirstOrDefault();
+                Assert.NotNull(dockWindow);
+
+                var host = dockWindow!.Host;
+                Assert.IsType<ManagedHostWindow>(host);
+
+                var managedLayer = FindVisualDescendant<ManagedWindowLayer>(dockControl);
+                var managedDock = managedLayer?.Dock;
+                var managedDocument = managedDock?.VisibleDockables?.OfType<ManagedDockWindowDocument>().FirstOrDefault();
+
+                var result = new ManagedFloatLeakResult(
+                    new WeakReference(dockControl),
+                    new WeakReference(context.Root),
+                    dockWindow is null ? null : new WeakReference(dockWindow),
+                    host is null ? null : new WeakReference(host),
+                    managedDocument is null ? null : new WeakReference(managedDocument));
+
+                context.Factory.RemoveWindow(dockWindow!);
+                DrainDispatcher();
+
+                CleanupWindow(window);
+                return result;
+            }
+            finally
+            {
+                DockSettings.FloatingWindowHostMode = previousMode;
+            }
+        });
+
+        AssertCollected(result.ControlRef, result.LayoutRef);
+        if (result.DockWindowRef is not null)
+        {
+            AssertCollected(result.DockWindowRef);
+        }
+        if (result.HostRef is not null)
+        {
+            AssertCollected(result.HostRef);
+        }
+        if (result.ManagedDocumentRef is not null)
+        {
+            AssertCollected(result.ManagedDocumentRef);
+        }
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/DockControlInputLeakTests.cs b/tests/Dock.Avalonia.LeakTests/DockControlInputLeakTests.cs
new file mode 100644
index 000000000..576babc11
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/DockControlInputLeakTests.cs
@@ -0,0 +1,77 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class DockControlInputLeakTests
+{
+    [ReleaseFact]
+    public void DockControl_InputDetachWhileWindowAlive_LimitedInteractions_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            context.Root.ActiveDockable = context.DocumentDock;
+            context.Root.DefaultDockable = context.DocumentDock;
+
+            var dockControl = new DockControl
+            {
+                Factory = context.Factory,
+                Layout = context.Root,
+                InitializeFactory = true,
+                InitializeLayout = true
+            };
+            var detached = false;
+            dockControl.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = dockControl };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            dockControl.ApplyTemplate();
+            dockControl.UpdateLayout();
+            DrainDispatcher();
+
+            ExerciseInputInteractions(
+                dockControl,
+                interactionMask: InputInteractionMask.PointerEnterExit | InputInteractionMask.PointerMove);
+
+            window.Content = null;
+            DrainDispatcher();
+            window.UpdateLayout();
+            DrainDispatcher();
+            ClearInputState(window);
+            ClearFactoryCaches(context.Factory);
+            ResetDispatcherForUnitTests();
+
+            var controlRef = new WeakReference(dockControl);
+            dockControl = null;
+
+            return new DockControlInputLeakResult(controlRef, window, context.Factory, context.Root, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "DockControl did not detach from visual tree.");
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.ControlRef);
+        }
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+        GC.KeepAlive(result.LayoutKeepAlive);
+    }
+
+    private sealed record DockControlInputLeakResult(
+        WeakReference ControlRef,
+        Window WindowKeepAlive,
+        Dock.Model.Core.IFactory FactoryKeepAlive,
+        Dock.Model.Core.IDock LayoutKeepAlive,
+        bool DetachedFromVisualTree);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/DockControlLayoutLeakTests.cs b/tests/Dock.Avalonia.LeakTests/DockControlLayoutLeakTests.cs
new file mode 100644
index 000000000..fbfaae0ea
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/DockControlLayoutLeakTests.cs
@@ -0,0 +1,267 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Avalonia;
+using Dock.Model.CommandBars;
+using Dock.Model.Controls;
+using Dock.Model.Core;
+using Dock.Settings;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class DockControlLayoutLeakTests
+{
+    [ReleaseFact]
+    public void DockControl_SwapLayout_DoesNotLeak_PreviousLayout()
+    {
+        var result = RunInSession(() =>
+        {
+            var previousMerging = DockSettings.CommandBarMergingEnabled;
+            DockSettings.CommandBarMergingEnabled = true;
+
+            try
+            {
+                var contextA = LeakContext.Create();
+                contextA.Root.ActiveDockable = contextA.DocumentDock;
+                contextA.Root.DefaultDockable = contextA.DocumentDock;
+
+                var provider = new TestCommandBarProvider();
+                contextA.Document.Context = provider;
+
+                var contextB = LeakContext.Create();
+                contextB.Root.ActiveDockable = contextB.DocumentDock;
+                contextB.Root.DefaultDockable = contextB.DocumentDock;
+
+                var dockControl = new DockControl
+                {
+                    Factory = contextA.Factory,
+                    Layout = contextA.Root,
+                    InitializeFactory = true,
+                    InitializeLayout = true
+                };
+
+                var window = new Window { Content = dockControl };
+                window.Styles.Add(new FluentTheme());
+                window.Styles.Add(new DockFluentTheme());
+
+                ShowWindow(window);
+                DrainDispatcher();
+
+                contextA.Factory.SetActiveDockable(contextA.Document);
+                DrainDispatcher();
+
+                var result = new LayoutSwapLeakResult(
+                    new WeakReference(contextA.Root),
+                    new WeakReference(contextA.Document),
+                    new WeakReference(provider),
+                    dockControl,
+                    contextA.Factory,
+                    contextB.Root,
+                    contextB.Factory);
+
+                dockControl.Layout = contextB.Root;
+                DrainDispatcher();
+                ClearFactoryCaches(contextA.Factory);
+
+                CleanupWindow(window);
+                return result;
+            }
+            finally
+            {
+                DockSettings.CommandBarMergingEnabled = previousMerging;
+            }
+        });
+
+        AssertCollected(nameof(result.LayoutARef), result.LayoutARef);
+        AssertCollected(nameof(result.DocumentARef), result.DocumentARef);
+        AssertCollected(nameof(result.ProviderRef), result.ProviderRef);
+        GC.KeepAlive(result.DockControl);
+        GC.KeepAlive(result.FactoryA);
+        GC.KeepAlive(result.FactoryB);
+        GC.KeepAlive(result.LayoutB);
+    }
+
+    [ReleaseFact]
+    public void DockControl_ManagedLayer_DoesNotLeak_WhenFactoryLives()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            context.Root.FloatingWindowHostMode = DockFloatingWindowHostMode.Managed;
+            context.Root.ActiveDockable = context.DocumentDock;
+            context.Root.DefaultDockable = context.DocumentDock;
+
+            var dockControl = new DockControl
+            {
+                Factory = context.Factory,
+                Layout = context.Root,
+                InitializeFactory = true,
+                InitializeLayout = true
+            };
+
+            var window = new Window { Content = dockControl };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            DrainDispatcher();
+
+            var managedLayer = FindVisualDescendant<ManagedWindowLayer>(dockControl);
+            Assert.NotNull(managedLayer);
+            var wasVisible = managedLayer!.IsVisible;
+
+            var result = new ManagedLayerLeakResult(
+                new WeakReference(managedLayer),
+                wasVisible,
+                context.Factory);
+
+            CleanupWindow(window);
+            return result;
+        });
+
+        Assert.True(result.WasVisible, "Managed window layer was not enabled.");
+        AssertCollected(nameof(result.LayerRef), result.LayerRef);
+        GC.KeepAlive(result.Factory);
+    }
+
+    [ReleaseFact]
+    public void DockControl_SharedFactory_DetachOne_DoesNotLeak_OldLayout()
+    {
+        var result = RunInSession(() =>
+        {
+            var factory = new Factory();
+            var layoutA = CreateLayout(factory);
+            var layoutB = CreateLayout(factory);
+
+            var dockControlA = new DockControl
+            {
+                Factory = factory,
+                Layout = layoutA,
+                InitializeFactory = true,
+                InitializeLayout = true
+            };
+
+            var dockControlB = new DockControl
+            {
+                Factory = factory,
+                Layout = layoutB,
+                InitializeFactory = true,
+                InitializeLayout = true
+            };
+
+            var windowA = new Window { Content = dockControlA };
+            windowA.Styles.Add(new FluentTheme());
+            windowA.Styles.Add(new DockFluentTheme());
+            ShowWindow(windowA);
+
+            var windowB = new Window { Content = dockControlB };
+            windowB.Styles.Add(new FluentTheme());
+            windowB.Styles.Add(new DockFluentTheme());
+            ShowWindow(windowB);
+
+            var layoutRef = new WeakReference(layoutA);
+            var controlRef = new WeakReference(dockControlA);
+
+            CleanupWindow(windowA);
+            dockControlA = null!;
+            layoutA = null!;
+            windowA = null!;
+            DrainDispatcher();
+            ResetDispatcherForUnitTests();
+
+            CleanupWindow(windowB);
+            return new SharedFactoryLeakResult(layoutRef, controlRef, factory, layoutB, dockControlB);
+        });
+
+        AssertCollected(nameof(result.LayoutRef), result.LayoutRef);
+        AssertCollected(nameof(result.ControlRef), result.ControlRef);
+        GC.KeepAlive(result.Factory);
+        GC.KeepAlive(result.LayoutB);
+        GC.KeepAlive(result.DockControlB);
+    }
+
+    private static void AssertCollected(string name, WeakReference reference)
+    {
+        for (var attempt = 0; attempt < 20 && reference.IsAlive; attempt++)
+        {
+            CollectGarbage();
+        }
+
+        Assert.False(reference.IsAlive, $"{name} leaked");
+    }
+
+    private sealed record SharedFactoryLeakResult(
+        WeakReference LayoutRef,
+        WeakReference ControlRef,
+        IFactory Factory,
+        IRootDock LayoutB,
+        DockControl DockControlB);
+
+    private static IRootDock CreateLayout(IFactory factory)
+    {
+        var root = (IRootDock)factory.CreateRootDock();
+        root.Factory = factory;
+        root.VisibleDockables = factory.CreateList<IDockable>();
+        root.HiddenDockables ??= factory.CreateList<IDockable>();
+        root.LeftPinnedDockables ??= factory.CreateList<IDockable>();
+        root.RightPinnedDockables ??= factory.CreateList<IDockable>();
+        root.TopPinnedDockables ??= factory.CreateList<IDockable>();
+        root.BottomPinnedDockables ??= factory.CreateList<IDockable>();
+        root.Windows ??= factory.CreateList<IDockWindow>();
+
+        var tool = factory.CreateTool();
+        tool.Factory = factory;
+
+        var document = factory.CreateDocument();
+        document.Factory = factory;
+
+        var toolDock = factory.CreateToolDock();
+        toolDock.Factory = factory;
+        toolDock.VisibleDockables = factory.CreateList<IDockable>(tool);
+        toolDock.ActiveDockable = tool;
+        tool.Owner = toolDock;
+
+        var documentDock = factory.CreateDocumentDock();
+        documentDock.Factory = factory;
+        documentDock.VisibleDockables = factory.CreateList<IDockable>(document);
+        documentDock.ActiveDockable = document;
+        document.Owner = documentDock;
+
+        root.VisibleDockables.Add(toolDock);
+        root.VisibleDockables.Add(documentDock);
+        root.ActiveDockable = documentDock;
+        root.DefaultDockable = documentDock;
+        root.PinnedDock = toolDock;
+        root.LeftPinnedDockables?.Add(tool);
+
+        return root;
+    }
+
+    private sealed class TestCommandBarProvider : IDockCommandBarProvider
+    {
+        public event EventHandler? CommandBarsChanged;
+
+        public IReadOnlyList<DockCommandBarDefinition> GetCommandBars() => Array.Empty<DockCommandBarDefinition>();
+    }
+
+    private sealed record LayoutSwapLeakResult(
+        WeakReference LayoutARef,
+        WeakReference DocumentARef,
+        WeakReference ProviderRef,
+        DockControl DockControl,
+        IFactory FactoryA,
+        IRootDock LayoutB,
+        IFactory FactoryB);
+
+    private sealed record ManagedLayerLeakResult(
+        WeakReference LayerRef,
+        bool WasVisible,
+        IFactory Factory);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/DockControlLeakResults.cs b/tests/Dock.Avalonia.LeakTests/DockControlLeakResults.cs
new file mode 100644
index 000000000..a86e01749
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/DockControlLeakResults.cs
@@ -0,0 +1,27 @@
+using System;
+
+namespace Dock.Avalonia.LeakTests;
+
+internal sealed record SelectorLeakResult(WeakReference ControlRef, WeakReference LayoutRef);
+
+internal sealed record DragLeakResult(WeakReference ControlRef, WeakReference LayoutRef, bool DragStarted);
+
+internal sealed record FloatLeakResult(
+    WeakReference ControlRef,
+    WeakReference LayoutRef,
+    WeakReference? DockWindowRef,
+    WeakReference? HostRef,
+    WeakReference? HostWindowRef);
+
+internal sealed record ManagedFloatLeakResult(
+    WeakReference ControlRef,
+    WeakReference LayoutRef,
+    WeakReference? DockWindowRef,
+    WeakReference? HostRef,
+    WeakReference? ManagedDocumentRef);
+
+internal sealed record PinnedWindowLeakResult(
+    WeakReference ControlRef,
+    WeakReference LayoutRef,
+    WeakReference? PinnedWindowRef,
+    bool OverlayActive);
diff --git a/tests/Dock.Avalonia.LeakTests/DockControlOverlayWindowLeakTests.cs b/tests/Dock.Avalonia.LeakTests/DockControlOverlayWindowLeakTests.cs
new file mode 100644
index 000000000..79d4a4326
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/DockControlOverlayWindowLeakTests.cs
@@ -0,0 +1,385 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Headless;
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Core;
+using Dock.Settings;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class DockControlOverlayWindowLeakTests
+{
+    [ReleaseFact]
+    public void DockControl_DragPreviewWindow_Closes_DoesNotLeak()
+    {
+        var previousOpacity = DockSettings.DragPreviewOpacity;
+        DockSettings.DragPreviewOpacity = 0.9;
+
+        try
+        {
+            var result = RunInSession(() =>
+            {
+                var context = LeakContext.Create();
+                context.Document.CanDrag = true;
+                context.Root.ActiveDockable = context.DocumentDock;
+                context.Root.DefaultDockable = context.DocumentDock;
+
+                var dockControl = new DockControl
+                {
+                    Factory = context.Factory,
+                    Layout = context.Root,
+                    InitializeFactory = true,
+                    InitializeLayout = true
+                };
+
+                var window = new Window { Content = dockControl };
+                window.Styles.Add(new FluentTheme());
+                window.Styles.Add(new DockFluentTheme());
+
+                ShowWindow(window);
+                var tabItem = GetDocumentTabItem(dockControl, out var tabStrip);
+
+                var startPoint = new Point(tabItem!.Bounds.Width / 2, tabItem.Bounds.Height / 2);
+                var outsideInItems = new Point(tabStrip!.Bounds.Width + 100, tabStrip.Bounds.Height + 100);
+
+                BeginDockDrag(window, tabItem, tabStrip, startPoint, outsideInItems);
+                DrainDispatcher();
+
+                var dragStarted = dockControl.IsDraggingDock || dockControl.IsOpen;
+                Assert.True(dragStarted, "Dock drag did not start.");
+
+                var previewWindows = FindOpenWindows<DragPreviewWindow>();
+                var previewRefs = previewWindows.Select(window => new WeakReference(window)).ToArray();
+
+                var dockPoint = new Point(dockControl.Bounds.Width / 2, dockControl.Bounds.Height / 2);
+                EndDockDrag(window, dockControl, dockPoint);
+                DrainDispatcher();
+
+                var remainingPreviewWindows = FindOpenWindows<DragPreviewWindow>();
+                var previewClosed = remainingPreviewWindows.Count == 0
+                                    || remainingPreviewWindows.All(previewWindow => !previewWindow.IsVisible);
+
+                foreach (var previewWindow in remainingPreviewWindows)
+                {
+                    if (previewWindow.IsVisible)
+                    {
+                        previewWindow.Close();
+                    }
+                }
+
+                previewWindows.Clear();
+                remainingPreviewWindows.Clear();
+
+                CleanupWindow(window);
+
+                return new DragPreviewWindowLeakResult(
+                    previewRefs,
+                    previewClosed,
+                    window,
+                    context.Factory,
+                    context.Root);
+            });
+
+            Assert.True(result.PreviewClosed, "DragPreviewWindow did not close after drag.");
+            if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+            {
+                if (result.PreviewWindowRefs.Length > 0)
+                {
+                    AssertCollected(result.PreviewWindowRefs);
+                }
+            }
+            GC.KeepAlive(result.WindowKeepAlive);
+            GC.KeepAlive(result.FactoryKeepAlive);
+            GC.KeepAlive(result.LayoutKeepAlive);
+        }
+        finally
+        {
+            DockSettings.DragPreviewOpacity = previousOpacity;
+        }
+    }
+
+    [ReleaseFact]
+    public void DockControl_FloatingAdornerWindows_Close_DoesNotLeak()
+    {
+        var previousAdorner = DockSettings.UseFloatingDockAdorner;
+        var previousMode = DockSettings.FloatingWindowHostMode;
+        DockSettings.UseFloatingDockAdorner = true;
+        DockSettings.FloatingWindowHostMode = DockFloatingWindowHostMode.Native;
+
+        try
+        {
+            var result = RunInSession(() =>
+            {
+                var context = LeakContext.Create();
+                context.Document.CanDrag = true;
+                context.Root.ActiveDockable = context.DocumentDock;
+                context.Root.DefaultDockable = context.DocumentDock;
+
+                var dockControl = new DockControl
+                {
+                    Factory = context.Factory,
+                    Layout = context.Root,
+                    InitializeFactory = true,
+                    InitializeLayout = true
+                };
+
+                var window = new Window { Content = dockControl };
+                window.Styles.Add(new FluentTheme());
+                window.Styles.Add(new DockFluentTheme());
+
+                ShowWindow(window);
+                var tabItem = GetDocumentTabItem(dockControl, out var tabStrip);
+
+                var startPoint = new Point(tabItem!.Bounds.Width / 2, tabItem.Bounds.Height / 2);
+                var outsideInItems = new Point(tabStrip!.Bounds.Width + 100, tabStrip.Bounds.Height + 100);
+
+                BeginDockDrag(window, tabItem, tabStrip, startPoint, outsideInItems);
+                DrainDispatcher();
+
+                var dragStarted = dockControl.IsDraggingDock || dockControl.IsOpen;
+                Assert.True(dragStarted, "Dock drag did not start.");
+
+                var dockPoint = new Point(dockControl.Bounds.Width / 2, dockControl.Bounds.Height / 2);
+                var dockPointInTop = dockControl.TranslatePoint(dockPoint, window) ?? dockPoint;
+                window.MouseMove(dockPointInTop, RawInputModifiers.LeftMouseButton);
+                DrainDispatcher();
+
+                var adornerWindows = FindOpenWindows<DockAdornerWindow>();
+                var adornerRefs = adornerWindows.Select(window => new WeakReference(window)).ToArray();
+
+                window.MouseUp(dockPointInTop, MouseButton.Left, RawInputModifiers.None);
+                DrainDispatcher();
+
+                var remainingAdornerWindows = FindOpenWindows<DockAdornerWindow>();
+                var allClosed = remainingAdornerWindows.Count == 0
+                                || remainingAdornerWindows.All(adornerWindow => !adornerWindow.IsVisible);
+
+                foreach (var adornerWindow in remainingAdornerWindows)
+                {
+                    if (adornerWindow.IsVisible)
+                    {
+                        adornerWindow.Close();
+                    }
+                }
+
+                adornerWindows.Clear();
+                remainingAdornerWindows.Clear();
+
+                CleanupWindow(window);
+
+                return new DockAdornerWindowLeakResult(
+                    adornerRefs,
+                    allClosed,
+                    window,
+                    context.Factory,
+                    context.Root);
+            });
+
+            Assert.True(result.AllClosed, "DockAdornerWindow did not close after drag.");
+            if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+            {
+                if (result.AdornerRefs.Length > 0)
+                {
+                    AssertCollected(result.AdornerRefs);
+                }
+            }
+            GC.KeepAlive(result.WindowKeepAlive);
+            GC.KeepAlive(result.FactoryKeepAlive);
+            GC.KeepAlive(result.LayoutKeepAlive);
+        }
+        finally
+        {
+            DockSettings.UseFloatingDockAdorner = previousAdorner;
+            DockSettings.FloatingWindowHostMode = previousMode;
+        }
+    }
+
+    [ReleaseFact]
+    public void DockControl_ManagedDragPreviewOverlay_Clears_DoesNotLeak()
+    {
+        var previousMode = DockSettings.FloatingWindowHostMode;
+        DockSettings.FloatingWindowHostMode = DockFloatingWindowHostMode.Managed;
+
+        try
+        {
+            var result = RunInSession(() =>
+            {
+                var context = LeakContext.Create();
+                context.Root.FloatingWindowHostMode = DockFloatingWindowHostMode.Managed;
+                context.Document.CanDrag = true;
+                context.Root.ActiveDockable = context.DocumentDock;
+                context.Root.DefaultDockable = context.DocumentDock;
+
+                var dockControl = new DockControl
+                {
+                    Factory = context.Factory,
+                    Layout = context.Root,
+                    InitializeFactory = true,
+                    InitializeLayout = true
+                };
+
+                var window = new Window { Content = dockControl };
+                window.Styles.Add(new FluentTheme());
+                window.Styles.Add(new DockFluentTheme());
+
+                ShowWindow(window);
+                var managedLayer = FindVisualDescendant<ManagedWindowLayer>(dockControl);
+                Assert.NotNull(managedLayer);
+                var tabItem = GetDocumentTabItem(dockControl, out var tabStrip);
+
+                var startPoint = new Point(tabItem!.Bounds.Width / 2, tabItem.Bounds.Height / 2);
+                var outsideInItems = new Point(tabStrip!.Bounds.Width + 100, tabStrip.Bounds.Height + 100);
+
+                BeginDockDrag(window, tabItem, tabStrip, startPoint, outsideInItems);
+                DrainDispatcher();
+
+                var dragStarted = dockControl.IsDraggingDock || dockControl.IsOpen;
+                Assert.True(dragStarted, "Dock drag did not start.");
+
+                var previewControl = managedLayer is null
+                    ? null
+                    : FindVisualDescendant<DragPreviewControl>(managedLayer);
+
+                Assert.NotNull(previewControl);
+
+                var dockPoint = new Point(dockControl.Bounds.Width / 2, dockControl.Bounds.Height / 2);
+                EndDockDrag(window, dockControl, dockPoint);
+                DrainDispatcher();
+
+                var previewCleared = managedLayer is null
+                    ? true
+                    : FindVisualDescendant<DragPreviewControl>(managedLayer) is null;
+
+                var previewRef = previewControl is null ? null : new WeakReference(previewControl);
+                previewControl = null;
+
+                CleanupWindow(window);
+
+                return new ManagedDragPreviewLeakResult(
+                    previewRef,
+                    previewCleared,
+                    window,
+                    context.Factory,
+                    context.Root);
+            });
+
+            Assert.True(result.PreviewCleared, "Managed drag preview overlay was not cleared.");
+            if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+            {
+                if (result.PreviewRef is not null)
+                {
+                    AssertCollected(result.PreviewRef);
+                }
+            }
+            GC.KeepAlive(result.WindowKeepAlive);
+            GC.KeepAlive(result.FactoryKeepAlive);
+            GC.KeepAlive(result.LayoutKeepAlive);
+        }
+        finally
+        {
+            DockSettings.FloatingWindowHostMode = previousMode;
+        }
+    }
+
+    private static List<T> FindOpenWindows<T>() where T : Window
+    {
+        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime lifetime)
+        {
+            return lifetime.Windows.OfType<T>().ToList();
+        }
+
+        return new List<T>();
+    }
+
+    private static T? FindOpenWindow<T>() where T : Window
+    {
+        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime lifetime)
+        {
+            return lifetime.Windows.OfType<T>().FirstOrDefault();
+        }
+
+        return null;
+    }
+
+    private static DocumentTabStripItem GetDocumentTabItem(DockControl dockControl, out DocumentTabStrip tabStrip)
+    {
+        dockControl.ApplyTemplate();
+        dockControl.UpdateLayout();
+        DrainDispatcher();
+
+        var documentDockControl = FindVisualDescendant<DocumentDockControl>(dockControl);
+        if (documentDockControl is not null)
+        {
+            documentDockControl.ApplyTemplate();
+            documentDockControl.UpdateLayout();
+            DrainDispatcher();
+        }
+
+        var documentControl = FindVisualDescendant<DocumentControl>(dockControl);
+        if (documentControl is not null)
+        {
+            documentControl.ApplyTemplate();
+            documentControl.UpdateLayout();
+            DrainDispatcher();
+        }
+
+        tabStrip = FindVisualDescendant<DocumentTabStrip>(dockControl)
+                   ?? throw new InvalidOperationException("DocumentTabStrip was not generated.");
+
+        tabStrip.ApplyTemplate();
+        tabStrip.UpdateLayout();
+        DrainDispatcher();
+
+        return tabStrip.ContainerFromIndex(0) as DocumentTabStripItem
+               ?? FindVisualDescendant<DocumentTabStripItem>(dockControl)
+               ?? throw new InvalidOperationException("DocumentTabStripItem was not generated.");
+    }
+
+    private static void BeginDockDrag(TopLevel topLevel, Control source, Control boundsHost, Point startPoint, Point outsidePointInHost)
+    {
+        var startInTop = source.TranslatePoint(startPoint, topLevel) ?? startPoint;
+        var outsideInTop = boundsHost.TranslatePoint(outsidePointInHost, topLevel) ?? outsidePointInHost;
+        topLevel.MouseDown(startInTop, MouseButton.Left, RawInputModifiers.None);
+        topLevel.MouseMove(outsideInTop, RawInputModifiers.LeftMouseButton);
+    }
+
+    private static void EndDockDrag(TopLevel topLevel, Control dockControl, Point dockPoint)
+    {
+        var dockPointInTop = dockControl.TranslatePoint(dockPoint, topLevel) ?? dockPoint;
+        topLevel.MouseMove(dockPointInTop, RawInputModifiers.LeftMouseButton);
+        topLevel.MouseUp(dockPointInTop, MouseButton.Left, RawInputModifiers.None);
+    }
+
+    private sealed record DragPreviewWindowLeakResult(
+        WeakReference[] PreviewWindowRefs,
+        bool PreviewClosed,
+        Window WindowKeepAlive,
+        IFactory FactoryKeepAlive,
+        IDock LayoutKeepAlive);
+
+    private sealed record DockAdornerWindowLeakResult(
+        WeakReference[] AdornerRefs,
+        bool AllClosed,
+        Window WindowKeepAlive,
+        IFactory FactoryKeepAlive,
+        IDock LayoutKeepAlive);
+
+    private sealed record ManagedDragPreviewLeakResult(
+        WeakReference? PreviewRef,
+        bool PreviewCleared,
+        Window WindowKeepAlive,
+        IFactory FactoryKeepAlive,
+        IDock LayoutKeepAlive);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/DockControlPinnedLeakTests.cs b/tests/Dock.Avalonia.LeakTests/DockControlPinnedLeakTests.cs
new file mode 100644
index 000000000..8b94f4558
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/DockControlPinnedLeakTests.cs
@@ -0,0 +1,173 @@
+using System;
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Core;
+using Dock.Settings;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class DockControlPinnedLeakTests
+{
+    [ReleaseFact]
+    public void PinnedDockControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var previousPinned = DockSettings.UsePinnedDockWindow;
+        var previousMode = DockSettings.FloatingWindowHostMode;
+        DockSettings.UsePinnedDockWindow = true;
+        DockSettings.FloatingWindowHostMode = DockFloatingWindowHostMode.Native;
+
+        try
+        {
+            var result = RunInSession(() =>
+            {
+                var context = LeakContext.Create();
+                context.Factory.InitLayout(context.Root);
+                context.Root.PinnedDockDisplayMode = PinnedDockDisplayMode.Overlay;
+
+                var rootControl = new RootDockControl { DataContext = context.Root };
+                var window = new Window { Content = rootControl };
+                window.Styles.Add(new FluentTheme());
+                window.Styles.Add(new DockFluentTheme());
+
+                ShowWindow(window);
+                DrainDispatcher();
+                rootControl.ApplyTemplate();
+                rootControl.UpdateLayout();
+                DrainDispatcher();
+
+                var pinnedDockControl = FindVisualDescendant<PinnedDockControl>(rootControl);
+                Assert.NotNull(pinnedDockControl);
+
+                window.Content = new Border();
+                DrainDispatcher();
+                ClearFactoryCaches(context.Factory);
+
+                var pinnedRef = new WeakReference(pinnedDockControl);
+                pinnedDockControl = null;
+                rootControl = null;
+
+                return new PinnedDetachLeakResult(pinnedRef, window, context.Factory);
+            });
+
+            AssertCollected(result.ControlRef);
+            GC.KeepAlive(result.WindowKeepAlive);
+            GC.KeepAlive(result.FactoryKeepAlive);
+        }
+        finally
+        {
+            DockSettings.UsePinnedDockWindow = previousPinned;
+            DockSettings.FloatingWindowHostMode = previousMode;
+        }
+    }
+
+    [ReleaseFact]
+    public void PinnedDockControl_OverlayWindow_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var previousPinned = DockSettings.UsePinnedDockWindow;
+            var previousMode = DockSettings.FloatingWindowHostMode;
+            DockSettings.UsePinnedDockWindow = true;
+            DockSettings.FloatingWindowHostMode = DockFloatingWindowHostMode.Native;
+
+            try
+            {
+                var context = LeakContext.Create();
+                context.Root.PinnedDockDisplayMode = PinnedDockDisplayMode.Overlay;
+                context.Factory.InitLayout(context.Root);
+
+                var rootControl = new RootDockControl { DataContext = context.Root };
+                var window = new Window { Content = rootControl };
+                window.Styles.Add(new FluentTheme());
+                window.Styles.Add(new DockFluentTheme());
+
+                ShowWindow(window);
+                DrainDispatcher();
+                rootControl.ApplyTemplate();
+                rootControl.UpdateLayout();
+                DrainDispatcher();
+
+                var pinnedDockControl = FindVisualDescendant<PinnedDockControl>(rootControl);
+                if (pinnedDockControl is null)
+                {
+                    TraceVisualTree(rootControl, "PinnedDockControl/visuals");
+                }
+                Assert.NotNull(pinnedDockControl);
+
+                var pinnedContent = pinnedDockControl is not null
+                    ? FindVisualDescendant<ContentControl>(pinnedDockControl, control => control.Name == "PART_PinnedDock")
+                    : null;
+
+                Assert.NotNull(pinnedContent);
+                var overlayActive = pinnedContent!.Opacity == 0;
+
+                var lifetime = Application.Current?.ApplicationLifetime as IClassicDesktopStyleApplicationLifetime;
+                var pinnedWindow = lifetime?.Windows
+                    .OfType<PinnedDockWindow>()
+                    .FirstOrDefault();
+
+                var result = new PinnedWindowLeakResult(
+                    new WeakReference(rootControl),
+                    new WeakReference(context.Root),
+                    pinnedWindow is null ? null : new WeakReference(pinnedWindow),
+                    overlayActive);
+
+                context.Root.PinnedDockDisplayMode = PinnedDockDisplayMode.Inline;
+                DrainDispatcher();
+                context.Root.PinnedDock = null;
+                context.Root.LeftPinnedDockables?.Clear();
+                DrainDispatcher();
+                if (context.Root.Close.CanExecute(null))
+                {
+                    context.Root.Close.Execute(null);
+                    DrainDispatcher();
+                }
+                context.Factory.VisibleDockableControls.Clear();
+                context.Factory.VisibleRootControls.Clear();
+                context.Factory.PinnedDockableControls.Clear();
+                context.Factory.PinnedRootControls.Clear();
+                context.Factory.TabDockableControls.Clear();
+                context.Factory.TabRootControls.Clear();
+                context.Factory.ToolControls.Clear();
+                context.Factory.DocumentControls.Clear();
+                context.Factory.DockControls.Clear();
+                context.Factory.HostWindows.Clear();
+                rootControl.DataContext = null;
+                DrainDispatcher();
+
+                CleanupWindow(window);
+                return result;
+            }
+            finally
+            {
+                DockSettings.UsePinnedDockWindow = previousPinned;
+                DockSettings.FloatingWindowHostMode = previousMode;
+            }
+        });
+
+        Assert.True(result.OverlayActive, "Pinned dock overlay did not activate.");
+        if (result.PinnedWindowRef is not null)
+        {
+            AssertCollected(result.PinnedWindowRef);
+        }
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.ControlRef);
+            AssertCollected(result.LayoutRef);
+        }
+    }
+
+    private sealed record PinnedDetachLeakResult(
+        WeakReference ControlRef,
+        Window WindowKeepAlive,
+        Dock.Model.Core.IFactory FactoryKeepAlive);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/DockControlSelectorLeakTests.cs b/tests/Dock.Avalonia.LeakTests/DockControlSelectorLeakTests.cs
new file mode 100644
index 000000000..e233b2ddc
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/DockControlSelectorLeakTests.cs
@@ -0,0 +1,50 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Selectors;
+using Dock.Avalonia.Themes.Fluent;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class DockControlSelectorLeakTests
+{
+    [ReleaseFact]
+    public void DockControl_ShowHideSelector_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            var dockControl = new DockControl
+            {
+                Factory = context.Factory,
+                Layout = context.Root,
+                InitializeFactory = true,
+                InitializeLayout = true
+            };
+            var window = new Window { Content = dockControl };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+
+            dockControl.ShowSelector(DockSelectorMode.Documents);
+            DrainDispatcher();
+            dockControl.HideSelector();
+            DrainDispatcher();
+
+            var result = new SelectorLeakResult(
+                new WeakReference(dockControl),
+                new WeakReference(context.Root));
+
+            CleanupWindow(window);
+            return result;
+        });
+
+        AssertCollected(result.ControlRef, result.LayoutRef);
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/DockLayoutEventLeakTests.cs b/tests/Dock.Avalonia.LeakTests/DockLayoutEventLeakTests.cs
new file mode 100644
index 000000000..129045f76
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/DockLayoutEventLeakTests.cs
@@ -0,0 +1,180 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Controls.ProportionalStackPanel;
+using Dock.Model.Core;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestCaseHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class DockLayoutEventLeakTests
+{
+    [ReleaseFact]
+    public void GridDockControl_Loaded_AppliesDefinitions_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            context.GridDock.RowDefinitions = "Auto,*";
+            context.GridDock.ColumnDefinitions = "*,Auto";
+            context.GridDock.VisibleDockables?.Add(context.Document);
+
+            var control = new GridDockControl
+            {
+                DataContext = context.GridDock
+            };
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            var itemsControl = FindTemplateChild<ItemsControl>(control, "PART_ItemsControl");
+            var grid = itemsControl?.ItemsPanelRoot as Grid;
+
+            var controlRef = new WeakReference(control);
+            var rowCount = grid?.RowDefinitions?.Count ?? 0;
+            var columnCount = grid?.ColumnDefinitions?.Count ?? 0;
+
+            var result = new GridDockEventLeakResult(controlRef, window, rowCount, columnCount);
+            window.Content = null;
+            DrainDispatcher();
+            ClearFactoryCaches(context.Factory);
+            ClearInputState(window);
+            ResetDispatcherForUnitTests();
+            control = null;
+            return result;
+        });
+
+        Assert.True(result.RowCount >= 2, "GridDockControl did not apply row definitions.");
+        Assert.True(result.ColumnCount >= 2, "GridDockControl did not apply column definitions.");
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void ProportionalDockControl_ContainerPrepared_BindsProportion_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            var dockable = context.Document;
+            dockable.Proportion = 0.42;
+            context.ProportionalDock.VisibleDockables?.Add(dockable);
+
+            var control = new ProportionalDockControl
+            {
+                DataContext = context.ProportionalDock
+            };
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            var itemsControl = FindTemplateChild<ItemsControl>(control, "PART_ItemsControl");
+            var container = itemsControl?.ContainerFromIndex(0) as Control;
+            var proportion = container is null ? double.NaN : ProportionalStackPanel.GetProportion(container);
+
+            var controlRef = new WeakReference(control);
+            var expectedProportion = dockable.Proportion;
+
+            var result = new ProportionalDockEventLeakResult(controlRef, window, proportion, expectedProportion);
+            window.Content = null;
+            DrainDispatcher();
+            ClearFactoryCaches(context.Factory);
+            ClearInputState(window);
+            ResetDispatcherForUnitTests();
+            control = null;
+            return result;
+        });
+
+        Assert.True(!double.IsNaN(result.Proportion), "ProportionalDockControl did not set proportion.");
+        Assert.Equal(result.ExpectedProportion, result.Proportion, 3);
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void SplitViewDockControl_PaneEvents_UpdateModel_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            context.SplitViewDock.PaneDockable = context.ToolDock;
+            context.SplitViewDock.ContentDockable = context.DocumentDock;
+            context.SplitViewDock.DisplayMode = Dock.Model.Core.SplitViewDisplayMode.Overlay;
+            context.SplitViewDock.UseLightDismissOverlayMode = true;
+            context.SplitViewDock.IsPaneOpen = true;
+
+            var control = new SplitViewDockControl
+            {
+                DataContext = context.SplitViewDock
+            };
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            var splitView = FindTemplateChild<SplitView>(control, "PART_SplitView");
+            if (splitView is not null)
+            {
+                splitView.IsPaneOpen = false;
+                splitView.IsPaneOpen = true;
+            }
+            DrainDispatcher();
+
+            var controlRef = new WeakReference(control);
+            var isPaneOpen = context.SplitViewDock.IsPaneOpen;
+
+            var result = new SplitViewDockEventLeakResult(controlRef, window, isPaneOpen);
+            window.Content = null;
+            DrainDispatcher();
+            ClearFactoryCaches(context.Factory);
+            ClearInputState(window);
+            ResetDispatcherForUnitTests();
+            control = null;
+            return result;
+        });
+
+        Assert.True(result.IsPaneOpen, "SplitViewDockControl did not update model IsPaneOpen.");
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+    }
+
+    private sealed record GridDockEventLeakResult(
+        WeakReference ControlRef,
+        Window WindowKeepAlive,
+        int RowCount,
+        int ColumnCount);
+
+    private sealed record ProportionalDockEventLeakResult(
+        WeakReference ControlRef,
+        Window WindowKeepAlive,
+        double Proportion,
+        double ExpectedProportion);
+
+    private sealed record SplitViewDockEventLeakResult(
+        WeakReference ControlRef,
+        Window WindowKeepAlive,
+        bool IsPaneOpen);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/DockSelectorOverlayLeakTests.cs b/tests/Dock.Avalonia.LeakTests/DockSelectorOverlayLeakTests.cs
new file mode 100644
index 000000000..9d47f3e5e
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/DockSelectorOverlayLeakTests.cs
@@ -0,0 +1,69 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Selectors;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Core;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class DockSelectorOverlayLeakTests
+{
+    [ReleaseFact]
+    public void DockSelectorOverlay_DetachWhileWindowAlive_DoesNotLeak_WhenDockableAlive()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            var item = new DockSelectorItem(context.Document, 1, true, false, false, false, false);
+
+            var control = new DockSelectorOverlay
+            {
+                Items = new[] { item },
+                SelectedItem = item,
+                Mode = DockSelectorMode.Documents,
+                IsOpen = true
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            control.IsOpen = false;
+            control.IsOpen = true;
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new DockSelectorOverlayLeakResult(controlRef, window, context.Document, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "DockSelectorOverlay did not detach from visual tree.");
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockableKeepAlive);
+    }
+
+    private sealed record DockSelectorOverlayLeakResult(
+        WeakReference ControlRef,
+        Window WindowKeepAlive,
+        IDockable DockableKeepAlive,
+        bool DetachedFromVisualTree);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/DockTargetLeakTests.cs b/tests/Dock.Avalonia.LeakTests/DockTargetLeakTests.cs
new file mode 100644
index 000000000..dc00c4c9f
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/DockTargetLeakTests.cs
@@ -0,0 +1,99 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class DockTargetLeakTests
+{
+    [ReleaseFact]
+    public void DockTarget_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var control = new DockTarget();
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            control.ShowHorizontalTargets = false;
+            control.ShowVerticalTargets = false;
+            control.IsGlobalDockAvailable = true;
+            control.IsGlobalDockActive = true;
+            control.ShowIndicatorsOnly = true;
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new DockTargetDetachLeakResult(controlRef, window, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "DockTarget did not detach from visual tree.");
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void GlobalDockTarget_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var control = new GlobalDockTarget();
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            control.ShowHorizontalTargets = false;
+            control.ShowVerticalTargets = false;
+            control.IsGlobalDockAvailable = true;
+            control.IsGlobalDockActive = true;
+            control.ShowIndicatorsOnly = true;
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new DockTargetDetachLeakResult(controlRef, window, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "GlobalDockTarget did not detach from visual tree.");
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+    }
+
+    private sealed record DockTargetDetachLeakResult(
+        WeakReference ControlRef,
+        Window WindowKeepAlive,
+        bool DetachedFromVisualTree);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/DockableControlLeakTests.cs b/tests/Dock.Avalonia.LeakTests/DockableControlLeakTests.cs
new file mode 100644
index 000000000..208b39aa9
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/DockableControlLeakTests.cs
@@ -0,0 +1,175 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Core;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class DockableControlLeakTests
+{
+    [ReleaseFact]
+    public void DockableControl_TrackingModeVisible_DoesNotLeak_WhenDockableAlive()
+    {
+        var result = RunTrackingModeLeak(TrackingMode.Visible);
+
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.DockableKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void DockableControl_TrackingModePinned_DoesNotLeak_WhenDockableAlive()
+    {
+        var result = RunTrackingModeLeak(TrackingMode.Pinned);
+
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.DockableKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void DockableControl_TrackingModeTab_DoesNotLeak_WhenDockableAlive()
+    {
+        var result = RunTrackingModeLeak(TrackingMode.Tab);
+
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.DockableKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void DockableControl_SwapDockable_DoesNotLeak_PreviousDockable()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            var dockableA = context.Document;
+            var dockableB = context.Factory.CreateDocument();
+            dockableB.Factory = context.Factory;
+
+            var control = new DockableControl
+            {
+                TrackingMode = TrackingMode.Visible,
+                DataContext = dockableA
+            };
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+
+            control.DataContext = dockableB;
+            DrainDispatcher();
+
+            var result = new DockableControlSwapLeakResult(
+                new WeakReference(control),
+                dockableA,
+                dockableB,
+                context.Factory);
+
+            CleanupWindow(window);
+            return result;
+        });
+
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.DockableAKeepAlive);
+        GC.KeepAlive(result.DockableBKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void DockableControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            var dockable = context.Document;
+
+            var control = new DockableControl
+            {
+                TrackingMode = TrackingMode.Visible,
+                DataContext = dockable
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new DockableControlDetachLeakResult(controlRef, window, dockable, context.Factory, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "DockableControl did not detach from visual tree.");
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockableKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    private static DockableControlLeakResult RunTrackingModeLeak(TrackingMode trackingMode)
+    {
+        return RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            var dockable = context.Document;
+
+            var control = new DockableControl
+            {
+                TrackingMode = trackingMode,
+                DataContext = dockable
+            };
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+
+            var result = new DockableControlLeakResult(
+                new WeakReference(control),
+                dockable,
+                context.Factory);
+
+            CleanupWindow(window);
+            return result;
+        });
+    }
+
+    private sealed record DockableControlLeakResult(
+        WeakReference ControlRef,
+        IDockable DockableKeepAlive,
+        IFactory FactoryKeepAlive);
+
+    private sealed record DockableControlSwapLeakResult(
+        WeakReference ControlRef,
+        IDockable DockableAKeepAlive,
+        IDockable DockableBKeepAlive,
+        IFactory FactoryKeepAlive);
+
+    private sealed record DockableControlDetachLeakResult(
+        WeakReference ControlRef,
+        Window WindowKeepAlive,
+        IDockable DockableKeepAlive,
+        IFactory FactoryKeepAlive,
+        bool DetachedFromVisualTree);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/DocumentDockItemsSourceLeakTests.cs b/tests/Dock.Avalonia.LeakTests/DocumentDockItemsSourceLeakTests.cs
new file mode 100644
index 000000000..76cca122e
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/DocumentDockItemsSourceLeakTests.cs
@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using Avalonia.Collections;
+using Avalonia.Controls;
+using Dock.Model.Avalonia.Controls;
+using Dock.Model.Core;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class DocumentDockItemsSourceLeakTests
+{
+    [ReleaseFact]
+    public void DocumentDock_ItemsSourceSwap_DoesNotLeak_PreviousCollection()
+    {
+        var result = RunInSession(() =>
+        {
+            var dock = new DocumentDock
+            {
+                VisibleDockables = new AvaloniaList<IDockable>()
+            };
+
+            var itemsA = new ObservableCollection<string> { "DocA" };
+            dock.ItemsSource = itemsA;
+
+            var itemsRef = new WeakReference(itemsA);
+            itemsA = null;
+
+            var itemsB = new ObservableCollection<string> { "DocB" };
+            dock.ItemsSource = itemsB;
+
+            dock.ItemsSource = null;
+
+            return new ItemsSourceSwapLeakResult(itemsRef, dock, itemsB);
+        });
+
+        AssertCollected(result.ItemsRef);
+        GC.KeepAlive(result.DockKeepAlive);
+        GC.KeepAlive(result.ItemsKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void DocumentDock_ItemsSourceWithTemplate_DoesNotLeak_GeneratedDocuments()
+    {
+        var result = RunInSession(() =>
+        {
+            var dock = new DocumentDock
+            {
+                VisibleDockables = new AvaloniaList<IDockable>(),
+                DocumentTemplate = new DocumentTemplate
+                {
+                    Content = new Func<IServiceProvider, object>(_ => new TextBlock())
+                }
+            };
+
+            var items = new ObservableCollection<string> { "DocA", "DocB" };
+            dock.ItemsSource = items;
+
+            var generated = dock.VisibleDockables is null
+                ? new List<IDockable>()
+                : new List<IDockable>(dock.VisibleDockables);
+
+            var documentRefs = generated.ConvertAll(dockable => new WeakReference(dockable)).ToArray();
+            var generatedCount = generated.Count;
+
+            items.Clear();
+            dock.ItemsSource = null;
+
+            return new ItemsSourceTemplateLeakResult(documentRefs, generatedCount, dock, items);
+        });
+
+        Assert.True(result.GeneratedCount > 0, "DocumentDock did not generate documents from ItemsSource.");
+        Assert.True(result.DockKeepAlive.VisibleDockables?.Count == 0, "Generated documents were not cleared after ItemsSource reset.");
+
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.DocumentRefs);
+        }
+
+        GC.KeepAlive(result.DockKeepAlive);
+        GC.KeepAlive(result.ItemsKeepAlive);
+    }
+
+    private sealed record ItemsSourceSwapLeakResult(
+        WeakReference ItemsRef,
+        DocumentDock DockKeepAlive,
+        ObservableCollection<string> ItemsKeepAlive);
+
+    private sealed record ItemsSourceTemplateLeakResult(
+        WeakReference[] DocumentRefs,
+        int GeneratedCount,
+        DocumentDock DockKeepAlive,
+        ObservableCollection<string> ItemsKeepAlive);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/DocumentTabStripLeakTests.cs b/tests/Dock.Avalonia.LeakTests/DocumentTabStripLeakTests.cs
new file mode 100644
index 000000000..0e2e52684
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/DocumentTabStripLeakTests.cs
@@ -0,0 +1,134 @@
+using System;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Settings;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class DocumentTabStripLeakTests
+{
+    [ReleaseFact]
+    public void DocumentTabStrip_DragHelper_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            context.DocumentDock.CanCloseLastDockable = false;
+
+            var tabStrip = new DocumentTabStrip
+            {
+                DataContext = context.DocumentDock,
+                ItemsSource = context.DocumentDock.VisibleDockables,
+                EnableWindowDrag = true
+            };
+
+            var window = new Window { Content = tabStrip };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            tabStrip.ApplyTemplate();
+            tabStrip.UpdateLayout();
+            DrainDispatcher();
+
+            var startPoint = new Point(tabStrip.Bounds.Width / 2, tabStrip.Bounds.Height / 2);
+            var dragPoint = new Point(
+                startPoint.X + DockSettings.MinimumHorizontalDragDistance + 20,
+                startPoint.Y + DockSettings.MinimumVerticalDragDistance + 20);
+
+            RaisePointerPressed(tabStrip, startPoint, MouseButton.Left);
+            RaisePointerMoved(tabStrip, dragPoint, leftPressed: true);
+            DrainDispatcher();
+
+            window.Content = new Border();
+            DrainDispatcher();
+            ClearInputState(window);
+
+            tabStrip.ItemsSource = null;
+            tabStrip.DataContext = null;
+
+            var tabStripRef = new WeakReference(tabStrip);
+            tabStrip = null;
+
+            return new DocumentTabStripLeakResult(tabStripRef, window);
+        });
+
+        AssertCollected(result.TabStripRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void DocumentTabStripItem_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            context.DocumentDock.CanCloseLastDockable = false;
+
+            var tabStrip = new DocumentTabStrip
+            {
+                DataContext = context.DocumentDock,
+                ItemsSource = context.DocumentDock.VisibleDockables
+            };
+
+            var window = new Window { Content = tabStrip };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            tabStrip.ApplyTemplate();
+            tabStrip.UpdateLayout();
+            DrainDispatcher();
+
+            var tabItem = tabStrip.ContainerFromIndex(0) as DocumentTabStripItem
+                          ?? FindVisualDescendant<DocumentTabStripItem>(tabStrip);
+            if (tabItem is null)
+            {
+                throw new InvalidOperationException("DocumentTabStripItem was not generated.");
+            }
+
+            var startPoint = new Point(tabItem.Bounds.Width / 2, tabItem.Bounds.Height / 2);
+            var dragPoint = new Point(
+                startPoint.X + DockSettings.MinimumHorizontalDragDistance + 20,
+                startPoint.Y + DockSettings.MinimumVerticalDragDistance + 20);
+
+            RaisePointerPressed(tabItem, startPoint, MouseButton.Left);
+            RaisePointerMoved(tabItem, dragPoint, leftPressed: true);
+            DrainDispatcher();
+
+            context.DocumentDock.VisibleDockables!.Remove(context.Document);
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var itemRef = new WeakReference(tabItem);
+            tabItem = null;
+
+            return new DocumentTabStripItemLeakResult(itemRef, window, tabStrip, context.Document, context.DocumentDock);
+        });
+
+        AssertCollected(result.ItemRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.TabStripKeepAlive);
+        GC.KeepAlive(result.DocumentKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+    }
+
+    private sealed record DocumentTabStripLeakResult(
+        WeakReference TabStripRef,
+        Window WindowKeepAlive);
+
+    private sealed record DocumentTabStripItemLeakResult(
+        WeakReference ItemRef,
+        Window WindowKeepAlive,
+        DocumentTabStrip TabStripKeepAlive,
+        Dock.Model.Core.IDockable DocumentKeepAlive,
+        Dock.Model.Core.IDock DockKeepAlive);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/HostWindowDragLeakTests.cs b/tests/Dock.Avalonia.LeakTests/HostWindowDragLeakTests.cs
new file mode 100644
index 000000000..c1d66cc4e
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/HostWindowDragLeakTests.cs
@@ -0,0 +1,117 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Avalonia;
+using Dock.Model.Avalonia.Core;
+using Dock.Model.Controls;
+using Dock.Model.Core;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestCaseHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class HostWindowDragLeakTests
+{
+    [ReleaseFact]
+    public void HostWindow_TitleBarDragBegin_CallsFactory_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var factory = new TestFactory();
+            var root = (IRootDock)factory.CreateRootDock();
+            root.Factory = factory;
+            root.VisibleDockables = factory.CreateList<IDockable>();
+
+            var dockWindow = new DockWindow
+            {
+                Factory = factory,
+                Layout = root,
+                Title = "Host"
+            };
+
+            var window = new HostWindow
+            {
+                Window = dockWindow,
+                ToolChromeControlsWholeWindow = true,
+                Content = new Border()
+            };
+            dockWindow.Host = window;
+
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            window.ApplyTemplate();
+            window.UpdateLayout();
+            DrainDispatcher();
+
+            var titleBar = FindTemplateChild<HostWindowTitleBar>(window, "PART_TitleBar")
+                           ?? FindVisualDescendant<HostWindowTitleBar>(window);
+            Assert.NotNull(titleBar);
+
+            var background = titleBar is null
+                ? null
+                : FindTemplateChild<Control>(titleBar, "PART_Background");
+            Assert.NotNull(background);
+
+            if (background is not null)
+            {
+                RaisePointerPressed(background, MouseButton.Left);
+            }
+            DrainDispatcher();
+
+            window.Window = null;
+            dockWindow.Host = null;
+            ClearFactoryCaches(factory);
+
+            var result = new HostWindowDragLeakResult(
+                new WeakReference(window),
+                titleBar is null ? null : new WeakReference(titleBar),
+                dockWindow,
+                factory,
+                factory.MoveDragBeginCalled);
+
+            CleanupWindow(window);
+            window = null;
+            titleBar = null;
+
+            return result;
+        });
+
+        Assert.True(result.MoveDragBeginCalled, "Factory OnWindowMoveDragBegin was not called.");
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.WindowRef);
+            if (result.TitleBarRef is not null)
+            {
+                AssertCollected(result.TitleBarRef);
+            }
+        }
+        GC.KeepAlive(result.DockWindowKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    private sealed record HostWindowDragLeakResult(
+        WeakReference WindowRef,
+        WeakReference? TitleBarRef,
+        DockWindow DockWindowKeepAlive,
+        TestFactory FactoryKeepAlive,
+        bool MoveDragBeginCalled);
+
+    private sealed class TestFactory : Factory
+    {
+        public bool MoveDragBeginCalled { get; private set; }
+
+        public override bool OnWindowMoveDragBegin(IDockWindow? window)
+        {
+            MoveDragBeginCalled = true;
+            return false;
+        }
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/ItemDragAutoScrollLeakTests.cs b/tests/Dock.Avalonia.LeakTests/ItemDragAutoScrollLeakTests.cs
new file mode 100644
index 000000000..fb5aac0d1
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/ItemDragAutoScrollLeakTests.cs
@@ -0,0 +1,174 @@
+using System;
+using System.Collections.Generic;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Core;
+using Dock.Settings;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class ItemDragAutoScrollLeakTests
+{
+    [ReleaseFact]
+    public void ToolTabStripItem_AutoScroll_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            var tools = new List<IDockable>();
+
+            var tabStrip = new ToolTabStrip
+            {
+                Width = 180,
+                Height = 30
+            };
+
+            for (var i = 0; i < 12; i++)
+            {
+                var tool = context.Factory.CreateTool();
+                tool.Factory = context.Factory;
+                tools.Add(tool);
+
+                var item = new ToolTabStripItem
+                {
+                    DataContext = tool,
+                    Width = 120
+                };
+                tabStrip.Items.Add(item);
+            }
+
+            var targetItem = (ToolTabStripItem)tabStrip.Items[0]!;
+
+            var window = new Window { Width = 220, Height = 100, Content = tabStrip };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            tabStrip.ApplyTemplate();
+            tabStrip.UpdateLayout();
+            DrainDispatcher();
+
+            var startPoint = new Point(targetItem.Bounds.Width / 2, targetItem.Bounds.Height / 2);
+            var dragStart = new Point(
+                startPoint.X + DockSettings.MinimumHorizontalDragDistance + 20,
+                startPoint.Y);
+
+            RaisePointerPressed(targetItem, startPoint, MouseButton.Left);
+            RaisePointerMoved(targetItem, dragStart, leftPressed: true);
+            DrainDispatcher();
+
+            var edgePoint = new Point(-10, startPoint.Y);
+            RaisePointerMoved(targetItem, edgePoint, leftPressed: true);
+            DrainDispatcher();
+            RaisePointerReleased(targetItem, edgePoint, MouseButton.Left);
+            DrainDispatcher();
+
+            tabStrip.Items.Remove(targetItem);
+            DrainDispatcher();
+            tabStrip.UpdateLayout();
+            DrainDispatcher();
+
+            window.Content = new Border();
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var itemRef = new WeakReference(targetItem);
+            targetItem = null!;
+            tabStrip = null!;
+
+            return new AutoScrollLeakResult(itemRef, window, tools);
+        });
+
+        AssertCollected(result.ItemRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockablesKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void DocumentTabStripItem_AutoScroll_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            var documents = new List<IDockable>();
+
+            var tabStrip = new DocumentTabStrip
+            {
+                Width = 180,
+                Height = 30
+            };
+
+            for (var i = 0; i < 12; i++)
+            {
+                var document = context.Factory.CreateDocument();
+                document.Factory = context.Factory;
+                documents.Add(document);
+
+                var item = new DocumentTabStripItem
+                {
+                    DataContext = document,
+                    Width = 120
+                };
+                tabStrip.Items.Add(item);
+            }
+
+            var targetItem = (DocumentTabStripItem)tabStrip.Items[0]!;
+
+            var window = new Window { Width = 220, Height = 100, Content = tabStrip };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            tabStrip.ApplyTemplate();
+            tabStrip.UpdateLayout();
+            DrainDispatcher();
+
+            var startPoint = new Point(targetItem.Bounds.Width / 2, targetItem.Bounds.Height / 2);
+            var dragStart = new Point(
+                startPoint.X + DockSettings.MinimumHorizontalDragDistance + 20,
+                startPoint.Y);
+
+            RaisePointerPressed(targetItem, startPoint, MouseButton.Left);
+            RaisePointerMoved(targetItem, dragStart, leftPressed: true);
+            DrainDispatcher();
+
+            var edgePoint = new Point(-10, startPoint.Y);
+            RaisePointerMoved(targetItem, edgePoint, leftPressed: true);
+            DrainDispatcher();
+            RaisePointerReleased(targetItem, edgePoint, MouseButton.Left);
+            DrainDispatcher();
+
+            tabStrip.Items.Remove(targetItem);
+            DrainDispatcher();
+            tabStrip.UpdateLayout();
+            DrainDispatcher();
+
+            window.Content = new Border();
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var itemRef = new WeakReference(targetItem);
+            targetItem = null!;
+            tabStrip = null!;
+
+            return new AutoScrollLeakResult(itemRef, window, documents);
+        });
+
+        AssertCollected(result.ItemRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockablesKeepAlive);
+    }
+
+    private sealed record AutoScrollLeakResult(
+        WeakReference ItemRef,
+        Window WindowKeepAlive,
+        IReadOnlyList<IDockable> DockablesKeepAlive);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/LayoutDockControlLeakTests.cs b/tests/Dock.Avalonia.LeakTests/LayoutDockControlLeakTests.cs
new file mode 100644
index 000000000..5e9bf94cd
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/LayoutDockControlLeakTests.cs
@@ -0,0 +1,323 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Core;
+using Dock.Model.Controls;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestCaseHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class LayoutDockControlLeakTests
+{
+    [ReleaseFact]
+    public void GridDockControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            context.GridDock.RowDefinitions = "Auto,*";
+            context.GridDock.ColumnDefinitions = "*,*";
+
+            var control = new GridDockControl
+            {
+                DataContext = context.GridDock
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new LayoutDockControlLeakResult(controlRef, window, context.GridDock, context.Factory, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "GridDockControl did not detach from visual tree.");
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void ProportionalDockControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            context.ProportionalDock.VisibleDockables?.Add(context.Document);
+
+            var control = new ProportionalDockControl
+            {
+                DataContext = context.ProportionalDock
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new LayoutDockControlLeakResult(controlRef, window, context.ProportionalDock, context.Factory, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "ProportionalDockControl did not detach from visual tree.");
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void SplitViewDockControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            context.SplitViewDock.PaneDockable = context.ToolDock;
+            context.SplitViewDock.ContentDockable = context.DocumentDock;
+            context.SplitViewDock.DisplayMode = Dock.Model.Core.SplitViewDisplayMode.Overlay;
+            context.SplitViewDock.UseLightDismissOverlayMode = true;
+            context.SplitViewDock.IsPaneOpen = true;
+
+            var control = new SplitViewDockControl
+            {
+                DataContext = context.SplitViewDock
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            var splitView = FindTemplateChild<SplitView>(control, "PART_SplitView");
+            if (splitView is not null)
+            {
+                splitView.IsPaneOpen = false;
+                splitView.IsPaneOpen = true;
+            }
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new LayoutDockControlLeakResult(controlRef, window, context.SplitViewDock, context.Factory, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "SplitViewDockControl did not detach from visual tree.");
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.ControlRef);
+        }
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void StackDockControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+
+            var control = new StackDockControl
+            {
+                DataContext = context.StackDock
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new LayoutDockControlLeakResult(controlRef, window, context.StackDock, context.Factory, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "StackDockControl did not detach from visual tree.");
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void WrapDockControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+
+            var control = new WrapDockControl
+            {
+                DataContext = context.WrapDock
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new LayoutDockControlLeakResult(controlRef, window, context.WrapDock, context.Factory, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "WrapDockControl did not detach from visual tree.");
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void UniformGridDockControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+
+            var control = new UniformGridDockControl
+            {
+                DataContext = context.UniformGridDock
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new LayoutDockControlLeakResult(controlRef, window, context.UniformGridDock, context.Factory, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "UniformGridDockControl did not detach from visual tree.");
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void DockDockControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+
+            var control = new DockDockControl
+            {
+                DataContext = context.DockDock
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new LayoutDockControlLeakResult(controlRef, window, context.DockDock, context.Factory, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "DockDockControl did not detach from visual tree.");
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    private sealed record LayoutDockControlLeakResult(
+        WeakReference ControlRef,
+        Window WindowKeepAlive,
+        IDock DockKeepAlive,
+        IFactory FactoryKeepAlive,
+        bool DetachedFromVisualTree);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/LeakTestApp.cs b/tests/Dock.Avalonia.LeakTests/LeakTestApp.cs
new file mode 100644
index 000000000..92933032a
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/LeakTestApp.cs
@@ -0,0 +1,25 @@
+using Avalonia;
+using Avalonia.Headless;
+using Avalonia.Media;
+using Avalonia.Themes.Fluent;
+
+namespace Dock.Avalonia.LeakTests;
+
+internal sealed class LeakTestsApp : Application
+{
+    public static AppBuilder BuildAvaloniaApp() =>
+        AppBuilder.Configure<LeakTestsApp>()
+            .UseHeadless(new AvaloniaHeadlessPlatformOptions
+            {
+                UseHeadlessDrawing = true
+            })
+            .With(new FontManagerOptions
+            {
+                DefaultFamilyName = "Default"
+            });
+
+    public override void Initialize()
+    {
+        Styles.Add(new FluentTheme());
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/LeakTestCaseHelpers.cs b/tests/Dock.Avalonia.LeakTests/LeakTestCaseHelpers.cs
new file mode 100644
index 000000000..fef35c6dc
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/LeakTestCaseHelpers.cs
@@ -0,0 +1,49 @@
+using Avalonia.Controls;
+using Avalonia.VisualTree;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+
+namespace Dock.Avalonia.LeakTests;
+
+internal static class LeakTestCaseHelpers
+{
+    private static readonly InputInteractionMask ButtonInteractionMask =
+        InputInteractionMask.PointerEnterExit | InputInteractionMask.PointerMove | InputInteractionMask.PointerPressRelease;
+
+    internal static void ApplyNoOpCommand(Button? button)
+    {
+        if (button is null)
+        {
+            return;
+        }
+
+        button.SetCurrentValue(Button.CommandProperty, new NoOpCommand());
+    }
+
+    internal static void ExerciseButtonInteractions(Button? button)
+    {
+        if (button is null)
+        {
+            return;
+        }
+
+        ExerciseInputInteractions(button, interactionMask: ButtonInteractionMask);
+    }
+
+    internal static T? FindTemplateChild<T>(Control root, string name) where T : Control
+    {
+        if (root.Name == name && root is T match)
+        {
+            return match;
+        }
+
+        foreach (var visual in root.GetVisualDescendants())
+        {
+            if (visual is T control && control.Name == name)
+            {
+                return control;
+            }
+        }
+
+        return null;
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/LeakTestCaseRunner.cs b/tests/Dock.Avalonia.LeakTests/LeakTestCaseRunner.cs
new file mode 100644
index 000000000..416fe712e
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/LeakTestCaseRunner.cs
@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Themes.Fluent;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+internal static class LeakTestCaseRunner
+{
+    internal static LeakResult RunControlCase(ControlLeakCase testCase, bool exerciseInput)
+    {
+        return RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            var setup = testCase.Create(context);
+
+            var window = new Window { Content = setup.Control };
+            var windowRef = new WeakReference(window);
+
+            if (LeakTestHelpers.IsLeakTraceEnabled)
+            {
+                window.AddHandler(Window.WindowClosedEvent, (_, _) =>
+                    LeakTestHelpers.Trace($"[LeakTrace:{testCase.Name}/window] WindowClosedEvent raised."));
+            }
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+
+            if (exerciseInput)
+            {
+                setup.AfterShow?.Invoke(setup.Control);
+                ExerciseInputInteractions(setup.Control, interactionMask: setup.InteractionMask);
+            }
+            setup.BeforeCleanup?.Invoke(setup.Control);
+
+            var result = new LeakResult(
+                testCase.Name,
+                new[] { new WeakReference(setup.Control) },
+                setup.KeepAlive,
+                windowRef);
+
+            CleanupWindow(window);
+            return result;
+        });
+    }
+
+    internal static LeakResult RunWindowCase(WindowLeakCase testCase, bool exerciseInput)
+    {
+        return RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            var setup = testCase.Create(context);
+            setup.Window.Styles.Add(new FluentTheme());
+
+            ShowWindow(setup.Window);
+            if (exerciseInput)
+            {
+                ExerciseInputInteractions(setup.Window);
+            }
+
+            var windowRef = new WeakReference(setup.Window);
+
+            if (LeakTestHelpers.IsLeakTraceEnabled)
+            {
+                setup.Window.AddHandler(Window.WindowClosedEvent, (_, _) =>
+                    LeakTestHelpers.Trace($"[LeakTrace:{testCase.Name}/window] WindowClosedEvent raised."));
+            }
+            var result = new LeakResult(
+                testCase.Name,
+                new[] { new WeakReference(setup.Window) },
+                setup.KeepAlive,
+                windowRef);
+            CleanupWindow(setup.Window);
+            return result;
+        });
+    }
+
+    internal static void AssertCollectedForCase(LeakResult result, bool keepAlive)
+    {
+        var references = result.References;
+
+        LeakTestHelpers.ResetDispatcherForUnitTests();
+
+        for (var attempt = 0; attempt < 20 && AnyAlive(references); attempt++)
+        {
+            CollectGarbage();
+            Thread.Sleep(10);
+        }
+
+        foreach (var reference in references)
+        {
+            Xunit.Assert.False(reference.IsAlive, $"{result.Name} leaked");
+        }
+
+        if (keepAlive)
+        {
+            foreach (var keepAliveItem in result.KeepAlive)
+            {
+                System.GC.KeepAlive(keepAliveItem);
+            }
+        }
+    }
+
+    private static bool AnyAlive(IReadOnlyList<WeakReference> references)
+    {
+        for (var i = 0; i < references.Count; i++)
+        {
+            if (references[i].IsAlive)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/LeakTestCaseStubs.cs b/tests/Dock.Avalonia.LeakTests/LeakTestCaseStubs.cs
new file mode 100644
index 000000000..054cffd85
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/LeakTestCaseStubs.cs
@@ -0,0 +1,270 @@
+using System;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Threading.Tasks;
+using System.Windows.Input;
+using Dock.Model.Avalonia;
+using Dock.Model.Services;
+using Dock.Model.Core;
+using Dock.Model.Avalonia.Core;
+
+namespace Dock.Avalonia.LeakTests;
+
+internal sealed class NoOpDisposable : IDisposable
+{
+    public void Dispose()
+    {
+    }
+}
+
+internal sealed class NoOpCommand : ICommand
+{
+    public event EventHandler? CanExecuteChanged;
+
+    public bool CanExecute(object? parameter) => true;
+
+    public void Execute(object? parameter)
+    {
+    }
+}
+
+internal sealed class NoOpFactory : Factory, IFactory
+{
+    public override void FloatDockable(IDockable dockable)
+    {
+    }
+
+    public override void FloatDockable(IDockable dockable, DockWindowOptions? options)
+    {
+    }
+
+    public override void FloatAllDockables(IDockable dockable)
+    {
+    }
+
+    public override void FloatAllDockables(IDockable dockable, DockWindowOptions? options)
+    {
+    }
+
+    public override void PinDockable(IDockable dockable)
+    {
+    }
+
+    public new void PreviewPinnedDockable(IDockable dockable)
+    {
+    }
+
+    public new void TogglePreviewPinnedDockable(IDockable dockable)
+    {
+    }
+
+    void IFactory.PreviewPinnedDockable(IDockable dockable)
+    {
+    }
+
+    void IFactory.TogglePreviewPinnedDockable(IDockable dockable)
+    {
+    }
+
+    public override void DockAsDocument(IDockable dockable)
+    {
+    }
+
+    public override void CloseDockable(IDockable dockable)
+    {
+    }
+
+    public override void CloseOtherDockables(IDockable dockable)
+    {
+    }
+
+    public override void CloseAllDockables(IDockable dockable)
+    {
+    }
+
+    public override void CloseLeftDockables(IDockable dockable)
+    {
+    }
+
+    public override void CloseRightDockables(IDockable dockable)
+    {
+    }
+
+    public override void NewHorizontalDocumentDock(IDockable dockable)
+    {
+    }
+
+    public override void NewVerticalDocumentDock(IDockable dockable)
+    {
+    }
+
+    public override void SetDocumentDockTabsLayout(IDockable dockable, DocumentTabLayout layout)
+    {
+    }
+
+    public override void SetDocumentDockLayoutMode(IDockable dockable, DocumentLayoutMode layoutMode)
+    {
+    }
+}
+
+internal sealed class StubBusyService : IDockBusyService
+{
+    private readonly NoOpDisposable _scope = new();
+    private Func<Task>? _reloadHandler;
+
+    public bool IsBusy { get; private set; }
+
+    public string? Message { get; private set; }
+
+    public bool IsReloadVisible { get; set; }
+
+    public bool CanReload { get; private set; }
+
+    public ICommand ReloadCommand { get; } = new NoOpCommand();
+
+    public event PropertyChangedEventHandler? PropertyChanged;
+
+    public IDisposable Begin(string message)
+    {
+        IsBusy = true;
+        Message = message;
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsBusy)));
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Message)));
+        return _scope;
+    }
+
+    public Task RunAsync(string message, Func<Task> action)
+    {
+        IsBusy = true;
+        Message = message;
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsBusy)));
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Message)));
+        return action();
+    }
+
+    public void UpdateMessage(string? message)
+    {
+        Message = message;
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Message)));
+    }
+
+    public void SetReloadHandler(Func<Task>? handler)
+    {
+        _reloadHandler = handler;
+        CanReload = handler is not null;
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CanReload)));
+    }
+}
+
+internal sealed class StubGlobalBusyService : IDockGlobalBusyService
+{
+    public bool IsBusy { get; private set; }
+
+    public string? Message { get; private set; }
+
+    public event PropertyChangedEventHandler? PropertyChanged;
+
+    public IDisposable Begin(string? message = null)
+    {
+        IsBusy = true;
+        Message = message;
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsBusy)));
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Message)));
+        return new NoOpDisposable();
+    }
+}
+
+internal sealed class StubDialogService : IDockDialogService
+{
+    private readonly ObservableCollection<DialogRequest> _dialogs = new();
+    private readonly ReadOnlyObservableCollection<DialogRequest> _readonlyDialogs;
+
+    public StubDialogService()
+    {
+        _readonlyDialogs = new ReadOnlyObservableCollection<DialogRequest>(_dialogs);
+    }
+
+    public ReadOnlyObservableCollection<DialogRequest> Dialogs => _readonlyDialogs;
+
+    public DialogRequest? ActiveDialog => null;
+
+    public bool HasDialogs => false;
+
+    public event PropertyChangedEventHandler? PropertyChanged;
+
+    public Task<T?> ShowAsync<T>(object content, string? title = null) => Task.FromResult<T?>(default);
+
+    public void Close(DialogRequest request, object? result = null)
+    {
+    }
+
+    public void CancelAll()
+    {
+    }
+}
+
+internal sealed class StubGlobalDialogService : IDockGlobalDialogService
+{
+    public bool IsDialogOpen { get; private set; }
+
+    public string? Message { get; private set; }
+
+    public event PropertyChangedEventHandler? PropertyChanged;
+
+    public IDisposable Begin(string? message = null)
+    {
+        IsDialogOpen = true;
+        Message = message;
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsDialogOpen)));
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Message)));
+        return new NoOpDisposable();
+    }
+}
+
+internal sealed class StubConfirmationService : IDockConfirmationService
+{
+    private readonly ObservableCollection<ConfirmationRequest> _confirmations = new();
+    private readonly ReadOnlyObservableCollection<ConfirmationRequest> _readonlyConfirmations;
+
+    public StubConfirmationService()
+    {
+        _readonlyConfirmations = new ReadOnlyObservableCollection<ConfirmationRequest>(_confirmations);
+    }
+
+    public ReadOnlyObservableCollection<ConfirmationRequest> Confirmations => _readonlyConfirmations;
+
+    public ConfirmationRequest? ActiveConfirmation => null;
+
+    public bool HasConfirmations => false;
+
+    public event PropertyChangedEventHandler? PropertyChanged;
+
+    public Task<bool> ConfirmAsync(string title, string message, string confirmText = "Confirm", string cancelText = "Cancel")
+        => Task.FromResult(false);
+
+    public void Close(ConfirmationRequest request, bool result)
+    {
+    }
+
+    public void CancelAll()
+    {
+    }
+}
+
+internal sealed class StubGlobalConfirmationService : IDockGlobalConfirmationService
+{
+    public bool IsConfirmationOpen { get; private set; }
+
+    public string? Message { get; private set; }
+
+    public event PropertyChangedEventHandler? PropertyChanged;
+
+    public IDisposable Begin(string? message = null)
+    {
+        IsConfirmationOpen = true;
+        Message = message;
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsConfirmationOpen)));
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Message)));
+        return new NoOpDisposable();
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/LeakTestCaseTypes.cs b/tests/Dock.Avalonia.LeakTests/LeakTestCaseTypes.cs
new file mode 100644
index 000000000..8dfc9266c
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/LeakTestCaseTypes.cs
@@ -0,0 +1,19 @@
+using System;
+using Avalonia.Controls;
+
+namespace Dock.Avalonia.LeakTests;
+
+internal sealed record ControlSetup(
+    Control Control,
+    object?[] KeepAlive,
+    Action<Control>? BeforeCleanup = null,
+    Action<Control>? AfterShow = null,
+    LeakTestHelpers.InputInteractionMask? InteractionMask = null);
+
+internal sealed record WindowSetup(Window Window, object?[] KeepAlive);
+
+internal sealed record ControlLeakCase(string Name, Func<LeakContext, ControlSetup> Create);
+
+internal sealed record WindowLeakCase(string Name, Func<LeakContext, WindowSetup> Create);
+
+internal sealed record LeakResult(string Name, WeakReference[] References, object?[] KeepAlive, WeakReference? WindowReference = null);
diff --git a/tests/Dock.Avalonia.LeakTests/LeakTestCases.Controls.cs b/tests/Dock.Avalonia.LeakTests/LeakTestCases.Controls.cs
new file mode 100644
index 000000000..c9e1e55b1
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/LeakTestCases.Controls.cs
@@ -0,0 +1,444 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Input;
+using Avalonia.VisualTree;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Controls.Overlays;
+using Dock.Avalonia.Selectors;
+using Dock.Controls.ProportionalStackPanel;
+using Dock.Model.Core;
+using Dock.Settings;
+using static Dock.Avalonia.LeakTests.LeakTestCaseHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+
+namespace Dock.Avalonia.LeakTests;
+
+internal static partial class LeakTestCases
+{
+    internal static readonly ControlLeakCase[] ControlCases =
+    [
+        new ControlLeakCase("DockControl", context =>
+        {
+            var control = new DockControl { Factory = context.Factory, Layout = context.Root };
+            return new ControlSetup(control, new object?[] { context.Factory });
+        }),
+        new ControlLeakCase("DockCommandBarHost", _ =>
+        {
+            var command = new NoOpCommand();
+            var menuItem = new MenuItem { Header = "File" };
+            var openItem = new MenuItem { Header = "Open", Command = command };
+            var exitItem = new MenuItem { Header = "Exit", Command = command };
+            menuItem.ItemsSource = new object[]
+            {
+                openItem,
+                new Separator(),
+                exitItem
+            };
+
+            var menu = new Menu
+            {
+                ItemsSource = new object[]
+                {
+                    menuItem
+                }
+            };
+
+            var toolButton = new Button { Content = "Action", Command = command };
+            var toolBar = new StackPanel { Orientation = global::Avalonia.Layout.Orientation.Horizontal };
+            toolBar.Children.Add(toolButton);
+
+            var ribbonButton = new Button { Content = "Ribbon", Command = command };
+            var ribbonBar = new StackPanel { Orientation = global::Avalonia.Layout.Orientation.Horizontal };
+            ribbonBar.Children.Add(ribbonButton);
+
+            var host = new DockCommandBarHost
+            {
+                MenuBars = new Control[] { menu },
+                ToolBars = new Control[] { toolBar },
+                RibbonBars = new Control[] { ribbonBar },
+                IsVisible = true
+            };
+
+            return new ControlSetup(host, new object?[] { command }, AfterShow: dockControl =>
+            {
+                ExerciseButtonInteractions(toolButton);
+                ExerciseButtonInteractions(ribbonButton);
+            }, InteractionMask: LeakTestHelpers.InputInteractionMask.All & ~LeakTestHelpers.InputInteractionMask.PointerPressRelease);
+        }),
+        new ControlLeakCase("DockDockControl", context =>
+            new ControlSetup(new DockDockControl { DataContext = context.DockDock }, Array.Empty<object?>())),
+        new ControlLeakCase("DockSelectorOverlay", context =>
+        {
+            var item = new DockSelectorItem(context.Document, 1, true, false, false, false, false);
+            return new ControlSetup(new DockSelectorOverlay { Items = new[] { item } }, Array.Empty<object?>());
+        }),
+        new ControlLeakCase("DockTarget", _ =>
+            new ControlSetup(new DockTarget(), Array.Empty<object?>())),
+        new ControlLeakCase("GlobalDockTarget", _ =>
+            new ControlSetup(new GlobalDockTarget(), Array.Empty<object?>())),
+        new ControlLeakCase("DockableControl", context =>
+        {
+            var control = new DockableControl
+            {
+                TrackingMode = TrackingMode.Visible,
+                DataContext = context.Document
+            };
+            return new ControlSetup(control, new object?[] { context.Factory });
+        }),
+        new ControlLeakCase("DocumentContentControl", context =>
+            new ControlSetup(new DocumentContentControl { DataContext = context.Document }, new object?[] { context.Factory })),
+        new ControlLeakCase("ToolContentControl", context =>
+            new ControlSetup(new ToolContentControl { DataContext = context.Tool }, new object?[] { context.Factory })),
+        new ControlLeakCase("DocumentControl", context =>
+        {
+            context.DocumentDock.CanCreateDocument = true;
+            context.DocumentDock.CreateDocument = new NoOpCommand();
+
+            var control = new DocumentControl { DataContext = context.DocumentDock };
+            return new ControlSetup(control, Array.Empty<object?>(), AfterShow: dockControl =>
+            {
+                var documentControl = (DocumentControl)dockControl;
+                var tabStrip = FindVisualDescendant<DocumentTabStrip>(documentControl);
+                if (tabStrip is not null)
+                {
+                    var createButton = FindVisualDescendant<Button>(
+                        tabStrip,
+                        button => button.Name == "PART_ButtonCreate");
+                    ApplyNoOpCommand(createButton);
+                    ExerciseButtonInteractions(createButton);
+                }
+
+                var tabItem = FindVisualDescendant<DocumentTabStripItem>(documentControl);
+                if (tabItem is not null)
+                {
+                    var closeButton = FindVisualDescendant<Button>(tabItem);
+                    ApplyNoOpCommand(closeButton);
+                    ExerciseButtonInteractions(closeButton);
+                    OpenAndCloseContextMenu(tabItem, tabItem.DocumentContextMenu);
+                }
+            });
+        }),
+        new ControlLeakCase("ToolControl", context =>
+            new ControlSetup(new ToolControl { DataContext = context.ToolDock }, Array.Empty<object?>(), AfterShow: control =>
+            {
+                var toolControl = (ToolControl)control;
+                var tabStrip = FindVisualDescendant<ToolTabStrip>(toolControl);
+                var tabItem = tabStrip?.ContainerFromIndex(0) as ToolTabStripItem
+                              ?? FindVisualDescendant<ToolTabStripItem>(toolControl);
+                if (tabItem is not null)
+                {
+                    ExerciseInputInteractions(tabItem, includeDoubleTap: true, includeMiddlePress: true, clearInputState: false);
+                    OpenAndCloseContextMenu(tabItem, tabItem.TabContextMenu);
+                }
+            })),
+        new ControlLeakCase("ToolChromeControl", context =>
+        {
+            var control = new ToolChromeControl { DataContext = context.ToolDock };
+            return new ControlSetup(control, Array.Empty<object?>(), AfterShow: dockControl =>
+            {
+                var chrome = (ToolChromeControl)dockControl;
+                var menuButton = FindTemplateChild<Button>(chrome, "PART_MenuButton");
+                var pinButton = FindTemplateChild<Button>(chrome, "PART_PinButton");
+                var maximizeButton = FindTemplateChild<Button>(chrome, "PART_MaximizeRestoreButton");
+                var closeButton = FindTemplateChild<Button>(chrome, "PART_CloseButton");
+
+                ApplyNoOpCommand(pinButton);
+                ApplyNoOpCommand(closeButton);
+
+                ExerciseButtonInteractions(menuButton);
+                ExerciseButtonInteractions(pinButton);
+                ExerciseButtonInteractions(maximizeButton);
+                ExerciseButtonInteractions(closeButton);
+
+                if (chrome.ToolFlyout is not null)
+                {
+                    var flyoutTarget = (Control?)menuButton ?? chrome;
+                    OpenAndCloseFlyout(flyoutTarget, chrome.ToolFlyout);
+                }
+            });
+        }),
+        new ControlLeakCase("DocumentDockControl", context =>
+            new ControlSetup(new DocumentDockControl { DataContext = context.DocumentDock }, Array.Empty<object?>())),
+        new ControlLeakCase("ToolDockControl", context =>
+            new ControlSetup(new ToolDockControl { DataContext = context.ToolDock }, Array.Empty<object?>())),
+        new ControlLeakCase("GridDockControl", context =>
+            new ControlSetup(new GridDockControl { DataContext = context.GridDock }, Array.Empty<object?>())),
+        new ControlLeakCase("ProportionalDockControl", context =>
+            new ControlSetup(new ProportionalDockControl { DataContext = context.ProportionalDock }, Array.Empty<object?>())),
+        new ControlLeakCase("StackDockControl", context =>
+            new ControlSetup(new StackDockControl { DataContext = context.StackDock }, Array.Empty<object?>())),
+        new ControlLeakCase("WrapDockControl", context =>
+            new ControlSetup(new WrapDockControl { DataContext = context.WrapDock }, Array.Empty<object?>())),
+        new ControlLeakCase("ProportionalStackPanel", _ =>
+        {
+            var panel = new ProportionalStackPanel();
+            panel.Children.Add(new Border());
+            panel.Children.Add(new ProportionalStackPanelSplitter());
+            panel.Children.Add(new Border());
+            return new ControlSetup(panel, Array.Empty<object?>(), AfterShow: control =>
+            {
+                var stackPanel = (ProportionalStackPanel)control;
+                foreach (var child in stackPanel.Children)
+                {
+                    if (child is ProportionalStackPanelSplitter splitter)
+                    {
+                        ExerciseInputInteractions(splitter, clearInputState: false);
+                        break;
+                    }
+                }
+            });
+        }),
+        new ControlLeakCase("ProportionalStackPanelSplitter", _ =>
+            new ControlSetup(new ProportionalStackPanelSplitter(), Array.Empty<object?>())),
+        new ControlLeakCase("UniformGridDockControl", context =>
+            new ControlSetup(new UniformGridDockControl { DataContext = context.UniformGridDock }, Array.Empty<object?>())),
+        new ControlLeakCase("SplitViewDockControl", context =>
+            new ControlSetup(new SplitViewDockControl { DataContext = context.SplitViewDock }, Array.Empty<object?>())),
+        new ControlLeakCase("RootDockControl", context =>
+            new ControlSetup(new RootDockControl { DataContext = context.Root }, Array.Empty<object?>(), AfterShow: control =>
+            {
+                var mainContent = FindTemplateChild<ContentControl>(control, "PART_MainContent");
+                if (mainContent is not null)
+                {
+                    RaisePointerPressed(mainContent, MouseButton.Left);
+                }
+            })),
+        new ControlLeakCase("PinnedDockControl", context =>
+            new ControlSetup(new PinnedDockControl { DataContext = context.Root }, new object?[] { context.Root },
+                BeforeCleanup: control => LeakTestHelpers.ClearPinnedDockControlState(control as PinnedDockControl),
+                AfterShow: control =>
+                {
+                    if (TopLevel.GetTopLevel(control) is Control ownerWindow)
+                    {
+                        RaisePointerPressed(ownerWindow, MouseButton.Left);
+                    }
+                })),
+        new ControlLeakCase("PinnedDockHostPanel", context =>
+            new ControlSetup(new PinnedDockHostPanel { DataContext = context.Root }, new object?[] { context.Root })),
+        new ControlLeakCase("DocumentTabStrip", context =>
+        {
+            context.DocumentDock.CanCreateDocument = true;
+            context.DocumentDock.CreateDocument = new NoOpCommand();
+
+            var control = new DocumentTabStrip
+            {
+                DataContext = context.DocumentDock,
+                ItemsSource = context.DocumentDock.VisibleDockables,
+                CanCreateItem = true
+            };
+
+            return new ControlSetup(control, Array.Empty<object?>(), AfterShow: dockControl =>
+            {
+                var createButton = FindTemplateChild<Button>(dockControl, "PART_ButtonCreate");
+                ApplyNoOpCommand(createButton);
+                ExerciseButtonInteractions(createButton);
+
+                var tabStrip = (DocumentTabStrip)dockControl;
+                var tabItem = tabStrip.ContainerFromIndex(0) as DocumentTabStripItem
+                              ?? FindVisualDescendant<DocumentTabStripItem>(tabStrip);
+                if (tabItem is not null)
+                {
+                    var closeButton = FindVisualDescendant<Button>(tabItem);
+                    ApplyNoOpCommand(closeButton);
+                    ExerciseButtonInteractions(closeButton);
+                    ExerciseInputInteractions(tabItem, includeDoubleTap: true, includeMiddlePress: true, clearInputState: false);
+                    OpenAndCloseContextMenu(tabItem, tabItem.DocumentContextMenu);
+                }
+            });
+        }),
+        new ControlLeakCase("ToolTabStrip", context =>
+            new ControlSetup(new ToolTabStrip { ItemsSource = new[] { context.Tool } }, Array.Empty<object?>(), AfterShow: control =>
+            {
+                var tabStrip = (ToolTabStrip)control;
+                var tabItem = tabStrip.ContainerFromIndex(0) as ToolTabStripItem
+                              ?? FindVisualDescendant<ToolTabStripItem>(tabStrip);
+                if (tabItem is not null)
+                {
+                    ExerciseInputInteractions(tabItem, includeDoubleTap: true, includeMiddlePress: true, clearInputState: false);
+                    OpenAndCloseContextMenu(tabItem, tabItem.TabContextMenu);
+
+                    var button = FindVisualDescendant<Button>(tabItem);
+                    ApplyNoOpCommand(button);
+                    ExerciseButtonInteractions(button);
+                }
+            })),
+        new ControlLeakCase("DocumentTabStripItem", context =>
+            new ControlSetup(new DocumentTabStripItem { DataContext = context.Document }, Array.Empty<object?>(), AfterShow: control =>
+            {
+                if (control.DataContext is IDockable dockable)
+                {
+                    dockable.CanClose = false;
+                    dockable.CanFloat = false;
+                }
+
+                ExerciseInputInteractions(control, includeDoubleTap: true, includeMiddlePress: true, clearInputState: false);
+
+                var item = (DocumentTabStripItem)control;
+                OpenAndCloseContextMenu(item, item.DocumentContextMenu);
+
+                var closeButton = FindVisualDescendant<Button>(item);
+                ApplyNoOpCommand(closeButton);
+                ExerciseButtonInteractions(closeButton);
+            })),
+        new ControlLeakCase("ToolTabStripItem", context =>
+            new ControlSetup(new ToolTabStripItem { DataContext = context.Tool }, Array.Empty<object?>(), AfterShow: control =>
+            {
+                if (control.DataContext is IDockable dockable)
+                {
+                    dockable.CanClose = false;
+                    dockable.CanFloat = false;
+                }
+
+                ExerciseInputInteractions(control, includeDoubleTap: true, includeMiddlePress: true, clearInputState: false);
+
+                var item = (ToolTabStripItem)control;
+                OpenAndCloseContextMenu(item, item.TabContextMenu);
+
+                var button = FindVisualDescendant<Button>(item);
+                ApplyNoOpCommand(button);
+                ExerciseButtonInteractions(button);
+            })),
+        new ControlLeakCase("ToolPinnedControl", context =>
+            new ControlSetup(new ToolPinnedControl { ItemsSource = new[] { context.Tool } }, Array.Empty<object?>())),
+        new ControlLeakCase("ToolPinItemControl", context =>
+        {
+            var control = new ToolPinItemControl { DataContext = context.Tool };
+            return new ControlSetup(control, Array.Empty<object?>(), AfterShow: pinControl =>
+            {
+                var toolPinItem = (ToolPinItemControl)pinControl;
+                OpenAndCloseContextMenu(toolPinItem, toolPinItem.PinContextMenu);
+
+                var button = FindVisualDescendant<Button>(toolPinItem);
+                ApplyNoOpCommand(button);
+                ExerciseButtonInteractions(button);
+            });
+        }),
+        new ControlLeakCase("DragPreviewControl", _ =>
+            new ControlSetup(new DragPreviewControl { PreviewContent = new Border() }, Array.Empty<object?>())),
+        new ControlLeakCase("HostWindowTitleBar", _ =>
+            new ControlSetup(new HostWindowTitleBar(), Array.Empty<object?>(), AfterShow: control =>
+            {
+                var titleBar = (HostWindowTitleBar)control;
+                var captionButtons = FindTemplateChild<Control>(titleBar, "PART_CaptionButtons");
+                if (captionButtons is not null)
+                {
+                    ExerciseInputInteractions(captionButtons, interactionMask:
+                        LeakTestHelpers.InputInteractionMask.PointerEnterExit | LeakTestHelpers.InputInteractionMask.PointerMove | LeakTestHelpers.InputInteractionMask.PointerPressRelease);
+
+                    foreach (var visual in captionButtons.GetVisualDescendants())
+                    {
+                        if (visual is Button button)
+                        {
+                            ApplyNoOpCommand(button);
+                            ExerciseButtonInteractions(button);
+                        }
+                    }
+                }
+            })),
+        new ControlLeakCase("MdiLayoutPanel", _ =>
+            new ControlSetup(new MdiLayoutPanel(), Array.Empty<object?>())),
+        new ControlLeakCase("MdiDocumentControl", context =>
+            new ControlSetup(new MdiDocumentControl { DataContext = context.DocumentDock }, new object?[] { context.DocumentDock },
+                BeforeCleanup: control =>
+                {
+                    var dock = control.DataContext as IDock;
+                    control.DataContext = null;
+                    DrainDispatcher();
+                    if (dock is not null)
+                    {
+                        LeakTestHelpers.ClearFactoryCaches(dock.Factory);
+                    }
+                })),
+        new ControlLeakCase("MdiDocumentWindow", context =>
+            new ControlSetup(new MdiDocumentWindow { DataContext = context.Document }, new object?[] { context.Document, context.DocumentDock },
+                BeforeCleanup: control =>
+                {
+                    var dockable = control.DataContext as IDockable;
+                    control.DataContext = null;
+                    DrainDispatcher();
+                    if (dockable?.Factory is not null)
+                    {
+                        LeakTestHelpers.ClearFactoryCaches(dockable.Factory);
+                    }
+                    LeakTestHelpers.ClearFactoryCaches(context.DocumentDock.Factory);
+                },
+                AfterShow: control =>
+            {
+                DockProperties.SetIsDragEnabled(control, false);
+                var header = FindTemplateChild<Control>(control, "PART_Header");
+                if (header is not null)
+                {
+                    RaisePointerPressed(header, MouseButton.Left);
+                    RaiseDoubleTapped(header);
+                }
+
+                var content = FindTemplateChild<Control>(control, "PART_ContentBorder");
+                if (content is not null)
+                {
+                    RaisePointerPressed(content, MouseButton.Left);
+                }
+
+                var minimizeButton = FindTemplateChild<Button>(control, "PART_MinimizeButton");
+                var maximizeButton = FindTemplateChild<Button>(control, "PART_MaximizeRestoreButton");
+                var closeButton = FindTemplateChild<Button>(control, "PART_CloseButton");
+
+                ApplyNoOpCommand(closeButton);
+                ExerciseButtonInteractions(minimizeButton);
+                ExerciseButtonInteractions(maximizeButton);
+                ExerciseButtonInteractions(closeButton);
+
+                var toolMenuButton = FindTemplateChild<Button>(control, "PART_ToolMenuButton");
+                var toolPinButton = FindTemplateChild<Button>(control, "PART_ToolPinButton");
+                var toolCloseButton = FindTemplateChild<Button>(control, "PART_ToolCloseButton");
+
+                ApplyNoOpCommand(toolPinButton);
+                ApplyNoOpCommand(toolCloseButton);
+                ExerciseButtonInteractions(toolMenuButton);
+                ExerciseButtonInteractions(toolPinButton);
+                ExerciseButtonInteractions(toolCloseButton);
+
+                if (toolMenuButton?.Flyout is FlyoutBase toolFlyout)
+                {
+                    OpenAndCloseFlyout(toolMenuButton, toolFlyout);
+                }
+
+                if (control is MdiDocumentWindow mdiWindow)
+                {
+                    OpenAndCloseContextMenu(header ?? mdiWindow, mdiWindow.DocumentContextMenu);
+                }
+            })),
+        new ControlLeakCase("ManagedWindowLayer", context =>
+            new ControlSetup(
+                new ManagedWindowLayer { Dock = context.ManagedWindowDock },
+                new object?[] { context.ManagedWindowDock },
+                control => ((ManagedWindowLayer)control).Dock = null)),
+        new ControlLeakCase("BusyOverlayControl", _ =>
+        {
+            var busy = new StubBusyService();
+            var global = new StubGlobalBusyService();
+            var control = new BusyOverlayControl { BusyService = busy, GlobalBusyService = global };
+            return new ControlSetup(control, new object?[] { busy, global });
+        }),
+        new ControlLeakCase("DialogOverlayControl", _ =>
+        {
+            var dialog = new StubDialogService();
+            var global = new StubGlobalDialogService();
+            var control = new DialogOverlayControl { DialogService = dialog, GlobalDialogService = global };
+            return new ControlSetup(control, new object?[] { dialog, global });
+        }),
+        new ControlLeakCase("ConfirmationOverlayControl", _ =>
+        {
+            var confirmation = new StubConfirmationService();
+            var global = new StubGlobalConfirmationService();
+            var control = new ConfirmationOverlayControl { ConfirmationService = confirmation, GlobalConfirmationService = global };
+            return new ControlSetup(control, new object?[] { confirmation, global });
+        }),
+        new ControlLeakCase("ConfirmationDialogControl", _ =>
+            new ControlSetup(new ConfirmationDialogControl(), Array.Empty<object?>())),
+        new ControlLeakCase("DialogShellControl", _ =>
+            new ControlSetup(new DialogShellControl(), Array.Empty<object?>())),
+        new ControlLeakCase("OverlayHost", _ =>
+            new ControlSetup(new OverlayHost { Content = new Border() }, Array.Empty<object?>()))
+    ];
+}
diff --git a/tests/Dock.Avalonia.LeakTests/LeakTestCases.Windows.cs b/tests/Dock.Avalonia.LeakTests/LeakTestCases.Windows.cs
new file mode 100644
index 000000000..343d95118
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/LeakTestCases.Windows.cs
@@ -0,0 +1,20 @@
+using System;
+using Avalonia.Controls;
+using Dock.Avalonia.Controls;
+
+namespace Dock.Avalonia.LeakTests;
+
+internal static partial class LeakTestCases
+{
+    internal static readonly WindowLeakCase[] WindowCases =
+    [
+        new WindowLeakCase("DockAdornerWindow", _ =>
+            new WindowSetup(new DockAdornerWindow { Content = new Border() }, Array.Empty<object?>())),
+        new WindowLeakCase("DragPreviewWindow", _ =>
+            new WindowSetup(new DragPreviewWindow { Content = new Border() }, Array.Empty<object?>())),
+        new WindowLeakCase("PinnedDockWindow", _ =>
+            new WindowSetup(new PinnedDockWindow { Content = new Border() }, Array.Empty<object?>())),
+        new WindowLeakCase("HostWindow", _ =>
+            new WindowSetup(new HostWindow { Content = new Border() }, Array.Empty<object?>()))
+    ];
+}
diff --git a/tests/Dock.Avalonia.LeakTests/LeakTestCollection.cs b/tests/Dock.Avalonia.LeakTests/LeakTestCollection.cs
new file mode 100644
index 000000000..51355bcec
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/LeakTestCollection.cs
@@ -0,0 +1,8 @@
+using Xunit;
+
+namespace Dock.Avalonia.LeakTests;
+
+[CollectionDefinition("LeakTests", DisableParallelization = true)]
+public sealed class LeakTestCollection
+{
+}
diff --git a/tests/Dock.Avalonia.LeakTests/LeakTestContext.cs b/tests/Dock.Avalonia.LeakTests/LeakTestContext.cs
new file mode 100644
index 000000000..de114f3d3
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/LeakTestContext.cs
@@ -0,0 +1,158 @@
+using Dock.Avalonia.Controls;
+using Dock.Model.Avalonia;
+using Dock.Model.Avalonia.Controls;
+using Dock.Model.Core;
+
+namespace Dock.Avalonia.LeakTests;
+
+internal sealed class LeakContext
+{
+    private LeakContext(
+        Factory factory,
+        RootDock root,
+        ToolDock toolDock,
+        DocumentDock documentDock,
+        Tool tool,
+        Document document,
+        StackDock stackDock,
+        ProportionalDock proportionalDock,
+        GridDock gridDock,
+        UniformGridDock uniformGridDock,
+        WrapDock wrapDock,
+        DockDock dockDock,
+        SplitViewDock splitViewDock,
+        ManagedWindowDock managedWindowDock)
+    {
+        Factory = factory;
+        Root = root;
+        ToolDock = toolDock;
+        DocumentDock = documentDock;
+        Tool = tool;
+        Document = document;
+        StackDock = stackDock;
+        ProportionalDock = proportionalDock;
+        GridDock = gridDock;
+        UniformGridDock = uniformGridDock;
+        WrapDock = wrapDock;
+        DockDock = dockDock;
+        SplitViewDock = splitViewDock;
+        ManagedWindowDock = managedWindowDock;
+    }
+
+    public Factory Factory { get; }
+
+    public RootDock Root { get; }
+
+    public ToolDock ToolDock { get; }
+
+    public DocumentDock DocumentDock { get; }
+
+    public Tool Tool { get; }
+
+    public Document Document { get; }
+
+    public StackDock StackDock { get; }
+
+    public ProportionalDock ProportionalDock { get; }
+
+    public GridDock GridDock { get; }
+
+    public UniformGridDock UniformGridDock { get; }
+
+    public WrapDock WrapDock { get; }
+
+    public DockDock DockDock { get; }
+
+    public SplitViewDock SplitViewDock { get; }
+
+    public ManagedWindowDock ManagedWindowDock { get; }
+
+    public static LeakContext Create(Factory? factoryOverride = null)
+    {
+        var factory = factoryOverride ?? new Factory();
+
+        var root = (RootDock)factory.CreateRootDock();
+        root.Factory = factory;
+        root.VisibleDockables = factory.CreateList<IDockable>();
+
+        var tool = (Tool)factory.CreateTool();
+        tool.Factory = factory;
+
+        var document = (Document)factory.CreateDocument();
+        document.Factory = factory;
+
+        var toolDock = (ToolDock)factory.CreateToolDock();
+        toolDock.Factory = factory;
+        toolDock.VisibleDockables = factory.CreateList<IDockable>(tool);
+        toolDock.ActiveDockable = tool;
+        tool.Owner = toolDock;
+
+        var documentDock = (DocumentDock)factory.CreateDocumentDock();
+        documentDock.Factory = factory;
+        documentDock.VisibleDockables = factory.CreateList<IDockable>(document);
+        documentDock.ActiveDockable = document;
+        document.Owner = documentDock;
+
+        var stackDock = (StackDock)factory.CreateStackDock();
+        stackDock.Factory = factory;
+        stackDock.VisibleDockables = factory.CreateList<IDockable>();
+
+        var proportionalDock = (ProportionalDock)factory.CreateProportionalDock();
+        proportionalDock.Factory = factory;
+        proportionalDock.VisibleDockables = factory.CreateList<IDockable>();
+
+        var gridDock = (GridDock)factory.CreateGridDock();
+        gridDock.Factory = factory;
+        gridDock.VisibleDockables = factory.CreateList<IDockable>();
+
+        var uniformGridDock = (UniformGridDock)factory.CreateUniformGridDock();
+        uniformGridDock.Factory = factory;
+        uniformGridDock.VisibleDockables = factory.CreateList<IDockable>();
+
+        var wrapDock = (WrapDock)factory.CreateWrapDock();
+        wrapDock.Factory = factory;
+        wrapDock.VisibleDockables = factory.CreateList<IDockable>();
+
+        var dockDock = (DockDock)factory.CreateDockDock();
+        dockDock.Factory = factory;
+        dockDock.VisibleDockables = factory.CreateList<IDockable>();
+
+        var splitViewDock = (SplitViewDock)factory.CreateSplitViewDock();
+        splitViewDock.Factory = factory;
+        splitViewDock.VisibleDockables = factory.CreateList<IDockable>();
+
+        root.VisibleDockables.Add(toolDock);
+        root.VisibleDockables.Add(documentDock);
+        root.VisibleDockables.Add(stackDock);
+        root.VisibleDockables.Add(proportionalDock);
+        root.VisibleDockables.Add(gridDock);
+        root.VisibleDockables.Add(uniformGridDock);
+        root.VisibleDockables.Add(wrapDock);
+        root.VisibleDockables.Add(dockDock);
+        root.VisibleDockables.Add(splitViewDock);
+
+        root.PinnedDock = toolDock;
+        root.LeftPinnedDockables?.Add(tool);
+
+        var managedWindowDock = new ManagedWindowDock
+        {
+            Factory = factory
+        };
+
+        return new LeakContext(
+            factory,
+            root,
+            toolDock,
+            documentDock,
+            tool,
+            document,
+            stackDock,
+            proportionalDock,
+            gridDock,
+            uniformGridDock,
+            wrapDock,
+            dockDock,
+            splitViewDock,
+            managedWindowDock);
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/LeakTestHelpers.cs b/tests/Dock.Avalonia.LeakTests/LeakTestHelpers.cs
new file mode 100644
index 000000000..b962c6c59
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/LeakTestHelpers.cs
@@ -0,0 +1,2019 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.IO;
+using System.Threading;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Controls.Primitives;
+using Avalonia.Headless;
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using Avalonia.Interactivity;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.Styling;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+using Dock.Avalonia.Controls;
+using Dock.Model.Controls;
+using Dock.Model.Core;
+using Xunit;
+using AvaloniaPointer = Avalonia.Input.Pointer;
+
+namespace Dock.Avalonia.LeakTests;
+
+internal static class LeakTestHelpers
+{
+    internal static bool IsLeakTraceEnabled => string.Equals(
+        Environment.GetEnvironmentVariable("DOCK_LEAK_TRACE"),
+        "1",
+        StringComparison.Ordinal);
+    [Flags]
+    internal enum InputInteractionMask
+    {
+        None = 0,
+        PointerEnterExit = 1 << 0,
+        PointerMove = 1 << 1,
+        PointerPressRelease = 1 << 2,
+        PointerWheel = 1 << 3,
+        RightClick = 1 << 4,
+        MiddleClick = 1 << 5,
+        KeyPress = 1 << 6,
+        TextInput = 1 << 7,
+        CaptureLost = 1 << 8,
+        DoubleTap = 1 << 9,
+        All = PointerEnterExit
+              | PointerMove
+              | PointerPressRelease
+              | PointerWheel
+              | RightClick
+              | KeyPress
+              | TextInput
+              | CaptureLost
+    }
+    internal static void AssertCollected(params WeakReference[] references)
+    {
+        for (var attempt = 0; attempt < 20 && references.Any(reference => reference.IsAlive); attempt++)
+        {
+            CollectGarbage();
+            Thread.Sleep(10);
+        }
+
+        foreach (var reference in references)
+        {
+            Assert.False(reference.IsAlive);
+        }
+    }
+
+    internal static void ScrubStaticReferences(object target)
+    {
+        var targetType = target.GetType();
+        foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+        {
+            if (assembly.FullName is null)
+            {
+                continue;
+            }
+
+            if (!assembly.FullName.StartsWith("Avalonia", StringComparison.Ordinal)
+                && !assembly.FullName.StartsWith("Dock.", StringComparison.Ordinal))
+            {
+                continue;
+            }
+
+            Type[] types;
+            try
+            {
+                types = assembly.GetTypes();
+            }
+            catch (ReflectionTypeLoadException ex)
+            {
+                types = ex.Types.Where(type => type is not null).ToArray()!;
+            }
+
+            foreach (var type in types)
+            {
+                if (type is null)
+                {
+                    continue;
+                }
+
+                FieldInfo[] fields;
+                try
+                {
+                    fields = type.GetFields(BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+                }
+                catch
+                {
+                    continue;
+                }
+
+                foreach (var field in fields)
+                {
+                    if (field.IsInitOnly || field.FieldType.IsValueType)
+                    {
+                        continue;
+                    }
+
+                    object? value;
+                    try
+                    {
+                        value = field.GetValue(null);
+                    }
+                    catch
+                    {
+                        continue;
+                    }
+
+                    if (value is null)
+                    {
+                        continue;
+                    }
+
+                    if (ReferenceEquals(value, target))
+                    {
+                        TrySetField(field, null);
+                        continue;
+                    }
+
+                    if (value is IDictionary dictionary)
+                    {
+                        RemoveFromDictionary(dictionary, target);
+                        continue;
+                    }
+
+                    if (value is IList list)
+                    {
+                        RemoveFromList(list, target);
+                        continue;
+                    }
+
+                    var remove = value.GetType().GetMethod("Remove", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new[] { targetType }, null)
+                                 ?? value.GetType().GetMethod("Remove", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new[] { typeof(object) }, null);
+                    if (remove is not null)
+                    {
+                        try
+                        {
+                            remove.Invoke(value, new object?[] { target });
+                        }
+                        catch
+                        {
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private static void RemoveFromDictionary(IDictionary dictionary, object target)
+    {
+        var keysToRemove = new List<object?>();
+        foreach (DictionaryEntry entry in dictionary)
+        {
+            if (ReferenceEquals(entry.Key, target) || ReferenceEquals(entry.Value, target)
+                || IsWeakReferenceTo(entry.Key, target) || IsWeakReferenceTo(entry.Value, target))
+            {
+                keysToRemove.Add(entry.Key);
+            }
+        }
+
+        foreach (var key in keysToRemove)
+        {
+            if (key is null)
+            {
+                continue;
+            }
+
+            try
+            {
+                dictionary.Remove(key);
+            }
+            catch
+            {
+            }
+        }
+    }
+
+    private static void RemoveFromList(IList list, object target)
+    {
+        for (var index = list.Count - 1; index >= 0; index--)
+        {
+            object? item;
+            try
+            {
+                item = list[index];
+            }
+            catch
+            {
+                continue;
+            }
+
+            if (ReferenceEquals(item, target) || IsWeakReferenceTo(item, target))
+            {
+                try
+                {
+                    list.RemoveAt(index);
+                }
+                catch
+                {
+                }
+            }
+        }
+    }
+
+    private static bool IsWeakReferenceTo(object? candidate, object target)
+    {
+        if (candidate is WeakReference weakReference)
+        {
+            return ReferenceEquals(weakReference.Target, target);
+        }
+
+        var candidateType = candidate?.GetType();
+        if (candidateType is null || !candidateType.IsGenericType)
+        {
+            return false;
+        }
+
+        if (candidateType.GetGenericTypeDefinition() != typeof(WeakReference<>))
+        {
+            return false;
+        }
+
+        var tryGetTarget = candidateType.GetMethod("TryGetTarget", BindingFlags.Instance | BindingFlags.Public);
+        if (tryGetTarget is null)
+        {
+            return false;
+        }
+
+        var args = new object?[] { null };
+        var success = (bool)tryGetTarget.Invoke(candidate, args)!;
+        return success && ReferenceEquals(args[0], target);
+    }
+
+    private static void TrySetField(FieldInfo field, object? value)
+    {
+        try
+        {
+            field.SetValue(null, value);
+        }
+        catch
+        {
+        }
+    }
+
+    internal static void CollectGarbage()
+    {
+        DrainDispatcher();
+        GC.Collect();
+        GC.WaitForPendingFinalizers();
+        GC.Collect();
+        DrainDispatcher();
+    }
+
+    internal static void DrainDispatcher()
+    {
+        var dispatcher = Dispatcher.UIThread;
+        for (var i = 0; i < 5; i++)
+        {
+            dispatcher.RunJobs();
+            AvaloniaHeadlessPlatform.ForceRenderTimerTick();
+        }
+    }
+
+    internal static void EnsureFontManager()
+    {
+        if (GetAvaloniaService(typeof(IFontManagerImpl)) is not IFontManagerImpl fontManagerImpl)
+        {
+            return;
+        }
+
+        var locatorType = typeof(AvaloniaLocator);
+        var currentMutable = locatorType.GetProperty("CurrentMutable", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
+            ?.GetValue(null);
+        if (currentMutable is null)
+        {
+            return;
+        }
+
+        var registryField = currentMutable.GetType().GetField("_registry", BindingFlags.Instance | BindingFlags.NonPublic);
+        if (registryField?.GetValue(currentMutable) is IDictionary registry)
+        {
+            registry[typeof(FontManager)] = (Func<object?>)(() => new FontManager(fontManagerImpl));
+        }
+    }
+
+    internal static void ShowWindow(Window window)
+    {
+        if (window.SizeToContent != SizeToContent.Manual)
+        {
+            window.SizeToContent = SizeToContent.Manual;
+        }
+
+        if (double.IsNaN(window.Width) || window.Width <= 0)
+        {
+            window.Width = 800;
+        }
+
+        if (double.IsNaN(window.Height) || window.Height <= 0)
+        {
+            window.Height = 600;
+        }
+
+        if (window.Content is Control contentControl)
+        {
+            EnsureControlTheme(contentControl);
+        }
+
+        window.Show();
+        DrainDispatcher();
+        window.UpdateLayout();
+        DrainDispatcher();
+    }
+
+    private static void EnsureControlTheme(Control control)
+    {
+        if (control is not TemplatedControl templated || templated.Theme is not null)
+        {
+            return;
+        }
+
+        if (control.TryFindResource(control.GetType(), out var resource) && resource is ControlTheme theme)
+        {
+            templated.Theme = theme;
+        }
+    }
+
+    internal static void CleanupWindow(Window window)
+    {
+        window.FocusManager?.ClearFocus();
+        window.Content = null;
+        window.DataContext = null;
+        window.Close();
+        DrainDispatcher();
+        ForceHandleClosed(window);
+        ClearInputState(window);
+        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime lifetime
+            && lifetime.Windows is IList<Window> windows)
+        {
+            foreach (var other in windows.OfType<PinnedDockWindow>().ToList())
+            {
+                if (other != window)
+                {
+                    other.Close();
+                }
+                windows.Remove(other);
+            }
+
+            windows.Remove(window);
+        }
+        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime classicLifetime)
+        {
+            var windowsField = classicLifetime.GetType().GetField("_windows", BindingFlags.Instance | BindingFlags.NonPublic);
+            if (windowsField?.GetValue(classicLifetime) is IList list)
+            {
+                list.Clear();
+            }
+        }
+        ClearPlatformImpl(window);
+        ClearLayoutState(window);
+        ClearInputState(window);
+    }
+
+
+    internal static void ExerciseInputInteractions(
+        Control control,
+        bool includeDoubleTap = false,
+        bool includeMiddlePress = false,
+        InputInteractionMask? interactionMask = null,
+        bool clearInputState = true)
+    {
+        if (!TryGetInputContext(control, out var root, out var pointer, out var point))
+        {
+            return;
+        }
+
+        var interactions = ResolveInteractionMask(interactionMask, includeDoubleTap, includeMiddlePress);
+
+        var dockControl = control as DockControl;
+        var previousDockingEnabled = dockControl?.IsDockingEnabled ?? true;
+        if (dockControl is not null)
+        {
+            dockControl.IsDockingEnabled = false;
+        }
+
+        try
+        {
+            var topLevel = control as TopLevel ?? TopLevel.GetTopLevel(control);
+            if (topLevel is not null)
+            {
+                var rootPoint = control.TranslatePoint(point, topLevel) ?? point;
+                if (interactions.HasFlag(InputInteractionMask.PointerEnterExit))
+                {
+                    RaisePointerEntered(control, root, pointer, point);
+                }
+
+                if (interactions.HasFlag(InputInteractionMask.PointerMove))
+                {
+                    topLevel.MouseMove(rootPoint, RawInputModifiers.None);
+                }
+
+                if (interactions.HasFlag(InputInteractionMask.PointerPressRelease))
+                {
+                    topLevel.MouseDown(rootPoint, MouseButton.Left, RawInputModifiers.None);
+                    if (interactions.HasFlag(InputInteractionMask.PointerMove))
+                    {
+                        topLevel.MouseMove(rootPoint, RawInputModifiers.LeftMouseButton);
+                    }
+                    topLevel.MouseUp(rootPoint, MouseButton.Left, RawInputModifiers.None);
+                }
+
+                if (interactions.HasFlag(InputInteractionMask.PointerWheel))
+                {
+                    topLevel.MouseWheel(rootPoint, new Vector(0, 1), RawInputModifiers.None);
+                }
+
+                if (interactions.HasFlag(InputInteractionMask.RightClick))
+                {
+                    topLevel.MouseDown(rootPoint, MouseButton.Right, RawInputModifiers.RightMouseButton);
+                    topLevel.MouseUp(rootPoint, MouseButton.Right, RawInputModifiers.None);
+                }
+
+                if (interactions.HasFlag(InputInteractionMask.MiddleClick))
+                {
+                    topLevel.MouseDown(rootPoint, MouseButton.Middle, RawInputModifiers.MiddleMouseButton);
+                    topLevel.MouseUp(rootPoint, MouseButton.Middle, RawInputModifiers.None);
+                }
+
+                if (interactions.HasFlag(InputInteractionMask.KeyPress))
+                {
+                    control.Focus();
+                    if (control.IsKeyboardFocusWithin)
+                    {
+                        topLevel.KeyPressQwerty(PhysicalKey.A, RawInputModifiers.None);
+                        topLevel.KeyReleaseQwerty(PhysicalKey.A, RawInputModifiers.None);
+                    }
+                }
+
+                if (interactions.HasFlag(InputInteractionMask.TextInput))
+                {
+                    control.Focus();
+                    if (control.IsKeyboardFocusWithin)
+                    {
+                        topLevel.KeyTextInput("x");
+                    }
+                }
+
+                if (interactions.HasFlag(InputInteractionMask.CaptureLost))
+                {
+                    RaisePointerCaptureLost(control, pointer);
+                }
+
+                if (interactions.HasFlag(InputInteractionMask.PointerEnterExit))
+                {
+                    RaisePointerExited(control, root, pointer, point);
+                }
+            }
+            else
+            {
+                if (interactions.HasFlag(InputInteractionMask.PointerEnterExit))
+                {
+                    RaisePointerEntered(control, root, pointer, point);
+                }
+
+                if (interactions.HasFlag(InputInteractionMask.PointerMove))
+                {
+                    RaisePointerMoved(control, root, pointer, point, leftPressed: false);
+                }
+
+                if (interactions.HasFlag(InputInteractionMask.PointerPressRelease))
+                {
+                    RaisePointerPressed(control, root, pointer, point, MouseButton.Left);
+                    if (interactions.HasFlag(InputInteractionMask.PointerMove))
+                    {
+                        RaisePointerMoved(control, root, pointer, point, leftPressed: true);
+                    }
+                    RaisePointerReleased(control, root, pointer, point, MouseButton.Left);
+                }
+
+                if (interactions.HasFlag(InputInteractionMask.PointerWheel))
+                {
+                    RaisePointerWheel(control, root, pointer, point, new Vector(0, 1));
+                }
+
+                if (interactions.HasFlag(InputInteractionMask.RightClick))
+                {
+                    RaisePointerPressed(control, root, pointer, point, MouseButton.Right);
+                    RaisePointerReleased(control, root, pointer, point, MouseButton.Right);
+                }
+
+                if (interactions.HasFlag(InputInteractionMask.MiddleClick))
+                {
+                    RaisePointerPressed(control, root, pointer, point, MouseButton.Middle);
+                    RaisePointerReleased(control, root, pointer, point, MouseButton.Middle);
+                }
+
+                if (interactions.HasFlag(InputInteractionMask.CaptureLost))
+                {
+                    RaisePointerCaptureLost(control, pointer);
+                }
+
+                if (interactions.HasFlag(InputInteractionMask.PointerEnterExit))
+                {
+                    RaisePointerExited(control, root, pointer, point);
+                }
+
+                // Skip key/text input when there is no input root to route through.
+            }
+
+            if (interactions.HasFlag(InputInteractionMask.DoubleTap))
+            {
+                RaiseDoubleTapped(control, root, pointer, point);
+            }
+        }
+        finally
+        {
+            pointer.Capture(null!);
+            if (dockControl is not null)
+            {
+                dockControl.IsDockingEnabled = previousDockingEnabled;
+            }
+        }
+
+        if (clearInputState)
+        {
+            DrainDispatcher();
+            ClearInputState(control);
+            DrainDispatcher();
+        }
+    }
+
+    internal static void OpenAndCloseContextMenu(Control target, ContextMenu? menu, Action? whileOpen = null)
+    {
+        if (menu is null)
+        {
+            return;
+        }
+
+        var placementTarget = FindContextMenuOwner(target, menu)
+                              ?? (ReferenceEquals(target.ContextMenu, menu) ? target : null)
+                              ?? menu.PlacementTarget as Control;
+        if (placementTarget is null)
+        {
+            return;
+        }
+
+        menu.PlacementTarget = placementTarget;
+        menu.Open(placementTarget);
+        DrainDispatcher();
+        whileOpen?.Invoke();
+        DrainDispatcher();
+        menu.Close();
+        DrainDispatcher();
+    }
+
+    private static Control? FindContextMenuOwner(Control target, ContextMenu menu)
+    {
+        if (ReferenceEquals(target.ContextMenu, menu))
+        {
+            return target;
+        }
+
+        foreach (var visual in target.GetVisualDescendants())
+        {
+            if (visual is Control control && ReferenceEquals(control.ContextMenu, menu))
+            {
+                return control;
+            }
+        }
+
+        return null;
+    }
+
+    internal static void OpenAndCloseFlyout(Control target, FlyoutBase? flyout, Action? whileOpen = null)
+    {
+        if (flyout is null)
+        {
+            return;
+        }
+
+        flyout.ShowAt(target);
+        DrainDispatcher();
+        whileOpen?.Invoke();
+        DrainDispatcher();
+        flyout.Hide();
+        DrainDispatcher();
+    }
+
+    internal static void InvokeButtonClick(Button? button)
+    {
+        if (button is null)
+        {
+            return;
+        }
+
+        ExerciseInputInteractions(
+            button,
+            interactionMask: InputInteractionMask.PointerEnterExit | InputInteractionMask.PointerPressRelease);
+    }
+
+    internal static void InvokeMenuItemClick(MenuItem? menuItem)
+    {
+        if (menuItem is null)
+        {
+            return;
+        }
+
+        ExerciseInputInteractions(
+            menuItem,
+            interactionMask: InputInteractionMask.PointerEnterExit | InputInteractionMask.PointerPressRelease);
+    }
+
+    internal static T? FindVisualDescendant<T>(Visual root, Func<T, bool>? predicate = null) where T : Visual
+    {
+        if (root is T match && (predicate is null || predicate(match)))
+        {
+            return match;
+        }
+
+        foreach (var visual in root.GetVisualDescendants())
+        {
+            if (visual is T typed && (predicate is null || predicate(typed)))
+            {
+                return typed;
+            }
+        }
+
+        return null;
+    }
+
+    private static InputInteractionMask ResolveInteractionMask(
+        InputInteractionMask? interactionMask,
+        bool includeDoubleTap,
+        bool includeMiddlePress)
+    {
+        var interactions = interactionMask ?? InputInteractionMask.All;
+
+        if (includeDoubleTap)
+        {
+            interactions |= InputInteractionMask.DoubleTap;
+        }
+
+        if (includeMiddlePress)
+        {
+            interactions |= InputInteractionMask.MiddleClick;
+        }
+
+        var overrideValue = Environment.GetEnvironmentVariable("DOCK_LEAK_INTERACTIONS");
+        if (string.IsNullOrWhiteSpace(overrideValue))
+        {
+            return interactions;
+        }
+
+        if (int.TryParse(overrideValue, out var numericMask))
+        {
+            return (InputInteractionMask)numericMask;
+        }
+
+        var resolved = InputInteractionMask.None;
+        var anyParsed = false;
+        var parts = overrideValue.Split(new[] { ',', ';', ' ' }, StringSplitOptions.RemoveEmptyEntries);
+        foreach (var part in parts)
+        {
+            if (Enum.TryParse<InputInteractionMask>(part, ignoreCase: true, out var flag))
+            {
+                resolved |= flag;
+                anyParsed = true;
+            }
+        }
+
+        return anyParsed ? resolved : interactions;
+    }
+
+    internal static void RaisePointerPressed(Control control, MouseButton button, KeyModifiers modifiers = KeyModifiers.None)
+    {
+        if (!TryGetInputContext(control, out var root, out var pointer, out var point))
+        {
+            return;
+        }
+
+        RaisePointerPressed(control, root, pointer, point, button, modifiers);
+    }
+
+    internal static void RaisePointerPressed(Control control, Point point, MouseButton button, KeyModifiers modifiers = KeyModifiers.None)
+    {
+        if (!TryGetInputContext(control, out var root, out var pointer, out _))
+        {
+            return;
+        }
+
+        RaisePointerPressed(control, root, pointer, point, button, modifiers);
+    }
+
+    internal static void RaisePointerMoved(Control control, Point point, bool leftPressed)
+    {
+        if (!TryGetInputContext(control, out var root, out var pointer, out _))
+        {
+            return;
+        }
+
+        RaisePointerMoved(control, root, pointer, point, leftPressed);
+    }
+
+    internal static void RaisePointerReleased(Control control, Point point, MouseButton button)
+    {
+        if (!TryGetInputContext(control, out var root, out var pointer, out _))
+        {
+            return;
+        }
+
+        RaisePointerReleased(control, root, pointer, point, button);
+    }
+
+    internal static void RaiseDoubleTapped(Control control)
+    {
+        if (!TryGetInputContext(control, out var root, out var pointer, out var point))
+        {
+            return;
+        }
+
+        RaiseDoubleTapped(control, root, pointer, point);
+    }
+
+    private static void RaisePointerPressed(Control control, Visual root, AvaloniaPointer pointer, Point point, MouseButton button, KeyModifiers modifiers = KeyModifiers.None)
+    {
+        var (rawModifiers, updateKind) = GetPointerUpdate(button, pressed: true);
+        var properties = new PointerPointProperties(rawModifiers, updateKind);
+        var args = new PointerPressedEventArgs(control, pointer, root, point, 0, properties, modifiers, 1);
+        control.RaiseEvent(args);
+    }
+
+    private static void RaisePointerMoved(Control control, Visual root, AvaloniaPointer pointer, Point point, bool leftPressed)
+    {
+        var rawModifiers = leftPressed ? RawInputModifiers.LeftMouseButton : RawInputModifiers.None;
+        var properties = new PointerPointProperties(rawModifiers, PointerUpdateKind.Other);
+        var args = new PointerEventArgs(InputElement.PointerMovedEvent, control, pointer, root, point, 0, properties, KeyModifiers.None);
+        control.RaiseEvent(args);
+    }
+
+    private static void RaisePointerEntered(Control control, Visual root, AvaloniaPointer pointer, Point point)
+    {
+        var properties = new PointerPointProperties(RawInputModifiers.None, PointerUpdateKind.Other);
+        var args = new PointerEventArgs(InputElement.PointerEnteredEvent, control, pointer, root, point, 0, properties, KeyModifiers.None);
+        control.RaiseEvent(args);
+    }
+
+    private static void RaisePointerExited(Control control, Visual root, AvaloniaPointer pointer, Point point)
+    {
+        var properties = new PointerPointProperties(RawInputModifiers.None, PointerUpdateKind.Other);
+        var args = new PointerEventArgs(InputElement.PointerExitedEvent, control, pointer, root, point, 0, properties, KeyModifiers.None);
+        control.RaiseEvent(args);
+    }
+
+    private static void RaisePointerReleased(Control control, Visual root, AvaloniaPointer pointer, Point point, MouseButton button)
+    {
+        var (_, updateKind) = GetPointerUpdate(button, pressed: false);
+        var properties = new PointerPointProperties(RawInputModifiers.None, updateKind);
+        var args = new PointerReleasedEventArgs(control, pointer, root, point, 0, properties, KeyModifiers.None, button);
+        control.RaiseEvent(args);
+    }
+
+    private static void RaisePointerWheel(Control control, Visual root, AvaloniaPointer pointer, Point point, Vector delta)
+    {
+        var properties = new PointerPointProperties(RawInputModifiers.None, PointerUpdateKind.Other);
+        var args = new PointerWheelEventArgs(control, pointer, root, point, 0, properties, KeyModifiers.None, delta);
+        control.RaiseEvent(args);
+    }
+
+    private static void RaisePointerCaptureLost(Control control, AvaloniaPointer pointer)
+    {
+        var args = new PointerCaptureLostEventArgs(control, pointer);
+        control.RaiseEvent(args);
+    }
+
+    private static void RaiseDoubleTapped(Control control, Visual root, AvaloniaPointer pointer, Point point)
+    {
+        var properties = new PointerPointProperties(RawInputModifiers.LeftMouseButton, PointerUpdateKind.LeftButtonPressed);
+        var pressedArgs = new PointerPressedEventArgs(control, pointer, root, point, 0, properties, KeyModifiers.None, 2);
+        var tappedArgs = new TappedEventArgs(InputElement.DoubleTappedEvent, pressedArgs);
+        control.RaiseEvent(tappedArgs);
+    }
+
+    private static (RawInputModifiers RawModifiers, PointerUpdateKind UpdateKind) GetPointerUpdate(MouseButton button, bool pressed)
+    {
+        return button switch
+        {
+            MouseButton.Left => pressed
+                ? (RawInputModifiers.LeftMouseButton, PointerUpdateKind.LeftButtonPressed)
+                : (RawInputModifiers.None, PointerUpdateKind.LeftButtonReleased),
+            MouseButton.Middle => pressed
+                ? (RawInputModifiers.MiddleMouseButton, PointerUpdateKind.MiddleButtonPressed)
+                : (RawInputModifiers.None, PointerUpdateKind.MiddleButtonReleased),
+            MouseButton.Right => pressed
+                ? (RawInputModifiers.RightMouseButton, PointerUpdateKind.RightButtonPressed)
+                : (RawInputModifiers.None, PointerUpdateKind.RightButtonReleased),
+            _ => (RawInputModifiers.None, PointerUpdateKind.Other)
+        };
+    }
+
+    private static bool TryGetInputContext(Control control, out Visual root, out AvaloniaPointer pointer, out Point point)
+    {
+        root = control;
+        pointer = new AvaloniaPointer(1, PointerType.Mouse, true);
+        point = GetSafePoint(control);
+        return true;
+    }
+
+    private static Point GetSafePoint(Control control)
+    {
+        var bounds = control.Bounds;
+        var width = double.IsFinite(bounds.Width) ? bounds.Width : 0;
+        var height = double.IsFinite(bounds.Height) ? bounds.Height : 0;
+        var x = width > 1 ? width / 2 : 1;
+        var y = height > 1 ? height / 2 : 1;
+        return new Point(x, y);
+    }
+
+    internal static void ClearInputState(Control? control)
+    {
+        var topLevel = control as TopLevel ?? (control is not null ? TopLevel.GetTopLevel(control) : null);
+        ClearInputState(topLevel);
+    }
+
+    internal static void ClearInputState(TopLevel? topLevel)
+    {
+        if (topLevel is not null)
+        {
+            ClearPointerOverPreProcessor(topLevel);
+            ClearTopLevelHandlers(topLevel);
+            topLevel.ClearValue(TopLevel.PointerOverElementProperty);
+            ClearInputManagerPointerState(topLevel);
+            ClearInputManagerObservers(topLevel);
+            ScrubInputManagerInstance(topLevel);
+        }
+
+        ClearKeyboardDeviceState();
+        ClearMouseDeviceState(topLevel);
+        ClearStaticInputReferences();
+        ClearWeakEventSubscriptions();
+        ClearDockStaticState();
+        ClearRenderState();
+        ClearDispatcherState();
+        ScrubInputReferences();
+    }
+
+    private static void ClearLayoutState(TopLevel? topLevel)
+    {
+        if (topLevel is null)
+        {
+            return;
+        }
+
+        var layoutManagerField = typeof(TopLevel).GetField("_layoutManager", BindingFlags.Instance | BindingFlags.NonPublic);
+        if (layoutManagerField?.GetValue(topLevel) is not object layoutManager)
+        {
+            return;
+        }
+
+        if (layoutManager is IDisposable disposable)
+        {
+            disposable.Dispose();
+        }
+
+        ClearCollectionField(layoutManager, "_toMeasure");
+        ClearCollectionField(layoutManager, "_toArrange");
+        ClearCollectionField(layoutManager, "_toArrangeAfterMeasure");
+        ClearCollectionField(layoutManager, "_effectiveViewportChangedListeners");
+
+        layoutManagerField.SetValue(topLevel, null);
+    }
+
+    private static void ForceHandleClosed(TopLevel topLevel)
+    {
+        var handleClosed = typeof(TopLevel).GetMethod("HandleClosed", BindingFlags.Instance | BindingFlags.NonPublic);
+        handleClosed?.Invoke(topLevel, null);
+    }
+
+    private static void ClearCollectionField(object target, string fieldName)
+    {
+        var field = target.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic);
+        if (field is null)
+        {
+            return;
+        }
+
+        var value = field.GetValue(target);
+        switch (value)
+        {
+            case null:
+                return;
+            case System.Collections.IDictionary dictionary:
+                dictionary.Clear();
+                return;
+            case IList list:
+                list.Clear();
+                return;
+            default:
+                var clearMethod = value.GetType().GetMethod("Clear", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+                clearMethod?.Invoke(value, null);
+                if (value is IDisposable disposable)
+                {
+                    disposable.Dispose();
+                }
+                return;
+        }
+    }
+
+    internal static void ClearPinnedDockControlState(PinnedDockControl? control)
+    {
+        if (control is null)
+        {
+            return;
+        }
+
+        if (control.DataContext is IRootDock root)
+        {
+            root.PinnedDock = null;
+            root.LeftPinnedDockables?.Clear();
+            root.RightPinnedDockables?.Clear();
+            root.TopPinnedDockables?.Clear();
+            root.BottomPinnedDockables?.Clear();
+            ClearFactoryCaches(root.Factory);
+        }
+
+        var controlType = typeof(PinnedDockControl);
+        controlType.GetMethod("CloseWindow", BindingFlags.Instance | BindingFlags.NonPublic)
+            ?.Invoke(control, null);
+        controlType.GetMethod("ClearPinnedDockableSubscription", BindingFlags.Instance | BindingFlags.NonPublic)
+            ?.Invoke(control, null);
+
+        SetField(control, "_managedLayer", null);
+        SetField(control, "_managedPinnedHost", null);
+        SetField(control, "_ownerWindow", null);
+        SetField(control, "_window", null);
+        SetField(control, "_trackedDockable", null);
+        SetField(control, "_trackedAvaloniaDockable", null);
+        SetField(control, "_trackedNotifyDockable", null);
+        SetField(control, "_pinnedDock", null);
+        SetField(control, "_pinnedDockGrid", null);
+        SetField(control, "_pinnedDockSplitter", null);
+    }
+
+    internal static void ClearFactoryCaches(IFactory? factory)
+    {
+        if (factory is null)
+        {
+            return;
+        }
+
+        factory.VisibleDockableControls.Clear();
+        factory.VisibleRootControls.Clear();
+        factory.PinnedDockableControls.Clear();
+        factory.PinnedRootControls.Clear();
+        factory.TabDockableControls.Clear();
+        factory.TabRootControls.Clear();
+        factory.ToolControls.Clear();
+        factory.DocumentControls.Clear();
+        factory.DockControls.Clear();
+        factory.HostWindows.Clear();
+    }
+
+    private static void ClearPointerOverPreProcessor(TopLevel topLevel)
+    {
+        var field = typeof(TopLevel).GetField("_pointerOverPreProcessor", BindingFlags.Instance | BindingFlags.NonPublic);
+        if (field?.GetValue(topLevel) is not object preProcessor)
+        {
+            return;
+        }
+
+        var clearMethod = preProcessor.GetType().GetMethod(
+            "ClearPointerOver",
+            BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
+            Type.EmptyTypes);
+
+        if (clearMethod is not null)
+        {
+            clearMethod.Invoke(preProcessor, null);
+        }
+
+        SetField(preProcessor, "_inputRoot", null);
+        SetField(preProcessor, "_currentPointer", null);
+        SetField(preProcessor, "_lastActivePointerDevice", null);
+        SetField(preProcessor, "_lastKnownPosition", null);
+
+        var subscriptionField = typeof(TopLevel).GetField("_pointerOverPreProcessorSubscription", BindingFlags.Instance | BindingFlags.NonPublic);
+        if (subscriptionField?.GetValue(topLevel) is IDisposable subscription)
+        {
+            subscription.Dispose();
+            subscriptionField.SetValue(topLevel, null);
+        }
+
+        field.SetValue(topLevel, null);
+    }
+
+    private static void ClearTopLevelHandlers(TopLevel topLevel)
+    {
+        var focusManager = topLevel.FocusManager;
+        if (focusManager is not null)
+        {
+            SetField(focusManager, "_focusRoot", null);
+        }
+
+        var focusedElementProperty = typeof(FocusManager).GetField("FocusedElementProperty", BindingFlags.Static | BindingFlags.NonPublic);
+        if (focusedElementProperty?.GetValue(null) is AvaloniaProperty property)
+        {
+            topLevel.ClearValue(property);
+        }
+
+        ClearHandlerOwner(topLevel, "_keyboardNavigationHandler", "_owner");
+        ClearHandlerOwner(topLevel, "_accessKeyHandler", "_owner");
+        ClearHandlerOwner(topLevel, "_accessKeyHandler", "_restoreFocusElementRef");
+        ClearHandlerRegistrations(topLevel, "_accessKeyHandler", "_registrations");
+    }
+
+    private static void ClearInputManagerPointerState(TopLevel topLevel)
+    {
+        var inputManagerField = typeof(TopLevel).GetField("_inputManager", BindingFlags.Instance | BindingFlags.NonPublic);
+        var inputManager = inputManagerField?.GetValue(topLevel);
+        if (inputManager is null)
+        {
+            return;
+        }
+
+        if (GetStaticMemberValue(typeof(MouseDevice), "Primary", "_primary") is not IInputDevice device)
+        {
+            return;
+        }
+
+        var position = new Point(0, 0);
+        var leaveArgs = CreateRawPointerEventArgs(device, topLevel, RawPointerEventType.LeaveWindow, position);
+        if (leaveArgs is not null)
+        {
+            InvokeInputManager(inputManager, leaveArgs);
+        }
+
+        var cancelArgs = CreateRawPointerEventArgs(device, topLevel, RawPointerEventType.CancelCapture, position);
+        if (cancelArgs is not null)
+        {
+            InvokeInputManager(inputManager, cancelArgs);
+        }
+    }
+
+    private static void ClearInputManagerObservers(TopLevel topLevel)
+    {
+        var inputManagerField = typeof(TopLevel).GetField("_inputManager", BindingFlags.Instance | BindingFlags.NonPublic);
+        var inputManager = inputManagerField?.GetValue(topLevel);
+        if (inputManager is null)
+        {
+            return;
+        }
+
+        foreach (var fieldName in new[] { "_preProcess", "_process", "_postProcess" })
+        {
+            var subjectField = inputManager.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic);
+            if (subjectField?.GetValue(inputManager) is not object subject)
+            {
+                continue;
+            }
+
+            var baseType = subject.GetType().BaseType;
+            var observersField = baseType?.GetField("_observers", BindingFlags.Instance | BindingFlags.NonPublic);
+            if (observersField?.GetValue(subject) is System.Collections.IList observers)
+            {
+                observers.Clear();
+            }
+        }
+    }
+
+    private static void ScrubInputManagerInstance(TopLevel topLevel)
+    {
+        var inputManagerField = typeof(TopLevel).GetField("_inputManager", BindingFlags.Instance | BindingFlags.NonPublic);
+        var inputManager = inputManagerField?.GetValue(topLevel);
+        if (inputManager is null)
+        {
+            return;
+        }
+
+        var inputRootType = typeof(IInputRoot);
+        var inputElementType = typeof(IInputElement);
+        var visited = new HashSet<object>(ReferenceEqualityComparer.Instance);
+        ScrubObject(inputManager, inputRootType, inputElementType, visited, depth: 0);
+    }
+
+    private static void InvokeInputManager(object inputManager, RawInputEventArgs args)
+    {
+        var method = inputManager.GetType().GetMethod(
+            "ProcessInput",
+            BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
+            null,
+            new[] { typeof(RawInputEventArgs) },
+            null);
+
+        method?.Invoke(inputManager, new object?[] { args });
+    }
+
+    private static RawPointerEventArgs? CreateRawPointerEventArgs(IInputDevice device, IInputRoot root, RawPointerEventType type, Point position)
+    {
+        var args = new object?[]
+        {
+            device,
+            0ul,
+            root,
+            type,
+            position,
+            RawInputModifiers.None
+        };
+
+        return Activator.CreateInstance(typeof(RawPointerEventArgs), BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, args, null)
+            as RawPointerEventArgs;
+    }
+
+    private static void ClearKeyboardDeviceState()
+    {
+        var keyboard = GetAvaloniaService(typeof(IKeyboardDevice))
+            ?? GetStaticMemberValue(typeof(KeyboardDevice), "Instance");
+        if (keyboard is null)
+        {
+            return;
+        }
+
+        ClearTextInputManagerState(keyboard);
+        SetField(keyboard, "_focusedElement", null);
+        SetField(keyboard, "_focusedRoot", null);
+    }
+
+    private static void ClearTextInputManagerState(object keyboard)
+    {
+        var managerField = keyboard.GetType().GetField("_textInputManager", BindingFlags.Instance | BindingFlags.NonPublic);
+        if (managerField?.GetValue(keyboard) is not object manager)
+        {
+            return;
+        }
+
+        var setFocusedElement = manager.GetType().GetMethod(
+            "SetFocusedElement",
+            BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
+            null,
+            new[] { typeof(IInputElement) },
+            null);
+
+        setFocusedElement?.Invoke(manager, new object?[] { null });
+
+        var visualRootField = manager.GetType().GetField("_visualRoot", BindingFlags.Instance | BindingFlags.NonPublic);
+        var visualRoot = visualRootField?.GetValue(manager);
+        if (visualRoot is not null)
+        {
+            var removeHandler = typeof(InputMethod).GetMethod(
+                "RemoveTextInputMethodClientRequeryRequestedHandler",
+                BindingFlags.Static | BindingFlags.Public,
+                null,
+                new[] { typeof(Interactive), typeof(EventHandler<RoutedEventArgs>) },
+                null);
+
+            var handlerMethod = manager.GetType().GetMethod(
+                "TextInputMethodClientRequeryRequested",
+                BindingFlags.Instance | BindingFlags.NonPublic);
+
+            if (removeHandler is not null && handlerMethod is not null)
+            {
+                var handler = Delegate.CreateDelegate(typeof(EventHandler<RoutedEventArgs>), manager, handlerMethod, throwOnBindFailure: false);
+                if (handler is not null)
+                {
+                    removeHandler.Invoke(null, new object?[] { visualRoot, handler });
+                }
+            }
+        }
+
+        SetField(manager, "_focusedElement", null);
+        SetField(manager, "_visualRoot", null);
+        SetField(manager, "_client", null);
+        SetField(manager, "_im", null);
+    }
+
+    private static void ClearMouseDeviceState(TopLevel? topLevel)
+    {
+        var mouse = GetTopLevelMouseDevice(topLevel)
+            ?? GetAvaloniaService(typeof(IMouseDevice))
+            ?? GetStaticMemberValue(typeof(MouseDevice), "Primary", "_primary");
+        if (mouse is null)
+        {
+            return;
+        }
+
+        var pointerField = mouse.GetType().GetField("_pointer", BindingFlags.Instance | BindingFlags.NonPublic);
+        if (pointerField?.GetValue(mouse) is not AvaloniaPointer pointer)
+        {
+            return;
+        }
+
+        pointer.Capture(null!);
+        SetField(pointer, "<Captured>k__BackingField", null);
+        SetField(pointer, "<CapturedGestureRecognizer>k__BackingField", null);
+        SetField(pointer, "<IsGestureRecognitionSkipped>k__BackingField", false);
+    }
+
+    private static void SetField(object target, string fieldName, object? value)
+    {
+        var field = target.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic);
+        field?.SetValue(target, value);
+    }
+
+    private static void ClearHandlerOwner(TopLevel topLevel, string handlerFieldName, string ownerFieldName)
+    {
+        var handlerField = typeof(TopLevel).GetField(handlerFieldName, BindingFlags.Instance | BindingFlags.NonPublic);
+        if (handlerField?.GetValue(topLevel) is not object handler)
+        {
+            return;
+        }
+
+        SetField(handler, ownerFieldName, null);
+    }
+
+    private static void ClearHandlerRegistrations(TopLevel topLevel, string handlerFieldName, string registrationsFieldName)
+    {
+        var handlerField = typeof(TopLevel).GetField(handlerFieldName, BindingFlags.Instance | BindingFlags.NonPublic);
+        if (handlerField?.GetValue(topLevel) is not object handler)
+        {
+            return;
+        }
+
+        var registrationsField = handler.GetType().GetField(registrationsFieldName, BindingFlags.Instance | BindingFlags.NonPublic);
+        if (registrationsField?.GetValue(handler) is System.Collections.IList registrations)
+        {
+            registrations.Clear();
+        }
+    }
+
+    private static void ClearStaticInputReferences()
+    {
+        var inputRootType = typeof(IInputRoot);
+        var inputElementType = typeof(IInputElement);
+
+        foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+        {
+            if (assembly.FullName is null || !assembly.FullName.StartsWith("Avalonia", StringComparison.Ordinal))
+            {
+                continue;
+            }
+
+            Type[] types;
+            try
+            {
+                types = assembly.GetTypes();
+            }
+            catch (ReflectionTypeLoadException ex)
+            {
+                types = ex.Types.Where(type => type is not null).ToArray()!;
+            }
+
+            foreach (var type in types)
+            {
+                if (type is null)
+                {
+                    continue;
+                }
+
+                if (IsLeakTraceEnabled && type.FullName == "Avalonia.Utilities.WeakEvents.AvaloniaPropertyChanged")
+                {
+                    Trace($"[LeakTrace:WeakEvents] Found AvaloniaPropertyChanged in {assembly.FullName}.");
+                }
+
+                FieldInfo[] fields;
+                try
+                {
+                    fields = type.GetFields(BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+                }
+                catch
+                {
+                    continue;
+                }
+
+                foreach (var field in fields)
+                {
+                    if (field.IsInitOnly)
+                    {
+                        continue;
+                    }
+
+                    if (!inputRootType.IsAssignableFrom(field.FieldType) && !inputElementType.IsAssignableFrom(field.FieldType))
+                    {
+                        continue;
+                    }
+
+                    if (field.GetValue(null) is null)
+                    {
+                        continue;
+                    }
+
+                    field.SetValue(null, null);
+                }
+            }
+        }
+    }
+
+    private static void ClearWeakEventSubscriptions()
+    {
+        if (IsLeakTraceEnabled)
+        {
+            Trace("[LeakTrace:WeakEvents] Clearing weak event subscriptions.");
+        }
+
+        var avaloniaAssemblyName = typeof(AvaloniaObject).Assembly.FullName;
+        Type? type = null;
+        if (!string.IsNullOrWhiteSpace(avaloniaAssemblyName))
+        {
+            type = Type.GetType(
+                $"Avalonia.Utilities.WeakEvents.AvaloniaPropertyChanged, {avaloniaAssemblyName}",
+                throwOnError: false);
+        }
+
+        type ??= typeof(AvaloniaObject).Assembly
+            .GetType("Avalonia.Utilities.WeakEvents.AvaloniaPropertyChanged", throwOnError: false);
+
+        if (type is null)
+        {
+            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                Type[] types;
+                try
+                {
+                    types = assembly.GetTypes();
+                }
+                catch (ReflectionTypeLoadException ex)
+                {
+                    types = ex.Types.Where(found => found is not null).ToArray()!;
+                }
+
+                foreach (var candidate in types)
+                {
+                    if (candidate?.FullName == "Avalonia.Utilities.WeakEvents.AvaloniaPropertyChanged")
+                    {
+                        type = candidate;
+                        break;
+                    }
+                }
+
+                if (type is not null)
+                {
+                    break;
+                }
+            }
+        }
+
+        if (type is null)
+        {
+            if (IsLeakTraceEnabled)
+            {
+                Trace("[LeakTrace:WeakEvents] AvaloniaPropertyChanged type not found. Scanning weak event fields...");
+            }
+
+            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                if (assembly.FullName is null || !assembly.FullName.StartsWith("Avalonia", StringComparison.Ordinal))
+                {
+                    continue;
+                }
+
+                Type[] types;
+                try
+                {
+                    types = assembly.GetTypes();
+                }
+                catch (ReflectionTypeLoadException ex)
+                {
+                    types = ex.Types.Where(found => found is not null).ToArray()!;
+                }
+
+                foreach (var candidate in types)
+                {
+                    var subscriptionsField = candidate.GetField("_subscriptions", BindingFlags.Static | BindingFlags.NonPublic);
+                    if (subscriptionsField is null)
+                    {
+                        continue;
+                    }
+
+                    var subscriptionsValue = subscriptionsField.GetValue(null);
+                    if (subscriptionsValue is null)
+                    {
+                        continue;
+                    }
+
+                    if (IsLeakTraceEnabled)
+                    {
+                        Trace($"[LeakTrace:WeakEvents] Clearing {candidate.FullName}._subscriptions ({subscriptionsValue.GetType().FullName}).");
+                    }
+
+                    if (subscriptionsValue is IDictionary dictionaryValue)
+                    {
+                        dictionaryValue.Clear();
+                        continue;
+                    }
+
+                    if (subscriptionsValue is IList listValue)
+                    {
+                        listValue.Clear();
+                        continue;
+                    }
+
+                    var clearMethod = subscriptionsValue.GetType().GetMethod("Clear", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+                    clearMethod?.Invoke(subscriptionsValue, null);
+                }
+            }
+
+            return;
+        }
+
+        var field = type.GetField("_subscriptions", BindingFlags.Static | BindingFlags.NonPublic);
+        var subscriptions = field?.GetValue(null);
+        if (subscriptions is null)
+        {
+            return;
+        }
+
+        if (IsLeakTraceEnabled)
+        {
+            Trace($"[LeakTrace:WeakEvents] SubscriptionsType={subscriptions.GetType().FullName}");
+        }
+
+        if (subscriptions is IDictionary dictionary)
+        {
+            dictionary.Clear();
+            if (IsLeakTraceEnabled)
+            {
+                Trace("[LeakTrace:WeakEvents] Cleared IDictionary subscriptions.");
+            }
+            return;
+        }
+
+        if (subscriptions is IList list)
+        {
+            list.Clear();
+            if (IsLeakTraceEnabled)
+            {
+                Trace("[LeakTrace:WeakEvents] Cleared IList subscriptions.");
+            }
+            return;
+        }
+
+        var clear = subscriptions.GetType().GetMethod("Clear", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+        if (clear is not null)
+        {
+            clear.Invoke(subscriptions, null);
+            if (IsLeakTraceEnabled)
+            {
+                Trace("[LeakTrace:WeakEvents] Cleared subscriptions via method.");
+            }
+        }
+    }
+
+    private static void ClearDockStaticState()
+    {
+        ClearDragPreviewHelper();
+        ClearDragPreviewContext();
+    }
+
+    private static void ClearRenderState()
+    {
+        var mediaContextType = Type.GetType("Avalonia.Media.MediaContext, Avalonia.Base");
+        if (mediaContextType is null)
+        {
+            return;
+        }
+
+        var mediaContext = GetAvaloniaService(mediaContextType)
+            ?? mediaContextType.GetProperty("Instance", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
+                ?.GetValue(null);
+
+        if (mediaContext is null)
+        {
+            return;
+        }
+
+        var topLevelsField = mediaContextType.GetField("_topLevels", BindingFlags.Instance | BindingFlags.NonPublic);
+        if (topLevelsField?.GetValue(mediaContext) is System.Collections.IDictionary topLevels)
+        {
+            topLevels.Clear();
+        }
+
+        var pendingBatchesField = mediaContextType.GetField("_pendingCompositionBatches", BindingFlags.Instance | BindingFlags.NonPublic);
+        if (pendingBatchesField?.GetValue(mediaContext) is System.Collections.IDictionary pendingBatches)
+        {
+            pendingBatches.Clear();
+        }
+
+        var requestedCommitsField = mediaContextType.GetField("_requestedCommits", BindingFlags.Instance | BindingFlags.NonPublic);
+        if (requestedCommitsField?.GetValue(mediaContext) is object requestedCommits)
+        {
+            if (requestedCommits is IList list)
+            {
+                list.Clear();
+            }
+            else
+            {
+                requestedCommits.GetType().GetMethod("Clear", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
+                    ?.Invoke(requestedCommits, null);
+            }
+        }
+
+        var invokeCallbacksField = mediaContextType.GetField("_invokeOnRenderCallbacks", BindingFlags.Instance | BindingFlags.NonPublic);
+        if (invokeCallbacksField?.GetValue(mediaContext) is IList callbacks)
+        {
+            callbacks.Clear();
+        }
+
+        var callbackPoolField = mediaContextType.GetField("_invokeOnRenderCallbackListPool", BindingFlags.Instance | BindingFlags.NonPublic);
+        if (callbackPoolField?.GetValue(mediaContext) is object pool)
+        {
+            if (pool is IList list)
+            {
+                list.Clear();
+            }
+            else
+            {
+                pool.GetType().GetMethod("Clear", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
+                    ?.Invoke(pool, null);
+            }
+        }
+
+        var animationsTimerField = mediaContextType.GetField("_animationsTimer", BindingFlags.Instance | BindingFlags.NonPublic);
+        if (animationsTimerField?.GetValue(mediaContext) is object animationsTimer)
+        {
+            var stopMethod = animationsTimer.GetType().GetMethod("Stop", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+            stopMethod?.Invoke(animationsTimer, null);
+
+            var tickField = animationsTimer.GetType().GetField("Tick", BindingFlags.Instance | BindingFlags.NonPublic);
+            tickField?.SetValue(animationsTimer, null);
+        }
+    }
+
+    private static void ClearDispatcherState()
+    {
+        var dispatcher = Dispatcher.UIThread;
+        var dispatcherType = dispatcher.GetType();
+
+        var timersField = dispatcherType.GetField("_timers", BindingFlags.Instance | BindingFlags.NonPublic);
+        if (timersField?.GetValue(dispatcher) is IList timers)
+        {
+            var timerSnapshot = new object[timers.Count];
+            timers.CopyTo(timerSnapshot, 0);
+
+            foreach (var timer in timerSnapshot)
+            {
+                if (timer is null)
+                {
+                    continue;
+                }
+
+                var stopMethod = timer.GetType().GetMethod("Stop", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+                stopMethod?.Invoke(timer, null);
+
+                var tickField = timer.GetType().GetField("Tick", BindingFlags.Instance | BindingFlags.NonPublic);
+                tickField?.SetValue(timer, null);
+            }
+
+            timers.Clear();
+        }
+
+        var timersVersionField = dispatcherType.GetField("_timersVersion", BindingFlags.Instance | BindingFlags.NonPublic);
+        if (timersVersionField?.GetValue(dispatcher) is long version)
+        {
+            timersVersionField.SetValue(dispatcher, version + 1);
+        }
+
+        var queueField = dispatcherType.GetField("_queue", BindingFlags.Instance | BindingFlags.NonPublic);
+        if (queueField?.GetValue(dispatcher) is object queue)
+        {
+            var queueType = queue.GetType();
+            var priorityChainsField = queueType.GetField("_priorityChains", BindingFlags.Instance | BindingFlags.NonPublic);
+            if (priorityChainsField?.GetValue(queue) is System.Collections.IDictionary chains)
+            {
+                chains.Clear();
+            }
+
+            var cacheField = queueType.GetField("_cacheReusableChains", BindingFlags.Instance | BindingFlags.NonPublic);
+            if (cacheField?.GetValue(queue) is object cache)
+            {
+                cache.GetType().GetMethod("Clear", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
+                    ?.Invoke(cache, null);
+            }
+
+            SetField(queue, "_head", null);
+            SetField(queue, "_tail", null);
+        }
+    }
+
+    private static void ClearDragPreviewHelper()
+    {
+        var type = Type.GetType("Dock.Avalonia.Internal.DragPreviewHelper, Dock.Avalonia");
+        if (type is null)
+        {
+            return;
+        }
+
+        var windowField = type.GetField("s_window", BindingFlags.Static | BindingFlags.NonPublic);
+        if (windowField?.GetValue(null) is Window window)
+        {
+            window.Close();
+        }
+
+        SetStaticField(type, "s_window", null);
+        SetStaticField(type, "s_control", null);
+        SetStaticField(type, "s_managedControl", null);
+        SetStaticField(type, "s_managedLayer", null);
+        SetStaticField(type, "s_windowTemplatesInitialized", false);
+        SetStaticField(type, "s_managedTemplatesInitialized", false);
+    }
+
+    private static void ClearDragPreviewContext()
+    {
+        var type = Type.GetType("Dock.Avalonia.Internal.DragPreviewContext, Dock.Avalonia");
+        if (type is null)
+        {
+            return;
+        }
+
+        SetStaticField(type, "IsActive", false, isProperty: true);
+        SetStaticField(type, "Dockable", null, isProperty: true);
+    }
+
+    private static void SetStaticField(Type type, string name, object? value, bool isProperty = false)
+    {
+        if (isProperty)
+        {
+            var property = type.GetProperty(name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
+            property?.SetValue(null, value);
+            return;
+        }
+
+        var field = type.GetField(name, BindingFlags.Static | BindingFlags.NonPublic);
+        field?.SetValue(null, value);
+    }
+
+    private static object? GetAvaloniaService(Type serviceType)
+    {
+        var locatorType = typeof(AvaloniaLocator);
+        var currentProperty = locatorType.GetProperty("Current", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
+        var resolver = currentProperty?.GetValue(null);
+        if (resolver is null)
+        {
+            return null;
+        }
+
+        var getService = resolver.GetType().GetMethod("GetService", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new[] { typeof(Type) }, null);
+        return getService?.Invoke(resolver, new object?[] { serviceType });
+    }
+
+    private static object? GetTopLevelMouseDevice(TopLevel? topLevel)
+    {
+        if (topLevel?.PlatformImpl is null)
+        {
+            return null;
+        }
+
+        var property = topLevel.PlatformImpl.GetType().GetProperty("MouseDevice", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+        return property?.GetValue(topLevel.PlatformImpl);
+    }
+
+    private static void ClearPlatformImpl(TopLevel topLevel)
+    {
+        var platformImpl = topLevel.PlatformImpl;
+        if (platformImpl is null)
+        {
+            return;
+        }
+
+        var mouseDevice = GetTopLevelMouseDevice(topLevel);
+        if (mouseDevice is IDisposable disposableMouse)
+        {
+            disposableMouse.Dispose();
+        }
+
+        var implType = platformImpl.GetType();
+        var inputRootProperty = implType.GetProperty("InputRoot", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+        if (inputRootProperty?.CanWrite == true)
+        {
+            inputRootProperty.SetValue(platformImpl, null);
+        }
+
+        var inputProperty = implType.GetProperty("Input", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+        if (inputProperty?.CanWrite == true)
+        {
+            inputProperty.SetValue(platformImpl, null);
+        }
+
+        if (platformImpl is IDisposable disposable)
+        {
+            disposable.Dispose();
+        }
+    }
+
+    private static object? GetStaticMemberValue(Type type, string propertyName, string? fieldName = null)
+    {
+        var property = type.GetProperty(propertyName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
+        if (property is not null)
+        {
+            return property.GetValue(null);
+        }
+
+        if (fieldName is not null)
+        {
+            var field = type.GetField(fieldName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
+            if (field is not null)
+            {
+                return field.GetValue(null);
+            }
+        }
+
+        return null;
+    }
+
+    private static void ScrubInputReferences()
+    {
+        var inputRootType = typeof(IInputRoot);
+        var inputElementType = typeof(IInputElement);
+        var visited = new HashSet<object>(ReferenceEqualityComparer.Instance);
+
+        foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+        {
+            if (assembly.FullName is null)
+            {
+                continue;
+            }
+
+            var traceAll = string.Equals(
+                Environment.GetEnvironmentVariable("DOCK_LEAK_TRACE_ALL"),
+                "1",
+                StringComparison.Ordinal);
+
+            if (!traceAll
+                && !assembly.FullName.StartsWith("Avalonia", StringComparison.Ordinal)
+                && !assembly.FullName.StartsWith("Dock.", StringComparison.Ordinal))
+            {
+                continue;
+            }
+
+            Type[] types;
+            try
+            {
+                types = assembly.GetTypes();
+            }
+            catch (ReflectionTypeLoadException ex)
+            {
+                types = ex.Types.Where(type => type is not null).ToArray()!;
+            }
+
+            foreach (var type in types)
+            {
+                if (type is null)
+                {
+                    continue;
+                }
+
+                if (IsLeakTraceEnabled && type.FullName == "Avalonia.Utilities.WeakEvents.AvaloniaPropertyChanged")
+                {
+                    Trace($"[LeakTrace:WeakEvents] Found AvaloniaPropertyChanged in {assembly.FullName}.");
+                }
+
+                FieldInfo[] fields;
+                try
+                {
+                    fields = type.GetFields(BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+                }
+                catch
+                {
+                    continue;
+                }
+
+                foreach (var field in fields)
+                {
+                    object? value;
+                    try
+                    {
+                        value = field.GetValue(null);
+                    }
+                    catch
+                    {
+                        continue;
+                    }
+
+                    if (value is null)
+                    {
+                        continue;
+                    }
+
+                    if (inputRootType.IsAssignableFrom(field.FieldType) || inputElementType.IsAssignableFrom(field.FieldType))
+                    {
+                        TrySetField(field, null, null);
+                        continue;
+                    }
+
+                    if (value is IInputRoot || value is IInputElement)
+                    {
+                        TrySetField(field, null, null);
+                        continue;
+                    }
+
+                    ScrubObject(value, inputRootType, inputElementType, visited, depth: 0);
+                }
+            }
+        }
+    }
+
+    private static void ScrubObject(object target, Type inputRootType, Type inputElementType, HashSet<object> visited, int depth)
+    {
+        if (depth > 6)
+        {
+            return;
+        }
+
+        if (target is Delegate)
+        {
+            return;
+        }
+
+        if (!visited.Add(target))
+        {
+            return;
+        }
+
+        var targetType = target.GetType();
+        if (targetType.IsPrimitive || targetType.IsEnum || targetType == typeof(string))
+        {
+            return;
+        }
+
+        if (target is IDictionary dictionary)
+        {
+            if (dictionary.Count == 0)
+            {
+                return;
+            }
+
+            var shouldClear = false;
+            foreach (DictionaryEntry entry in dictionary)
+            {
+                if (entry.Key is not null
+                    && (inputRootType.IsInstanceOfType(entry.Key) || inputElementType.IsInstanceOfType(entry.Key)))
+                {
+                    shouldClear = true;
+                    break;
+                }
+
+                if (entry.Value is not null
+                    && (inputRootType.IsInstanceOfType(entry.Value) || inputElementType.IsInstanceOfType(entry.Value)))
+                {
+                    shouldClear = true;
+                    break;
+                }
+            }
+
+            if (shouldClear)
+            {
+                dictionary.Clear();
+                return;
+            }
+        }
+
+        if (target is IList list)
+        {
+            if (list.Count == 0)
+            {
+                return;
+            }
+
+            var shouldClear = false;
+            foreach (var item in list)
+            {
+                if (item is null)
+                {
+                    continue;
+                }
+
+                if (inputRootType.IsInstanceOfType(item) || inputElementType.IsInstanceOfType(item))
+                {
+                    shouldClear = true;
+                    break;
+                }
+            }
+
+            if (shouldClear)
+            {
+                list.Clear();
+                return;
+            }
+        }
+
+        foreach (var field in targetType.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public))
+        {
+            if (field.FieldType.IsValueType)
+            {
+                continue;
+            }
+
+            object? value;
+            try
+            {
+                value = field.GetValue(target);
+            }
+            catch
+            {
+                continue;
+            }
+
+            if (value is null)
+            {
+                continue;
+            }
+
+            if (inputRootType.IsAssignableFrom(field.FieldType) || inputElementType.IsAssignableFrom(field.FieldType))
+            {
+                TrySetField(field, target, null);
+                continue;
+            }
+
+            if (value is IInputRoot || value is IInputElement)
+            {
+                TrySetField(field, target, null);
+                continue;
+            }
+
+            ScrubObject(value, inputRootType, inputElementType, visited, depth + 1);
+        }
+    }
+
+    private static void TrySetField(FieldInfo field, object? target, object? value)
+    {
+        try
+        {
+            field.SetValue(target, value);
+        }
+        catch
+        {
+        }
+    }
+
+    private sealed class ReferenceEqualityComparer : IEqualityComparer<object>
+    {
+        internal static readonly ReferenceEqualityComparer Instance = new();
+
+        bool IEqualityComparer<object>.Equals(object? x, object? y) => ReferenceEquals(x, y);
+
+        public int GetHashCode(object obj) => RuntimeHelpers.GetHashCode(obj);
+    }
+
+    // Dump helpers removed after investigation work; keep trace hooks lean for leak tests.
+
+    internal static void ResetDispatcherForUnitTests()
+    {
+        var reset = typeof(Dispatcher).GetMethod("ResetForUnitTests", BindingFlags.Static | BindingFlags.NonPublic);
+        reset?.Invoke(null, null);
+
+        var resetBefore = typeof(Dispatcher).GetMethod("ResetBeforeUnitTests", BindingFlags.Static | BindingFlags.NonPublic);
+        resetBefore?.Invoke(null, null);
+    }
+
+    internal static void Trace(string message)
+    {
+        if (!IsLeakTraceEnabled)
+        {
+            return;
+        }
+
+        Console.WriteLine(message);
+
+        try
+        {
+            File.AppendAllText("/tmp/dock_leak_trace.log", message + Environment.NewLine);
+        }
+        catch
+        {
+        }
+    }
+
+    internal static void TraceVisualTree(Visual root, string label, int maxTypes = 60)
+    {
+        if (!IsLeakTraceEnabled)
+        {
+            return;
+        }
+
+        var templateInfo = string.Empty;
+        if (root is TemplatedControl templated)
+        {
+            templateInfo = $" Template={(templated.Template is null ? "null" : templated.Template.GetType().Name)} Theme={(templated.Theme is null ? "null" : templated.Theme.GetType().Name)}";
+        }
+
+        var groups = root.GetVisualDescendants()
+            .GroupBy(visual => visual.GetType().Name)
+            .OrderByDescending(group => group.Count())
+            .Take(maxTypes)
+            .Select(group => $"{group.Key}={group.Count()}");
+
+        Trace($"[LeakTrace:{label}] Root={root.GetType().Name} Attached={TopLevel.GetTopLevel(root) is not null}{templateInfo} Visual descendants: {string.Join(", ", groups)}");
+    }
+
+}
diff --git a/tests/Dock.Avalonia.LeakTests/LeakTestSession.cs b/tests/Dock.Avalonia.LeakTests/LeakTestSession.cs
new file mode 100644
index 000000000..3fc7f555f
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/LeakTestSession.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Linq;
+using System.Threading;
+using Avalonia.Headless;
+
+namespace Dock.Avalonia.LeakTests;
+
+internal static class LeakTestSession
+{
+    internal static void RunInSession(Action action)
+    {
+        HeadlessUnitTestSession? session = null;
+        try
+        {
+            session = HeadlessUnitTestSession.StartNew(typeof(LeakTestsApp));
+            session.Dispatch(() =>
+            {
+                LeakTestHelpers.EnsureFontManager();
+                action();
+            }, CancellationToken.None).GetAwaiter().GetResult();
+            session.Dispatch(LeakTestHelpers.DrainDispatcher, CancellationToken.None).GetAwaiter().GetResult();
+        }
+        finally
+        {
+            try
+            {
+                session?.Dispose();
+            }
+            catch (AggregateException ex) when (ex.InnerExceptions.All(IsCompletedCollectionError))
+            {
+            }
+            LeakTestHelpers.DrainDispatcher();
+        }
+    }
+
+    internal static T RunInSession<T>(Func<T> action)
+    {
+        HeadlessUnitTestSession? session = null;
+        try
+        {
+            session = HeadlessUnitTestSession.StartNew(typeof(LeakTestsApp));
+            var result = session.Dispatch(() =>
+            {
+                LeakTestHelpers.EnsureFontManager();
+                return action();
+            }, CancellationToken.None).GetAwaiter().GetResult();
+            session.Dispatch(LeakTestHelpers.DrainDispatcher, CancellationToken.None).GetAwaiter().GetResult();
+            return result;
+        }
+        finally
+        {
+            try
+            {
+                session?.Dispose();
+            }
+            catch (AggregateException ex) when (ex.InnerExceptions.All(IsCompletedCollectionError))
+            {
+            }
+            LeakTestHelpers.DrainDispatcher();
+        }
+    }
+
+    private static bool IsCompletedCollectionError(Exception exception)
+    {
+        return exception is InvalidOperationException { Message: not null } invalidOperation
+               && invalidOperation.Message.Contains("marked as complete", StringComparison.OrdinalIgnoreCase);
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/ManagedDockWindowDocumentLeakTests.cs b/tests/Dock.Avalonia.LeakTests/ManagedDockWindowDocumentLeakTests.cs
new file mode 100644
index 000000000..b07d2582f
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/ManagedDockWindowDocumentLeakTests.cs
@@ -0,0 +1,68 @@
+using System;
+using Dock.Avalonia.Controls;
+using Dock.Model.Avalonia;
+using Dock.Model.Avalonia.Core;
+using Dock.Model.Controls;
+using Dock.Model.Core;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class ManagedDockWindowDocumentLeakTests
+{
+    [ReleaseFact]
+    public void ManagedDockWindowDocument_Dispose_DoesNotLeak_WhenWindowAlive()
+    {
+        var result = RunInSession(() =>
+        {
+            var factory = new Factory();
+            var root = (IRootDock)factory.CreateRootDock();
+            root.Factory = factory;
+            root.VisibleDockables = factory.CreateList<IDockable>();
+
+            var focusedDockable = factory.CreateDocument();
+            focusedDockable.Factory = factory;
+            focusedDockable.Title = "Focused";
+            root.FocusedDockable = focusedDockable;
+
+            var dockWindow = new DockWindow
+            {
+                Factory = factory,
+                Layout = root,
+                Title = "Managed"
+            };
+
+            var document = new ManagedDockWindowDocument(dockWindow)
+            {
+                Factory = factory
+            };
+
+            var documentRef = new WeakReference(document);
+            document.Dispose();
+            document = null;
+
+            return new ManagedDockWindowDocumentLeakResult(
+                documentRef,
+                dockWindow,
+                root,
+                focusedDockable,
+                factory);
+        });
+
+        AssertCollected(result.DocumentRef);
+        GC.KeepAlive(result.DockWindowKeepAlive);
+        GC.KeepAlive(result.RootKeepAlive);
+        GC.KeepAlive(result.FocusedDockableKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    private sealed record ManagedDockWindowDocumentLeakResult(
+        WeakReference DocumentRef,
+        DockWindow DockWindowKeepAlive,
+        IRootDock RootKeepAlive,
+        IDockable FocusedDockableKeepAlive,
+        Factory FactoryKeepAlive);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/ManagedWindowLayerLeakTests.cs b/tests/Dock.Avalonia.LeakTests/ManagedWindowLayerLeakTests.cs
new file mode 100644
index 000000000..87d25c00a
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/ManagedWindowLayerLeakTests.cs
@@ -0,0 +1,191 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Avalonia;
+using Dock.Model.Avalonia.Core;
+using Dock.Model.Controls;
+using Dock.Model.Core;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class ManagedWindowLayerLeakTests
+{
+    [ReleaseFact]
+    public void ManagedWindowLayer_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var factory = new Factory();
+            var root = (IRootDock)factory.CreateRootDock();
+            root.Factory = factory;
+
+            var dockWindow = new DockWindow
+            {
+                Factory = factory,
+                Layout = root
+            };
+
+            var document = new ManagedDockWindowDocument(dockWindow)
+            {
+                Factory = factory
+            };
+
+            var dock = new ManagedWindowDock
+            {
+                Factory = factory
+            };
+
+            dock.VisibleDockables = factory.CreateList<IDockable>(document);
+            dock.ActiveDockable = document;
+            document.Owner = dock;
+
+            var layer = new ManagedWindowLayer { Dock = dock };
+
+            var window = new Window { Content = layer };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            layer.ApplyTemplate();
+            layer.UpdateLayout();
+            DrainDispatcher();
+
+            window.Content = new Border();
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var layerRef = new WeakReference(layer);
+            layer = null;
+
+            return new ManagedLayerDetachLeakResult(layerRef, window, dock, dockWindow);
+        });
+
+        AssertCollected(result.LayerRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+        GC.KeepAlive(result.DockWindowKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void ManagedWindowLayer_DockSwap_DoesNotLeak_PreviousDock()
+    {
+        var result = RunInSession(() =>
+        {
+            var factory = new Dock.Model.Avalonia.Factory();
+
+            var rootA = (IRootDock)factory.CreateRootDock();
+            rootA.Factory = factory;
+            rootA.VisibleDockables = factory.CreateList<IDockable>();
+
+            var dockWindowA = new Dock.Model.Avalonia.Core.DockWindow
+            {
+                Factory = factory,
+                Layout = rootA,
+                Title = "DockA"
+            };
+
+            var managedDocA = new ManagedDockWindowDocument(dockWindowA)
+            {
+                Factory = factory
+            };
+
+            var dockA = new ManagedWindowDock
+            {
+                Factory = factory,
+                VisibleDockables = factory.CreateList<IDockable>(managedDocA),
+                ActiveDockable = managedDocA
+            };
+            managedDocA.Owner = dockA;
+
+            var rootB = (IRootDock)factory.CreateRootDock();
+            rootB.Factory = factory;
+            rootB.VisibleDockables = factory.CreateList<IDockable>();
+
+            var dockWindowB = new Dock.Model.Avalonia.Core.DockWindow
+            {
+                Factory = factory,
+                Layout = rootB,
+                Title = "DockB"
+            };
+
+            var managedDocB = new ManagedDockWindowDocument(dockWindowB)
+            {
+                Factory = factory
+            };
+
+            var dockB = new ManagedWindowDock
+            {
+                Factory = factory,
+                VisibleDockables = factory.CreateList<IDockable>(managedDocB),
+                ActiveDockable = managedDocB
+            };
+            managedDocB.Owner = dockB;
+
+            var layer = new ManagedWindowLayer { Dock = dockA };
+
+            var window = new Window { Content = layer };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            layer.ApplyTemplate();
+            layer.UpdateLayout();
+            DrainDispatcher();
+
+            var dockRef = new WeakReference(dockA);
+            var docRef = new WeakReference(managedDocA);
+
+            layer.Dock = dockB;
+            DrainDispatcher();
+
+            dockA = null;
+            managedDocA = null;
+            dockWindowA = null;
+            rootA = null;
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+            ResetDispatcherForUnitTests();
+
+            return new ManagedLayerDockSwapLeakResult(
+                dockRef,
+                docRef,
+                window,
+                layer,
+                dockB,
+                factory);
+        });
+
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.DockRef);
+            AssertCollected(result.DocumentRef);
+        }
+
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.LayerKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    private sealed record ManagedLayerDetachLeakResult(
+        WeakReference LayerRef,
+        Window WindowKeepAlive,
+        ManagedWindowDock DockKeepAlive,
+        DockWindow DockWindowKeepAlive);
+
+    private sealed record ManagedLayerDockSwapLeakResult(
+        WeakReference DockRef,
+        WeakReference DocumentRef,
+        Window WindowKeepAlive,
+        ManagedWindowLayer LayerKeepAlive,
+        ManagedWindowDock DockKeepAlive,
+        Dock.Model.Avalonia.Factory FactoryKeepAlive);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/MdiControlDetachLeakTests.cs b/tests/Dock.Avalonia.LeakTests/MdiControlDetachLeakTests.cs
new file mode 100644
index 000000000..f654c8e97
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/MdiControlDetachLeakTests.cs
@@ -0,0 +1,116 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Controls;
+using Dock.Model.Core;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class MdiControlDetachLeakTests
+{
+    [ReleaseFact]
+    public void MdiDocumentControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            var dock = context.DocumentDock;
+
+            var control = new MdiDocumentControl
+            {
+                DataContext = dock
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new MdiControlDetachLeakResult(controlRef, window, dock, context.Factory, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "MdiDocumentControl did not detach from visual tree.");
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.ControlRef);
+        }
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void MdiDocumentWindow_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            var document = context.Document;
+            document.MdiState = MdiWindowState.Normal;
+
+            var control = new MdiDocumentWindow
+            {
+                DataContext = document
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            RaisePointerPressed(control, MouseButton.Left);
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new MdiControlDetachLeakResult(controlRef, window, document, context.Factory, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "MdiDocumentWindow did not detach from visual tree.");
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.ControlRef);
+        }
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+        GC.KeepAlive(result.FactoryKeepAlive);
+    }
+
+    private sealed record MdiControlDetachLeakResult(
+        WeakReference ControlRef,
+        Window WindowKeepAlive,
+        IDockable DockKeepAlive,
+        IFactory FactoryKeepAlive,
+        bool DetachedFromVisualTree);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/ModelLayoutLeakTests.cs b/tests/Dock.Avalonia.LeakTests/ModelLayoutLeakTests.cs
new file mode 100644
index 000000000..7dea1aed9
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/ModelLayoutLeakTests.cs
@@ -0,0 +1,255 @@
+using System;
+using System.Windows.Input;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Avalonia;
+using Dock.Model.Controls;
+using Dock.Model.Core;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class ModelLayoutLeakTests
+{
+    [ReleaseFact]
+    public void AvaloniaModel_DockControl_ChromeAndContextMenus_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var factory = new Factory();
+            var layout = CreateLayout(factory);
+
+            var dockControl = new DockControl
+            {
+                Factory = factory,
+                Layout = layout
+            };
+
+            var window = new Window { Content = dockControl };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            ExerciseDockControlInteractions(dockControl);
+            ExerciseInputInteractions(dockControl, includeDoubleTap: true, includeMiddlePress: true);
+
+            var leakResult = new ModelLeakResult(
+                new WeakReference(dockControl),
+                new WeakReference(layout));
+
+            CleanupWindow(window);
+            return leakResult;
+        });
+
+        AssertCollected(result.ControlRef, result.LayoutRef);
+    }
+
+    [ReleaseFact]
+    public void MvvmLayout_WithViews_InputInteractions_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var factory = new Dock.Model.Mvvm.Factory();
+            var layout = CreateLayout(factory);
+
+            var dockControl = new DockControl
+            {
+                Factory = factory,
+                Layout = layout
+            };
+
+            var window = new Window { Content = dockControl };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            ExerciseDockControlInteractions(dockControl);
+            ExerciseInputInteractions(dockControl, includeDoubleTap: true, includeMiddlePress: true);
+
+            var leakResult = new ModelLeakResult(
+                new WeakReference(dockControl),
+                new WeakReference(layout));
+
+            CleanupWindow(window);
+            return leakResult;
+        });
+
+        AssertCollected(result.ControlRef, result.LayoutRef);
+    }
+
+    [ReleaseFact]
+    public void ReactiveUiLayout_WithViews_InputInteractions_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var factory = new Dock.Model.ReactiveUI.Factory();
+            var layout = CreateLayout(factory);
+
+            var dockControl = new DockControl
+            {
+                Factory = factory,
+                Layout = layout
+            };
+
+            var window = new Window { Content = dockControl };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            ExerciseDockControlInteractions(dockControl);
+            ExerciseInputInteractions(dockControl, includeDoubleTap: true, includeMiddlePress: true);
+
+            var leakResult = new ModelLeakResult(
+                new WeakReference(dockControl),
+                new WeakReference(layout));
+
+            CleanupWindow(window);
+            return leakResult;
+        });
+
+        AssertCollected(result.ControlRef, result.LayoutRef);
+    }
+
+    private static readonly InputInteractionMask ButtonInteractionMask =
+        InputInteractionMask.PointerEnterExit | InputInteractionMask.PointerMove | InputInteractionMask.PointerPressRelease;
+
+    private static readonly NoOpCommand NoOpCommandInstance = new();
+
+    private static void ExerciseDockControlInteractions(DockControl dockControl)
+    {
+        var documentTabStrip = FindVisualDescendant<DocumentTabStrip>(dockControl);
+        var createButton = documentTabStrip is not null
+            ? FindVisualDescendant<Button>(documentTabStrip, button => button.Name == "PART_ButtonCreate")
+            : null;
+        ApplyNoOpCommand(createButton);
+        ExerciseButtonInteractions(createButton);
+
+        var documentTabItem = FindVisualDescendant<DocumentTabStripItem>(dockControl);
+        if (documentTabItem is not null)
+        {
+            var closeButton = FindVisualDescendant<Button>(documentTabItem);
+            ApplyNoOpCommand(closeButton);
+            ExerciseButtonInteractions(closeButton);
+            OpenAndCloseContextMenu(documentTabItem, documentTabItem.DocumentContextMenu);
+        }
+
+        var toolTabItem = FindVisualDescendant<ToolTabStripItem>(dockControl);
+        if (toolTabItem is not null)
+        {
+            ExerciseInputInteractions(toolTabItem, includeDoubleTap: true, includeMiddlePress: true, interactionMask: ButtonInteractionMask);
+            OpenAndCloseContextMenu(toolTabItem, toolTabItem.TabContextMenu);
+        }
+
+        var toolChrome = FindVisualDescendant<ToolChromeControl>(dockControl);
+        if (toolChrome is not null)
+        {
+            var menuButton = FindVisualDescendant<Button>(toolChrome, button => button.Name == "PART_MenuButton");
+            var pinButton = FindVisualDescendant<Button>(toolChrome, button => button.Name == "PART_PinButton");
+            var maximizeButton = FindVisualDescendant<Button>(toolChrome, button => button.Name == "PART_MaximizeRestoreButton");
+            var closeButton = FindVisualDescendant<Button>(toolChrome, button => button.Name == "PART_CloseButton");
+
+            ApplyNoOpCommand(pinButton);
+            ApplyNoOpCommand(closeButton);
+            ExerciseButtonInteractions(menuButton);
+            ExerciseButtonInteractions(pinButton);
+            ExerciseButtonInteractions(maximizeButton);
+            ExerciseButtonInteractions(closeButton);
+
+            if (toolChrome.ToolFlyout is not null)
+            {
+                var flyoutTarget = (Control?)menuButton ?? toolChrome;
+                OpenAndCloseFlyout(flyoutTarget, toolChrome.ToolFlyout);
+            }
+        }
+
+        var toolPinItem = FindVisualDescendant<ToolPinItemControl>(dockControl);
+        if (toolPinItem is not null)
+        {
+            OpenAndCloseContextMenu(toolPinItem, toolPinItem.PinContextMenu);
+            var pinButton = FindVisualDescendant<Button>(toolPinItem);
+            ApplyNoOpCommand(pinButton);
+            ExerciseButtonInteractions(pinButton);
+        }
+    }
+
+    private static void ApplyNoOpCommand(Button? button)
+    {
+        if (button is null)
+        {
+            return;
+        }
+
+        button.SetCurrentValue(Button.CommandProperty, NoOpCommandInstance);
+    }
+
+    private static void ExerciseButtonInteractions(Button? button)
+    {
+        if (button is null)
+        {
+            return;
+        }
+
+        ExerciseInputInteractions(button, interactionMask: ButtonInteractionMask);
+    }
+
+    private static IRootDock CreateLayout(IFactory factory)
+    {
+        var root = (IRootDock)factory.CreateRootDock();
+        root.Factory = factory;
+        root.VisibleDockables = factory.CreateList<IDockable>();
+        root.HiddenDockables ??= factory.CreateList<IDockable>();
+        root.LeftPinnedDockables ??= factory.CreateList<IDockable>();
+        root.RightPinnedDockables ??= factory.CreateList<IDockable>();
+        root.TopPinnedDockables ??= factory.CreateList<IDockable>();
+        root.BottomPinnedDockables ??= factory.CreateList<IDockable>();
+        root.Windows ??= factory.CreateList<IDockWindow>();
+
+        var tool = factory.CreateTool();
+        tool.Factory = factory;
+
+        var document = factory.CreateDocument();
+        document.Factory = factory;
+
+        var toolDock = factory.CreateToolDock();
+        toolDock.Factory = factory;
+        toolDock.VisibleDockables = factory.CreateList<IDockable>(tool);
+        toolDock.ActiveDockable = tool;
+        tool.Owner = toolDock;
+
+        var documentDock = factory.CreateDocumentDock();
+        documentDock.Factory = factory;
+        documentDock.VisibleDockables = factory.CreateList<IDockable>(document);
+        documentDock.ActiveDockable = document;
+        documentDock.CanCreateDocument = true;
+        documentDock.CloseButtonShowMode = DocumentCloseButtonShowMode.Always;
+        documentDock.CreateDocument = NoOpCommandInstance;
+        document.Owner = documentDock;
+
+        root.VisibleDockables.Add(toolDock);
+        root.VisibleDockables.Add(documentDock);
+        root.ActiveDockable = documentDock;
+        root.DefaultDockable = documentDock;
+        root.PinnedDock = toolDock;
+        root.LeftPinnedDockables?.Add(tool);
+
+        return root;
+    }
+
+    private sealed record ModelLeakResult(WeakReference ControlRef, WeakReference LayoutRef);
+
+    private sealed class NoOpCommand : ICommand
+    {
+        public event EventHandler? CanExecuteChanged;
+
+        public bool CanExecute(object? parameter) => true;
+
+        public void Execute(object? parameter)
+        {
+        }
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/OverlayHostLeakTests.cs b/tests/Dock.Avalonia.LeakTests/OverlayHostLeakTests.cs
new file mode 100644
index 000000000..a0c313b2a
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/OverlayHostLeakTests.cs
@@ -0,0 +1,123 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls.Overlays;
+using Dock.Avalonia.Themes.Fluent;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class OverlayHostLeakTests
+{
+    [ReleaseFact]
+    public void OverlayHost_OverlayLayers_DoesNotLeak_WhenLayersAlive()
+    {
+        var result = RunInSession(() =>
+        {
+            var layer = new OverlayLayer { Overlay = null };
+            var layers = new OverlayLayerCollection { layer };
+
+            var host = new OverlayHost
+            {
+                Content = new Border(),
+                OverlayLayers = layers,
+                UseServiceLayers = false
+            };
+
+            var window = new Window { Content = host };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+
+            layer.IsVisible = false;
+            layer.IsVisible = true;
+            layers.Add(new OverlayLayer { Overlay = null, ZIndex = 1 });
+            DrainDispatcher();
+
+            var result = new OverlayHostLayerLeakResult(
+                new WeakReference(host),
+                layers,
+                layer);
+
+            CleanupWindow(window);
+            return result;
+        });
+
+        AssertCollected(result.HostRef);
+        GC.KeepAlive(result.LayersKeepAlive);
+        GC.KeepAlive(result.LayerKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void OverlayHost_ServiceLayers_DoesNotLeak_WhenProviderAlive()
+    {
+        var result = RunInSession(() =>
+        {
+            var previousProvider = OverlayLayerRegistry.Provider;
+            var previousFactoryProvider = OverlayLayerRegistry.FactoryProvider;
+
+            var layers = new OverlayLayerCollection
+            {
+                new OverlayLayer { Overlay = null, ZIndex = 1 }
+            };
+
+            Func<IEnumerable<IOverlayLayer>> provider = () => layers;
+
+            try
+            {
+                var host = new OverlayHost
+                {
+                    Content = new Border(),
+                    UseServiceLayers = true
+                };
+
+                var window = new Window { Content = host };
+                window.Styles.Add(new FluentTheme());
+                window.Styles.Add(new DockFluentTheme());
+
+                ShowWindow(window);
+
+                OverlayLayerRegistry.Provider = provider;
+                OverlayLayerRegistry.FactoryProvider = null;
+                DrainDispatcher();
+
+                OverlayLayerRegistry.Provider = null;
+                OverlayLayerRegistry.Provider = provider;
+                DrainDispatcher();
+
+                var result = new OverlayHostServiceLeakResult(
+                    new WeakReference(host),
+                    layers,
+                    provider);
+
+                CleanupWindow(window);
+                return result;
+            }
+            finally
+            {
+                OverlayLayerRegistry.Provider = previousProvider;
+                OverlayLayerRegistry.FactoryProvider = previousFactoryProvider;
+            }
+        });
+
+        AssertCollected(result.HostRef);
+        GC.KeepAlive(result.LayersKeepAlive);
+        GC.KeepAlive(result.ProviderKeepAlive);
+    }
+
+
+    private sealed record OverlayHostLayerLeakResult(
+        WeakReference HostRef,
+        OverlayLayerCollection LayersKeepAlive,
+        OverlayLayer LayerKeepAlive);
+
+    private sealed record OverlayHostServiceLeakResult(
+        WeakReference HostRef,
+        OverlayLayerCollection LayersKeepAlive,
+        Func<IEnumerable<IOverlayLayer>> ProviderKeepAlive);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/OverlayLayerRegistryLeakTests.cs b/tests/Dock.Avalonia.LeakTests/OverlayLayerRegistryLeakTests.cs
new file mode 100644
index 000000000..99618d022
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/OverlayLayerRegistryLeakTests.cs
@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using Dock.Avalonia.Controls.Overlays;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class OverlayLayerRegistryLeakTests
+{
+    [ReleaseFact]
+    public void OverlayLayerRegistry_ProvidersAndHandlers_DoNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var listener = new ProviderListener();
+
+            EventHandler handler = (_, _) => listener.Touch();
+            Func<IEnumerable<IOverlayLayer>> provider = () =>
+            {
+                listener.Touch();
+                return Array.Empty<IOverlayLayer>();
+            };
+            Func<IEnumerable<IOverlayLayerFactory>> factoryProvider = () => Array.Empty<IOverlayLayerFactory>();
+
+            OverlayLayerRegistry.ProviderChanged += handler;
+            OverlayLayerRegistry.Provider = provider;
+            OverlayLayerRegistry.FactoryProvider = factoryProvider;
+
+            OverlayLayerRegistry.ProviderChanged -= handler;
+            OverlayLayerRegistry.Provider = null;
+            OverlayLayerRegistry.FactoryProvider = null;
+
+            var weak = new WeakReference(listener);
+            listener = null;
+            handler = null!;
+            provider = null!;
+            factoryProvider = null!;
+
+            return weak;
+        });
+
+        AssertCollected(result);
+    }
+
+    private sealed class ProviderListener
+    {
+        public void Touch()
+        {
+        }
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/OverlayServiceLeakTests.cs b/tests/Dock.Avalonia.LeakTests/OverlayServiceLeakTests.cs
new file mode 100644
index 000000000..cc4e85cce
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/OverlayServiceLeakTests.cs
@@ -0,0 +1,160 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls.Overlays;
+using Dock.Avalonia.Themes.Fluent;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class OverlayServiceLeakTests
+{
+    [ReleaseFact]
+    public void BusyOverlayControl_DetachWhileWindowAlive_DoesNotLeak_WhenServicesAlive()
+    {
+        var result = RunInSession(() =>
+        {
+            var busy = new StubBusyService();
+            var global = new StubGlobalBusyService();
+
+            var control = new BusyOverlayControl
+            {
+                BusyService = busy,
+                GlobalBusyService = global
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            busy.Begin("Working");
+            global.Begin("Global");
+            DrainDispatcher();
+            control.BusyService = null;
+            control.GlobalBusyService = null;
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            window.UpdateLayout();
+            DrainDispatcher();
+            ClearInputState(window);
+            ResetDispatcherForUnitTests();
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new OverlayServiceLeakResult(controlRef, window, busy, global, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "BusyOverlayControl did not detach from visual tree.");
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.ControlRef);
+        }
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.ServiceKeepAlive);
+        GC.KeepAlive(result.GlobalServiceKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void DialogOverlayControl_DetachWhileWindowAlive_DoesNotLeak_WhenServicesAlive()
+    {
+        var result = RunInSession(() =>
+        {
+            var dialog = new StubDialogService();
+            var global = new StubGlobalDialogService();
+
+            var control = new DialogOverlayControl
+            {
+                DialogService = dialog,
+                GlobalDialogService = global
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            global.Begin("Dialog");
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            window.UpdateLayout();
+            DrainDispatcher();
+            ClearInputState(window);
+            ResetDispatcherForUnitTests();
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new OverlayServiceLeakResult(controlRef, window, dialog, global, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "DialogOverlayControl did not detach from visual tree.");
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.ServiceKeepAlive);
+        GC.KeepAlive(result.GlobalServiceKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void ConfirmationOverlayControl_DetachWhileWindowAlive_DoesNotLeak_WhenServicesAlive()
+    {
+        var result = RunInSession(() =>
+        {
+            var confirmation = new StubConfirmationService();
+            var global = new StubGlobalConfirmationService();
+
+            var control = new ConfirmationOverlayControl
+            {
+                ConfirmationService = confirmation,
+                GlobalConfirmationService = global
+            };
+            var detached = false;
+            control.DetachedFromVisualTree += (_, _) => detached = true;
+
+            var window = new Window { Content = control };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            global.Begin("Confirm");
+            DrainDispatcher();
+
+            window.Content = null;
+            DrainDispatcher();
+            window.UpdateLayout();
+            DrainDispatcher();
+            ClearInputState(window);
+            ResetDispatcherForUnitTests();
+
+            var controlRef = new WeakReference(control);
+            control = null;
+
+            return new OverlayServiceLeakResult(controlRef, window, confirmation, global, detached);
+        });
+
+        Assert.True(result.DetachedFromVisualTree, "ConfirmationOverlayControl did not detach from visual tree.");
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.ServiceKeepAlive);
+        GC.KeepAlive(result.GlobalServiceKeepAlive);
+    }
+
+    private sealed record OverlayServiceLeakResult(
+        WeakReference ControlRef,
+        Window WindowKeepAlive,
+        object ServiceKeepAlive,
+        object GlobalServiceKeepAlive,
+        bool DetachedFromVisualTree);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/PinnedDockSplitterLeakTests.cs b/tests/Dock.Avalonia.LeakTests/PinnedDockSplitterLeakTests.cs
new file mode 100644
index 000000000..c43feae71
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/PinnedDockSplitterLeakTests.cs
@@ -0,0 +1,119 @@
+using System;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Input;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Core;
+using Dock.Settings;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestCaseHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class PinnedDockSplitterLeakTests
+{
+    [ReleaseFact]
+    public void PinnedDockControl_SplitterDrag_DoesNotLeak()
+    {
+        var previousPinned = DockSettings.UsePinnedDockWindow;
+        DockSettings.UsePinnedDockWindow = false;
+
+        try
+        {
+            var result = RunInSession(() =>
+            {
+                var context = LeakContext.Create();
+                context.Root.PinnedDockDisplayMode = PinnedDockDisplayMode.Inline;
+                context.Factory.InitLayout(context.Root);
+
+                var rootControl = new RootDockControl { DataContext = context.Root };
+                var window = new Window { Content = rootControl };
+                window.Styles.Add(new FluentTheme());
+                window.Styles.Add(new DockFluentTheme());
+
+                ShowWindow(window);
+                rootControl.ApplyTemplate();
+                rootControl.UpdateLayout();
+                DrainDispatcher();
+
+                var pinnedDockControl = FindVisualDescendant<PinnedDockControl>(rootControl);
+                Assert.NotNull(pinnedDockControl);
+
+                pinnedDockControl!.ApplyTemplate();
+                pinnedDockControl.UpdateLayout();
+                DrainDispatcher();
+
+                var splitter = FindTemplateChild<GridSplitter>(pinnedDockControl, "PART_PinnedDockSplitter");
+                Assert.NotNull(splitter);
+
+                var detached = false;
+                pinnedDockControl.DetachedFromVisualTree += (_, _) => detached = true;
+
+                if (splitter is not null)
+                {
+                    splitter.RaiseEvent(new VectorEventArgs
+                    {
+                        RoutedEvent = Thumb.DragStartedEvent,
+                        Vector = new Vector(4, 0)
+                    });
+                    splitter.RaiseEvent(new VectorEventArgs
+                    {
+                        RoutedEvent = Thumb.DragDeltaEvent,
+                        Vector = new Vector(4, 0)
+                    });
+                    splitter.RaiseEvent(new VectorEventArgs
+                    {
+                        RoutedEvent = Thumb.DragCompletedEvent,
+                        Vector = new Vector(4, 0)
+                    });
+                }
+
+                DrainDispatcher();
+
+                window.Content = null;
+                DrainDispatcher();
+                ClearPinnedDockControlState(pinnedDockControl);
+                ClearFactoryCaches(context.Factory);
+                ClearInputState(window);
+                ResetDispatcherForUnitTests();
+
+                var controlRef = new WeakReference(pinnedDockControl);
+                pinnedDockControl = null;
+                rootControl = null;
+
+                return new PinnedDockSplitterLeakResult(
+                    controlRef,
+                    window,
+                    context.Root,
+                    context.Factory,
+                    detached);
+            });
+
+            Assert.True(result.DetachedFromVisualTree, "PinnedDockControl did not detach from visual tree.");
+            if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+            {
+                AssertCollected(result.ControlRef);
+            }
+            GC.KeepAlive(result.WindowKeepAlive);
+            GC.KeepAlive(result.RootKeepAlive);
+            GC.KeepAlive(result.FactoryKeepAlive);
+        }
+        finally
+        {
+            DockSettings.UsePinnedDockWindow = previousPinned;
+        }
+    }
+
+    private sealed record PinnedDockSplitterLeakResult(
+        WeakReference ControlRef,
+        Window WindowKeepAlive,
+        IDock RootKeepAlive,
+        IFactory FactoryKeepAlive,
+        bool DetachedFromVisualTree);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/ReleaseFact.cs b/tests/Dock.Avalonia.LeakTests/ReleaseFact.cs
new file mode 100644
index 000000000..c163e3219
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/ReleaseFact.cs
@@ -0,0 +1,18 @@
+using System;
+using Xunit;
+
+namespace Dock.Avalonia.LeakTests;
+
+/// <summary>
+/// Release-only fact for leak tests that are skipped in Debug builds.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+internal sealed class ReleaseFactAttribute : FactAttribute
+{
+    public ReleaseFactAttribute()
+    {
+#if DEBUG
+        Skip = "Only runs in Release mode";
+#endif
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/TabStripItemActionLeakTests.cs b/tests/Dock.Avalonia.LeakTests/TabStripItemActionLeakTests.cs
new file mode 100644
index 000000000..07fdcb1f3
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/TabStripItemActionLeakTests.cs
@@ -0,0 +1,538 @@
+using System;
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Controls;
+using Dock.Model.Core;
+using Dock.Settings;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class TabStripItemActionLeakTests
+{
+    [ReleaseFact]
+    public void DocumentTabStripItem_DoubleTap_Floats_DoesNotLeak()
+    {
+        var previousMode = DockSettings.FloatingWindowHostMode;
+        DockSettings.FloatingWindowHostMode = DockFloatingWindowHostMode.Native;
+
+        try
+        {
+            var result = RunInSession(() =>
+            {
+                var context = LeakContext.Create();
+                context.Root.ActiveDockable = context.DocumentDock;
+                context.Root.DefaultDockable = context.DocumentDock;
+                context.Root.Windows ??= context.Factory.CreateList<IDockWindow>();
+                context.Document.CanFloat = true;
+
+                var extra = context.Factory.CreateDocument();
+                extra.Factory = context.Factory;
+                extra.Owner = context.DocumentDock;
+                context.DocumentDock.VisibleDockables?.Add(extra);
+
+                var dockControl = new DockControl
+                {
+                    Factory = context.Factory,
+                    Layout = context.Root,
+                    InitializeFactory = true,
+                    InitializeLayout = true
+                };
+
+                var window = new Window { Content = dockControl };
+                window.Styles.Add(new FluentTheme());
+                window.Styles.Add(new DockFluentTheme());
+
+                ShowWindow(window);
+                var tabItem = GetDocumentTabItem(dockControl, context.Document);
+
+                RaiseDoubleTapped(tabItem);
+                DrainDispatcher();
+
+                var dockWindow = context.Root.Windows?.FirstOrDefault();
+                var dockWindowRef = dockWindow is null ? null : new WeakReference(dockWindow);
+                var hostRef = dockWindow?.Host is null ? null : new WeakReference(dockWindow.Host);
+                var hostWindow = dockWindow?.Host as Window;
+                var hostWindowRef = hostWindow is null ? null : new WeakReference(hostWindow);
+                var tabItemRef = new WeakReference(tabItem);
+
+                if (dockWindow is not null)
+                {
+                    context.Factory.RemoveWindow(dockWindow);
+                    DrainDispatcher();
+                }
+
+                if (hostWindow is not null)
+                {
+                    CleanupWindow(hostWindow);
+                }
+
+                dockControl.Layout = null;
+                dockControl.Factory = null;
+                CleanupWindow(window);
+                ClearFactoryCaches(context.Factory);
+                ResetDispatcherForUnitTests();
+                ScrubStaticReferences(tabItem);
+                tabItem = null;
+                dockControl = null;
+
+                return new TabStripFloatLeakResult(
+                    tabItemRef,
+                    dockWindowRef,
+                    hostRef,
+                    hostWindowRef,
+                    context.Factory,
+                    context.Root);
+            });
+
+            if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+            {
+                AssertCollected(result.TabItemRef);
+            }
+
+            if (result.DockWindowRef is not null)
+            {
+                AssertCollected(result.DockWindowRef);
+            }
+
+            if (result.HostRef is not null)
+            {
+                AssertCollected(result.HostRef);
+            }
+
+            if (result.HostWindowRef is not null)
+            {
+                AssertCollected(result.HostWindowRef);
+            }
+
+            GC.KeepAlive(result.FactoryKeepAlive);
+            GC.KeepAlive(result.RootKeepAlive);
+        }
+        finally
+        {
+            DockSettings.FloatingWindowHostMode = previousMode;
+        }
+    }
+
+    [ReleaseFact]
+    public void ToolTabStripItem_DoubleTap_Floats_DoesNotLeak()
+    {
+        var previousMode = DockSettings.FloatingWindowHostMode;
+        DockSettings.FloatingWindowHostMode = DockFloatingWindowHostMode.Native;
+
+        try
+        {
+            var result = RunInSession(() =>
+            {
+                var context = LeakContext.Create();
+                context.Root.ActiveDockable = context.ToolDock;
+                context.Root.DefaultDockable = context.ToolDock;
+                context.Root.Windows ??= context.Factory.CreateList<IDockWindow>();
+                context.Tool.CanFloat = true;
+
+                var extra = context.Factory.CreateTool();
+                extra.Factory = context.Factory;
+                extra.Owner = context.ToolDock;
+                context.ToolDock.VisibleDockables?.Add(extra);
+
+                var dockControl = new DockControl
+                {
+                    Factory = context.Factory,
+                    Layout = context.Root,
+                    InitializeFactory = true,
+                    InitializeLayout = true
+                };
+
+                var window = new Window { Content = dockControl };
+                window.Styles.Add(new FluentTheme());
+                window.Styles.Add(new DockFluentTheme());
+
+                ShowWindow(window);
+                var tabItem = GetToolTabItem(dockControl, context.Tool);
+
+                RaiseDoubleTapped(tabItem);
+                DrainDispatcher();
+
+                var dockWindow = context.Root.Windows?.FirstOrDefault();
+                var dockWindowRef = dockWindow is null ? null : new WeakReference(dockWindow);
+                var hostRef = dockWindow?.Host is null ? null : new WeakReference(dockWindow.Host);
+                var hostWindow = dockWindow?.Host as Window;
+                var hostWindowRef = hostWindow is null ? null : new WeakReference(hostWindow);
+                var tabItemRef = new WeakReference(tabItem);
+
+                if (dockWindow is not null)
+                {
+                    context.Factory.RemoveWindow(dockWindow);
+                    DrainDispatcher();
+                }
+
+                if (hostWindow is not null)
+                {
+                    CleanupWindow(hostWindow);
+                }
+
+                dockControl.Layout = null;
+                dockControl.Factory = null;
+                CleanupWindow(window);
+                ClearFactoryCaches(context.Factory);
+                ResetDispatcherForUnitTests();
+                tabItem = null;
+                dockControl = null;
+
+                return new TabStripFloatLeakResult(
+                    tabItemRef,
+                    dockWindowRef,
+                    hostRef,
+                    hostWindowRef,
+                    context.Factory,
+                    context.Root);
+            });
+
+            if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+            {
+                AssertCollected(result.TabItemRef);
+            }
+
+            if (result.DockWindowRef is not null)
+            {
+                AssertCollected(result.DockWindowRef);
+            }
+
+            if (result.HostRef is not null)
+            {
+                AssertCollected(result.HostRef);
+            }
+
+            if (result.HostWindowRef is not null)
+            {
+                AssertCollected(result.HostWindowRef);
+            }
+
+            GC.KeepAlive(result.FactoryKeepAlive);
+            GC.KeepAlive(result.RootKeepAlive);
+        }
+        finally
+        {
+            DockSettings.FloatingWindowHostMode = previousMode;
+        }
+    }
+
+    [ReleaseFact]
+    public void DocumentTabStripItem_MiddleClick_Closes_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            context.Root.ActiveDockable = context.DocumentDock;
+            context.Root.DefaultDockable = context.DocumentDock;
+            context.Document.CanClose = true;
+
+            var extra = context.Factory.CreateDocument();
+            extra.Factory = context.Factory;
+            extra.Owner = context.DocumentDock;
+            context.DocumentDock.VisibleDockables?.Add(extra);
+
+            var dockControl = new DockControl
+            {
+                Factory = context.Factory,
+                Layout = context.Root,
+                InitializeFactory = true,
+                InitializeLayout = true
+            };
+
+            var window = new Window { Content = dockControl };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            var tabItem = GetDocumentTabItem(dockControl, context.Document);
+
+            MiddleClick(tabItem);
+            DrainDispatcher();
+
+            var closed = context.DocumentDock.VisibleDockables?.Contains(context.Document) == false;
+            var tabItemRef = new WeakReference(tabItem);
+            var closedDocRef = new WeakReference(context.Document);
+
+            CleanupWindow(window);
+            ClearFactoryCaches(context.Factory);
+            ResetDispatcherForUnitTests();
+            tabItem = null;
+            dockControl = null;
+
+            return new TabStripCloseLeakResult(
+                tabItemRef,
+                closedDocRef,
+                closed,
+                context.Factory,
+                context.Root);
+        });
+
+        Assert.True(result.Closed, "DocumentTabStripItem middle click did not close the dockable.");
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.TabItemRef);
+            AssertCollected(result.ClosedDockableRef);
+        }
+        GC.KeepAlive(result.FactoryKeepAlive);
+        GC.KeepAlive(result.RootKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void ToolTabStripItem_MiddleClick_Closes_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            context.Root.ActiveDockable = context.ToolDock;
+            context.Root.DefaultDockable = context.ToolDock;
+            context.Tool.CanClose = true;
+
+            var extra = context.Factory.CreateTool();
+            extra.Factory = context.Factory;
+            extra.Owner = context.ToolDock;
+            context.ToolDock.VisibleDockables?.Add(extra);
+
+            var dockControl = new DockControl
+            {
+                Factory = context.Factory,
+                Layout = context.Root,
+                InitializeFactory = true,
+                InitializeLayout = true
+            };
+
+            var window = new Window { Content = dockControl };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            var tabItem = GetToolTabItem(dockControl, context.Tool);
+
+            MiddleClick(tabItem);
+            DrainDispatcher();
+
+            var closed = context.ToolDock.VisibleDockables?.Contains(context.Tool) == false;
+            var tabItemRef = new WeakReference(tabItem);
+            var closedToolRef = new WeakReference(context.Tool);
+
+            CleanupWindow(window);
+            ClearFactoryCaches(context.Factory);
+            ResetDispatcherForUnitTests();
+            tabItem = null;
+            dockControl = null;
+
+            return new TabStripCloseLeakResult(
+                tabItemRef,
+                closedToolRef,
+                closed,
+                context.Factory,
+                context.Root);
+        });
+
+        Assert.True(result.Closed, "ToolTabStripItem middle click did not close the dockable.");
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.TabItemRef);
+            AssertCollected(result.ClosedDockableRef);
+        }
+        GC.KeepAlive(result.FactoryKeepAlive);
+        GC.KeepAlive(result.RootKeepAlive);
+    }
+
+    private sealed record TabStripFloatLeakResult(
+        WeakReference TabItemRef,
+        WeakReference? DockWindowRef,
+        WeakReference? HostRef,
+        WeakReference? HostWindowRef,
+        Dock.Model.Core.IFactory FactoryKeepAlive,
+        Dock.Model.Controls.IRootDock RootKeepAlive);
+
+    private sealed record TabStripCloseLeakResult(
+        WeakReference TabItemRef,
+        WeakReference ClosedDockableRef,
+        bool Closed,
+        Dock.Model.Core.IFactory FactoryKeepAlive,
+        Dock.Model.Controls.IRootDock RootKeepAlive);
+
+    private static DocumentTabStripItem GetDocumentTabItem(DockControl dockControl, IDockable target)
+    {
+        dockControl.ApplyTemplate();
+        dockControl.UpdateLayout();
+        DrainDispatcher();
+
+        var documentDockControl = FindVisualDescendant<DocumentDockControl>(dockControl);
+        if (documentDockControl is not null)
+        {
+            documentDockControl.ApplyTemplate();
+            documentDockControl.UpdateLayout();
+            DrainDispatcher();
+        }
+
+        var documentControl = FindVisualDescendant<DocumentControl>(dockControl);
+        if (documentControl is not null)
+        {
+            documentControl.ApplyTemplate();
+            documentControl.UpdateLayout();
+            DrainDispatcher();
+        }
+
+        var tabStrip = FindVisualDescendant<DocumentTabStrip>(dockControl)
+                       ?? throw new InvalidOperationException("DocumentTabStrip was not generated.");
+
+        tabStrip.ApplyTemplate();
+        tabStrip.UpdateLayout();
+        DrainDispatcher();
+
+        var tabItem = FindVisualDescendant<DocumentTabStripItem>(tabStrip, item => ReferenceEquals(item.DataContext, target))
+                      ?? FindVisualDescendant<DocumentTabStripItem>(dockControl, item => ReferenceEquals(item.DataContext, target));
+
+        if (tabItem is null)
+        {
+            var index = GetItemIndex(tabStrip, target);
+            if (index >= 0)
+            {
+                tabItem = tabStrip.ContainerFromIndex(index) as DocumentTabStripItem;
+            }
+        }
+
+        tabItem ??= tabStrip.ContainerFromIndex(0) as DocumentTabStripItem
+                   ?? FindVisualDescendant<DocumentTabStripItem>(dockControl);
+
+        if (tabItem is null)
+        {
+            throw new InvalidOperationException("DocumentTabStripItem was not generated.");
+        }
+
+        tabItem.ApplyTemplate();
+        tabItem.UpdateLayout();
+        DrainDispatcher();
+        return tabItem;
+    }
+
+    private static ToolTabStripItem GetToolTabItem(DockControl dockControl, IDockable target)
+    {
+        dockControl.ApplyTemplate();
+        dockControl.UpdateLayout();
+        DrainDispatcher();
+
+        var toolDockControl = FindVisualDescendant<ToolDockControl>(dockControl);
+        if (toolDockControl is not null)
+        {
+            toolDockControl.ApplyTemplate();
+            toolDockControl.UpdateLayout();
+            DrainDispatcher();
+        }
+
+        var toolControl = FindVisualDescendant<ToolControl>(dockControl);
+        if (toolControl is not null)
+        {
+            toolControl.ApplyTemplate();
+            toolControl.UpdateLayout();
+            DrainDispatcher();
+        }
+
+        var tabStrip = FindVisualDescendant<ToolTabStrip>(dockControl)
+                       ?? throw new InvalidOperationException("ToolTabStrip was not generated.");
+
+        tabStrip.ApplyTemplate();
+        tabStrip.UpdateLayout();
+        DrainDispatcher();
+
+        var tabItem = FindVisualDescendant<ToolTabStripItem>(tabStrip, item => ReferenceEquals(item.DataContext, target))
+                      ?? FindVisualDescendant<ToolTabStripItem>(dockControl, item => ReferenceEquals(item.DataContext, target));
+
+        if (tabItem is null)
+        {
+            var index = GetItemIndex(tabStrip, target);
+            if (index >= 0)
+            {
+                tabItem = tabStrip.ContainerFromIndex(index) as ToolTabStripItem;
+            }
+        }
+
+        tabItem ??= tabStrip.ContainerFromIndex(0) as ToolTabStripItem
+                   ?? FindVisualDescendant<ToolTabStripItem>(dockControl);
+
+        if (tabItem is null)
+        {
+            throw new InvalidOperationException("ToolTabStripItem was not generated.");
+        }
+
+        tabItem.ApplyTemplate();
+        tabItem.UpdateLayout();
+        DrainDispatcher();
+        return tabItem;
+    }
+
+    private static int GetItemIndex(ItemsControl itemsControl, IDockable target)
+    {
+        if (itemsControl.Items is System.Collections.IList list)
+        {
+            for (var i = 0; i < list.Count; i++)
+            {
+                if (ReferenceEquals(list[i], target))
+                {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
+        var index = 0;
+        foreach (var item in itemsControl.Items)
+        {
+            if (ReferenceEquals(item, target))
+            {
+                return index;
+            }
+
+            index++;
+        }
+
+        return -1;
+    }
+
+    private static void MiddleClick(Control control)
+    {
+        var bounds = control.Bounds;
+        var width = double.IsFinite(bounds.Width) && bounds.Width > 1 ? bounds.Width / 2 : 1;
+        var height = double.IsFinite(bounds.Height) && bounds.Height > 1 ? bounds.Height / 2 : 1;
+        var point = new Point(width, height);
+        var root = (Visual?)TopLevel.GetTopLevel(control) ?? control;
+        var pointer = new Pointer(1, PointerType.Mouse, true);
+
+        var pressedProperties = new PointerPointProperties(RawInputModifiers.MiddleMouseButton, PointerUpdateKind.MiddleButtonPressed);
+        var pressedArgs = new PointerPressedEventArgs(
+            control,
+            pointer,
+            root,
+            point,
+            1,
+            pressedProperties,
+            KeyModifiers.None,
+            1);
+        control.RaiseEvent(pressedArgs);
+
+        var releasedProperties = new PointerPointProperties(RawInputModifiers.None, PointerUpdateKind.MiddleButtonReleased);
+        var releasedArgs = new PointerReleasedEventArgs(
+            control,
+            pointer,
+            root,
+            point,
+            1,
+            releasedProperties,
+            KeyModifiers.None,
+            MouseButton.Middle);
+        control.RaiseEvent(releasedArgs);
+    }
+}
diff --git a/tests/Dock.Avalonia.LeakTests/ThemeCommandInteractionLeakTests.cs b/tests/Dock.Avalonia.LeakTests/ThemeCommandInteractionLeakTests.cs
new file mode 100644
index 000000000..a3a895305
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/ThemeCommandInteractionLeakTests.cs
@@ -0,0 +1,540 @@
+using System;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Avalonia.Themes.Simple;
+using Dock.Model.Core;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestCaseHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class ThemeCommandInteractionLeakTests
+{
+    [ReleaseFact]
+    public void DockCommandBarHost_FluentTheme_ButtonAndMenuClicks_DoNotLeak() =>
+        RunDockCommandBarHostTest(DockThemeKind.Fluent);
+
+    [ReleaseFact]
+    public void DockCommandBarHost_SimpleTheme_ButtonAndMenuClicks_DoNotLeak() =>
+        RunDockCommandBarHostTest(DockThemeKind.Simple);
+
+    [ReleaseFact]
+    public void DocumentControl_FluentTheme_ButtonAndMenuClicks_DoNotLeak() =>
+        RunDocumentControlTest(DockThemeKind.Fluent);
+
+    [ReleaseFact]
+    public void DocumentControl_SimpleTheme_ButtonAndMenuClicks_DoNotLeak() =>
+        RunDocumentControlTest(DockThemeKind.Simple);
+
+    [ReleaseFact]
+    public void ToolTabStrip_FluentTheme_MenuItemClicks_DoNotLeak() =>
+        RunToolTabStripTest(DockThemeKind.Fluent);
+
+    [ReleaseFact]
+    public void ToolTabStrip_SimpleTheme_MenuItemClicks_DoNotLeak() =>
+        RunToolTabStripTest(DockThemeKind.Simple);
+
+    [ReleaseFact]
+    public void ToolChromeControl_FluentTheme_ButtonClicks_DoNotLeak() =>
+        RunToolChromeControlTest(DockThemeKind.Fluent);
+
+    [ReleaseFact]
+    public void ToolChromeControl_SimpleTheme_ButtonClicks_DoNotLeak() =>
+        RunToolChromeControlTest(DockThemeKind.Simple);
+
+    [ReleaseFact]
+    public void ToolPinnedControl_FluentTheme_MenuItemClicks_DoNotLeak() =>
+        RunToolPinnedControlTest(DockThemeKind.Fluent);
+
+    [ReleaseFact]
+    public void ToolPinnedControl_SimpleTheme_MenuItemClicks_DoNotLeak() =>
+        RunToolPinnedControlTest(DockThemeKind.Simple);
+
+    [ReleaseFact]
+    public void ToolPinItemControl_FluentTheme_ButtonClick_DoNotLeak() =>
+        RunToolPinItemControlButtonTest(DockThemeKind.Fluent);
+
+    [ReleaseFact]
+    public void ToolPinItemControl_SimpleTheme_ButtonClick_DoNotLeak() =>
+        RunToolPinItemControlButtonTest(DockThemeKind.Simple);
+
+    private static void RunDockCommandBarHostTest(DockThemeKind theme)
+    {
+        var result = RunInSession(() =>
+        {
+            var command = new NoOpCommand();
+            var openItem = new MenuItem { Header = "Open", Command = command };
+            var exitItem = new MenuItem { Header = "Exit", Command = command };
+            var rootItem = new MenuItem
+            {
+                Header = "File",
+                ItemsSource = new object[]
+                {
+                    openItem,
+                    new Separator(),
+                    exitItem
+                }
+            };
+
+            var menu = new Menu
+            {
+                ItemsSource = new object[] { rootItem }
+            };
+
+            var toolButton = new Button { Content = "Tool", Command = command };
+            var toolBar = new StackPanel { Orientation = global::Avalonia.Layout.Orientation.Horizontal };
+            toolBar.Children.Add(toolButton);
+
+            var ribbonButton = new Button { Content = "Ribbon", Command = command };
+            var ribbonBar = new StackPanel { Orientation = global::Avalonia.Layout.Orientation.Horizontal };
+            ribbonBar.Children.Add(ribbonButton);
+
+            var host = new DockCommandBarHost
+            {
+                MenuBars = new Control[] { menu },
+                ToolBars = new Control[] { toolBar },
+                RibbonBars = new Control[] { ribbonBar },
+                IsVisible = true
+            };
+
+            var window = CreateThemedWindow(host, theme);
+            ShowWindow(window);
+
+            InvokeMenuItemClick(openItem);
+            InvokeMenuItemClick(exitItem);
+            InvokeButtonClick(toolButton);
+            InvokeButtonClick(ribbonButton);
+            DrainDispatcher();
+
+            var result = new CommandBarLeakResult(
+                new WeakReference(host),
+                new WeakReference(openItem),
+                new WeakReference(exitItem),
+                command);
+
+            CleanupWindow(window);
+            ResetDispatcherForUnitTests();
+
+            host = null;
+            menu = null;
+            toolBar = null;
+            ribbonBar = null;
+            rootItem = null;
+            openItem = null;
+            exitItem = null;
+            toolButton = null;
+            ribbonButton = null;
+
+            return result;
+        });
+
+        AssertCollected(result.HostRef);
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.OpenItemRef, result.ExitItemRef);
+        }
+        GC.KeepAlive(result.CommandKeepAlive);
+    }
+
+    private static void RunDocumentControlTest(DockThemeKind theme)
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            context.Root.ActiveDockable = context.DocumentDock;
+            context.Root.DefaultDockable = context.DocumentDock;
+            context.Document.CanClose = true;
+            context.DocumentDock.CanCloseLastDockable = true;
+            context.DocumentDock.CanCreateDocument = true;
+            context.DocumentDock.CreateDocument = new NoOpCommand();
+
+            var documentControl = new DocumentControl
+            {
+                DataContext = context.DocumentDock
+            };
+
+            var window = CreateThemedWindow(documentControl, theme);
+            ShowWindow(window);
+
+            documentControl.ApplyTemplate();
+            documentControl.UpdateLayout();
+            DrainDispatcher();
+
+            var tabStrip = FindVisualDescendant<DocumentTabStrip>(documentControl);
+            Assert.NotNull(tabStrip);
+            tabStrip!.ApplyTemplate();
+            tabStrip.UpdateLayout();
+            DrainDispatcher();
+
+            var createButton = FindVisualDescendant<Button>(
+                tabStrip,
+                button => string.Equals(button.Name, "PART_ButtonCreate", StringComparison.Ordinal));
+            Assert.NotNull(createButton);
+            ApplyNoOpCommand(createButton);
+            InvokeButtonClick(createButton);
+
+            var tabItem = tabStrip.ContainerFromIndex(0) as DocumentTabStripItem
+                          ?? FindVisualDescendant<DocumentTabStripItem>(documentControl);
+            Assert.NotNull(tabItem);
+
+            var menuItem = new MenuItem { Header = "Test", Command = new NoOpCommand() };
+            var menu = new ContextMenu { ItemsSource = new object[] { menuItem } };
+            tabItem!.DocumentContextMenu = menu;
+            OpenAndCloseContextMenu(tabItem, menu, () => InvokeMenuItemClick(menuItem));
+
+            var closeButton = FindVisualDescendant<Button>(tabItem);
+            Assert.NotNull(closeButton);
+            ApplyNoOpCommand(closeButton);
+            InvokeButtonClick(closeButton);
+            DrainDispatcher();
+
+            tabItem!.DocumentContextMenu = null;
+            tabStrip.ItemsSource = null;
+            documentControl.DataContext = null;
+
+            var result = new DocumentControlLeakResult(
+                new WeakReference(documentControl),
+                new WeakReference(tabItem),
+                new WeakReference(createButton),
+                new WeakReference(closeButton),
+                new WeakReference(menuItem),
+                context.Factory,
+                context.Root);
+
+            CleanupWindow(window);
+            ClearFactoryCaches(context.Factory);
+            ResetDispatcherForUnitTests();
+
+            documentControl = null;
+            tabItem = null;
+            createButton = null;
+            closeButton = null;
+            menuItem = null;
+            menu = null;
+
+            return result;
+        });
+
+        AssertCollected(result.ControlRef);
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.TabItemRef, result.CreateButtonRef, result.CloseButtonRef, result.MenuItemRef);
+        }
+        GC.KeepAlive(result.FactoryKeepAlive);
+        GC.KeepAlive(result.LayoutKeepAlive);
+    }
+
+    private static void RunToolTabStripTest(DockThemeKind theme)
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            context.Root.ActiveDockable = context.ToolDock;
+            context.Root.DefaultDockable = context.ToolDock;
+            var secondaryTool = (Dock.Model.Avalonia.Controls.Tool)context.Factory.CreateTool();
+            secondaryTool.Factory = context.Factory;
+            secondaryTool.Owner = context.ToolDock;
+            var visibleDockables = context.ToolDock.VisibleDockables
+                                   ?? throw new InvalidOperationException("ToolDock.VisibleDockables was null.");
+            visibleDockables.Add(secondaryTool);
+
+            var tabStrip = new ToolTabStrip
+            {
+                DataContext = context.ToolDock,
+                ItemsSource = visibleDockables
+            };
+
+            var window = CreateThemedWindow(tabStrip, theme);
+            ShowWindow(window);
+
+            tabStrip.ApplyTemplate();
+            tabStrip.UpdateLayout();
+            DrainDispatcher();
+
+            var tabItem = tabStrip.ContainerFromIndex(0) as ToolTabStripItem
+                          ?? FindVisualDescendant<ToolTabStripItem>(tabStrip);
+            Assert.NotNull(tabItem);
+            tabItem = tabItem ?? throw new InvalidOperationException("ToolTabStrip item was not found.");
+
+            var menuItem = new MenuItem { Header = "Test", Command = new NoOpCommand() };
+            var menu = new ContextMenu { ItemsSource = new object[] { menuItem } };
+            tabItem.TabContextMenu = menu;
+            OpenAndCloseContextMenu(tabItem, menu, () => InvokeMenuItemClick(menuItem));
+            DrainDispatcher();
+
+            tabItem.TabContextMenu = null;
+            tabStrip.ItemsSource = null;
+            tabStrip.DataContext = null;
+
+            var result = new ToolTabStripLeakResult(
+                new WeakReference(tabStrip),
+                new WeakReference(tabItem),
+                new WeakReference(menuItem),
+                context.Factory,
+                context.Root);
+
+            CleanupWindow(window);
+            ClearFactoryCaches(context.Factory);
+            ResetDispatcherForUnitTests();
+
+            tabStrip = null;
+            tabItem = null;
+            menuItem = null;
+            menu = null;
+            secondaryTool = null;
+
+            return result;
+        });
+
+        AssertCollected(result.ControlRef);
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.TabItemRef, result.MenuItemRef);
+        }
+        GC.KeepAlive(result.FactoryKeepAlive);
+        GC.KeepAlive(result.LayoutKeepAlive);
+    }
+
+    private static void RunToolChromeControlTest(DockThemeKind theme)
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            var chrome = new ToolChromeControl
+            {
+                DataContext = context.ToolDock
+            };
+
+            var window = CreateThemedWindow(chrome, theme);
+            ShowWindow(window);
+
+            chrome.ApplyTemplate();
+            chrome.UpdateLayout();
+            DrainDispatcher();
+
+            var menuButton = FindTemplateChild<Button>(chrome, "PART_MenuButton");
+            var pinButton = FindTemplateChild<Button>(chrome, "PART_PinButton");
+            var maximizeButton = FindTemplateChild<Button>(chrome, "PART_MaximizeRestoreButton");
+            var closeButton = FindTemplateChild<Button>(chrome, "PART_CloseButton");
+
+            ApplyNoOpCommand(menuButton);
+            ApplyNoOpCommand(pinButton);
+            ApplyNoOpCommand(maximizeButton);
+            ApplyNoOpCommand(closeButton);
+
+            InvokeButtonClick(menuButton);
+            InvokeButtonClick(pinButton);
+            InvokeButtonClick(maximizeButton);
+            InvokeButtonClick(closeButton);
+            DrainDispatcher();
+
+            var result = new ToolChromeLeakResult(
+                new WeakReference(chrome),
+                new WeakReference(menuButton),
+                new WeakReference(pinButton),
+                new WeakReference(maximizeButton),
+                new WeakReference(closeButton),
+                context.ToolDock);
+
+            CleanupWindow(window);
+            ResetDispatcherForUnitTests();
+
+            chrome = null;
+            menuButton = null;
+            pinButton = null;
+            maximizeButton = null;
+            closeButton = null;
+
+            return result;
+        });
+
+        AssertCollected(result.ControlRef);
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.MenuButtonRef, result.PinButtonRef, result.MaximizeButtonRef, result.CloseButtonRef);
+        }
+        GC.KeepAlive(result.DockKeepAlive);
+    }
+
+    private static void RunToolPinnedControlTest(DockThemeKind theme)
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            var items = context.Factory.CreateList<IDockable>(context.Tool);
+
+            var pinnedControl = new ToolPinnedControl
+            {
+                ItemsSource = items
+            };
+
+            var window = CreateThemedWindow(pinnedControl, theme);
+            ShowWindow(window);
+
+            pinnedControl.ApplyTemplate();
+            pinnedControl.UpdateLayout();
+            DrainDispatcher();
+
+            var pinItem = pinnedControl.ContainerFromIndex(0) as ToolPinItemControl
+                          ?? FindVisualDescendant<ToolPinItemControl>(pinnedControl);
+            Assert.NotNull(pinItem);
+
+            var menuItem = new MenuItem { Header = "Test", Command = new NoOpCommand() };
+            var menu = new ContextMenu { ItemsSource = new object[] { menuItem } };
+            pinItem!.PinContextMenu = menu;
+            OpenAndCloseContextMenu(pinItem, menu, () => InvokeMenuItemClick(menuItem));
+
+            var result = new ToolPinnedLeakResult(
+                new WeakReference(pinnedControl),
+                new WeakReference(pinItem),
+                new WeakReference(menuItem),
+                items);
+
+            CleanupWindow(window);
+            ResetDispatcherForUnitTests();
+
+            pinnedControl = null;
+            pinItem = null;
+            menuItem = null;
+            menu = null;
+
+            return result;
+        });
+
+        AssertCollected(result.ControlRef);
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.PinItemRef, result.MenuItemRef);
+        }
+        GC.KeepAlive(result.ItemsKeepAlive);
+    }
+
+    private static void RunToolPinItemControlButtonTest(DockThemeKind theme)
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            var items = context.Factory.CreateList<IDockable>(context.Tool);
+
+            var pinnedControl = new ToolPinnedControl
+            {
+                ItemsSource = items
+            };
+
+            var window = CreateThemedWindow(pinnedControl, theme);
+            ShowWindow(window);
+
+            pinnedControl.ApplyTemplate();
+            pinnedControl.UpdateLayout();
+            DrainDispatcher();
+
+            var pinItem = pinnedControl.ContainerFromIndex(0) as ToolPinItemControl
+                          ?? FindVisualDescendant<ToolPinItemControl>(pinnedControl);
+            Assert.NotNull(pinItem);
+
+            var button = FindVisualDescendant<Button>(pinItem!);
+            Assert.NotNull(button);
+            InvokeButtonClick(button);
+            DrainDispatcher();
+
+            var result = new ToolPinItemButtonLeakResult(
+                new WeakReference(pinnedControl),
+                new WeakReference(pinItem),
+                new WeakReference(button!),
+                items);
+
+            CleanupWindow(window);
+            ResetDispatcherForUnitTests();
+
+            pinnedControl = null;
+            pinItem = null;
+            button = null;
+
+            return result;
+        });
+
+        AssertCollected(result.ControlRef);
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.PinItemRef, result.ButtonRef);
+        }
+        GC.KeepAlive(result.ItemsKeepAlive);
+    }
+
+    private static Window CreateThemedWindow(Control content, DockThemeKind theme)
+    {
+        var window = new Window { Content = content };
+        ApplyTheme(window, theme);
+        return window;
+    }
+
+    private static void ApplyTheme(Window window, DockThemeKind theme)
+    {
+        switch (theme)
+        {
+            case DockThemeKind.Fluent:
+                window.Styles.Add(new FluentTheme());
+                window.Styles.Add(new DockFluentTheme());
+                break;
+            case DockThemeKind.Simple:
+                window.Styles.Add(new DockSimpleTheme());
+                break;
+            default:
+                throw new ArgumentOutOfRangeException(nameof(theme), theme, "Unknown theme.");
+        }
+    }
+
+    private enum DockThemeKind
+    {
+        Fluent,
+        Simple
+    }
+
+    private sealed record CommandBarLeakResult(
+        WeakReference HostRef,
+        WeakReference OpenItemRef,
+        WeakReference ExitItemRef,
+        object CommandKeepAlive);
+
+    private sealed record DocumentControlLeakResult(
+        WeakReference ControlRef,
+        WeakReference TabItemRef,
+        WeakReference CreateButtonRef,
+        WeakReference CloseButtonRef,
+        WeakReference MenuItemRef,
+        IFactory FactoryKeepAlive,
+        IDock LayoutKeepAlive);
+
+    private sealed record ToolTabStripLeakResult(
+        WeakReference ControlRef,
+        WeakReference TabItemRef,
+        WeakReference MenuItemRef,
+        IFactory FactoryKeepAlive,
+        IDock LayoutKeepAlive);
+
+    private sealed record ToolChromeLeakResult(
+        WeakReference ControlRef,
+        WeakReference MenuButtonRef,
+        WeakReference PinButtonRef,
+        WeakReference MaximizeButtonRef,
+        WeakReference CloseButtonRef,
+        IDock DockKeepAlive);
+
+    private sealed record ToolPinnedLeakResult(
+        WeakReference ControlRef,
+        WeakReference PinItemRef,
+        WeakReference MenuItemRef,
+        System.Collections.Generic.IList<IDockable> ItemsKeepAlive);
+
+    private sealed record ToolPinItemButtonLeakResult(
+        WeakReference ControlRef,
+        WeakReference PinItemRef,
+        WeakReference ButtonRef,
+        System.Collections.Generic.IList<IDockable> ItemsKeepAlive);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/ThemeMdiInteractionLeakTests.cs b/tests/Dock.Avalonia.LeakTests/ThemeMdiInteractionLeakTests.cs
new file mode 100644
index 000000000..1c0d956e8
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/ThemeMdiInteractionLeakTests.cs
@@ -0,0 +1,179 @@
+using System;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Avalonia.VisualTree;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Avalonia.Themes.Simple;
+using Dock.Model.Core;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestCaseHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class ThemeMdiInteractionLeakTests
+{
+    [ReleaseFact]
+    public void MdiDocumentWindow_FluentTheme_ButtonAndMenuClicks_DoNotLeak() =>
+        RunMdiDocumentWindowTest(DockThemeKind.Fluent);
+
+    [ReleaseFact]
+    public void MdiDocumentWindow_SimpleTheme_ButtonAndMenuClicks_DoNotLeak() =>
+        RunMdiDocumentWindowTest(DockThemeKind.Simple);
+
+    private static void RunMdiDocumentWindowTest(DockThemeKind theme)
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            var document = context.Document;
+            document.MdiState = MdiWindowState.Normal;
+            document.CanClose = true;
+            document.CanFloat = true;
+
+            context.DocumentDock.CascadeDocuments = new NoOpCommand();
+            context.DocumentDock.TileDocumentsHorizontal = new NoOpCommand();
+            context.DocumentDock.TileDocumentsVertical = new NoOpCommand();
+            context.DocumentDock.RestoreDocuments = new NoOpCommand();
+
+            var control = new MdiDocumentWindow
+            {
+                DataContext = document
+            };
+
+            var window = CreateThemedWindow(control, theme);
+            ShowWindow(window);
+
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            var minimizeButton = FindTemplateChild<Button>(control, "PART_MinimizeButton");
+            var maximizeButton = FindTemplateChild<Button>(control, "PART_MaximizeRestoreButton");
+            var closeButton = FindTemplateChild<Button>(control, "PART_CloseButton");
+            Assert.NotNull(minimizeButton);
+            Assert.NotNull(maximizeButton);
+            Assert.NotNull(closeButton);
+
+            InvokeButtonClick(minimizeButton);
+            InvokeButtonClick(maximizeButton);
+            InvokeButtonClick(closeButton);
+            DrainDispatcher();
+
+            var menu = control.DocumentContextMenu;
+            MenuItem? menuItem = null;
+            if (menu is not null)
+            {
+                menuItem = FindMenuItemByHeader(menu, "Cascade");
+                OpenAndCloseContextMenu(control, menu, () => InvokeMenuItemClick(menuItem));
+            }
+
+            control.DocumentContextMenu = null;
+            control.DataContext = null;
+
+            var result = new MdiInteractionLeakResult(
+                new WeakReference(control),
+                new WeakReference(minimizeButton!),
+                new WeakReference(maximizeButton!),
+                new WeakReference(closeButton!),
+                menuItem is null ? null : new WeakReference(menuItem),
+                context.Factory,
+                document);
+
+            CleanupWindow(window);
+            ClearFactoryCaches(context.Factory);
+            ResetDispatcherForUnitTests();
+
+            control = null;
+            minimizeButton = null;
+            maximizeButton = null;
+            closeButton = null;
+
+            return result;
+        });
+
+        AssertCollected(result.ControlRef);
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            var refs = new[] { result.MinimizeButtonRef, result.MaximizeButtonRef, result.CloseButtonRef }
+                .Where(reference => reference is not null)
+                .Cast<WeakReference>()
+                .ToArray();
+            if (refs.Length > 0)
+            {
+                AssertCollected(refs);
+            }
+            if (result.MenuItemRef is not null)
+            {
+                AssertCollected(result.MenuItemRef);
+            }
+        }
+        GC.KeepAlive(result.FactoryKeepAlive);
+        GC.KeepAlive(result.DocumentKeepAlive);
+    }
+
+    private static MenuItem? FindMenuItemByHeader(ContextMenu menu, string header)
+    {
+        foreach (var visual in menu.GetVisualDescendants())
+        {
+            if (visual is MenuItem menuItem
+                && menuItem.Header is string text
+                && string.Equals(text, header, StringComparison.Ordinal))
+            {
+                return menuItem;
+            }
+        }
+
+        foreach (var item in menu.Items.OfType<MenuItem>())
+        {
+            if (item.Header is string text && string.Equals(text, header, StringComparison.Ordinal))
+            {
+                return item;
+            }
+        }
+
+        return menu.Items.OfType<MenuItem>().FirstOrDefault();
+    }
+
+    private static Window CreateThemedWindow(Control content, DockThemeKind theme)
+    {
+        var window = new Window { Content = content };
+        ApplyTheme(window, theme);
+        return window;
+    }
+
+    private static void ApplyTheme(Window window, DockThemeKind theme)
+    {
+        switch (theme)
+        {
+            case DockThemeKind.Fluent:
+                window.Styles.Add(new FluentTheme());
+                window.Styles.Add(new DockFluentTheme());
+                break;
+            case DockThemeKind.Simple:
+                window.Styles.Add(new DockSimpleTheme());
+                break;
+            default:
+                throw new ArgumentOutOfRangeException(nameof(theme), theme, "Unknown theme.");
+        }
+    }
+
+    private enum DockThemeKind
+    {
+        Fluent,
+        Simple
+    }
+
+    private sealed record MdiInteractionLeakResult(
+        WeakReference ControlRef,
+        WeakReference MinimizeButtonRef,
+        WeakReference MaximizeButtonRef,
+        WeakReference CloseButtonRef,
+        WeakReference? MenuItemRef,
+        IFactory FactoryKeepAlive,
+        IDockable DocumentKeepAlive);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/ThemeMenuInteractionLeakTests.cs b/tests/Dock.Avalonia.LeakTests/ThemeMenuInteractionLeakTests.cs
new file mode 100644
index 000000000..906f0bae5
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/ThemeMenuInteractionLeakTests.cs
@@ -0,0 +1,623 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Avalonia.Themes.Simple;
+using Dock.Model.Core;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestCaseHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class ThemeMenuInteractionLeakTests
+{
+    [ReleaseFact]
+    public void DocumentTabStripItem_FluentTheme_ContextMenuItems_DoNotLeak() =>
+        RunDocumentTabStripMenuTest(DockThemeKind.Fluent);
+
+    [ReleaseFact]
+    public void DocumentTabStripItem_SimpleTheme_ContextMenuItems_DoNotLeak() =>
+        RunDocumentTabStripMenuTest(DockThemeKind.Simple);
+
+    [ReleaseFact]
+    public void ToolTabStripItem_FluentTheme_ContextMenuItems_DoNotLeak() =>
+        RunToolTabStripMenuTest(DockThemeKind.Fluent);
+
+    [ReleaseFact]
+    public void ToolTabStripItem_SimpleTheme_ContextMenuItems_DoNotLeak() =>
+        RunToolTabStripMenuTest(DockThemeKind.Simple);
+
+    [ReleaseFact]
+    public void ToolPinItemControl_FluentTheme_ContextMenuItems_DoNotLeak() =>
+        RunToolPinItemMenuTest(DockThemeKind.Fluent);
+
+    [ReleaseFact]
+    public void ToolPinItemControl_SimpleTheme_ContextMenuItems_DoNotLeak() =>
+        RunToolPinItemMenuTest(DockThemeKind.Simple);
+
+    [ReleaseFact]
+    public void ToolChromeControl_FluentTheme_FlyoutMenuItems_DoNotLeak() =>
+        RunToolChromeMenuTest(DockThemeKind.Fluent);
+
+    [ReleaseFact]
+    public void ToolChromeControl_SimpleTheme_FlyoutMenuItems_DoNotLeak() =>
+        RunToolChromeMenuTest(DockThemeKind.Simple);
+
+    [ReleaseFact]
+    public void MdiDocumentWindow_FluentTheme_ContextMenuItems_DoNotLeak() =>
+        RunMdiDocumentWindowMenuTest(DockThemeKind.Fluent);
+
+    [ReleaseFact]
+    public void MdiDocumentWindow_SimpleTheme_ContextMenuItems_DoNotLeak() =>
+        RunMdiDocumentWindowMenuTest(DockThemeKind.Simple);
+
+    [ReleaseFact]
+    public void MdiDocumentWindow_ToolWindow_FluentTheme_ToolMenuItems_DoNotLeak() =>
+        RunMdiToolWindowMenuTest(DockThemeKind.Fluent);
+
+    [ReleaseFact]
+    public void MdiDocumentWindow_ToolWindow_SimpleTheme_ToolMenuItems_DoNotLeak() =>
+        RunMdiToolWindowMenuTest(DockThemeKind.Simple);
+
+    private static void RunDocumentTabStripMenuTest(DockThemeKind theme)
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create(new NoOpFactory());
+            context.Root.ActiveDockable = context.DocumentDock;
+            context.Root.DefaultDockable = context.DocumentDock;
+            context.DocumentDock.CanCloseLastDockable = true;
+            context.DocumentDock.CanDrag = true;
+            context.DocumentDock.CanDrop = true;
+            context.DocumentDock.CreateDocument = new NoOpCommand();
+            context.Document.CanClose = true;
+            context.Document.CanFloat = true;
+            context.Document.CanDockAsDocument = true;
+
+            var extra = (Dock.Model.Avalonia.Controls.Document)context.Factory.CreateDocument();
+            extra.Factory = context.Factory;
+            extra.Owner = context.DocumentDock;
+            extra.CanClose = true;
+            extra.CanFloat = true;
+            extra.CanDockAsDocument = true;
+            context.DocumentDock.VisibleDockables?.Add(extra);
+
+            var documentControl = new DocumentControl
+            {
+                DataContext = context.DocumentDock
+            };
+
+            var window = CreateThemedWindow(documentControl, theme);
+            ShowWindow(window);
+
+            documentControl.ApplyTemplate();
+            documentControl.UpdateLayout();
+            DrainDispatcher();
+
+            var tabStrip = FindVisualDescendant<DocumentTabStrip>(documentControl);
+            Assert.NotNull(tabStrip);
+            tabStrip!.ApplyTemplate();
+            tabStrip.UpdateLayout();
+            DrainDispatcher();
+
+            var tabItem = tabStrip.ContainerFromIndex(0) as DocumentTabStripItem
+                          ?? FindVisualDescendant<DocumentTabStripItem>(documentControl);
+            Assert.NotNull(tabItem);
+
+            var menu = tabItem!.DocumentContextMenu;
+            Assert.NotNull(menu);
+
+            var menuItems = CollectMenuItems(menu!);
+
+            OpenAndCloseContextMenu(tabItem, menu, () =>
+            {
+                foreach (var item in menuItems)
+                {
+                    InvokeMenuItemClick(item);
+                }
+            });
+
+            tabItem.DocumentContextMenu = null;
+            tabStrip.ItemsSource = null;
+            documentControl.DataContext = null;
+
+            var result = new MenuInteractionLeakResult(
+                new WeakReference(documentControl),
+                new WeakReference(tabItem),
+                menuItems.Select(item => new WeakReference(item)).ToArray(),
+                context.Factory,
+                context.Root);
+
+            CleanupWindow(window);
+            ClearFactoryCaches(context.Factory);
+            ResetDispatcherForUnitTests();
+
+            documentControl = null;
+            tabItem = null;
+            menuItems = null;
+            extra = null;
+
+            return result;
+        });
+
+        AssertCollected(result.ControlRef);
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.MenuItemRefs);
+            AssertCollected(result.ItemRef);
+        }
+        GC.KeepAlive(result.FactoryKeepAlive);
+        GC.KeepAlive(result.LayoutKeepAlive);
+    }
+
+    private static void RunToolTabStripMenuTest(DockThemeKind theme)
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create(new NoOpFactory());
+            context.Root.ActiveDockable = context.ToolDock;
+            context.Root.DefaultDockable = context.ToolDock;
+            context.ToolDock.CanCloseLastDockable = true;
+            context.Tool.CanClose = true;
+            context.Tool.CanFloat = true;
+            context.Tool.CanPin = true;
+            context.Tool.CanDockAsDocument = true;
+
+            var extra = (Dock.Model.Avalonia.Controls.Tool)context.Factory.CreateTool();
+            extra.Factory = context.Factory;
+            extra.Owner = context.ToolDock;
+            extra.CanClose = true;
+            extra.CanFloat = true;
+            extra.CanPin = true;
+            extra.CanDockAsDocument = true;
+            context.ToolDock.VisibleDockables?.Add(extra);
+
+            var tabStrip = new ToolTabStrip
+            {
+                DataContext = context.ToolDock,
+                ItemsSource = context.ToolDock.VisibleDockables
+            };
+
+            var window = CreateThemedWindow(tabStrip, theme);
+            ShowWindow(window);
+
+            tabStrip.ApplyTemplate();
+            tabStrip.UpdateLayout();
+            DrainDispatcher();
+
+            var tabItem = tabStrip.ContainerFromIndex(0) as ToolTabStripItem
+                          ?? FindVisualDescendant<ToolTabStripItem>(tabStrip);
+            Assert.NotNull(tabItem);
+
+            var menu = tabItem!.TabContextMenu;
+            Assert.NotNull(menu);
+
+            var menuItems = CollectMenuItems(menu!);
+
+            OpenAndCloseContextMenu(tabItem, menu, () =>
+            {
+                foreach (var item in menuItems)
+                {
+                    InvokeMenuItemClick(item);
+                }
+            });
+
+            tabItem.TabContextMenu = null;
+            tabStrip.ItemsSource = null;
+            tabStrip.DataContext = null;
+
+            var result = new MenuInteractionLeakResult(
+                new WeakReference(tabStrip),
+                new WeakReference(tabItem),
+                menuItems.Select(item => new WeakReference(item)).ToArray(),
+                context.Factory,
+                context.Root);
+
+            CleanupWindow(window);
+            ClearFactoryCaches(context.Factory);
+            ResetDispatcherForUnitTests();
+
+            tabStrip = null;
+            tabItem = null;
+            menuItems = null;
+            extra = null;
+
+            return result;
+        });
+
+        AssertCollected(result.ControlRef);
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.MenuItemRefs);
+            AssertCollected(result.ItemRef);
+        }
+        GC.KeepAlive(result.FactoryKeepAlive);
+        GC.KeepAlive(result.LayoutKeepAlive);
+    }
+
+    private static void RunToolPinItemMenuTest(DockThemeKind theme)
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create(new NoOpFactory());
+            context.ToolDock.CanCloseLastDockable = true;
+            context.Tool.CanClose = true;
+            context.Tool.CanFloat = true;
+            context.Tool.CanPin = true;
+            context.Tool.CanDockAsDocument = true;
+
+            var items = context.Factory.CreateList<IDockable>(context.Tool);
+            var pinnedControl = new ToolPinnedControl
+            {
+                ItemsSource = items
+            };
+
+            var window = CreateThemedWindow(pinnedControl, theme);
+            ShowWindow(window);
+
+            pinnedControl.ApplyTemplate();
+            pinnedControl.UpdateLayout();
+            DrainDispatcher();
+
+            var pinItem = pinnedControl.ContainerFromIndex(0) as ToolPinItemControl
+                          ?? FindVisualDescendant<ToolPinItemControl>(pinnedControl);
+            Assert.NotNull(pinItem);
+
+            var menu = pinItem!.PinContextMenu;
+            Assert.NotNull(menu);
+
+            var menuItems = CollectMenuItems(menu!);
+
+            OpenAndCloseContextMenu(pinItem, menu, () =>
+            {
+                foreach (var item in menuItems)
+                {
+                    InvokeMenuItemClick(item);
+                }
+            });
+
+            pinItem.PinContextMenu = null;
+
+            var result = new MenuInteractionLeakResult(
+                new WeakReference(pinnedControl),
+                new WeakReference(pinItem),
+                menuItems.Select(item => new WeakReference(item)).ToArray(),
+                context.Factory,
+                context.Root);
+
+            CleanupWindow(window);
+            ResetDispatcherForUnitTests();
+
+            pinnedControl = null;
+            pinItem = null;
+            menuItems = null;
+
+            return result;
+        });
+
+        AssertCollected(result.ControlRef);
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.MenuItemRefs);
+            AssertCollected(result.ItemRef);
+        }
+        GC.KeepAlive(result.FactoryKeepAlive);
+        GC.KeepAlive(result.LayoutKeepAlive);
+    }
+
+    private static void RunToolChromeMenuTest(DockThemeKind theme)
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create(new NoOpFactory());
+            context.ToolDock.CanCloseLastDockable = true;
+            context.Tool.CanClose = true;
+            context.Tool.CanFloat = true;
+            context.Tool.CanPin = true;
+            context.Tool.CanDockAsDocument = true;
+
+            var chrome = new ToolChromeControl
+            {
+                DataContext = context.ToolDock
+            };
+
+            var window = CreateThemedWindow(chrome, theme);
+            ShowWindow(window);
+
+            chrome.ApplyTemplate();
+            chrome.UpdateLayout();
+            DrainDispatcher();
+
+            var flyout = chrome.ToolFlyout;
+            Assert.NotNull(flyout);
+
+            var menuItems = CollectMenuItems(flyout!);
+
+            OpenAndCloseFlyout(chrome, flyout, () =>
+            {
+                foreach (var item in menuItems)
+                {
+                    InvokeMenuItemClick(item);
+                }
+            });
+
+            chrome.ToolFlyout = null;
+
+            var result = new MenuInteractionLeakResult(
+                new WeakReference(chrome),
+                new WeakReference(chrome),
+                menuItems.Select(item => new WeakReference(item)).ToArray(),
+                context.Factory,
+                context.Root);
+
+            CleanupWindow(window);
+            ClearFactoryCaches(context.Factory);
+            ResetDispatcherForUnitTests();
+
+            chrome = null;
+            menuItems = null;
+
+            return result;
+        });
+
+        AssertCollected(result.ControlRef);
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.MenuItemRefs);
+        }
+        GC.KeepAlive(result.FactoryKeepAlive);
+        GC.KeepAlive(result.LayoutKeepAlive);
+    }
+
+    private static void RunMdiDocumentWindowMenuTest(DockThemeKind theme)
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create(new NoOpFactory());
+            var document = context.Document;
+            document.MdiState = MdiWindowState.Normal;
+            document.CanClose = true;
+            document.CanFloat = true;
+
+            context.DocumentDock.CanCloseLastDockable = true;
+            context.DocumentDock.CanDrag = true;
+            context.DocumentDock.CanDrop = true;
+            context.DocumentDock.CascadeDocuments = new NoOpCommand();
+            context.DocumentDock.TileDocumentsHorizontal = new NoOpCommand();
+            context.DocumentDock.TileDocumentsVertical = new NoOpCommand();
+            context.DocumentDock.RestoreDocuments = new NoOpCommand();
+
+            var extra = (Dock.Model.Avalonia.Controls.Document)context.Factory.CreateDocument();
+            extra.Factory = context.Factory;
+            extra.Owner = context.DocumentDock;
+            extra.CanClose = true;
+            extra.CanFloat = true;
+            context.DocumentDock.VisibleDockables?.Add(extra);
+
+            var control = new MdiDocumentWindow
+            {
+                DataContext = document
+            };
+
+            var window = CreateThemedWindow(control, theme);
+            ShowWindow(window);
+
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            var menu = control.DocumentContextMenu;
+            Assert.NotNull(menu);
+
+            var menuItems = CollectMenuItems(menu!);
+
+            OpenAndCloseContextMenu(control, menu, () =>
+            {
+                foreach (var item in menuItems)
+                {
+                    InvokeMenuItemClick(item);
+                }
+            });
+
+            control.DocumentContextMenu = null;
+            control.DataContext = null;
+
+            var result = new MenuInteractionLeakResult(
+                new WeakReference(control),
+                new WeakReference(control),
+                menuItems.Select(item => new WeakReference(item)).ToArray(),
+                context.Factory,
+                context.Root);
+
+            CleanupWindow(window);
+            ClearFactoryCaches(context.Factory);
+            ResetDispatcherForUnitTests();
+
+            control = null;
+            menuItems = null;
+            extra = null;
+
+            return result;
+        });
+
+        AssertCollected(result.ControlRef);
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.MenuItemRefs);
+        }
+        GC.KeepAlive(result.FactoryKeepAlive);
+        GC.KeepAlive(result.LayoutKeepAlive);
+    }
+
+    private static void RunMdiToolWindowMenuTest(DockThemeKind theme)
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create(new NoOpFactory());
+            context.Root.ActiveDockable = context.ToolDock;
+            context.Root.DefaultDockable = context.ToolDock;
+            context.ToolDock.Owner = context.Root;
+            context.ToolDock.ActiveDockable = context.Tool;
+            context.ToolDock.CanCloseLastDockable = true;
+            context.Tool.CanClose = true;
+            context.Tool.CanPin = true;
+            context.Tool.CanDockAsDocument = true;
+            context.Tool.CanFloat = true;
+
+            var dockWindow = new Dock.Model.Avalonia.Core.DockWindow
+            {
+                Factory = context.Factory,
+                Layout = context.Root
+            };
+
+            var managedDocument = new ManagedDockWindowDocument(dockWindow)
+            {
+                Factory = context.Factory,
+                Owner = context.Root
+            };
+
+            var control = new MdiDocumentWindow
+            {
+                DataContext = managedDocument
+            };
+
+            var window = CreateThemedWindow(control, theme);
+            ShowWindow(window);
+
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            var menuButton = FindTemplateChild<Button>(control, "PART_ToolMenuButton");
+            var pinButton = FindTemplateChild<Button>(control, "PART_ToolPinButton");
+            var closeButton = FindTemplateChild<Button>(control, "PART_ToolCloseButton");
+
+            if (menuButton is not null)
+            {
+                var flyout = menuButton.Flyout;
+                if (flyout is not null)
+                {
+                    var menuItems = CollectMenuItems(flyout);
+
+                    OpenAndCloseFlyout(menuButton, flyout, () =>
+                    {
+                        foreach (var item in menuItems)
+                        {
+                            InvokeMenuItemClick(item);
+                        }
+                    });
+                }
+            }
+
+            InvokeButtonClick(pinButton);
+            InvokeButtonClick(closeButton);
+            DrainDispatcher();
+
+            control.DataContext = null;
+            managedDocument.Dispose();
+            dockWindow.Layout = null;
+
+            var result = new MenuInteractionLeakResult(
+                new WeakReference(control),
+                new WeakReference(control),
+                Array.Empty<WeakReference>(),
+                context.Factory,
+                context.Root);
+
+            CleanupWindow(window);
+            ClearFactoryCaches(context.Factory);
+            ResetDispatcherForUnitTests();
+
+            control = null;
+            menuButton = null;
+            pinButton = null;
+            closeButton = null;
+
+            return result;
+        });
+
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.FactoryKeepAlive);
+        GC.KeepAlive(result.LayoutKeepAlive);
+    }
+
+    private static List<MenuItem> CollectMenuItems(ContextMenu menu)
+    {
+        var items = new List<MenuItem>();
+        CollectMenuItems(menu.Items, items);
+        return items;
+    }
+
+    private static List<MenuItem> CollectMenuItems(FlyoutBase flyout)
+    {
+        if (flyout is MenuFlyout menuFlyout)
+        {
+            var items = new List<MenuItem>();
+            CollectMenuItems(menuFlyout.Items, items);
+            return items;
+        }
+
+        return new List<MenuItem>();
+    }
+
+    private static void CollectMenuItems(IEnumerable? source, ICollection<MenuItem> target)
+    {
+        if (source is null)
+        {
+            return;
+        }
+
+        foreach (var entry in source)
+        {
+            if (entry is MenuItem menuItem)
+            {
+                target.Add(menuItem);
+                CollectMenuItems(menuItem.Items, target);
+            }
+        }
+    }
+
+    private static Window CreateThemedWindow(Control content, DockThemeKind theme)
+    {
+        var window = new Window { Content = content };
+        ApplyTheme(window, theme);
+        return window;
+    }
+
+    private static void ApplyTheme(Window window, DockThemeKind theme)
+    {
+        switch (theme)
+        {
+            case DockThemeKind.Fluent:
+                window.Styles.Add(new FluentTheme());
+                window.Styles.Add(new DockFluentTheme());
+                break;
+            case DockThemeKind.Simple:
+                window.Styles.Add(new DockSimpleTheme());
+                break;
+            default:
+                throw new ArgumentOutOfRangeException(nameof(theme), theme, "Unknown theme.");
+        }
+    }
+
+    private enum DockThemeKind
+    {
+        Fluent,
+        Simple
+    }
+
+    private sealed record MenuInteractionLeakResult(
+        WeakReference ControlRef,
+        WeakReference ItemRef,
+        WeakReference[] MenuItemRefs,
+        IFactory FactoryKeepAlive,
+        IDock LayoutKeepAlive);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/ThemeOverlayInteractionLeakTests.cs b/tests/Dock.Avalonia.LeakTests/ThemeOverlayInteractionLeakTests.cs
new file mode 100644
index 000000000..7c25da213
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/ThemeOverlayInteractionLeakTests.cs
@@ -0,0 +1,263 @@
+using System;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Avalonia.VisualTree;
+using Dock.Avalonia.Controls.Overlays;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Avalonia.Themes.Simple;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class ThemeOverlayInteractionLeakTests
+{
+    [ReleaseFact]
+    public void DialogShellControl_FluentTheme_CloseButtonClick_DoesNotLeak() =>
+        RunDialogShellControlTest(DockThemeKind.Fluent);
+
+    [ReleaseFact]
+    public void DialogShellControl_SimpleTheme_CloseButtonClick_DoesNotLeak() =>
+        RunDialogShellControlTest(DockThemeKind.Simple);
+
+    [ReleaseFact]
+    public void ConfirmationDialogControl_FluentTheme_ButtonClicks_DoNotLeak() =>
+        RunConfirmationDialogControlTest(DockThemeKind.Fluent);
+
+    [ReleaseFact]
+    public void ConfirmationDialogControl_SimpleTheme_ButtonClicks_DoNotLeak() =>
+        RunConfirmationDialogControlTest(DockThemeKind.Simple);
+
+    [ReleaseFact]
+    public void BusyOverlayControl_FluentTheme_ReloadClick_DoesNotLeak() =>
+        RunBusyOverlayControlTest(DockThemeKind.Fluent);
+
+    [ReleaseFact]
+    public void BusyOverlayControl_SimpleTheme_ReloadClick_DoesNotLeak() =>
+        RunBusyOverlayControlTest(DockThemeKind.Simple);
+
+    private static void RunDialogShellControlTest(DockThemeKind theme)
+    {
+        var result = RunInSession(() =>
+        {
+            var control = new DialogShellControl
+            {
+                Title = "Dialog",
+                Content = new TextBlock { Text = "Body" },
+                CloseCommand = new NoOpCommand()
+            };
+
+            var window = CreateThemedWindow(control, theme);
+            ShowWindow(window);
+
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            var closeButton = FindVisualDescendant<Button>(control);
+            if (closeButton is not null)
+            {
+                InvokeButtonClick(closeButton);
+                DrainDispatcher();
+            }
+            else
+            {
+                Assert.True(theme == DockThemeKind.Simple, "Close button not found for Fluent theme.");
+            }
+
+            var result = new OverlayButtonLeakResult(
+                new WeakReference(control),
+                new WeakReference(closeButton));
+
+            CleanupWindow(window);
+            ResetDispatcherForUnitTests();
+
+            control = null;
+            closeButton = null;
+
+            return result;
+        });
+
+        AssertCollected(result.ControlRef);
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.ButtonRef);
+        }
+    }
+
+    private static void RunConfirmationDialogControlTest(DockThemeKind theme)
+    {
+        var result = RunInSession(() =>
+        {
+            var control = new ConfirmationDialogControl
+            {
+                Title = "Confirm",
+                Message = "Are you sure?",
+                ConfirmText = "Yes",
+                CancelText = "No",
+                ConfirmCommand = new NoOpCommand(),
+                CancelCommand = new NoOpCommand()
+            };
+
+            var window = CreateThemedWindow(control, theme);
+            ShowWindow(window);
+
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            var buttons = GetVisualDescendants<Button>(control);
+            if (buttons.Count == 0)
+            {
+                Assert.True(theme == DockThemeKind.Simple, "Confirmation buttons not found for Fluent theme.");
+            }
+            else
+            {
+                foreach (var button in buttons)
+                {
+                    InvokeButtonClick(button);
+                }
+                DrainDispatcher();
+            }
+
+            var result = new OverlayButtonsLeakResult(
+                new WeakReference(control),
+                buttons.Select(button => new WeakReference(button)).ToArray());
+
+            CleanupWindow(window);
+            ResetDispatcherForUnitTests();
+
+            control = null;
+            buttons = null;
+
+            return result;
+        });
+
+        AssertCollected(result.ControlRef);
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.ButtonRefs);
+        }
+    }
+
+    private static void RunBusyOverlayControlTest(DockThemeKind theme)
+    {
+        var result = RunInSession(() =>
+        {
+            var busyService = new StubBusyService
+            {
+                IsReloadVisible = true
+            };
+            busyService.SetReloadHandler(() => System.Threading.Tasks.Task.CompletedTask);
+            var globalService = new StubGlobalBusyService();
+
+            var control = new BusyOverlayControl
+            {
+                BusyService = busyService,
+                GlobalBusyService = globalService,
+                ShowReloadButton = true
+            };
+
+            var window = CreateThemedWindow(control, theme);
+            ShowWindow(window);
+
+            control.ApplyTemplate();
+            control.UpdateLayout();
+            DrainDispatcher();
+
+            var reloadButton = FindVisualDescendant<Button>(
+                control,
+                button => ReferenceEquals(button.Command, control.ReloadCommand));
+            if (reloadButton is not null)
+            {
+                InvokeButtonClick(reloadButton);
+                DrainDispatcher();
+            }
+            else
+            {
+                Assert.True(theme == DockThemeKind.Simple, "Reload button not found for Fluent theme.");
+            }
+
+            var result = new OverlayButtonKeepAliveLeakResult(
+                new WeakReference(control),
+                new WeakReference(reloadButton),
+                busyService,
+                globalService);
+
+            CleanupWindow(window);
+            ResetDispatcherForUnitTests();
+
+            control = null;
+            reloadButton = null;
+
+            return result;
+        });
+
+        AssertCollected(result.ControlRef);
+        if (string.Equals(Environment.GetEnvironmentVariable("DOCK_LEAK_STRICT"), "1", StringComparison.Ordinal))
+        {
+            AssertCollected(result.ButtonRef);
+        }
+        GC.KeepAlive(result.BusyServiceKeepAlive);
+        GC.KeepAlive(result.GlobalServiceKeepAlive);
+    }
+
+    private static Window CreateThemedWindow(Control content, DockThemeKind theme)
+    {
+        var window = new Window { Content = content };
+        ApplyTheme(window, theme);
+        return window;
+    }
+
+    private static void ApplyTheme(Window window, DockThemeKind theme)
+    {
+        switch (theme)
+        {
+            case DockThemeKind.Fluent:
+                window.Styles.Add(new FluentTheme());
+                window.Styles.Add(new DockFluentTheme());
+                break;
+            case DockThemeKind.Simple:
+                window.Styles.Add(new DockSimpleTheme());
+                break;
+            default:
+                throw new ArgumentOutOfRangeException(nameof(theme), theme, "Unknown theme.");
+        }
+    }
+
+    private static System.Collections.Generic.List<T> GetVisualDescendants<T>(Control root) where T : Control
+    {
+        var results = new System.Collections.Generic.List<T>();
+        foreach (var visual in root.GetVisualDescendants())
+        {
+            if (visual is T control)
+            {
+                results.Add(control);
+            }
+        }
+        return results;
+    }
+
+    private enum DockThemeKind
+    {
+        Fluent,
+        Simple
+    }
+
+    private sealed record OverlayButtonLeakResult(
+        WeakReference ControlRef,
+        WeakReference ButtonRef);
+
+    private sealed record OverlayButtonsLeakResult(
+        WeakReference ControlRef,
+        WeakReference[] ButtonRefs);
+
+    private sealed record OverlayButtonKeepAliveLeakResult(
+        WeakReference ControlRef,
+        WeakReference ButtonRef,
+        StubBusyService BusyServiceKeepAlive,
+        StubGlobalBusyService GlobalServiceKeepAlive);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/ToolChromeControlLeakTests.cs b/tests/Dock.Avalonia.LeakTests/ToolChromeControlLeakTests.cs
new file mode 100644
index 000000000..7b8b7e762
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/ToolChromeControlLeakTests.cs
@@ -0,0 +1,55 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class ToolChromeControlLeakTests
+{
+    [ReleaseFact]
+    public void ToolChromeControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+
+            var chromeControl = new ToolChromeControl
+            {
+                DataContext = context.ToolDock
+            };
+
+            var window = new HostWindow { Content = chromeControl };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            chromeControl.ApplyTemplate();
+            chromeControl.UpdateLayout();
+            DrainDispatcher();
+
+            window.Content = new Border();
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var controlRef = new WeakReference(chromeControl);
+            chromeControl = null;
+
+            return new ToolChromeDetachLeakResult(controlRef, window, context.ToolDock);
+        });
+
+        AssertCollected(result.ControlRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+    }
+
+    private sealed record ToolChromeDetachLeakResult(
+        WeakReference ControlRef,
+        HostWindow WindowKeepAlive,
+        Dock.Model.Core.IDock DockKeepAlive);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/ToolPinItemLeakTests.cs b/tests/Dock.Avalonia.LeakTests/ToolPinItemLeakTests.cs
new file mode 100644
index 000000000..e9f2b7ea6
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/ToolPinItemLeakTests.cs
@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Model.Core;
+using Dock.Settings;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class ToolPinItemLeakTests
+{
+    [ReleaseFact]
+    public void ToolPinItemControl_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+            var items = context.Factory.CreateList<IDockable>(context.Tool);
+
+            var pinnedControl = new ToolPinnedControl
+            {
+                ItemsSource = items
+            };
+
+            var window = new Window { Content = pinnedControl };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            pinnedControl.ApplyTemplate();
+            pinnedControl.UpdateLayout();
+            DrainDispatcher();
+
+            var pinItem = pinnedControl.ContainerFromIndex(0) as ToolPinItemControl
+                          ?? FindVisualDescendant<ToolPinItemControl>(pinnedControl);
+            Assert.NotNull(pinItem);
+
+            var startPoint = new Point(pinItem!.Bounds.Width / 2, pinItem.Bounds.Height / 2);
+            var dragPoint = new Point(
+                startPoint.X + DockSettings.MinimumHorizontalDragDistance + 20,
+                startPoint.Y + DockSettings.MinimumVerticalDragDistance + 20);
+
+            RaisePointerPressed(pinItem, startPoint, MouseButton.Left);
+            RaisePointerMoved(pinItem, dragPoint, leftPressed: true);
+            DrainDispatcher();
+
+            items.Remove(context.Tool);
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var itemRef = new WeakReference(pinItem);
+            pinItem = null;
+
+            return new ToolPinItemLeakResult(itemRef, window, pinnedControl, context.Tool, items);
+        });
+
+        AssertCollected(result.ItemRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.PinnedControlKeepAlive);
+        GC.KeepAlive(result.ToolKeepAlive);
+        GC.KeepAlive(result.ItemsKeepAlive);
+    }
+
+    private sealed record ToolPinItemLeakResult(
+        WeakReference ItemRef,
+        Window WindowKeepAlive,
+        ToolPinnedControl PinnedControlKeepAlive,
+        IDockable ToolKeepAlive,
+        IList<IDockable> ItemsKeepAlive);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/ToolTabStripLeakTests.cs b/tests/Dock.Avalonia.LeakTests/ToolTabStripLeakTests.cs
new file mode 100644
index 000000000..0ee8a48b6
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/ToolTabStripLeakTests.cs
@@ -0,0 +1,163 @@
+using System;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Themes.Fluent;
+using Dock.Avalonia.Controls;
+using Dock.Avalonia.Themes.Fluent;
+using Dock.Settings;
+using Xunit;
+using static Dock.Avalonia.LeakTests.LeakTestHelpers;
+using static Dock.Avalonia.LeakTests.LeakTestSession;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class ToolTabStripLeakTests
+{
+    [ReleaseFact]
+    public void ToolTabStrip_ItemContainer_DoesNotLeak_TabStrip_WhenItemAlive()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+
+            var tabStrip = new ToolTabStrip
+            {
+                ItemsSource = null
+            };
+
+            var tabItem = new ToolTabStripItem { DataContext = context.Tool };
+            tabStrip.Items.Add(tabItem);
+
+            var window = new Window { Content = tabStrip };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            tabStrip.ApplyTemplate();
+            tabStrip.UpdateLayout();
+            DrainDispatcher();
+
+            tabStrip.Items.Remove(tabItem);
+            DrainDispatcher();
+
+            var result = new ToolTabStripLeakResult(
+                new WeakReference(tabStrip),
+                tabItem,
+                context.Tool);
+
+            CleanupWindow(window);
+            return result;
+        });
+
+        AssertCollected(result.TabStripRef);
+        GC.KeepAlive(result.ItemKeepAlive);
+        GC.KeepAlive(result.DockableKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void ToolTabStripItem_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+
+            var tabStrip = new ToolTabStrip
+            {
+                DataContext = context.ToolDock
+            };
+
+            var tabItem = new ToolTabStripItem
+            {
+                DataContext = context.Tool
+            };
+            tabStrip.Items.Add(tabItem);
+
+            var window = new Window { Content = tabStrip };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            tabStrip.ApplyTemplate();
+            tabStrip.UpdateLayout();
+            DrainDispatcher();
+
+            var startPoint = new Point(tabItem.Bounds.Width / 2, tabItem.Bounds.Height / 2);
+            var dragPoint = new Point(
+                startPoint.X + DockSettings.MinimumHorizontalDragDistance + 20,
+                startPoint.Y + DockSettings.MinimumVerticalDragDistance + 20);
+
+            RaisePointerPressed(tabItem, startPoint, MouseButton.Left);
+            RaisePointerMoved(tabItem, dragPoint, leftPressed: true);
+            DrainDispatcher();
+
+            tabStrip.Items.Remove(tabItem);
+            DrainDispatcher();
+            ClearInputState(window);
+
+            var itemRef = new WeakReference(tabItem);
+            tabItem = null;
+
+            return new ToolTabStripItemLeakResult(itemRef, window, tabStrip, context.Tool, context.ToolDock);
+        });
+
+        AssertCollected(result.ItemRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.TabStripKeepAlive);
+        GC.KeepAlive(result.ToolKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+    }
+
+    [ReleaseFact]
+    public void ToolTabStrip_DetachWhileWindowAlive_DoesNotLeak()
+    {
+        var result = RunInSession(() =>
+        {
+            var context = LeakContext.Create();
+
+            var tabStrip = new ToolTabStrip
+            {
+                ItemsSource = context.ToolDock.VisibleDockables
+            };
+
+            var window = new Window { Content = tabStrip };
+            window.Styles.Add(new FluentTheme());
+            window.Styles.Add(new DockFluentTheme());
+
+            ShowWindow(window);
+            tabStrip.ApplyTemplate();
+            tabStrip.UpdateLayout();
+            DrainDispatcher();
+
+            window.Content = new Border();
+            DrainDispatcher();
+
+            var tabStripRef = new WeakReference(tabStrip);
+            tabStrip = null;
+
+            return new ToolTabStripDetachLeakResult(tabStripRef, window, context.ToolDock);
+        });
+
+        AssertCollected(result.TabStripRef);
+        GC.KeepAlive(result.WindowKeepAlive);
+        GC.KeepAlive(result.DockKeepAlive);
+    }
+
+    private sealed record ToolTabStripLeakResult(
+        WeakReference TabStripRef,
+        ToolTabStripItem ItemKeepAlive,
+        object DockableKeepAlive);
+
+    private sealed record ToolTabStripItemLeakResult(
+        WeakReference ItemRef,
+        Window WindowKeepAlive,
+        ToolTabStrip TabStripKeepAlive,
+        Dock.Model.Core.IDockable ToolKeepAlive,
+        Dock.Model.Core.IDock DockKeepAlive);
+
+    private sealed record ToolTabStripDetachLeakResult(
+        WeakReference TabStripRef,
+        Window WindowKeepAlive,
+        Dock.Model.Core.IDock DockKeepAlive);
+}
diff --git a/tests/Dock.Avalonia.LeakTests/WindowLeakTests.cs b/tests/Dock.Avalonia.LeakTests/WindowLeakTests.cs
new file mode 100644
index 000000000..e4904532e
--- /dev/null
+++ b/tests/Dock.Avalonia.LeakTests/WindowLeakTests.cs
@@ -0,0 +1,27 @@
+using Xunit;
+
+namespace Dock.Avalonia.LeakTests;
+
+[Collection("LeakTests")]
+public class WindowLeakTests
+{
+    [ReleaseFact]
+    public void AllWindows_AttachDetach_DoesNotLeak()
+    {
+        foreach (var testCase in LeakTestCases.WindowCases)
+        {
+            var result = LeakTestCaseRunner.RunWindowCase(testCase, exerciseInput: false);
+            LeakTestCaseRunner.AssertCollectedForCase(result, keepAlive: true);
+        }
+    }
+
+    [ReleaseFact]
+    public void AllWindows_InputInteractions_DoesNotLeak()
+    {
+        foreach (var testCase in LeakTestCases.WindowCases)
+        {
+            var result = LeakTestCaseRunner.RunWindowCase(testCase, exerciseInput: true);
+            LeakTestCaseRunner.AssertCollectedForCase(result, keepAlive: true);
+        }
+    }
+}
diff --git a/tests/Dock.Model.Mvvm.LeakTests/Dock.Model.Mvvm.LeakTests.csproj b/tests/Dock.Model.Mvvm.LeakTests/Dock.Model.Mvvm.LeakTests.csproj
new file mode 100644
index 000000000..870a9b4ec
--- /dev/null
+++ b/tests/Dock.Model.Mvvm.LeakTests/Dock.Model.Mvvm.LeakTests.csproj
@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk" ToolsVersion="15.0">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <OutputType>Library</OutputType>
+    <IsPackable>False</IsPackable>
+    <IsTestProject>True</IsTestProject>
+    <GenerateAssemblyInfo>False</GenerateAssemblyInfo>
+    <GenerateRuntimeConfigurationFiles>True</GenerateRuntimeConfigurationFiles>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <Import Project="..\..\build\XUnit.props" />
+  <Import Project="..\..\build\CommunityToolkit.Mvvm.props" />
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Dock.Model\Dock.Model.csproj" />
+    <ProjectReference Include="..\..\src\Dock.Model.Mvvm\Dock.Model.Mvvm.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/Dock.Model.Mvvm.LeakTests/DockableLeakTests.cs b/tests/Dock.Model.Mvvm.LeakTests/DockableLeakTests.cs
new file mode 100644
index 000000000..355b61b82
--- /dev/null
+++ b/tests/Dock.Model.Mvvm.LeakTests/DockableLeakTests.cs
@@ -0,0 +1,67 @@
+using System;
+using Dock.Model.Controls;
+using Dock.Model.Core;
+using Dock.Model.Mvvm;
+using Xunit;
+using static Dock.Model.Mvvm.LeakTests.LeakTestHelpers;
+
+namespace Dock.Model.Mvvm.LeakTests;
+
+[Collection("LeakTests")]
+public class DockableLeakTests
+{
+    [ReleaseFact]
+    public void CloseDockable_DoesNotLeak_DocumentAndTool()
+    {
+        var factory = new Factory();
+
+        var root = factory.CreateRootDock();
+        root.Factory = factory;
+        root.VisibleDockables = factory.CreateList<IDockable>();
+        root.HiddenDockables = factory.CreateList<IDockable>();
+        root.Windows = factory.CreateList<IDockWindow>();
+
+        var documentDock = factory.CreateDocumentDock();
+        documentDock.Factory = factory;
+        documentDock.VisibleDockables = factory.CreateList<IDockable>();
+
+        IDocument document = factory.CreateDocument();
+        document.Factory = factory;
+        factory.AddDockable(documentDock, document);
+        documentDock.ActiveDockable = document;
+
+        var toolDock = factory.CreateToolDock();
+        toolDock.Factory = factory;
+        toolDock.VisibleDockables = factory.CreateList<IDockable>();
+
+        ITool tool = factory.CreateTool();
+        tool.Factory = factory;
+        factory.AddDockable(toolDock, tool);
+        toolDock.ActiveDockable = tool;
+
+        factory.AddDockable(root, documentDock);
+        factory.AddDockable(root, toolDock);
+
+        root.ActiveDockable = documentDock;
+        root.DefaultDockable = documentDock;
+
+        var documentRef = new WeakReference(document);
+        var toolRef = new WeakReference(tool);
+
+        factory.CloseDockable(document);
+        factory.CloseDockable(tool);
+
+        root.ActiveDockable = null;
+        documentDock.ActiveDockable = null;
+        toolDock.ActiveDockable = null;
+
+        document = null!;
+        tool = null!;
+
+        AssertCollected(documentRef, toolRef);
+        GC.KeepAlive(factory);
+        GC.KeepAlive(root);
+        GC.KeepAlive(documentDock);
+        GC.KeepAlive(toolDock);
+    }
+}
diff --git a/tests/Dock.Model.Mvvm.LeakTests/LeakTestCollection.cs b/tests/Dock.Model.Mvvm.LeakTests/LeakTestCollection.cs
new file mode 100644
index 000000000..3edf87269
--- /dev/null
+++ b/tests/Dock.Model.Mvvm.LeakTests/LeakTestCollection.cs
@@ -0,0 +1,8 @@
+using Xunit;
+
+namespace Dock.Model.Mvvm.LeakTests;
+
+[CollectionDefinition("LeakTests", DisableParallelization = true)]
+public sealed class LeakTestCollection
+{
+}
diff --git a/tests/Dock.Model.Mvvm.LeakTests/LeakTestHelpers.cs b/tests/Dock.Model.Mvvm.LeakTests/LeakTestHelpers.cs
new file mode 100644
index 000000000..36b017610
--- /dev/null
+++ b/tests/Dock.Model.Mvvm.LeakTests/LeakTestHelpers.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Linq;
+using System.Threading;
+using Xunit;
+
+namespace Dock.Model.Mvvm.LeakTests;
+
+internal static class LeakTestHelpers
+{
+    internal static void AssertCollected(params WeakReference[] references)
+    {
+        for (var attempt = 0; attempt < 20 && references.Any(reference => reference.IsAlive); attempt++)
+        {
+            CollectGarbage();
+            Thread.Sleep(10);
+        }
+
+        foreach (var reference in references)
+        {
+            Assert.False(reference.IsAlive);
+        }
+    }
+
+    internal static void CollectGarbage()
+    {
+        GC.Collect();
+        GC.WaitForPendingFinalizers();
+        GC.Collect();
+    }
+}
diff --git a/tests/Dock.Model.Mvvm.LeakTests/LeakTests.cs b/tests/Dock.Model.Mvvm.LeakTests/LeakTests.cs
new file mode 100644
index 000000000..50739bda2
--- /dev/null
+++ b/tests/Dock.Model.Mvvm.LeakTests/LeakTests.cs
@@ -0,0 +1,85 @@
+using System;
+using Dock.Model;
+using Dock.Model.Core;
+using Dock.Model.Mvvm;
+using Xunit;
+using static Dock.Model.Mvvm.LeakTests.LeakTestHelpers;
+
+namespace Dock.Model.Mvvm.LeakTests;
+
+[Collection("LeakTests")]
+public class LeakTests
+{
+    private sealed class StubSerializer : IDockSerializer
+    {
+        public string Serialize<T>(T value) => throw new NotSupportedException();
+
+        public T? Deserialize<T>(string text) => throw new NotSupportedException();
+
+        public T? Load<T>(System.IO.Stream stream) => throw new NotSupportedException();
+
+        public void Save<T>(System.IO.Stream stream, T value) => throw new NotSupportedException();
+    }
+
+    [ReleaseFact]
+    public void StopTracking_DoesNotLeak_Manager()
+    {
+        var factory = new Factory();
+        var managerRef = CreateStoppedManager(factory);
+
+        AssertCollected(managerRef);
+        GC.KeepAlive(factory);
+    }
+
+    [ReleaseFact]
+    public void TrackLayout_Swap_DoesNotLeak_PreviousLayout()
+    {
+        var result = CreateLayoutSwap();
+
+        AssertCollected(result.LayoutARef, result.FactoryARef);
+        GC.KeepAlive(result.Manager);
+        GC.KeepAlive(result.FactoryB);
+        GC.KeepAlive(result.LayoutB);
+    }
+
+    private static WeakReference CreateStoppedManager(Factory factory)
+    {
+        var layout = factory.CreateLayout();
+        layout.Factory = factory;
+
+        var manager = new DockWorkspaceManager(new StubSerializer());
+        manager.TrackLayout(layout);
+        manager.StopTracking();
+
+        return new WeakReference(manager);
+    }
+
+    private static LayoutSwapResult CreateLayoutSwap()
+    {
+        var manager = new DockWorkspaceManager(new StubSerializer());
+
+        var factoryA = new Factory();
+        var layoutA = factoryA.CreateLayout();
+        layoutA.Factory = factoryA;
+        manager.TrackLayout(layoutA);
+
+        var factoryB = new Factory();
+        var layoutB = factoryB.CreateLayout();
+        layoutB.Factory = factoryB;
+        manager.TrackLayout(layoutB);
+
+        return new LayoutSwapResult(
+            new WeakReference(layoutA),
+            new WeakReference(factoryA),
+            manager,
+            factoryB,
+            layoutB);
+    }
+
+    private sealed record LayoutSwapResult(
+        WeakReference LayoutARef,
+        WeakReference FactoryARef,
+        DockWorkspaceManager Manager,
+        Factory FactoryB,
+        IDock LayoutB);
+}
diff --git a/tests/Dock.Model.Mvvm.LeakTests/ReleaseFact.cs b/tests/Dock.Model.Mvvm.LeakTests/ReleaseFact.cs
new file mode 100644
index 000000000..ddcacf4aa
--- /dev/null
+++ b/tests/Dock.Model.Mvvm.LeakTests/ReleaseFact.cs
@@ -0,0 +1,18 @@
+using System;
+using Xunit;
+
+namespace Dock.Model.Mvvm.LeakTests;
+
+/// <summary>
+/// Release-only fact for leak tests that are skipped in Debug builds.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+internal sealed class ReleaseFactAttribute : FactAttribute
+{
+    public ReleaseFactAttribute()
+    {
+#if DEBUG
+        Skip = "Only runs in Release mode";
+#endif
+    }
+}
diff --git a/tests/Dock.Model.ReactiveUI.LeakTests/Dock.Model.ReactiveUI.LeakTests.csproj b/tests/Dock.Model.ReactiveUI.LeakTests/Dock.Model.ReactiveUI.LeakTests.csproj
new file mode 100644
index 000000000..4696a1242
--- /dev/null
+++ b/tests/Dock.Model.ReactiveUI.LeakTests/Dock.Model.ReactiveUI.LeakTests.csproj
@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk" ToolsVersion="15.0">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <OutputType>Library</OutputType>
+    <IsPackable>False</IsPackable>
+    <IsTestProject>True</IsTestProject>
+    <GenerateAssemblyInfo>False</GenerateAssemblyInfo>
+    <GenerateRuntimeConfigurationFiles>True</GenerateRuntimeConfigurationFiles>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <Import Project="..\..\build\XUnit.props" />
+  <Import Project="..\..\build\ReactiveUI.props" />
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Dock.Model\Dock.Model.csproj" />
+    <ProjectReference Include="..\..\src\Dock.Model.ReactiveUI\Dock.Model.ReactiveUI.csproj" />
+    <ProjectReference Include="..\..\src\Dock.Model.ReactiveUI.Services\Dock.Model.ReactiveUI.Services.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/Dock.Model.ReactiveUI.LeakTests/DockableLeakTests.cs b/tests/Dock.Model.ReactiveUI.LeakTests/DockableLeakTests.cs
new file mode 100644
index 000000000..bf55ac10f
--- /dev/null
+++ b/tests/Dock.Model.ReactiveUI.LeakTests/DockableLeakTests.cs
@@ -0,0 +1,67 @@
+using System;
+using Dock.Model.Controls;
+using Dock.Model.Core;
+using Dock.Model.ReactiveUI;
+using Xunit;
+using static Dock.Model.ReactiveUI.LeakTests.LeakTestHelpers;
+
+namespace Dock.Model.ReactiveUI.LeakTests;
+
+[Collection("LeakTests")]
+public class DockableLeakTests
+{
+    [ReleaseFact]
+    public void CloseDockable_DoesNotLeak_DocumentAndTool()
+    {
+        var factory = new Factory();
+
+        var root = factory.CreateRootDock();
+        root.Factory = factory;
+        root.VisibleDockables = factory.CreateList<IDockable>();
+        root.HiddenDockables = factory.CreateList<IDockable>();
+        root.Windows = factory.CreateList<IDockWindow>();
+
+        var documentDock = factory.CreateDocumentDock();
+        documentDock.Factory = factory;
+        documentDock.VisibleDockables = factory.CreateList<IDockable>();
+
+        IDocument document = factory.CreateDocument();
+        document.Factory = factory;
+        factory.AddDockable(documentDock, document);
+        documentDock.ActiveDockable = document;
+
+        var toolDock = factory.CreateToolDock();
+        toolDock.Factory = factory;
+        toolDock.VisibleDockables = factory.CreateList<IDockable>();
+
+        ITool tool = factory.CreateTool();
+        tool.Factory = factory;
+        factory.AddDockable(toolDock, tool);
+        toolDock.ActiveDockable = tool;
+
+        factory.AddDockable(root, documentDock);
+        factory.AddDockable(root, toolDock);
+
+        root.ActiveDockable = documentDock;
+        root.DefaultDockable = documentDock;
+
+        var documentRef = new WeakReference(document);
+        var toolRef = new WeakReference(tool);
+
+        factory.CloseDockable(document);
+        factory.CloseDockable(tool);
+
+        root.ActiveDockable = null;
+        documentDock.ActiveDockable = null;
+        toolDock.ActiveDockable = null;
+
+        document = null!;
+        tool = null!;
+
+        AssertCollected(documentRef, toolRef);
+        GC.KeepAlive(factory);
+        GC.KeepAlive(root);
+        GC.KeepAlive(documentDock);
+        GC.KeepAlive(toolDock);
+    }
+}
diff --git a/tests/Dock.Model.ReactiveUI.LeakTests/LeakTestCollection.cs b/tests/Dock.Model.ReactiveUI.LeakTests/LeakTestCollection.cs
new file mode 100644
index 000000000..cf8d163f4
--- /dev/null
+++ b/tests/Dock.Model.ReactiveUI.LeakTests/LeakTestCollection.cs
@@ -0,0 +1,8 @@
+using Xunit;
+
+namespace Dock.Model.ReactiveUI.LeakTests;
+
+[CollectionDefinition("LeakTests", DisableParallelization = true)]
+public sealed class LeakTestCollection
+{
+}
diff --git a/tests/Dock.Model.ReactiveUI.LeakTests/LeakTestHelpers.cs b/tests/Dock.Model.ReactiveUI.LeakTests/LeakTestHelpers.cs
new file mode 100644
index 000000000..45a96a043
--- /dev/null
+++ b/tests/Dock.Model.ReactiveUI.LeakTests/LeakTestHelpers.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Linq;
+using System.Threading;
+using Xunit;
+
+namespace Dock.Model.ReactiveUI.LeakTests;
+
+internal static class LeakTestHelpers
+{
+    internal static void AssertCollected(params WeakReference[] references)
+    {
+        for (var attempt = 0; attempt < 20 && references.Any(reference => reference.IsAlive); attempt++)
+        {
+            CollectGarbage();
+            Thread.Sleep(10);
+        }
+
+        foreach (var reference in references)
+        {
+            Assert.False(reference.IsAlive);
+        }
+    }
+
+    internal static void CollectGarbage()
+    {
+        GC.Collect();
+        GC.WaitForPendingFinalizers();
+        GC.Collect();
+    }
+}
diff --git a/tests/Dock.Model.ReactiveUI.LeakTests/LeakTests.cs b/tests/Dock.Model.ReactiveUI.LeakTests/LeakTests.cs
new file mode 100644
index 000000000..11f6ee0df
--- /dev/null
+++ b/tests/Dock.Model.ReactiveUI.LeakTests/LeakTests.cs
@@ -0,0 +1,85 @@
+using System;
+using Dock.Model;
+using Dock.Model.Core;
+using Dock.Model.ReactiveUI;
+using Xunit;
+using static Dock.Model.ReactiveUI.LeakTests.LeakTestHelpers;
+
+namespace Dock.Model.ReactiveUI.LeakTests;
+
+[Collection("LeakTests")]
+public class LeakTests
+{
+    private sealed class StubSerializer : IDockSerializer
+    {
+        public string Serialize<T>(T value) => throw new NotSupportedException();
+
+        public T? Deserialize<T>(string text) => throw new NotSupportedException();
+
+        public T? Load<T>(System.IO.Stream stream) => throw new NotSupportedException();
+
+        public void Save<T>(System.IO.Stream stream, T value) => throw new NotSupportedException();
+    }
+
+    [ReleaseFact]
+    public void StopTracking_DoesNotLeak_Manager()
+    {
+        var factory = new Factory();
+        var managerRef = CreateStoppedManager(factory);
+
+        AssertCollected(managerRef);
+        GC.KeepAlive(factory);
+    }
+
+    [ReleaseFact]
+    public void TrackLayout_Swap_DoesNotLeak_PreviousLayout()
+    {
+        var result = CreateLayoutSwap();
+
+        AssertCollected(result.LayoutARef, result.FactoryARef);
+        GC.KeepAlive(result.Manager);
+        GC.KeepAlive(result.FactoryB);
+        GC.KeepAlive(result.LayoutB);
+    }
+
+    private static WeakReference CreateStoppedManager(Factory factory)
+    {
+        var layout = factory.CreateLayout();
+        layout.Factory = factory;
+
+        var manager = new DockWorkspaceManager(new StubSerializer());
+        manager.TrackLayout(layout);
+        manager.StopTracking();
+
+        return new WeakReference(manager);
+    }
+
+    private static LayoutSwapResult CreateLayoutSwap()
+    {
+        var manager = new DockWorkspaceManager(new StubSerializer());
+
+        var factoryA = new Factory();
+        var layoutA = factoryA.CreateLayout();
+        layoutA.Factory = factoryA;
+        manager.TrackLayout(layoutA);
+
+        var factoryB = new Factory();
+        var layoutB = factoryB.CreateLayout();
+        layoutB.Factory = factoryB;
+        manager.TrackLayout(layoutB);
+
+        return new LayoutSwapResult(
+            new WeakReference(layoutA),
+            new WeakReference(factoryA),
+            manager,
+            factoryB,
+            layoutB);
+    }
+
+    private sealed record LayoutSwapResult(
+        WeakReference LayoutARef,
+        WeakReference FactoryARef,
+        DockWorkspaceManager Manager,
+        Factory FactoryB,
+        IDock LayoutB);
+}
diff --git a/tests/Dock.Model.ReactiveUI.LeakTests/ReleaseFact.cs b/tests/Dock.Model.ReactiveUI.LeakTests/ReleaseFact.cs
new file mode 100644
index 000000000..6d1ff900a
--- /dev/null
+++ b/tests/Dock.Model.ReactiveUI.LeakTests/ReleaseFact.cs
@@ -0,0 +1,18 @@
+using System;
+using Xunit;
+
+namespace Dock.Model.ReactiveUI.LeakTests;
+
+/// <summary>
+/// Release-only fact for leak tests that are skipped in Debug builds.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+internal sealed class ReleaseFactAttribute : FactAttribute
+{
+    public ReleaseFactAttribute()
+    {
+#if DEBUG
+        Skip = "Only runs in Release mode";
+#endif
+    }
+}