From ee6035316ac3597e2bb5259f91e89fcf06fae504 Mon Sep 17 00:00:00 2001
From: HadenSmith <cole.h.smith@usace.army.mil>
Date: Tue, 23 Jun 2026 11:39:18 -0600
Subject: [PATCH 01/11] fix: keep read-only data grid cells selectable

---
 .../Themes/GenericControlsTheme.xaml          |   8 +-
 src/Themes/Resources/Controls/DataGrid.xaml   |   2 -
 .../Controls/DataGridThemeSelectionTests.cs   | 124 ++++++++++++++++++
 .../Core/DataGridReadOnlyCellStyleTests.cs    | 100 ++++++++++++++
 4 files changed, 231 insertions(+), 3 deletions(-)
 create mode 100644 tests/GenericControls.Tests/Controls/DataGridThemeSelectionTests.cs
 create mode 100644 tests/Themes.Tests/Core/DataGridReadOnlyCellStyleTests.cs

diff --git a/src/GenericControls/Themes/GenericControlsTheme.xaml b/src/GenericControls/Themes/GenericControlsTheme.xaml
index a4f9585e..87450e1f 100644
--- a/src/GenericControls/Themes/GenericControlsTheme.xaml
+++ b/src/GenericControls/Themes/GenericControlsTheme.xaml
@@ -451,7 +451,7 @@
     <!-- Center-aligned Read-Only Cell Style -->
     <Style x:Key="Center_ReadOnly_CellStyle" TargetType="{x:Type DataGridCell}">
         <Setter Property="TextBlock.TextAlignment" Value="Center"/>
-        <Setter Property="TextBlock.Background" Value="{DynamicResource EnvironmentWindowBackground}"/>
+        <Setter Property="Foreground" Value="{DynamicResource EnvironmentToolWindowDisabledText}"/>
     </Style>
 
     <!-- Right-aligned Cell Style -->
@@ -459,6 +459,12 @@
         <Setter Property="TextBlock.TextAlignment" Value="Right"/>
     </Style>
 
+    <!-- Right-aligned Read-Only Cell Style -->
+    <Style x:Key="Right_ReadOnly_CellStyle" TargetType="{x:Type DataGridCell}">
+        <Setter Property="TextBlock.TextAlignment" Value="Right"/>
+        <Setter Property="Foreground" Value="{DynamicResource EnvironmentToolWindowDisabledText}"/>
+    </Style>
+
     <!-- Disabled Cell Style -->
     <Style x:Key="Disabled_CellStyle" TargetType="{x:Type DataGridCell}">
         <Setter Property="TextBlock.TextAlignment" Value="Center"/>
diff --git a/src/Themes/Resources/Controls/DataGrid.xaml b/src/Themes/Resources/Controls/DataGrid.xaml
index 448be485..ba99b9b8 100644
--- a/src/Themes/Resources/Controls/DataGrid.xaml
+++ b/src/Themes/Resources/Controls/DataGrid.xaml
@@ -25,7 +25,6 @@
     <Style x:Key="Center_ReadOnly_CellStyle" TargetType="{x:Type DataGridCell}">
         <Setter Property="TextBlock.TextAlignment" Value="Center"/>
         <Setter Property="Foreground" Value="{DynamicResource EnvironmentToolWindowDisabledText}"/>
-        <Setter Property="IsHitTestVisible" Value="False"/>
     </Style>
 
     <Style x:Key="Right_CellStyle" TargetType="{x:Type DataGridCell}">
@@ -35,7 +34,6 @@
     <Style x:Key="Right_ReadOnly_CellStyle" TargetType="{x:Type DataGridCell}">
         <Setter Property="TextBlock.TextAlignment" Value="Right"/>
         <Setter Property="Foreground" Value="{DynamicResource EnvironmentToolWindowDisabledText}"/>
-        <Setter Property="IsHitTestVisible" Value="False"/>
     </Style>
 
     <Style x:Key="Disabled_CellStyle" TargetType="{x:Type DataGridCell}">
diff --git a/tests/GenericControls.Tests/Controls/DataGridThemeSelectionTests.cs b/tests/GenericControls.Tests/Controls/DataGridThemeSelectionTests.cs
new file mode 100644
index 00000000..bead7cac
--- /dev/null
+++ b/tests/GenericControls.Tests/Controls/DataGridThemeSelectionTests.cs
@@ -0,0 +1,124 @@
+using System.IO;
+using System.Xml.Linq;
+using Xunit;
+
+namespace GenericControls.Tests.Controls;
+
+/// <summary>
+/// Regression tests for GenericControls DataGrid selection styling.
+/// </summary>
+public class DataGridThemeSelectionTests
+{
+    private static readonly XNamespace PresentationNamespace = "http://schemas.microsoft.com/winfx/2006/xaml/presentation";
+    private static readonly XNamespace XamlNamespace = "http://schemas.microsoft.com/winfx/2006/xaml";
+
+    /// <summary>
+    /// Verifies read-only helper styles remain hit-testable for mouse selection.
+    /// </summary>
+    /// <param name="styleKey">The read-only cell style key.</param>
+    [Theory]
+    [InlineData("Center_ReadOnly_CellStyle")]
+    [InlineData("Right_ReadOnly_CellStyle")]
+    public void ReadOnlyCellStyle_DoesNotDisableHitTesting(string styleKey)
+    {
+        XElement style = GetStyle(styleKey);
+
+        Assert.DoesNotContain(
+            style.Elements(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "IsHitTestVisible", "False"));
+    }
+
+    /// <summary>
+    /// Verifies the disabled cell helper remains disabled.
+    /// </summary>
+    [Fact]
+    public void DisabledCellStyle_DisablesCells()
+    {
+        XElement style = GetStyle("Disabled_CellStyle");
+
+        Assert.Contains(
+            style.Elements(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "IsEnabled", "False"));
+    }
+
+    /// <summary>
+    /// Verifies the grid-level styles use selectable cell styles.
+    /// </summary>
+    /// <param name="gridStyleKey">The grid style key.</param>
+    /// <param name="cellStyleKey">The expected cell style key.</param>
+    [Theory]
+    [InlineData("CopyPasteDataGridStyle", "CopyPasteDataGridCellStyle")]
+    [InlineData("ValidationDataGridStyle", "ValidationDataGridCellStyle")]
+    public void DataGridStyle_UsesSelectableCellStyle(string gridStyleKey, string cellStyleKey)
+    {
+        XElement gridStyle = GetStyle(gridStyleKey);
+        XElement cellStyle = GetStyle(cellStyleKey);
+
+        Assert.Contains(
+            gridStyle.Elements(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "CellStyle", "{StaticResource " + cellStyleKey + "}"));
+        Assert.Contains(
+            cellStyle.Descendants(PresentationNamespace + "Trigger"),
+            trigger => HasSetter(trigger, "IsSelected", "True"));
+        Assert.DoesNotContain(
+            cellStyle.Elements(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "IsHitTestVisible", "False"));
+    }
+
+    /// <summary>
+    /// Finds a style in the GenericControls resource dictionary.
+    /// </summary>
+    /// <param name="styleKey">The style key to find.</param>
+    /// <returns>The style element.</returns>
+    private static XElement GetStyle(string styleKey)
+    {
+        XDocument document = XDocument.Load(ResolveRepoPath("src/GenericControls/Themes/GenericControlsTheme.xaml"));
+        XElement? style = document
+            .Descendants(PresentationNamespace + "Style")
+            .FirstOrDefault(element => (string?)element.Attribute(XamlNamespace + "Key") == styleKey);
+
+        Assert.NotNull(style);
+        return style!;
+    }
+
+    /// <summary>
+    /// Determines whether an element has the expected property and value.
+    /// </summary>
+    /// <param name="element">The element to inspect.</param>
+    /// <param name="property">The expected property.</param>
+    /// <param name="value">The expected value.</param>
+    /// <returns><c>true</c> when the element matches.</returns>
+    private static bool HasSetter(XElement element, string property, string value)
+    {
+        return (string?)element.Attribute("Property") == property
+            && (string?)element.Attribute("Value") == value;
+    }
+
+    /// <summary>
+    /// Resolves a repository-relative path from the test output directory.
+    /// </summary>
+    /// <param name="repoRelativePath">The repository-relative path.</param>
+    /// <returns>The absolute path.</returns>
+    private static string ResolveRepoPath(string repoRelativePath)
+    {
+        string current = AppContext.BaseDirectory;
+        while (!string.IsNullOrEmpty(current))
+        {
+            if (File.Exists(Path.Combine(current, "WPF-Framework.sln")))
+            {
+                return Path.Combine(current, repoRelativePath.Replace('/', Path.DirectorySeparatorChar));
+            }
+
+            string? parent = Path.GetDirectoryName(current);
+            if (parent == current)
+            {
+                break;
+            }
+
+            current = parent!;
+        }
+
+        throw new InvalidOperationException(
+            $"Could not locate repository root (looking for WPF-Framework.sln) starting from {AppContext.BaseDirectory}");
+    }
+}
diff --git a/tests/Themes.Tests/Core/DataGridReadOnlyCellStyleTests.cs b/tests/Themes.Tests/Core/DataGridReadOnlyCellStyleTests.cs
new file mode 100644
index 00000000..7a5d988b
--- /dev/null
+++ b/tests/Themes.Tests/Core/DataGridReadOnlyCellStyleTests.cs
@@ -0,0 +1,100 @@
+using System.IO;
+using System.Xml.Linq;
+using Xunit;
+
+namespace Themes.Tests.Core;
+
+/// <summary>
+/// Regression tests for shared DataGrid read-only cell styles.
+/// </summary>
+public class DataGridReadOnlyCellStyleTests
+{
+    private static readonly XNamespace PresentationNamespace = "http://schemas.microsoft.com/winfx/2006/xaml/presentation";
+    private static readonly XNamespace XamlNamespace = "http://schemas.microsoft.com/winfx/2006/xaml";
+
+    /// <summary>
+    /// Verifies read-only cell styles remain selectable by mouse.
+    /// </summary>
+    /// <param name="styleKey">The read-only cell style key.</param>
+    [Theory]
+    [InlineData("Center_ReadOnly_CellStyle")]
+    [InlineData("Right_ReadOnly_CellStyle")]
+    public void ReadOnlyCellStyle_DoesNotDisableHitTesting(string styleKey)
+    {
+        XElement style = GetStyle(styleKey);
+
+        Assert.DoesNotContain(
+            style.Elements(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "IsHitTestVisible", "False"));
+    }
+
+    /// <summary>
+    /// Verifies the disabled cell style still disables interaction.
+    /// </summary>
+    [Fact]
+    public void DisabledCellStyle_DisablesCells()
+    {
+        XElement style = GetStyle("Disabled_CellStyle");
+
+        Assert.Contains(
+            style.Elements(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "IsEnabled", "False"));
+    }
+
+    /// <summary>
+    /// Finds a style in the shared DataGrid resource dictionary.
+    /// </summary>
+    /// <param name="styleKey">The style key to find.</param>
+    /// <returns>The style element.</returns>
+    private static XElement GetStyle(string styleKey)
+    {
+        XDocument document = XDocument.Load(ResolveRepoPath("src/Themes/Resources/Controls/DataGrid.xaml"));
+        XElement? style = document
+            .Descendants(PresentationNamespace + "Style")
+            .FirstOrDefault(element => (string?)element.Attribute(XamlNamespace + "Key") == styleKey);
+
+        Assert.NotNull(style);
+        return style!;
+    }
+
+    /// <summary>
+    /// Determines whether a setter has the expected property and value.
+    /// </summary>
+    /// <param name="setter">The setter element.</param>
+    /// <param name="property">The expected property.</param>
+    /// <param name="value">The expected value.</param>
+    /// <returns><c>true</c> when the setter matches.</returns>
+    private static bool HasSetter(XElement setter, string property, string value)
+    {
+        return (string?)setter.Attribute("Property") == property
+            && (string?)setter.Attribute("Value") == value;
+    }
+
+    /// <summary>
+    /// Resolves a repository-relative path from the test output directory.
+    /// </summary>
+    /// <param name="repoRelativePath">The repository-relative path.</param>
+    /// <returns>The absolute path.</returns>
+    private static string ResolveRepoPath(string repoRelativePath)
+    {
+        string current = AppContext.BaseDirectory;
+        while (!string.IsNullOrEmpty(current))
+        {
+            if (File.Exists(Path.Combine(current, "WPF-Framework.sln")))
+            {
+                return Path.Combine(current, repoRelativePath.Replace('/', Path.DirectorySeparatorChar));
+            }
+
+            string? parent = Path.GetDirectoryName(current);
+            if (parent == current)
+            {
+                break;
+            }
+
+            current = parent!;
+        }
+
+        throw new InvalidOperationException(
+            $"Could not locate repository root (looking for WPF-Framework.sln) starting from {AppContext.BaseDirectory}");
+    }
+}

From 4ae90b9bbc82f1b96c18f4d37c5c235561ab14c3 Mon Sep 17 00:00:00 2001
From: HadenSmith <cole.h.smith@usace.army.mil>
Date: Tue, 23 Jun 2026 12:31:53 -0600
Subject: [PATCH 02/11] fix: theme inactive data grid cell selection

---
 .../Themes/GenericControlsTheme.xaml          | 185 +++++++-----------
 src/Themes/Resources/Controls/DataGrid.xaml   |  91 ++++-----
 .../Controls/DataGridThemeSelectionTests.cs   |  45 ++++-
 .../Core/DataGridReadOnlyCellStyleTests.cs    |  40 ++++
 4 files changed, 195 insertions(+), 166 deletions(-)

diff --git a/src/GenericControls/Themes/GenericControlsTheme.xaml b/src/GenericControls/Themes/GenericControlsTheme.xaml
index 87450e1f..dd37f50c 100644
--- a/src/GenericControls/Themes/GenericControlsTheme.xaml
+++ b/src/GenericControls/Themes/GenericControlsTheme.xaml
@@ -438,29 +438,88 @@
     <!-- DATAGRID CELL STYLES (Backward Compatible)                                   -->
     <!-- ═══════════════════════════════════════════════════════════════════════════ -->
 
+    <!-- Selectable DataGrid Cell Style shared by grid-level and manual column styles -->
+    <Style x:Key="SelectableDataGridCellStyle" TargetType="{x:Type DataGridCell}">
+        <Setter Property="Foreground" Value="{Binding Foreground, RelativeSource={RelativeSource AncestorType=DataGridRow}}"/>
+        <Setter Property="BorderThickness" Value="0"/>
+        <Setter Property="FocusVisualStyle" Value="{x:Null}"/>
+        <Setter Property="VerticalContentAlignment" Value="Center"/>
+        <!-- Custom template to prevent default WPF template from using SystemColors for inactive selection -->
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type DataGridCell}">
+                    <ControlTemplate.Resources>
+                        <!-- Implicit TextBox style for editing cells. WPF DataGrid creates the
+                             editing TextBox outside the visual tree, so it does not reliably
+                             inherit the application-level implicit TextBox style. Defining it
+                             here ensures the editing TextBox uses theme-aware colors instead of
+                             the WPF default white background. Columns with an explicit
+                             EditingElementStyle override this implicit style. -->
+                        <Style TargetType="{x:Type TextBox}">
+                            <Setter Property="Background" Value="{DynamicResource TextBox.Static.Background}"/>
+                            <Setter Property="Foreground" Value="{DynamicResource EnvironmentToolWindowText}"/>
+                            <Setter Property="CaretBrush" Value="{DynamicResource TextBox.Caret}"/>
+                            <Setter Property="SelectionBrush" Value="{DynamicResource TextBox.Selection.Background}"/>
+                            <Setter Property="BorderThickness" Value="0"/>
+                            <Setter Property="Padding" Value="0"/>
+                            <Setter Property="VerticalContentAlignment" Value="Center"/>
+                        </Style>
+                    </ControlTemplate.Resources>
+                    <Border Background="{TemplateBinding Background}"
+                            BorderBrush="{TemplateBinding BorderBrush}"
+                            BorderThickness="{TemplateBinding BorderThickness}"
+                            SnapsToDevicePixels="True">
+                        <ContentPresenter SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"/>
+                    </Border>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+        <Style.Triggers>
+            <!-- Cell selection highlighting for extended selection mode -->
+            <Trigger Property="IsSelected" Value="True">
+                <Setter Property="Background" Value="{DynamicResource DataGrid.Row.Selection.Background}"/>
+                <Setter Property="Foreground" Value="{DynamicResource DataGrid.Row.Selection.Foreground}"/>
+            </Trigger>
+            <!-- Inactive selection (when DataGrid loses focus) -->
+            <MultiTrigger>
+                <MultiTrigger.Conditions>
+                    <Condition Property="IsSelected" Value="True"/>
+                    <Condition Property="Selector.IsSelectionActive" Value="False"/>
+                </MultiTrigger.Conditions>
+                <Setter Property="Background" Value="{DynamicResource DataGrid.Row.Selection.Inactive.Background}"/>
+                <Setter Property="Foreground" Value="{DynamicResource DataGrid.Row.Selection.Inactive.Foreground}"/>
+            </MultiTrigger>
+            <!-- Focus border for keyboard navigation -->
+            <Trigger Property="IsKeyboardFocusWithin" Value="True">
+                <Setter Property="BorderBrush" Value="{DynamicResource DataGrid.Cell.Focus.Border}"/>
+                <Setter Property="BorderThickness" Value="1"/>
+            </Trigger>
+        </Style.Triggers>
+    </Style>
+
     <!-- Left-aligned Cell Style -->
-    <Style x:Key="Left_CellStyle" TargetType="{x:Type DataGridCell}">
+    <Style x:Key="Left_CellStyle" TargetType="{x:Type DataGridCell}" BasedOn="{StaticResource SelectableDataGridCellStyle}">
         <Setter Property="TextBlock.TextAlignment" Value="Left"/>
     </Style>
 
     <!-- Center-aligned Cell Style -->
-    <Style x:Key="Center_CellStyle" TargetType="{x:Type DataGridCell}">
+    <Style x:Key="Center_CellStyle" TargetType="{x:Type DataGridCell}" BasedOn="{StaticResource SelectableDataGridCellStyle}">
         <Setter Property="TextBlock.TextAlignment" Value="Center"/>
     </Style>
 
     <!-- Center-aligned Read-Only Cell Style -->
-    <Style x:Key="Center_ReadOnly_CellStyle" TargetType="{x:Type DataGridCell}">
+    <Style x:Key="Center_ReadOnly_CellStyle" TargetType="{x:Type DataGridCell}" BasedOn="{StaticResource SelectableDataGridCellStyle}">
         <Setter Property="TextBlock.TextAlignment" Value="Center"/>
         <Setter Property="Foreground" Value="{DynamicResource EnvironmentToolWindowDisabledText}"/>
     </Style>
 
     <!-- Right-aligned Cell Style -->
-    <Style x:Key="Right_CellStyle" TargetType="{x:Type DataGridCell}">
+    <Style x:Key="Right_CellStyle" TargetType="{x:Type DataGridCell}" BasedOn="{StaticResource SelectableDataGridCellStyle}">
         <Setter Property="TextBlock.TextAlignment" Value="Right"/>
     </Style>
 
     <!-- Right-aligned Read-Only Cell Style -->
-    <Style x:Key="Right_ReadOnly_CellStyle" TargetType="{x:Type DataGridCell}">
+    <Style x:Key="Right_ReadOnly_CellStyle" TargetType="{x:Type DataGridCell}" BasedOn="{StaticResource SelectableDataGridCellStyle}">
         <Setter Property="TextBlock.TextAlignment" Value="Right"/>
         <Setter Property="Foreground" Value="{DynamicResource EnvironmentToolWindowDisabledText}"/>
     </Style>
@@ -789,63 +848,7 @@
     </Style>
 
     <!-- DataGrid Cell Style for CopyPasteDataGrid -->
-    <Style x:Key="CopyPasteDataGridCellStyle" TargetType="{x:Type DataGridCell}">
-        <Setter Property="Foreground" Value="{Binding Foreground, RelativeSource={RelativeSource AncestorType=DataGridRow}}"/>
-        <Setter Property="BorderThickness" Value="0"/>
-        <Setter Property="FocusVisualStyle" Value="{x:Null}"/>
-        <Setter Property="VerticalContentAlignment" Value="Center"/>
-        <!-- Custom template to prevent default WPF template from using SystemColors for inactive selection -->
-        <Setter Property="Template">
-            <Setter.Value>
-                <ControlTemplate TargetType="{x:Type DataGridCell}">
-                    <ControlTemplate.Resources>
-                        <!-- Implicit TextBox style for editing cells. WPF DataGrid creates the
-                             editing TextBox outside the visual tree, so it does not reliably
-                             inherit the application-level implicit TextBox style. Defining it
-                             here ensures the editing TextBox uses theme-aware colors instead of
-                             the WPF default white background. Columns with an explicit
-                             EditingElementStyle override this implicit style. -->
-                        <Style TargetType="{x:Type TextBox}">
-                            <Setter Property="Background" Value="{DynamicResource TextBox.Static.Background}"/>
-                            <Setter Property="Foreground" Value="{DynamicResource EnvironmentToolWindowText}"/>
-                            <Setter Property="CaretBrush" Value="{DynamicResource TextBox.Caret}"/>
-                            <Setter Property="SelectionBrush" Value="{DynamicResource TextBox.Selection.Background}"/>
-                            <Setter Property="BorderThickness" Value="0"/>
-                            <Setter Property="Padding" Value="0"/>
-                            <Setter Property="VerticalContentAlignment" Value="Center"/>
-                        </Style>
-                    </ControlTemplate.Resources>
-                    <Border Background="{TemplateBinding Background}"
-                            BorderBrush="{TemplateBinding BorderBrush}"
-                            BorderThickness="{TemplateBinding BorderThickness}"
-                            SnapsToDevicePixels="True">
-                        <ContentPresenter SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"/>
-                    </Border>
-                </ControlTemplate>
-            </Setter.Value>
-        </Setter>
-        <Style.Triggers>
-            <!-- Cell selection highlighting for extended selection mode -->
-            <Trigger Property="IsSelected" Value="True">
-                <Setter Property="Background" Value="{DynamicResource DataGrid.Row.Selection.Background}"/>
-                <Setter Property="Foreground" Value="{DynamicResource DataGrid.Row.Selection.Foreground}"/>
-            </Trigger>
-            <!-- Inactive selection (when DataGrid loses focus) -->
-            <MultiTrigger>
-                <MultiTrigger.Conditions>
-                    <Condition Property="IsSelected" Value="True"/>
-                    <Condition Property="Selector.IsSelectionActive" Value="False"/>
-                </MultiTrigger.Conditions>
-                <Setter Property="Background" Value="{DynamicResource DataGrid.Row.Selection.Inactive.Background}"/>
-                <Setter Property="Foreground" Value="{DynamicResource DataGrid.Row.Selection.Inactive.Foreground}"/>
-            </MultiTrigger>
-            <!-- Focus border for keyboard navigation -->
-            <Trigger Property="IsKeyboardFocusWithin" Value="True">
-                <Setter Property="BorderBrush" Value="{DynamicResource DataGrid.Cell.Focus.Border}"/>
-                <Setter Property="BorderThickness" Value="1"/>
-            </Trigger>
-        </Style.Triggers>
-    </Style>
+    <Style x:Key="CopyPasteDataGridCellStyle" TargetType="{x:Type DataGridCell}" BasedOn="{StaticResource SelectableDataGridCellStyle}"/>
 
     <Style x:Key="CopyPasteDataGridStyle" TargetType="{x:Type local:CopyPasteDataGrid}">
         <Setter Property="Background" Value="{DynamicResource EnvironmentWindowBackground}"/>
@@ -914,63 +917,7 @@
     </Style>
 
     <!-- DataGrid Cell Style for ValidationDataGrid (includes error handling) -->
-    <Style x:Key="ValidationDataGridCellStyle" TargetType="{x:Type DataGridCell}">
-        <Setter Property="Foreground" Value="{Binding Foreground, RelativeSource={RelativeSource AncestorType=DataGridRow}}"/>
-        <Setter Property="BorderThickness" Value="0"/>
-        <Setter Property="FocusVisualStyle" Value="{x:Null}"/>
-        <Setter Property="VerticalContentAlignment" Value="Center"/>
-        <!-- Custom template to prevent default WPF template from using SystemColors for inactive selection -->
-        <Setter Property="Template">
-            <Setter.Value>
-                <ControlTemplate TargetType="{x:Type DataGridCell}">
-                    <ControlTemplate.Resources>
-                        <!-- Implicit TextBox style for editing cells. WPF DataGrid creates the
-                             editing TextBox outside the visual tree, so it does not reliably
-                             inherit the application-level implicit TextBox style. Defining it
-                             here ensures the editing TextBox uses theme-aware colors instead of
-                             the WPF default white background. Columns with an explicit
-                             EditingElementStyle override this implicit style. -->
-                        <Style TargetType="{x:Type TextBox}">
-                            <Setter Property="Background" Value="{DynamicResource TextBox.Static.Background}"/>
-                            <Setter Property="Foreground" Value="{DynamicResource EnvironmentToolWindowText}"/>
-                            <Setter Property="CaretBrush" Value="{DynamicResource TextBox.Caret}"/>
-                            <Setter Property="SelectionBrush" Value="{DynamicResource TextBox.Selection.Background}"/>
-                            <Setter Property="BorderThickness" Value="0"/>
-                            <Setter Property="Padding" Value="0"/>
-                            <Setter Property="VerticalContentAlignment" Value="Center"/>
-                        </Style>
-                    </ControlTemplate.Resources>
-                    <Border Background="{TemplateBinding Background}"
-                            BorderBrush="{TemplateBinding BorderBrush}"
-                            BorderThickness="{TemplateBinding BorderThickness}"
-                            SnapsToDevicePixels="True">
-                        <ContentPresenter SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"/>
-                    </Border>
-                </ControlTemplate>
-            </Setter.Value>
-        </Setter>
-        <Style.Triggers>
-            <!-- Cell selection highlighting for extended selection mode -->
-            <Trigger Property="IsSelected" Value="True">
-                <Setter Property="Background" Value="{DynamicResource DataGrid.Row.Selection.Background}"/>
-                <Setter Property="Foreground" Value="{DynamicResource DataGrid.Row.Selection.Foreground}"/>
-            </Trigger>
-            <!-- Inactive selection (when DataGrid loses focus) -->
-            <MultiTrigger>
-                <MultiTrigger.Conditions>
-                    <Condition Property="IsSelected" Value="True"/>
-                    <Condition Property="Selector.IsSelectionActive" Value="False"/>
-                </MultiTrigger.Conditions>
-                <Setter Property="Background" Value="{DynamicResource DataGrid.Row.Selection.Inactive.Background}"/>
-                <Setter Property="Foreground" Value="{DynamicResource DataGrid.Row.Selection.Inactive.Foreground}"/>
-            </MultiTrigger>
-            <!-- Focus border for keyboard navigation -->
-            <Trigger Property="IsKeyboardFocusWithin" Value="True">
-                <Setter Property="BorderBrush" Value="{DynamicResource DataGrid.Cell.Focus.Border}"/>
-                <Setter Property="BorderThickness" Value="1"/>
-            </Trigger>
-        </Style.Triggers>
-    </Style>
+    <Style x:Key="ValidationDataGridCellStyle" TargetType="{x:Type DataGridCell}" BasedOn="{StaticResource SelectableDataGridCellStyle}"/>
 
     <Style x:Key="ValidationDataGridStyle" TargetType="{x:Type local:ValidationDataGrid}">
         <Setter Property="Background" Value="{DynamicResource EnvironmentWindowBackground}"/>
diff --git a/src/Themes/Resources/Controls/DataGrid.xaml b/src/Themes/Resources/Controls/DataGrid.xaml
index ba99b9b8..8ba097b6 100644
--- a/src/Themes/Resources/Controls/DataGrid.xaml
+++ b/src/Themes/Resources/Controls/DataGrid.xaml
@@ -13,25 +13,66 @@
     All colors use DynamicResource bindings for runtime theme switching.
     -->
 
+    <!-- Selectable DataGrid Cell Style shared by grid-level and manual column styles -->
+    <Style x:Key="SelectableDataGridCellStyle" TargetType="{x:Type DataGridCell}">
+        <Setter Property="Foreground" Value="{Binding Foreground, RelativeSource={RelativeSource AncestorType=DataGridRow}}"/>
+        <Setter Property="BorderThickness" Value="0"/>
+        <Setter Property="FocusVisualStyle" Value="{x:Null}"/>
+        <!-- Custom template to prevent default WPF template from using SystemColors for inactive selection -->
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type DataGridCell}">
+                    <Border Background="{TemplateBinding Background}"
+                            BorderBrush="{TemplateBinding BorderBrush}"
+                            BorderThickness="{TemplateBinding BorderThickness}"
+                            SnapsToDevicePixels="True">
+                        <ContentPresenter SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"/>
+                    </Border>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+        <Style.Triggers>
+            <!-- Cell selection highlighting for extended selection mode -->
+            <Trigger Property="IsSelected" Value="True">
+                <Setter Property="Background" Value="{DynamicResource DataGrid.Row.Selection.Background}"/>
+                <Setter Property="Foreground" Value="{DynamicResource DataGrid.Row.Selection.Foreground}"/>
+            </Trigger>
+            <!-- Inactive selection (when DataGrid loses focus) -->
+            <MultiTrigger>
+                <MultiTrigger.Conditions>
+                    <Condition Property="IsSelected" Value="True"/>
+                    <Condition Property="Selector.IsSelectionActive" Value="False"/>
+                </MultiTrigger.Conditions>
+                <Setter Property="Background" Value="{DynamicResource DataGrid.Row.Selection.Inactive.Background}"/>
+                <Setter Property="Foreground" Value="{DynamicResource DataGrid.Row.Selection.Inactive.Foreground}"/>
+            </MultiTrigger>
+            <!-- Focus border for keyboard navigation -->
+            <Trigger Property="IsKeyboardFocusWithin" Value="True">
+                <Setter Property="BorderBrush" Value="{DynamicResource DataGrid.Cell.Focus.Border}"/>
+                <Setter Property="BorderThickness" Value="1"/>
+            </Trigger>
+        </Style.Triggers>
+    </Style>
+
     <!-- Cell Alignment Styles -->
-    <Style x:Key="Left_CellStyle" TargetType="{x:Type DataGridCell}">
+    <Style x:Key="Left_CellStyle" TargetType="{x:Type DataGridCell}" BasedOn="{StaticResource SelectableDataGridCellStyle}">
         <Setter Property="TextBlock.TextAlignment" Value="Left"/>
     </Style>
 
-    <Style x:Key="Center_CellStyle" TargetType="{x:Type DataGridCell}">
+    <Style x:Key="Center_CellStyle" TargetType="{x:Type DataGridCell}" BasedOn="{StaticResource SelectableDataGridCellStyle}">
         <Setter Property="TextBlock.TextAlignment" Value="Center"/>
     </Style>
 
-    <Style x:Key="Center_ReadOnly_CellStyle" TargetType="{x:Type DataGridCell}">
+    <Style x:Key="Center_ReadOnly_CellStyle" TargetType="{x:Type DataGridCell}" BasedOn="{StaticResource SelectableDataGridCellStyle}">
         <Setter Property="TextBlock.TextAlignment" Value="Center"/>
         <Setter Property="Foreground" Value="{DynamicResource EnvironmentToolWindowDisabledText}"/>
     </Style>
 
-    <Style x:Key="Right_CellStyle" TargetType="{x:Type DataGridCell}">
+    <Style x:Key="Right_CellStyle" TargetType="{x:Type DataGridCell}" BasedOn="{StaticResource SelectableDataGridCellStyle}">
         <Setter Property="TextBlock.TextAlignment" Value="Right"/>
     </Style>
 
-    <Style x:Key="Right_ReadOnly_CellStyle" TargetType="{x:Type DataGridCell}">
+    <Style x:Key="Right_ReadOnly_CellStyle" TargetType="{x:Type DataGridCell}" BasedOn="{StaticResource SelectableDataGridCellStyle}">
         <Setter Property="TextBlock.TextAlignment" Value="Right"/>
         <Setter Property="Foreground" Value="{DynamicResource EnvironmentToolWindowDisabledText}"/>
     </Style>
@@ -254,45 +295,7 @@
     </Style>
 
     <!-- DataGrid Cell Style -->
-    <Style x:Key="DataGridCellStyle" TargetType="{x:Type DataGridCell}">
-        <Setter Property="Foreground" Value="{Binding Foreground, RelativeSource={RelativeSource AncestorType=DataGridRow}}"/>
-        <Setter Property="BorderThickness" Value="0"/>
-        <Setter Property="FocusVisualStyle" Value="{x:Null}"/>
-        <!-- Custom template to prevent default WPF template from using SystemColors for inactive selection -->
-        <Setter Property="Template">
-            <Setter.Value>
-                <ControlTemplate TargetType="{x:Type DataGridCell}">
-                    <Border Background="{TemplateBinding Background}"
-                            BorderBrush="{TemplateBinding BorderBrush}"
-                            BorderThickness="{TemplateBinding BorderThickness}"
-                            SnapsToDevicePixels="True">
-                        <ContentPresenter SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"/>
-                    </Border>
-                </ControlTemplate>
-            </Setter.Value>
-        </Setter>
-        <Style.Triggers>
-            <!-- Cell selection highlighting for extended selection mode -->
-            <Trigger Property="IsSelected" Value="True">
-                <Setter Property="Background" Value="{DynamicResource DataGrid.Row.Selection.Background}"/>
-                <Setter Property="Foreground" Value="{DynamicResource DataGrid.Row.Selection.Foreground}"/>
-            </Trigger>
-            <!-- Inactive selection (when DataGrid loses focus) -->
-            <MultiTrigger>
-                <MultiTrigger.Conditions>
-                    <Condition Property="IsSelected" Value="True"/>
-                    <Condition Property="Selector.IsSelectionActive" Value="False"/>
-                </MultiTrigger.Conditions>
-                <Setter Property="Background" Value="{DynamicResource DataGrid.Row.Selection.Inactive.Background}"/>
-                <Setter Property="Foreground" Value="{DynamicResource DataGrid.Row.Selection.Inactive.Foreground}"/>
-            </MultiTrigger>
-            <!-- Focus border for keyboard navigation -->
-            <Trigger Property="IsKeyboardFocusWithin" Value="True">
-                <Setter Property="BorderBrush" Value="{DynamicResource DataGrid.Cell.Focus.Border}"/>
-                <Setter Property="BorderThickness" Value="1"/>
-            </Trigger>
-        </Style.Triggers>
-    </Style>
+    <Style x:Key="DataGridCellStyle" TargetType="{x:Type DataGridCell}" BasedOn="{StaticResource SelectableDataGridCellStyle}"/>
 
     <!-- Select All Button Style (top-left corner) -->
     <Style x:Key="{ComponentResourceKey ResourceId=DataGridSelectAllButtonStyle, TypeInTargetAssembly={x:Type DataGrid}}" TargetType="{x:Type Button}">
diff --git a/tests/GenericControls.Tests/Controls/DataGridThemeSelectionTests.cs b/tests/GenericControls.Tests/Controls/DataGridThemeSelectionTests.cs
index bead7cac..cba5bd8e 100644
--- a/tests/GenericControls.Tests/Controls/DataGridThemeSelectionTests.cs
+++ b/tests/GenericControls.Tests/Controls/DataGridThemeSelectionTests.cs
@@ -12,6 +12,47 @@ public class DataGridThemeSelectionTests
     private static readonly XNamespace PresentationNamespace = "http://schemas.microsoft.com/winfx/2006/xaml/presentation";
     private static readonly XNamespace XamlNamespace = "http://schemas.microsoft.com/winfx/2006/xaml";
 
+    /// <summary>
+    /// Verifies selectable cell helper styles inherit the shared selectable base style.
+    /// </summary>
+    /// <param name="styleKey">The selectable cell style key.</param>
+    [Theory]
+    [InlineData("Left_CellStyle")]
+    [InlineData("Center_CellStyle")]
+    [InlineData("Center_ReadOnly_CellStyle")]
+    [InlineData("Right_CellStyle")]
+    [InlineData("Right_ReadOnly_CellStyle")]
+    [InlineData("CopyPasteDataGridCellStyle")]
+    [InlineData("ValidationDataGridCellStyle")]
+    public void SelectableCellStyles_InheritSelectableBaseStyle(string styleKey)
+    {
+        XElement style = GetStyle(styleKey);
+
+        Assert.Equal("{StaticResource SelectableDataGridCellStyle}", (string?)style.Attribute("BasedOn"));
+    }
+
+    /// <summary>
+    /// Verifies the selectable cell base style uses theme resources for active and inactive selection.
+    /// </summary>
+    [Fact]
+    public void SelectableDataGridCellStyle_UsesThemeSelectionResources()
+    {
+        XElement style = GetStyle("SelectableDataGridCellStyle");
+
+        Assert.Contains(
+            style.Descendants(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "Background", "{DynamicResource DataGrid.Row.Selection.Background}"));
+        Assert.Contains(
+            style.Descendants(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "Foreground", "{DynamicResource DataGrid.Row.Selection.Foreground}"));
+        Assert.Contains(
+            style.Descendants(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "Background", "{DynamicResource DataGrid.Row.Selection.Inactive.Background}"));
+        Assert.Contains(
+            style.Descendants(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "Foreground", "{DynamicResource DataGrid.Row.Selection.Inactive.Foreground}"));
+    }
+
     /// <summary>
     /// Verifies read-only helper styles remain hit-testable for mouse selection.
     /// </summary>
@@ -57,9 +98,7 @@ public void DataGridStyle_UsesSelectableCellStyle(string gridStyleKey, string ce
         Assert.Contains(
             gridStyle.Elements(PresentationNamespace + "Setter"),
             setter => HasSetter(setter, "CellStyle", "{StaticResource " + cellStyleKey + "}"));
-        Assert.Contains(
-            cellStyle.Descendants(PresentationNamespace + "Trigger"),
-            trigger => HasSetter(trigger, "IsSelected", "True"));
+        Assert.Equal("{StaticResource SelectableDataGridCellStyle}", (string?)cellStyle.Attribute("BasedOn"));
         Assert.DoesNotContain(
             cellStyle.Elements(PresentationNamespace + "Setter"),
             setter => HasSetter(setter, "IsHitTestVisible", "False"));
diff --git a/tests/Themes.Tests/Core/DataGridReadOnlyCellStyleTests.cs b/tests/Themes.Tests/Core/DataGridReadOnlyCellStyleTests.cs
index 7a5d988b..ca787a83 100644
--- a/tests/Themes.Tests/Core/DataGridReadOnlyCellStyleTests.cs
+++ b/tests/Themes.Tests/Core/DataGridReadOnlyCellStyleTests.cs
@@ -12,6 +12,46 @@ public class DataGridReadOnlyCellStyleTests
     private static readonly XNamespace PresentationNamespace = "http://schemas.microsoft.com/winfx/2006/xaml/presentation";
     private static readonly XNamespace XamlNamespace = "http://schemas.microsoft.com/winfx/2006/xaml";
 
+    /// <summary>
+    /// Verifies selectable cell helper styles inherit the shared selectable base style.
+    /// </summary>
+    /// <param name="styleKey">The selectable cell style key.</param>
+    [Theory]
+    [InlineData("Left_CellStyle")]
+    [InlineData("Center_CellStyle")]
+    [InlineData("Center_ReadOnly_CellStyle")]
+    [InlineData("Right_CellStyle")]
+    [InlineData("Right_ReadOnly_CellStyle")]
+    [InlineData("DataGridCellStyle")]
+    public void SelectableCellStyles_InheritSelectableBaseStyle(string styleKey)
+    {
+        XElement style = GetStyle(styleKey);
+
+        Assert.Equal("{StaticResource SelectableDataGridCellStyle}", (string?)style.Attribute("BasedOn"));
+    }
+
+    /// <summary>
+    /// Verifies the selectable cell base style uses theme resources for active and inactive selection.
+    /// </summary>
+    [Fact]
+    public void SelectableDataGridCellStyle_UsesThemeSelectionResources()
+    {
+        XElement style = GetStyle("SelectableDataGridCellStyle");
+
+        Assert.Contains(
+            style.Descendants(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "Background", "{DynamicResource DataGrid.Row.Selection.Background}"));
+        Assert.Contains(
+            style.Descendants(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "Foreground", "{DynamicResource DataGrid.Row.Selection.Foreground}"));
+        Assert.Contains(
+            style.Descendants(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "Background", "{DynamicResource DataGrid.Row.Selection.Inactive.Background}"));
+        Assert.Contains(
+            style.Descendants(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "Foreground", "{DynamicResource DataGrid.Row.Selection.Inactive.Foreground}"));
+    }
+
     /// <summary>
     /// Verifies read-only cell styles remain selectable by mouse.
     /// </summary>

From 578205c5ee0497b3f936110a74ad77f798501f4f Mon Sep 17 00:00:00 2001
From: HadenSmith <cole.h.smith@usace.army.mil>
Date: Tue, 23 Jun 2026 13:56:50 -0600
Subject: [PATCH 03/11] Fix TableViewer inactive selection colors

---
 src/DatabaseControls/TableViewer.xaml.cs      |  77 ++++++-
 .../Themes/DatabaseControlsTheme.xaml         |   2 +
 .../Core/TableViewerInactiveSelectionTests.cs | 195 ++++++++++++++++++
 3 files changed, 272 insertions(+), 2 deletions(-)
 create mode 100644 tests/Themes.Tests/Core/TableViewerInactiveSelectionTests.cs

diff --git a/src/DatabaseControls/TableViewer.xaml.cs b/src/DatabaseControls/TableViewer.xaml.cs
index 2924244d..32f52f20 100644
--- a/src/DatabaseControls/TableViewer.xaml.cs
+++ b/src/DatabaseControls/TableViewer.xaml.cs
@@ -179,6 +179,12 @@ private static void OnEditableChanged(DependencyObject d, DependencyPropertyChan
         public static readonly DependencyProperty SelectedColorProperty = DependencyProperty.Register(
             nameof(SelectedColor), typeof(Brush), typeof(TableViewer), new UIPropertyMetadata(new SolidColorBrush(Color.FromArgb(240, 0, 120, 215)), OnVisualPropertyChanged));
 
+        /// <summary>
+        /// Identifies the <see cref="InactiveSelectedColor"/> dependency property.
+        /// </summary>
+        public static readonly DependencyProperty InactiveSelectedColorProperty = DependencyProperty.Register(
+            nameof(InactiveSelectedColor), typeof(Brush), typeof(TableViewer), new UIPropertyMetadata(new SolidColorBrush(Color.FromRgb(196, 213, 240)), OnVisualPropertyChanged));
+
         /// <summary>
         /// Identifies the <see cref="ActiveCellForeground"/> dependency property.
         /// </summary>
@@ -203,6 +209,12 @@ private static void OnEditableChanged(DependencyObject d, DependencyPropertyChan
         public static readonly DependencyProperty SelectedForegroundColorProperty = DependencyProperty.Register(
             nameof(SelectedForegroundColor), typeof(Brush), typeof(TableViewer), new UIPropertyMetadata(new SolidColorBrush(Colors.White), OnVisualPropertyChanged));
 
+        /// <summary>
+        /// Identifies the <see cref="InactiveSelectedForegroundColor"/> dependency property.
+        /// </summary>
+        public static readonly DependencyProperty InactiveSelectedForegroundColorProperty = DependencyProperty.Register(
+            nameof(InactiveSelectedForegroundColor), typeof(Brush), typeof(TableViewer), new UIPropertyMetadata(new SolidColorBrush(Color.FromRgb(30, 30, 30)), OnVisualPropertyChanged));
+
         /// <summary>
         /// Identifies the <see cref="DeSelectedForegroundColor"/> dependency property.
         /// </summary>
@@ -451,6 +463,16 @@ public Brush SelectedColor
             set => SetValue(SelectedColorProperty, value);
         }
 
+        /// <summary>
+        /// Gets or sets the background color for selected cells when table selection is inactive.
+        /// </summary>
+        /// <value>The <see cref="Brush"/> used to fill inactive selected cells.</value>
+        public Brush InactiveSelectedColor
+        {
+            get => (Brush)GetValue(InactiveSelectedColorProperty);
+            set => SetValue(InactiveSelectedColorProperty, value);
+        }
+
         /// <summary>
         /// Gets or sets the foreground color for the active cell.
         /// </summary>
@@ -491,6 +513,16 @@ public Brush SelectedForegroundColor
             set => SetValue(SelectedForegroundColorProperty, value);
         }
 
+        /// <summary>
+        /// Gets or sets the foreground color for selected cells when table selection is inactive.
+        /// </summary>
+        /// <value>The <see cref="Brush"/> used for inactive selected cell text.</value>
+        public Brush InactiveSelectedForegroundColor
+        {
+            get => (Brush)GetValue(InactiveSelectedForegroundColorProperty);
+            set => SetValue(InactiveSelectedForegroundColorProperty, value);
+        }
+
         /// <summary>
         /// Gets or sets the foreground color for deselected cells.
         /// </summary>
@@ -639,6 +671,8 @@ public TableViewer()
             _cellEditTextBox.LostFocus += EditTextLostFocus;
             EditorToolbar.IsEnabled = false;
             GotFocus += (_, _) => UpdatePasteButtonState();
+            GridPanel.GotKeyboardFocus += TableSelectionFocusChanged;
+            GridPanel.LostKeyboardFocus += TableSelectionFocusChanged;
         }
 
         #endregion
@@ -687,6 +721,16 @@ private static void OnVisualPropertyChanged(DependencyObject d, DependencyProper
             }
         }
 
+        /// <summary>
+        /// Handles table body keyboard focus changes by repainting selected cells with active or inactive selection brushes.
+        /// </summary>
+        /// <param name="sender">The source of the keyboard focus change.</param>
+        /// <param name="e">The keyboard focus event data.</param>
+        private void TableSelectionFocusChanged(object sender, KeyboardFocusChangedEventArgs e)
+        {
+            RefreshSelectionVisuals();
+        }
+
         private static void LoadView(DependencyObject d, DependencyPropertyChangedEventArgs e)
         {
             if (d == null || d.GetType() != typeof(TableViewer)) return;
@@ -1714,9 +1758,11 @@ private void DeSelectAllCells()
         private void SelectCell(int columnIndex, int rowIndex)
         {
             var cell = (Cell)GridPanel.Children[rowIndex * DataView.ColumnNames.Count() + columnIndex];
-            cell.Background = SelectedColor;
-            cell.Foreground = SelectedForegroundColor;
+            bool selectionActive = IsTableSelectionActive();
+            cell.Background = selectionActive ? SelectedColor : InactiveSelectedColor;
+            cell.Foreground = selectionActive ? SelectedForegroundColor : InactiveSelectedForegroundColor;
         }
+
         private void DeSelectCell(int columnIndex, int rowIndex)
         {
             var cell = (Cell)GridPanel.Children[rowIndex * DataView.ColumnNames.Count() + columnIndex];
@@ -1726,6 +1772,7 @@ private void DeSelectCell(int columnIndex, int rowIndex)
 
         private void SetActiveCell()
         {
+            if (!IsTableSelectionActive()) return;
             if (GridPanel.Children.Count == 0) return;
             int firstRowTableIndex = (int)Math.Floor(VerticalScrollbar.Value);
             int lastRowTableIndex = firstRowTableIndex + _visibleRowCount - 1;
@@ -1738,6 +1785,26 @@ private void SetActiveCell()
             }
         }
 
+        /// <summary>
+        /// Gets a value indicating whether the table selection should use active selection colors.
+        /// </summary>
+        /// <returns><c>true</c> when the table body or in-place editor contains keyboard focus; otherwise, <c>false</c>.</returns>
+        private bool IsTableSelectionActive()
+        {
+            return GridPanel.IsKeyboardFocusWithin || _cellEditTextBox.IsKeyboardFocusWithin;
+        }
+
+        /// <summary>
+        /// Repaints visible selection cells without changing the selected row, column, or cell collections.
+        /// </summary>
+        private void RefreshSelectionVisuals()
+        {
+            if (DataView == null || GridPanel.Children.Count == 0) return;
+
+            DeSelectAllCells();
+            SetSelectedCells();
+        }
+
         /// <summary>
         /// Sets the active cell to the specified data row and column, optionally scrolling to bring the row into view.
         /// </summary>
@@ -2346,6 +2413,7 @@ private void EditTextLostFocus(object sender, RoutedEventArgs e)
         /// </summary>
         private void RowsGrid_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
         {
+            GridPanel.Focus();
             if (_selectedRowsOnly)
             {
                 _mouseSelectionMode = SelectionMode.None;
@@ -2509,6 +2577,7 @@ private void RowsGrid_MouseMove(object sender, MouseEventArgs e)
         /// </summary>
         private void RowsGrid_MouseRightButtonUp(object sender, MouseButtonEventArgs e)
         {
+            GridPanel.Focus();
             int dataRowIndex = GetDataRowIndex(GetTableRowIndex(e.GetPosition(GridPanel)));
 
             if (_selectedDataRowIndices.BinarySearch(dataRowIndex) < 0)
@@ -2550,6 +2619,7 @@ private void RowsGrid_MouseRightButtonUp(object sender, MouseButtonEventArgs e)
         /// </summary>
         private void ColumnsGrid_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
         {
+            GridPanel.Focus();
             AllCellsSelected = false;
             if (!Keyboard.IsKeyDown(Key.LeftCtrl) && !Keyboard.IsKeyDown(Key.RightCtrl) &&
                 !Keyboard.IsKeyDown(Key.LeftShift) && !Keyboard.IsKeyDown(Key.RightShift) && !_selectedRowsOnly)
@@ -2710,6 +2780,7 @@ private void ColumnsGrid_MouseLeftButtonUp(object sender, MouseButtonEventArgs e
         /// <param name="e">The event data.</param>
         private void SelectAllLeftMouseDown(object sender, MouseButtonEventArgs e)
         {
+            GridPanel.Focus();
             _mouseSelectionMode = SelectionMode.All;
         }
 
@@ -2978,6 +3049,7 @@ private void CalculatorRendered(object? sender, EventArgs e)
         /// <param name="e">The event data.</param>
         private void GridPanel_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
         {
+            GridPanel.Focus();
             Point gridPosition = e.GetPosition(GridPanel);
 
             if (_selectedRowsOnly)
@@ -3214,6 +3286,7 @@ private void GridPanel_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
 
         private void CreateColumnContextMenu(object sender, MouseButtonEventArgs e)
         {
+            GridPanel.Focus();
             if (DataView.NumberOfRows == 0) return;
 
             Point gridPosition = e.GetPosition(GridPanel);
diff --git a/src/DatabaseControls/Themes/DatabaseControlsTheme.xaml b/src/DatabaseControls/Themes/DatabaseControlsTheme.xaml
index af21264c..0919b299 100644
--- a/src/DatabaseControls/Themes/DatabaseControlsTheme.xaml
+++ b/src/DatabaseControls/Themes/DatabaseControlsTheme.xaml
@@ -194,6 +194,8 @@
         <!-- Selection Colors -->
         <Setter Property="SelectedColor" Value="{DynamicResource DataGrid.Row.Selection.Background}"/>
         <Setter Property="SelectedForegroundColor" Value="{DynamicResource DataGrid.Row.Selection.Foreground}"/>
+        <Setter Property="InactiveSelectedColor" Value="{DynamicResource DataGrid.Row.Selection.Inactive.Background}"/>
+        <Setter Property="InactiveSelectedForegroundColor" Value="{DynamicResource DataGrid.Row.Selection.Inactive.Foreground}"/>
         <Setter Property="DeSelectedColor" Value="Transparent"/>
         <Setter Property="DeSelectedForegroundColor" Value="{DynamicResource DataGrid.Static.Foreground}"/>
         <Setter Property="ActiveCellBackground" Value="{DynamicResource DataGrid.Cell.Focus.Border}"/>
diff --git a/tests/Themes.Tests/Core/TableViewerInactiveSelectionTests.cs b/tests/Themes.Tests/Core/TableViewerInactiveSelectionTests.cs
new file mode 100644
index 00000000..e6f883f7
--- /dev/null
+++ b/tests/Themes.Tests/Core/TableViewerInactiveSelectionTests.cs
@@ -0,0 +1,195 @@
+using System.IO;
+using System.Xml.Linq;
+using Xunit;
+
+namespace Themes.Tests.Core;
+
+/// <summary>
+/// Regression tests for TableViewer active and inactive selection styling.
+/// </summary>
+public class TableViewerInactiveSelectionTests
+{
+    private static readonly XNamespace PresentationNamespace = "http://schemas.microsoft.com/winfx/2006/xaml/presentation";
+    private static readonly XNamespace XamlNamespace = "http://schemas.microsoft.com/winfx/2006/xaml";
+
+    /// <summary>
+    /// Verifies TableViewer exposes inactive selection brushes as dependency properties.
+    /// </summary>
+    [Fact]
+    public void TableViewer_ExposesInactiveSelectionDependencyProperties()
+    {
+        string source = File.ReadAllText(ResolveRepoPath("src/DatabaseControls/TableViewer.xaml.cs"));
+
+        Assert.Contains("InactiveSelectedColorProperty", source);
+        Assert.Contains("nameof(InactiveSelectedColor)", source);
+        Assert.Contains("public Brush InactiveSelectedColor", source);
+        Assert.Contains("InactiveSelectedForegroundColorProperty", source);
+        Assert.Contains("nameof(InactiveSelectedForegroundColor)", source);
+        Assert.Contains("public Brush InactiveSelectedForegroundColor", source);
+        Assert.Contains("OnVisualPropertyChanged", source);
+    }
+
+    /// <summary>
+    /// Verifies TableViewerStyle maps active and inactive selection colors to shared DataGrid theme resources.
+    /// </summary>
+    [Fact]
+    public void TableViewerStyle_UsesSharedActiveAndInactiveSelectionResources()
+    {
+        XElement style = GetTableViewerStyle();
+
+        Assert.Contains(
+            style.Elements(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "SelectedColor", "{DynamicResource DataGrid.Row.Selection.Background}"));
+        Assert.Contains(
+            style.Elements(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "SelectedForegroundColor", "{DynamicResource DataGrid.Row.Selection.Foreground}"));
+        Assert.Contains(
+            style.Elements(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "InactiveSelectedColor", "{DynamicResource DataGrid.Row.Selection.Inactive.Background}"));
+        Assert.Contains(
+            style.Elements(PresentationNamespace + "Setter"),
+            setter => HasSetter(setter, "InactiveSelectedForegroundColor", "{DynamicResource DataGrid.Row.Selection.Inactive.Foreground}"));
+    }
+
+    /// <summary>
+    /// Verifies selected cells switch to inactive brushes when table selection is inactive.
+    /// </summary>
+    [Fact]
+    public void SelectCell_UsesInactiveBrushesWhenTableSelectionIsInactive()
+    {
+        string source = File.ReadAllText(ResolveRepoPath("src/DatabaseControls/TableViewer.xaml.cs"));
+        string selectCell = ExtractMethod(source, "private void SelectCell");
+
+        Assert.Contains("bool selectionActive = IsTableSelectionActive();", selectCell);
+        Assert.Contains("cell.Background = selectionActive ? SelectedColor : InactiveSelectedColor;", selectCell);
+        Assert.Contains("cell.Foreground = selectionActive ? SelectedForegroundColor : InactiveSelectedForegroundColor;", selectCell);
+    }
+
+    /// <summary>
+    /// Verifies the focused active-cell highlight is skipped when table selection is inactive.
+    /// </summary>
+    [Fact]
+    public void SetActiveCell_DoesNotForceActiveBrushesWhenSelectionIsInactive()
+    {
+        string source = File.ReadAllText(ResolveRepoPath("src/DatabaseControls/TableViewer.xaml.cs"));
+        string setActiveCell = ExtractMethod(source, "private void SetActiveCell");
+
+        Assert.Contains("if (!IsTableSelectionActive()) return;", setActiveCell);
+        Assert.Contains("cell.Background = ActiveCellBackground;", setActiveCell);
+        Assert.Contains("cell.Foreground = ActiveCellForeground;", setActiveCell);
+    }
+
+    /// <summary>
+    /// Verifies focus changes repaint visible selections without clearing selection state.
+    /// </summary>
+    [Fact]
+    public void FocusHandlersRefreshSelectionVisualsWithoutClearingSelectionState()
+    {
+        string source = File.ReadAllText(ResolveRepoPath("src/DatabaseControls/TableViewer.xaml.cs"));
+        string refreshSelectionVisuals = ExtractMethod(source, "private void RefreshSelectionVisuals");
+        string focusHandler = ExtractMethod(source, "private void TableSelectionFocusChanged");
+
+        Assert.Contains("GridPanel.GotKeyboardFocus += TableSelectionFocusChanged;", source);
+        Assert.Contains("GridPanel.LostKeyboardFocus += TableSelectionFocusChanged;", source);
+        Assert.Contains("RefreshSelectionVisuals();", focusHandler);
+        Assert.Contains("DeSelectAllCells();", refreshSelectionVisuals);
+        Assert.Contains("SetSelectedCells();", refreshSelectionVisuals);
+        Assert.DoesNotContain("_selectedDataRowIndices.Clear()", refreshSelectionVisuals);
+        Assert.DoesNotContain("_selectedCellIndices.Clear()", refreshSelectionVisuals);
+        Assert.DoesNotContain("_selectedColumnIndices.Clear()", refreshSelectionVisuals);
+        Assert.Contains("GridPanel.Focus();", ExtractMethod(source, "private void GridPanel_MouseLeftButtonDown"));
+        Assert.Contains("GridPanel.Focus();", ExtractMethod(source, "private void RowsGrid_MouseLeftButtonDown"));
+        Assert.Contains("GridPanel.Focus();", ExtractMethod(source, "private void ColumnsGrid_MouseLeftButtonDown"));
+        Assert.Contains("GridPanel.Focus();", ExtractMethod(source, "private void SelectAllLeftMouseDown"));
+    }
+
+    /// <summary>
+    /// Finds the TableViewerStyle in the DatabaseControls theme resource dictionary.
+    /// </summary>
+    /// <returns>The TableViewer style element.</returns>
+    private static XElement GetTableViewerStyle()
+    {
+        XDocument document = XDocument.Load(ResolveRepoPath("src/DatabaseControls/Themes/DatabaseControlsTheme.xaml"));
+        XElement? style = document
+            .Descendants(PresentationNamespace + "Style")
+            .FirstOrDefault(element => (string?)element.Attribute(XamlNamespace + "Key") == "TableViewerStyle");
+
+        Assert.NotNull(style);
+        return style!;
+    }
+
+    /// <summary>
+    /// Determines whether a setter has the expected property and value.
+    /// </summary>
+    /// <param name="setter">The setter element.</param>
+    /// <param name="property">The expected property.</param>
+    /// <param name="value">The expected value.</param>
+    /// <returns><c>true</c> when the setter matches.</returns>
+    private static bool HasSetter(XElement setter, string property, string value)
+    {
+        return (string?)setter.Attribute("Property") == property
+            && (string?)setter.Attribute("Value") == value;
+    }
+
+    /// <summary>
+    /// Extracts a method body from a C# source file.
+    /// </summary>
+    /// <param name="source">The source text.</param>
+    /// <param name="signature">The method signature prefix.</param>
+    /// <returns>The method body, including the signature and braces.</returns>
+    private static string ExtractMethod(string source, string signature)
+    {
+        int start = source.IndexOf(signature, StringComparison.Ordinal);
+        Assert.True(start >= 0, signature + " should exist.");
+
+        int bodyStart = source.IndexOf('{', start);
+        Assert.True(bodyStart >= start, signature + " should have a body.");
+
+        int depth = 0;
+        for (int i = bodyStart; i < source.Length; i++)
+        {
+            if (source[i] == '{')
+            {
+                depth++;
+            }
+            else if (source[i] == '}')
+            {
+                depth--;
+                if (depth == 0)
+                {
+                    return source.Substring(start, i - start + 1);
+                }
+            }
+        }
+
+        throw new InvalidOperationException(signature + " body was not closed.");
+    }
+
+    /// <summary>
+    /// Resolves a repository-relative path from the test output directory.
+    /// </summary>
+    /// <param name="repoRelativePath">The repository-relative path.</param>
+    /// <returns>The absolute path.</returns>
+    private static string ResolveRepoPath(string repoRelativePath)
+    {
+        string current = AppContext.BaseDirectory;
+        while (!string.IsNullOrEmpty(current))
+        {
+            if (File.Exists(Path.Combine(current, "WPF-Framework.sln")))
+            {
+                return Path.Combine(current, repoRelativePath.Replace('/', Path.DirectorySeparatorChar));
+            }
+
+            string? parent = Path.GetDirectoryName(current);
+            if (parent == current)
+            {
+                break;
+            }
+
+            current = parent!;
+        }
+
+        throw new InvalidOperationException(
+            $"Could not locate repository root (looking for WPF-Framework.sln) starting from {AppContext.BaseDirectory}");
+    }
+}

From dea7babb38c0ac137736efa5faf8d43b94e3091c Mon Sep 17 00:00:00 2001
From: HadenSmith <cole.h.smith@usace.army.mil>
Date: Wed, 24 Jun 2026 11:59:19 -0600
Subject: [PATCH 04/11] Fix TableViewer active selection focus

---
 src/DatabaseControls/TableViewer.xaml.cs         | 16 +++++++++++++++-
 .../Core/TableViewerInactiveSelectionTests.cs    |  7 +++++++
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/DatabaseControls/TableViewer.xaml.cs b/src/DatabaseControls/TableViewer.xaml.cs
index 32f52f20..d6b8563b 100644
--- a/src/DatabaseControls/TableViewer.xaml.cs
+++ b/src/DatabaseControls/TableViewer.xaml.cs
@@ -671,6 +671,7 @@ public TableViewer()
             _cellEditTextBox.LostFocus += EditTextLostFocus;
             EditorToolbar.IsEnabled = false;
             GotFocus += (_, _) => UpdatePasteButtonState();
+            IsKeyboardFocusWithinChanged += TableSelectionFocusWithinChanged;
             GridPanel.GotKeyboardFocus += TableSelectionFocusChanged;
             GridPanel.LostKeyboardFocus += TableSelectionFocusChanged;
         }
@@ -731,6 +732,16 @@ private void TableSelectionFocusChanged(object sender, KeyboardFocusChangedEvent
             RefreshSelectionVisuals();
         }
 
+        /// <summary>
+        /// Handles control-wide keyboard focus changes by repainting selected cells with active or inactive selection brushes.
+        /// </summary>
+        /// <param name="sender">The source of the keyboard focus change.</param>
+        /// <param name="e">The focus-within property change data.</param>
+        private void TableSelectionFocusWithinChanged(object sender, DependencyPropertyChangedEventArgs e)
+        {
+            RefreshSelectionVisuals();
+        }
+
         private static void LoadView(DependencyObject d, DependencyPropertyChangedEventArgs e)
         {
             if (d == null || d.GetType() != typeof(TableViewer)) return;
@@ -1791,7 +1802,10 @@ private void SetActiveCell()
         /// <returns><c>true</c> when the table body or in-place editor contains keyboard focus; otherwise, <c>false</c>.</returns>
         private bool IsTableSelectionActive()
         {
-            return GridPanel.IsKeyboardFocusWithin || _cellEditTextBox.IsKeyboardFocusWithin;
+            return IsKeyboardFocusWithin
+                || GridPanel.IsKeyboardFocusWithin
+                || _cellEditTextBox.IsKeyboardFocusWithin
+                || _mouseSelectionMode != SelectionMode.None;
         }
 
         /// <summary>
diff --git a/tests/Themes.Tests/Core/TableViewerInactiveSelectionTests.cs b/tests/Themes.Tests/Core/TableViewerInactiveSelectionTests.cs
index e6f883f7..36453886 100644
--- a/tests/Themes.Tests/Core/TableViewerInactiveSelectionTests.cs
+++ b/tests/Themes.Tests/Core/TableViewerInactiveSelectionTests.cs
@@ -59,10 +59,15 @@ public void SelectCell_UsesInactiveBrushesWhenTableSelectionIsInactive()
     {
         string source = File.ReadAllText(ResolveRepoPath("src/DatabaseControls/TableViewer.xaml.cs"));
         string selectCell = ExtractMethod(source, "private void SelectCell");
+        string isTableSelectionActive = ExtractMethod(source, "private bool IsTableSelectionActive");
 
         Assert.Contains("bool selectionActive = IsTableSelectionActive();", selectCell);
         Assert.Contains("cell.Background = selectionActive ? SelectedColor : InactiveSelectedColor;", selectCell);
         Assert.Contains("cell.Foreground = selectionActive ? SelectedForegroundColor : InactiveSelectedForegroundColor;", selectCell);
+        Assert.Contains("IsKeyboardFocusWithin", isTableSelectionActive);
+        Assert.Contains("GridPanel.IsKeyboardFocusWithin", isTableSelectionActive);
+        Assert.Contains("_cellEditTextBox.IsKeyboardFocusWithin", isTableSelectionActive);
+        Assert.Contains("_mouseSelectionMode != SelectionMode.None", isTableSelectionActive);
     }
 
     /// <summary>
@@ -91,7 +96,9 @@ public void FocusHandlersRefreshSelectionVisualsWithoutClearingSelectionState()
 
         Assert.Contains("GridPanel.GotKeyboardFocus += TableSelectionFocusChanged;", source);
         Assert.Contains("GridPanel.LostKeyboardFocus += TableSelectionFocusChanged;", source);
+        Assert.Contains("IsKeyboardFocusWithinChanged += TableSelectionFocusWithinChanged;", source);
         Assert.Contains("RefreshSelectionVisuals();", focusHandler);
+        Assert.Contains("RefreshSelectionVisuals();", ExtractMethod(source, "private void TableSelectionFocusWithinChanged"));
         Assert.Contains("DeSelectAllCells();", refreshSelectionVisuals);
         Assert.Contains("SetSelectedCells();", refreshSelectionVisuals);
         Assert.DoesNotContain("_selectedDataRowIndices.Clear()", refreshSelectionVisuals);

From 494e37960d9c35ecee66b326104410edf91cb654 Mon Sep 17 00:00:00 2001
From: HadenSmith <cole.h.smith@usace.army.mil>
Date: Wed, 24 Jun 2026 14:58:04 -0600
Subject: [PATCH 05/11] fix: preserve legacy project explorer groups

---
 WPF-Framework.sln                             |  15 +
 .../View Models/ProjectNode.cs                | 396 ++++++++++++++----
 .../FrameworkUI.Tests.csproj                  |  37 ++
 .../ProjectNodeLayoutCompatibilityTests.cs    | 375 +++++++++++++++++
 tests/FrameworkUI.Tests/xunit.runner.json     |   5 +
 5 files changed, 737 insertions(+), 91 deletions(-)
 create mode 100644 tests/FrameworkUI.Tests/FrameworkUI.Tests.csproj
 create mode 100644 tests/FrameworkUI.Tests/ProjectExplorer/ProjectNodeLayoutCompatibilityTests.cs
 create mode 100644 tests/FrameworkUI.Tests/xunit.runner.json

diff --git a/WPF-Framework.sln b/WPF-Framework.sln
index e6f2a2b9..a5bc4d98 100644
--- a/WPF-Framework.sln
+++ b/WPF-Framework.sln
@@ -91,6 +91,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DAG.Demo", "src\DAG.Demo\DA
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DAG.Tests", "tests\DAG.Tests\DAG.Tests.csproj", "{3ECEE969-A703-44C7-A084-AA685991A454}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FrameworkUI.Tests", "tests\FrameworkUI.Tests\FrameworkUI.Tests.csproj", "{EFB3100E-0B1D-41EC-BAD4-C79B42481E57}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -569,6 +571,18 @@ Global
 		{3ECEE969-A703-44C7-A084-AA685991A454}.Release|x64.Build.0 = Release|Any CPU
 		{3ECEE969-A703-44C7-A084-AA685991A454}.Release|x86.ActiveCfg = Release|Any CPU
 		{3ECEE969-A703-44C7-A084-AA685991A454}.Release|x86.Build.0 = Release|Any CPU
+		{EFB3100E-0B1D-41EC-BAD4-C79B42481E57}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EFB3100E-0B1D-41EC-BAD4-C79B42481E57}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EFB3100E-0B1D-41EC-BAD4-C79B42481E57}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{EFB3100E-0B1D-41EC-BAD4-C79B42481E57}.Debug|x64.Build.0 = Debug|Any CPU
+		{EFB3100E-0B1D-41EC-BAD4-C79B42481E57}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{EFB3100E-0B1D-41EC-BAD4-C79B42481E57}.Debug|x86.Build.0 = Debug|Any CPU
+		{EFB3100E-0B1D-41EC-BAD4-C79B42481E57}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EFB3100E-0B1D-41EC-BAD4-C79B42481E57}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EFB3100E-0B1D-41EC-BAD4-C79B42481E57}.Release|x64.ActiveCfg = Release|Any CPU
+		{EFB3100E-0B1D-41EC-BAD4-C79B42481E57}.Release|x64.Build.0 = Release|Any CPU
+		{EFB3100E-0B1D-41EC-BAD4-C79B42481E57}.Release|x86.ActiveCfg = Release|Any CPU
+		{EFB3100E-0B1D-41EC-BAD4-C79B42481E57}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -613,6 +627,7 @@ Global
 		{B647E1EA-AA43-419A-AFF1-606D8D0308AB} = {2B3C4D5E-6F78-90AB-12CD-34EF56789012}
 		{A7C3BE0A-ED0B-465A-9ED2-99FBDB791A44} = {3C4D5E6F-7890-AB12-CD34-EF5678901234}
 		{3ECEE969-A703-44C7-A084-AA685991A454} = {4D5E6F78-90AB-12CD-34EF-567890123456}
+		{EFB3100E-0B1D-41EC-BAD4-C79B42481E57} = {4D5E6F78-90AB-12CD-34EF-567890123456}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {5E6F7890-AB12-CD34-EF56-789012345678}
diff --git a/src/FrameworkUI/Project Explorer/View Models/ProjectNode.cs b/src/FrameworkUI/Project Explorer/View Models/ProjectNode.cs
index 4f290172..99e7d1c0 100644
--- a/src/FrameworkUI/Project Explorer/View Models/ProjectNode.cs	
+++ b/src/FrameworkUI/Project Explorer/View Models/ProjectNode.cs	
@@ -145,51 +145,29 @@ public void ElementMatches(Node node, IElement element, ref bool matches)
         public virtual void Load()
         {
 
-            //var tempNodes = new ObservableCollection<Node>();
-            for (int i = ChildNodes.Count - 1; i >= 0; i--)
-            {
-                Node n = ChildNodes[i];
-                ChildNodes.RemoveAt(i);
-                if (n as ElementNodeCollection == null) continue;
-                ((ElementNodeCollection)n).ElementCollection = null;
-            }
+            ClearChildNodesForRetry();
 
-            bool loadStandard = true;
+            var currentCandidate = TryCreateLayoutCandidate(Project.ProjectExplorerLayout, "current");
+            var previousCandidate = TryCreateLayoutCandidate(Project.ProjectExplorerLayoutPrevious, "previous");
+            var chosenCandidate = ChooseLayoutCandidate(currentCandidate, previousCandidate);
 
-            // Try the current layout XML first; if it fails or mismatches, fall back
-            // to the previous (dual-buffer) layout; only then rebuild from scratch.
-            // Capturing a previous-known-good buffer lets us recover from a corrupted
-            // write instead of silently discarding the user's groupings and ordering.
-            if (TryLoadLayoutFromXml(Project.ProjectExplorerLayout, "current"))
-            {
-                loadStandard = false;
-            }
-            else if (TryLoadLayoutFromXml(Project.ProjectExplorerLayoutPrevious, "previous"))
+            if (chosenCandidate != null)
             {
-                loadStandard = false;
-                System.Diagnostics.Debug.WriteLine(
-                    "ProjectNode: recovered Project Explorer layout from previous (dual-buffer) column.");
-            }
-
-            // Check if we need to load the standard way
-            if (loadStandard == true)
-            {
-                // Add child element collections
-                foreach (var nodeCollection in ChildNodes)
+                foreach (var node in chosenCandidate.Nodes)
                 {
-                    if (nodeCollection is not ElementNodeCollection enc) continue;
-                    enc.ElementCollection = null;
-                }
-                for (int i = ChildNodes.Count - 1; i >= 0; i--)
-                {
-                    ChildNodes.RemoveAt(i);
+                    ChildNodes.Add(node);
                 }
-                for (int i = 0; i < (Project.ElementCollections?.Count ?? 0); i++)
+
+                if (chosenCandidate.Source == "previous")
                 {
-                    var elementNodeCollection = new ElementNodeCollection(this, (ProjectExplorerTreeView?)ParentTreeView) { ElementCollection = Project.ElementCollections![i] };
-                    ChildNodes.Add(elementNodeCollection);
+                    System.Diagnostics.Debug.WriteLine(
+                        "ProjectNode: recovered Project Explorer layout from previous (dual-buffer) column.");
                 }
             }
+            else
+            {
+                LoadStandardLayout();
+            }
 
             ResetItemsSource();
             Items.Refresh();
@@ -199,91 +177,177 @@ public virtual void Load()
         }
 
         /// <summary>
-        /// Attempts to rebuild the Project Explorer tree from the given layout XML.
+        /// Attempts to build a Project Explorer layout candidate from the given XML.
         /// </summary>
         /// <remarks>
         /// <para>
-        /// Used by <see cref="Load"/> as part of a two-tier recovery chain: the current
-        /// layout column is tried first, then the previous (dual-buffer) layout column
-        /// as a fallback before the code falls through to the standard
-        /// element-collection iteration.
+        /// Layout XML is intentionally loaded tolerantly for backward compatibility.
+        /// Older project files can contain stale element names or omit collections
+        /// introduced by newer versions. Those mismatches should not discard all user
+        /// grouping and ordering information.
         /// </para>
         /// <para>
-        /// On success, the freshly built tree is left in <see cref="Node.ChildNodes"/>.
-        /// On any failure — malformed XML, missing nodes, or a node-count mismatch —
-        /// any partial tree is torn down so the next attempt starts from a clean slate.
+        /// The returned candidate is not installed into <see cref="Node.ChildNodes"/>
+        /// until <see cref="Load"/> chooses it, so a failed current layout cannot leave
+        /// partial nodes behind before the previous-layout fallback is considered.
         /// </para>
         /// </remarks>
         /// <param name="xml">The layout XML string to parse.</param>
         /// <param name="source">Short diagnostic label (e.g. "current", "previous") for logging.</param>
-        /// <returns><c>true</c> if the tree was fully rebuilt; otherwise <c>false</c>.</returns>
-        private bool TryLoadLayoutFromXml(string? xml, string source)
+        /// <returns>A candidate layout, or null if no usable layout could be built.</returns>
+        private LayoutCandidate? TryCreateLayoutCandidate(string? xml, string source)
         {
-            if (string.IsNullOrEmpty(xml)) return false;
+            if (string.IsNullOrWhiteSpace(xml)) return null;
 
             try
             {
+                var nodes = new List<Node>();
                 var layout = XElement.Parse(xml);
                 foreach (XElement xElement in layout.Elements())
                 {
-                    var node = NodeFromXElement(xElement, this);
-                    if (node == null)
-                    {
-                        // Node couldn't be reconstructed — tear down any partial work
-                        // and let the caller try the next source.
-                        ClearChildNodesForRetry();
-                        return false;
-                    }
-                    ChildNodes.Add(node);
+                    var node = NodeFromXElementTolerant(xElement, this);
+                    if (node != null) nodes.Add(node);
                 }
 
-                // Backfill nodes that exist on disk but not in the XML. This is the
-                // common case when a new element was added between saves: we keep the
-                // user's custom ordering for nodes that WERE in the XML and append
-                // the new ones to their respective collections.
-                foreach (var child in ChildNodes)
+                AppendMissingCollections(nodes);
+                AppendMissingElements(nodes);
+
+                if (nodes.Count == 0) return null;
+
+                return new LayoutCandidate(source, nodes, CountGroups(nodes), IsStandardFlatLayout(nodes));
+            }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine(
+                    $"ProjectNode: failed to load project explorer layout from {source} XML: {ex.Message}");
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Selects the best usable layout candidate.
+        /// </summary>
+        /// <param name="current">Candidate created from the current layout column.</param>
+        /// <param name="previous">Candidate created from the optional previous-layout column.</param>
+        /// <returns>The candidate to install, or null to rebuild the standard layout.</returns>
+        private static LayoutCandidate? ChooseLayoutCandidate(LayoutCandidate? current, LayoutCandidate? previous)
+        {
+            if (current == null) return previous;
+            if (previous == null) return current;
+
+            if (current.IsStandardFlatLayout && previous.GroupCount > 0)
+            {
+                return previous;
+            }
+
+            return current;
+        }
+
+        /// <summary>
+        /// Adds collection nodes for project collections absent from the layout XML.
+        /// </summary>
+        /// <param name="nodes">The candidate top-level nodes.</param>
+        private void AppendMissingCollections(IList<Node> nodes)
+        {
+            for (int i = 0; i < (Project.ElementCollections?.Count ?? 0); i++)
+            {
+                var collection = Project.ElementCollections![i];
+                bool collectionExists = nodes
+                    .OfType<ElementNodeCollection>()
+                    .Any(node => node.ElementCollection?.Name == collection.Name);
+
+                if (!collectionExists)
                 {
-                    if (child is ElementNodeCollection enc && enc.ElementCollection != null)
+                    nodes.Add(CreateStandardCollectionNode(collection));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Adds element nodes for project elements absent from the layout XML.
+        /// </summary>
+        /// <param name="nodes">The candidate top-level nodes.</param>
+        private void AppendMissingElements(IEnumerable<Node> nodes)
+        {
+            foreach (var child in nodes.OfType<ElementNodeCollection>())
+            {
+                if (child.ElementCollection == null) continue;
+
+                for (int i = 0; i < (Project.ElementCollections?.Count ?? 0); i++)
+                {
+                    if (child.ElementCollection.Name != Project.ElementCollections![i].Name) continue;
+
+                    for (int j = 0; j < Project.ElementCollections[i].Count; j++)
                     {
-                        for (int i = 0; i < (Project.ElementCollections?.Count ?? 0); i++)
-                        {
-                            if (enc.ElementCollection.Name == Project.ElementCollections![i].Name)
-                            {
-                                for (int j = 0; j < Project.ElementCollections[i].Count; j++)
-                                {
-                                    bool itMatches = false;
-                                    ElementMatches(child, Project.ElementCollections[i][j], ref itMatches);
+                        bool itMatches = false;
+                        ElementMatches(child, Project.ElementCollections[i][j], ref itMatches);
 
-                                    if (itMatches == false)
-                                    {
-                                        enc.Add(new ElementNode(Project.ElementCollections[i][j], child, (ProjectExplorerTreeView?)ParentTreeView));
-                                    }
-                                }
-                            }
+                        if (itMatches == false)
+                        {
+                            child.Add(new ElementNode(Project.ElementCollections[i][j], child, (ProjectExplorerTreeView?)ParentTreeView));
                         }
                     }
                 }
+            }
+        }
 
-                if (ChildNodes.Count != (Project.ElementCollections?.Count ?? 0))
-                {
-                    // XML has fewer collections than disk — reject and let the caller
-                    // try the next source. A collection-count mismatch typically means
-                    // the XML was written against an older project schema.
-                    ClearChildNodesForRetry();
-                    return false;
-                }
+        /// <summary>
+        /// Counts all group nodes in a candidate tree.
+        /// </summary>
+        /// <param name="nodes">The candidate nodes to inspect.</param>
+        /// <returns>The number of group nodes in the candidate tree.</returns>
+        private static int CountGroups(IEnumerable<Node> nodes)
+        {
+            int count = 0;
+            foreach (var node in nodes)
+            {
+                if (node is NodeGroup) count++;
+                count += CountGroups(node.ChildNodes);
+            }
+            return count;
+        }
+
+        /// <summary>
+        /// Determines whether the candidate is equivalent to the standard flat project layout.
+        /// </summary>
+        /// <param name="nodes">The candidate top-level nodes.</param>
+        /// <returns><c>true</c> when the layout contains all collections flat and no groups.</returns>
+        private bool IsStandardFlatLayout(IList<Node> nodes)
+        {
+            int collectionCount = Project.ElementCollections?.Count ?? 0;
+            if (nodes.Count != collectionCount) return false;
+            if (CountGroups(nodes) != 0) return false;
 
-                return true;
+            for (int i = 0; i < collectionCount; i++)
+            {
+                if (nodes[i] is not ElementNodeCollection collectionNode) return false;
+                if (collectionNode.ElementCollection != Project.ElementCollections![i]) return false;
             }
-            catch (Exception ex)
+
+            return true;
+        }
+
+        /// <summary>
+        /// Loads the default flat collection layout.
+        /// </summary>
+        private void LoadStandardLayout()
+        {
+            for (int i = 0; i < (Project.ElementCollections?.Count ?? 0); i++)
             {
-                System.Diagnostics.Debug.WriteLine(
-                    $"ProjectNode: failed to load project explorer layout from {source} XML: {ex.Message}");
-                ClearChildNodesForRetry();
-                return false;
+                ChildNodes.Add(CreateStandardCollectionNode(Project.ElementCollections![i]));
             }
         }
 
+        /// <summary>
+        /// Creates a standard element collection node populated from the project collection.
+        /// </summary>
+        /// <param name="collection">The project element collection.</param>
+        /// <returns>A populated collection node.</returns>
+        private ElementNodeCollection CreateStandardCollectionNode(FrameworkInterfaces.IElementCollection collection)
+        {
+            return new ElementNodeCollection(this, (ProjectExplorerTreeView?)ParentTreeView) { ElementCollection = collection };
+        }
+
         /// <summary>
         /// Tears down any partially-built tree, used when a layout-load attempt fails
         /// and the caller needs to retry from a different source (previous column,
@@ -491,6 +555,156 @@ private XElement NodeToXElement(Node node)
             }
         }
 
+        /// <summary>
+        /// Creates a node from XElement while tolerating stale layout entries.
+        /// </summary>
+        /// <param name="xElement">The XML element to read.</param>
+        /// <param name="parentNode">The parent node to attach to.</param>
+        /// <returns>A node when the XML entry matches the current project, otherwise null.</returns>
+        private Node? NodeFromXElementTolerant(XElement xElement, Node parentNode)
+        {
+            var nodeTypeAttr = xElement.Attribute("NodeType");
+            var nameAttr = xElement.Attribute("Name");
+            if (nodeTypeAttr == null || nameAttr == null) return null;
+
+            var treeView = ParentTreeView as ProjectExplorerTreeView;
+            Node? node = null;
+
+            if (nodeTypeAttr.Value == nameof(ElementNodeCollection))
+            {
+                var collection = FindElementCollection(nameAttr.Value);
+                if (collection == null) return null;
+
+                node = new ElementNodeCollection(this, treeView) { ElementCollection = collection };
+                SetExpandedFromXml(node, xElement);
+                node.ChildNodes.Clear();
+            }
+            else if (nodeTypeAttr.Value == nameof(ElementNodeGroup))
+            {
+                node = new ElementNodeGroup(parentNode, treeView);
+                node.NodeHeader.HeaderText = nameAttr.Value;
+                SetExpandedFromXml(node, xElement);
+            }
+            else if (nodeTypeAttr.Value == nameof(NodeGroup))
+            {
+                node = new NodeGroup(parentNode, treeView);
+                node.NodeHeader.HeaderText = nameAttr.Value;
+                SetExpandedFromXml(node, xElement);
+            }
+            else if (nodeTypeAttr.Value == nameof(ElementNode))
+            {
+                var collectionNode = FindParentElementNodeCollection(parentNode);
+                if (collectionNode?.ElementCollection == null) return null;
+
+                var element = collectionNode.ElementCollection.FirstOrDefault(e => e.Name == nameAttr.Value);
+                if (element == null) return null;
+
+                node = new ElementNode(element, parentNode, treeView);
+                SetExpandedFromXml(node, xElement);
+            }
+            else
+            {
+                node = new SimpleNode("", parentNode, ParentTreeView);
+                node.NodeHeader.HeaderText = nameAttr.Value;
+                SetExpandedFromXml(node, xElement);
+            }
+
+            foreach (XElement child in xElement.Elements())
+            {
+                var newNode = NodeFromXElementTolerant(child, node);
+                if (newNode == null) continue;
+
+                AddLoadedChild(node, newNode);
+            }
+
+            return node;
+        }
+
+        /// <summary>
+        /// Adds a child node reconstructed from XML to its parent node.
+        /// </summary>
+        /// <param name="parent">The parent node.</param>
+        /// <param name="child">The child node.</param>
+        private static void AddLoadedChild(Node parent, Node child)
+        {
+            if (child is ElementNode elementNode && parent is ElementNodeCollection parentCollection)
+            {
+                parentCollection.Add(elementNode);
+            }
+            else if (child is ElementNodeGroup elementNodeGroup && parent is ElementNodeCollection parentElementCollection)
+            {
+                parentElementCollection.AddGroup(elementNodeGroup);
+            }
+            else if (child is NodeGroup nodeGroup && parent is ElementNodeCollection nodeCollection)
+            {
+                nodeCollection.AddGroup(nodeGroup);
+            }
+            else if (parent is NodeGroup group)
+            {
+                group.Add(child, false);
+            }
+            else
+            {
+                parent.ChildNodes.Add(child);
+            }
+        }
+
+        /// <summary>
+        /// Reads a node expansion value from XML.
+        /// </summary>
+        /// <param name="node">The node to update.</param>
+        /// <param name="xElement">The XML element containing expansion state.</param>
+        private static void SetExpandedFromXml(Node node, XElement xElement)
+        {
+            bool expand = true;
+            var expandAttr = xElement.Attribute(nameof(node.IsExpanded));
+            if (expandAttr != null) bool.TryParse(expandAttr.Value, out expand);
+            node.IsExpanded = expand;
+        }
+
+        /// <summary>
+        /// Finds a project element collection by name.
+        /// </summary>
+        /// <param name="name">The collection name.</param>
+        /// <returns>The matching collection, or null if it does not exist.</returns>
+        private FrameworkInterfaces.IElementCollection? FindElementCollection(string name)
+        {
+            for (int i = 0; i < (Project.ElementCollections?.Count ?? 0); i++)
+            {
+                if (Project.ElementCollections![i].Name == name) return Project.ElementCollections[i];
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Finds the nearest parent element collection node.
+        /// </summary>
+        /// <param name="parentNode">The node where the parent search should begin.</param>
+        /// <returns>The nearest element collection node, or null if there is none.</returns>
+        private static ElementNodeCollection? FindParentElementNodeCollection(Node parentNode)
+        {
+            Node? tempParent = parentNode;
+            while (tempParent != null)
+            {
+                if (tempParent is ElementNodeCollection elementNodeCollection)
+                    return elementNodeCollection;
+
+                tempParent = tempParent.ParentNode;
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Candidate project-explorer layout built from one persisted XML column.
+        /// </summary>
+        /// <param name="Source">Diagnostic source label for the XML column.</param>
+        /// <param name="Nodes">Top-level nodes in the candidate layout.</param>
+        /// <param name="GroupCount">Number of group nodes in the candidate layout.</param>
+        /// <param name="IsStandardFlatLayout">Whether the candidate matches the standard flat layout.</param>
+        private sealed record LayoutCandidate(string Source, IList<Node> Nodes, int GroupCount, bool IsStandardFlatLayout);
+
         /// <summary>
         /// When the Project Node header is left clicked, raise OnClick event.
         /// </summary>
diff --git a/tests/FrameworkUI.Tests/FrameworkUI.Tests.csproj b/tests/FrameworkUI.Tests/FrameworkUI.Tests.csproj
new file mode 100644
index 00000000..fe391f7f
--- /dev/null
+++ b/tests/FrameworkUI.Tests/FrameworkUI.Tests.csproj
@@ -0,0 +1,37 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0-windows</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <UseWPF>true</UseWPF>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="Xunit.StaFact" Version="1.1.11" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\FrameworkInterfaces\FrameworkInterfaces.csproj" />
+    <ProjectReference Include="..\..\src\FrameworkUI\FrameworkUI.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="xunit.runner.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+</Project>
diff --git a/tests/FrameworkUI.Tests/ProjectExplorer/ProjectNodeLayoutCompatibilityTests.cs b/tests/FrameworkUI.Tests/ProjectExplorer/ProjectNodeLayoutCompatibilityTests.cs
new file mode 100644
index 00000000..283b22aa
--- /dev/null
+++ b/tests/FrameworkUI.Tests/ProjectExplorer/ProjectNodeLayoutCompatibilityTests.cs
@@ -0,0 +1,375 @@
+using System.Collections.ObjectModel;
+using System.Windows.Controls;
+using System.Windows.Media;
+using FrameworkInterfaces;
+using FrameworkUI.ProjectExplorer;
+using Xunit;
+
+namespace FrameworkUI.Tests.ProjectExplorer;
+
+public class ProjectNodeLayoutCompatibilityTests
+{
+    [StaFact]
+    public void Load_WithLegacyGroupedXml_PreservesGroupsOrderAndExpansion()
+    {
+        var project = CreateProject();
+        project.ProjectExplorerLayout =
+            """
+            <Node NodeType="ProjectNode" Name="Legacy" IsExpanded="true">
+              <Node NodeType="ElementNodeCollection" Name="Input Data" IsExpanded="false">
+                <Node NodeType="ElementNode" Name="Root Item" IsExpanded="true" />
+                <Node NodeType="ElementNodeGroup" Name="Final Set" IsExpanded="true">
+                  <Node NodeType="ElementNode" Name="Grouped A" IsExpanded="true" />
+                  <Node NodeType="ElementNode" Name="Grouped B" IsExpanded="false" />
+                </Node>
+              </Node>
+              <Node NodeType="ElementNodeCollection" Name="Univariate Distribution Analysis" IsExpanded="true">
+                <Node NodeType="ElementNode" Name="Analysis A" IsExpanded="true" />
+              </Node>
+            </Node>
+            """;
+
+        var node = new TestProjectNode(project);
+
+        var input = Assert.IsType<ElementNodeCollection>(node.ChildNodes[0]);
+        Assert.False(input.IsExpanded);
+        Assert.Equal("Root Item", Assert.IsType<ElementNode>(input.ChildNodes[0]).Element.Name);
+
+        var group = Assert.IsType<ElementNodeGroup>(input.ChildNodes[1]);
+        Assert.Equal("Final Set", group.NodeHeader.HeaderText);
+        Assert.True(group.IsExpanded);
+        Assert.Equal("Grouped A", Assert.IsType<ElementNode>(group.ChildNodes[0]).Element.Name);
+        Assert.False(group.ChildNodes[1].IsExpanded);
+
+        var analysis = Assert.IsType<ElementNodeCollection>(node.ChildNodes[1]);
+        Assert.Equal("Univariate Distribution Analysis", analysis.ElementCollection?.Name);
+    }
+
+    [StaFact]
+    public void Load_WithNoPreviousLayout_LoadsCurrentLayoutOnly()
+    {
+        var project = CreateProject();
+        project.ProjectExplorerLayout =
+            """
+            <Node NodeType="ProjectNode" Name="Legacy" IsExpanded="true">
+              <Node NodeType="ElementNodeCollection" Name="Input Data" IsExpanded="true">
+                <Node NodeType="ElementNodeGroup" Name="Only Current" IsExpanded="true">
+                  <Node NodeType="ElementNode" Name="Grouped A" IsExpanded="true" />
+                </Node>
+              </Node>
+            </Node>
+            """;
+        project.SetPreviousProjectExplorerLayout(string.Empty);
+
+        var node = new TestProjectNode(project);
+
+        var input = Assert.IsType<ElementNodeCollection>(node.ChildNodes[0]);
+        Assert.Contains(input.ChildNodes, child => child is ElementNodeGroup group && group.NodeHeader.HeaderText == "Only Current");
+    }
+
+    [StaFact]
+    public void Load_WithStaleElementInsideGroup_KeepsGroupAndBackfillsCurrentElements()
+    {
+        var project = CreateProject();
+        project.ProjectExplorerLayout =
+            """
+            <Node NodeType="ProjectNode" Name="Legacy" IsExpanded="true">
+              <Node NodeType="ElementNodeCollection" Name="Input Data" IsExpanded="true">
+                <Node NodeType="ElementNodeGroup" Name="Final Set" IsExpanded="true">
+                  <Node NodeType="ElementNode" Name="Grouped A" IsExpanded="true" />
+                  <Node NodeType="ElementNode" Name="Renamed Or Deleted" IsExpanded="true" />
+                </Node>
+              </Node>
+            </Node>
+            """;
+
+        var node = new TestProjectNode(project);
+
+        var input = Assert.IsType<ElementNodeCollection>(node.ChildNodes[0]);
+        var group = Assert.IsType<ElementNodeGroup>(input.ChildNodes[0]);
+        Assert.Single(group.ChildNodes);
+        Assert.Equal("Grouped A", Assert.IsType<ElementNode>(group.ChildNodes[0]).Element.Name);
+        Assert.Contains(input.ChildNodes, child => child is ElementNode element && element.Element.Name == "Grouped B");
+        Assert.Contains(input.ChildNodes, child => child is ElementNode element && element.Element.Name == "Root Item");
+    }
+
+    [StaFact]
+    public void Load_WithCollectionMissingFromXml_AppendsCollectionWithoutLosingGroups()
+    {
+        var project = CreateProject();
+        project.AddCollection("Rating Curve Analysis", "Rating A");
+        project.ProjectExplorerLayout =
+            """
+            <Node NodeType="ProjectNode" Name="Legacy" IsExpanded="true">
+              <Node NodeType="ElementNodeCollection" Name="Input Data" IsExpanded="true">
+                <Node NodeType="ElementNodeGroup" Name="Final Set" IsExpanded="true">
+                  <Node NodeType="ElementNode" Name="Grouped A" IsExpanded="true" />
+                </Node>
+              </Node>
+            </Node>
+            """;
+
+        var node = new TestProjectNode(project);
+
+        var input = Assert.IsType<ElementNodeCollection>(node.ChildNodes[0]);
+        Assert.Contains(input.ChildNodes, child => child is ElementNodeGroup group && group.NodeHeader.HeaderText == "Final Set");
+        Assert.Contains(node.ChildNodes, child => child is ElementNodeCollection collection && collection.ElementCollection?.Name == "Rating Curve Analysis");
+    }
+
+    [StaFact]
+    public void Load_WithCurrentFlatLayoutAndPreviousGroupedLayout_RecoversPreviousGroups()
+    {
+        var project = CreateProject();
+        project.ProjectExplorerLayout =
+            """
+            <Node NodeType="ProjectNode" Name="Flat" IsExpanded="true">
+              <Node NodeType="ElementNodeCollection" Name="Input Data" IsExpanded="true">
+                <Node NodeType="ElementNode" Name="Root Item" IsExpanded="true" />
+                <Node NodeType="ElementNode" Name="Grouped A" IsExpanded="true" />
+                <Node NodeType="ElementNode" Name="Grouped B" IsExpanded="true" />
+              </Node>
+              <Node NodeType="ElementNodeCollection" Name="Univariate Distribution Analysis" IsExpanded="true">
+                <Node NodeType="ElementNode" Name="Analysis A" IsExpanded="true" />
+              </Node>
+            </Node>
+            """;
+        project.SetPreviousProjectExplorerLayout(
+            """
+            <Node NodeType="ProjectNode" Name="Grouped" IsExpanded="true">
+              <Node NodeType="ElementNodeCollection" Name="Input Data" IsExpanded="true">
+                <Node NodeType="ElementNodeGroup" Name="Recovered" IsExpanded="true">
+                  <Node NodeType="ElementNode" Name="Grouped A" IsExpanded="true" />
+                </Node>
+              </Node>
+              <Node NodeType="ElementNodeCollection" Name="Univariate Distribution Analysis" IsExpanded="true">
+                <Node NodeType="ElementNode" Name="Analysis A" IsExpanded="true" />
+              </Node>
+            </Node>
+            """);
+
+        var node = new TestProjectNode(project);
+
+        var input = Assert.IsType<ElementNodeCollection>(node.ChildNodes[0]);
+        Assert.Contains(input.ChildNodes, child => child is ElementNodeGroup group && group.NodeHeader.HeaderText == "Recovered");
+    }
+
+    [StaFact]
+    public void Load_WithMalformedCurrentLayout_FallsBackSafely()
+    {
+        var project = CreateProject();
+        project.ProjectExplorerLayout = "<Node><Node";
+        project.SetPreviousProjectExplorerLayout(
+            """
+            <Node NodeType="ProjectNode" Name="Grouped" IsExpanded="true">
+              <Node NodeType="ElementNodeCollection" Name="Input Data" IsExpanded="true">
+                <Node NodeType="ElementNodeGroup" Name="Previous" IsExpanded="true">
+                  <Node NodeType="ElementNode" Name="Grouped A" IsExpanded="true" />
+                </Node>
+              </Node>
+            </Node>
+            """);
+
+        var node = new TestProjectNode(project);
+
+        var input = Assert.IsType<ElementNodeCollection>(node.ChildNodes[0]);
+        Assert.Contains(input.ChildNodes, child => child is ElementNodeGroup group && group.NodeHeader.HeaderText == "Previous");
+    }
+
+    private static FakeProject CreateProject()
+    {
+        return new FakeProject(
+            ("Input Data", new[] { "Root Item", "Grouped A", "Grouped B" }),
+            ("Univariate Distribution Analysis", new[] { "Analysis A" }));
+    }
+
+    private sealed class TestProjectNode : ProjectNode
+    {
+        public TestProjectNode(IProject project)
+            : base(project)
+        {
+            Load();
+        }
+
+        public override bool CanMultiSelect => false;
+
+        protected override void DefineProjectExplorerMenuItems()
+        {
+        }
+    }
+
+    private sealed class FakeProject : ProjectBase
+    {
+        private readonly List<IElementCollection> _collections = new();
+
+        public FakeProject(params (string Name, string[] ElementNames)[] collections)
+        {
+            _name = "Fake Project";
+            _description = string.Empty;
+            _creationDate = DateTime.UtcNow;
+            _lastModified = _creationDate;
+
+            foreach (var collection in collections)
+            {
+                AddCollection(collection.Name, collection.ElementNames);
+            }
+        }
+
+        public override string Name
+        {
+            get => _name;
+            set => _name = value;
+        }
+
+        public override string Description
+        {
+            get => _description;
+            set => _description = value;
+        }
+
+        public override string SoftwareVersion => "2.4";
+
+        public override ImageSource ProjectImage { get; } = new DrawingImage();
+
+        public void AddCollection(string name, params string[] elementNames)
+        {
+            _collections.Add(new FakeElementCollection(this, name, elementNames));
+            _readOnlyElementCollections = new ReadOnlyCollection<IElementCollection>(_collections);
+        }
+
+        public void SetPreviousProjectExplorerLayout(string layout)
+        {
+            _projectExplorerLayoutPrevious = layout;
+        }
+
+        public override bool IsValid()
+        {
+            return true;
+        }
+
+        public override void CreateNew(string newFullFileName)
+        {
+            FullFileName = newFullFileName;
+        }
+
+        public override void Open()
+        {
+        }
+
+        public override void Save()
+        {
+        }
+
+        public override void Close()
+        {
+        }
+
+        public override void Compact()
+        {
+        }
+
+        public override void Optimize()
+        {
+        }
+    }
+
+    private sealed class FakeElementCollection : ElementCollectionBase
+    {
+        private readonly string _name;
+
+        public FakeElementCollection(IProject parentProject, string name, IEnumerable<string> elementNames)
+            : base(parentProject)
+        {
+            _name = name;
+
+            foreach (var elementName in elementNames)
+            {
+                Add(new FakeElement(elementName, this));
+            }
+        }
+
+        public override string Name => _name;
+
+        public override void Open()
+        {
+        }
+
+        public override void Add(IElement item)
+        {
+            ElementList.Add(item);
+            RaiseElementAddedEvent(item);
+        }
+
+        public override void Insert(int index, IElement item)
+        {
+            ElementList.Insert(index, item);
+            RaiseElementAddedEvent(item);
+        }
+
+        public override void InsertFromExternalProject(int index, string elementName, string elementType, string fullFileName)
+        {
+            Insert(index, new FakeElement(elementName, this));
+        }
+
+        public override void Delete()
+        {
+        }
+    }
+
+    private sealed class FakeElement : ElementBase
+    {
+        public FakeElement(string name, IElementCollection parentCollection)
+            : base(name, parentCollection)
+        {
+            _description = string.Empty;
+            _creationDate = DateTime.UtcNow;
+            _lastModified = _creationDate;
+            _isValid = true;
+        }
+
+        public override string Name
+        {
+            get => NameField;
+            set => NameField = value;
+        }
+
+        public override string Description
+        {
+            get => _description;
+            set => _description = value;
+        }
+
+        public override DateTime CreationDate => _creationDate;
+
+        public override DateTime LastModified => _lastModified;
+
+        public override bool IsValid => _isValid;
+
+        public override string NameOnDisk => Name;
+
+        public override ImageSource ElementImage { get; } = new DrawingImage();
+
+        public override bool CanCopyFromExternal => false;
+
+        public override void Open()
+        {
+        }
+
+        public override void Save()
+        {
+        }
+
+        public override IElement Copy(string? newName = null)
+        {
+            return new FakeElement(newName ?? Name, ParentCollection);
+        }
+
+        public override IElement CopyFromExternal(string itemName, string fullFileName)
+        {
+            return new FakeElement(itemName, ParentCollection);
+        }
+
+        public override void Delete()
+        {
+        }
+    }
+}
diff --git a/tests/FrameworkUI.Tests/xunit.runner.json b/tests/FrameworkUI.Tests/xunit.runner.json
new file mode 100644
index 00000000..dd80f43a
--- /dev/null
+++ b/tests/FrameworkUI.Tests/xunit.runner.json
@@ -0,0 +1,5 @@
+{
+  "$schema": "https://xunit.net/schema/current/xunit.runner.schema.json",
+  "parallelizeAssembly": false,
+  "parallelizeTestCollections": false
+}

From 7e6b984bd1e7085903f86a3e5610ff1e0b01b958 Mon Sep 17 00:00:00 2001
From: HadenSmith <cole.h.smith@usace.army.mil>
Date: Tue, 30 Jun 2026 08:16:20 -0600
Subject: [PATCH 06/11] fix: use native save as for plot image export

---
 docs/oxyplot-controls.md                      |   4 +-
 src/OxyPlotControls/SavePlotImageDialog.xaml  |  68 +---
 .../SavePlotImageDialog.xaml.cs               | 293 ++++++++--------
 .../SavePlotImageDialogTests.cs               | 319 ++++++------------
 4 files changed, 267 insertions(+), 417 deletions(-)

diff --git a/docs/oxyplot-controls.md b/docs/oxyplot-controls.md
index 8400b339..3e166582 100644
--- a/docs/oxyplot-controls.md
+++ b/docs/oxyplot-controls.md
@@ -135,8 +135,8 @@ A dialog window for exporting charts as image files. Extends `MetroDialogWindow`
 - Preset and custom dimension selection
 - Live WYSIWYG bitmap preview that scales to fit the dialog
 - Report theme toggle -- exports with a white-background print-optimized theme
-- Duplicate file name detection
-- Persists last-used folder path across invocations
+- Native Windows Save As dialog for file name, file type, folder, extension, and overwrite handling
+- Persists last-used export folder path across invocations
 
 ```csharp
 var dialog = new SavePlotImageDialog(myPlot);
diff --git a/src/OxyPlotControls/SavePlotImageDialog.xaml b/src/OxyPlotControls/SavePlotImageDialog.xaml
index 66c2de3a..6f1ce175 100644
--- a/src/OxyPlotControls/SavePlotImageDialog.xaml
+++ b/src/OxyPlotControls/SavePlotImageDialog.xaml
@@ -5,7 +5,7 @@
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
         xmlns:cntrls="clr-namespace:GenericControls;assembly=GenericControls"
         mc:Ignorable="d"
-        Title="Save Plot Image" SizeToContent="Manual" Width="700" Height="650"
+        Title="Export Plot Image" SizeToContent="Manual" Width="700" Height="650"
         MinWidth="500" MinHeight="450"
         WindowStartupLocation="CenterOwner"
         Style="{DynamicResource MetroDialogStyle}"
@@ -13,7 +13,7 @@
 
     <DockPanel Margin="6" LastChildFill="True">
 
-        <!-- ═══ TOP: Image Size, Dimensions & Report Theme ═══ -->
+        <!-- TOP: Image Size, Dimensions & Report Theme -->
         <Grid DockPanel.Dock="Top" Margin="0,0,0,4">
             <Grid.RowDefinitions>
                 <RowDefinition Height="Auto"/>
@@ -24,7 +24,6 @@
                 <ColumnDefinition Width="*"/>
             </Grid.ColumnDefinitions>
 
-            <!-- Row 0: Image Size Preset -->
             <TextBlock Grid.Row="0" Grid.Column="0" Text="Image Size:"
                        HorizontalAlignment="Right" VerticalAlignment="Center" Margin="0,4,8,4"/>
             <ComboBox Name="ImageSizeComboBox" Grid.Row="0" Grid.Column="1"
@@ -42,7 +41,6 @@
                 <ComboBoxItem Content="Custom"/>
             </ComboBox>
 
-            <!-- Row 1: Report Theme checkbox + Custom dimensions (when visible) -->
             <Grid Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2" Margin="0,2,0,0">
                 <Grid.ColumnDefinitions>
                     <ColumnDefinition Width="*"/>
@@ -56,7 +54,6 @@
                           Checked="ReportThemeCheckBox_Changed"
                           Unchecked="ReportThemeCheckBox_Changed"/>
 
-                <!-- Width & Height (visible only when Custom is selected) -->
                 <Grid x:Name="CustomDimensionsPanel" Grid.Column="1" Visibility="Collapsed">
                     <Grid.ColumnDefinitions>
                         <ColumnDefinition Width="Auto"/>
@@ -80,62 +77,21 @@
             </Grid>
         </Grid>
 
-        <!-- ═══ BOTTOM: File Controls & Buttons ═══ -->
-        <Grid DockPanel.Dock="Bottom" Margin="0,4,0,0">
-            <Grid.RowDefinitions>
-                <RowDefinition Height="Auto"/>
-                <RowDefinition Height="Auto"/>
-                <RowDefinition Height="Auto"/>
-                <RowDefinition Height="Auto"/>
-            </Grid.RowDefinitions>
+        <!-- BOTTOM: Buttons -->
+        <Grid DockPanel.Dock="Bottom" Margin="0,6,0,0" HorizontalAlignment="Right">
             <Grid.ColumnDefinitions>
                 <ColumnDefinition Width="Auto"/>
-                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="Auto"/>
             </Grid.ColumnDefinitions>
-
-            <!-- File Type -->
-            <TextBlock Grid.Row="0" Grid.Column="0" Text="File Type:"
-                       HorizontalAlignment="Right" VerticalAlignment="Center" Margin="0,4,8,4"/>
-            <ComboBox Name="FileTypeComboBox" Grid.Row="0" Grid.Column="1"
-                      Margin="0,4" VerticalAlignment="Center" SelectedIndex="0"
-                      SelectionChanged="FileTypeComboBox_SelectionChanged">
-                <ComboBoxItem Content="PNG (.png)"/>
-                <ComboBoxItem Content="PDF (.pdf)"/>
-                <ComboBoxItem Content="SVG (.svg)"/>
-            </ComboBox>
-
-            <!-- Directory -->
-            <TextBlock Grid.Row="1" Grid.Column="0" Text="Directory:"
-                       HorizontalAlignment="Right" VerticalAlignment="Center" Margin="0,4,8,4"/>
-            <cntrls:FolderSelectorControl x:Name="FolderPathControl" Grid.Row="1" Grid.Column="1"
-                                           Title="" ShowLeaderLine="False"
-                                           PropertyWidth="10*" MaxPropertyWidth="2000" MinPropertyWidth="200"
-                                           Margin="-3,4,0,4" HorizontalAlignment="Stretch"
-                                           TextChanged="FolderPathControl_TextChanged"/>
-
-            <!-- File Name -->
-            <TextBlock Grid.Row="2" Grid.Column="0" Text="File Name:"
-                       HorizontalAlignment="Right" VerticalAlignment="Center" Margin="0,4,8,4"/>
-            <cntrls:NameTextBox x:Name="FileNameTextBox" Grid.Row="2" Grid.Column="1"
-                                Height="22" Margin="0,4"
-                                CanBeBlank="False" CharacterLimit="200"/>
-
-            <!-- Buttons -->
-            <Grid Grid.Row="3" Grid.Column="0" Grid.ColumnSpan="2" HorizontalAlignment="Right">
-                <Grid.ColumnDefinitions>
-                    <ColumnDefinition Width="Auto"/>
-                    <ColumnDefinition Width="Auto"/>
-                </Grid.ColumnDefinitions>
-                <Button Name="SaveButton" Content="Save" IsDefault="True" Grid.Column="0"
-                        Width="75" Height="24" Margin="6,0,0,0" Cursor="Hand"
-                        Click="SaveButton_Click"/>
-                <Button Name="CancelButton" Content="Cancel" IsCancel="True" Grid.Column="1"
-                        Width="75" Height="24" Margin="6,0,0,0" Cursor="Hand"
-                        Click="CancelButton_Click"/>
-            </Grid>
+            <Button Name="SaveAsButton" Content="Save As..." IsDefault="True" Grid.Column="0"
+                    Width="90" Height="24" Margin="6,0,0,0" Cursor="Hand"
+                    Click="SaveAsButton_Click"/>
+            <Button Name="CancelButton" Content="Cancel" IsCancel="True" Grid.Column="1"
+                    Width="75" Height="24" Margin="6,0,0,0" Cursor="Hand"
+                    Click="CancelButton_Click"/>
         </Grid>
 
-        <!-- ═══ CENTER: Plot Preview ═══ -->
+        <!-- CENTER: Plot Preview -->
         <Border BorderBrush="{DynamicResource SeparatorBorder}" BorderThickness="1"
                 Margin="0,2,0,0" Background="{DynamicResource EnvironmentWindowBackground}">
             <Grid Name="PreviewContainer" SizeChanged="PreviewContainer_SizeChanged">
diff --git a/src/OxyPlotControls/SavePlotImageDialog.xaml.cs b/src/OxyPlotControls/SavePlotImageDialog.xaml.cs
index 7432df1d..8107606d 100644
--- a/src/OxyPlotControls/SavePlotImageDialog.xaml.cs
+++ b/src/OxyPlotControls/SavePlotImageDialog.xaml.cs
@@ -1,37 +1,41 @@
 using System;
 using System.ComponentModel;
 using System.IO;
-using System.Linq;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Media;
 using System.Windows.Threading;
 using GenericControls;
+using Microsoft.Win32;
 using OxyPlot.Wpf;
 
 namespace OxyPlotControls
 {
     /// <summary>
-    /// A dialog window for saving OxyPlot charts as image files.
-    /// Provides a live plot preview that scales with the selected export dimensions,
-    /// and inline controls for file type, directory, and file name.
-    /// Supports PNG, PDF, and SVG formats with customizable dimensions.
+    /// A dialog window for exporting OxyPlot charts.
+    /// Provides a live plot preview, export dimensions, report-theme selection,
+    /// and delegates file name, type, overwrite, and folder selection to the
+    /// native Windows Save As dialog.
     /// </summary>
     public partial class SavePlotImageDialog : MetroDialogWindow
     {
-        private Plot _sourcePlot;
-        private DispatcherTimer _resizeDebounceTimer;
+        private const string SaveFileFilter = "PNG Image (*.png)|*.png|PDF Document (*.pdf)|*.pdf|SVG Vector Image (*.svg)|*.svg";
+        private const int PngFilterIndex = 1;
+        private const int PdfFilterIndex = 2;
+        private const int SvgFilterIndex = 3;
+        private const int DefaultFileNameMaxLength = 200;
+
+        private readonly Plot _sourcePlot;
+        private readonly DispatcherTimer _resizeDebounceTimer;
         private bool _isInitialized;
         private bool _useReportTheme = true;
-        private static string _lastUsedFolderPath = "";
+        private static string _lastUsedFolderPath = string.Empty;
         private double _desiredPreviewWidth;
         private double _desiredPreviewHeight;
 
         // Layout constants for dialog sizing calculations.
-        // These estimate the non-preview space (controls, chrome, margins) so the dialog
-        // is sized appropriately. The preview itself uses explicit dimensions and does not
-        // depend on these constants being pixel-perfect.
-        private const double ControlsPanelHeight = 190;
+        // These estimate the non-preview space so the preview can scale to the selected export size.
+        private const double ControlsPanelHeight = 110;
         private const double DialogChromeHeight = 50;
         private const double DialogHorizontalPadding = 36;
         private const double MinPreviewWidth = 280;
@@ -48,7 +52,6 @@ public SavePlotImageDialog(Plot thePlot)
 
             _sourcePlot = thePlot;
 
-            // Set theme-aware window icon
             SetThemeAwareIcon();
 
             _resizeDebounceTimer = new DispatcherTimer
@@ -74,38 +77,21 @@ public SavePlotImageDialog(Plot thePlot)
         }
 
         /// <summary>
-        /// Handles the ContentRendered event to initialize the dialog with default values and render the first preview.
+        /// Handles the ContentRendered event to initialize the dialog and render the first preview.
         /// </summary>
         private void SavePlotImageDialog_ContentRendered(object? sender, EventArgs e)
         {
-            // Set tooltips showing current plot dimensions
             WidthTextBox.ToolTip = "Current Plot Width is " + ((int)_sourcePlot.ActualWidth).ToString() + " px";
             HeightTextBox.ToolTip = "Current Plot Height is " + ((int)_sourcePlot.ActualHeight).ToString() + " px";
 
-            // Initialize folder path: last used > Pictures > Documents
-            if (!string.IsNullOrEmpty(_lastUsedFolderPath) && Directory.Exists(_lastUsedFolderPath))
-                FolderPathControl.Text = _lastUsedFolderPath;
-            else
-            {
-                string picturesPath = Environment.GetFolderPath(Environment.SpecialFolder.MyPictures);
-                FolderPathControl.Text = Directory.Exists(picturesPath) ? picturesPath
-                    : Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
-            }
-
-            // Initialize file name
-            FileNameTextBox.Text = "plot";
-
-            // Populate existing file names for duplicate detection
-            UpdateExistingFileNames();
-
             _isInitialized = true;
 
-            // Defer first preview render until layout is complete
+            // Defer first preview render until layout is complete.
             Dispatcher.BeginInvoke(DispatcherPriority.Loaded, new Action(UpdatePreview));
         }
 
         /// <summary>
-        /// Handles the Closing event to activate the owner window and persist the folder path.
+        /// Handles the Closing event to activate the owner window.
         /// </summary>
         private void SavePlotImageDialog_Closing(object? sender, CancelEventArgs e)
         {
@@ -114,9 +100,6 @@ private void SavePlotImageDialog_Closing(object? sender, CancelEventArgs e)
             _resizeDebounceTimer.Stop();
             _resizeDebounceTimer.Tick -= ResizeDebounceTimer_Tick;
 
-            if (!string.IsNullOrEmpty(FolderPathControl.Text))
-                _lastUsedFolderPath = FolderPathControl.Text;
-
             if (Owner != null) Owner.Activate();
         }
 
@@ -130,7 +113,7 @@ private void SetThemeAwareIcon()
             {
                 var iconBrush = FindResource("EnvironmentWindowText") as SolidColorBrush ?? Brushes.Black;
 
-                // Camera/save icon: simple camera shape matching the toolbar CameraIcon
+                // Camera/save icon: simple camera shape matching the toolbar CameraIcon.
                 var geometry = Geometry.Parse(
                     "F0 M 5.40625 1.828125 C 5.2435365 1.828125 5.1126068 1.9997109 5.03125 2.140625 " +
                     "C 4.7248392 2.671344 4.09375 3.734375 4.09375 3.734375 L 2.4375 3.734375 " +
@@ -157,7 +140,7 @@ private void SetThemeAwareIcon()
             }
             catch
             {
-                // Fall back gracefully - no icon if resource resolution fails
+                // Fall back gracefully - no icon if resource resolution fails.
             }
         }
 
@@ -239,20 +222,18 @@ private void ResizeDebounceTimer_Tick(object? sender, EventArgs e)
 
         /// <summary>
         /// Computes the optimal dialog dimensions for the given export size.
-        /// Used both for initial sizing (before the window is shown) and subsequent resizes.
+        /// Used both for initial sizing before the window is shown and subsequent resizes.
         /// </summary>
         private static (double dialogWidth, double dialogHeight, double previewWidth, double previewHeight) ComputeDialogSize(int exportWidth, int exportHeight)
         {
-            // Get available screen space
             var workArea = SystemParameters.WorkArea;
             double maxDialogWidth = workArea.Width * ScreenUsageFraction;
             double maxDialogHeight = workArea.Height * ScreenUsageFraction;
 
-            // Compute available preview space
             double availablePreviewWidth = maxDialogWidth - DialogHorizontalPadding;
             double availablePreviewHeight = maxDialogHeight - ControlsPanelHeight - DialogChromeHeight;
 
-            // Scale to fit — never upscale beyond the export dimensions
+            // Scale to fit and never upscale beyond the export dimensions.
             double scaleX = availablePreviewWidth / exportWidth;
             double scaleY = availablePreviewHeight / exportHeight;
             double scale = Math.Min(scaleX, scaleY);
@@ -261,11 +242,9 @@ private static (double dialogWidth, double dialogHeight, double previewWidth, do
             double previewWidth = Math.Max(exportWidth * scale, MinPreviewWidth);
             double previewHeight = Math.Max(exportHeight * scale, MinPreviewHeight);
 
-            // Compute dialog dimensions
             double dialogWidth = previewWidth + DialogHorizontalPadding;
             double dialogHeight = previewHeight + ControlsPanelHeight + DialogChromeHeight;
 
-            // Enforce min/max
             dialogWidth = Math.Clamp(dialogWidth, 500, maxDialogWidth);
             dialogHeight = Math.Clamp(dialogHeight, 450, maxDialogHeight);
 
@@ -287,14 +266,12 @@ private void UpdateDialogSize()
             _desiredPreviewWidth = previewWidth;
             _desiredPreviewHeight = previewHeight;
 
-            // Re-center on owner, clamped to the work area
             if (Owner != null)
             {
                 var workArea = SystemParameters.WorkArea;
                 double newLeft = Owner.Left + (Owner.ActualWidth - Width) / 2;
                 double newTop = Owner.Top + (Owner.ActualHeight - Height) / 2;
 
-                // Clamp to work area so the title bar stays accessible
                 Left = Math.Max(workArea.Left, Math.Min(newLeft, workArea.Right - Width));
                 Top = Math.Max(workArea.Top, Math.Min(newTop, workArea.Bottom - Height));
             }
@@ -312,13 +289,9 @@ private void UpdatePreview()
 
             if (_desiredPreviewWidth <= 0 || _desiredPreviewHeight <= 0) return;
 
-            // Render at exactly the desired preview dimensions so the preview
-            // is always the correct size, regardless of how much space the container has.
             int previewWidth = Math.Max((int)_desiredPreviewWidth, 100);
             int previewHeight = Math.Max((int)_desiredPreviewHeight, 100);
 
-            // Set explicit dimensions on the Image — with Stretch="None" and Center alignment,
-            // the preview is always exactly the right size even if the container is slightly larger.
             PreviewImage.Width = previewWidth;
             PreviewImage.Height = previewHeight;
 
@@ -350,7 +323,7 @@ private void UpdatePreview()
             }
             catch (Exception)
             {
-                // Silently handle preview render failures
+                // Preview is helpful but not required for export.
             }
         }
 
@@ -380,97 +353,156 @@ private bool TryGetExportDimensions(out int width, out int height)
         }
 
         /// <summary>
-        /// Gets the file extension for the currently selected file type.
+        /// Handles the Save As button click event to collect a file path and export the plot.
         /// </summary>
-        private string GetSelectedFileExtension()
+        private void SaveAsButton_Click(object sender, RoutedEventArgs e)
         {
-            return FileTypeComboBox.SelectedIndex switch
+            if (!TryValidateExportInputs(out int imageWidth, out int imageHeight)) return;
+
+            var saveFileDialog = CreateSaveFileDialog();
+            if (saveFileDialog.ShowDialog() != true) return;
+
+            string saveFile = GetExportFilePath(saveFileDialog.FileName, saveFileDialog.FilterIndex);
+            string extension = Path.GetExtension(saveFile).ToLowerInvariant();
+
+            try
             {
-                0 => ".png",
-                1 => ".pdf",
-                2 => ".svg",
-                _ => ".png"
-            };
+                if (_useReportTheme)
+                {
+                    OxyPlotThemeManager.WithThemedModel(_sourcePlot.ActualModel, OxyPlotThemeManager.ReportTheme, model =>
+                    {
+                        ExportModel(model, saveFile, extension, imageWidth, imageHeight);
+                    });
+                }
+                else
+                {
+                    ExportModel(_sourcePlot.ActualModel, saveFile, extension, imageWidth, imageHeight);
+                }
+            }
+            catch (Exception ex)
+            {
+                GenericControls.MessageBox.Show("Error occurred attempting to save the image file: " + ex.Message, "Cannot Save", MessageBoxButton.OK, MessageBoxImage.Error);
+                return;
+            }
+
+            _lastUsedFolderPath = Path.GetDirectoryName(saveFile) ?? string.Empty;
+            Close();
         }
 
-        /// <summary>
-        /// Handles the Save button click event to validate inputs and export the plot.
-        /// </summary>
-        private void SaveButton_Click(object sender, RoutedEventArgs e)
+        private bool TryValidateExportInputs(out int imageWidth, out int imageHeight)
         {
-            if (_sourcePlot == null) return;
+            imageWidth = 0;
+            imageHeight = 0;
+
             if (_sourcePlot.ActualModel == null)
             {
                 GenericControls.MessageBox.Show("The plot has no model to export.", "Cannot Save", MessageBoxButton.OK, MessageBoxImage.Error);
-                return;
+                return false;
             }
 
-            // Validate folder
-            string folderPath = FolderPathControl.Text?.Trim() ?? "";
-            if (string.IsNullOrEmpty(folderPath) || !Directory.Exists(folderPath))
+            if (!TryGetExportDimensions(out imageWidth, out imageHeight))
             {
-                GenericControls.MessageBox.Show("The specified directory does not exist. Please select a valid folder.", "Invalid Folder", MessageBoxButton.OK, MessageBoxImage.Error);
-                return;
+                GenericControls.MessageBox.Show("Image dimensions are not valid. Width and height must be between 50 and 10,000 pixels.", "Invalid Dimensions", MessageBoxButton.OK, MessageBoxImage.Error);
+                return false;
             }
 
-            // Validate file name
-            if (!FileNameTextBox.IsValid)
+            return true;
+        }
+
+        private SaveFileDialog CreateSaveFileDialog()
+        {
+            var saveFileDialog = new SaveFileDialog
             {
-                var errors = FileNameTextBox.GetErrorMessages();
-                string errorMessage = errors.Count > 0 ? string.Join("\n", errors) : "File name is not valid.";
-                GenericControls.MessageBox.Show(errorMessage, "Invalid Name", MessageBoxButton.OK, MessageBoxImage.Error);
-                return;
+                Title = "Save Plot Image As",
+                Filter = SaveFileFilter,
+                FilterIndex = PngFilterIndex,
+                DefaultExt = "png",
+                AddExtension = true,
+                OverwritePrompt = true,
+                ValidateNames = true,
+                CheckPathExists = true,
+                FileName = GetDefaultFileName(_sourcePlot.Model?.Title ?? _sourcePlot.ActualModel?.Title)
+            };
+
+            string initialDirectory = GetInitialDirectory();
+            if (Directory.Exists(initialDirectory))
+            {
+                saveFileDialog.InitialDirectory = initialDirectory;
             }
 
-            string fileName = FileNameTextBox.Text?.Trim() ?? "";
-            if (string.IsNullOrEmpty(fileName))
+            return saveFileDialog;
+        }
+
+        private static string GetInitialDirectory()
+        {
+            if (!string.IsNullOrEmpty(_lastUsedFolderPath) && Directory.Exists(_lastUsedFolderPath))
             {
-                GenericControls.MessageBox.Show("Please enter a file name.", "Invalid Name", MessageBoxButton.OK, MessageBoxImage.Error);
-                return;
+                return _lastUsedFolderPath;
             }
 
-            // Validate dimensions
-            if (!TryGetExportDimensions(out int imageWidth, out int imageHeight))
+            string picturesPath = Environment.GetFolderPath(Environment.SpecialFolder.MyPictures);
+            if (Directory.Exists(picturesPath))
             {
-                GenericControls.MessageBox.Show("Image dimensions are not valid. Width and height must be between 50 and 10,000 pixels.", "Invalid Dimensions", MessageBoxButton.OK, MessageBoxImage.Error);
-                return;
+                return picturesPath;
             }
 
-            // Construct full file path
-            string extension = GetSelectedFileExtension();
-            string saveFile = Path.Combine(folderPath, fileName + extension);
+            return Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
+        }
 
-            // Export
-            try
+        private static string GetDefaultFileName(string? plotTitle)
+        {
+            string source = string.IsNullOrWhiteSpace(plotTitle) ? "plot" : plotTitle.Trim();
+            char[] invalidCharacters = Path.GetInvalidFileNameChars();
+            var fileName = new char[source.Length];
+
+            for (int i = 0; i < source.Length; i++)
             {
-                if (_useReportTheme)
-                {
-                    OxyPlotThemeManager.WithThemedModel(_sourcePlot.ActualModel, OxyPlotThemeManager.ReportTheme, model =>
-                    {
-                        ExportModel(model, saveFile, extension, imageWidth, imageHeight);
-                    });
-                }
-                else
-                {
-                    ExportModel(_sourcePlot.ActualModel, saveFile, extension, imageWidth, imageHeight);
-                }
+                fileName[i] = Array.IndexOf(invalidCharacters, source[i]) >= 0 ? '_' : source[i];
             }
-            catch (Exception ex)
+
+            string sanitized = new string(fileName).Trim().TrimEnd('.');
+            if (sanitized.Length > DefaultFileNameMaxLength)
             {
-                GenericControls.MessageBox.Show("Error occurred attempting to save the image file: " + ex.Message, "Cannot Save", MessageBoxButton.OK, MessageBoxImage.Error);
-                return;
+                sanitized = sanitized.Substring(0, DefaultFileNameMaxLength).Trim().TrimEnd('.');
             }
 
-            _lastUsedFolderPath = folderPath;
-            Close();
+            return string.IsNullOrWhiteSpace(sanitized) ? "plot" : sanitized;
+        }
+
+        private static string GetExportFilePath(string filePath, int filterIndex)
+        {
+            string extension = Path.GetExtension(filePath).ToLowerInvariant();
+            if (IsSupportedExportExtension(extension))
+            {
+                return filePath;
+            }
+
+            return Path.ChangeExtension(filePath, GetExportExtensionForFilterIndex(filterIndex));
+        }
+
+        private static string GetExportExtensionForFilterIndex(int filterIndex)
+        {
+            return filterIndex switch
+            {
+                PdfFilterIndex => ".pdf",
+                SvgFilterIndex => ".svg",
+                _ => ".png"
+            };
+        }
+
+        private static bool IsSupportedExportExtension(string extension)
+        {
+            return string.Equals(extension, ".png", StringComparison.OrdinalIgnoreCase)
+                || string.Equals(extension, ".pdf", StringComparison.OrdinalIgnoreCase)
+                || string.Equals(extension, ".svg", StringComparison.OrdinalIgnoreCase);
         }
 
         /// <summary>
         /// Exports the given PlotModel to the specified file using the appropriate exporter.
         /// </summary>
-        private void ExportModel(OxyPlot.PlotModel model, string filePath, string extension, int width, int height)
+        private static void ExportModel(OxyPlot.PlotModel model, string filePath, string extension, int width, int height)
         {
-            switch (extension)
+            switch (extension.ToLowerInvariant())
             {
                 case ".png":
                     var exporter = new PngExporter { Width = width, Height = height, Background = model.Background };
@@ -491,6 +523,8 @@ private void ExportModel(OxyPlot.PlotModel model, string filePath, string extens
                         OxyPlot.Wpf.WpfPdfExporter.Export(model, fs, width, height);
                     }
                     break;
+                default:
+                    throw new NotSupportedException("Unsupported plot export format: " + extension);
             }
         }
 
@@ -501,50 +535,5 @@ private void CancelButton_Click(object sender, RoutedEventArgs e)
         {
             Close();
         }
-
-        /// <summary>
-        /// Handles the SelectionChanged event of the FileTypeComboBox to refresh the existing file names list.
-        /// </summary>
-        private void FileTypeComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
-        {
-            if (!_isInitialized) return;
-            UpdateExistingFileNames();
-        }
-
-        /// <summary>
-        /// Handles the TextChanged event of the FolderPathControl to refresh the existing file names list.
-        /// </summary>
-        private void FolderPathControl_TextChanged(object sender, TextChangedEventArgs e)
-        {
-            if (!_isInitialized) return;
-            UpdateExistingFileNames();
-        }
-
-        /// <summary>
-        /// Updates the NameTextBox InvalidStrings with existing file names (without extension)
-        /// in the selected directory that match the selected file type.
-        /// </summary>
-        private void UpdateExistingFileNames()
-        {
-            string folder = FolderPathControl.Text?.Trim() ?? "";
-            if (!Directory.Exists(folder))
-            {
-                FileNameTextBox.InvalidStrings = Array.Empty<string>();
-                return;
-            }
-
-            try
-            {
-                string extension = GetSelectedFileExtension();
-                var existingNames = Directory.GetFiles(folder, "*" + extension)
-                    .Select(f => Path.GetFileNameWithoutExtension(f))
-                    .ToArray();
-                FileNameTextBox.InvalidStrings = existingNames;
-            }
-            catch (Exception)
-            {
-                FileNameTextBox.InvalidStrings = Array.Empty<string>();
-            }
-        }
     }
 }
diff --git a/tests/OxyPlotControls.Tests/SavePlotImageDialog/SavePlotImageDialogTests.cs b/tests/OxyPlotControls.Tests/SavePlotImageDialog/SavePlotImageDialogTests.cs
index 99643f02..13c3729e 100644
--- a/tests/OxyPlotControls.Tests/SavePlotImageDialog/SavePlotImageDialogTests.cs
+++ b/tests/OxyPlotControls.Tests/SavePlotImageDialog/SavePlotImageDialogTests.cs
@@ -1,26 +1,26 @@
 using System.IO;
+using System.Reflection;
 using System.Windows;
+using Microsoft.Win32;
 using OxyPlot;
-using OxyPlot.Series;
 using OxyPlot.Wpf;
-using OxyPlotControls;
 using Xunit;
 
 namespace OxyPlotControls.Tests.SavePlotImageDialog;
 
 /// <summary>
 /// Unit tests for the SavePlotImageDialog.
-/// Tests construction, preset parsing, custom mode, and file name validation.
+/// Tests construction, export options, native Save As configuration, and file export.
 /// </summary>
 public class SavePlotImageDialogTests
 {
     /// <summary>
     /// Creates a Plot control with a simple PlotModel for testing.
     /// </summary>
-    private static Plot CreateTestPlot()
+    private static Plot CreateTestPlot(string? title = "Test Plot")
     {
         var plot = new Plot();
-        var model = new PlotModel { Title = "Test Plot" };
+        var model = new PlotModel { Title = title };
         model.Series.Add(new OxyPlot.Series.LineSeries());
         plot.Model = model;
         return plot;
@@ -34,53 +34,39 @@ private static Plot CreateTestPlot()
     [StaFact]
     public void Constructor_WithValidPlot_DoesNotThrow()
     {
-        // Arrange
         var plot = CreateTestPlot();
 
-        // Act & Assert
         var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
+
         Assert.NotNull(dialog);
     }
 
     /// <summary>
-    /// Verifies that the dialog title is set correctly.
+    /// Verifies that the dialog title reflects export settings rather than file selection.
     /// </summary>
     [StaFact]
     public void Constructor_WithValidPlot_TitleIsSetCorrectly()
     {
-        // Arrange
         var plot = CreateTestPlot();
 
-        // Act
         var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
 
-        // Assert
-        Assert.Equal("Save Plot Image", dialog.Title);
+        Assert.Equal("Export Plot Image", dialog.Title);
     }
 
     /// <summary>
     /// Verifies that the dialog initial size is computed from the default preset (600x480) and
-    /// falls within the expected bounds. The exact dialog size depends on
-    /// <see cref="System.Windows.SystemParameters.WorkArea"/>, which varies by display/DPI and
-    /// between interactive and headless (CI) environments, so the assertion uses tolerant ranges
-    /// rather than exact pixel values.
+    /// falls within the expected bounds. The exact dialog size depends on display/DPI and CI.
     /// </summary>
     [StaFact]
     public void Constructor_WithValidPlot_HasCorrectInitialSize()
     {
-        // Arrange
         var plot = CreateTestPlot();
 
-        // Act
         var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
 
-        // Assert — initial size computed from default 600x480 preset:
-        //   width  = 600 + 36 (padding)                       ≈ 636 on a typical display
-        //   height = 480 + 190 (controls) + 50 (chrome)       ≈ 720 on a typical display
-        // Both are clamped to at least MinWidth/MinHeight and at most WorkArea * ScreenUsageFraction,
-        // so CI's smaller WorkArea can produce slightly smaller values.
         Assert.InRange(dialog.Width, dialog.MinWidth, 800);
-        Assert.InRange(dialog.Height, dialog.MinHeight, 900);
+        Assert.InRange(dialog.Height, dialog.MinHeight, 800);
     }
 
     /// <summary>
@@ -89,13 +75,10 @@ public void Constructor_WithValidPlot_HasCorrectInitialSize()
     [StaFact]
     public void Constructor_WithValidPlot_HasCorrectMinimumSize()
     {
-        // Arrange
         var plot = CreateTestPlot();
 
-        // Act
         var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
 
-        // Assert
         Assert.Equal(500, dialog.MinWidth);
         Assert.Equal(450, dialog.MinHeight);
     }
@@ -105,21 +88,18 @@ public void Constructor_WithValidPlot_HasCorrectMinimumSize()
     #region Image Size Preset Tests
 
     /// <summary>
-    /// Verifies that the ImageSizeComboBox has all 10 preset items plus Custom.
+    /// Verifies that the ImageSizeComboBox has all 9 preset items plus Custom.
     /// </summary>
     [StaFact]
     public void ImageSizeComboBox_HasCorrectItemCount()
     {
-        // Arrange
         var plot = CreateTestPlot();
         var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
 
-        // Act
         var comboBox = (System.Windows.Controls.ComboBox)dialog.FindName("ImageSizeComboBox");
 
-        // Assert
         Assert.NotNull(comboBox);
-        Assert.Equal(10, comboBox.Items.Count); // 9 presets + Custom
+        Assert.Equal(10, comboBox.Items.Count);
     }
 
     /// <summary>
@@ -128,14 +108,11 @@ public void ImageSizeComboBox_HasCorrectItemCount()
     [StaFact]
     public void ImageSizeComboBox_DefaultSelectionIsFirstPreset()
     {
-        // Arrange
         var plot = CreateTestPlot();
         var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
 
-        // Act
         var comboBox = (System.Windows.Controls.ComboBox)dialog.FindName("ImageSizeComboBox");
 
-        // Assert
         Assert.NotNull(comboBox);
         Assert.Equal(0, comboBox.SelectedIndex);
     }
@@ -146,15 +123,12 @@ public void ImageSizeComboBox_DefaultSelectionIsFirstPreset()
     [StaFact]
     public void ImageSizeComboBox_LastItemIsCustom()
     {
-        // Arrange
         var plot = CreateTestPlot();
         var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
 
-        // Act
         var comboBox = (System.Windows.Controls.ComboBox)dialog.FindName("ImageSizeComboBox");
         var lastItem = (System.Windows.Controls.ComboBoxItem)comboBox!.Items[comboBox.Items.Count - 1];
 
-        // Assert
         Assert.Equal("Custom", lastItem.Content.ToString());
     }
 
@@ -164,17 +138,14 @@ public void ImageSizeComboBox_LastItemIsCustom()
     [StaFact]
     public void ImageSizeComboBox_PresetsContainExpectedFormat()
     {
-        // Arrange
         var plot = CreateTestPlot();
         var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
         var comboBox = (System.Windows.Controls.ComboBox)dialog.FindName("ImageSizeComboBox");
 
-        // Act & Assert - verify first preset is "600 x 480 (5:4)"
         var firstItem = (System.Windows.Controls.ComboBoxItem)comboBox!.Items[0];
-        Assert.Equal("600 x 480 (5:4)", firstItem.Content.ToString());
-
-        // Verify 1920x1080 preset exists
         var fullHdItem = (System.Windows.Controls.ComboBoxItem)comboBox.Items[5];
+
+        Assert.Equal("600 x 480 (5:4)", firstItem.Content.ToString());
         Assert.Equal("1920 x 1080 (16:9)", fullHdItem.Content.ToString());
     }
 
@@ -188,14 +159,11 @@ public void ImageSizeComboBox_PresetsContainExpectedFormat()
     [StaFact]
     public void CustomDimensionsPanel_IsCollapsedByDefault()
     {
-        // Arrange
         var plot = CreateTestPlot();
         var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
 
-        // Act
         var panel = (System.Windows.Controls.Grid)dialog.FindName("CustomDimensionsPanel");
 
-        // Assert
         Assert.NotNull(panel);
         Assert.Equal(Visibility.Collapsed, panel.Visibility);
     }
@@ -206,15 +174,12 @@ public void CustomDimensionsPanel_IsCollapsedByDefault()
     [StaFact]
     public void DimensionTextBoxes_AreDisabledByDefault()
     {
-        // Arrange
         var plot = CreateTestPlot();
         var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
 
-        // Act
         var widthBox = (GenericControls.NumericTextBox)dialog.FindName("WidthTextBox");
         var heightBox = (GenericControls.NumericTextBox)dialog.FindName("HeightTextBox");
 
-        // Assert
         Assert.NotNull(widthBox);
         Assert.NotNull(heightBox);
         Assert.False(widthBox.IsEnabled);
@@ -223,142 +188,115 @@ public void DimensionTextBoxes_AreDisabledByDefault()
 
     #endregion
 
-    #region File Type Tests
+    #region Native Save As Tests
 
     /// <summary>
-    /// Verifies that the FileTypeComboBox has PNG, PDF, and SVG options.
+    /// Verifies that custom file-picking controls are no longer part of the export window.
     /// </summary>
     [StaFact]
-    public void FileTypeComboBox_HasThreeOptions()
+    public void CustomFilePickerControls_AreRemoved()
     {
-        // Arrange
         var plot = CreateTestPlot();
         var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
 
-        // Act
-        var comboBox = (System.Windows.Controls.ComboBox)dialog.FindName("FileTypeComboBox");
-
-        // Assert
-        Assert.NotNull(comboBox);
-        Assert.Equal(3, comboBox.Items.Count);
+        Assert.Null(dialog.FindName("FileTypeComboBox"));
+        Assert.Null(dialog.FindName("FolderPathControl"));
+        Assert.Null(dialog.FindName("FileNameTextBox"));
     }
 
     /// <summary>
-    /// Verifies that PNG is the default selected file type.
+    /// Verifies that the native SaveFileDialog is configured like a traditional Save As dialog.
     /// </summary>
     [StaFact]
-    public void FileTypeComboBox_DefaultIsPng()
+    public void CreateSaveFileDialog_UsesExpectedConfiguration()
     {
-        // Arrange
-        var plot = CreateTestPlot();
+        var plot = CreateTestPlot("Hydrograph: Test/Run");
         var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
 
-        // Act
-        var comboBox = (System.Windows.Controls.ComboBox)dialog.FindName("FileTypeComboBox");
-        var selectedItem = (System.Windows.Controls.ComboBoxItem)comboBox!.SelectedItem;
-
-        // Assert
-        Assert.Equal(0, comboBox.SelectedIndex);
-        Assert.Equal("PNG (.png)", selectedItem.Content.ToString());
+        var saveFileDialog = InvokePrivateInstance<SaveFileDialog>(dialog, "CreateSaveFileDialog");
+
+        Assert.Equal("Save Plot Image As", saveFileDialog.Title);
+        Assert.Equal("PNG Image (*.png)|*.png|PDF Document (*.pdf)|*.pdf|SVG Vector Image (*.svg)|*.svg", saveFileDialog.Filter);
+        Assert.Equal(1, saveFileDialog.FilterIndex);
+        Assert.Equal("png", saveFileDialog.DefaultExt);
+        Assert.True(saveFileDialog.AddExtension);
+        Assert.True(saveFileDialog.OverwritePrompt);
+        Assert.True(saveFileDialog.ValidateNames);
+        Assert.True(saveFileDialog.CheckPathExists);
+        Assert.Equal("Hydrograph_ Test_Run", saveFileDialog.FileName);
     }
 
     /// <summary>
-    /// Verifies that all file type options have correct display text.
+    /// Verifies that blank plot titles fall back to a simple default file name.
     /// </summary>
     [StaFact]
-    public void FileTypeComboBox_HasCorrectDisplayText()
+    public void GetDefaultFileName_BlankTitle_ReturnsPlot()
     {
-        // Arrange
-        var plot = CreateTestPlot();
-        var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
-        var comboBox = (System.Windows.Controls.ComboBox)dialog.FindName("FileTypeComboBox");
-
-        // Act & Assert
-        var pngItem = (System.Windows.Controls.ComboBoxItem)comboBox!.Items[0];
-        var pdfItem = (System.Windows.Controls.ComboBoxItem)comboBox.Items[1];
-        var svgItem = (System.Windows.Controls.ComboBoxItem)comboBox.Items[2];
+        var fileName = InvokePrivateStatic<string>("GetDefaultFileName", "   ");
 
-        Assert.Equal("PNG (.png)", pngItem.Content.ToString());
-        Assert.Equal("PDF (.pdf)", pdfItem.Content.ToString());
-        Assert.Equal("SVG (.svg)", svgItem.Content.ToString());
+        Assert.Equal("plot", fileName);
     }
 
-    #endregion
+    /// <summary>
+    /// Verifies that default file names do not contain invalid Windows filename characters.
+    /// </summary>
+    [StaFact]
+    public void GetDefaultFileName_InvalidCharacters_AreReplaced()
+    {
+        var fileName = InvokePrivateStatic<string>("GetDefaultFileName", "A:B/C*D?");
 
-    #region File Name Validation Tests
+        Assert.DoesNotContain(fileName, c => Array.IndexOf(Path.GetInvalidFileNameChars(), c) >= 0);
+        Assert.Contains("_", fileName);
+    }
 
     /// <summary>
-    /// Verifies that the NameTextBox is configured to not allow blank names.
+    /// Verifies that supported user-entered extensions are honored even when the selected filter differs.
     /// </summary>
     [StaFact]
-    public void FileNameTextBox_CannotBeBlank()
+    public void GetExportFilePath_WithSupportedExtension_HonorsExtension()
     {
-        // Arrange
-        var plot = CreateTestPlot();
-        var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
+        string path = Path.Combine("C:\\Temp", "chart.svg");
 
-        // Act
-        var nameBox = (GenericControls.NameTextBox)dialog.FindName("FileNameTextBox");
+        var exportPath = InvokePrivateStatic<string>("GetExportFilePath", path, 1);
 
-        // Assert
-        Assert.NotNull(nameBox);
-        Assert.False(nameBox.CanBeBlank);
+        Assert.Equal(path, exportPath);
     }
 
     /// <summary>
-    /// Verifies that the NameTextBox character limit is 200.
+    /// Verifies that a missing extension uses the selected filter extension.
     /// </summary>
     [StaFact]
-    public void FileNameTextBox_CharacterLimitIs200()
+    public void GetExportFilePath_WithoutExtension_AddsFilterExtension()
     {
-        // Arrange
-        var plot = CreateTestPlot();
-        var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
+        string path = Path.Combine("C:\\Temp", "chart");
 
-        // Act
-        var nameBox = (GenericControls.NameTextBox)dialog.FindName("FileNameTextBox");
+        var exportPath = InvokePrivateStatic<string>("GetExportFilePath", path, 2);
 
-        // Assert
-        Assert.NotNull(nameBox);
-        Assert.Equal(200, nameBox.CharacterLimit);
+        Assert.Equal(Path.Combine("C:\\Temp", "chart.pdf"), exportPath);
     }
 
     /// <summary>
-    /// Verifies that setting InvalidStrings marks a matching name as invalid.
+    /// Verifies that unsupported extensions are replaced by the selected filter extension.
     /// </summary>
     [StaFact]
-    public void FileNameTextBox_DuplicateName_IsInvalid()
+    public void GetExportFilePath_WithUnsupportedExtension_ReplacesWithFilterExtension()
     {
-        // Arrange
-        var plot = CreateTestPlot();
-        var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
-        var nameBox = (GenericControls.NameTextBox)dialog.FindName("FileNameTextBox");
+        string path = Path.Combine("C:\\Temp", "chart.txt");
 
-        // Act
-        nameBox!.InvalidStrings = new[] { "existing_file", "another_file" };
-        nameBox.Text = "existing_file";
+        var exportPath = InvokePrivateStatic<string>("GetExportFilePath", path, 3);
 
-        // Assert
-        Assert.False(nameBox.IsValid);
+        Assert.Equal(Path.Combine("C:\\Temp", "chart.svg"), exportPath);
     }
 
     /// <summary>
-    /// Verifies that a unique name is valid when InvalidStrings are set.
+    /// Verifies that unknown filter indexes fall back to PNG.
     /// </summary>
     [StaFact]
-    public void FileNameTextBox_UniqueName_IsValid()
+    public void GetExportExtensionForFilterIndex_UnknownIndex_ReturnsPng()
     {
-        // Arrange
-        var plot = CreateTestPlot();
-        var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
-        var nameBox = (GenericControls.NameTextBox)dialog.FindName("FileNameTextBox");
-
-        // Act
-        nameBox!.InvalidStrings = new[] { "existing_file", "another_file" };
-        nameBox.Text = "new_unique_name";
+        var extension = InvokePrivateStatic<string>("GetExportExtensionForFilterIndex", 99);
 
-        // Assert
-        Assert.True(nameBox.IsValid);
+        Assert.Equal(".png", extension);
     }
 
     #endregion
@@ -371,15 +309,12 @@ public void FileNameTextBox_UniqueName_IsValid()
     [StaFact]
     public void PreviewContainer_Exists()
     {
-        // Arrange
         var plot = CreateTestPlot();
         var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
 
-        // Act
         var container = (System.Windows.Controls.Grid)dialog.FindName("PreviewContainer");
         var image = (System.Windows.Controls.Image)dialog.FindName("PreviewImage");
 
-        // Assert
         Assert.NotNull(container);
         Assert.NotNull(image);
     }
@@ -390,14 +325,11 @@ public void PreviewContainer_Exists()
     [StaFact]
     public void PreviewImage_UsesHighQualityScaling()
     {
-        // Arrange
         var plot = CreateTestPlot();
         var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
 
-        // Act
         var image = (System.Windows.Controls.Image)dialog.FindName("PreviewImage");
 
-        // Assert
         Assert.NotNull(image);
         Assert.Equal(System.Windows.Media.BitmapScalingMode.HighQuality,
                      System.Windows.Media.RenderOptions.GetBitmapScalingMode(image));
@@ -408,22 +340,19 @@ public void PreviewImage_UsesHighQualityScaling()
     #region Button Tests
 
     /// <summary>
-    /// Verifies that the Save button exists and is the default button.
+    /// Verifies that the Save As button exists and is the default button.
     /// </summary>
     [StaFact]
-    public void SaveButton_IsDefault()
+    public void SaveAsButton_IsDefault()
     {
-        // Arrange
         var plot = CreateTestPlot();
         var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
 
-        // Act
-        var saveButton = (System.Windows.Controls.Button)dialog.FindName("SaveButton");
+        var saveAsButton = (System.Windows.Controls.Button)dialog.FindName("SaveAsButton");
 
-        // Assert
-        Assert.NotNull(saveButton);
-        Assert.True(saveButton.IsDefault);
-        Assert.Equal("Save", saveButton.Content.ToString());
+        Assert.NotNull(saveAsButton);
+        Assert.True(saveAsButton.IsDefault);
+        Assert.Equal("Save As...", saveAsButton.Content.ToString());
     }
 
     /// <summary>
@@ -432,36 +361,30 @@ public void SaveButton_IsDefault()
     [StaFact]
     public void CancelButton_IsCancel()
     {
-        // Arrange
         var plot = CreateTestPlot();
         var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
 
-        // Act
         var cancelButton = (System.Windows.Controls.Button)dialog.FindName("CancelButton");
 
-        // Assert
         Assert.NotNull(cancelButton);
         Assert.True(cancelButton.IsCancel);
         Assert.Equal("Cancel", cancelButton.Content.ToString());
     }
 
     /// <summary>
-    /// Verifies that both buttons have consistent dimensions matching NameDialog pattern.
+    /// Verifies that both buttons have consistent dimensions.
     /// </summary>
     [StaFact]
     public void Buttons_HaveConsistentDimensions()
     {
-        // Arrange
         var plot = CreateTestPlot();
         var dialog = new OxyPlotControls.SavePlotImageDialog(plot);
 
-        // Act
-        var saveButton = (System.Windows.Controls.Button)dialog.FindName("SaveButton");
+        var saveAsButton = (System.Windows.Controls.Button)dialog.FindName("SaveAsButton");
         var cancelButton = (System.Windows.Controls.Button)dialog.FindName("CancelButton");
 
-        // Assert - both should be 75x24 matching NameDialog pattern
-        Assert.Equal(75, saveButton!.Width);
-        Assert.Equal(24, saveButton.Height);
+        Assert.Equal(90, saveAsButton!.Width);
+        Assert.Equal(24, saveAsButton.Height);
         Assert.Equal(75, cancelButton!.Width);
         Assert.Equal(24, cancelButton.Height);
     }
@@ -476,26 +399,7 @@ public void Buttons_HaveConsistentDimensions()
     [StaFact]
     public void Export_Png_CreatesFile()
     {
-        // Arrange
-        var plot = CreateTestPlot();
-        string tempDir = Path.Combine(Path.GetTempPath(), "SavePlotImageDialogTests_" + Guid.NewGuid().ToString("N"));
-        Directory.CreateDirectory(tempDir);
-
-        try
-        {
-            string filePath = Path.Combine(tempDir, "test_export.png");
-
-            // Act
-            plot.SaveBitmap(filePath, 600, 480, OxyColors.White);
-
-            // Assert
-            Assert.True(File.Exists(filePath));
-            Assert.True(new FileInfo(filePath).Length > 0);
-        }
-        finally
-        {
-            Directory.Delete(tempDir, true);
-        }
+        AssertExportCreatesFile(".png");
     }
 
     /// <summary>
@@ -504,29 +408,7 @@ public void Export_Png_CreatesFile()
     [StaFact]
     public void Export_Svg_CreatesFile()
     {
-        // Arrange
-        var plot = CreateTestPlot();
-        string tempDir = Path.Combine(Path.GetTempPath(), "SavePlotImageDialogTests_" + Guid.NewGuid().ToString("N"));
-        Directory.CreateDirectory(tempDir);
-
-        try
-        {
-            string filePath = Path.Combine(tempDir, "test_export.svg");
-
-            // Act
-            using (var fs = new FileStream(filePath, FileMode.Create))
-            {
-                OxyPlot.SvgExporter.Export(plot.Model, fs, 600, 480, true);
-            }
-
-            // Assert
-            Assert.True(File.Exists(filePath));
-            Assert.True(new FileInfo(filePath).Length > 0);
-        }
-        finally
-        {
-            Directory.Delete(tempDir, true);
-        }
+        AssertExportCreatesFile(".svg");
     }
 
     /// <summary>
@@ -535,24 +417,21 @@ public void Export_Svg_CreatesFile()
     [StaFact]
     public void Export_Pdf_CreatesFile()
     {
-        // Arrange
+        AssertExportCreatesFile(".pdf");
+    }
+
+    private static void AssertExportCreatesFile(string extension)
+    {
         var plot = CreateTestPlot();
         string tempDir = Path.Combine(Path.GetTempPath(), "SavePlotImageDialogTests_" + Guid.NewGuid().ToString("N"));
         Directory.CreateDirectory(tempDir);
 
         try
         {
-            string filePath = Path.Combine(tempDir, "test_export.pdf");
+            string filePath = Path.Combine(tempDir, "test_export" + extension);
 
-            // Act
-            using (var fs = new FileStream(filePath, FileMode.Create))
-            {
-#pragma warning disable CS0618
-                OxyPlot.PdfExporter.Export(plot.Model, fs, 600, 480);
-#pragma warning restore CS0618
-            }
+            InvokePrivateStatic("ExportModel", plot.Model!, filePath, extension, 600, 480);
 
-            // Assert
             Assert.True(File.Exists(filePath));
             Assert.True(new FileInfo(filePath).Length > 0);
         }
@@ -563,4 +442,30 @@ public void Export_Pdf_CreatesFile()
     }
 
     #endregion
+
+    private static T InvokePrivateStatic<T>(string methodName, params object?[] parameters)
+    {
+        var method = typeof(OxyPlotControls.SavePlotImageDialog).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Static);
+        Assert.NotNull(method);
+
+        var result = method!.Invoke(null, parameters);
+        return Assert.IsType<T>(result);
+    }
+
+    private static void InvokePrivateStatic(string methodName, params object?[] parameters)
+    {
+        var method = typeof(OxyPlotControls.SavePlotImageDialog).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Static);
+        Assert.NotNull(method);
+
+        method!.Invoke(null, parameters);
+    }
+
+    private static T InvokePrivateInstance<T>(object instance, string methodName, params object?[] parameters)
+    {
+        var method = typeof(OxyPlotControls.SavePlotImageDialog).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
+        Assert.NotNull(method);
+
+        var result = method!.Invoke(instance, parameters);
+        return Assert.IsType<T>(result);
+    }
 }

From 9af082aed9e205634327112a8dc9c81d13e2930a Mon Sep 17 00:00:00 2001
From: HadenSmith <cole.h.smith@usace.army.mil>
Date: Tue, 30 Jun 2026 08:17:34 -0600
Subject: [PATCH 07/11] fix: disable legend item visibility toggle by default

---
 src/OxyPlot/OxyPlot.Wpf/Plot.cs               |  19 +++
 .../Serialization/PlotSerializer.cs           |   7 +-
 src/OxyPlot/OxyPlot/Legends/Legend.cs         |   8 +-
 .../Legends/LegendHitTestTests.cs             | 111 ++++++++++++++++++
 .../Serialization/LegendSerializationTests.cs |  24 ++++
 5 files changed, 167 insertions(+), 2 deletions(-)
 create mode 100644 tests/OxyPlot.Tests/Legends/LegendHitTestTests.cs

diff --git a/src/OxyPlot/OxyPlot.Wpf/Plot.cs b/src/OxyPlot/OxyPlot.Wpf/Plot.cs
index d4b0d456..cb90f2f3 100644
--- a/src/OxyPlot/OxyPlot.Wpf/Plot.cs
+++ b/src/OxyPlot/OxyPlot.Wpf/Plot.cs
@@ -285,6 +285,15 @@ protected void OnPropertyChanged(string propertyName)
             typeof(Plot),
             new PropertyMetadata(System.Windows.HorizontalAlignment.Left, AppearanceChanged));
 
+        /// <summary>
+        /// Identifies the <see cref="LegendItemClickTogglesSeriesVisibility"/> dependency property.
+        /// </summary>
+        public static readonly DependencyProperty LegendItemClickTogglesSeriesVisibilityProperty = DependencyProperty.Register(
+            nameof(LegendItemClickTogglesSeriesVisibility),
+            typeof(bool),
+            typeof(Plot),
+            new PropertyMetadata(false, AppearanceChanged));
+
         /// <summary>
         /// Identifies the <see cref="LegendItemOrder"/> dependency property.
         /// </summary>
@@ -922,6 +931,15 @@ public System.Windows.HorizontalAlignment LegendItemAlignment
             set => this.SetValue(LegendItemAlignmentProperty, value);
         }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether clicking a legend item toggles the corresponding series visibility.
+        /// </summary>
+        public bool LegendItemClickTogglesSeriesVisibility
+        {
+            get => (bool)this.GetValue(LegendItemClickTogglesSeriesVisibilityProperty);
+            set => this.SetValue(LegendItemClickTogglesSeriesVisibilityProperty, value);
+        }
+
         /// <summary>
         /// Gets or sets the legend item order.
         /// </summary>
@@ -1617,6 +1635,7 @@ private void SynchronizeLegend()
             legend.LegendBorder = this.LegendBorder.ToOxyColor();
             legend.LegendBorderThickness = this.LegendBorderThickness;
             legend.LegendItemAlignment = this.LegendItemAlignment.ToHorizontalAlignment();
+            legend.LegendItemClickTogglesSeriesVisibility = this.LegendItemClickTogglesSeriesVisibility;
             legend.LegendItemOrder = this.LegendItemOrder;
             legend.LegendItemSpacing = this.LegendItemSpacing;
             legend.LegendLineSpacing = this.LegendLineSpacing;
diff --git a/src/OxyPlot/OxyPlot.Wpf/Serialization/PlotSerializer.cs b/src/OxyPlot/OxyPlot.Wpf/Serialization/PlotSerializer.cs
index b210e827..1b8f8696 100644
--- a/src/OxyPlot/OxyPlot.Wpf/Serialization/PlotSerializer.cs
+++ b/src/OxyPlot/OxyPlot.Wpf/Serialization/PlotSerializer.cs
@@ -98,7 +98,8 @@ public static class PlotSerializer
             "LegendTitle", "LegendTitleColor", "LegendTitleFont", "LegendTitleFontSize", "LegendTitleFontWeight",
             "LegendTextColor", "LegendFont", "LegendFontSize", "LegendFontWeight",
             "LegendSymbolLength", "LegendSymbolMargin", "LegendSymbolPlacement",
-            "LegendColumnSpacing", "LegendItemAlignment", "LegendItemOrder", "LegendItemSpacing", "LegendLineSpacing",
+            "LegendColumnSpacing", "LegendItemAlignment", "LegendItemClickTogglesSeriesVisibility",
+            "LegendItemOrder", "LegendItemSpacing", "LegendLineSpacing",
         };
 
         #endregion
@@ -424,6 +425,7 @@ public static XElement LegendPropertiesToXElement(Plot plot)
             itemProperties.SetAttributeValue(nameof(plot.LegendSymbolPlacement), plot.LegendSymbolPlacement.ToString());
             itemProperties.SetAttributeValue(nameof(plot.LegendColumnSpacing), plot.LegendColumnSpacing.ToString("G17", CultureInfo.InvariantCulture));
             itemProperties.SetAttributeValue(nameof(plot.LegendItemAlignment), plot.LegendItemAlignment.ToString());
+            itemProperties.SetAttributeValue(nameof(plot.LegendItemClickTogglesSeriesVisibility), plot.LegendItemClickTogglesSeriesVisibility);
             itemProperties.SetAttributeValue(nameof(plot.LegendItemOrder), plot.LegendItemOrder.ToString());
             itemProperties.SetAttributeValue(nameof(plot.LegendItemSpacing), plot.LegendItemSpacing.ToString("G17", CultureInfo.InvariantCulture));
             itemProperties.SetAttributeValue(nameof(plot.LegendLineSpacing), plot.LegendLineSpacing.ToString("G17", CultureInfo.InvariantCulture));
@@ -562,6 +564,9 @@ public static void XElementToLegendProperties(Plot plot, XElement element)
                 System.Windows.HorizontalAlignment legendItemAlignment;
                 if (GetEnumAttribute(itemsElement, nameof(plot.LegendItemAlignment), out legendItemAlignment)) plot.LegendItemAlignment = legendItemAlignment;
 
+                bool legendItemClickTogglesSeriesVisibility;
+                if (GetBooleanAttribute(itemsElement, nameof(plot.LegendItemClickTogglesSeriesVisibility), out legendItemClickTogglesSeriesVisibility)) plot.LegendItemClickTogglesSeriesVisibility = legendItemClickTogglesSeriesVisibility;
+
                 LegendItemOrder legendItemOrder;
                 if (GetEnumAttribute(itemsElement, nameof(plot.LegendItemOrder), out legendItemOrder)) plot.LegendItemOrder = legendItemOrder;
 
diff --git a/src/OxyPlot/OxyPlot/Legends/Legend.cs b/src/OxyPlot/OxyPlot/Legends/Legend.cs
index 28379570..cdc44f86 100644
--- a/src/OxyPlot/OxyPlot/Legends/Legend.cs
+++ b/src/OxyPlot/OxyPlot/Legends/Legend.cs
@@ -60,6 +60,7 @@ public Legend()
             this.LegendItemAlignment = HorizontalAlignment.Left;
             this.LegendSymbolPlacement = LegendSymbolPlacement.Left;
 
+            this.LegendItemClickTogglesSeriesVisibility = false;
             this.ShowInvisibleSeries = true;
 
             this.SeriesInvisibleTextColor = OxyColor.FromAColor(64, this.LegendTextColor);
@@ -91,7 +92,7 @@ protected override HitTestResult LegendHitTest(HitTestArguments args)
                     {
                         if (kvp.Value.Contains(point))
                         {
-                            if (this.ShowInvisibleSeries)
+                            if (this.LegendItemClickTogglesSeriesVisibility && this.ShowInvisibleSeries)
                             {
                                 kvp.Key.IsVisible = !kvp.Key.IsVisible;
                                 this.PlotModel.InvalidatePlot(false);
@@ -132,6 +133,11 @@ public double GroupNameFontWeight
             set;
         }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether clicking a legend item toggles the corresponding series visibility.
+        /// </summary>
+        public bool LegendItemClickTogglesSeriesVisibility { get; set; }
+
         private Dictionary<Series.Series, OxyRect> SeriesPosMap { get; set; }
 
         /// <summary>
diff --git a/tests/OxyPlot.Tests/Legends/LegendHitTestTests.cs b/tests/OxyPlot.Tests/Legends/LegendHitTestTests.cs
new file mode 100644
index 00000000..e263f71c
--- /dev/null
+++ b/tests/OxyPlot.Tests/Legends/LegendHitTestTests.cs
@@ -0,0 +1,111 @@
+namespace OxyPlot.Tests.Legends
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using NUnit.Framework;
+    using OxyPlot.Legends;
+    using OxyPlot.Series;
+
+    [TestFixture]
+    public class LegendHitTestTests
+    {
+        [Test]
+        public void HandleMouseDown_LegendItemClick_DefaultDoesNotToggleSeriesVisibilityAndBubbles()
+        {
+            var model = CreateModel(out var series, out var legend);
+            legend.LegendItemClickTogglesSeriesVisibility = false;
+            var clickPosition = GetLegendTextClickPosition(model, series.Title);
+            var mouseDownRaised = false;
+            model.MouseDown += (s, e) => mouseDownRaised = true;
+
+            model.HandleMouseDown(
+                this,
+                new OxyMouseDownEventArgs
+                {
+                    ChangedButton = OxyMouseButton.Left,
+                    Position = clickPosition
+                });
+
+            Assert.IsTrue(mouseDownRaised);
+            Assert.IsTrue(series.IsVisible);
+        }
+
+        [Test]
+        public void HandleMouseDown_LegendItemClick_WhenEnabledTogglesSeriesVisibilityAndBubbles()
+        {
+            var model = CreateModel(out var series, out var legend);
+            legend.LegendItemClickTogglesSeriesVisibility = true;
+            var clickPosition = GetLegendTextClickPosition(model, series.Title);
+            var mouseDownRaised = false;
+            model.MouseDown += (s, e) => mouseDownRaised = true;
+
+            model.HandleMouseDown(
+                this,
+                new OxyMouseDownEventArgs
+                {
+                    ChangedButton = OxyMouseButton.Left,
+                    Position = clickPosition
+                });
+
+            Assert.IsTrue(mouseDownRaised);
+            Assert.IsFalse(series.IsVisible);
+        }
+
+        private static PlotModel CreateModel(out LineSeries series, out Legend legend)
+        {
+            var model = new PlotModel();
+            legend = new Legend();
+            model.Legends.Add(legend);
+
+            series = new LineSeries { Title = "Series 1" };
+            series.Points.Add(new DataPoint(0, 0));
+            series.Points.Add(new DataPoint(1, 1));
+            model.Series.Add(series);
+
+            return model;
+        }
+
+        private static ScreenPoint GetLegendTextClickPosition(PlotModel model, string title)
+        {
+            var rc = new RecordingRenderContext();
+            ((IPlotModel)model).Update(true);
+            ((IPlotModel)model).Render(rc, new OxyRect(0, 0, 500, 300));
+
+            var legendText = rc.DrawnTexts.Single(t => t.Text == title);
+            return new ScreenPoint(legendText.Point.X + 1, legendText.Point.Y + 1);
+        }
+
+        private sealed class RecordingRenderContext : NullRenderContext
+        {
+            public List<TextDraw> DrawnTexts { get; } = new List<TextDraw>();
+
+            public override void DrawText(
+                ScreenPoint p,
+                string text,
+                OxyColor fill,
+                string fontFamily,
+                double fontSize,
+                double fontWeight,
+                double rotate,
+                HorizontalAlignment halign,
+                VerticalAlignment valign,
+                OxySize? maxSize)
+            {
+                this.DrawnTexts.Add(new TextDraw(text, p));
+            }
+        }
+
+        private sealed class TextDraw
+        {
+            public TextDraw(string text, ScreenPoint point)
+            {
+                this.Text = text;
+                this.Point = point;
+            }
+
+            public string Text { get; }
+
+            public ScreenPoint Point { get; }
+        }
+    }
+}
diff --git a/tests/OxyPlotControls.Tests/Serialization/LegendSerializationTests.cs b/tests/OxyPlotControls.Tests/Serialization/LegendSerializationTests.cs
index 975dbdf8..648c00f6 100644
--- a/tests/OxyPlotControls.Tests/Serialization/LegendSerializationTests.cs
+++ b/tests/OxyPlotControls.Tests/Serialization/LegendSerializationTests.cs
@@ -293,6 +293,7 @@ public void LegendPropertiesToXElement_ItemProperties_SerializesCorrectly()
             LegendSymbolPlacement = LegendSymbolPlacement.Left,
             LegendColumnSpacing = 10,
             LegendItemAlignment = HorizontalAlignment.Left,
+            LegendItemClickTogglesSeriesVisibility = true,
             LegendItemOrder = LegendItemOrder.Normal,
             LegendItemSpacing = 8,
             LegendLineSpacing = 4
@@ -309,6 +310,7 @@ public void LegendPropertiesToXElement_ItemProperties_SerializesCorrectly()
         Assert.Equal("Left", itemsElement.Attribute("LegendSymbolPlacement")?.Value);
         Assert.Equal("10", itemsElement.Attribute("LegendColumnSpacing")?.Value);
         Assert.Equal("Left", itemsElement.Attribute("LegendItemAlignment")?.Value);
+        Assert.Equal("true", itemsElement.Attribute("LegendItemClickTogglesSeriesVisibility")?.Value);
         Assert.Equal("Normal", itemsElement.Attribute("LegendItemOrder")?.Value);
         Assert.Equal("8", itemsElement.Attribute("LegendItemSpacing")?.Value);
         Assert.Equal("4", itemsElement.Attribute("LegendLineSpacing")?.Value);
@@ -327,6 +329,7 @@ public void XElementToLegendProperties_ItemProperties_DeserializesCorrectly()
                 new XAttribute("LegendSymbolPlacement", "Right"),
                 new XAttribute("LegendColumnSpacing", "12"),
                 new XAttribute("LegendItemAlignment", "Center"),
+                new XAttribute("LegendItemClickTogglesSeriesVisibility", "True"),
                 new XAttribute("LegendItemOrder", "Reverse"),
                 new XAttribute("LegendItemSpacing", "10"),
                 new XAttribute("LegendLineSpacing", "5")));
@@ -341,11 +344,28 @@ public void XElementToLegendProperties_ItemProperties_DeserializesCorrectly()
         Assert.Equal(LegendSymbolPlacement.Right, plot.LegendSymbolPlacement);
         Assert.Equal(12, plot.LegendColumnSpacing);
         Assert.Equal(HorizontalAlignment.Center, plot.LegendItemAlignment);
+        Assert.True(plot.LegendItemClickTogglesSeriesVisibility);
         Assert.Equal(LegendItemOrder.Reverse, plot.LegendItemOrder);
         Assert.Equal(10, plot.LegendItemSpacing);
         Assert.Equal(5, plot.LegendLineSpacing);
     }
 
+    [StaFact]
+    public void XElementToLegendProperties_ItemClickToggleMissing_DefaultsToFalse()
+    {
+        // Arrange
+        var plot = new Plot();
+        var element = new XElement(PlotSerializer.LegendPropertiesTag,
+            new XElement("Items",
+                new XAttribute("LegendItemAlignment", "Left")));
+
+        // Act
+        PlotSerializer.XElementToLegendProperties(plot, element);
+
+        // Assert
+        Assert.False(plot.LegendItemClickTogglesSeriesVisibility);
+    }
+
     [StaFact]
     public void ItemProperties_RoundTrip_PreservesValues()
     {
@@ -358,6 +378,7 @@ public void ItemProperties_RoundTrip_PreservesValues()
             LegendSymbolPlacement = LegendSymbolPlacement.Right,
             LegendColumnSpacing = 15,
             LegendItemAlignment = HorizontalAlignment.Right,
+            LegendItemClickTogglesSeriesVisibility = true,
             LegendItemOrder = LegendItemOrder.Reverse,
             LegendItemSpacing = 12,
             LegendLineSpacing = 6
@@ -375,6 +396,7 @@ public void ItemProperties_RoundTrip_PreservesValues()
         Assert.Equal(originalPlot.LegendSymbolPlacement, deserializedPlot.LegendSymbolPlacement);
         Assert.Equal(originalPlot.LegendColumnSpacing, deserializedPlot.LegendColumnSpacing);
         Assert.Equal(originalPlot.LegendItemAlignment, deserializedPlot.LegendItemAlignment);
+        Assert.Equal(originalPlot.LegendItemClickTogglesSeriesVisibility, deserializedPlot.LegendItemClickTogglesSeriesVisibility);
         Assert.Equal(originalPlot.LegendItemOrder, deserializedPlot.LegendItemOrder);
         Assert.Equal(originalPlot.LegendItemSpacing, deserializedPlot.LegendItemSpacing);
         Assert.Equal(originalPlot.LegendLineSpacing, deserializedPlot.LegendLineSpacing);
@@ -584,6 +606,7 @@ public void AllLegendProperties_CompleteRoundTrip_PreservesValues()
             LegendSymbolPlacement = LegendSymbolPlacement.Left,
             LegendColumnSpacing = 12,
             LegendItemAlignment = HorizontalAlignment.Left,
+            LegendItemClickTogglesSeriesVisibility = true,
             LegendItemOrder = LegendItemOrder.Normal,
             LegendItemSpacing = 8,
             LegendLineSpacing = 4
@@ -614,6 +637,7 @@ public void AllLegendProperties_CompleteRoundTrip_PreservesValues()
         Assert.Equal(originalPlot.LegendSymbolPlacement, deserializedPlot.LegendSymbolPlacement);
         Assert.Equal(originalPlot.LegendColumnSpacing, deserializedPlot.LegendColumnSpacing);
         Assert.Equal(originalPlot.LegendItemAlignment, deserializedPlot.LegendItemAlignment);
+        Assert.Equal(originalPlot.LegendItemClickTogglesSeriesVisibility, deserializedPlot.LegendItemClickTogglesSeriesVisibility);
         Assert.Equal(originalPlot.LegendItemOrder, deserializedPlot.LegendItemOrder);
         Assert.Equal(originalPlot.LegendItemSpacing, deserializedPlot.LegendItemSpacing);
         Assert.Equal(originalPlot.LegendLineSpacing, deserializedPlot.LegendLineSpacing);

From 32173b33ac371626f08dc0fea8abdac159548355 Mon Sep 17 00:00:00 2001
From: HadenSmith <cole.h.smith@usace.army.mil>
Date: Tue, 30 Jun 2026 08:18:06 -0600
Subject: [PATCH 08/11] Various updates

---
 Directory.Build.props                         |    7 +
 docs/critical-review-implementation-plan.md   |  207 +++
 src/DatabaseControls/DatabaseControls.csproj  |    3 +-
 src/NumericControls/NumericControls.csproj    |    3 +-
 src/OxyPlot/OxyPlot.Wpf/WpfPdfExporter.cs     |    2 +-
 .../OxyPlot.Wpf/WpfPdfRenderContext.cs        |  152 +-
 .../OxyPlot/Annotations/TextAnnotation.cs     |    2 +-
 src/OxyPlot/OxyPlot/Pdf/PdfRenderContext.cs   |   21 +-
 src/OxyPlot/OxyPlot/Pdf/PortableDocument.cs   |    7 +-
 src/OxyPlotControls/OxyPlotToolbar.xaml.cs    | 1261 ++++++++++-------
 tests/OxyPlot.Tests/TextAnnotationTests.cs    |  162 +++
 .../TextAnnotationExporterTests.cs            |  154 ++
 .../WpfPdfRenderContextTests.cs               |  133 ++
 ...yPlotToolbarAnnotationAxisBehaviorTests.cs |  418 ++++++
 .../OxyPlotToolbarAnnotationWiringTests.cs    |  302 ++++
 .../OxyPlotToolbarExportDataTests.cs          |  174 +++
 16 files changed, 2453 insertions(+), 555 deletions(-)
 create mode 100644 docs/critical-review-implementation-plan.md
 create mode 100644 tests/OxyPlot.Tests/TextAnnotationTests.cs
 create mode 100644 tests/OxyPlot.Wpf.Tests/TextAnnotationExporterTests.cs
 create mode 100644 tests/OxyPlot.Wpf.Tests/WpfPdfRenderContextTests.cs
 create mode 100644 tests/OxyPlotControls.Tests/OxyPlotToolbarAnnotationAxisBehaviorTests.cs
 create mode 100644 tests/OxyPlotControls.Tests/OxyPlotToolbarAnnotationWiringTests.cs
 create mode 100644 tests/OxyPlotControls.Tests/OxyPlotToolbarExportDataTests.cs

diff --git a/Directory.Build.props b/Directory.Build.props
index d3b6ee2f..b632eb82 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -39,6 +39,13 @@
     <WarningsAsErrors>$(WarningsAsErrors);CS1591;CS1572;CS1573;CS1574;CS0419</WarningsAsErrors>
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(UseLocalRmcNumericsProject)' == '' and ('$(MSBuildProjectName)' == 'DatabaseControls' or '$(MSBuildProjectName)' == 'NumericControls')">
+    <BestFitRepositoryRoot Condition="'$(BestFitRepositoryRoot)' == '' and '$(SolutionDir)' != '' and Exists('$(SolutionDir)RMC.BestFit.sln')">$(SolutionDir)</BestFitRepositoryRoot>
+    <BestFitRepositoryRoot Condition="'$(BestFitRepositoryRoot)' == '' and Exists('$(MSBuildStartupDirectory)\RMC.BestFit.sln')">$(MSBuildStartupDirectory)\</BestFitRepositoryRoot>
+    <UseLocalRmcNumericsProject Condition="'$(BestFitRepositoryRoot)' != ''">true</UseLocalRmcNumericsProject>
+    <RmcNumericsProject Condition="'$(RmcNumericsProject)' == '' and '$(BestFitRepositoryRoot)' != ''">$(BestFitRepositoryRoot)..\numerics\Numerics\Numerics.csproj</RmcNumericsProject>
+  </PropertyGroup>
+
   <ItemGroup Condition="'$(IsWpfFrameworkLibrary)' == 'true'">
     <None Include="$(MSBuildThisFileDirectory)README.md" Pack="true" PackagePath="\" Visible="false" />
 
diff --git a/docs/critical-review-implementation-plan.md b/docs/critical-review-implementation-plan.md
new file mode 100644
index 00000000..f0366474
--- /dev/null
+++ b/docs/critical-review-implementation-plan.md
@@ -0,0 +1,207 @@
+# Critical Review And Implementation Plan
+
+Review date: 2026-05-01  
+Scope: all tracked C# libraries under `src/`, excluding generated build output and `.claude/worktrees`.
+
+## Context Notes
+
+- No tracked or workspace `Claude.md`, `CLAUDE.md`, or `claude.md` files were found. I used `README.md`, `docs/architecture.md`, the solution file, project references, tests, and source review to orient.
+- Baseline verification before changes:
+  - `dotnet build WPF-Framework.sln --no-restore --configuration Debug --verbosity minimal` passed with 0 warnings and 0 errors.
+  - `dotnet test WPF-Framework.sln --no-restore --configuration Debug --verbosity minimal` passed, with about 6815 tests passing and 6 skipped.
+- Review focus: critical bugs only: data loss, security/destructive injection, corrupted installs, or silent data corruption.
+- No implementation changes are approved yet.
+
+## Approval Checklist
+
+Use this section for review feedback.
+
+- [ ] Approve all listed fixes.
+- [ ] Approve only issue DB-001.
+- [ ] Approve only issue DB-002.
+- [ ] Approve only issue UPD-001.
+- [ ] Approve only issue DB-003.
+- [ ] Hold issue DB-001.
+- [ ] Hold issue DB-002.
+- [ ] Hold issue UPD-001.
+- [ ] Hold issue DB-003.
+- [ ] Revise scope or approach before implementation.
+
+Reviewer notes:
+
+```text
+
+```
+
+## Critical Findings
+
+### DB-001: DBF table edits can permanently delete the database if replacement fails
+
+Status: proposed  
+Severity: P0 data loss  
+Primary files:
+
+- `src/DatabaseManager/DBFReader.cs:625`
+- `src/DatabaseManager/DBFReader.cs:705`
+- `src/DatabaseManager/DBFReader.cs:1573`
+- `src/DatabaseManager/DBFReader.cs:1679`
+- `src/DatabaseManager/DBFReader.cs:1794`
+- `src/DatabaseManager/DBFReader.cs:1904`
+- `src/DatabaseManager/DBFReader.cs:2014`
+- `src/DatabaseManager/DBFReader.cs:2125`
+- `src/DatabaseManager/DBFReader.cs:2233`
+- `src/DatabaseManager/DBFReader.cs:2341`
+- `src/DatabaseManager/DBFReader.cs:2458`
+- `src/DatabaseManager/DBFReader.cs:2581`
+
+Evidence:
+
+Multiple DBF mutation paths create a temp DBF, then call `File.Delete(_parentDatabase.DataBasePath)` before `File.Copy(tmpdbf, _parentDatabase.DataBasePath)`. If the copy fails after deletion due to disk space, permissions, antivirus locking, process interruption, or file-system failure, the original database is gone.
+
+Implementation plan:
+
+1. Add a private safe-replacement helper in `DBFReader`.
+2. Keep the original DBF in place until the replacement file is fully written and ready.
+3. Use `File.Replace(tempPath, targetPath, backupPath, ignoreMetadataErrors: true)` when the target exists.
+4. Use a same-directory move only for new targets.
+5. Clean up temp and backup files in `finally`, preserving the backup if replacement fails.
+6. Replace all DBF delete/copy mutation call sites with the helper.
+7. Add tests around row deletion, column deletion, and column addition to confirm outputs remain valid and that failure leaves the original intact where feasible.
+
+Acceptance criteria:
+
+- No DBF mutation path deletes the target before a successful replacement.
+- Existing DBF edit tests still pass.
+- New tests cover at least one failure path and representative edit paths.
+
+### DB-002: SQLite table and column identifiers are interpolated without safe quoting
+
+Status: proposed  
+Severity: P0 data integrity/security  
+Primary files:
+
+- `src/DatabaseManager/SQLiteManager.cs:415`
+- `src/DatabaseManager/SQLiteManager.cs:576`
+- `src/DatabaseManager/SQLiteManager.cs:698`
+- `src/DatabaseManager/SQLiteManager.cs:846`
+- `src/DatabaseManager/SQLiteManager.cs:1402`
+- `src/DatabaseManager/SQLiteManager.cs:1759`
+- `src/DatabaseManager/SQLiteManager.cs:1868`
+- `src/DatabaseManager/SQLiteManager.cs:1902`
+- `src/DatabaseManager/SQLiteManager.cs:2003`
+- `src/DatabaseManager/SQLiteManager.cs:2531`
+- `src/DatabaseManager/DatabaseManager.cs:237`
+
+Evidence:
+
+SQLite identifiers are assembled as `[` + name + `]` in many schema and update statements. Names are accepted from external sources such as CSV headers and table names. A name containing `]`, quotes, reserved words, or SQL punctuation can break SQL, target the wrong object, or potentially execute destructive extra statements through `ExecuteNonQuery`. Some write paths also derive parameter names directly from user column names, which fails for spaces and special characters.
+
+Implementation plan:
+
+1. Add a central `QuoteIdentifier(string identifier)` helper using SQLite double-quoted identifiers and escaped embedded quotes.
+2. Validate null or empty identifiers explicitly.
+3. Replace direct bracket concatenation for table names, temp table names, and column names.
+4. Stop generating parameter names from column names; use stable generated names such as `@p0`, `@p1`, `@cellValue`, and `@rowId`.
+5. Prefer parameterized `rowid` predicates where practical, even though current `rowid` sources are internal.
+6. Add tests for names with spaces, dashes, reserved words, `]`, `"`, and injection-like text across create, save, append, edit, read, add-column, and delete-column paths.
+
+Acceptance criteria:
+
+- SQLite schema and data operations work with quoted/special table and column names.
+- Injection-like names are stored as identifiers, not interpreted as SQL.
+- Existing SQLite tests still pass.
+
+### UPD-001: Updater can leave a mixed-version installation after partial extraction
+
+Status: proposed  
+Severity: P1 install integrity/data loss  
+Primary files:
+
+- `src/SoftwareUpdate.Updater/InstallationManager.cs:131`
+- `src/SoftwareUpdate.Updater/InstallationManager.cs:181`
+- `src/SoftwareUpdate.Updater/InstallationManager.cs:199`
+- `src/SoftwareUpdate.Updater/InstallationManager.cs:246`
+- `src/SoftwareUpdate.Updater/InstallationManager.cs:285`
+
+Evidence:
+
+The updater backs up the target directory, then extracts files directly into the live target. If extraction fails after writing new files, rollback copies backup files over the target but does not remove newly-created files from the failed package. A successful update also does not remove stale files that disappeared from the new package. This can leave assemblies/resources from different versions side by side. There is also a related root-folder stripping edge case: root detection accepts `/` and `\`, but stripping uses only `/`.
+
+Implementation plan:
+
+1. Extract and validate the update archive into a staging directory, not the live target.
+2. Normalize archive separators before root-folder stripping and path traversal checks.
+3. Validate every entry path before copying anything into the target.
+4. Apply the staged update in a controlled replace step: backup target, clear intended target contents, copy staging contents in.
+5. On failure, restore from backup and remove files that were not present in the backup.
+6. Add tests for partial extraction failure, new-file rollback, stale-file cleanup, traversal protection, backup-directory skipping, and backslash root-folder packages.
+
+Acceptance criteria:
+
+- A failed update restores the exact previous target contents, except intentional updater/log exclusions if documented.
+- A successful update does not leave stale files from the previous version.
+- Existing updater tests still pass.
+
+### DB-003: DBF export can filter the wrong columns and delete an existing export before a successful write
+
+Status: proposed  
+Severity: P1 data export integrity  
+Primary file:
+
+- `src/DatabaseManager/DataTableView.cs:2688`
+- `src/DatabaseManager/DataTableView.cs:2725`
+- `src/DatabaseManager/DataTableView.cs:2728`
+
+Evidence:
+
+`ExportToDBF` filters selected columns by checking `_columnTypes[i]` instead of `_columnTypes[columnIndicesToExport[i]]`. When exporting a subset or reordered list of columns, the method can include unsupported fields or omit valid fields. The method also reads `rowIndicesToExport[0]`, which crashes for an empty selection, and deletes an existing output file before the new DBF is successfully created.
+
+Implementation plan:
+
+1. Change the filter to inspect `_columnTypes[columnIndicesToExport[i]]`.
+2. Define empty-row export behavior and test it. Preferred behavior: create a valid DBF schema with zero rows.
+3. Write export output to a temp file in the destination directory.
+4. Replace the requested output only after the temp DBF is successfully created and validated.
+5. Add tests for subset export, reordered export, unsupported skipped types, empty row export, and failed export preserving an existing target where feasible.
+
+Acceptance criteria:
+
+- Exported DBF columns match the requested supported columns.
+- Empty row selections do not crash.
+- Existing export targets are preserved if export creation fails.
+
+## Reviewed With No Critical Findings
+
+No critical issues crossed the review threshold in these areas during this pass:
+
+- `FrameworkInterfaces`
+- `FrameworkUI`
+- `Themes`
+- `DAG` and `DAGControls`
+- `ExpressionParser` and `ExpressionParserControls`
+- `DatabaseControls`
+- `GenericControls`
+- `NumericControls`
+- `OxyPlotControls`
+- Vendored `AvalonDock`
+- Vendored `OxyPlot`
+
+Non-critical issues were intentionally not added to this plan.
+
+## Proposed Execution Order
+
+1. Implement DB-001 first because it is the highest direct data-loss risk.
+2. Implement DB-002 next because it touches many SQLite paths and should be tested broadly.
+3. Implement UPD-001 after database fixes because it changes update transaction semantics.
+4. Implement DB-003 last because it is narrower and mostly isolated to export behavior.
+5. Run targeted tests after each issue, then full `dotnet build` and `dotnet test` at the end.
+
+## Final Verification Plan
+
+After approved implementation:
+
+1. Run focused database tests.
+2. Run focused updater tests.
+3. Run `dotnet build WPF-Framework.sln --no-restore --configuration Debug --verbosity minimal`.
+4. Run `dotnet test WPF-Framework.sln --no-restore --configuration Debug --verbosity minimal`.
+5. Summarize changed files, risk reduction, and any remaining test gaps.
diff --git a/src/DatabaseControls/DatabaseControls.csproj b/src/DatabaseControls/DatabaseControls.csproj
index 465b2c4e..a4a03dfb 100644
--- a/src/DatabaseControls/DatabaseControls.csproj
+++ b/src/DatabaseControls/DatabaseControls.csproj
@@ -56,7 +56,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="RMC.Numerics" Version="2.0.1" />
+    <ProjectReference Include="$(RmcNumericsProject)" Condition="'$(UseLocalRmcNumericsProject)' == 'true' And Exists('$(RmcNumericsProject)')" />
+    <PackageReference Include="RMC.Numerics" Version="2.0.1" Condition="'$(UseLocalRmcNumericsProject)' != 'true' Or !Exists('$(RmcNumericsProject)')" />
     <ProjectReference Include="..\OxyPlot\OxyPlot\OxyPlot.csproj" />
     <ProjectReference Include="..\OxyPlot\OxyPlot.Wpf\OxyPlot.Wpf.csproj" />
     <ProjectReference Include="..\OxyPlot\OxyPlot.Wpf.Shared\OxyPlot.Wpf.Shared.csproj" />
diff --git a/src/NumericControls/NumericControls.csproj b/src/NumericControls/NumericControls.csproj
index 26fc82f4..23108775 100644
--- a/src/NumericControls/NumericControls.csproj
+++ b/src/NumericControls/NumericControls.csproj
@@ -24,7 +24,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="RMC.Numerics" Version="2.0.1" />
+    <ProjectReference Include="$(RmcNumericsProject)" Condition="'$(UseLocalRmcNumericsProject)' == 'true' And Exists('$(RmcNumericsProject)')" />
+    <PackageReference Include="RMC.Numerics" Version="2.0.1" Condition="'$(UseLocalRmcNumericsProject)' != 'true' Or !Exists('$(RmcNumericsProject)')" />
     <ProjectReference Include="..\OxyPlot\OxyPlot\OxyPlot.csproj" />
     <ProjectReference Include="..\OxyPlot\OxyPlot.Wpf\OxyPlot.Wpf.csproj" />
     <ProjectReference Include="..\OxyPlot\OxyPlot.Wpf.Shared\OxyPlot.Wpf.Shared.csproj" />
diff --git a/src/OxyPlot/OxyPlot.Wpf/WpfPdfExporter.cs b/src/OxyPlot/OxyPlot.Wpf/WpfPdfExporter.cs
index e6a39343..e751fec4 100644
--- a/src/OxyPlot/OxyPlot.Wpf/WpfPdfExporter.cs
+++ b/src/OxyPlot/OxyPlot.Wpf/WpfPdfExporter.cs
@@ -62,7 +62,7 @@ public void Export(IPlotModel model, Stream stream)
 
             var rc = new WpfPdfRenderContext(pageWidth, pageHeight, model.Background);
             model.Update(true);
-            model.Render(rc, new OxyRect(0, 0, pageWidth, pageHeight));
+            model.Render(rc, new OxyRect(0, 0, this.Width, this.Height));
             rc.Save(stream);
         }
     }
diff --git a/src/OxyPlot/OxyPlot.Wpf/WpfPdfRenderContext.cs b/src/OxyPlot/OxyPlot.Wpf/WpfPdfRenderContext.cs
index fd282c42..452c3996 100644
--- a/src/OxyPlot/OxyPlot.Wpf/WpfPdfRenderContext.cs
+++ b/src/OxyPlot/OxyPlot.Wpf/WpfPdfRenderContext.cs
@@ -10,6 +10,7 @@
 namespace OxyPlot.Wpf
 {
     using System;
+    using System.Collections.Generic;
 
     /// <summary>
     /// Provides a PDF render context that converts text to geometry paths using WPF's
@@ -35,6 +36,53 @@ public WpfPdfRenderContext(double width, double height, OxyColor background)
         {
         }
 
+        /// <inheritdoc/>
+        public override void DrawEllipse(
+            OxyRect rect,
+            OxyColor fill,
+            OxyColor stroke,
+            double thickness,
+            EdgeRenderingMode edgeRenderingMode)
+        {
+            base.DrawEllipse(ToPdfRect(rect), fill, stroke, thickness, edgeRenderingMode);
+        }
+
+        /// <inheritdoc/>
+        public override void DrawLine(
+            IList<ScreenPoint> points,
+            OxyColor stroke,
+            double thickness,
+            EdgeRenderingMode edgeRenderingMode,
+            double[] dashArray,
+            LineJoin lineJoin)
+        {
+            base.DrawLine(ToPdfPoints(points), stroke, thickness, edgeRenderingMode, dashArray, lineJoin);
+        }
+
+        /// <inheritdoc/>
+        public override void DrawPolygon(
+            IList<ScreenPoint> points,
+            OxyColor fill,
+            OxyColor stroke,
+            double thickness,
+            EdgeRenderingMode edgeRenderingMode,
+            double[] dashArray,
+            LineJoin lineJoin)
+        {
+            base.DrawPolygon(ToPdfPoints(points), fill, stroke, thickness, edgeRenderingMode, dashArray, lineJoin);
+        }
+
+        /// <inheritdoc/>
+        public override void DrawRectangle(
+            OxyRect rect,
+            OxyColor fill,
+            OxyColor stroke,
+            double thickness,
+            EdgeRenderingMode edgeRenderingMode)
+        {
+            base.DrawRectangle(ToPdfRect(rect), fill, stroke, thickness, edgeRenderingMode);
+        }
+
         /// <summary>
         /// Draws text at the specified position by converting it to geometry paths.
         /// </summary>
@@ -55,21 +103,23 @@ public override void DrawText(
                 return;
             }
 
-            // fontSize is in DIP (1/96 inch). Measure in DIP then convert to points.
+            // fontSize is in DIP (1/96 inch). Measure in DIP then convert to points
+            // only for the final PDF path geometry.
             var textSizeDip = TextToGeometryHelper.MeasureText(text, fontFamily, fontSize, fontWeight);
             double width = textSizeDip.Width * DipToPoints;
             double height = textSizeDip.Height * DipToPoints;
 
             if (maxSize != null)
             {
-                if (width > maxSize.Value.Width)
+                var maxSizePoints = ToPdfSize(maxSize.Value);
+                if (width > maxSizePoints.Width)
                 {
-                    width = Math.Max(maxSize.Value.Width, 0);
+                    width = Math.Max(maxSizePoints.Width, 0);
                 }
 
-                if (height > maxSize.Value.Height)
+                if (height > maxSizePoints.Height)
                 {
-                    height = Math.Max(maxSize.Value.Height, 0);
+                    height = Math.Max(maxSizePoints.Height, 0);
                 }
             }
 
@@ -102,10 +152,11 @@ public override void DrawText(
             this.doc.SaveState();
             this.doc.SetFillColor(fill);
 
-            // p.X, p.Y are in points (model renders to a points-sized OxyRect).
+            // The model renders in WPF DIP coordinates. Convert the anchor point to PDF points.
             // Flip Y for PDF coordinate system (Y-up).
-            double pdfY = this.doc.PageHeight - p.Y;
-            this.doc.Translate(p.X, pdfY);
+            double pdfX = p.X * DipToPoints;
+            double pdfY = this.doc.PageHeight - (p.Y * DipToPoints);
+            this.doc.Translate(pdfX, pdfY);
 
             if (Math.Abs(rotate) > 1e-6)
             {
@@ -116,7 +167,7 @@ public override void DrawText(
             this.doc.Translate(dx, dy);
 
             // The geometry is in DIP with Y-down. We need to:
-            // 1. Scale DIP → points (multiply by DipToPoints)
+            // 1. Scale DIP to points (multiply by DipToPoints)
             // 2. Flip Y (negate Y scale)
             // 3. Shift up by height so flipped text extends upward from baseline
             // Combined: Transform(scale, 0, 0, -scale, 0, height)
@@ -130,13 +181,88 @@ public override void DrawText(
         }
 
         /// <summary>
-        /// Measures text using WPF font metrics. Returns size in points for consistency
-        /// with the PDF coordinate system used by the model render rectangle.
+        /// Measures text using WPF font metrics. Returns size in DIP so model layout
+        /// matches the WPF drawing and SVG renderers; drawing converts to PDF points.
         /// </summary>
         public override OxySize MeasureText(string text, string fontFamily, double fontSize, double fontWeight)
         {
-            var sizeDip = TextToGeometryHelper.MeasureText(text, fontFamily, fontSize, fontWeight);
-            return new OxySize(sizeDip.Width * DipToPoints, sizeDip.Height * DipToPoints);
+            return TextToGeometryHelper.MeasureText(text, fontFamily, fontSize, fontWeight);
+        }
+
+        /// <inheritdoc/>
+        public override void DrawImage(
+            OxyImage source,
+            double srcX,
+            double srcY,
+            double srcWidth,
+            double srcHeight,
+            double destX,
+            double destY,
+            double destWidth,
+            double destHeight,
+            double opacity,
+            bool interpolate)
+        {
+            base.DrawImage(
+                source,
+                srcX,
+                srcY,
+                srcWidth,
+                srcHeight,
+                destX * DipToPoints,
+                destY * DipToPoints,
+                destWidth * DipToPoints,
+                destHeight * DipToPoints,
+                opacity,
+                interpolate);
+        }
+
+        /// <inheritdoc/>
+        protected override void SetClip(OxyRect clippingRectangle)
+        {
+            base.SetClip(ToPdfRect(clippingRectangle));
+        }
+
+        /// <summary>
+        /// Converts a screen point from WPF device-independent pixels to PDF points.
+        /// </summary>
+        private static ScreenPoint ToPdfPoint(ScreenPoint point)
+        {
+            return new ScreenPoint(point.X * DipToPoints, point.Y * DipToPoints);
+        }
+
+        /// <summary>
+        /// Converts a rectangle from WPF device-independent pixels to PDF points.
+        /// </summary>
+        private static OxyRect ToPdfRect(OxyRect rect)
+        {
+            return new OxyRect(
+                rect.Left * DipToPoints,
+                rect.Top * DipToPoints,
+                rect.Width * DipToPoints,
+                rect.Height * DipToPoints);
+        }
+
+        /// <summary>
+        /// Converts a size from WPF device-independent pixels to PDF points.
+        /// </summary>
+        private static OxySize ToPdfSize(OxySize size)
+        {
+            return new OxySize(size.Width * DipToPoints, size.Height * DipToPoints);
+        }
+
+        /// <summary>
+        /// Converts screen points from WPF device-independent pixels to PDF points.
+        /// </summary>
+        private static IList<ScreenPoint> ToPdfPoints(IList<ScreenPoint> points)
+        {
+            var scaled = new ScreenPoint[points.Count];
+            for (int i = 0; i < points.Count; i++)
+            {
+                scaled[i] = ToPdfPoint(points[i]);
+            }
+
+            return scaled;
         }
     }
 }
diff --git a/src/OxyPlot/OxyPlot/Annotations/TextAnnotation.cs b/src/OxyPlot/OxyPlot/Annotations/TextAnnotation.cs
index 86fd08bb..494d044b 100644
--- a/src/OxyPlot/OxyPlot/Annotations/TextAnnotation.cs
+++ b/src/OxyPlot/OxyPlot/Annotations/TextAnnotation.cs
@@ -76,7 +76,7 @@ public override void Render(IRenderContext rc)
 
             base.Render(rc);
 
-            var position = this.Transform(this.TextPosition) + this.Orientate(this.Offset);
+            var position = this.GetActualTextPosition(() => this.PlotModel.PlotArea.Center) + this.Orientate(this.Offset);
 
             var textSize = rc.MeasureText(this.Text, this.ActualFont, this.ActualFontSize, this.ActualFontWeight);
             this.GetActualTextAlignment(out var ha, out var va);
diff --git a/src/OxyPlot/OxyPlot/Pdf/PdfRenderContext.cs b/src/OxyPlot/OxyPlot/Pdf/PdfRenderContext.cs
index 5f301a01..86c79abe 100644
--- a/src/OxyPlot/OxyPlot/Pdf/PdfRenderContext.cs
+++ b/src/OxyPlot/OxyPlot/Pdf/PdfRenderContext.cs
@@ -117,7 +117,7 @@ public override void DrawLine(
             this.SetLineWidth(thickness);
             if (dashArray != null)
             {
-                this.SetLineDashPattern(dashArray, 0);
+                this.SetLineDashPattern(dashArray, 0, thickness);
             }
 
             this.doc.SetLineJoin(Convert(lineJoin));
@@ -174,7 +174,7 @@ public override void DrawPolygon(
                 this.SetLineWidth(thickness);
                 if (dashArray != null)
                 {
-                    this.SetLineDashPattern(dashArray, 0);
+                    this.SetLineDashPattern(dashArray, 0, thickness);
                 }
 
                 this.doc.SetLineJoin(Convert(lineJoin));
@@ -383,7 +383,7 @@ public override void DrawImage(
             double width = image.Width / srcWidth * destWidth;
             double y = destY - (srcY / srcHeight * destHeight);
             double height = image.Height / srcHeight * destHeight;
-            this.doc.SetClippingRectangle(destX, this.doc.PageHeight - (destY - destHeight), destWidth, destHeight);
+            this.doc.SetClippingRectangle(destX, this.doc.PageHeight - (destY + destHeight), destWidth, destHeight);
             this.doc.Translate(x, this.doc.PageHeight - (y + height));
             this.doc.Scale(width, height);
             this.doc.DrawImage(image);
@@ -394,7 +394,11 @@ public override void DrawImage(
         protected override void SetClip(OxyRect clippingRectangle)
         {
             this.doc.SaveState();
-            this.doc.SetClippingRectangle(clippingRectangle.Left, clippingRectangle.Bottom, clippingRectangle.Width, clippingRectangle.Height);
+            this.doc.SetClippingRectangle(
+                clippingRectangle.Left,
+                this.doc.PageHeight - clippingRectangle.Bottom,
+                clippingRectangle.Width,
+                clippingRectangle.Height);
         }
 
         /// <inheritdoc/>
@@ -434,11 +438,12 @@ private void SetLineWidth(double thickness)
         /// <summary>
         /// Sets the line dash pattern.
         /// </summary>
-        /// <param name="dashArray">The dash array (in 1/96 inch units).</param>
-        /// <param name="dashPhase">The dash phase (in 1/96 inch units).</param>
-        private void SetLineDashPattern(double[] dashArray, double dashPhase)
+        /// <param name="dashArray">The dash array, expressed in multiples of the stroke thickness.</param>
+        /// <param name="dashPhase">The dash phase, expressed in multiples of the stroke thickness.</param>
+        /// <param name="thickness">The stroke thickness (in 1/96 inch units).</param>
+        private void SetLineDashPattern(double[] dashArray, double dashPhase, double thickness)
         {
-            this.doc.SetLineDashPattern(dashArray.Select(d => d / 96 * 72).ToArray(), dashPhase / 96 * 72);
+            this.doc.SetLineDashPattern(dashArray.Select(d => d * thickness / 96 * 72).ToArray(), dashPhase * thickness / 96 * 72);
         }
     }
 }
diff --git a/src/OxyPlot/OxyPlot/Pdf/PortableDocument.cs b/src/OxyPlot/OxyPlot/Pdf/PortableDocument.cs
index e4298731..2dcbd396 100644
--- a/src/OxyPlot/OxyPlot/Pdf/PortableDocument.cs
+++ b/src/OxyPlot/OxyPlot/Pdf/PortableDocument.cs
@@ -537,13 +537,10 @@ public void DrawRectangle(double x, double y, double w, double h, bool fill = fa
         /// <param name="evenOddRule">Use the even-odd region rule if set to <c>true</c>.</param>
         public void SetClippingRectangle(double x, double y, double w, double h, bool evenOddRule = false)
         {
-            // TODO: not working?
-            return;
-
             // Set clipping path using non-zero rule (W)
             // Set clipping path using even-odd rule (W*)
             // End path without filling or stroking (n)
-            // TODO: this.AppendLine("{0} {1} {2} {3} re {4} n", x, y, w, h, evenOddRule ? "W*" : "W");
+            this.AppendLine("{0:0.####} {1:0.####} {2:0.####} {3:0.####} re {4} n", x, y, w, h, evenOddRule ? "W*" : "W");
         }
 
         /// <summary>
@@ -1279,4 +1276,4 @@ public void Write(PdfWriter w)
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/OxyPlotControls/OxyPlotToolbar.xaml.cs b/src/OxyPlotControls/OxyPlotToolbar.xaml.cs
index 3b020b3f..b8e7ba6f 100644
--- a/src/OxyPlotControls/OxyPlotToolbar.xaml.cs
+++ b/src/OxyPlotControls/OxyPlotToolbar.xaml.cs
@@ -5,6 +5,7 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
@@ -216,6 +217,10 @@ private static void InitializePlot(DependencyObject d, DependencyPropertyChanged
                     newPlot.ActualModel.MouseUp += oxyToolBar.PlotModelMouseUp;
                 }
                 newPlot.Annotations.CollectionChanged += oxyToolBar.PlotModelAnnotationCollectionChanged;
+                foreach (var annotation in newPlot.Annotations)
+                {
+                    oxyToolBar.AttachAnnotationHandlers(annotation);
+                }
 
                 newPlot.ApplyTemplate(); // Needed to set the canvas
 
@@ -386,8 +391,6 @@ public enum AddToolMode
         private bool _scaleMaxY = false;
         private bool _scaleMinX = false;
         private bool _scaleMinY = false;
-        private Color _originalColor = Colors.White;
-
         // Adding Annotations
         private AddToolMode _addAnnotationToolMode = AddToolMode.None;
         private Wpf.Annotation _targetAddAnnotation = null!;
@@ -395,6 +398,11 @@ public enum AddToolMode
         // Annotation marker overlays (WPF elements drawn on the overlay canvas for hit-point markers)
         private readonly List<UIElement> _markerOverlays = new();
 
+        // Tracks toolbar mouse-handler wiring without keeping removed annotations alive.
+        private readonly ConditionalWeakTable<Wpf.Annotation, object> _annotationsWithMouseHandlers = new();
+
+        private static readonly object AnnotationHandlersAttached = new();
+
         /// <summary>
         /// Delegate for the PropertiesCalled event.
         /// </summary>
@@ -819,6 +827,25 @@ private void BindEscapeToCancelAnnotation()
                 }));
         }
 
+        /// <summary>
+        /// Attaches annotation mouse handlers for annotations that already existed before
+        /// the toolbar subscribed to collection changes.
+        /// </summary>
+        /// <param name="annotation">The annotation to wire for toolbar interaction.</param>
+        private void AttachAnnotationHandlers(Wpf.Annotation annotation)
+        {
+            this.PlotModelAnnotationCollectionChanged(
+                this.Plot?.Annotations,
+                new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, annotation));
+        }
+
+        private ScreenPoint GetCurrentTextAnnotationScreenPoint(Wpf.TextAnnotation annotation)
+        {
+            return annotation.TextPosition.IsDefined()
+                ? annotation.InternalAnnotation.Transform(annotation.TextPosition)
+                : Plot.ActualModel.PlotArea.Center;
+        }
+
         /// <summary>
         /// A new annotation has been added to the plot. Adds the appropriate handlers.
         /// </summary>
@@ -828,6 +855,10 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
 
             foreach (var item in e.NewItems)
             {
+                if (item is not Wpf.Annotation annotation) continue;
+                if (this._annotationsWithMouseHandlers.TryGetValue(annotation, out _)) continue;
+                this._annotationsWithMouseHandlers.Add(annotation, AnnotationHandlersAttached);
+
                 if (item is Wpf.ArrowAnnotation)
                 {
                     var newArrow = (Wpf.ArrowAnnotation)item;
@@ -842,9 +873,7 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                         _lastScreenPoint = new ScreenPoint(ae.Position.X, ae.Position.Y);
                         _moveStartPoint = ae.HitTestResult.Index != 2;
                         _moveEndPoint = ae.HitTestResult.Index != 1;
-                        _originalColor = newArrow.Color;
                         newArrow.SuppressPropertyChanged = true;
-                        newArrow.Color = Colors.Red;
 
                         GetSelectedObjects(s!, ae);
 
@@ -858,14 +887,11 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
 
                         double dx = ae.Position.X - _lastScreenPoint.X;
                         double dy = ae.Position.Y - _lastScreenPoint.Y;
-                        var startScreenPoint = newArrow.InternalAnnotation.Transform(new DataPoint(newArrow.StartPoint.X, newArrow.StartPoint.Y));
-                        var endScreenPoint = newArrow.InternalAnnotation.Transform(new DataPoint(newArrow.EndPoint.X, newArrow.EndPoint.Y));
+                        TryOffsetDataPoint(newArrow, newArrow.StartPoint, dx, dy, out var startDataPoint);
+                        TryOffsetDataPoint(newArrow, newArrow.EndPoint, dx, dy, out var endDataPoint);
 
-                        var startDataPoint = newArrow.InternalAnnotation.InverseTransform(new ScreenPoint(startScreenPoint.X + dx, startScreenPoint.Y + dy));
-                        var endDataPoint = newArrow.InternalAnnotation.InverseTransform(new ScreenPoint(endScreenPoint.X + dx, endScreenPoint.Y + dy));
-
-                        if (_moveStartPoint) newArrow.StartPoint = startDataPoint;
-                        if (_moveEndPoint) newArrow.EndPoint = endDataPoint;
+                        if (_moveStartPoint && startDataPoint.IsDefined()) newArrow.StartPoint = startDataPoint;
+                        if (_moveEndPoint && endDataPoint.IsDefined()) newArrow.EndPoint = endDataPoint;
 
                         _lastScreenPoint = ae.Position;
                         Plot.ActualModel.InvalidatePlot(false);
@@ -875,17 +901,8 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                     newArrow.InternalAnnotation.MouseUp += (s, ae) =>
                     {
                         if (!newArrow.IsEnabled) return;
-                        try
-                        {
-                            newArrow.Color = _originalColor;
-                        }
-                        finally
-                        {
-                            // Guarantee suppression is cleared even if the Color setter throws,
-                            // so PropertyChanged (and undo bridge) are not silenced indefinitely.
-                            newArrow.SuppressPropertyChanged = false;
-                        }
-                        newArrow.RaisePropertyChanged(nameof(newArrow.StartPoint), nameof(newArrow.EndPoint), nameof(newArrow.Color));
+                        newArrow.SuppressPropertyChanged = false;
+                        newArrow.RaisePropertyChanged(nameof(newArrow.StartPoint), nameof(newArrow.EndPoint));
                     };
                 }
                 else if (item is Wpf.TextAnnotation)
@@ -901,9 +918,7 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
 
                         _lastScreenPoint = new ScreenPoint(ae.Position.X, ae.Position.Y);
                         _moveStartPoint = ae.HitTestResult.Index == 0;
-                        _originalColor = newText.Background;
                         newText.SuppressPropertyChanged = true;
-                        newText.Background = Colors.Red;
 
                         GetSelectedObjects(s!, ae);
 
@@ -917,10 +932,18 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
 
                         double dx = ae.Position.X - _lastScreenPoint.X;
                         double dy = ae.Position.Y - _lastScreenPoint.Y;
-                        var theScreenPoint = newText.InternalAnnotation.Transform(new DataPoint(newText.TextPosition.X, newText.TextPosition.Y));
-                        var theDataPoint = newText.InternalAnnotation.InverseTransform(new ScreenPoint(theScreenPoint.X + dx, theScreenPoint.Y + dy));
+                        var theDataPoint = DataPoint.Undefined;
+                        if (newText.TextPosition.IsDefined())
+                        {
+                            TryOffsetDataPoint(newText, newText.TextPosition, dx, dy, out theDataPoint);
+                        }
+                        else
+                        {
+                            var theScreenPoint = GetCurrentTextAnnotationScreenPoint(newText);
+                            TryScreenPointToDataPoint(newText, new ScreenPoint(theScreenPoint.X + dx, theScreenPoint.Y + dy), out theDataPoint);
+                        }
 
-                        if (_moveStartPoint) newText.TextPosition = theDataPoint;
+                        if (_moveStartPoint && theDataPoint.IsDefined()) newText.TextPosition = theDataPoint;
 
                         _lastScreenPoint = ae.Position;
                         Plot.ActualModel.InvalidatePlot(false);
@@ -930,15 +953,8 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                     newText.InternalAnnotation.MouseUp += (s, ae) =>
                     {
                         if (!newText.IsEnabled) return;
-                        try
-                        {
-                            newText.Background = _originalColor;
-                        }
-                        finally
-                        {
-                            newText.SuppressPropertyChanged = false;
-                        }
-                        newText.RaisePropertyChanged(nameof(newText.TextPosition), nameof(newText.Background));
+                        newText.SuppressPropertyChanged = false;
+                        newText.RaisePropertyChanged(nameof(newText.TextPosition));
                     };
                 }
                 else if (item is Wpf.RectangleAnnotation)
@@ -968,9 +984,7 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                             _moveStartPoint = !_scaleMaxX && !_scaleMaxY && !_scaleMinX && !_scaleMinY;
                         }
 
-                        _originalColor = newRect.Fill;
                         newRect.SuppressPropertyChanged = true;
-                        newRect.Fill = Colors.Red;
 
                         GetSelectedObjects(s!, ae);
 
@@ -984,18 +998,15 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
 
                         double dx = ae.Position.X - _lastScreenPoint.X;
                         double dy = ae.Position.Y - _lastScreenPoint.Y;
-                        var upperRightScreenPoint = newRect.InternalAnnotation.Transform(newRect.MaximumX, newRect.MaximumY);
-                        var lowerLeftScreenPoint = newRect.InternalAnnotation.Transform(newRect.MinimumX, newRect.MinimumY);
+                        TryOffsetDataPoint(newRect, new DataPoint(newRect.MaximumX, newRect.MaximumY), dx, dy, out var upperRightDataPoint);
+                        TryOffsetDataPoint(newRect, new DataPoint(newRect.MinimumX, newRect.MinimumY), dx, dy, out var lowerLeftDataPoint);
 
-                        var upperRightDataPoint = newRect.InternalAnnotation.InverseTransform(new ScreenPoint(upperRightScreenPoint.X + dx, upperRightScreenPoint.Y + dy));
-                        var lowerLeftDataPoint = newRect.InternalAnnotation.InverseTransform(new ScreenPoint(lowerLeftScreenPoint.X + dx, lowerLeftScreenPoint.Y + dy));
+                        if (_scaleMaxX && upperRightDataPoint.IsDefined()) newRect.MaximumX = upperRightDataPoint.X;
+                        if (_scaleMaxY && upperRightDataPoint.IsDefined()) newRect.MaximumY = upperRightDataPoint.Y;
+                        if (_scaleMinX && lowerLeftDataPoint.IsDefined()) newRect.MinimumX = lowerLeftDataPoint.X;
+                        if (_scaleMinY && lowerLeftDataPoint.IsDefined()) newRect.MinimumY = lowerLeftDataPoint.Y;
 
-                        if (_scaleMaxX) newRect.MaximumX = upperRightDataPoint.X;
-                        if (_scaleMaxY) newRect.MaximumY = upperRightDataPoint.Y;
-                        if (_scaleMinX) newRect.MinimumX = lowerLeftDataPoint.X;
-                        if (_scaleMinY) newRect.MinimumY = lowerLeftDataPoint.Y;
-
-                        if (_moveStartPoint)
+                        if (_moveStartPoint && upperRightDataPoint.IsDefined() && lowerLeftDataPoint.IsDefined())
                         {
                             newRect.MaximumX = upperRightDataPoint.X;
                             newRect.MaximumY = upperRightDataPoint.Y;
@@ -1011,15 +1022,8 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                     newRect.InternalAnnotation.MouseUp += (s, ae) =>
                     {
                         if (!newRect.IsEnabled) return;
-                        try
-                        {
-                            newRect.Fill = _originalColor;
-                        }
-                        finally
-                        {
-                            newRect.SuppressPropertyChanged = false;
-                        }
-                        newRect.RaisePropertyChanged(nameof(newRect.MinimumX), nameof(newRect.MaximumX), nameof(newRect.MinimumY), nameof(newRect.MaximumY), nameof(newRect.Fill));
+                        newRect.SuppressPropertyChanged = false;
+                        newRect.RaisePropertyChanged(nameof(newRect.MinimumX), nameof(newRect.MaximumX), nameof(newRect.MinimumY), nameof(newRect.MaximumY));
                     };
                 }
                 else if (item is Wpf.EllipseAnnotation)
@@ -1049,9 +1053,7 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                             _moveStartPoint = !_scaleMaxX && !_scaleMaxY && !_scaleMinX && !_scaleMinY;
                         }
 
-                        _originalColor = newEllipse.Fill;
                         newEllipse.SuppressPropertyChanged = true;
-                        newEllipse.Fill = Colors.Red;
 
                         GetSelectedObjects(s!, ae);
 
@@ -1065,18 +1067,15 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
 
                         double dx = ae.Position.X - _lastScreenPoint.X;
                         double dy = ae.Position.Y - _lastScreenPoint.Y;
-                        var upperRightScreenPoint = newEllipse.InternalAnnotation.Transform(newEllipse.MaximumX, newEllipse.MaximumY);
-                        var lowerLeftScreenPoint = newEllipse.InternalAnnotation.Transform(newEllipse.MinimumX, newEllipse.MinimumY);
+                        TryOffsetDataPoint(newEllipse, new DataPoint(newEllipse.MaximumX, newEllipse.MaximumY), dx, dy, out var upperRightDataPoint);
+                        TryOffsetDataPoint(newEllipse, new DataPoint(newEllipse.MinimumX, newEllipse.MinimumY), dx, dy, out var lowerLeftDataPoint);
 
-                        var upperRightDataPoint = newEllipse.InternalAnnotation.InverseTransform(new ScreenPoint(upperRightScreenPoint.X + dx, upperRightScreenPoint.Y + dy));
-                        var lowerLeftDataPoint = newEllipse.InternalAnnotation.InverseTransform(new ScreenPoint(lowerLeftScreenPoint.X + dx, lowerLeftScreenPoint.Y + dy));
+                        if (_scaleMaxX && upperRightDataPoint.IsDefined()) newEllipse.MaximumX = upperRightDataPoint.X;
+                        if (_scaleMaxY && upperRightDataPoint.IsDefined()) newEllipse.MaximumY = upperRightDataPoint.Y;
+                        if (_scaleMinX && lowerLeftDataPoint.IsDefined()) newEllipse.MinimumX = lowerLeftDataPoint.X;
+                        if (_scaleMinY && lowerLeftDataPoint.IsDefined()) newEllipse.MinimumY = lowerLeftDataPoint.Y;
 
-                        if (_scaleMaxX) newEllipse.MaximumX = upperRightDataPoint.X;
-                        if (_scaleMaxY) newEllipse.MaximumY = upperRightDataPoint.Y;
-                        if (_scaleMinX) newEllipse.MinimumX = lowerLeftDataPoint.X;
-                        if (_scaleMinY) newEllipse.MinimumY = lowerLeftDataPoint.Y;
-
-                        if (_moveStartPoint)
+                        if (_moveStartPoint && upperRightDataPoint.IsDefined() && lowerLeftDataPoint.IsDefined())
                         {
                             newEllipse.MaximumX = upperRightDataPoint.X;
                             newEllipse.MaximumY = upperRightDataPoint.Y;
@@ -1092,15 +1091,8 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                     newEllipse.InternalAnnotation.MouseUp += (s, ae) =>
                     {
                         if (!newEllipse.IsEnabled) return;
-                        try
-                        {
-                            newEllipse.Fill = _originalColor;
-                        }
-                        finally
-                        {
-                            newEllipse.SuppressPropertyChanged = false;
-                        }
-                        newEllipse.RaisePropertyChanged(nameof(newEllipse.X), nameof(newEllipse.Y), nameof(newEllipse.Width), nameof(newEllipse.Height), nameof(newEllipse.Fill));
+                        newEllipse.SuppressPropertyChanged = false;
+                        newEllipse.RaisePropertyChanged(nameof(newEllipse.X), nameof(newEllipse.Y), nameof(newEllipse.Width), nameof(newEllipse.Height));
                     };
                 }
                 else if (item is Wpf.PointAnnotation)
@@ -1116,9 +1108,7 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
 
                         _lastScreenPoint = new ScreenPoint(ae.Position.X, ae.Position.Y);
                         _moveStartPoint = ae.HitTestResult.Index == 0;
-                        _originalColor = newPoint.Fill;
                         newPoint.SuppressPropertyChanged = true;
-                        newPoint.Fill = Colors.Red;
 
                         GetSelectedObjects(s!, ae);
 
@@ -1132,10 +1122,9 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
 
                         double dx = ae.Position.X - _lastScreenPoint.X;
                         double dy = ae.Position.Y - _lastScreenPoint.Y;
-                        var theScreenPoint = newPoint.InternalAnnotation.Transform(new DataPoint(newPoint.X, newPoint.Y));
-                        var theDataPoint = newPoint.InternalAnnotation.InverseTransform(new ScreenPoint(theScreenPoint.X + dx, theScreenPoint.Y + dy));
+                        TryOffsetDataPoint(newPoint, new DataPoint(newPoint.X, newPoint.Y), dx, dy, out var theDataPoint);
 
-                        if (_moveStartPoint)
+                        if (_moveStartPoint && theDataPoint.IsDefined())
                         {
                             newPoint.X = theDataPoint.X;
                             newPoint.Y = theDataPoint.Y;
@@ -1149,15 +1138,8 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                     newPoint.InternalAnnotation.MouseUp += (s, ae) =>
                     {
                         if (!newPoint.IsEnabled) return;
-                        try
-                        {
-                            newPoint.Fill = _originalColor;
-                        }
-                        finally
-                        {
-                            newPoint.SuppressPropertyChanged = false;
-                        }
-                        newPoint.RaisePropertyChanged(nameof(newPoint.X), nameof(newPoint.Y), nameof(newPoint.Fill));
+                        newPoint.SuppressPropertyChanged = false;
+                        newPoint.RaisePropertyChanged(nameof(newPoint.X), nameof(newPoint.Y));
                     };
                 }
                 else if (item is Wpf.PolygonAnnotation)
@@ -1172,15 +1154,10 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                         ClearMarkerOverlays();
 
                         _lastScreenPoint = new ScreenPoint(ae.Position.X, ae.Position.Y);
-                        var screenToData = newPolygon.InternalAnnotation.InverseTransform(ae.Position);
-                        var screen2ToData = newPolygon.InternalAnnotation.InverseTransform(new ScreenPoint(ae.Position.X - HitTestTolerance, ae.Position.Y - HitTestTolerance));
-                        var dxy = new DataPoint(Math.Abs(screenToData.X - screen2ToData.X), Math.Abs(screenToData.Y - screen2ToData.Y));
-                        var dPoint = newPolygon.InternalAnnotation.InverseTransform(ae.Position);
-
                         _movePointIndex = -1;
                         for (int i = 0; i < newPolygon.Points.Count; i++)
                         {
-                            if (Math.Abs(dPoint.X - newPolygon.Points[i].X) < dxy.X && Math.Abs(dPoint.Y - newPolygon.Points[i].Y) < dxy.Y)
+                            if (IsMouseNearDataPoint(newPolygon, newPolygon.Points[i], ae.Position, HitTestTolerance))
                             {
                                 _movePointIndex = i;
                                 break;
@@ -1195,9 +1172,10 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                                 var p1 = newPolygon.InternalAnnotation.Transform(newPolygon.Points[i]);
                                 var p2 = newPolygon.InternalAnnotation.Transform(newPolygon.Points[i + 1]);
                                 var linePoint = ScreenPointHelper.FindPointOnLine(ae.Position, p1, p2);
-                                if ((linePoint - ae.Position).Length < HitTestTolerance)
+                                if ((linePoint - ae.Position).Length < HitTestTolerance
+                                    && TryScreenPointToDataPoint(newPolygon, linePoint, out var insertedPoint))
                                 {
-                                    newPolygon.Points.Insert(i + 1, newPolygon.InternalAnnotation.InverseTransform(linePoint));
+                                    newPolygon.Points.Insert(i + 1, insertedPoint);
                                     onLine = true;
                                     _movePointIndex = i + 1;
                                     break;
@@ -1209,9 +1187,10 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                                 var p1 = newPolygon.InternalAnnotation.Transform(newPolygon.Points[0]);
                                 var p2 = newPolygon.InternalAnnotation.Transform(newPolygon.Points[newPolygon.Points.Count - 1]);
                                 var linePoint = ScreenPointHelper.FindPointOnLine(ae.Position, p1, p2);
-                                if ((linePoint - ae.Position).Length < HitTestTolerance)
+                                if ((linePoint - ae.Position).Length < HitTestTolerance
+                                    && TryScreenPointToDataPoint(newPolygon, linePoint, out var insertedPoint))
                                 {
-                                    newPolygon.Points.Add(newPolygon.InternalAnnotation.InverseTransform(linePoint));
+                                    newPolygon.Points.Add(insertedPoint);
                                     _movePointIndex = newPolygon.Points.Count - 1;
                                 }
                                 else
@@ -1221,9 +1200,7 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                             }
                         }
 
-                        _originalColor = newPolygon.Fill;
                         newPolygon.SuppressPropertyChanged = true;
-                        newPolygon.Fill = Colors.Red;
 
                         GetSelectedObjects(s!, ae);
 
@@ -1240,15 +1217,16 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
 
                         if (_movePointIndex > -1)
                         {
-                            var screenPoint = newPolygon.InternalAnnotation.Transform(new DataPoint(newPolygon.Points[_movePointIndex].X, newPolygon.Points[_movePointIndex].Y));
-                            newPolygon.Points[_movePointIndex] = newPolygon.InternalAnnotation.InverseTransform(new ScreenPoint(screenPoint.X + dx, screenPoint.Y + dy));
+                            if (TryOffsetDataPoint(newPolygon, newPolygon.Points[_movePointIndex], dx, dy, out var movedPoint))
+                            {
+                                newPolygon.Points[_movePointIndex] = movedPoint;
+                            }
                         }
                         else if (_moveStartPoint)
                         {
-                            for (int i = 0; i < newPolygon.Points.Count; i++)
+                            if (TryOffsetDataPoints(newPolygon, newPolygon.Points, dx, dy, out var movedPoints))
                             {
-                                var screenPoint = newPolygon.InternalAnnotation.Transform(new DataPoint(newPolygon.Points[i].X, newPolygon.Points[i].Y));
-                                newPolygon.Points[i] = newPolygon.InternalAnnotation.InverseTransform(new ScreenPoint(screenPoint.X + dx, screenPoint.Y + dy));
+                                newPolygon.Points = movedPoints;
                             }
                         }
 
@@ -1260,15 +1238,8 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                     newPolygon.InternalAnnotation.MouseUp += (s, ae) =>
                     {
                         if (!newPolygon.IsEnabled) return;
-                        try
-                        {
-                            newPolygon.Fill = _originalColor;
-                        }
-                        finally
-                        {
-                            newPolygon.SuppressPropertyChanged = false;
-                        }
-                        newPolygon.RaisePropertyChanged(nameof(newPolygon.Points), nameof(newPolygon.Fill));
+                        newPolygon.SuppressPropertyChanged = false;
+                        newPolygon.RaisePropertyChanged(nameof(newPolygon.Points));
                     };
                 }
                 else if (item is Wpf.PolylineAnnotation)
@@ -1283,15 +1254,10 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                         ClearMarkerOverlays();
 
                         _lastScreenPoint = new ScreenPoint(ae.Position.X, ae.Position.Y);
-                        var screenToData = newPolyline.InternalAnnotation.InverseTransform(ae.Position);
-                        var screen2ToData = newPolyline.InternalAnnotation.InverseTransform(new ScreenPoint(ae.Position.X - HitTestTolerance, ae.Position.Y - HitTestTolerance));
-                        var dxy = new DataPoint(Math.Abs(screenToData.X - screen2ToData.X), Math.Abs(screenToData.Y - screen2ToData.Y));
-                        var dPoint = newPolyline.InternalAnnotation.InverseTransform(ae.Position);
-
                         _movePointIndex = -1;
                         for (int i = 0; i < newPolyline.Points.Count; i++)
                         {
-                            if (Math.Abs(dPoint.X - newPolyline.Points[i].X) < dxy.X && Math.Abs(dPoint.Y - newPolyline.Points[i].Y) < dxy.Y)
+                            if (IsMouseNearDataPoint(newPolyline, newPolyline.Points[i], ae.Position, HitTestTolerance))
                             {
                                 _movePointIndex = i;
                                 break;
@@ -1306,9 +1272,10 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                                 var p1 = newPolyline.InternalAnnotation.Transform(newPolyline.Points[i]);
                                 var p2 = newPolyline.InternalAnnotation.Transform(newPolyline.Points[i + 1]);
                                 var linePoint = ScreenPointHelper.FindPointOnLine(ae.Position, p1, p2);
-                                if ((linePoint - ae.Position).Length < HitTestTolerance)
+                                if ((linePoint - ae.Position).Length < HitTestTolerance
+                                    && TryScreenPointToDataPoint(newPolyline, linePoint, out var insertedPoint))
                                 {
-                                    newPolyline.Points.Insert(i + 1, newPolyline.InternalAnnotation.InverseTransform(linePoint));
+                                    newPolyline.Points.Insert(i + 1, insertedPoint);
                                     onLine = true;
                                     _movePointIndex = i + 1;
                                     break;
@@ -1318,9 +1285,7 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
 
                         if (!onLine) _moveStartPoint = true;
 
-                        _originalColor = newPolyline.Color;
                         newPolyline.SuppressPropertyChanged = true;
-                        newPolyline.Color = Colors.Red;
 
                         GetSelectedObjects(s!, ae);
 
@@ -1337,15 +1302,16 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
 
                         if (_movePointIndex > -1)
                         {
-                            var screenPoint = newPolyline.InternalAnnotation.Transform(new DataPoint(newPolyline.Points[_movePointIndex].X, newPolyline.Points[_movePointIndex].Y));
-                            newPolyline.Points[_movePointIndex] = newPolyline.InternalAnnotation.InverseTransform(new ScreenPoint(screenPoint.X + dx, screenPoint.Y + dy));
+                            if (TryOffsetDataPoint(newPolyline, newPolyline.Points[_movePointIndex], dx, dy, out var movedPoint))
+                            {
+                                newPolyline.Points[_movePointIndex] = movedPoint;
+                            }
                         }
                         else if (_moveStartPoint)
                         {
-                            for (int i = 0; i < newPolyline.Points.Count; i++)
+                            if (TryOffsetDataPoints(newPolyline, newPolyline.Points, dx, dy, out var movedPoints))
                             {
-                                var screenPoint = newPolyline.InternalAnnotation.Transform(new DataPoint(newPolyline.Points[i].X, newPolyline.Points[i].Y));
-                                newPolyline.Points[i] = newPolyline.InternalAnnotation.InverseTransform(new ScreenPoint(screenPoint.X + dx, screenPoint.Y + dy));
+                                newPolyline.Points = movedPoints;
                             }
                         }
 
@@ -1357,15 +1323,8 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                     newPolyline.InternalAnnotation.MouseUp += (s, ae) =>
                     {
                         if (!newPolyline.IsEnabled) return;
-                        try
-                        {
-                            newPolyline.Color = _originalColor;
-                        }
-                        finally
-                        {
-                            newPolyline.SuppressPropertyChanged = false;
-                        }
-                        newPolyline.RaisePropertyChanged(nameof(newPolyline.Points), nameof(newPolyline.Color));
+                        newPolyline.SuppressPropertyChanged = false;
+                        newPolyline.RaisePropertyChanged(nameof(newPolyline.Points));
                     };
                 }
                 else if (item is Wpf.LineAnnotation)
@@ -1382,9 +1341,7 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                         _lastScreenPoint = new ScreenPoint(ae.Position.X, ae.Position.Y);
                         _moveStartPoint = ae.HitTestResult.Index == 0;
 
-                        _originalColor = newLine.Color;
                         newLine.SuppressPropertyChanged = true;
-                        newLine.Color = Colors.Red;
 
                         GetSelectedObjects(s!, ae);
 
@@ -1407,21 +1364,26 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
 
                         double dx = ae.Position.X - _lastScreenPoint.X;
                         double dy = ae.Position.Y - _lastScreenPoint.Y;
-                        var screenPoint = newLine.InternalAnnotation.Transform(new DataPoint(newLine.X, newLine.Y));
-                        var dataPoint = newLine.InternalAnnotation.InverseTransform(new ScreenPoint(screenPoint.X + dx, screenPoint.Y + dy));
+                        TryOffsetDataPoint(newLine, new DataPoint(newLine.X, newLine.Y), dx, dy, out var dataPoint);
 
                         if (_moveStartPoint)
                         {
                             if (newLine.Type == OxyPlot.Annotations.LineAnnotationType.LinearEquation)
                             {
-                                dx = dataPoint.X - newLine.X;
-                                dy = dataPoint.Y - newLine.Y;
-                                newLine.Intercept += (dy - newLine.Slope * dx);
+                                if (dataPoint.IsDefined())
+                                {
+                                    dx = dataPoint.X - newLine.X;
+                                    dy = dataPoint.Y - newLine.Y;
+                                    newLine.Intercept += (dy - newLine.Slope * dx);
+                                }
                             }
                             else
                             {
-                                newLine.X = dataPoint.X;
-                                newLine.Y = dataPoint.Y;
+                                if (TryScreenPointToDataPoint(newLine, ae.Position, out var mouseDataPoint))
+                                {
+                                    newLine.X = mouseDataPoint.X;
+                                    newLine.Y = mouseDataPoint.Y;
+                                }
                             }
                             UpdateLineAnnotationTooltip(newLine);
                         }
@@ -1434,15 +1396,8 @@ private void PlotModelAnnotationCollectionChanged(object? sender, NotifyCollecti
                     newLine.InternalAnnotation.MouseUp += (s, ae) =>
                     {
                         if (!newLine.IsEnabled) return;
-                        try
-                        {
-                            newLine.Color = _originalColor;
-                        }
-                        finally
-                        {
-                            newLine.SuppressPropertyChanged = false;
-                        }
-                        newLine.RaisePropertyChanged(nameof(newLine.X), nameof(newLine.Y), nameof(newLine.Intercept), nameof(newLine.Color));
+                        newLine.SuppressPropertyChanged = false;
+                        newLine.RaisePropertyChanged(nameof(newLine.X), nameof(newLine.Y), nameof(newLine.Intercept));
                         CloseLineAnnotationTooltip(newLine);
                     };
                 }
@@ -1490,11 +1445,11 @@ private void UpdateLineAnnotationTooltip(Wpf.LineAnnotation lineAnnotation)
                         DataPoint dataPoint;
                         if (!lineAnnotation.InternalAnnotation.XAxis!.IsReversed)
                         {
-                            dataPoint = new DataPoint(lineAnnotation.InternalAnnotation.XAxis.ActualMinimum, lineAnnotation.Y);
+                            dataPoint = new DataPoint(lineAnnotation.InternalAnnotation.XAxis.ClipMinimum, lineAnnotation.Y);
                         }
                         else
                         {
-                            dataPoint = new DataPoint(lineAnnotation.InternalAnnotation.XAxis.ActualMaximum, lineAnnotation.Y);
+                            dataPoint = new DataPoint(lineAnnotation.InternalAnnotation.XAxis.ClipMaximum, lineAnnotation.Y);
                         }
                         var toolTip = (ToolTip)lineAnnotation.ToolTip;
                         toolTip.Content = lineAnnotation.InternalAnnotation.YAxis!.FormatValue(lineAnnotation.Y);
@@ -1510,11 +1465,11 @@ private void UpdateLineAnnotationTooltip(Wpf.LineAnnotation lineAnnotation)
                         DataPoint dataPoint;
                         if (!lineAnnotation.InternalAnnotation.YAxis!.IsReversed)
                         {
-                            dataPoint = new DataPoint(lineAnnotation.X, lineAnnotation.InternalAnnotation.YAxis.ActualMinimum);
+                            dataPoint = new DataPoint(lineAnnotation.X, lineAnnotation.InternalAnnotation.YAxis.ClipMinimum);
                         }
                         else
                         {
-                            dataPoint = new DataPoint(lineAnnotation.X, lineAnnotation.InternalAnnotation.YAxis.ActualMaximum);
+                            dataPoint = new DataPoint(lineAnnotation.X, lineAnnotation.InternalAnnotation.YAxis.ClipMaximum);
                         }
                         var toolTip = (ToolTip)lineAnnotation.ToolTip;
                         toolTip.Content = lineAnnotation.InternalAnnotation.XAxis!.FormatValue(lineAnnotation.X);
@@ -1583,10 +1538,19 @@ private void PlotModelMouseDown(object? sender, OxyMouseDownEventArgs e)
                         var newArrow = new Wpf.ArrowAnnotation();
                         newArrow.SuppressPropertyChanged = true;
                         newArrow.Text = "Arrow Annotation";
+                        newArrow.HeadLength = 6;
+                        newArrow.HeadWidth = 2;
+                        newArrow.Veeness = 1;
 
                         Plot.Annotations.Add(newArrow);
+                        if (!TryScreenPointToDataPoint(newArrow, e.Position, out var arrowDataPoint))
+                        {
+                            Plot.Annotations.Remove(newArrow);
+                            break;
+                        }
+
                         PropertiesCalled?.Invoke(Plot, true, OxyPlotPropertiesControl.PropertyEXP.Annotations_Text, newArrow);
-                        newArrow.StartPoint = newArrow.InternalAnnotation.InverseTransform(e.Position);
+                        newArrow.StartPoint = arrowDataPoint;
                         newArrow.EndPoint = newArrow.StartPoint;
                         _targetAddAnnotation = newArrow;
                         break;
@@ -1597,8 +1561,14 @@ private void PlotModelMouseDown(object? sender, OxyMouseDownEventArgs e)
                         newText.Text = "Text Annotation";
 
                         Plot.Annotations.Add(newText);
+                        if (!TryScreenPointToDataPoint(newText, e.Position, out var textDataPoint))
+                        {
+                            Plot.Annotations.Remove(newText);
+                            break;
+                        }
+
                         PropertiesCalled?.Invoke(Plot, true, OxyPlotPropertiesControl.PropertyEXP.Annotations_Text, newText);
-                        newText.TextPosition = newText.InternalAnnotation.InverseTransform(e.Position);
+                        newText.TextPosition = textDataPoint;
                         _targetAddAnnotation = newText;
                         break;
 
@@ -1608,9 +1578,16 @@ private void PlotModelMouseDown(object? sender, OxyMouseDownEventArgs e)
                         newVLine.Text = "Vertical Line Annotation";
 
                         Plot.Annotations.Add(newVLine);
+                        if (!TryGetAnnotationAxes(newVLine, out _, out var verticalYAxis)
+                            || !TryScreenPointToDataPoint(newVLine, e.Position, out var verticalLineDataPoint))
+                        {
+                            Plot.Annotations.Remove(newVLine);
+                            break;
+                        }
+
                         PropertiesCalled?.Invoke(Plot, true, OxyPlotPropertiesControl.PropertyEXP.Annotations_Text, newVLine);
 
-                        if (newVLine.InternalAnnotation.YAxis!.IsReversed == false)
+                        if (verticalYAxis.IsReversed == false)
                         {
                             newVLine.TextLinePosition = 1;
                             newVLine.TextHorizontalAlignment = System.Windows.HorizontalAlignment.Right;
@@ -1622,15 +1599,9 @@ private void PlotModelMouseDown(object? sender, OxyMouseDownEventArgs e)
                         }
 
                         {
-                            OxyRect plotArea = Plot.ActualModel.PlotArea;
-                            var plotLL = newVLine.InternalAnnotation.InverseTransform(new ScreenPoint(plotArea.Left, plotArea.Bottom));
-                            var plotUR = newVLine.InternalAnnotation.InverseTransform(new ScreenPoint(plotArea.Right, plotArea.Top));
-                            var dataPointClicked = newVLine.InternalAnnotation.InverseTransform(e.Position);
-                            newVLine.X = dataPointClicked.X;
-                            newVLine.Y = dataPointClicked.Y;
+                            newVLine.X = verticalLineDataPoint.X;
+                            newVLine.Y = verticalLineDataPoint.Y;
                             newVLine.Type = OxyPlot.Annotations.LineAnnotationType.Vertical;
-                            newVLine.Intercept = dataPointClicked.Y;
-                            newVLine.Slope = (plotUR.Y - plotLL.Y) / (plotUR.X - plotLL.X);
                             _targetAddAnnotation = newVLine;
 
                             OpenLineAnnotationTooltip(newVLine);
@@ -1644,9 +1615,16 @@ private void PlotModelMouseDown(object? sender, OxyMouseDownEventArgs e)
                         newHLine.Text = "Horizontal Line Annotation";
 
                         Plot.Annotations.Add(newHLine);
+                        if (!TryGetAnnotationAxes(newHLine, out var horizontalXAxis, out _)
+                            || !TryScreenPointToDataPoint(newHLine, e.Position, out var horizontalLineDataPoint))
+                        {
+                            Plot.Annotations.Remove(newHLine);
+                            break;
+                        }
+
                         PropertiesCalled?.Invoke(Plot, true, OxyPlotPropertiesControl.PropertyEXP.Annotations_Text, newHLine);
 
-                        if (newHLine.InternalAnnotation.XAxis!.IsReversed == false)
+                        if (horizontalXAxis.IsReversed == false)
                         {
                             newHLine.TextLinePosition = 0;
                             newHLine.TextHorizontalAlignment = System.Windows.HorizontalAlignment.Left;
@@ -1658,15 +1636,9 @@ private void PlotModelMouseDown(object? sender, OxyMouseDownEventArgs e)
                         }
 
                         {
-                            OxyRect plotArea = Plot.ActualModel.PlotArea;
-                            var plotLL = newHLine.InternalAnnotation.InverseTransform(new ScreenPoint(plotArea.Left, plotArea.Bottom));
-                            var plotUR = newHLine.InternalAnnotation.InverseTransform(new ScreenPoint(plotArea.Right, plotArea.Top));
-                            var dataPointClicked = newHLine.InternalAnnotation.InverseTransform(e.Position);
-                            newHLine.X = dataPointClicked.X;
-                            newHLine.Y = dataPointClicked.Y;
+                            newHLine.X = horizontalLineDataPoint.X;
+                            newHLine.Y = horizontalLineDataPoint.Y;
                             newHLine.Type = OxyPlot.Annotations.LineAnnotationType.Horizontal;
-                            newHLine.Intercept = dataPointClicked.Y;
-                            newHLine.Slope = (plotUR.Y - plotLL.Y) / (plotUR.X - plotLL.X);
                             _targetAddAnnotation = newHLine;
 
                             OpenLineAnnotationTooltip(newHLine);
@@ -1680,13 +1652,18 @@ private void PlotModelMouseDown(object? sender, OxyMouseDownEventArgs e)
                         newRectangle.Text = "Rectangle Annotation";
 
                         Plot.Annotations.Add(newRectangle);
+                        if (!TryScreenPointToDataPoint(newRectangle, e.Position, out var rectangleDataPoint))
+                        {
+                            Plot.Annotations.Remove(newRectangle);
+                            break;
+                        }
+
                         PropertiesCalled?.Invoke(Plot, true, OxyPlotPropertiesControl.PropertyEXP.Annotations_Text, newRectangle);
                         {
-                            var dataPointClicked = newRectangle.InternalAnnotation.InverseTransform(e.Position);
-                            newRectangle.MinimumX = dataPointClicked.X;
-                            newRectangle.MaximumX = dataPointClicked.X;
-                            newRectangle.MinimumY = dataPointClicked.Y;
-                            newRectangle.MaximumY = dataPointClicked.Y;
+                            newRectangle.MinimumX = rectangleDataPoint.X;
+                            newRectangle.MaximumX = rectangleDataPoint.X;
+                            newRectangle.MinimumY = rectangleDataPoint.Y;
+                            newRectangle.MaximumY = rectangleDataPoint.Y;
                             _targetAddAnnotation = newRectangle;
                         }
                         break;
@@ -1697,13 +1674,18 @@ private void PlotModelMouseDown(object? sender, OxyMouseDownEventArgs e)
                         newEllipse.Text = "Ellipse Annotation";
 
                         Plot.Annotations.Add(newEllipse);
+                        if (!TryScreenPointToDataPoint(newEllipse, e.Position, out var ellipseDataPoint))
+                        {
+                            Plot.Annotations.Remove(newEllipse);
+                            break;
+                        }
+
                         PropertiesCalled?.Invoke(Plot, true, OxyPlotPropertiesControl.PropertyEXP.Annotations_Text, newEllipse);
                         {
-                            var dataPointClicked = newEllipse.InternalAnnotation.InverseTransform(e.Position);
-                            newEllipse.MinimumX = dataPointClicked.X;
-                            newEllipse.MaximumX = dataPointClicked.X;
-                            newEllipse.MinimumY = dataPointClicked.Y;
-                            newEllipse.MaximumY = dataPointClicked.Y;
+                            newEllipse.MinimumX = ellipseDataPoint.X;
+                            newEllipse.MaximumX = ellipseDataPoint.X;
+                            newEllipse.MinimumY = ellipseDataPoint.Y;
+                            newEllipse.MaximumY = ellipseDataPoint.Y;
                             _targetAddAnnotation = newEllipse;
                         }
                         break;
@@ -1715,16 +1697,16 @@ private void PlotModelMouseDown(object? sender, OxyMouseDownEventArgs e)
                         newPoint.Size = 5;
 
                         Plot.Annotations.Add(newPoint);
+                        if (!TryScreenPointToDataPoint(newPoint, e.Position, out var pointDataPoint))
+                        {
+                            Plot.Annotations.Remove(newPoint);
+                            break;
+                        }
+
                         PropertiesCalled?.Invoke(Plot, true, OxyPlotPropertiesControl.PropertyEXP.Annotations_Text, newPoint);
                         {
-                            var dataPointClicked = newPoint.InternalAnnotation.InverseTransform(e.Position);
-                            OxyRect plotArea = Plot.ActualModel.PlotArea;
-                            var plotLL = newPoint.InternalAnnotation.InverseTransform(new ScreenPoint(plotArea.Left, plotArea.Bottom));
-                            var plotUR = newPoint.InternalAnnotation.InverseTransform(new ScreenPoint(plotArea.Right, plotArea.Top));
-                            var plotCenter = newPoint.InternalAnnotation.InverseTransform(Plot.ActualModel.PlotArea.Center);
-
-                            newPoint.X = dataPointClicked.X;
-                            newPoint.Y = dataPointClicked.Y;
+                            newPoint.X = pointDataPoint.X;
+                            newPoint.Y = pointDataPoint.Y;
                             _targetAddAnnotation = newPoint;
                         }
                         break;
@@ -1861,47 +1843,67 @@ private void PlotModelMouseMove(object? sender, OxyMouseEventArgs e)
                 switch (_addAnnotationToolMode)
                 {
                     case AddToolMode.AddArrowAnnotation:
-                        ((Wpf.ArrowAnnotation)_targetAddAnnotation).EndPoint = _targetAddAnnotation.InternalAnnotation.InverseTransform(e.Position);
+                        if (TryScreenPointToDataPoint(_targetAddAnnotation, e.Position, out var arrowEndPoint))
+                        {
+                            ((Wpf.ArrowAnnotation)_targetAddAnnotation).EndPoint = arrowEndPoint;
+                        }
                         break;
 
                     case AddToolMode.AddTextAnnotation:
-                        ((Wpf.TextAnnotation)_targetAddAnnotation).TextPosition = _targetAddAnnotation.InternalAnnotation.InverseTransform(e.Position);
+                        if (TryScreenPointToDataPoint(_targetAddAnnotation, e.Position, out var textPosition))
+                        {
+                            ((Wpf.TextAnnotation)_targetAddAnnotation).TextPosition = textPosition;
+                        }
                         break;
 
                     case AddToolMode.AddVerticalLineAnnotation:
-                        ((Wpf.LineAnnotation)_targetAddAnnotation).X = _targetAddAnnotation.InternalAnnotation.InverseTransform(e.Position).X;
+                        if (TryScreenPointToDataPoint(_targetAddAnnotation, e.Position, out var verticalLinePoint))
+                        {
+                            ((Wpf.LineAnnotation)_targetAddAnnotation).X = verticalLinePoint.X;
+                            ((Wpf.LineAnnotation)_targetAddAnnotation).Y = verticalLinePoint.Y;
+                        }
                         UpdateLineAnnotationTooltip((Wpf.LineAnnotation)_targetAddAnnotation);
                         break;
 
                     case AddToolMode.AddHorizontalLineAnnotation:
-                        ((Wpf.LineAnnotation)_targetAddAnnotation).Y = _targetAddAnnotation.InternalAnnotation.InverseTransform(e.Position).Y;
+                        if (TryScreenPointToDataPoint(_targetAddAnnotation, e.Position, out var horizontalLinePoint))
+                        {
+                            ((Wpf.LineAnnotation)_targetAddAnnotation).X = horizontalLinePoint.X;
+                            ((Wpf.LineAnnotation)_targetAddAnnotation).Y = horizontalLinePoint.Y;
+                        }
                         UpdateLineAnnotationTooltip((Wpf.LineAnnotation)_targetAddAnnotation);
                         break;
 
                     case AddToolMode.AddRectangleAnnotation:
                         {
-                            var mouseDataPoint = _targetAddAnnotation.InternalAnnotation.InverseTransform(e.Position);
-                            var rect = (Wpf.RectangleAnnotation)_targetAddAnnotation;
-                            rect.MaximumX = mouseDataPoint.X;
-                            rect.MaximumY = mouseDataPoint.Y;
+                            if (TryScreenPointToDataPoint(_targetAddAnnotation, e.Position, out var mouseDataPoint))
+                            {
+                                var rect = (Wpf.RectangleAnnotation)_targetAddAnnotation;
+                                rect.MaximumX = mouseDataPoint.X;
+                                rect.MaximumY = mouseDataPoint.Y;
+                            }
                         }
                         break;
 
                     case AddToolMode.AddEllipseAnnotation:
                         {
-                            var mouseDataPoint = _targetAddAnnotation.InternalAnnotation.InverseTransform(e.Position);
-                            var ellipse = (Wpf.EllipseAnnotation)_targetAddAnnotation;
-                            ellipse.MaximumX = mouseDataPoint.X;
-                            ellipse.MaximumY = mouseDataPoint.Y;
+                            if (TryScreenPointToDataPoint(_targetAddAnnotation, e.Position, out var mouseDataPoint))
+                            {
+                                var ellipse = (Wpf.EllipseAnnotation)_targetAddAnnotation;
+                                ellipse.MaximumX = mouseDataPoint.X;
+                                ellipse.MaximumY = mouseDataPoint.Y;
+                            }
                         }
                         break;
 
                     case AddToolMode.AddPointAnnotation:
                         {
-                            var mouseDataPoint = _targetAddAnnotation.InternalAnnotation.InverseTransform(e.Position);
-                            var point = (Wpf.PointAnnotation)_targetAddAnnotation;
-                            point.X = mouseDataPoint.X;
-                            point.Y = mouseDataPoint.Y;
+                            if (TryScreenPointToDataPoint(_targetAddAnnotation, e.Position, out var mouseDataPoint))
+                            {
+                                var point = (Wpf.PointAnnotation)_targetAddAnnotation;
+                                point.X = mouseDataPoint.X;
+                                point.Y = mouseDataPoint.Y;
+                            }
                         }
                         break;
 
@@ -1916,7 +1918,10 @@ private void PlotModelMouseMove(object? sender, OxyMouseEventArgs e)
                     case AddToolMode.AddPolylineAnnotation:
                         {
                             var polyAnnotation = (Wpf.PolylineAnnotation)_targetAddAnnotation;
-                            _leaderLine.Points[0] = ConvertDataPointToPoint(polyAnnotation.Points[polyAnnotation.Points.Count - 1]);
+                            if (TryDataPointToScreenPoint(polyAnnotation, polyAnnotation.Points[polyAnnotation.Points.Count - 1], out var leaderStartPoint))
+                            {
+                                _leaderLine.Points[0] = new Point(leaderStartPoint.X, leaderStartPoint.Y);
+                            }
                             _leaderLine.Points[_leaderLine.Points.Count - 1] = new Point(e.Position.X, e.Position.Y);
                             Plot.InvalidatePlot(false);
                         }
@@ -2030,9 +2035,6 @@ private void PlotModelMouseMove(object? sender, OxyMouseEventArgs e)
                     if (ht.Index == 0)
                     {
                         var polyAnnotation = (Wpf.PolygonAnnotation)a;
-                        var screenToData = polyAnnotation.InternalAnnotation.InverseTransform(e.Position);
-                        var screen2ToData = polyAnnotation.InternalAnnotation.InverseTransform(new ScreenPoint(e.Position.X - HitTestTolerance, e.Position.Y - HitTestTolerance));
-                        var dxy = new DataPoint(Math.Abs(screenToData.X - screen2ToData.X), Math.Abs(screenToData.Y - screen2ToData.Y));
 
                         foreach (var p in polyAnnotation.Points)
                         {
@@ -2040,9 +2042,8 @@ private void PlotModelMouseMove(object? sender, OxyMouseEventArgs e)
                             markerSizes.Add(2);
                         }
 
-                        var dPoint = polyAnnotation.InternalAnnotation.InverseTransform(e.Position);
                         // Check if cursor is over any points
-                        if (polyAnnotation.Points.Any(o => Math.Abs(dPoint.X - o.X) < dxy.X && Math.Abs(dPoint.Y - o.Y) < dxy.Y))
+                        if (polyAnnotation.Points.Any(o => IsMouseNearDataPoint(polyAnnotation, o, e.Position, HitTestTolerance)))
                         {
                             updatedCursor = _movePointsCursor;
                         }
@@ -2084,9 +2085,6 @@ private void PlotModelMouseMove(object? sender, OxyMouseEventArgs e)
                     if (ht.Index == 0)
                     {
                         var polylineAnnotation = (Wpf.PolylineAnnotation)a;
-                        var screenToData = polylineAnnotation.InternalAnnotation.InverseTransform(e.Position);
-                        var screen2ToData = polylineAnnotation.InternalAnnotation.InverseTransform(new ScreenPoint(e.Position.X - HitTestTolerance, e.Position.Y - HitTestTolerance));
-                        var dxy = new DataPoint(Math.Abs(screenToData.X - screen2ToData.X), Math.Abs(screenToData.Y - screen2ToData.Y));
 
                         foreach (var p in polylineAnnotation.Points)
                         {
@@ -2094,9 +2092,8 @@ private void PlotModelMouseMove(object? sender, OxyMouseEventArgs e)
                             markerSizes.Add(2);
                         }
 
-                        var dPoint = polylineAnnotation.InternalAnnotation.InverseTransform(e.Position);
                         // Check if cursor is over any points
-                        if (polylineAnnotation.Points.Any(o => Math.Abs(dPoint.X - o.X) < dxy.X && Math.Abs(dPoint.Y - o.Y) < dxy.Y))
+                        if (polylineAnnotation.Points.Any(o => IsMouseNearDataPoint(polylineAnnotation, o, e.Position, HitTestTolerance)))
                         {
                             updatedCursor = _movePointsCursor;
                         }
@@ -2191,20 +2188,18 @@ private void PlotModelMouseUp(object? sender, OxyMouseEventArgs e)
                 // Correct the height and width if necessary
                 if (pixelWidth < MinAnnotationSize || pixelHeight < MinAnnotationSize)
                 {
-                    var plotLL = rectangle.InternalAnnotation.InverseTransform(new ScreenPoint(Plot.ActualModel.PlotArea.Left, Plot.ActualModel.PlotArea.Bottom));
-                    var plotUR = rectangle.InternalAnnotation.InverseTransform(new ScreenPoint(Plot.ActualModel.PlotArea.Right, Plot.ActualModel.PlotArea.Top));
-                    double centerXShift = Math.Abs((plotUR.X - plotLL.X) * 0.1);
-                    double centerYShift = Math.Abs((plotUR.Y - plotLL.Y) * 0.1);
-                    var mouseDataPoint = rectangle.InternalAnnotation.InverseTransform(e.Position);
-                    if (pixelWidth < MinAnnotationSize)
+                    if (TryCreateMinimumScreenBounds(rectangle, e.Position, out var minimumPoint, out var maximumPoint))
                     {
-                        rectangle.MinimumX = mouseDataPoint.X - centerXShift;
-                        rectangle.MaximumX = mouseDataPoint.X + centerXShift;
-                    }
-                    if (pixelHeight < MinAnnotationSize)
-                    {
-                        rectangle.MinimumY = mouseDataPoint.Y - centerYShift;
-                        rectangle.MaximumY = mouseDataPoint.Y + centerYShift;
+                        if (pixelWidth < MinAnnotationSize)
+                        {
+                            rectangle.MinimumX = minimumPoint.X;
+                            rectangle.MaximumX = maximumPoint.X;
+                        }
+                        if (pixelHeight < MinAnnotationSize)
+                        {
+                            rectangle.MinimumY = minimumPoint.Y;
+                            rectangle.MaximumY = maximumPoint.Y;
+                        }
                     }
                 }
                 StopAddAnnotation();
@@ -2220,20 +2215,18 @@ private void PlotModelMouseUp(object? sender, OxyMouseEventArgs e)
                 // Correct the height and width if necessary
                 if (pixelWidth < MinAnnotationSize || pixelHeight < MinAnnotationSize)
                 {
-                    var plotLL = ellipse.InternalAnnotation.InverseTransform(new ScreenPoint(Plot.ActualModel.PlotArea.Left, Plot.ActualModel.PlotArea.Bottom));
-                    var plotUR = ellipse.InternalAnnotation.InverseTransform(new ScreenPoint(Plot.ActualModel.PlotArea.Right, Plot.ActualModel.PlotArea.Top));
-                    double centerXShift = Math.Abs((plotUR.X - plotLL.X) * 0.1);
-                    double centerYShift = Math.Abs((plotUR.Y - plotLL.Y) * 0.1);
-                    var mouseDataPoint = ellipse.InternalAnnotation.InverseTransform(e.Position);
-                    if (pixelWidth < MinAnnotationSize)
-                    {
-                        ellipse.MinimumX = mouseDataPoint.X - centerXShift;
-                        ellipse.MaximumX = mouseDataPoint.X + centerXShift;
-                    }
-                    if (pixelHeight < MinAnnotationSize)
+                    if (TryCreateMinimumScreenBounds(ellipse, e.Position, out var minimumPoint, out var maximumPoint))
                     {
-                        ellipse.MinimumY = mouseDataPoint.Y - centerYShift;
-                        ellipse.MaximumY = mouseDataPoint.Y + centerYShift;
+                        if (pixelWidth < MinAnnotationSize)
+                        {
+                            ellipse.MinimumX = minimumPoint.X;
+                            ellipse.MaximumX = maximumPoint.X;
+                        }
+                        if (pixelHeight < MinAnnotationSize)
+                        {
+                            ellipse.MinimumY = minimumPoint.Y;
+                            ellipse.MaximumY = maximumPoint.Y;
+                        }
                     }
                 }
                 StopAddAnnotation();
@@ -2251,9 +2244,10 @@ private void PlotModelMouseUp(object? sender, OxyMouseEventArgs e)
                         OxyRect plotArea = Plot.ActualModel.PlotArea;
                         double shiftPixels = Math.Abs(plotArea.Right - plotArea.Left) * 0.05;
                         var arrowScreen = arrow.InternalAnnotation.Transform(arrow.EndPoint);
-                        var shiftedData = arrow.InternalAnnotation.InverseTransform(
-                            new ScreenPoint(arrowScreen.X + shiftPixels, arrowScreen.Y));
-                        arrow.StartPoint = shiftedData;
+                        if (TryScreenPointToDataPoint(arrow, new ScreenPoint(arrowScreen.X + shiftPixels, arrowScreen.Y), out var shiftedData))
+                        {
+                            arrow.StartPoint = shiftedData;
+                        }
                     }
                 }
                 StopAddAnnotation();
@@ -3351,28 +3345,180 @@ private DataPoint ConvertScreenPointToDataPoint(ScreenPoint pt)
             {
                 return DataPoint.Undefined;
             }
-            return xAxis.InverseTransform(pt.X, pt.Y, yAxis);
+
+            var dataPoint = xAxis.InverseTransform(pt.X, pt.Y, yAxis);
+            return IsValidDataPoint(xAxis, yAxis, dataPoint)
+                ? dataPoint
+                : DataPoint.Undefined;
         }
 
-        /// <summary>
-        /// Converts a data point to a WPF Point using the plot's default axes.
-        /// </summary>
-        /// <param name="pt">The data point to convert.</param>
-        /// <returns>The corresponding WPF Point.</returns>
-        private Point ConvertDataPointToPoint(DataPoint pt)
+        private bool TryGetAnnotationAxes(Wpf.Annotation annotation, out OxyPlot.Axes.Axis xAxis, out OxyPlot.Axes.Axis yAxis)
         {
-            var sp = Plot.ActualModel.DefaultXAxis.Transform(pt.X, pt.Y, Plot.ActualModel.DefaultYAxis);
-            return new Point(sp.X, sp.Y);
+            var resolvedXAxis = annotation.InternalAnnotation.XAxis ?? Plot?.ActualModel?.DefaultXAxis;
+            var resolvedYAxis = annotation.InternalAnnotation.YAxis ?? Plot?.ActualModel?.DefaultYAxis;
+            if (resolvedXAxis == null || resolvedYAxis == null)
+            {
+                xAxis = null!;
+                yAxis = null!;
+                return false;
+            }
+
+            xAxis = resolvedXAxis;
+            yAxis = resolvedYAxis;
+            return true;
         }
 
-        /// <summary>
-        /// Converts a point from the leader line polyline to a data point.
-        /// </summary>
-        /// <param name="pointIndex">The index of the point in the leader line points collection.</param>
-        /// <returns>The corresponding data point.</returns>
-        private DataPoint ConvertLeaderLinePoint(int pointIndex)
+        private bool TryScreenPointToDataPoint(Wpf.Annotation annotation, ScreenPoint screenPoint, out DataPoint dataPoint)
+        {
+            dataPoint = DataPoint.Undefined;
+            if (!IsFinite(screenPoint.X) || !IsFinite(screenPoint.Y))
+            {
+                return false;
+            }
+
+            if (!TryGetAnnotationAxes(annotation, out var xAxis, out var yAxis))
+            {
+                return false;
+            }
+
+            var convertedPoint = xAxis.InverseTransform(screenPoint.X, screenPoint.Y, yAxis);
+            if (!IsValidDataPoint(xAxis, yAxis, convertedPoint))
+            {
+                return false;
+            }
+
+            dataPoint = convertedPoint;
+            return true;
+        }
+
+        private bool TryDataPointToScreenPoint(Wpf.Annotation annotation, DataPoint dataPoint, out ScreenPoint screenPoint)
+        {
+            screenPoint = ScreenPoint.Undefined;
+            if (!TryGetAnnotationAxes(annotation, out var xAxis, out var yAxis)
+                || !IsValidDataPoint(xAxis, yAxis, dataPoint))
+            {
+                return false;
+            }
+
+            var convertedPoint = xAxis.Transform(dataPoint.X, dataPoint.Y, yAxis);
+            if (!IsFinite(convertedPoint.X) || !IsFinite(convertedPoint.Y))
+            {
+                return false;
+            }
+
+            screenPoint = convertedPoint;
+            return true;
+        }
+
+        private bool TryOffsetDataPoint(Wpf.Annotation annotation, DataPoint dataPoint, double dx, double dy, out DataPoint offsetDataPoint)
+        {
+            offsetDataPoint = DataPoint.Undefined;
+            if (!TryDataPointToScreenPoint(annotation, dataPoint, out var screenPoint))
+            {
+                return false;
+            }
+
+            return TryScreenPointToDataPoint(
+                annotation,
+                new ScreenPoint(screenPoint.X + dx, screenPoint.Y + dy),
+                out offsetDataPoint);
+        }
+
+        private bool TryOffsetDataPoints(Wpf.Annotation annotation, IList<DataPoint> dataPoints, double dx, double dy, out List<DataPoint> offsetDataPoints)
+        {
+            offsetDataPoints = new List<DataPoint>(dataPoints.Count);
+            foreach (var dataPoint in dataPoints)
+            {
+                if (!TryOffsetDataPoint(annotation, dataPoint, dx, dy, out var offsetDataPoint))
+                {
+                    offsetDataPoints.Clear();
+                    return false;
+                }
+
+                offsetDataPoints.Add(offsetDataPoint);
+            }
+
+            return true;
+        }
+
+        private bool TryCreateMinimumScreenBounds(Wpf.Annotation annotation, ScreenPoint center, out DataPoint minimumPoint, out DataPoint maximumPoint)
+        {
+            minimumPoint = DataPoint.Undefined;
+            maximumPoint = DataPoint.Undefined;
+
+            var plotArea = Plot?.ActualModel?.PlotArea;
+            if (plotArea == null)
+            {
+                return false;
+            }
+
+            double plotWidth = Math.Abs(plotArea.Value.Right - plotArea.Value.Left);
+            double plotHeight = Math.Abs(plotArea.Value.Bottom - plotArea.Value.Top);
+            if (plotWidth <= 0 || plotHeight <= 0)
+            {
+                return false;
+            }
+
+            double boxWidth = Math.Min(MinAnnotationSize, plotWidth);
+            double boxHeight = Math.Min(MinAnnotationSize, plotHeight);
+            double centerX = Clamp(center.X, plotArea.Value.Left, plotArea.Value.Right);
+            double centerY = Clamp(center.Y, plotArea.Value.Top, plotArea.Value.Bottom);
+
+            double left = Clamp(centerX - boxWidth / 2, plotArea.Value.Left, plotArea.Value.Right - boxWidth);
+            double top = Clamp(centerY - boxHeight / 2, plotArea.Value.Top, plotArea.Value.Bottom - boxHeight);
+            double right = left + boxWidth;
+            double bottom = top + boxHeight;
+
+            if (!TryScreenPointToDataPoint(annotation, new ScreenPoint(left, bottom), out var lowerLeftPoint)
+                || !TryScreenPointToDataPoint(annotation, new ScreenPoint(right, top), out var upperRightPoint))
+            {
+                return false;
+            }
+
+            minimumPoint = new DataPoint(
+                Math.Min(lowerLeftPoint.X, upperRightPoint.X),
+                Math.Min(lowerLeftPoint.Y, upperRightPoint.Y));
+            maximumPoint = new DataPoint(
+                Math.Max(lowerLeftPoint.X, upperRightPoint.X),
+                Math.Max(lowerLeftPoint.Y, upperRightPoint.Y));
+
+            return IsValidDataPoint(annotation, minimumPoint) && IsValidDataPoint(annotation, maximumPoint);
+        }
+
+        private bool IsMouseNearDataPoint(Wpf.Annotation annotation, DataPoint dataPoint, ScreenPoint mousePosition, double tolerance)
+        {
+            return TryDataPointToScreenPoint(annotation, dataPoint, out var screenPoint)
+                && (screenPoint - mousePosition).Length < tolerance;
+        }
+
+        private bool IsValidDataPoint(Wpf.Annotation annotation, DataPoint dataPoint)
+        {
+            return TryGetAnnotationAxes(annotation, out var xAxis, out var yAxis)
+                && IsValidDataPoint(xAxis, yAxis, dataPoint);
+        }
+
+        private static bool IsValidDataPoint(OxyPlot.Axes.Axis xAxis, OxyPlot.Axes.Axis yAxis, DataPoint dataPoint)
+        {
+            return dataPoint.IsDefined()
+                && IsFinite(dataPoint.X)
+                && IsFinite(dataPoint.Y)
+                && xAxis.IsValidValue(dataPoint.X)
+                && yAxis.IsValidValue(dataPoint.Y);
+        }
+
+        private static bool IsFinite(double value)
         {
-            return Plot.ActualModel.DefaultXAxis.InverseTransform(_leaderLine.Points[pointIndex].X, _leaderLine.Points[pointIndex].Y, Plot.ActualModel.DefaultYAxis);
+            return !double.IsNaN(value) && !double.IsInfinity(value);
+        }
+
+        private static double Clamp(double value, double minimum, double maximum)
+        {
+            if (maximum < minimum)
+            {
+                return minimum;
+            }
+
+            return Math.Max(minimum, Math.Min(maximum, value));
         }
 
         /// <summary>
@@ -3417,19 +3563,21 @@ private Point GetPosition(Visual element, Canvas canvas)
         /// <summary>
         /// Export series data to file.
         /// </summary>
-        private void ExportDataButton_Click(object sender, RoutedEventArgs e)
+        private static List<DataTable> BuildExportDataTables(Wpf.Plot plot)
         {
             var tableList = new List<DataTable>();
             int tableCount = 0;
             string[] badCharacters = { ":", "\\", "/", "?", "*", "[", "]" };
 
-            foreach (Wpf.Series series in Plot.Series)
+            foreach (Wpf.Series series in plot.Series)
             {
+                series.CreateModel();
+
                 var dataTable = new DataTable("Series");
                 string seriesName = "";
                 tableCount++;
 
-                if (series is Wpf.LineSeries)
+                if (series is Wpf.LineSeries && series is not Wpf.AreaSeries)
                 {
                     seriesName = !string.IsNullOrEmpty(series.Title) ? series.Title : "LineSeries_" + tableCount;
                     foreach (var badChar in badCharacters)
@@ -3443,35 +3591,11 @@ private void ExportDataButton_Click(object sender, RoutedEventArgs e)
                     dataTable.Columns.Add(seriesName + "_y", typeof(string));
 
                     var oxySeries = (OxyPlot.Series.LineSeries)series.InternalSeries;
+                    var wpfSeries = (Wpf.DataPointSeries)series;
 
-                    if (oxySeries.ItemsSource != null)
-                    {
-                        var datalist = oxySeries.ItemsSource as IEnumerable<DataPoint>;
-                        if (datalist != null)
-                        {
-                            foreach (var seriesValue in datalist.ToList())
-                            {
-                                dataTable.Rows.Add(dataTable.Rows.Count + 1, seriesValue.X, seriesValue.Y);
-                            }
-                        }
-                        else
-                        {
-                            foreach (var obj in oxySeries.ItemsSource.Cast<object>())
-                            {
-                                PropertyInfo? propX = obj.GetType().GetProperty(oxySeries.DataFieldX);
-                                string xVal = propX != null ? Convert.ToString(propX.GetValue(obj, null)) ?? "" : "";
-                                PropertyInfo? propY = obj.GetType().GetProperty(oxySeries.DataFieldY);
-                                string yVal = propY != null ? Convert.ToString(propY.GetValue(obj, null)) ?? "" : "";
-                                dataTable.Rows.Add(dataTable.Rows.Count + 1, xVal, yVal);
-                            }
-                        }
-                    }
-                    else
+                    foreach (var seriesValue in GetDataPointExportValues(wpfSeries, oxySeries))
                     {
-                        foreach (var seriesValue in oxySeries.Points)
-                        {
-                            dataTable.Rows.Add(dataTable.Rows.Count + 1, seriesValue.X, seriesValue.Y);
-                        }
+                        dataTable.Rows.Add(dataTable.Rows.Count + 1, seriesValue.X, seriesValue.Y);
                     }
                 }
                 else if (series is Wpf.ScatterPointSeries)
@@ -3488,35 +3612,11 @@ private void ExportDataButton_Click(object sender, RoutedEventArgs e)
                     dataTable.Columns.Add(seriesName + "_y", typeof(string));
 
                     var oxySeries = (OxyPlot.Series.ScatterSeries)series.InternalSeries;
+                    var wpfSeries = (Wpf.ScatterPointSeries)series;
 
-                    if (oxySeries.ItemsSource != null)
+                    foreach (var seriesValue in GetScatterPointExportValues(wpfSeries, oxySeries))
                     {
-                        var datalist = oxySeries.ItemsSource as IEnumerable<OxyPlot.Series.ScatterPoint>;
-                        if (datalist != null)
-                        {
-                            foreach (var seriesValue in datalist.ToList())
-                            {
-                                dataTable.Rows.Add(dataTable.Rows.Count + 1, seriesValue.X, seriesValue.Y);
-                            }
-                        }
-                        else
-                        {
-                            foreach (var obj in oxySeries.ItemsSource.Cast<object>())
-                            {
-                                PropertyInfo? propX = obj.GetType().GetProperty(oxySeries.DataFieldX);
-                                string xVal = propX != null ? Convert.ToString(propX.GetValue(obj, null)) ?? "" : "";
-                                PropertyInfo? propY = obj.GetType().GetProperty(oxySeries.DataFieldY);
-                                string yVal = propY != null ? Convert.ToString(propY.GetValue(obj, null)) ?? "" : "";
-                                dataTable.Rows.Add(dataTable.Rows.Count + 1, xVal, yVal);
-                            }
-                        }
-                    }
-                    else
-                    {
-                        foreach (var seriesValue in oxySeries.Points)
-                        {
-                            dataTable.Rows.Add(dataTable.Rows.Count + 1, seriesValue.X, seriesValue.Y);
-                        }
+                        dataTable.Rows.Add(dataTable.Rows.Count + 1, seriesValue.X, seriesValue.Y);
                     }
                 }
                 else if (series is Wpf.AreaSeries)
@@ -3535,57 +3635,11 @@ private void ExportDataButton_Click(object sender, RoutedEventArgs e)
                     dataTable.Columns.Add(seriesName + "_y2", typeof(string));
 
                     var oxySeries = (OxyPlot.Series.AreaSeries)series.InternalSeries;
+                    var wpfSeries = (Wpf.AreaSeries)series;
 
-                    if (oxySeries.ItemsSource != null)
+                    foreach (var seriesValue in GetAreaExportValues(wpfSeries, oxySeries))
                     {
-                        var datalist = oxySeries.ItemsSource as IEnumerable<DataPoint>;
-                        if (datalist != null)
-                        {
-                            foreach (var seriesValue in datalist.ToList())
-                            {
-                                dataTable.Rows.Add(dataTable.Rows.Count + 1, seriesValue.X, seriesValue.Y);
-                            }
-                        }
-                        else
-                        {
-                            foreach (var obj in oxySeries.ItemsSource.Cast<object>())
-                            {
-                                PropertyInfo? propX = obj.GetType().GetProperty(oxySeries.DataFieldX);
-                                string xVal = Convert.ToString(propX?.GetValue(obj, null)) ?? "";
-                                PropertyInfo? propY = obj.GetType().GetProperty(oxySeries.DataFieldY);
-                                string yVal = Convert.ToString(propY?.GetValue(obj, null)) ?? "";
-
-                                string xVal2 = "";
-                                if (oxySeries.DataFieldX2 != null)
-                                {
-                                    PropertyInfo? propX2 = obj.GetType().GetProperty(oxySeries.DataFieldX2);
-                                    xVal2 = Convert.ToString(propX2?.GetValue(obj, null)) ?? "";
-                                }
-
-                                string yVal2 = "";
-                                if (oxySeries.DataFieldY2 != null)
-                                {
-                                    PropertyInfo? propY2 = obj.GetType().GetProperty(oxySeries.DataFieldY2);
-                                    yVal2 = Convert.ToString(propY2?.GetValue(obj, null)) ?? "";
-                                }
-
-                                dataTable.Rows.Add(dataTable.Rows.Count + 1, xVal, yVal, xVal2, yVal2);
-                            }
-                        }
-                    }
-                    else
-                    {
-                        for (int i = 0; i < oxySeries.Points.Count; i++)
-                        {
-                            if (oxySeries.Points2.Count > 0)
-                            {
-                                dataTable.Rows.Add(dataTable.Rows.Count + 1, oxySeries.Points[i].X, oxySeries.Points[i].Y, oxySeries.Points2[i].X, oxySeries.Points2[i].Y);
-                            }
-                            else
-                            {
-                                dataTable.Rows.Add(dataTable.Rows.Count + 1, oxySeries.Points[i].X, oxySeries.Points[i].Y, "", "");
-                            }
-                        }
+                        dataTable.Rows.Add(dataTable.Rows.Count + 1, seriesValue.X, seriesValue.Y, seriesValue.X2, seriesValue.Y2);
                     }
                 }
                 else if (series is Wpf.BoxPlotSeries)
@@ -3704,19 +3758,8 @@ private void ExportDataButton_Click(object sender, RoutedEventArgs e)
                             int c = 0;
                             foreach (var obj in oxySeries.ItemsSource.Cast<object>())
                             {
-                                string colorVal = "";
-                                if (oxySeries.ColorField != null)
-                                {
-                                    PropertyInfo? propColor = obj.GetType().GetProperty(oxySeries.ColorField);
-                                    colorVal = Convert.ToString(propColor?.GetValue(obj, null)) ?? "";
-                                }
-
-                                string valueVal = "";
-                                if (oxySeries.ValueField != null)
-                                {
-                                    PropertyInfo? propValue = obj.GetType().GetProperty(oxySeries.ValueField);
-                                    valueVal = Convert.ToString(propValue?.GetValue(obj, null)) ?? "";
-                                }
+                                string colorVal = GetPropertyValueOrEmpty(obj, oxySeries.ColorField);
+                                string valueVal = GetPropertyValueOrEmpty(obj, oxySeries.ValueField);
 
                                 dataTable.Rows.Add(dataTable.Rows.Count + 1, c, colorVal, valueVal);
                                 c++;
@@ -3762,19 +3805,8 @@ private void ExportDataButton_Click(object sender, RoutedEventArgs e)
                             int c = 0;
                             foreach (var obj in oxySeries.ItemsSource.Cast<object>())
                             {
-                                string colorVal = "";
-                                if (oxySeries.ColorField != null)
-                                {
-                                    PropertyInfo? propColor = obj.GetType().GetProperty(oxySeries.ColorField);
-                                    colorVal = Convert.ToString(propColor?.GetValue(obj, null)) ?? "";
-                                }
-
-                                string valueVal = "";
-                                if (oxySeries.ValueField != null)
-                                {
-                                    PropertyInfo? propValue = obj.GetType().GetProperty(oxySeries.ValueField);
-                                    valueVal = Convert.ToString(propValue?.GetValue(obj, null)) ?? "";
-                                }
+                                string colorVal = GetPropertyValueOrEmpty(obj, oxySeries.ColorField);
+                                string valueVal = GetPropertyValueOrEmpty(obj, oxySeries.ValueField);
 
                                 dataTable.Rows.Add(dataTable.Rows.Count + 1, c, colorVal, valueVal);
                                 c++;
@@ -3944,135 +3976,39 @@ private void ExportDataButton_Click(object sender, RoutedEventArgs e)
                     var oxySeries = (OxyPlot.Series.ScatterErrorSeries)series.InternalSeries;
                     var wpfSeries = (Wpf.ScatterErrorSeries)series;
 
-                    if (oxySeries.ItemsSource != null)
-                    {
-                        var datalist = oxySeries.ItemsSource as IEnumerable<OxyPlot.Series.ScatterPoint>;
-                        if (datalist != null)
-                        {
-                            foreach (OxyPlot.Series.ScatterErrorPoint seriesValue in datalist.ToList())
-                            {
-                                dataTable.Rows.Add(dataTable.Rows.Count + 1, seriesValue.LowerErrorX, seriesValue.X, seriesValue.UpperErrorX, seriesValue.LowerErrorY, seriesValue.Y, seriesValue.UpperErrorY);
-                            }
-                        }
-                        else
-                        {
-                            foreach (var obj in oxySeries.ItemsSource.Cast<object>())
-                            {
-                                PropertyInfo? propX = obj.GetType().GetProperty(oxySeries.DataFieldX);
-                                string xVal = Convert.ToString(propX?.GetValue(obj, null)) ?? "";
-
-                                PropertyInfo? propY = obj.GetType().GetProperty(oxySeries.DataFieldY);
-                                string yVal = Convert.ToString(propY?.GetValue(obj, null)) ?? "";
-
-                                string xLower = "";
-                                if (wpfSeries.DataFieldLowerErrorX != null)
-                                {
-                                    PropertyInfo? propXlower = obj.GetType().GetProperty(wpfSeries.DataFieldLowerErrorX);
-                                    xLower = Convert.ToString(propXlower?.GetValue(obj, null)) ?? "";
-                                }
-
-                                string xUpper = "";
-                                if (wpfSeries.DataFieldUpperErrorX != null)
-                                {
-                                    PropertyInfo? propXupper = obj.GetType().GetProperty(wpfSeries.DataFieldUpperErrorX);
-                                    xUpper = Convert.ToString(propXupper?.GetValue(obj, null)) ?? "";
-                                }
-
-                                string yLower = "";
-                                if (wpfSeries.DataFieldLowerErrorY != null)
-                                {
-                                    PropertyInfo? propYlower = obj.GetType().GetProperty(wpfSeries.DataFieldLowerErrorY);
-                                    yLower = Convert.ToString(propYlower?.GetValue(obj, null)) ?? "";
-                                }
-
-                                string yUpper = "";
-                                if (wpfSeries.DataFieldUpperErrorY != null)
-                                {
-                                    PropertyInfo? propYupper = obj.GetType().GetProperty(wpfSeries.DataFieldUpperErrorY);
-                                    yUpper = Convert.ToString(propYupper?.GetValue(obj, null)) ?? "";
-                                }
-
-                                dataTable.Rows.Add(dataTable.Rows.Count + 1, xLower, xVal, xUpper, yLower, yVal, yUpper);
-                            }
-                        }
-                    }
-                    else
-                    {
-                        foreach (var seriesValue in oxySeries.Points)
-                        {
-                            dataTable.Rows.Add(dataTable.Rows.Count + 1, seriesValue.LowerErrorX, seriesValue.X, seriesValue.UpperErrorX, seriesValue.LowerErrorY, seriesValue.Y, seriesValue.UpperErrorY);
-                        }
-                    }
-                }
-
-                // Check for item source on a X category axis
-                var xCat = ((OxyPlot.Series.XYAxisSeries)series.InternalSeries).XAxis as OxyPlot.Axes.CategoryAxis;
-                if (xCat != null)
-                {
-                    dataTable.Columns.Add("Xcategory", typeof(string));
-
-                    if (xCat.ItemsSource != null)
-                    {
-                        var xCatList = xCat.ItemsSource as IEnumerable<string>;
-                        if (xCatList != null)
-                        {
-                            for (int i = 0; i < dataTable.Rows.Count; i++)
-                            {
-                                dataTable.Rows[i]["Xcategory"] = xCatList.ElementAt(i);
-                            }
-                        }
-                        else
-                        {
-                            int i = 0;
-                            foreach (var obj in xCat.ItemsSource.Cast<object>())
-                            {
-                                PropertyInfo? propLabel = obj.GetType().GetProperty(xCat.LabelField);
-                                string xVal = Convert.ToString(propLabel?.GetValue(obj, null)) ?? "";
-                                dataTable.Rows[i]["Xcategory"] = xVal;
-                                i++;
-                            }
-                        }
-                    }
-                }
-                else
-                {
-                    // Check for item source on a Y category axis
-                    var yCat = ((OxyPlot.Series.XYAxisSeries)series.InternalSeries).YAxis as OxyPlot.Axes.CategoryAxis;
-                    if (yCat != null)
+                    foreach (var seriesValue in GetScatterErrorExportValues(wpfSeries, oxySeries))
                     {
-                        dataTable.Columns.Add("Ycategory", typeof(string));
-
-                        if (yCat.ItemsSource != null)
-                        {
-                            var yCatList = yCat.ItemsSource as IEnumerable<string>;
-                            if (yCatList != null)
-                            {
-                                for (int i = 0; i < dataTable.Rows.Count; i++)
-                                {
-                                    dataTable.Rows[i]["Ycategory"] = yCatList.ElementAt(i);
-                                }
-                            }
-                            else
-                            {
-                                int i = 0;
-                                foreach (var obj in yCat.ItemsSource.Cast<object>())
-                                {
-                                    PropertyInfo? propLabel = obj.GetType().GetProperty(yCat.LabelField);
-                                    string yVal = Convert.ToString(propLabel?.GetValue(obj, null)) ?? "";
-                                    dataTable.Rows[i]["Ycategory"] = yVal;
-                                    i++;
-                                }
-                            }
-                        }
+                        dataTable.Rows.Add(dataTable.Rows.Count + 1, seriesValue.XLower, seriesValue.X, seriesValue.XUpper, seriesValue.YLower, seriesValue.Y, seriesValue.YUpper);
                     }
                 }
 
                 // Skip contour series for now
                 if (series is Wpf.ContourSeries) continue;
+                if (dataTable.Columns.Count == 0) continue;
+
+                AddCategoryAxisLabels(series.InternalSeries as OxyPlot.Series.XYAxisSeries, dataTable);
 
                 tableList.Add(dataTable);
             }
 
+            return tableList;
+        }
+
+        /// <summary>
+        /// Export series data to file.
+        /// </summary>
+        private void ExportDataButton_Click(object sender, RoutedEventArgs e)
+        {
+            if (Plot == null)
+            {
+                return;
+            }
+
+            ExportDataTablesToFile(BuildExportDataTables(Plot));
+        }
+
+        private void ExportDataTablesToFile(IList<DataTable> tableList)
+        {
             // Show save dialog
             string filters = "comma delimited(*.csv) |*.csv|Excel(*.xlsx) |*.xlsx|Sqlite(*.sqlite) |*.sqlite";
             try
@@ -4149,6 +4085,281 @@ private void ExportDataButton_Click(object sender, RoutedEventArgs e)
             }
         }
 
+        private static IEnumerable<(object X, object Y)> GetDataPointExportValues(Wpf.DataPointSeries wpfSeries, OxyPlot.Series.DataPointSeries oxySeries)
+        {
+            if (oxySeries.ItemsSource == null)
+            {
+                foreach (var point in oxySeries.Points)
+                {
+                    yield return (point.X, point.Y);
+                }
+
+                yield break;
+            }
+
+            foreach (var item in oxySeries.ItemsSource.Cast<object?>())
+            {
+                yield return GetDataPointExportValue(wpfSeries, item);
+            }
+        }
+
+        private static (object X, object Y) GetDataPointExportValue(Wpf.DataPointSeries wpfSeries, object? item)
+        {
+            if (item != null)
+            {
+                if (wpfSeries.Mapping != null)
+                {
+                    var point = wpfSeries.Mapping(item);
+                    return (point.X, point.Y);
+                }
+
+                if (item is DataPoint dataPoint)
+                {
+                    return (dataPoint.X, dataPoint.Y);
+                }
+
+                if (item is IDataPointProvider pointProvider)
+                {
+                    var point = pointProvider.GetDataPoint();
+                    return (point.X, point.Y);
+                }
+            }
+
+            return (
+                GetExportPropertyValue(item, wpfSeries.DataFieldX, "X"),
+                GetExportPropertyValue(item, wpfSeries.DataFieldY, "Y"));
+        }
+
+        private static IEnumerable<(object X, object Y, object X2, object Y2)> GetAreaExportValues(Wpf.AreaSeries wpfSeries, OxyPlot.Series.AreaSeries oxySeries)
+        {
+            if (oxySeries.ItemsSource == null)
+            {
+                for (int i = 0; i < oxySeries.Points.Count; i++)
+                {
+                    if (i < oxySeries.Points2.Count)
+                    {
+                        yield return (oxySeries.Points[i].X, oxySeries.Points[i].Y, oxySeries.Points2[i].X, oxySeries.Points2[i].Y);
+                    }
+                    else
+                    {
+                        yield return (oxySeries.Points[i].X, oxySeries.Points[i].Y, "", "");
+                    }
+                }
+
+                yield break;
+            }
+
+            foreach (var item in oxySeries.ItemsSource.Cast<object?>())
+            {
+                var firstPoint = GetDataPointExportValue(wpfSeries, item);
+                yield return (
+                    firstPoint.X,
+                    firstPoint.Y,
+                    GetExportPropertyValue(item, wpfSeries.DataFieldX2),
+                    GetExportPropertyValue(item, wpfSeries.DataFieldY2));
+            }
+        }
+
+        private static IEnumerable<(object X, object Y)> GetScatterPointExportValues(Wpf.ScatterPointSeries wpfSeries, OxyPlot.Series.ScatterSeries oxySeries)
+        {
+            if (oxySeries.ItemsSource == null)
+            {
+                foreach (var point in oxySeries.Points)
+                {
+                    yield return (point.X, point.Y);
+                }
+
+                yield break;
+            }
+
+            foreach (var item in oxySeries.ItemsSource.Cast<object?>())
+            {
+                yield return GetScatterPointExportValue(wpfSeries, item);
+            }
+        }
+
+        private static (object X, object Y) GetScatterPointExportValue(Wpf.ScatterPointSeries wpfSeries, object? item)
+        {
+            if (item != null)
+            {
+                if (wpfSeries.Mapping != null)
+                {
+                    var point = wpfSeries.Mapping(item);
+                    return (point.X, point.Y);
+                }
+
+                if (item is OxyPlot.Series.ScatterPoint scatterPoint)
+                {
+                    return (scatterPoint.X, scatterPoint.Y);
+                }
+
+                if (item is DataPoint dataPoint)
+                {
+                    return (dataPoint.X, dataPoint.Y);
+                }
+
+                if (item is OxyPlot.Series.IScatterPointProvider scatterPointProvider)
+                {
+                    var point = scatterPointProvider.GetScatterPoint();
+                    return (point.X, point.Y);
+                }
+            }
+
+            return (
+                GetExportPropertyValue(item, wpfSeries.DataFieldX, "X"),
+                GetExportPropertyValue(item, wpfSeries.DataFieldY, "Y"));
+        }
+
+        private static IEnumerable<(object XLower, object X, object XUpper, object YLower, object Y, object YUpper)> GetScatterErrorExportValues(Wpf.ScatterErrorSeries wpfSeries, OxyPlot.Series.ScatterErrorSeries oxySeries)
+        {
+            if (oxySeries.ItemsSource == null)
+            {
+                foreach (var point in oxySeries.Points)
+                {
+                    yield return GetScatterErrorPointExportValue(point);
+                }
+
+                yield break;
+            }
+
+            foreach (var item in oxySeries.ItemsSource.Cast<object?>())
+            {
+                if (item != null && wpfSeries.Mapping != null)
+                {
+                    yield return GetScatterErrorPointExportValue(wpfSeries.Mapping(item));
+                }
+                else if (item is OxyPlot.Series.ScatterErrorPoint scatterErrorPoint)
+                {
+                    yield return GetScatterErrorPointExportValue(scatterErrorPoint);
+                }
+                else
+                {
+                    yield return (
+                        GetExportPropertyValue(item, wpfSeries.DataFieldLowerErrorX),
+                        GetExportPropertyValue(item, wpfSeries.DataFieldX, "X"),
+                        GetExportPropertyValue(item, wpfSeries.DataFieldUpperErrorX),
+                        GetExportPropertyValue(item, wpfSeries.DataFieldLowerErrorY),
+                        GetExportPropertyValue(item, wpfSeries.DataFieldY, "Y"),
+                        GetExportPropertyValue(item, wpfSeries.DataFieldUpperErrorY));
+                }
+            }
+        }
+
+        private static (object XLower, object X, object XUpper, object YLower, object Y, object YUpper) GetScatterErrorPointExportValue(OxyPlot.Series.ScatterErrorPoint point)
+        {
+            return (point.LowerErrorX, point.X, point.UpperErrorX, point.LowerErrorY, point.Y, point.UpperErrorY);
+        }
+
+        private static void AddCategoryAxisLabels(OxyPlot.Series.XYAxisSeries? series, DataTable dataTable)
+        {
+            if (series?.XAxis is OxyPlot.Axes.CategoryAxis xCategoryAxis)
+            {
+                AddCategoryAxisLabelColumn(xCategoryAxis, dataTable, "Xcategory");
+            }
+            else if (series?.YAxis is OxyPlot.Axes.CategoryAxis yCategoryAxis)
+            {
+                AddCategoryAxisLabelColumn(yCategoryAxis, dataTable, "Ycategory");
+            }
+        }
+
+        private static void AddCategoryAxisLabelColumn(OxyPlot.Axes.CategoryAxis categoryAxis, DataTable dataTable, string columnName)
+        {
+            dataTable.Columns.Add(columnName, typeof(string));
+            if (categoryAxis.ItemsSource == null)
+            {
+                return;
+            }
+
+            if (categoryAxis.ItemsSource is IEnumerable<string> labels)
+            {
+                int i = 0;
+                foreach (var label in labels.Take(dataTable.Rows.Count))
+                {
+                    dataTable.Rows[i][columnName] = label;
+                    i++;
+                }
+
+                return;
+            }
+
+            int rowIndex = 0;
+            foreach (var item in categoryAxis.ItemsSource.Cast<object?>().Take(dataTable.Rows.Count))
+            {
+                dataTable.Rows[rowIndex][columnName] = GetPropertyValueOrEmpty(item, categoryAxis.LabelField);
+                rowIndex++;
+            }
+        }
+
+        private static string GetExportPropertyValue(object? source, string? propertyName, string? fallbackPropertyName = null)
+        {
+            if (!string.IsNullOrWhiteSpace(propertyName))
+            {
+                return GetPropertyValueOrEmpty(source, propertyName);
+            }
+
+            return !string.IsNullOrWhiteSpace(fallbackPropertyName)
+                ? GetPropertyValueOrEmpty(source, fallbackPropertyName)
+                : "";
+        }
+
+        private static string GetPropertyValueOrEmpty(object? source, string? propertyName)
+        {
+            if (source == null || string.IsNullOrWhiteSpace(propertyName))
+            {
+                return "";
+            }
+
+            if (TryGetPropertyValue(source, propertyName, out var value))
+            {
+                return Convert.ToString(value) ?? "";
+            }
+
+            return "";
+        }
+
+        private static bool TryGetPropertyValue(object source, string propertyName, out object? value)
+        {
+            if (source is DataRow row && row.Table.Columns.Contains(propertyName))
+            {
+                value = row[propertyName];
+                return true;
+            }
+
+            if (source is DataRowView rowView && rowView.DataView.Table?.Columns.Contains(propertyName) == true)
+            {
+                value = rowView[propertyName];
+                return true;
+            }
+
+            if (source is IDictionary<string, object?> genericDictionary && genericDictionary.TryGetValue(propertyName, out value))
+            {
+                return true;
+            }
+
+            if (source is System.Collections.IDictionary dictionary && dictionary.Contains(propertyName))
+            {
+                value = dictionary[propertyName];
+                return true;
+            }
+
+            var property = source.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public);
+            if (property != null)
+            {
+                value = property.GetValue(source, null);
+                return true;
+            }
+
+            var descriptor = System.ComponentModel.TypeDescriptor.GetProperties(source).Find(propertyName, false);
+            if (descriptor != null)
+            {
+                value = descriptor.GetValue(source);
+                return true;
+            }
+
+            value = null;
+            return false;
+        }
+
         /// <summary>
         /// Merge all data tables by a primary key column.
         /// </summary>
diff --git a/tests/OxyPlot.Tests/TextAnnotationTests.cs b/tests/OxyPlot.Tests/TextAnnotationTests.cs
new file mode 100644
index 00000000..b6d392a4
--- /dev/null
+++ b/tests/OxyPlot.Tests/TextAnnotationTests.cs
@@ -0,0 +1,162 @@
+namespace OxyPlot.Tests
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using NUnit.Framework;
+    using OxyPlot.Annotations;
+    using OxyPlot.Axes;
+
+    [TestFixture]
+    public class TextAnnotationTests
+    {
+        [Test]
+        public void Render_DefinedTextPosition_RecomputesAnchorWhenPlotWidthChanges()
+        {
+            var annotation = new TextAnnotation
+            {
+                Text = "anchored",
+                TextPosition = new DataPoint(5, 5),
+                TextHorizontalAlignment = HorizontalAlignment.Left,
+                TextVerticalAlignment = VerticalAlignment.Top,
+                Padding = new OxyThickness(0),
+                StrokeThickness = 0
+            };
+            var model = CreateModel(annotation);
+
+            var small = RenderAndGetText(model, "anchored", 400, 300);
+            var smallExpected = new ScreenPoint(model.DefaultXAxis.Transform(5), model.DefaultYAxis.Transform(5));
+
+            var wide = RenderAndGetText(model, "anchored", 800, 300);
+            var wideExpected = new ScreenPoint(model.DefaultXAxis.Transform(5), model.DefaultYAxis.Transform(5));
+
+            Assert.That(small.Point.X, Is.EqualTo(smallExpected.X).Within(1e-6));
+            Assert.That(small.Point.Y, Is.EqualTo(smallExpected.Y).Within(1e-6));
+            Assert.That(wide.Point.X, Is.EqualTo(wideExpected.X).Within(1e-6));
+            Assert.That(wide.Point.Y, Is.EqualTo(wideExpected.Y).Within(1e-6));
+            Assert.That(wide.Point.X, Is.GreaterThan(small.Point.X));
+        }
+
+        [Test]
+        public void Render_UndefinedTextPosition_FallsBackToPlotAreaCenter()
+        {
+            var annotation = new TextAnnotation
+            {
+                Text = "centered",
+                TextHorizontalAlignment = HorizontalAlignment.Left,
+                TextVerticalAlignment = VerticalAlignment.Top,
+                Padding = new OxyThickness(0),
+                StrokeThickness = 0
+            };
+            var model = CreateModel(annotation);
+
+            var small = RenderAndGetText(model, "centered", 400, 300);
+            var smallExpected = model.PlotArea.Center;
+
+            var wide = RenderAndGetText(model, "centered", 800, 300);
+            var wideExpected = model.PlotArea.Center;
+
+            Assert.That(double.IsNaN(small.Point.X), Is.False);
+            Assert.That(double.IsNaN(small.Point.Y), Is.False);
+            Assert.That(small.Point.X, Is.EqualTo(smallExpected.X).Within(1e-6));
+            Assert.That(small.Point.Y, Is.EqualTo(smallExpected.Y).Within(1e-6));
+            Assert.That(wide.Point.X, Is.EqualTo(wideExpected.X).Within(1e-6));
+            Assert.That(wide.Point.Y, Is.EqualTo(wideExpected.Y).Within(1e-6));
+            Assert.That(wide.Point.X, Is.GreaterThan(small.Point.X));
+        }
+
+        [Test]
+        public void Render_DefinedTextPosition_MatchesArrowAnnotationTextAnchor()
+        {
+            var textAnnotation = new TextAnnotation
+            {
+                Text = "box",
+                TextPosition = new DataPoint(3, 7),
+                TextHorizontalAlignment = HorizontalAlignment.Left,
+                TextVerticalAlignment = VerticalAlignment.Top,
+                Padding = new OxyThickness(0),
+                StrokeThickness = 0
+            };
+            var arrowAnnotation = new ArrowAnnotation
+            {
+                Text = "arrow",
+                TextPosition = new DataPoint(3, 7),
+                StartPoint = new DataPoint(1, 1),
+                EndPoint = new DataPoint(2, 2),
+                TextHorizontalAlignment = HorizontalAlignment.Left,
+                TextVerticalAlignment = VerticalAlignment.Top
+            };
+            var model = CreateModel(textAnnotation, arrowAnnotation);
+
+            var rc = Render(model, 500, 300);
+            var text = rc.DrawnTexts.Single(t => t.Text == "box");
+            var arrow = rc.DrawnTexts.Single(t => t.Text == "arrow");
+
+            Assert.That(text.Point.X, Is.EqualTo(arrow.Point.X).Within(1e-6));
+            Assert.That(text.Point.Y, Is.EqualTo(arrow.Point.Y).Within(1e-6));
+        }
+
+        private static PlotModel CreateModel(params Annotation[] annotations)
+        {
+            var model = new PlotModel
+            {
+                PlotMargins = new OxyThickness(40, 20, 20, 30),
+                PlotAreaBorderThickness = new OxyThickness(0)
+            };
+            model.Axes.Add(new LinearAxis { Position = AxisPosition.Bottom, Minimum = 0, Maximum = 10, IsAxisVisible = false });
+            model.Axes.Add(new LinearAxis { Position = AxisPosition.Left, Minimum = 0, Maximum = 10, IsAxisVisible = false });
+
+            foreach (var annotation in annotations)
+            {
+                model.Annotations.Add(annotation);
+            }
+
+            return model;
+        }
+
+        private static TextDraw RenderAndGetText(PlotModel model, string text, double width, double height)
+        {
+            return Render(model, width, height).DrawnTexts.Single(t => t.Text == text);
+        }
+
+        private static RecordingRenderContext Render(PlotModel model, double width, double height)
+        {
+            var rc = new RecordingRenderContext();
+            ((IPlotModel)model).Update(true);
+            ((IPlotModel)model).Render(rc, new OxyRect(0, 0, width, height));
+            return rc;
+        }
+
+        private sealed class RecordingRenderContext : NullRenderContext
+        {
+            public List<TextDraw> DrawnTexts { get; } = new List<TextDraw>();
+
+            public override void DrawText(
+                ScreenPoint p,
+                string text,
+                OxyColor fill,
+                string fontFamily,
+                double fontSize,
+                double fontWeight,
+                double rotate,
+                HorizontalAlignment halign,
+                VerticalAlignment valign,
+                OxySize? maxSize)
+            {
+                this.DrawnTexts.Add(new TextDraw(text, p));
+            }
+        }
+
+        private sealed class TextDraw
+        {
+            public TextDraw(string text, ScreenPoint point)
+            {
+                this.Text = text;
+                this.Point = point;
+            }
+
+            public string Text { get; }
+
+            public ScreenPoint Point { get; }
+        }
+    }
+}
diff --git a/tests/OxyPlot.Wpf.Tests/TextAnnotationExporterTests.cs b/tests/OxyPlot.Wpf.Tests/TextAnnotationExporterTests.cs
new file mode 100644
index 00000000..94efd6b0
--- /dev/null
+++ b/tests/OxyPlot.Wpf.Tests/TextAnnotationExporterTests.cs
@@ -0,0 +1,154 @@
+namespace OxyPlot.Wpf.Tests
+{
+    using System;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using System.Xml.Linq;
+    using NUnit.Framework;
+    using OxyPlot.Annotations;
+    using OxyPlot.Axes;
+
+    [TestFixture]
+    public class TextAnnotationExporterTests
+    {
+        private static readonly OxyColor UniqueTextColor = OxyColor.FromRgb(0x12, 0x34, 0x56);
+
+        [Test]
+        public void WpfSvgExporter_TextAnnotationAnchor_ChangesWithExportWidth()
+        {
+            var model = CreateModel(new DataPoint(5, 5));
+
+            var small = ExportSvgAndReadTextTranslate(model, 400, 300);
+            var smallExpected = new ScreenPoint(model.DefaultXAxis.Transform(5), model.DefaultYAxis.Transform(5));
+
+            var wide = ExportSvgAndReadTextTranslate(model, 800, 300);
+            var wideExpected = new ScreenPoint(model.DefaultXAxis.Transform(5), model.DefaultYAxis.Transform(5));
+
+            Assert.That(small.X, Is.EqualTo(smallExpected.X).Within(1e-3));
+            Assert.That(small.Y, Is.EqualTo(smallExpected.Y).Within(1e-3));
+            Assert.That(wide.X, Is.EqualTo(wideExpected.X).Within(1e-3));
+            Assert.That(wide.Y, Is.EqualTo(wideExpected.Y).Within(1e-3));
+            Assert.That(wide.X, Is.GreaterThan(small.X));
+        }
+
+        [Test]
+        public void WpfPdfExporter_TextAnnotationAnchor_ChangesWithExportWidth()
+        {
+            var model = CreateModel(new DataPoint(5, 5));
+
+            var small = ExportPdfAndReadTextAnchor(model, 400, 300);
+            var smallExpected = ToPdfPoint(new ScreenPoint(model.DefaultXAxis.Transform(5), model.DefaultYAxis.Transform(5)), 300);
+
+            var wide = ExportPdfAndReadTextAnchor(model, 800, 300);
+            var wideExpected = ToPdfPoint(new ScreenPoint(model.DefaultXAxis.Transform(5), model.DefaultYAxis.Transform(5)), 300);
+
+            Assert.That(small.X, Is.EqualTo(smallExpected.X).Within(1e-3));
+            Assert.That(small.Y, Is.EqualTo(smallExpected.Y).Within(1e-3));
+            Assert.That(wide.X, Is.EqualTo(wideExpected.X).Within(1e-3));
+            Assert.That(wide.Y, Is.EqualTo(wideExpected.Y).Within(1e-3));
+            Assert.That(wide.X, Is.GreaterThan(small.X));
+        }
+
+        [Test]
+        public void PngExporter_TextAnnotationWithUndefinedPosition_Exports()
+        {
+            var model = CreateModel(DataPoint.Undefined);
+            var exporter = new PngExporter { Width = 400, Height = 300, Background = OxyColors.White };
+
+            using (var stream = new MemoryStream())
+            {
+                exporter.Export(model, stream);
+
+                Assert.That(stream.Length, Is.GreaterThan(0));
+                Assert.That(double.IsNaN(model.PlotArea.Center.X), Is.False);
+                Assert.That(double.IsNaN(model.PlotArea.Center.Y), Is.False);
+            }
+        }
+
+        private static PlotModel CreateModel(DataPoint textPosition)
+        {
+            var model = new PlotModel
+            {
+                Background = OxyColors.White,
+                PlotMargins = new OxyThickness(40, 20, 20, 30),
+                PlotAreaBorderThickness = new OxyThickness(0)
+            };
+            model.Axes.Add(new LinearAxis { Position = AxisPosition.Bottom, Minimum = 0, Maximum = 10, IsAxisVisible = false });
+            model.Axes.Add(new LinearAxis { Position = AxisPosition.Left, Minimum = 0, Maximum = 10, IsAxisVisible = false });
+            model.Annotations.Add(new TextAnnotation
+            {
+                Text = "Anchor",
+                TextColor = UniqueTextColor,
+                TextPosition = textPosition,
+                TextHorizontalAlignment = HorizontalAlignment.Left,
+                TextVerticalAlignment = VerticalAlignment.Top,
+                Padding = new OxyThickness(0),
+                StrokeThickness = 0
+            });
+
+            return model;
+        }
+
+        private static ScreenPoint ExportSvgAndReadTextTranslate(PlotModel model, int width, int height)
+        {
+            using (var stream = new MemoryStream())
+            {
+                WpfSvgExporter.Export(model, stream, width, height, true);
+                stream.Position = 0;
+                var document = XDocument.Load(stream);
+                var transforms = document.Descendants()
+                    .Where(e => e.Name.LocalName == "path")
+                    .Where(e => string.Equals((string)e.Attribute("fill"), "rgb(18,52,86)", StringComparison.OrdinalIgnoreCase))
+                    .Select(e => (string)e.Attribute("transform"))
+                    .Where(t => t != null)
+                    .ToArray();
+
+                Assert.That(transforms.Length, Is.EqualTo(1));
+                return ParseTranslate(transforms[0]);
+            }
+        }
+
+        private static ScreenPoint ExportPdfAndReadTextAnchor(PlotModel model, int width, int height)
+        {
+            using (var stream = new MemoryStream())
+            {
+                WpfPdfExporter.Export(model, stream, width, height);
+                var pdf = Encoding.ASCII.GetString(stream.ToArray());
+                var colorIndex = pdf.IndexOf("0.0706 0.2039 0.3373 rg", StringComparison.Ordinal);
+
+                Assert.That(colorIndex, Is.GreaterThanOrEqualTo(0));
+
+                var match = Regex.Match(
+                    pdf.Substring(colorIndex),
+                    @"1 0 0 1 (?<x>[-+0-9.]+) (?<y>[-+0-9.]+) cm");
+
+                Assert.That(match.Success, Is.True);
+                return new ScreenPoint(ParseInvariant(match.Groups["x"].Value), ParseInvariant(match.Groups["y"].Value));
+            }
+        }
+
+        private static ScreenPoint ParseTranslate(string transform)
+        {
+            var match = Regex.Match(
+                transform,
+                @"translate\((?<x>[-+0-9.Ee]+),(?<y>[-+0-9.Ee]+)\)");
+
+            Assert.That(match.Success, Is.True);
+            return new ScreenPoint(ParseInvariant(match.Groups["x"].Value), ParseInvariant(match.Groups["y"].Value));
+        }
+
+        private static ScreenPoint ToPdfPoint(ScreenPoint point, double height)
+        {
+            const double DipToPoints = 72.0 / 96.0;
+            return new ScreenPoint(point.X * DipToPoints, (height - point.Y) * DipToPoints);
+        }
+
+        private static double ParseInvariant(string value)
+        {
+            return double.Parse(value, CultureInfo.InvariantCulture);
+        }
+    }
+}
diff --git a/tests/OxyPlot.Wpf.Tests/WpfPdfRenderContextTests.cs b/tests/OxyPlot.Wpf.Tests/WpfPdfRenderContextTests.cs
new file mode 100644
index 00000000..d3d7bfc8
--- /dev/null
+++ b/tests/OxyPlot.Wpf.Tests/WpfPdfRenderContextTests.cs
@@ -0,0 +1,133 @@
+namespace OxyPlot.Wpf.Tests
+{
+    using System.IO;
+    using System.Text;
+
+    using NUnit.Framework;
+    using OxyPlot.Legends;
+    using OxyPlot.Series;
+
+    [TestFixture]
+    public class WpfPdfRenderContextTests
+    {
+        [Test]
+        public void DrawLine_ConvertsCoordinatesAndDashPatternFromDipToPoints()
+        {
+            var rc = new WpfPdfRenderContext(300, 270, OxyColors.White);
+
+            rc.DrawLine(
+                new[] { new ScreenPoint(10, 20), new ScreenPoint(30, 40) },
+                OxyColors.Blue,
+                2,
+                EdgeRenderingMode.PreferGeometricAccuracy,
+                new[] { 4d, 1d },
+                LineJoin.Bevel);
+
+            var pdf = SaveToString(rc);
+
+            Assert.That(pdf, Does.Contain("1.5 w"));
+            Assert.That(pdf, Does.Contain("[6 1.5]0 d"));
+            Assert.That(pdf, Does.Contain("2 j"));
+            Assert.That(pdf, Does.Contain("7.5 255 m"));
+            Assert.That(pdf, Does.Contain("22.5 240 l"));
+        }
+
+        [Test]
+        public void DrawRectangle_ConvertsMarkerSizedGeometryFromDipToPoints()
+        {
+            var rc = new WpfPdfRenderContext(300, 270, OxyColors.White);
+
+            rc.DrawRectangle(
+                new OxyRect(10, 20, 8, 6),
+                OxyColors.Red,
+                OxyColors.Black,
+                1,
+                EdgeRenderingMode.PreferGeometricAccuracy);
+
+            var pdf = SaveToString(rc);
+
+            Assert.That(pdf, Does.Contain("0.75 w"));
+            Assert.That(pdf, Does.Contain("7.5 250.5 6 4.5 re"));
+        }
+
+        [Test]
+        public void MeasureText_ReturnsWpfDipSizeForPlotLayout()
+        {
+            var rc = new WpfPdfRenderContext(300, 270, OxyColors.White);
+
+            var expected = TextToGeometryHelper.MeasureText("Expected Probability", "Segoe UI", 12, 400);
+            var actual = rc.MeasureText("Expected Probability", "Segoe UI", 12, 400);
+
+            Assert.That(actual.Width, Is.EqualTo(expected.Width).Within(1e-6));
+            Assert.That(actual.Height, Is.EqualTo(expected.Height).Within(1e-6));
+        }
+
+        [Test]
+        public void Export_DashedLineSeriesLegend_UsesStrokeRelativeDashPattern()
+        {
+            var model = new PlotModel { Background = OxyColors.White };
+            model.Legends.Add(new Legend { LegendPosition = LegendPosition.LeftTop });
+            var series = new LineSeries
+            {
+                Title = "Expected Probability",
+                Color = OxyColors.Blue,
+                LineStyle = LineStyle.Dash,
+                StrokeThickness = 2,
+                MarkerType = MarkerType.None
+            };
+            series.Points.Add(new DataPoint(0, 0));
+            series.Points.Add(new DataPoint(1, 1));
+            model.Series.Add(series);
+
+            using (var stream = new MemoryStream())
+            {
+                WpfPdfExporter.Export(model, stream, 600, 480);
+                var pdf = Encoding.ASCII.GetString(stream.ToArray());
+
+                Assert.That(CountOccurrences(pdf, "[6 1.5]0 d"), Is.GreaterThanOrEqualTo(2));
+                Assert.That(pdf, Does.Not.Contain("[3 0.75]0 d"));
+            }
+        }
+
+        [Test]
+        public void PushClip_EmitsScaledPdfClipRectangle()
+        {
+            var rc = new WpfPdfRenderContext(300, 270, OxyColors.White);
+
+            rc.PushClip(new OxyRect(10, 20, 100, 50));
+            rc.DrawRectangle(
+                new OxyRect(0, 0, 200, 200),
+                OxyColors.Red,
+                OxyColors.Undefined,
+                0,
+                EdgeRenderingMode.PreferGeometricAccuracy);
+            rc.PopClip();
+
+            var pdf = SaveToString(rc);
+
+            Assert.That(pdf, Does.Contain("7.5 217.5 75 37.5 re W n"));
+        }
+
+        private static string SaveToString(WpfPdfRenderContext rc)
+        {
+            using (var stream = new MemoryStream())
+            {
+                rc.Save(stream);
+                return Encoding.ASCII.GetString(stream.ToArray());
+            }
+        }
+
+        private static int CountOccurrences(string text, string value)
+        {
+            int count = 0;
+            int index = 0;
+            while ((index = text.IndexOf(value, index, System.StringComparison.Ordinal)) >= 0)
+            {
+                count++;
+                index += value.Length;
+            }
+
+            return count;
+        }
+    }
+}
diff --git a/tests/OxyPlotControls.Tests/OxyPlotToolbarAnnotationAxisBehaviorTests.cs b/tests/OxyPlotControls.Tests/OxyPlotToolbarAnnotationAxisBehaviorTests.cs
new file mode 100644
index 00000000..43e309e8
--- /dev/null
+++ b/tests/OxyPlotControls.Tests/OxyPlotToolbarAnnotationAxisBehaviorTests.cs
@@ -0,0 +1,418 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Windows;
+using OxyPlot;
+using OxyPlot.Annotations;
+using OxyPlot.Axes;
+using Xunit;
+using Wpf = OxyPlot.Wpf;
+
+namespace OxyPlotControls.Tests;
+
+public class OxyPlotToolbarAnnotationAxisBehaviorTests
+{
+    private const double RenderWidth = 400;
+    private const double RenderHeight = 300;
+
+    [StaTheory]
+    [InlineData("AddRectangleAnnotationItem_Click")]
+    [InlineData("AddEllipseAnnotationItem_Click")]
+    public void TinyRectangleAndEllipsePlacement_OnLogLogAxes_CreatesValidVisibleBounds(string addMethodName)
+    {
+        var plot = CreateLogLogPlot();
+        var toolbar = CreateToolbar(plot);
+        RenderPlot(plot);
+
+        InvokePrivate(toolbar, addMethodName, toolbar, new RoutedEventArgs());
+        var clickPosition = plot.ActualModel.PlotArea.Center;
+
+        InvokePrivate(toolbar, "PlotModelMouseDown", plot.ActualModel, NewMouseDown(clickPosition));
+        InvokePrivate(toolbar, "PlotModelMouseUp", plot.ActualModel, new OxyMouseEventArgs { Position = clickPosition });
+
+        var annotation = Assert.Single(plot.Annotations);
+        AssertShapeBoundsAreValidAndVisible(annotation);
+    }
+
+    [StaTheory]
+    [InlineData("LogLog", "AddArrowAnnotationItem_Click")]
+    [InlineData("LogLog", "AddTextAnnotationItem_Click")]
+    [InlineData("DateTime", "AddArrowAnnotationItem_Click")]
+    [InlineData("DateTime", "AddTextAnnotationItem_Click")]
+    [InlineData("Reversed", "AddArrowAnnotationItem_Click")]
+    [InlineData("Reversed", "AddTextAnnotationItem_Click")]
+    public void ArrowAndTextPlacement_CreatesValidCoordinatesAcrossAxisTypes(string axisKind, string addMethodName)
+    {
+        var plot = CreatePlot(axisKind);
+        var toolbar = CreateToolbar(plot);
+        RenderPlot(plot);
+
+        InvokePrivate(toolbar, addMethodName, toolbar, new RoutedEventArgs());
+        var startPosition = plot.ActualModel.PlotArea.Center;
+        var endPosition = new ScreenPoint(startPosition.X + 18, startPosition.Y - 12);
+
+        InvokePrivate(toolbar, "PlotModelMouseDown", plot.ActualModel, NewMouseDown(startPosition));
+        InvokePrivate(toolbar, "PlotModelMouseMove", plot.ActualModel, new OxyMouseEventArgs { Position = endPosition });
+        InvokePrivate(toolbar, "PlotModelMouseUp", plot.ActualModel, new OxyMouseEventArgs { Position = endPosition });
+
+        var annotation = Assert.Single(plot.Annotations);
+        if (annotation is Wpf.ArrowAnnotation arrow)
+        {
+            AssertValidPoint(arrow.InternalAnnotation.XAxis!, arrow.InternalAnnotation.YAxis!, arrow.StartPoint);
+            AssertValidPoint(arrow.InternalAnnotation.XAxis!, arrow.InternalAnnotation.YAxis!, arrow.EndPoint);
+        }
+        else
+        {
+            var text = Assert.IsType<Wpf.TextAnnotation>(annotation);
+            AssertValidPoint(text.InternalAnnotation.XAxis!, text.InternalAnnotation.YAxis!, text.TextPosition);
+        }
+    }
+
+    [StaTheory]
+    [InlineData("LogLog")]
+    [InlineData("DateTime")]
+    [InlineData("Reversed")]
+    public void PointAnnotationDrag_FollowsScreenDeltaAcrossAxisTypes(string axisKind)
+    {
+        var plot = CreatePlot(axisKind);
+        var initialPoint = GetInitialPoint(axisKind);
+        var point = new Wpf.PointAnnotation
+        {
+            Text = "Point",
+            X = initialPoint.X,
+            Y = initialPoint.Y
+        };
+        plot.Annotations.Add(point);
+
+        _ = CreateToolbar(plot);
+        RenderPlot(plot);
+
+        var startScreenPoint = point.InternalAnnotation.Transform(new DataPoint(point.X, point.Y));
+        var endScreenPoint = new ScreenPoint(startScreenPoint.X + 24, startScreenPoint.Y - 17);
+
+        InvokeMouseDown(point.InternalAnnotation, startScreenPoint, 0);
+        InvokeMouseMove(point.InternalAnnotation, endScreenPoint);
+        InvokeMouseUp(point.InternalAnnotation, endScreenPoint);
+
+        AssertValidPoint(point.InternalAnnotation.XAxis!, point.InternalAnnotation.YAxis!, new DataPoint(point.X, point.Y));
+        var movedScreenPoint = point.InternalAnnotation.Transform(new DataPoint(point.X, point.Y));
+        Assert.Equal(endScreenPoint.X, movedScreenPoint.X, 1);
+        Assert.Equal(endScreenPoint.Y, movedScreenPoint.Y, 1);
+    }
+
+    [StaTheory]
+    [InlineData("LogLog", LineAnnotationType.Vertical)]
+    [InlineData("DateTime", LineAnnotationType.Horizontal)]
+    [InlineData("Reversed", LineAnnotationType.Vertical)]
+    public void LineAnnotationDrag_FollowsMouseAcrossAxisTypes(string axisKind, LineAnnotationType lineType)
+    {
+        var plot = CreatePlot(axisKind);
+        var initialPoint = GetInitialPoint(axisKind);
+        var line = new Wpf.LineAnnotation
+        {
+            Text = "Line",
+            Type = lineType,
+            X = initialPoint.X,
+            Y = initialPoint.Y
+        };
+        plot.Annotations.Add(line);
+
+        _ = CreateToolbar(plot);
+        RenderPlot(plot);
+
+        var startScreenPoint = line.InternalAnnotation.Transform(new DataPoint(line.X, line.Y));
+        var endScreenPoint = new ScreenPoint(startScreenPoint.X + 19, startScreenPoint.Y + 13);
+
+        InvokeMouseDown(line.InternalAnnotation, startScreenPoint, 0);
+        InvokeMouseMove(line.InternalAnnotation, endScreenPoint);
+        InvokeMouseUp(line.InternalAnnotation, endScreenPoint);
+
+        AssertValidPoint(line.InternalAnnotation.XAxis!, line.InternalAnnotation.YAxis!, new DataPoint(line.X, line.Y));
+        var movedScreenPoint = line.InternalAnnotation.Transform(new DataPoint(line.X, line.Y));
+        Assert.Equal(endScreenPoint.X, movedScreenPoint.X, 1);
+        Assert.Equal(endScreenPoint.Y, movedScreenPoint.Y, 1);
+    }
+
+    [StaTheory]
+    [InlineData("Polygon")]
+    [InlineData("Polyline")]
+    public void PolygonAndPolylineVertexDrag_UsesScreenToleranceOnLogLogAxes(string annotationKind)
+    {
+        var plot = CreateLogLogPlot();
+        Wpf.Annotation annotation = annotationKind == "Polygon"
+            ? new Wpf.PolygonAnnotation
+            {
+                Points = new List<DataPoint>
+                {
+                    new(10, 10),
+                    new(100, 10),
+                    new(100, 100)
+                }
+            }
+            : new Wpf.PolylineAnnotation
+            {
+                Points = new List<DataPoint>
+                {
+                    new(10, 10),
+                    new(100, 10),
+                    new(100, 100)
+                }
+            };
+
+        plot.Annotations.Add(annotation);
+        _ = CreateToolbar(plot);
+        RenderPlot(plot);
+
+        var points = GetPoints(annotation);
+        var originalVertexScreenPoint = annotation.InternalAnnotation.Transform(points[0]);
+        var mouseDownPoint = new ScreenPoint(originalVertexScreenPoint.X + 6, originalVertexScreenPoint.Y + 4);
+        var mouseMovePoint = new ScreenPoint(mouseDownPoint.X + 21, mouseDownPoint.Y - 11);
+
+        InvokeMouseDown(annotation.InternalAnnotation, mouseDownPoint, 0);
+        InvokeMouseMove(annotation.InternalAnnotation, mouseMovePoint);
+        InvokeMouseUp(annotation.InternalAnnotation, mouseMovePoint);
+
+        var movedVertexScreenPoint = annotation.InternalAnnotation.Transform(GetPoints(annotation)[0]);
+        Assert.Equal(originalVertexScreenPoint.X + 21, movedVertexScreenPoint.X, 1);
+        Assert.Equal(originalVertexScreenPoint.Y - 11, movedVertexScreenPoint.Y, 1);
+    }
+
+    [StaFact]
+    public void PointPlacement_OnCategoryAxis_CreatesFiniteCoordinates()
+    {
+        var plot = new Wpf.Plot();
+        plot.Axes.Add(new Wpf.CategoryAxis
+        {
+            Position = AxisPosition.Bottom,
+            Minimum = -0.5,
+            Maximum = 2.5,
+            Labels = new List<string> { "A", "B", "C" }
+        });
+        plot.Axes.Add(new Wpf.LinearAxis
+        {
+            Position = AxisPosition.Left,
+            Minimum = 0,
+            Maximum = 100
+        });
+
+        var toolbar = CreateToolbar(plot);
+        RenderPlot(plot);
+
+        InvokePrivate(toolbar, "AddPointAnnotationItem_Click", toolbar, new RoutedEventArgs());
+        var clickPosition = plot.ActualModel.PlotArea.Center;
+
+        InvokePrivate(toolbar, "PlotModelMouseDown", plot.ActualModel, NewMouseDown(clickPosition));
+
+        var point = Assert.IsType<Wpf.PointAnnotation>(Assert.Single(plot.Annotations));
+        AssertValidPoint(point.InternalAnnotation.XAxis!, point.InternalAnnotation.YAxis!, new DataPoint(point.X, point.Y));
+    }
+
+    private static Wpf.Plot CreatePlot(string axisKind)
+    {
+        return axisKind switch
+        {
+            "LogLog" => CreateLogLogPlot(),
+            "DateTime" => CreateDateTimePlot(),
+            "Reversed" => CreateReversedPlot(),
+            _ => throw new ArgumentOutOfRangeException(nameof(axisKind), axisKind, null)
+        };
+    }
+
+    private static Wpf.Plot CreateLogLogPlot()
+    {
+        var plot = new Wpf.Plot();
+        plot.Axes.Add(new Wpf.LogarithmicAxis
+        {
+            Position = AxisPosition.Bottom,
+            Minimum = 1,
+            Maximum = 1000
+        });
+        plot.Axes.Add(new Wpf.LogarithmicAxis
+        {
+            Position = AxisPosition.Left,
+            Minimum = 1,
+            Maximum = 1000
+        });
+        return plot;
+    }
+
+    private static Wpf.Plot CreateDateTimePlot()
+    {
+        var plot = new Wpf.Plot();
+        plot.Axes.Add(new Wpf.DateTimeAxis
+        {
+            Position = AxisPosition.Bottom,
+            Minimum = OxyPlot.Axes.DateTimeAxis.ToDouble(new DateTime(2026, 1, 1)),
+            Maximum = OxyPlot.Axes.DateTimeAxis.ToDouble(new DateTime(2026, 2, 1))
+        });
+        plot.Axes.Add(new Wpf.LinearAxis
+        {
+            Position = AxisPosition.Left,
+            Minimum = 0,
+            Maximum = 100
+        });
+        return plot;
+    }
+
+    private static Wpf.Plot CreateReversedPlot()
+    {
+        var plot = new Wpf.Plot();
+        plot.Axes.Add(new Wpf.LinearAxis
+        {
+            Position = AxisPosition.Bottom,
+            Minimum = 0,
+            Maximum = 100,
+            StartPosition = 1,
+            EndPosition = 0
+        });
+        plot.Axes.Add(new Wpf.LinearAxis
+        {
+            Position = AxisPosition.Left,
+            Minimum = 0,
+            Maximum = 100,
+            StartPosition = 1,
+            EndPosition = 0
+        });
+        return plot;
+    }
+
+    private static DataPoint GetInitialPoint(string axisKind)
+    {
+        return axisKind switch
+        {
+            "LogLog" => new DataPoint(10, 10),
+            "DateTime" => new DataPoint(OxyPlot.Axes.DateTimeAxis.ToDouble(new DateTime(2026, 1, 15)), 50),
+            "Reversed" => new DataPoint(40, 40),
+            _ => throw new ArgumentOutOfRangeException(nameof(axisKind), axisKind, null)
+        };
+    }
+
+    private static OxyPlotToolbar CreateToolbar(Wpf.Plot plot)
+    {
+        SetPlotGrid(plot);
+        var toolbar = new OxyPlotToolbar { Plot = plot };
+        RenderPlot(plot);
+        return toolbar;
+    }
+
+    private static void AssertShapeBoundsAreValidAndVisible(Wpf.Annotation annotation)
+    {
+        double minimumX;
+        double maximumX;
+        double minimumY;
+        double maximumY;
+
+        if (annotation is Wpf.RectangleAnnotation rectangle)
+        {
+            minimumX = rectangle.MinimumX;
+            maximumX = rectangle.MaximumX;
+            minimumY = rectangle.MinimumY;
+            maximumY = rectangle.MaximumY;
+        }
+        else
+        {
+            var ellipse = Assert.IsType<Wpf.EllipseAnnotation>(annotation);
+            minimumX = ellipse.MinimumX;
+            maximumX = ellipse.MaximumX;
+            minimumY = ellipse.MinimumY;
+            maximumY = ellipse.MaximumY;
+        }
+
+        AssertValidPoint(annotation.InternalAnnotation.XAxis!, annotation.InternalAnnotation.YAxis!, new DataPoint(minimumX, minimumY));
+        AssertValidPoint(annotation.InternalAnnotation.XAxis!, annotation.InternalAnnotation.YAxis!, new DataPoint(maximumX, maximumY));
+
+        var lowerLeft = annotation.InternalAnnotation.Transform(minimumX, minimumY);
+        var upperRight = annotation.InternalAnnotation.Transform(maximumX, maximumY);
+        Assert.True(Math.Abs(upperRight.X - lowerLeft.X) >= 9.5);
+        Assert.True(Math.Abs(upperRight.Y - lowerLeft.Y) >= 9.5);
+    }
+
+    private static IList<DataPoint> GetPoints(Wpf.Annotation annotation)
+    {
+        return annotation switch
+        {
+            Wpf.PolygonAnnotation polygon => polygon.Points,
+            Wpf.PolylineAnnotation polyline => polyline.Points,
+            _ => throw new ArgumentOutOfRangeException(nameof(annotation), annotation, null)
+        };
+    }
+
+    private static void AssertValidPoint(Axis xAxis, Axis yAxis, DataPoint point)
+    {
+        Assert.True(point.IsDefined());
+        Assert.False(double.IsNaN(point.X));
+        Assert.False(double.IsInfinity(point.X));
+        Assert.False(double.IsNaN(point.Y));
+        Assert.False(double.IsInfinity(point.Y));
+        Assert.True(xAxis.IsValidValue(point.X));
+        Assert.True(yAxis.IsValidValue(point.Y));
+    }
+
+    private static void RenderPlot(Wpf.Plot plot)
+    {
+        plot.InvalidatePlot(true);
+        ((IPlotModel)plot.ActualModel).Render(new PdfRenderContext(RenderWidth, RenderHeight, OxyColors.White), new OxyRect(0, 0, RenderWidth, RenderHeight));
+    }
+
+    private static OxyMouseDownEventArgs NewMouseDown(ScreenPoint position)
+    {
+        return new OxyMouseDownEventArgs
+        {
+            ChangedButton = OxyMouseButton.Left,
+            ClickCount = 1,
+            Position = position
+        };
+    }
+
+    private static void InvokeMouseDown(Element element, ScreenPoint position, double hitIndex)
+    {
+        var handler = GetHandler<EventHandler<OxyMouseDownEventArgs>>(element, "MouseDown");
+        handler(
+            element,
+            new OxyMouseDownEventArgs
+            {
+                ChangedButton = OxyMouseButton.Left,
+                Position = position,
+                HitTestResult = new OxyPlot.HitTestResult(element, position, index: hitIndex)
+            });
+    }
+
+    private static void InvokeMouseMove(Element element, ScreenPoint position)
+    {
+        var handler = GetHandler<EventHandler<OxyMouseEventArgs>>(element, "MouseMove");
+        handler(element, new OxyMouseEventArgs { Position = position });
+    }
+
+    private static void InvokeMouseUp(Element element, ScreenPoint position)
+    {
+        var handler = GetHandler<EventHandler<OxyMouseEventArgs>>(element, "MouseUp");
+        handler(element, new OxyMouseEventArgs { Position = position });
+    }
+
+    private static T GetHandler<T>(Element element, string eventName)
+        where T : class
+    {
+        var eventField = typeof(Element).GetField(eventName, BindingFlags.Instance | BindingFlags.NonPublic);
+        Assert.NotNull(eventField);
+
+        var handler = eventField!.GetValue(element) as T;
+        Assert.NotNull(handler);
+        return handler!;
+    }
+
+    private static void InvokePrivate(object instance, string methodName, params object[] args)
+    {
+        var method = instance.GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.NonPublic);
+        Assert.NotNull(method);
+
+        method!.Invoke(instance, args);
+    }
+
+    private static void SetPlotGrid(Wpf.Plot plot)
+    {
+        var gridField = plot.GetType().BaseType?.GetField("grid", BindingFlags.Instance | BindingFlags.NonPublic);
+        Assert.NotNull(gridField);
+
+        gridField!.SetValue(plot, new System.Windows.Controls.Grid());
+    }
+}
diff --git a/tests/OxyPlotControls.Tests/OxyPlotToolbarAnnotationWiringTests.cs b/tests/OxyPlotControls.Tests/OxyPlotToolbarAnnotationWiringTests.cs
new file mode 100644
index 00000000..ac9886b7
--- /dev/null
+++ b/tests/OxyPlotControls.Tests/OxyPlotToolbarAnnotationWiringTests.cs
@@ -0,0 +1,302 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Windows;
+using System.Windows.Media;
+using OxyPlot;
+using OxyPlot.Annotations;
+using OxyPlot.Axes;
+using OxyPlot.Wpf.Serialization;
+using Xunit;
+using Wpf = OxyPlot.Wpf;
+
+namespace OxyPlotControls.Tests;
+
+public class OxyPlotToolbarAnnotationWiringTests
+{
+    [StaFact]
+    public void PlotAssignment_AttachesMouseHandlersToDeserializedAnnotations()
+    {
+        var sourcePlot = new Wpf.Plot();
+        sourcePlot.Annotations.Add(new Wpf.ArrowAnnotation
+        {
+            Text = "Move me",
+            StartPoint = new DataPoint(0, 0),
+            EndPoint = new DataPoint(1, 1)
+        });
+
+        var element = PlotSerializer.ToXElement(sourcePlot);
+        var plot = new Wpf.Plot();
+        PlotSerializer.FromXElement(plot, element);
+
+        var annotation = Assert.IsType<Wpf.ArrowAnnotation>(Assert.Single(plot.Annotations));
+        Assert.Equal(0, CountHandlers(annotation.InternalAnnotation, "MouseDown"));
+        Assert.Equal(0, CountHandlers(annotation.InternalAnnotation, "MouseMove"));
+        Assert.Equal(0, CountHandlers(annotation.InternalAnnotation, "MouseUp"));
+
+        var toolbar = new OxyPlotToolbar { Plot = plot };
+
+        Assert.Equal(1, CountHandlers(annotation.InternalAnnotation, "MouseDown"));
+        Assert.Equal(1, CountHandlers(annotation.InternalAnnotation, "MouseMove"));
+        Assert.Equal(1, CountHandlers(annotation.InternalAnnotation, "MouseUp"));
+
+        toolbar.Plot = null!;
+        toolbar.Plot = plot;
+
+        Assert.Equal(1, CountHandlers(annotation.InternalAnnotation, "MouseDown"));
+        Assert.Equal(1, CountHandlers(annotation.InternalAnnotation, "MouseMove"));
+        Assert.Equal(1, CountHandlers(annotation.InternalAnnotation, "MouseUp"));
+    }
+
+    [StaFact]
+    public void TextAnnotationScreenPoint_UsesPlotAreaCenterWhenTextPositionIsUndefined()
+    {
+        var plot = new Wpf.Plot();
+        var annotation = new Wpf.TextAnnotation { Text = "Move me" };
+        plot.Annotations.Add(annotation);
+
+        var toolbar = new OxyPlotToolbar { Plot = plot };
+        plot.InvalidatePlot(true);
+        ((IPlotModel)plot.ActualModel).Render(new PdfRenderContext(400, 300, OxyColors.White), new OxyRect(0, 0, 400, 300));
+
+        var point = GetCurrentTextAnnotationScreenPoint(toolbar, annotation);
+
+        Assert.False(double.IsNaN(point.X));
+        Assert.False(double.IsNaN(point.Y));
+        Assert.Equal(plot.ActualModel.PlotArea.Center.X, point.X, 6);
+        Assert.Equal(plot.ActualModel.PlotArea.Center.Y, point.Y, 6);
+    }
+
+    [StaFact]
+    public void AnnotationDrag_DoesNotChangeVisualColor()
+    {
+        foreach (var testCase in CreateAnnotationColorCases())
+        {
+            var plot = new Wpf.Plot();
+            plot.Annotations.Add(testCase.Annotation);
+
+            var toolbar = new OxyPlotToolbar { Plot = plot };
+            Assert.NotNull(toolbar);
+            RenderPlot(plot);
+
+            var originalColor = testCase.GetColor(testCase.Annotation);
+            var position = plot.ActualModel.PlotArea.Center;
+
+            InvokeMouseDown(testCase.Annotation.InternalAnnotation, position, testCase.HitIndex);
+            Assert.Equal(originalColor, testCase.GetColor(testCase.Annotation));
+
+            InvokeMouseUp(testCase.Annotation.InternalAnnotation, position);
+            Assert.Equal(originalColor, testCase.GetColor(testCase.Annotation));
+            Assert.False(testCase.Annotation.SuppressPropertyChanged);
+        }
+    }
+
+    [StaFact]
+    public void AddArrowAnnotation_UsesToolbarArrowHeadDefaults()
+    {
+        var plot = new Wpf.Plot();
+        plot.Axes.Add(new Wpf.LinearAxis { Position = AxisPosition.Bottom, Minimum = 0, Maximum = 1 });
+        plot.Axes.Add(new Wpf.LinearAxis { Position = AxisPosition.Left, Minimum = 0, Maximum = 1 });
+        SetPlotGrid(plot);
+
+        var toolbar = new OxyPlotToolbar { Plot = plot };
+        RenderPlot(plot);
+
+        InvokePrivate(toolbar, "AddArrowAnnotationItem_Click", toolbar, new RoutedEventArgs());
+        InvokePrivate(
+            toolbar,
+            "PlotModelMouseDown",
+            plot.ActualModel,
+            new OxyMouseDownEventArgs
+            {
+                ChangedButton = OxyMouseButton.Left,
+                ClickCount = 1,
+                Position = plot.ActualModel.PlotArea.Center
+            });
+
+        var arrow = Assert.IsType<Wpf.ArrowAnnotation>(Assert.Single(plot.Annotations));
+        Assert.Equal(6, arrow.HeadLength);
+        Assert.Equal(2, arrow.HeadWidth);
+        Assert.Equal(1, arrow.Veeness);
+    }
+
+    private static IEnumerable<AnnotationColorCase> CreateAnnotationColorCases()
+    {
+        yield return new AnnotationColorCase(
+            new Wpf.ArrowAnnotation
+            {
+                Text = "Arrow",
+                Color = Colors.SteelBlue,
+                StartPoint = new DataPoint(0, 0),
+                EndPoint = new DataPoint(1, 1)
+            },
+            annotation => ((Wpf.ArrowAnnotation)annotation).Color,
+            1);
+
+        yield return new AnnotationColorCase(
+            new Wpf.TextAnnotation
+            {
+                Text = "Text",
+                Background = Colors.LightGoldenrodYellow,
+                TextPosition = new DataPoint(0.5, 0.5)
+            },
+            annotation => ((Wpf.TextAnnotation)annotation).Background,
+            0);
+
+        yield return new AnnotationColorCase(
+            new Wpf.RectangleAnnotation
+            {
+                Text = "Rectangle",
+                Fill = Colors.LightGreen,
+                MinimumX = 0,
+                MaximumX = 1,
+                MinimumY = 0,
+                MaximumY = 1
+            },
+            annotation => ((Wpf.RectangleAnnotation)annotation).Fill,
+            0);
+
+        yield return new AnnotationColorCase(
+            new Wpf.EllipseAnnotation
+            {
+                Text = "Ellipse",
+                Fill = Colors.LightSkyBlue,
+                MinimumX = 0,
+                MaximumX = 1,
+                MinimumY = 0,
+                MaximumY = 1
+            },
+            annotation => ((Wpf.EllipseAnnotation)annotation).Fill,
+            0);
+
+        yield return new AnnotationColorCase(
+            new Wpf.PointAnnotation
+            {
+                Text = "Point",
+                Fill = Colors.Gold,
+                X = 0.5,
+                Y = 0.5
+            },
+            annotation => ((Wpf.PointAnnotation)annotation).Fill,
+            0);
+
+        yield return new AnnotationColorCase(
+            new Wpf.PolygonAnnotation
+            {
+                Text = "Polygon",
+                Fill = Colors.MediumPurple,
+                Points = new List<DataPoint>
+                {
+                    new(0, 0),
+                    new(1, 0),
+                    new(1, 1)
+                }
+            },
+            annotation => ((Wpf.PolygonAnnotation)annotation).Fill,
+            0);
+
+        yield return new AnnotationColorCase(
+            new Wpf.PolylineAnnotation
+            {
+                Text = "Polyline",
+                Color = Colors.DarkCyan,
+                Points = new List<DataPoint>
+                {
+                    new(0, 0),
+                    new(1, 0),
+                    new(1, 1)
+                }
+            },
+            annotation => ((Wpf.PolylineAnnotation)annotation).Color,
+            0);
+
+        yield return new AnnotationColorCase(
+            new Wpf.LineAnnotation
+            {
+                Text = "Line",
+                Color = Colors.DarkOrange,
+                Type = LineAnnotationType.Vertical,
+                X = 0.5,
+                Y = 0.5
+            },
+            annotation => ((Wpf.LineAnnotation)annotation).Color,
+            0);
+    }
+
+    private static void RenderPlot(Wpf.Plot plot)
+    {
+        plot.InvalidatePlot(true);
+        ((IPlotModel)plot.ActualModel).Render(new PdfRenderContext(400, 300, OxyColors.White), new OxyRect(0, 0, 400, 300));
+    }
+
+    private static void InvokeMouseDown(Element element, ScreenPoint position, double hitIndex)
+    {
+        var handler = GetHandler<EventHandler<OxyMouseDownEventArgs>>(element, "MouseDown");
+        handler(
+            element,
+            new OxyMouseDownEventArgs
+            {
+                ChangedButton = OxyMouseButton.Left,
+                Position = position,
+                HitTestResult = new OxyPlot.HitTestResult(element, position, index: hitIndex)
+            });
+    }
+
+    private static void InvokeMouseUp(Element element, ScreenPoint position)
+    {
+        var handler = GetHandler<EventHandler<OxyMouseEventArgs>>(element, "MouseUp");
+        handler(element, new OxyMouseEventArgs { Position = position });
+    }
+
+    private static int CountHandlers(Element element, string eventName)
+    {
+        var eventField = typeof(Element).GetField(eventName, BindingFlags.Instance | BindingFlags.NonPublic);
+        Assert.NotNull(eventField);
+
+        var handler = eventField!.GetValue(element) as MulticastDelegate;
+        return handler?.GetInvocationList().Length ?? 0;
+    }
+
+    private static ScreenPoint GetCurrentTextAnnotationScreenPoint(OxyPlotToolbar toolbar, Wpf.TextAnnotation annotation)
+    {
+        var method = typeof(OxyPlotToolbar).GetMethod(
+            "GetCurrentTextAnnotationScreenPoint",
+            BindingFlags.Instance | BindingFlags.NonPublic);
+        Assert.NotNull(method);
+
+        return Assert.IsType<ScreenPoint>(method!.Invoke(toolbar, new object[] { annotation }));
+    }
+
+    private static T GetHandler<T>(Element element, string eventName)
+        where T : class
+    {
+        var eventField = typeof(Element).GetField(eventName, BindingFlags.Instance | BindingFlags.NonPublic);
+        Assert.NotNull(eventField);
+
+        var handler = eventField!.GetValue(element) as T;
+        Assert.NotNull(handler);
+        return handler!;
+    }
+
+    private static void InvokePrivate(object instance, string methodName, params object[] args)
+    {
+        var method = instance.GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.NonPublic);
+        Assert.NotNull(method);
+
+        method!.Invoke(instance, args);
+    }
+
+    private static void SetPlotGrid(Wpf.Plot plot)
+    {
+        var gridField = plot.GetType().BaseType?.GetField("grid", BindingFlags.Instance | BindingFlags.NonPublic);
+        Assert.NotNull(gridField);
+
+        gridField!.SetValue(plot, new System.Windows.Controls.Grid());
+    }
+
+    private sealed record AnnotationColorCase(
+        Wpf.Annotation Annotation,
+        Func<Wpf.Annotation, Color> GetColor,
+        double HitIndex);
+}
diff --git a/tests/OxyPlotControls.Tests/OxyPlotToolbarExportDataTests.cs b/tests/OxyPlotControls.Tests/OxyPlotToolbarExportDataTests.cs
new file mode 100644
index 00000000..d8d5878f
--- /dev/null
+++ b/tests/OxyPlotControls.Tests/OxyPlotToolbarExportDataTests.cs
@@ -0,0 +1,174 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Reflection;
+using OxyPlot;
+using OxyPlot.Axes;
+using OxyPlot.Series;
+using Xunit;
+using Wpf = OxyPlot.Wpf;
+
+namespace OxyPlotControls.Tests;
+
+public class OxyPlotToolbarExportDataTests
+{
+    private const double RenderWidth = 400;
+    private const double RenderHeight = 300;
+
+    [StaFact]
+    public void BuildExportDataTables_ScatterPointSeriesWithMapping_ExportsMappedCoordinates()
+    {
+        var plot = new Wpf.Plot();
+        plot.Series.Add(new Wpf.ScatterPointSeries
+        {
+            Title = "Exact Data",
+            ItemsSource = new[]
+            {
+                new SourcePoint { Index = 1, Value = 10 },
+                new SourcePoint { Index = 2, Value = 20 }
+            },
+            Mapping = item =>
+            {
+                var point = (SourcePoint)item;
+                return new ScatterPoint(point.Index, point.Value);
+            }
+        });
+
+        var table = Assert.Single(BuildExportDataTables(plot));
+
+        Assert.Equal("1", Convert.ToString(table.Rows[0]["Exact Data_x"]));
+        Assert.Equal("10", Convert.ToString(table.Rows[0]["Exact Data_y"]));
+        Assert.Equal("2", Convert.ToString(table.Rows[1]["Exact Data_x"]));
+        Assert.Equal("20", Convert.ToString(table.Rows[1]["Exact Data_y"]));
+    }
+
+    [StaFact]
+    public void BuildExportDataTables_LineSeriesWithMapping_ExportsMappedCoordinates()
+    {
+        var plot = new Wpf.Plot();
+        plot.Series.Add(new Wpf.LineSeries
+        {
+            Title = "Trend",
+            ItemsSource = new[]
+            {
+                new SourcePoint { Index = 3, Value = 30 },
+                new SourcePoint { Index = 4, Value = 40 }
+            },
+            Mapping = item =>
+            {
+                var point = (SourcePoint)item;
+                return new DataPoint(point.Index, point.Value);
+            }
+        });
+
+        var table = Assert.Single(BuildExportDataTables(plot));
+
+        Assert.Equal("3", Convert.ToString(table.Rows[0]["Trend_x"]));
+        Assert.Equal("30", Convert.ToString(table.Rows[0]["Trend_y"]));
+        Assert.Equal("4", Convert.ToString(table.Rows[1]["Trend_x"]));
+        Assert.Equal("40", Convert.ToString(table.Rows[1]["Trend_y"]));
+    }
+
+    [StaFact]
+    public void BuildExportDataTables_ScatterErrorSeriesWithDataFields_ExportsErrors()
+    {
+        var plot = new Wpf.Plot();
+        plot.Series.Add(new Wpf.ScatterErrorSeries
+        {
+            Title = "Error Data",
+            ItemsSource = new[]
+            {
+                new ErrorPoint
+                {
+                    X = 5,
+                    Y = 50,
+                    LowerX = 4,
+                    UpperX = 6,
+                    LowerY = 45,
+                    UpperY = 55
+                }
+            },
+            DataFieldX = nameof(ErrorPoint.X),
+            DataFieldY = nameof(ErrorPoint.Y),
+            DataFieldLowerErrorX = nameof(ErrorPoint.LowerX),
+            DataFieldUpperErrorX = nameof(ErrorPoint.UpperX),
+            DataFieldLowerErrorY = nameof(ErrorPoint.LowerY),
+            DataFieldUpperErrorY = nameof(ErrorPoint.UpperY)
+        });
+
+        var table = Assert.Single(BuildExportDataTables(plot));
+
+        Assert.Equal("4", Convert.ToString(table.Rows[0]["Error Data_xLower"]));
+        Assert.Equal("5", Convert.ToString(table.Rows[0]["Error Data_x"]));
+        Assert.Equal("6", Convert.ToString(table.Rows[0]["Error Data_xUpper"]));
+        Assert.Equal("45", Convert.ToString(table.Rows[0]["Error Data_yLower"]));
+        Assert.Equal("50", Convert.ToString(table.Rows[0]["Error Data_y"]));
+        Assert.Equal("55", Convert.ToString(table.Rows[0]["Error Data_yUpper"]));
+    }
+
+    [StaFact]
+    public void BuildExportDataTables_CategoryAxisWithNullLabelField_DoesNotThrow()
+    {
+        var plot = new Wpf.Plot();
+        plot.Axes.Add(new Wpf.CategoryAxis
+        {
+            Position = AxisPosition.Bottom,
+            ItemsSource = new[] { new CategorySource { Label = "A" } },
+            LabelField = null
+        });
+        plot.Axes.Add(new Wpf.LinearAxis { Position = AxisPosition.Left });
+        plot.Series.Add(new Wpf.LineSeries
+        {
+            Title = "Categorized",
+            ItemsSource = new[] { new DataPoint(0, 1) }
+        });
+
+        RenderPlot(plot);
+
+        var table = Assert.Single(BuildExportDataTables(plot));
+
+        Assert.True(table.Columns.Contains("Xcategory"));
+        Assert.Equal("", Convert.ToString(table.Rows[0]["Xcategory"]));
+    }
+
+    private static List<DataTable> BuildExportDataTables(Wpf.Plot plot)
+    {
+        var method = typeof(OxyPlotToolbar).GetMethod("BuildExportDataTables", BindingFlags.NonPublic | BindingFlags.Static);
+        Assert.NotNull(method);
+
+        return Assert.IsType<List<DataTable>>(method!.Invoke(null, new object[] { plot }));
+    }
+
+    private static void RenderPlot(Wpf.Plot plot)
+    {
+        plot.InvalidatePlot(true);
+        ((IPlotModel)plot.ActualModel).Render(new PdfRenderContext(RenderWidth, RenderHeight, OxyColors.White), new OxyRect(0, 0, RenderWidth, RenderHeight));
+    }
+
+    private sealed class SourcePoint
+    {
+        public double Index { get; init; }
+
+        public double Value { get; init; }
+    }
+
+    private sealed class ErrorPoint
+    {
+        public double X { get; init; }
+
+        public double Y { get; init; }
+
+        public double LowerX { get; init; }
+
+        public double UpperX { get; init; }
+
+        public double LowerY { get; init; }
+
+        public double UpperY { get; init; }
+    }
+
+    private sealed class CategorySource
+    {
+        public string Label { get; init; } = "";
+    }
+}

From 59de43a033ee17790ea1a6fcefd1a3f4bd3fbe10 Mon Sep 17 00:00:00 2001
From: HadenSmith <cole.h.smith@usace.army.mil>
Date: Tue, 30 Jun 2026 10:42:16 -0600
Subject: [PATCH 09/11] Prepare WPF Framework for public release

---
 .gitignore                                    |   5 -
 Directory.Build.props                         |  30 +--
 Directory.Packages.props                      |  50 ++++
 README.md                                     |  27 +-
 WPF-Framework.sln                             |  79 +++++-
 docs/architecture.md                          |  34 ++-
 docs/critical-review-implementation-plan.md   | 207 ----------------
 docs/database-controls.md                     |  14 +-
 docs/getting-started.md                       |  12 +-
 docs/numeric-controls.md                      |   8 +-
 scripts/pack-wpf-framework.ps1                |  96 ++++++++
 scripts/validate-code-xml-docs.ps1            | 174 +++++++++++++
 src/DAG.Demo/App.xaml.cs                      |   3 +
 src/DAG.Demo/MainWindow.xaml.cs               |  63 +++++
 src/DAG/Graph.cs                              |  23 ++
 src/DAGControls/FlowGraphCanvas.xaml.cs       |  92 +++++++
 src/DAGControls/NodeControl.xaml.cs           |  30 +++
 .../DatabaseControls.Demo.csproj              |   6 +-
 src/DatabaseControls/DatabaseControls.csproj  |   3 +-
 .../CalculatorHelpWindow.xaml.cs              |  13 +
 .../FieldCalculator/FieldCalculator.xaml.cs   |   5 +
 src/DatabaseControls/TableViewer.xaml.cs      | 233 ++++++++++++++++++
 .../DatabaseManager.Tests.csproj              |   8 +-
 src/DatabaseManager/DataTableView.cs          |  21 +-
 src/DatabaseManager/DatabaseManager.csproj    |  14 +-
 .../ExpressionParser.Tests.csproj             |   6 +-
 src/ExpressionParser/Parser/Parser.cs         |   6 +-
 src/ExpressionParserControls.Demo/App.xaml.cs |   8 +
 .../ExpressionControl.xaml.cs                 |  61 ++---
 .../Messaging/BasicMessageItem.cs             |   6 +-
 .../Messaging/Messenger.cs                    |   5 +
 src/FrameworkInterfaces/Undo/UndoManager.cs   |  20 ++
 src/FrameworkUI.Demo/FrameworkUI.Demo.csproj  |   4 +-
 src/FrameworkUI.Demo/Model/DemoProject.cs     |   1 +
 .../Model/Hazard Elements/HazardElement.cs    |   3 +-
 .../Model/Undo Demo/UndoDemoElement.cs        |   1 +
 src/FrameworkUI.Demo/UI/DemoProjectNode.cs    |   4 +-
 .../UI/Hazard Controls/HazardControl.xaml.cs  |  14 +-
 src/FrameworkUI/Help Menu/AboutWindow.xaml.cs |   5 +
 .../TermsAndConditionsWindow.xaml.cs          |  37 +++
 .../Project Explorer/View Models/Node.cs      |   5 +
 src/FrameworkUI/Recent Files/RecentFiles.cs   |  17 ++
 .../Utilities/ShellPublicVariables.cs         |   4 +
 src/GenericControls.Demo/MainWindow.xaml.cs   |   6 +-
 .../DataGrid/DataGridToolbar.xaml.cs          |  11 +-
 .../ValidationDataGridObjects/PropertyRule.cs |   7 +-
 .../NumericControls.Demo.csproj               |   2 +-
 .../TimeSeriesTable.xaml.cs                   |   5 +
 .../DistributionSelectorControl.xaml.cs       |  23 ++
 .../Distribution Selector/Selector.xaml.cs    |  23 ++
 src/NumericControls/NumericControls.csproj    |   3 +-
 src/OxyPlotControls.Demo/MainWindow.xaml.cs   |  89 +++++++
 .../OxyPlotControls.Demo.csproj               |   4 +-
 .../OxyPlotPropertiesDialog.xaml.cs           |   5 +
 src/OxyPlotControls/OxyPlotToolbar.xaml.cs    | 142 +++++++++++
 .../SavePlotImageDialog.xaml.cs               |  35 +++
 .../Series/GenericSeriesControl.xaml.cs       |  10 +
 .../RMC.Wpf.Framework.Controls.csproj         |  11 +
 .../RMC.Wpf.Framework.Controls.nuspec         |  42 ++++
 .../RMC.Wpf.Framework.Core.csproj             |  11 +
 .../RMC.Wpf.Framework.Core.nuspec             |  25 ++
 .../RMC.Wpf.Framework.Models.csproj           |  11 +
 .../RMC.Wpf.Framework.Models.nuspec           |  40 +++
 .../RMC.Wpf.Framework.Support.csproj          |  13 +
 .../RMC.Wpf.Framework.Support.nuspec          |  33 +++
 tests/DAG.Tests/DAG.Tests.csproj              |   8 +-
 .../Snippets/DagSnippets.cs                   |   5 -
 .../Snippets/DatabaseSnippets.cs              |  10 -
 .../Snippets/GettingStartedSnippets.cs        |  12 +-
 .../Snippets/UndoRedoSnippets.cs              |   5 +-
 .../FrameworkInterfaces.Tests.csproj          |   8 +-
 .../FrameworkUI.Tests.csproj                  |  10 +-
 .../GenericControls.Tests.csproj              |   8 +-
 .../NumericControls.Tests.csproj              |  12 +-
 tests/OxyPlot.Tests/OxyPlot.Tests.csproj      |   8 +-
 .../OxyPlot.Wpf.Tests.csproj                  |   8 +-
 .../OxyPlotControls.Tests.csproj              |  10 +-
 .../SoftwareUpdate.Tests.csproj               |   8 +-
 .../SoftwareUpdate.Updater.Tests.csproj       |   8 +-
 tests/Themes.Tests/Themes.Tests.csproj        |   8 +-
 80 files changed, 1721 insertions(+), 415 deletions(-)
 create mode 100644 Directory.Packages.props
 delete mode 100644 docs/critical-review-implementation-plan.md
 create mode 100644 scripts/pack-wpf-framework.ps1
 create mode 100644 scripts/validate-code-xml-docs.ps1
 create mode 100644 src/Packaging/RMC.Wpf.Framework.Controls/RMC.Wpf.Framework.Controls.csproj
 create mode 100644 src/Packaging/RMC.Wpf.Framework.Controls/RMC.Wpf.Framework.Controls.nuspec
 create mode 100644 src/Packaging/RMC.Wpf.Framework.Core/RMC.Wpf.Framework.Core.csproj
 create mode 100644 src/Packaging/RMC.Wpf.Framework.Core/RMC.Wpf.Framework.Core.nuspec
 create mode 100644 src/Packaging/RMC.Wpf.Framework.Models/RMC.Wpf.Framework.Models.csproj
 create mode 100644 src/Packaging/RMC.Wpf.Framework.Models/RMC.Wpf.Framework.Models.nuspec
 create mode 100644 src/Packaging/RMC.Wpf.Framework.Support/RMC.Wpf.Framework.Support.csproj
 create mode 100644 src/Packaging/RMC.Wpf.Framework.Support/RMC.Wpf.Framework.Support.nuspec

diff --git a/.gitignore b/.gitignore
index afabb0a8..735cd521 100644
--- a/.gitignore
+++ b/.gitignore
@@ -417,8 +417,3 @@ FodyWeavers.xsd
 *.msm
 *.msp
 /nul
-
-# AI-assistant metadata (not tracked in this repo)
-CLAUDE.md
-**/CLAUDE.md
-.claude/
diff --git a/Directory.Build.props b/Directory.Build.props
index b632eb82..79ac2446 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -19,44 +19,38 @@
     <FileVersion>1.0.0.0</FileVersion>
 
     <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
+    <IsPackable>false</IsPackable>
     <EmbedUntrackedSources>true</EmbedUntrackedSources>
     <DebugType>embedded</DebugType>
 
     <PackageLicenseExpression>0BSD</PackageLicenseExpression>
     <PackageReadmeFile>README.md</PackageReadmeFile>
 
-    <!--
-      Treat XML-doc warnings as errors so missing or malformed documentation on public
-      API fails the build instead of shipping a partial reference. Scope limited to
-      IsWpfFrameworkLibrary=true so vendored forks (AvalonDock, upstream OxyPlot) are
-      unaffected.
-        CS1591 - missing XML comment for publicly visible type or member
-        CS1572 - XML comment has a param tag for a non-existent parameter
-        CS1573 - parameter has no matching param tag (but other parameters do)
-        CS1574 - XML comment has cref attribute that could not be resolved
-        CS0419 - ambiguous reference in cref attribute
-    -->
+    <!-- Public API XML documentation must be complete on packable RMC libraries. -->
     <WarningsAsErrors>$(WarningsAsErrors);CS1591;CS1572;CS1573;CS1574;CS0419</WarningsAsErrors>
   </PropertyGroup>
 
-  <PropertyGroup Condition="'$(UseLocalRmcNumericsProject)' == '' and ('$(MSBuildProjectName)' == 'DatabaseControls' or '$(MSBuildProjectName)' == 'NumericControls')">
-    <BestFitRepositoryRoot Condition="'$(BestFitRepositoryRoot)' == '' and '$(SolutionDir)' != '' and Exists('$(SolutionDir)RMC.BestFit.sln')">$(SolutionDir)</BestFitRepositoryRoot>
-    <BestFitRepositoryRoot Condition="'$(BestFitRepositoryRoot)' == '' and Exists('$(MSBuildStartupDirectory)\RMC.BestFit.sln')">$(MSBuildStartupDirectory)\</BestFitRepositoryRoot>
-    <UseLocalRmcNumericsProject Condition="'$(BestFitRepositoryRoot)' != ''">true</UseLocalRmcNumericsProject>
-    <RmcNumericsProject Condition="'$(RmcNumericsProject)' == '' and '$(BestFitRepositoryRoot)' != ''">$(BestFitRepositoryRoot)..\numerics\Numerics\Numerics.csproj</RmcNumericsProject>
+  <PropertyGroup Condition="'$(EnforceXmlDocumentation)' == 'true'">
+    <!--
+      Release validation enables the full XML documentation warning set. Run
+      scripts\validate-code-xml-docs.ps1 to combine this compiler gate with the
+      private class and method scanner.
+    -->
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <WarningsAsErrors>$(WarningsAsErrors);CS0419;CS1570;CS1571;CS1572;CS1573;CS1574;CS1584;CS1587;CS1589;CS1591</WarningsAsErrors>
   </PropertyGroup>
 
   <ItemGroup Condition="'$(IsWpfFrameworkLibrary)' == 'true'">
     <None Include="$(MSBuildThisFileDirectory)README.md" Pack="true" PackagePath="\" Visible="false" />
 
     <!-- Reproducible builds: https://github.com/dotnet/reproducible-builds -->
-    <PackageReference Include="DotNet.ReproducibleBuilds" Version="1.2.39">
+    <PackageReference Include="DotNet.ReproducibleBuilds">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
 
     <!-- Source Link: https://github.com/dotnet/sourcelink -->
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="10.0.102">
+    <PackageReference Include="Microsoft.SourceLink.GitHub">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
diff --git a/Directory.Packages.props b/Directory.Packages.props
new file mode 100644
index 00000000..d5d2d565
--- /dev/null
+++ b/Directory.Packages.props
@@ -0,0 +1,50 @@
+<Project>
+  <PropertyGroup>
+    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+    <CentralPackageFloatingVersionsEnabled>true</CentralPackageFloatingVersionsEnabled>
+    <ClosedXmlVersion>0.105.0</ClosedXmlVersion>
+    <CoverletCollectorVersion>6.0.2</CoverletCollectorVersion>
+    <DocumentFormatOpenXmlVersion>3.4.1</DocumentFormatOpenXmlVersion>
+    <DotNetReproducibleBuildsVersion>1.2.39</DotNetReproducibleBuildsVersion>
+    <ExcelNumberFormatVersion>1.1</ExcelNumberFormatVersion>
+    <FastMemberVersion>1.5.0</FastMemberVersion>
+    <MicrosoftNetTestSdkVersion>17.12.0</MicrosoftNetTestSdkVersion>
+    <MicrosoftSourceLinkGitHubVersion>10.0.102</MicrosoftSourceLinkGitHubVersion>
+    <MSTestTestAdapterVersion>3.5.2</MSTestTestAdapterVersion>
+    <MSTestTestFrameworkVersion>3.5.2</MSTestTestFrameworkVersion>
+    <NSubstituteVersion>4.2.1</NSubstituteVersion>
+    <NUnitVersion>3.14.0</NUnitVersion>
+    <NUnit3TestAdapterVersion>4.5.0</NUnit3TestAdapterVersion>
+    <!-- Restore the latest compatible RMC.Numerics 2.x release for source builds. -->
+    <RmcNumericsVersion>2.*</RmcNumericsVersion>
+    <!-- NuGet package dependencies require a valid version range, not a floating wildcard. -->
+    <RmcNumericsPackageDependencyVersion>[2.1.1,3.0.0)</RmcNumericsPackageDependencyVersion>
+    <SourceGearSqlite3Version>3.50.4.5</SourceGearSqlite3Version>
+    <SystemDataSQLiteVersion>2.0.2</SystemDataSQLiteVersion>
+    <XunitVersion>2.9.2</XunitVersion>
+    <XunitRunnerVisualStudioVersion>2.8.2</XunitRunnerVisualStudioVersion>
+    <XunitStaFactVersion>1.1.11</XunitStaFactVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageVersion Include="ClosedXML" Version="$(ClosedXmlVersion)" />
+    <PackageVersion Include="coverlet.collector" Version="$(CoverletCollectorVersion)" />
+    <PackageVersion Include="DocumentFormat.OpenXml" Version="$(DocumentFormatOpenXmlVersion)" />
+    <PackageVersion Include="DotNet.ReproducibleBuilds" Version="$(DotNetReproducibleBuildsVersion)" />
+    <PackageVersion Include="ExcelNumberFormat" Version="$(ExcelNumberFormatVersion)" />
+    <PackageVersion Include="FastMember" Version="$(FastMemberVersion)" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="$(MicrosoftNetTestSdkVersion)" />
+    <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="$(MicrosoftSourceLinkGitHubVersion)" />
+    <PackageVersion Include="MSTest.TestAdapter" Version="$(MSTestTestAdapterVersion)" />
+    <PackageVersion Include="MSTest.TestFramework" Version="$(MSTestTestFrameworkVersion)" />
+    <PackageVersion Include="NSubstitute" Version="$(NSubstituteVersion)" />
+    <PackageVersion Include="NUnit" Version="$(NUnitVersion)" />
+    <PackageVersion Include="NUnit3TestAdapter" Version="$(NUnit3TestAdapterVersion)" />
+    <PackageVersion Include="RMC.Numerics" Version="$(RmcNumericsVersion)" />
+    <PackageVersion Include="SourceGear.sqlite3" Version="$(SourceGearSqlite3Version)" />
+    <PackageVersion Include="System.Data.SQLite" Version="$(SystemDataSQLiteVersion)" />
+    <PackageVersion Include="xunit" Version="$(XunitVersion)" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="$(XunitRunnerVisualStudioVersion)" />
+    <PackageVersion Include="Xunit.StaFact" Version="$(XunitStaFactVersion)" />
+  </ItemGroup>
+</Project>
diff --git a/README.md b/README.md
index 7efa0249..cd049bda 100644
--- a/README.md
+++ b/README.md
@@ -12,21 +12,21 @@ WPF Framework is a free and open-source .NET 10.0 application framework for buil
 | .NET | 10.0 |
 | OS | Windows 10+ |
 
-WPF Framework is currently distributed as source only. NuGet package publishing is planned for a future release; until then, clone the repository and reference the individual library projects directly, or build them as local NuGet packages.
+WPF Framework can be consumed from source project references or packaged into NuGet bundles with `scripts/pack-wpf-framework.ps1`. The package layout follows the internal dependency map: Core, Models, Support, then Controls.
 
-The framework depends on the [Numerics](https://github.com/USACE-RMC/Numerics) library (built separately and referenced via `HintPath`). See [Prerequisites](#prerequisites) for the expected layout.
+The framework depends on [RMC.Numerics](https://github.com/USACE-RMC/Numerics) through central NuGet package management in `Directory.Packages.props`. Source builds restore the latest compatible 2.x package; NuGet bundles declare compatibility with RMC.Numerics 2.1.1 or later, below 3.0.0.
 
 ## Solution Structure
 
 | Folder | Projects | Description |
 |--------|----------|-------------|
-| **Core** | FrameworkInterfaces, FrameworkUI, Themes | Core contracts, application shell, and theming engine |
-| **Controls** | GenericControls, NumericControls, OxyPlotControls, DatabaseControls, ExpressionParserControls, DAGControls | Reusable WPF control libraries |
+| **Core** | FrameworkInterfaces, Themes | Core contracts and theming engine |
+| **Controls** | FrameworkUI, GenericControls, NumericControls, OxyPlotControls, DatabaseControls, ExpressionParserControls, DAGControls, Xceed.Wpf.AvalonDock, Xceed.Wpf.AvalonDock.Themes.VS2013 | Application shell, reusable WPF controls, and docking UI |
 | **Models** | DatabaseManager, ExpressionParser, OxyPlot, OxyPlot.Wpf, OxyPlot.Wpf.Shared, DAG | Platform-agnostic model and engine libraries |
 | **Support** | SoftwareUpdate, SoftwareUpdate.Updater | GitHub Releases-based auto-update system |
-| **AvalonDock** | Xceed.Wpf.AvalonDock, Xceed.Wpf.AvalonDock.Themes.VS2013 | Modified VS2013-themed docking layout (vendored fork) |
 | **Demos** | FrameworkUI.Demo, GenericControls.Demo, NumericControls.Demo, OxyPlotControls.Demo, DatabaseControls.Demo, ExpressionParserControls.Demo, DAG.Demo | Interactive demo applications |
 | **Tests** | OxyPlot.ExampleLibrary + 13 test projects | Example chart models and xunit, MSTest, and NUnit test suites |
+| **Packaging** | RMC.Wpf.Framework.Core, RMC.Wpf.Framework.Models, RMC.Wpf.Framework.Support, RMC.Wpf.Framework.Controls | NuGet bundle projects |
 
 ## Quick Start
 
@@ -43,6 +43,21 @@ dotnet build WPF-Framework.sln
 dotnet test WPF-Framework.sln
 ```
 
+### Build Packages
+
+```bash
+.\scripts\pack-wpf-framework.ps1 -Configuration Release
+```
+
+This creates and validates the following NuGet packages in `artifacts/packages/`:
+
+| Package | Includes | Depends on |
+|---------|----------|------------|
+| `RMC.Wpf.Framework.Core` | FrameworkInterfaces, Themes | None |
+| `RMC.Wpf.Framework.Models` | DAG, DatabaseManager, ExpressionParser, OxyPlot libraries | ClosedXML, DocumentFormat.OpenXml, ExcelNumberFormat, FastMember, SourceGear.sqlite3, System.Data.SQLite |
+| `RMC.Wpf.Framework.Support` | SoftwareUpdate and updater content files | None |
+| `RMC.Wpf.Framework.Controls` | FrameworkUI, control libraries, AvalonDock fork | Core, Models, Support, RMC.Numerics 2.x |
+
 ### Minimal Application
 
 ```csharp
@@ -142,7 +157,7 @@ WPF Framework powers the following USACE-RMC desktop applications:
 
 ## Related Libraries
 
-- [Numerics](https://github.com/USACE-RMC/Numerics) — .NET library for numerical computing, statistical analysis, and Bayesian inference (required dependency for NumericControls and DatabaseControls)
+- [RMC.Numerics](https://github.com/USACE-RMC/Numerics) - NuGet package for numerical computing, statistical analysis, and Bayesian inference (required dependency for NumericControls and DatabaseControls)
 
 ## Contributing
 
diff --git a/WPF-Framework.sln b/WPF-Framework.sln
index a5bc4d98..18aae876 100644
--- a/WPF-Framework.sln
+++ b/WPF-Framework.sln
@@ -3,14 +3,20 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 18
 VisualStudioVersion = 18.2.11415.280
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Core Framework", "Core Framework", "{1A2B3C4D-5E6F-7890-AB12-CD34EF567890}"
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Core", "Core", "{1A2B3C4D-5E6F-7890-AB12-CD34EF567890}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Controls", "Controls", "{2B3C4D5E-6F78-90AB-12CD-34EF56789012}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "AvalonDock", "AvalonDock", "{7868E064-C2D3-48E9-BB5A-01F4041E61F3}"
+EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Demos", "Demos", "{3C4D5E6F-7890-AB12-CD34-EF5678901234}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tests", "Tests", "{4D5E6F78-90AB-12CD-34EF-567890123456}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Support", "Support", "{CC28565E-FA51-41F3-BA10-E8823462B865}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Packaging", "Packaging", "{4447D44B-4E3D-49F2-82D1-BB5CBBDB7D8F}"
+EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FrameworkInterfaces", "src\FrameworkInterfaces\FrameworkInterfaces.csproj", "{12E48302-6991-4257-9649-7EBE5025444F}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FrameworkUI", "src\FrameworkUI\FrameworkUI.csproj", "{6E6C9D00-1F49-41F2-BE4C-BF23F509E06E}"
@@ -93,6 +99,14 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DAG.Tests", "tests\DAG.Test
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FrameworkUI.Tests", "tests\FrameworkUI.Tests\FrameworkUI.Tests.csproj", "{EFB3100E-0B1D-41EC-BAD4-C79B42481E57}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RMC.Wpf.Framework.Core", "src\Packaging\RMC.Wpf.Framework.Core\RMC.Wpf.Framework.Core.csproj", "{3B857B22-5ECF-47E7-8926-9408D1C5AF21}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RMC.Wpf.Framework.Models", "src\Packaging\RMC.Wpf.Framework.Models\RMC.Wpf.Framework.Models.csproj", "{710B690F-A845-49E5-9292-AEE1AA8A9A24}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RMC.Wpf.Framework.Support", "src\Packaging\RMC.Wpf.Framework.Support\RMC.Wpf.Framework.Support.csproj", "{19820B5F-AE0B-4D85-95B4-31427ACE5B70}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RMC.Wpf.Framework.Controls", "src\Packaging\RMC.Wpf.Framework.Controls\RMC.Wpf.Framework.Controls.csproj", "{C4B34581-1DCD-49D1-BB46-6DCE5CEC2594}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -583,21 +597,70 @@ Global
 		{EFB3100E-0B1D-41EC-BAD4-C79B42481E57}.Release|x64.Build.0 = Release|Any CPU
 		{EFB3100E-0B1D-41EC-BAD4-C79B42481E57}.Release|x86.ActiveCfg = Release|Any CPU
 		{EFB3100E-0B1D-41EC-BAD4-C79B42481E57}.Release|x86.Build.0 = Release|Any CPU
+		{3B857B22-5ECF-47E7-8926-9408D1C5AF21}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3B857B22-5ECF-47E7-8926-9408D1C5AF21}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3B857B22-5ECF-47E7-8926-9408D1C5AF21}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{3B857B22-5ECF-47E7-8926-9408D1C5AF21}.Debug|x64.Build.0 = Debug|Any CPU
+		{3B857B22-5ECF-47E7-8926-9408D1C5AF21}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{3B857B22-5ECF-47E7-8926-9408D1C5AF21}.Debug|x86.Build.0 = Debug|Any CPU
+		{3B857B22-5ECF-47E7-8926-9408D1C5AF21}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3B857B22-5ECF-47E7-8926-9408D1C5AF21}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3B857B22-5ECF-47E7-8926-9408D1C5AF21}.Release|x64.ActiveCfg = Release|Any CPU
+		{3B857B22-5ECF-47E7-8926-9408D1C5AF21}.Release|x64.Build.0 = Release|Any CPU
+		{3B857B22-5ECF-47E7-8926-9408D1C5AF21}.Release|x86.ActiveCfg = Release|Any CPU
+		{3B857B22-5ECF-47E7-8926-9408D1C5AF21}.Release|x86.Build.0 = Release|Any CPU
+		{710B690F-A845-49E5-9292-AEE1AA8A9A24}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{710B690F-A845-49E5-9292-AEE1AA8A9A24}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{710B690F-A845-49E5-9292-AEE1AA8A9A24}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{710B690F-A845-49E5-9292-AEE1AA8A9A24}.Debug|x64.Build.0 = Debug|Any CPU
+		{710B690F-A845-49E5-9292-AEE1AA8A9A24}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{710B690F-A845-49E5-9292-AEE1AA8A9A24}.Debug|x86.Build.0 = Debug|Any CPU
+		{710B690F-A845-49E5-9292-AEE1AA8A9A24}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{710B690F-A845-49E5-9292-AEE1AA8A9A24}.Release|Any CPU.Build.0 = Release|Any CPU
+		{710B690F-A845-49E5-9292-AEE1AA8A9A24}.Release|x64.ActiveCfg = Release|Any CPU
+		{710B690F-A845-49E5-9292-AEE1AA8A9A24}.Release|x64.Build.0 = Release|Any CPU
+		{710B690F-A845-49E5-9292-AEE1AA8A9A24}.Release|x86.ActiveCfg = Release|Any CPU
+		{710B690F-A845-49E5-9292-AEE1AA8A9A24}.Release|x86.Build.0 = Release|Any CPU
+		{19820B5F-AE0B-4D85-95B4-31427ACE5B70}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{19820B5F-AE0B-4D85-95B4-31427ACE5B70}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{19820B5F-AE0B-4D85-95B4-31427ACE5B70}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{19820B5F-AE0B-4D85-95B4-31427ACE5B70}.Debug|x64.Build.0 = Debug|Any CPU
+		{19820B5F-AE0B-4D85-95B4-31427ACE5B70}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{19820B5F-AE0B-4D85-95B4-31427ACE5B70}.Debug|x86.Build.0 = Debug|Any CPU
+		{19820B5F-AE0B-4D85-95B4-31427ACE5B70}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{19820B5F-AE0B-4D85-95B4-31427ACE5B70}.Release|Any CPU.Build.0 = Release|Any CPU
+		{19820B5F-AE0B-4D85-95B4-31427ACE5B70}.Release|x64.ActiveCfg = Release|Any CPU
+		{19820B5F-AE0B-4D85-95B4-31427ACE5B70}.Release|x64.Build.0 = Release|Any CPU
+		{19820B5F-AE0B-4D85-95B4-31427ACE5B70}.Release|x86.ActiveCfg = Release|Any CPU
+		{19820B5F-AE0B-4D85-95B4-31427ACE5B70}.Release|x86.Build.0 = Release|Any CPU
+		{C4B34581-1DCD-49D1-BB46-6DCE5CEC2594}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C4B34581-1DCD-49D1-BB46-6DCE5CEC2594}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C4B34581-1DCD-49D1-BB46-6DCE5CEC2594}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{C4B34581-1DCD-49D1-BB46-6DCE5CEC2594}.Debug|x64.Build.0 = Debug|Any CPU
+		{C4B34581-1DCD-49D1-BB46-6DCE5CEC2594}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{C4B34581-1DCD-49D1-BB46-6DCE5CEC2594}.Debug|x86.Build.0 = Debug|Any CPU
+		{C4B34581-1DCD-49D1-BB46-6DCE5CEC2594}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C4B34581-1DCD-49D1-BB46-6DCE5CEC2594}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C4B34581-1DCD-49D1-BB46-6DCE5CEC2594}.Release|x64.ActiveCfg = Release|Any CPU
+		{C4B34581-1DCD-49D1-BB46-6DCE5CEC2594}.Release|x64.Build.0 = Release|Any CPU
+		{C4B34581-1DCD-49D1-BB46-6DCE5CEC2594}.Release|x86.ActiveCfg = Release|Any CPU
+		{C4B34581-1DCD-49D1-BB46-6DCE5CEC2594}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
+		{7868E064-C2D3-48E9-BB5A-01F4041E61F3} = {2B3C4D5E-6F78-90AB-12CD-34EF56789012}
 		{12E48302-6991-4257-9649-7EBE5025444F} = {1A2B3C4D-5E6F-7890-AB12-CD34EF567890}
-		{6E6C9D00-1F49-41F2-BE4C-BF23F509E06E} = {1A2B3C4D-5E6F-7890-AB12-CD34EF567890}
+		{6E6C9D00-1F49-41F2-BE4C-BF23F509E06E} = {2B3C4D5E-6F78-90AB-12CD-34EF56789012}
 		{A1B2C3D4-E5F6-7890-ABCD-EF1234567890} = {1A2B3C4D-5E6F-7890-AB12-CD34EF567890}
-		{B2C3D4E5-F6A7-8901-BCDE-F23456789012} = {1A2B3C4D-5E6F-7890-AB12-CD34EF567890}
-		{C3D4E5F6-A7B8-9012-CDEF-345678901234} = {1A2B3C4D-5E6F-7890-AB12-CD34EF567890}
+		{B2C3D4E5-F6A7-8901-BCDE-F23456789012} = {CC28565E-FA51-41F3-BA10-E8823462B865}
+		{C3D4E5F6-A7B8-9012-CDEF-345678901234} = {CC28565E-FA51-41F3-BA10-E8823462B865}
 		{D4E5F6A7-B8C9-0123-DEF0-456789ABCDEF} = {2B3C4D5E-6F78-90AB-12CD-34EF56789012}
 		{076B29CF-41EC-45D1-A242-DACF6753FCCC} = {2B3C4D5E-6F78-90AB-12CD-34EF56789012}
 		{9546517F-92D0-FF56-3E5B-97099F8B46A3} = {2B3C4D5E-6F78-90AB-12CD-34EF56789012}
-		{8BB24B23-B834-E1DF-3CB4-C6E497C199A2} = {1A2B3C4D-5E6F-7890-AB12-CD34EF567890}
-		{6E53C842-1487-48BA-DA55-E26E8A04FBD1} = {1A2B3C4D-5E6F-7890-AB12-CD34EF567890}
+		{8BB24B23-B834-E1DF-3CB4-C6E497C199A2} = {7868E064-C2D3-48E9-BB5A-01F4041E61F3}
+		{6E53C842-1487-48BA-DA55-E26E8A04FBD1} = {7868E064-C2D3-48E9-BB5A-01F4041E61F3}
 		{4EC33CA3-51EA-2490-ABAC-FC047924346A} = {3C4D5E6F-7890-AB12-CD34-EF5678901234}
 		{65AC57AC-E65A-94EE-9E3E-E4916798798A} = {3C4D5E6F-7890-AB12-CD34-EF5678901234}
 		{5414DDD0-A423-2405-AB2A-739BAA0FAF68} = {3C4D5E6F-7890-AB12-CD34-EF5678901234}
@@ -628,6 +691,10 @@ Global
 		{A7C3BE0A-ED0B-465A-9ED2-99FBDB791A44} = {3C4D5E6F-7890-AB12-CD34-EF5678901234}
 		{3ECEE969-A703-44C7-A084-AA685991A454} = {4D5E6F78-90AB-12CD-34EF-567890123456}
 		{EFB3100E-0B1D-41EC-BAD4-C79B42481E57} = {4D5E6F78-90AB-12CD-34EF-567890123456}
+		{3B857B22-5ECF-47E7-8926-9408D1C5AF21} = {4447D44B-4E3D-49F2-82D1-BB5CBBDB7D8F}
+		{710B690F-A845-49E5-9292-AEE1AA8A9A24} = {4447D44B-4E3D-49F2-82D1-BB5CBBDB7D8F}
+		{19820B5F-AE0B-4D85-95B4-31427ACE5B70} = {4447D44B-4E3D-49F2-82D1-BB5CBBDB7D8F}
+		{C4B34581-1DCD-49D1-BB46-6DCE5CEC2594} = {4447D44B-4E3D-49F2-82D1-BB5CBBDB7D8F}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {5E6F7890-AB12-CD34-EF56-789012345678}
diff --git a/docs/architecture.md b/docs/architecture.md
index 94436ea9..cf40bf28 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -6,17 +6,17 @@ This document describes the solution structure, dependency graph, design pattern
 
 ## 1. Solution Overview
 
-The solution contains 39 projects organized into seven solution folders:
+The solution contains 43 projects organized around package boundaries, demos, and tests:
 
 | Folder | Projects | Purpose |
 |--------|----------|---------|
-| **Core** | FrameworkInterfaces, FrameworkUI, Themes | Application shell, contracts, and theme system |
-| **Controls** | GenericControls, NumericControls, OxyPlotControls, DatabaseControls, ExpressionParserControls, DAGControls | Reusable WPF control libraries |
+| **Core** | FrameworkInterfaces, Themes | Contracts and theme system |
+| **Controls** | FrameworkUI, GenericControls, NumericControls, OxyPlotControls, DatabaseControls, ExpressionParserControls, DAGControls, Xceed.Wpf.AvalonDock, Xceed.Wpf.AvalonDock.Themes.VS2013 | Application shell, reusable WPF controls, and docking UI |
 | **Models** | DatabaseManager, ExpressionParser, OxyPlot, OxyPlot.Wpf, OxyPlot.Wpf.Shared, DAG | Non-UI logic and vendored forks |
 | **Support** | SoftwareUpdate, SoftwareUpdate.Updater | Auto-update from GitHub Releases |
-| **AvalonDock** | Xceed.Wpf.AvalonDock, Xceed.Wpf.AvalonDock.Themes.VS2013 | Modified docking layout engine |
 | **Demos** | FrameworkUI.Demo, GenericControls.Demo, NumericControls.Demo, OxyPlotControls.Demo, DatabaseControls.Demo, ExpressionParserControls.Demo, DAG.Demo | Standalone demo applications |
 | **Tests** | OxyPlot.ExampleLibrary + 13 test projects | Example chart models and unit/integration tests |
+| **Packaging** | RMC.Wpf.Framework.Core, RMC.Wpf.Framework.Models, RMC.Wpf.Framework.Support, RMC.Wpf.Framework.Controls | NuGet bundle projects |
 
 ## 2. Dependency Diagram
 
@@ -25,7 +25,7 @@ The following diagram shows the dependency relationships between the main librar
 ```
                           External
                         +-----------+
-                        | Numerics  |
+                        |RMC.Numerics|
                         +-----+-----+
                               |
           +-------------------+-------------------+
@@ -74,6 +74,19 @@ The following diagram shows the dependency relationships between the main librar
 
 **Leaf dependencies** (no internal project references): FrameworkInterfaces, Themes, DAG, ExpressionParser, OxyPlot.
 
+## 2.1 NuGet Package Map
+
+The packaging projects in `src/Packaging/` create four bundles. Packages should follow this dependency order:
+
+| Package | Included assemblies/content | Package dependencies |
+|---------|-----------------------------|----------------------|
+| `RMC.Wpf.Framework.Core` | FrameworkInterfaces, Themes | None |
+| `RMC.Wpf.Framework.Models` | DAG, DatabaseManager, ExpressionParser, OxyPlot, OxyPlot.Wpf, OxyPlot.Wpf.Shared | ClosedXML, DocumentFormat.OpenXml, ExcelNumberFormat, FastMember, SourceGear.sqlite3, System.Data.SQLite |
+| `RMC.Wpf.Framework.Support` | SoftwareUpdate plus SoftwareUpdate.Updater content files | None |
+| `RMC.Wpf.Framework.Controls` | FrameworkUI, GenericControls, NumericControls, OxyPlotControls, DatabaseControls, ExpressionParserControls, DAGControls, Xceed.Wpf.AvalonDock, Xceed.Wpf.AvalonDock.Themes.VS2013 | `RMC.Wpf.Framework.Core`, `RMC.Wpf.Framework.Models`, `RMC.Wpf.Framework.Support`, `RMC.Numerics` 2.x |
+
+AvalonDock is a vendored UI dependency and is packaged with `RMC.Wpf.Framework.Controls`, not Core. `RMC.Numerics` is consumed as a NuGet package through central package management and should not be referenced through local `HintPath` DLLs. Source builds use the floating `2.*` version, while packages declare a compatible `[2.1.1,3.0.0)` dependency range.
+
 ## 3. Core Framework
 
 ### FrameworkInterfaces
@@ -124,9 +137,9 @@ Standalone theme resource library with no internal dependencies.
 | Library | Key Controls | Dependencies |
 |---------|-------------|--------------|
 | **GenericControls** | `NumericTextBox`, `NameTextBox`, `ColorPicker`, `CopyPasteDataGrid`, `MessageBox`, `NameDialog`, `ExplorerTreeView` | Themes |
-| **NumericControls** | `DistributionSelector`, `ParameterControl`, `ProbabilityCurveEditor`, `TimeSeriesDataGrid` | GenericControls, OxyPlotControls, Themes, Numerics (external) |
+| **NumericControls** | `DistributionSelector`, `ParameterControl`, `ProbabilityCurveEditor`, `TimeSeriesDataGrid` | GenericControls, OxyPlotControls, Themes, RMC.Numerics |
 | **OxyPlotControls** | `OxyPlotToolbar`, `OxyPlotPropertiesControl`, `PlotSeriesEditor`, `AxisPropertiesControl` | GenericControls, Themes, OxyPlot, OxyPlot.Wpf |
-| **DatabaseControls** | `DatabaseTableViewer`, `FieldCalculator`, `ExpressionEditorControl` | DatabaseManager, ExpressionParser, ExpressionParserControls, GenericControls, OxyPlotControls, Themes, Numerics (external) |
+| **DatabaseControls** | `DatabaseTableViewer`, `FieldCalculator`, `ExpressionEditorControl` | DatabaseManager, ExpressionParser, ExpressionParserControls, GenericControls, OxyPlotControls, Themes, RMC.Numerics |
 | **ExpressionParserControls** | `ExpressionEditorControl`, `FunctionBrowser`, `SyntaxHighlighter` | ExpressionParser, GenericControls, Themes |
 | **DAGControls** | `FlowGraphCanvas`, `NodeView`, `ConnectorView`, `ConnectionView` | DAG |
 
@@ -147,6 +160,11 @@ Standalone theme resource library with no internal dependencies.
 |---------|---------|
 | **SoftwareUpdate** | `IUpdateService` interface, `GitHubUpdateService`, `UpdateOptions`, `SemanticVersion`. Checks GitHub Releases for newer versions, downloads and extracts update assets. |
 | **SoftwareUpdate.Updater** | Standalone executable that applies updates. Waits for the parent process to exit, replaces files, and restarts the application. |
+
+### Vendored UI Libraries
+
+| Library | Purpose |
+|---------|---------|
 | **Xceed.Wpf.AvalonDock** | Modified fork of Xceed AvalonDock. Key modifications: `ContentPresenter` replaced with `ContentControl` for `LayoutItem.View` bindings (.NET 9+ fix), last `LayoutDocumentPane` protection in `CreateFloatingWindowCore`. |
 | **Xceed.Wpf.AvalonDock.Themes.VS2013** | Visual Studio 2013 theme for AvalonDock. Blue, Dark, and Light variants. Uses `DynamicResource` bindings to the Themes color keys. |
 
@@ -199,7 +217,7 @@ Key additions beyond upstream:
 
 | Dependency | Source | Purpose |
 |-----------|--------|---------|
-| **Numerics** | [USACE-RMC/Numerics](https://github.com/USACE-RMC/Numerics) (cloned alongside this repo) | Statistical distributions, parameter estimation, bootstrap analysis. Required by NumericControls and DatabaseControls. Must be built separately. |
+| **RMC.Numerics** | [USACE-RMC/Numerics](https://github.com/USACE-RMC/Numerics) NuGet package, latest compatible 2.x | Statistical distributions, parameter estimation, bootstrap analysis. Required by NumericControls and DatabaseControls. |
 
 All other dependencies are either vendored into the solution (AvalonDock, OxyPlot) or available as NuGet packages (System.Data.SQLite, DocumentFormat.OpenXml, etc.).
 
diff --git a/docs/critical-review-implementation-plan.md b/docs/critical-review-implementation-plan.md
deleted file mode 100644
index f0366474..00000000
--- a/docs/critical-review-implementation-plan.md
+++ /dev/null
@@ -1,207 +0,0 @@
-# Critical Review And Implementation Plan
-
-Review date: 2026-05-01  
-Scope: all tracked C# libraries under `src/`, excluding generated build output and `.claude/worktrees`.
-
-## Context Notes
-
-- No tracked or workspace `Claude.md`, `CLAUDE.md`, or `claude.md` files were found. I used `README.md`, `docs/architecture.md`, the solution file, project references, tests, and source review to orient.
-- Baseline verification before changes:
-  - `dotnet build WPF-Framework.sln --no-restore --configuration Debug --verbosity minimal` passed with 0 warnings and 0 errors.
-  - `dotnet test WPF-Framework.sln --no-restore --configuration Debug --verbosity minimal` passed, with about 6815 tests passing and 6 skipped.
-- Review focus: critical bugs only: data loss, security/destructive injection, corrupted installs, or silent data corruption.
-- No implementation changes are approved yet.
-
-## Approval Checklist
-
-Use this section for review feedback.
-
-- [ ] Approve all listed fixes.
-- [ ] Approve only issue DB-001.
-- [ ] Approve only issue DB-002.
-- [ ] Approve only issue UPD-001.
-- [ ] Approve only issue DB-003.
-- [ ] Hold issue DB-001.
-- [ ] Hold issue DB-002.
-- [ ] Hold issue UPD-001.
-- [ ] Hold issue DB-003.
-- [ ] Revise scope or approach before implementation.
-
-Reviewer notes:
-
-```text
-
-```
-
-## Critical Findings
-
-### DB-001: DBF table edits can permanently delete the database if replacement fails
-
-Status: proposed  
-Severity: P0 data loss  
-Primary files:
-
-- `src/DatabaseManager/DBFReader.cs:625`
-- `src/DatabaseManager/DBFReader.cs:705`
-- `src/DatabaseManager/DBFReader.cs:1573`
-- `src/DatabaseManager/DBFReader.cs:1679`
-- `src/DatabaseManager/DBFReader.cs:1794`
-- `src/DatabaseManager/DBFReader.cs:1904`
-- `src/DatabaseManager/DBFReader.cs:2014`
-- `src/DatabaseManager/DBFReader.cs:2125`
-- `src/DatabaseManager/DBFReader.cs:2233`
-- `src/DatabaseManager/DBFReader.cs:2341`
-- `src/DatabaseManager/DBFReader.cs:2458`
-- `src/DatabaseManager/DBFReader.cs:2581`
-
-Evidence:
-
-Multiple DBF mutation paths create a temp DBF, then call `File.Delete(_parentDatabase.DataBasePath)` before `File.Copy(tmpdbf, _parentDatabase.DataBasePath)`. If the copy fails after deletion due to disk space, permissions, antivirus locking, process interruption, or file-system failure, the original database is gone.
-
-Implementation plan:
-
-1. Add a private safe-replacement helper in `DBFReader`.
-2. Keep the original DBF in place until the replacement file is fully written and ready.
-3. Use `File.Replace(tempPath, targetPath, backupPath, ignoreMetadataErrors: true)` when the target exists.
-4. Use a same-directory move only for new targets.
-5. Clean up temp and backup files in `finally`, preserving the backup if replacement fails.
-6. Replace all DBF delete/copy mutation call sites with the helper.
-7. Add tests around row deletion, column deletion, and column addition to confirm outputs remain valid and that failure leaves the original intact where feasible.
-
-Acceptance criteria:
-
-- No DBF mutation path deletes the target before a successful replacement.
-- Existing DBF edit tests still pass.
-- New tests cover at least one failure path and representative edit paths.
-
-### DB-002: SQLite table and column identifiers are interpolated without safe quoting
-
-Status: proposed  
-Severity: P0 data integrity/security  
-Primary files:
-
-- `src/DatabaseManager/SQLiteManager.cs:415`
-- `src/DatabaseManager/SQLiteManager.cs:576`
-- `src/DatabaseManager/SQLiteManager.cs:698`
-- `src/DatabaseManager/SQLiteManager.cs:846`
-- `src/DatabaseManager/SQLiteManager.cs:1402`
-- `src/DatabaseManager/SQLiteManager.cs:1759`
-- `src/DatabaseManager/SQLiteManager.cs:1868`
-- `src/DatabaseManager/SQLiteManager.cs:1902`
-- `src/DatabaseManager/SQLiteManager.cs:2003`
-- `src/DatabaseManager/SQLiteManager.cs:2531`
-- `src/DatabaseManager/DatabaseManager.cs:237`
-
-Evidence:
-
-SQLite identifiers are assembled as `[` + name + `]` in many schema and update statements. Names are accepted from external sources such as CSV headers and table names. A name containing `]`, quotes, reserved words, or SQL punctuation can break SQL, target the wrong object, or potentially execute destructive extra statements through `ExecuteNonQuery`. Some write paths also derive parameter names directly from user column names, which fails for spaces and special characters.
-
-Implementation plan:
-
-1. Add a central `QuoteIdentifier(string identifier)` helper using SQLite double-quoted identifiers and escaped embedded quotes.
-2. Validate null or empty identifiers explicitly.
-3. Replace direct bracket concatenation for table names, temp table names, and column names.
-4. Stop generating parameter names from column names; use stable generated names such as `@p0`, `@p1`, `@cellValue`, and `@rowId`.
-5. Prefer parameterized `rowid` predicates where practical, even though current `rowid` sources are internal.
-6. Add tests for names with spaces, dashes, reserved words, `]`, `"`, and injection-like text across create, save, append, edit, read, add-column, and delete-column paths.
-
-Acceptance criteria:
-
-- SQLite schema and data operations work with quoted/special table and column names.
-- Injection-like names are stored as identifiers, not interpreted as SQL.
-- Existing SQLite tests still pass.
-
-### UPD-001: Updater can leave a mixed-version installation after partial extraction
-
-Status: proposed  
-Severity: P1 install integrity/data loss  
-Primary files:
-
-- `src/SoftwareUpdate.Updater/InstallationManager.cs:131`
-- `src/SoftwareUpdate.Updater/InstallationManager.cs:181`
-- `src/SoftwareUpdate.Updater/InstallationManager.cs:199`
-- `src/SoftwareUpdate.Updater/InstallationManager.cs:246`
-- `src/SoftwareUpdate.Updater/InstallationManager.cs:285`
-
-Evidence:
-
-The updater backs up the target directory, then extracts files directly into the live target. If extraction fails after writing new files, rollback copies backup files over the target but does not remove newly-created files from the failed package. A successful update also does not remove stale files that disappeared from the new package. This can leave assemblies/resources from different versions side by side. There is also a related root-folder stripping edge case: root detection accepts `/` and `\`, but stripping uses only `/`.
-
-Implementation plan:
-
-1. Extract and validate the update archive into a staging directory, not the live target.
-2. Normalize archive separators before root-folder stripping and path traversal checks.
-3. Validate every entry path before copying anything into the target.
-4. Apply the staged update in a controlled replace step: backup target, clear intended target contents, copy staging contents in.
-5. On failure, restore from backup and remove files that were not present in the backup.
-6. Add tests for partial extraction failure, new-file rollback, stale-file cleanup, traversal protection, backup-directory skipping, and backslash root-folder packages.
-
-Acceptance criteria:
-
-- A failed update restores the exact previous target contents, except intentional updater/log exclusions if documented.
-- A successful update does not leave stale files from the previous version.
-- Existing updater tests still pass.
-
-### DB-003: DBF export can filter the wrong columns and delete an existing export before a successful write
-
-Status: proposed  
-Severity: P1 data export integrity  
-Primary file:
-
-- `src/DatabaseManager/DataTableView.cs:2688`
-- `src/DatabaseManager/DataTableView.cs:2725`
-- `src/DatabaseManager/DataTableView.cs:2728`
-
-Evidence:
-
-`ExportToDBF` filters selected columns by checking `_columnTypes[i]` instead of `_columnTypes[columnIndicesToExport[i]]`. When exporting a subset or reordered list of columns, the method can include unsupported fields or omit valid fields. The method also reads `rowIndicesToExport[0]`, which crashes for an empty selection, and deletes an existing output file before the new DBF is successfully created.
-
-Implementation plan:
-
-1. Change the filter to inspect `_columnTypes[columnIndicesToExport[i]]`.
-2. Define empty-row export behavior and test it. Preferred behavior: create a valid DBF schema with zero rows.
-3. Write export output to a temp file in the destination directory.
-4. Replace the requested output only after the temp DBF is successfully created and validated.
-5. Add tests for subset export, reordered export, unsupported skipped types, empty row export, and failed export preserving an existing target where feasible.
-
-Acceptance criteria:
-
-- Exported DBF columns match the requested supported columns.
-- Empty row selections do not crash.
-- Existing export targets are preserved if export creation fails.
-
-## Reviewed With No Critical Findings
-
-No critical issues crossed the review threshold in these areas during this pass:
-
-- `FrameworkInterfaces`
-- `FrameworkUI`
-- `Themes`
-- `DAG` and `DAGControls`
-- `ExpressionParser` and `ExpressionParserControls`
-- `DatabaseControls`
-- `GenericControls`
-- `NumericControls`
-- `OxyPlotControls`
-- Vendored `AvalonDock`
-- Vendored `OxyPlot`
-
-Non-critical issues were intentionally not added to this plan.
-
-## Proposed Execution Order
-
-1. Implement DB-001 first because it is the highest direct data-loss risk.
-2. Implement DB-002 next because it touches many SQLite paths and should be tested broadly.
-3. Implement UPD-001 after database fixes because it changes update transaction semantics.
-4. Implement DB-003 last because it is narrower and mostly isolated to export behavior.
-5. Run targeted tests after each issue, then full `dotnet build` and `dotnet test` at the end.
-
-## Final Verification Plan
-
-After approved implementation:
-
-1. Run focused database tests.
-2. Run focused updater tests.
-3. Run `dotnet build WPF-Framework.sln --no-restore --configuration Debug --verbosity minimal`.
-4. Run `dotnet test WPF-Framework.sln --no-restore --configuration Debug --verbosity minimal`.
-5. Summarize changed files, risk reduction, and any remaining test gaps.
diff --git a/docs/database-controls.md b/docs/database-controls.md
index 210807a5..b6426732 100644
--- a/docs/database-controls.md
+++ b/docs/database-controls.md
@@ -72,14 +72,14 @@ public abstract class DataTableView
     public int NumberOfRows { get; }
 
     // Cell access
-    public abstract object GetValue(int column, int row);
-    public abstract void SetValue(int column, int row, object value);
+    public object GetCell(int columnIndex, int rowIndex);
+    public void EditCell(int rowIndex, int columnIndex, object value);
 
     // Editing
     public void ApplyEdits();       // Commit pending edits to storage
     public void CancelEdits();      // Discard pending edits
-    public void Undo();             // Undo the last edit
-    public void Redo();             // Redo the last undone edit
+    public void UndoEdit();         // Undo the last edit
+    public void RedoEdit();         // Redo the last undone edit
 
     // Structural operations
     public void AddRow();
@@ -129,7 +129,7 @@ var mem = new InMemoryReader(dt);
 
 ### Edit Tracking with Undo/Redo
 
-`DataTableView` maintains an internal edit stack with an index pointer. All cell, row, and column modifications are recorded as `TableEdit` objects. Calling `Undo()` decrements the pointer; `Redo()` increments it. When a new edit is made after undoing, all edits beyond the current pointer are discarded.
+`DataTableView` maintains an internal edit stack with an index pointer. All cell, row, and column modifications are recorded as `TableEdit` objects. Calling `UndoEdit()` decrements the pointer; `RedoEdit()` increments it. When a new edit is made after undoing, all edits beyond the current pointer are discarded.
 
 Edit types include `CellEdit`, `MultiCellEdit`, `AddRowEdit`, `DeleteRowEdit`, `AddColumnEdit`, `DeleteColumnEdit`, and their batch variants (`AddRowsEdit`, `DeleteRowsEdit`, etc.).
 
@@ -163,7 +163,7 @@ A column-scoped search dialog with support for:
 
 Displays summary statistics for a selected column. Automatically determines the appropriate statistics panel based on the column data type:
 
-- **Numeric columns** (`NumericColumnStats`) -- count, minimum, maximum, mean, standard deviation, and additional statistical measures powered by the external Numerics library
+- **Numeric columns** (`NumericColumnStats`) -- count, minimum, maximum, mean, standard deviation, and additional statistical measures powered by the RMC.Numerics package
 - **Text columns** (`AlphabeticColumnStats`) -- count, unique values, and frequency distribution
 
 Statistics can be filtered to selected rows only.
@@ -286,7 +286,7 @@ A browsable list of all parser functions. Supports inserting a selected function
 
 | Dependency | Type | Used By |
 |---|---|---|
-| [Numerics](https://github.com/USACE-RMC/Numerics) | External DLL | ColumnStatsWindow (statistical distributions) |
+| [RMC.Numerics](https://github.com/USACE-RMC/Numerics) | NuGet package | ColumnStatsWindow (statistical distributions) |
 | GenericControls | Project | MessageBox, MetroWindow, property controls |
 | Themes | Project | Theme colors and styles |
 | OxyPlot / OxyPlot.Wpf | Project | Chart rendering in table viewer |
diff --git a/docs/getting-started.md b/docs/getting-started.md
index c496c73b..58ca6599 100644
--- a/docs/getting-started.md
+++ b/docs/getting-started.md
@@ -24,9 +24,17 @@ Create a new WPF Application project targeting `net10.0-windows`. Enable `UseWPF
 </Project>
 ```
 
-## 3. Add Project References
+## 3. Add Framework References
 
-Add `ProjectReference` entries for the framework libraries. At minimum, you need FrameworkInterfaces, FrameworkUI, and Themes:
+For NuGet consumption, reference the Controls bundle. It brings in Core, Models, Support, and RMC.Numerics transitively:
+
+```xml
+<ItemGroup>
+  <PackageReference Include="RMC.Wpf.Framework.Controls" Version="1.0.0" />
+</ItemGroup>
+```
+
+For source development inside this repository, add `ProjectReference` entries for the framework libraries. At minimum, you need FrameworkInterfaces, FrameworkUI, and Themes:
 
 ```xml
 <ItemGroup>
diff --git a/docs/numeric-controls.md b/docs/numeric-controls.md
index a2fc2b44..dbc038b1 100644
--- a/docs/numeric-controls.md
+++ b/docs/numeric-controls.md
@@ -21,7 +21,7 @@ xmlns:uni="clr-namespace:NumericControls.Distributions.Univariate;assembly=Numer
 
 ## Dependencies
 
-NumericControls depends on several framework libraries and one external dependency:
+NumericControls depends on several framework libraries and one NuGet dependency:
 
 | Dependency | Type | Description |
 |------------|------|-------------|
@@ -29,7 +29,7 @@ NumericControls depends on several framework libraries and one external dependen
 | **OxyPlotControls** | Project reference | Plot integration for distribution and curve visualization |
 | **Themes** | Project reference | Theme-aware styling and runtime theme switching |
 | **OxyPlot / OxyPlot.Wpf** | Project reference | Chart rendering for PDF plots and curve previews |
-| **[Numerics](https://github.com/USACE-RMC/Numerics)** | External DLL | Statistical distribution types, ordered data structures, time series, and sampling utilities. Must be built separately from a sibling clone of the Numerics repository. |
+| **[RMC.Numerics](https://github.com/USACE-RMC/Numerics)** | NuGet package | Statistical distribution types, ordered data structures, time series, and sampling utilities. Version is centrally managed in `Directory.Packages.props`. |
 
 ---
 
@@ -260,13 +260,13 @@ The **NumericControls.Demo** project (`src/NumericControls.Demo/`) provides a wo
 dotnet run --project src/NumericControls.Demo/NumericControls.Demo.csproj
 ```
 
-> **Note:** The NumericControls.Demo requires the external Numerics DLL to be built and available at its HintPath location. Clone the [Numerics](https://github.com/USACE-RMC/Numerics) repository alongside WPF-Framework and build it first.
+> **Note:** The NumericControls.Demo restores [RMC.Numerics](https://github.com/USACE-RMC/Numerics) from NuGet through central package management.
 
 ---
 
 ## Best Practices and Troubleshooting
 
-1. **Build Numerics first.** NumericControls depends on the external Numerics library. If the Numerics DLL is missing, distribution selectors will have empty dropdowns and curve editors will not function.
+1. **Restore packages first.** NumericControls depends on the RMC.Numerics package. If package restore has not run, distribution selectors and curve editors will not build.
 
 2. **Use two-way binding** on `SelectedDistribution`, `SelectedOrderedData`, `SelectedUncertainOrderedData`, and `Series` properties to ensure the control writes changes back to your view model.
 
diff --git a/scripts/pack-wpf-framework.ps1 b/scripts/pack-wpf-framework.ps1
new file mode 100644
index 00000000..940d97b5
--- /dev/null
+++ b/scripts/pack-wpf-framework.ps1
@@ -0,0 +1,96 @@
+param(
+    [string]$Configuration = "Release",
+    [string]$OutputDirectory = "artifacts/packages",
+    [switch]$SkipRestore,
+    [switch]$SkipBuild
+)
+
+$ErrorActionPreference = "Stop"
+
+$repoRoot = Resolve-Path (Join-Path $PSScriptRoot "..")
+$outputPath = Join-Path $repoRoot $OutputDirectory
+New-Item -ItemType Directory -Force -Path $outputPath | Out-Null
+
+if (-not $SkipRestore) {
+    & dotnet restore (Join-Path $repoRoot "WPF-Framework.sln")
+    if ($LASTEXITCODE -ne 0) {
+        throw "Restore failed before packing."
+    }
+}
+
+if (-not $SkipBuild) {
+    & dotnet build (Join-Path $repoRoot "WPF-Framework.sln") -c $Configuration --no-restore
+    if ($LASTEXITCODE -ne 0) {
+        throw "Build failed before packing."
+    }
+}
+
+$packageProjects = @(
+    "src/Packaging/RMC.Wpf.Framework.Core/RMC.Wpf.Framework.Core.csproj",
+    "src/Packaging/RMC.Wpf.Framework.Models/RMC.Wpf.Framework.Models.csproj",
+    "src/Packaging/RMC.Wpf.Framework.Support/RMC.Wpf.Framework.Support.csproj",
+    "src/Packaging/RMC.Wpf.Framework.Controls/RMC.Wpf.Framework.Controls.csproj"
+)
+
+foreach ($project in $packageProjects) {
+    & dotnet pack (Join-Path $repoRoot $project) -c $Configuration --no-build --no-restore -o $outputPath
+    if ($LASTEXITCODE -ne 0) {
+        throw "Package creation failed for $project."
+    }
+}
+
+Add-Type -AssemblyName System.IO.Compression.FileSystem
+
+$expectedEntries = @{
+    "RMC.Wpf.Framework.Core" = @(
+        "lib/net10.0-windows7.0/FrameworkInterfaces.dll",
+        "lib/net10.0-windows7.0/Themes.dll")
+    "RMC.Wpf.Framework.Models" = @(
+        "lib/net10.0-windows7.0/DAG.dll",
+        "lib/net10.0-windows7.0/DatabaseManager.dll",
+        "lib/net10.0-windows7.0/ExpressionParser.dll",
+        "lib/net10.0-windows7.0/OxyPlot.dll",
+        "lib/net10.0-windows7.0/OxyPlot.Wpf.dll",
+        "lib/net10.0-windows7.0/OxyPlot.Wpf.Shared.dll")
+    "RMC.Wpf.Framework.Support" = @(
+        "lib/net10.0-windows7.0/SoftwareUpdate.dll",
+        "contentFiles/any/net10.0-windows7.0/SoftwareUpdate.Updater.exe",
+        "contentFiles/any/net10.0-windows7.0/SoftwareUpdate.Updater.dll",
+        "contentFiles/any/net10.0-windows7.0/SoftwareUpdate.Updater.deps.json",
+        "contentFiles/any/net10.0-windows7.0/SoftwareUpdate.Updater.runtimeconfig.json")
+    "RMC.Wpf.Framework.Controls" = @(
+        "lib/net10.0-windows7.0/GenericControls.dll",
+        "lib/net10.0-windows7.0/FrameworkUI.dll",
+        "lib/net10.0-windows7.0/DAGControls.dll",
+        "lib/net10.0-windows7.0/DatabaseControls.dll",
+        "lib/net10.0-windows7.0/ExpressionParserControls.dll",
+        "lib/net10.0-windows7.0/NumericControls.dll",
+        "lib/net10.0-windows7.0/OxyPlotControls.dll",
+        "lib/net10.0-windows7.0/Xceed.Wpf.AvalonDock.dll",
+        "lib/net10.0-windows7.0/Xceed.Wpf.AvalonDock.Themes.VS2013.dll")
+}
+
+foreach ($packageId in $expectedEntries.Keys) {
+    $package = Get-ChildItem -Path $outputPath -Filter "$packageId.*.nupkg" |
+        Sort-Object LastWriteTime -Descending |
+        Select-Object -First 1
+
+    if ($package -eq $null) {
+        throw "Missing package for $packageId."
+    }
+
+    $zip = [System.IO.Compression.ZipFile]::OpenRead($package.FullName)
+    try {
+        $entries = @($zip.Entries | ForEach-Object { $_.FullName })
+        foreach ($expectedEntry in $expectedEntries[$packageId]) {
+            if ($entries -notcontains $expectedEntry) {
+                throw "$($package.Name) is missing $expectedEntry."
+            }
+        }
+    }
+    finally {
+        $zip.Dispose()
+    }
+}
+
+Write-Host "Packed and validated $($expectedEntries.Count) RMC WPF Framework packages in $outputPath."
diff --git a/scripts/validate-code-xml-docs.ps1 b/scripts/validate-code-xml-docs.ps1
new file mode 100644
index 00000000..549b0bf3
--- /dev/null
+++ b/scripts/validate-code-xml-docs.ps1
@@ -0,0 +1,174 @@
+param(
+    [string]$Configuration = "Debug",
+    [switch]$SkipBuild
+)
+
+$ErrorActionPreference = "Stop"
+
+$repoRoot = Resolve-Path (Join-Path $PSScriptRoot "..")
+$failures = New-Object System.Collections.Generic.List[string]
+
+function Get-RelativePath([string]$Path) {
+    $root = (Resolve-Path $repoRoot).Path.TrimEnd('\', '/')
+    $resolved = (Resolve-Path $Path).Path
+    if ($resolved.StartsWith($root, [System.StringComparison]::OrdinalIgnoreCase)) {
+        return $resolved.Substring($root.Length).TrimStart('\', '/').Replace("\", "/")
+    }
+
+    return $resolved.Replace("\", "/")
+}
+
+function Add-Failure([string]$Message) {
+    [void]$failures.Add($Message)
+}
+
+$codeRoots = @(
+    "src/DAG",
+    "src/DAG.Demo",
+    "src/DAGControls",
+    "src/DatabaseControls",
+    "src/DatabaseControls.Demo",
+    "src/DatabaseManager",
+    "src/ExpressionParser",
+    "src/ExpressionParserControls",
+    "src/ExpressionParserControls.Demo",
+    "src/FrameworkInterfaces",
+    "src/FrameworkUI",
+    "src/FrameworkUI.Demo",
+    "src/GenericControls",
+    "src/GenericControls.Demo",
+    "src/NumericControls",
+    "src/NumericControls.Demo",
+    "src/OxyPlotControls",
+    "src/OxyPlotControls.Demo",
+    "src/SoftwareUpdate",
+    "src/SoftwareUpdate.Updater",
+    "src/Themes"
+)
+
+$sourceFiles = @(foreach ($root in $codeRoots) {
+    $path = Join-Path $repoRoot $root
+    if (Test-Path $path) {
+        Get-ChildItem -Path $path -Recurse -Filter *.cs -File |
+            Where-Object { $_.FullName -notmatch '[\\/](bin|obj)[\\/]' }
+    }
+})
+
+function Test-HasXmlDocumentation($lines, [int]$index) {
+    $j = $index - 1
+    while ($j -ge 0 -and [string]::IsNullOrWhiteSpace($lines[$j])) {
+        $j--
+    }
+
+    if ($j -ge 0 -and $lines[$j].Trim().EndsWith("]")) {
+        $depth = 0
+        while ($j -ge 0) {
+            $trimmed = $lines[$j].Trim()
+            if ($trimmed.EndsWith("]")) {
+                $depth++
+            }
+
+            if ($trimmed.StartsWith("[")) {
+                $depth--
+            }
+
+            $j--
+            while ($j -ge 0 -and
+                ([string]::IsNullOrWhiteSpace($lines[$j]) -or
+                ($lines[$j].TrimStart().StartsWith("//") -and -not $lines[$j].TrimStart().StartsWith("///")))) {
+                $j--
+            }
+
+            if ($depth -le 0 -and ($j -lt 0 -or -not $lines[$j].Trim().EndsWith("]"))) {
+                break
+            }
+        }
+    }
+
+    return ($j -ge 0 -and $lines[$j].TrimStart().StartsWith("///"))
+}
+
+$documentedMemberFiles = @($sourceFiles | Where-Object {
+    $_.Name -notmatch '\.(Designer|g|g\.i)\.cs$'
+})
+
+$accessModifier = '(?:public|internal|private|protected|file)(?:\s+(?:internal|protected))?'
+$typeDeclaration = [regex]("^\s*$accessModifier\s+(?:(?:abstract|sealed|static|partial|readonly|unsafe|new|ref)\s+)*(?:class|struct|interface|enum|record(?:\s+(?:class|struct))?)\s+[A-Za-z_][A-Za-z0-9_]*")
+$methodDeclaration = [regex]("^\s*$accessModifier\s+(?:(?:static|virtual|override|abstract|async|extern|unsafe|sealed|new|partial)\s+)*(?!class\b|struct\b|interface\b|enum\b|record\b|delegate\b|event\b)(?:[A-Za-z_][A-Za-z0-9_<>\[\],.?]*(?:\s+|[\*&]+\s*))+[A-Za-z_][A-Za-z0-9_]*(?:<[^>]+>)?\s*\(")
+$constructorDeclaration = [regex]("^\s*$accessModifier\s+(?:(?:static|extern|unsafe)\s+)*[A-Za-z_][A-Za-z0-9_]*\s*\(")
+$operatorDeclaration = [regex]("^\s*$accessModifier\s+(?:(?:static|extern|unsafe)\s+)*(?:[A-Za-z_][A-Za-z0-9_<>\[\],.?]*\s+)?(?:implicit|explicit\s+)?operator\s+")
+
+foreach ($file in $documentedMemberFiles) {
+    $lines = [System.IO.File]::ReadAllLines($file.FullName)
+    for ($i = 0; $i -lt $lines.Count; $i++) {
+        $line = $lines[$i]
+        $isDocumentedMember =
+            $typeDeclaration.IsMatch($line) -or
+            $methodDeclaration.IsMatch($line) -or
+            $constructorDeclaration.IsMatch($line) -or
+            $operatorDeclaration.IsMatch($line)
+
+        if ($isDocumentedMember -and -not (Test-HasXmlDocumentation $lines $i)) {
+            $relative = Get-RelativePath $file.FullName
+            Add-Failure "${relative}:$($i + 1) is missing XML documentation for a class or method declaration."
+        }
+    }
+}
+
+if (-not $SkipBuild) {
+    $projects = @(
+        "src/DAG/DAG.csproj",
+        "src/DAG.Demo/DAG.Demo.csproj",
+        "src/DAGControls/DAGControls.csproj",
+        "src/DatabaseControls/DatabaseControls.csproj",
+        "src/DatabaseControls.Demo/DatabaseControls.Demo.csproj",
+        "src/DatabaseManager/DatabaseManager.csproj",
+        "src/ExpressionParser/ExpressionParser.csproj",
+        "src/ExpressionParserControls/ExpressionParserControls.csproj",
+        "src/ExpressionParserControls.Demo/ExpressionParserControls.Demo.csproj",
+        "src/FrameworkInterfaces/FrameworkInterfaces.csproj",
+        "src/FrameworkUI/FrameworkUI.csproj",
+        "src/FrameworkUI.Demo/FrameworkUI.Demo.csproj",
+        "src/GenericControls/GenericControls.csproj",
+        "src/GenericControls.Demo/GenericControls.Demo.csproj",
+        "src/NumericControls/NumericControls.csproj",
+        "src/NumericControls.Demo/NumericControls.Demo.csproj",
+        "src/OxyPlotControls/OxyPlotControls.csproj",
+        "src/OxyPlotControls.Demo/OxyPlotControls.Demo.csproj",
+        "src/SoftwareUpdate/SoftwareUpdate.csproj",
+        "src/SoftwareUpdate.Updater/SoftwareUpdate.Updater.csproj",
+        "src/Themes/Themes.csproj"
+    )
+
+    foreach ($project in $projects) {
+        $projectPath = Join-Path $repoRoot $project
+        if (-not (Test-Path $projectPath)) {
+            Add-Failure "Missing project: $project"
+            continue
+        }
+
+        $args = @(
+            "build",
+            $projectPath,
+            "-c",
+            $Configuration,
+            "--no-restore",
+            "--no-dependencies",
+            "-p:EnforceXmlDocumentation=true",
+            "-p:UseSharedCompilation=false",
+            "-v:minimal"
+        )
+
+        & dotnet @args
+        if ($LASTEXITCODE -ne 0) {
+            Add-Failure "XML documentation build failed for $project."
+        }
+    }
+}
+
+if ($failures.Count -gt 0) {
+    $failures | ForEach-Object { [Console]::Error.WriteLine($_) }
+    exit 1
+}
+
+Write-Host "Code XML documentation validation passed."
diff --git a/src/DAG.Demo/App.xaml.cs b/src/DAG.Demo/App.xaml.cs
index 44d990c6..72956548 100644
--- a/src/DAG.Demo/App.xaml.cs
+++ b/src/DAG.Demo/App.xaml.cs
@@ -7,6 +7,9 @@ namespace DAG.Demo
     /// </summary>
     public partial class App : Application
     {
+        /// <summary>
+        /// Initializes culture-aware WPF binding metadata for the demo application.
+        /// </summary>
         public App()
         {
             // Set WPF to use the current culture for all bindings (international number support)
diff --git a/src/DAG.Demo/MainWindow.xaml.cs b/src/DAG.Demo/MainWindow.xaml.cs
index 6af552a9..131866f7 100644
--- a/src/DAG.Demo/MainWindow.xaml.cs
+++ b/src/DAG.Demo/MainWindow.xaml.cs
@@ -23,6 +23,9 @@ namespace DAG.Demo
     public partial class MainWindow : Window
     {
 
+        /// <summary>
+        /// Initializes the demo window and assigns the sample graph.
+        /// </summary>
         public MainWindow()
         {
             InitializeComponent();
@@ -30,11 +33,21 @@ public MainWindow()
             GraphCanvas.Graph = new TestGraph();
         }
 
+        /// <summary>
+        /// Adds a sample node at the default demo position.
+        /// </summary>
+        /// <param name="sender">The button that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void AddNodeButton_Click(object sender, RoutedEventArgs e)
         {
             AddNode(new Point(180, 180));
         }
 
+        /// <summary>
+        /// Adds the demo node command to the canvas context menu.
+        /// </summary>
+        /// <param name="cm">The context menu being prepared.</param>
+        /// <param name="canvasPosition">The canvas position where the menu was opened.</param>
         private void GraphCanvas_PreviewCanvasContextMenu(ContextMenu cm, Point canvasPosition)
         {
             Image addIcon = new Image() { Source = new BitmapImage(new Uri("pack://application:,,,/DAG.Demo;component/Resources/Add.png")) };
@@ -43,6 +56,11 @@ private void GraphCanvas_PreviewCanvasContextMenu(ContextMenu cm, Point canvasPo
             cm.Items.Add(cmi);
         }
 
+        /// <summary>
+        /// Adds a node near the context-menu position.
+        /// </summary>
+        /// <param name="sender">The context-menu item that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void Cmi_Click(object sender, RoutedEventArgs e)
         {
             var p = (Point)((MenuItem)sender).Tag;
@@ -51,6 +69,10 @@ private void Cmi_Click(object sender, RoutedEventArgs e)
 
         private static readonly Random _random = new();
 
+        /// <summary>
+        /// Creates and decorates a sample node at the specified canvas position.
+        /// </summary>
+        /// <param name="p">The canvas position for the node.</param>
         private void AddNode(Point p)
         {
             var newNode = new TestNode() { LeftPosition = p.X, TopPosition = p.Y };
@@ -83,6 +105,11 @@ private void AddNode(Point p)
             }
         }
 
+        /// <summary>
+        /// Adds demo-specific node commands to the node context menu.
+        /// </summary>
+        /// <param name="cm">The context menu being prepared.</param>
+        /// <param name="node">The node associated with the menu.</param>
         private void GraphCanvas_PreviewNodeContextMenu(ContextMenu cm, DAG.NodeBase node)
         {
             Image editIcon = new Image() { Source = new BitmapImage(new Uri("pack://application:,,,/DAG.Demo;component/Resources/EditWindow.png")) };
@@ -91,6 +118,10 @@ private void GraphCanvas_PreviewNodeContextMenu(ContextMenu cm, DAG.NodeBase nod
             cm.Items.Add(cmi);
         }
 
+        /// <summary>
+        /// Displays feedback when the user requests an automatic connection.
+        /// </summary>
+        /// <param name="fromConnector">The output connector that starts the connection.</param>
         private void GraphCanvas_AutoConnection_Clicked(DAG.OutConnector fromConnector)
         {
             ConnectionText.TextDecorations = null;
@@ -98,16 +129,31 @@ private void GraphCanvas_AutoConnection_Clicked(DAG.OutConnector fromConnector)
             if (FindResource("animate") is Storyboard sb1) sb1.Begin(ConnectionText);
         }
 
+        /// <summary>
+        /// Handles the placeholder graph save command in the demo.
+        /// </summary>
+        /// <param name="sender">The button that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void SaveGraphButton_Click(object sender, RoutedEventArgs e)
         {
             // TODO: Implement when FlowGraphCanvas.GraphToXElement() is available
         }
 
+        /// <summary>
+        /// Handles the placeholder graph load command in the demo.
+        /// </summary>
+        /// <param name="sender">The button that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void LoadGraphButton_Click(object sender, RoutedEventArgs e)
         {
             // TODO: Implement when FlowGraphCanvas.LoadFromXElement() is available
         }
 
+        /// <summary>
+        /// Adds a sample rectangle visual to the graph canvas.
+        /// </summary>
+        /// <param name="sender">The button that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void TestButton_Click(object sender, RoutedEventArgs e)
         {
             Rectangle rect = new Rectangle() { Width = 350, Height = 200, Stroke = Brushes.Black, StrokeThickness = 2 };
@@ -117,12 +163,21 @@ private void TestButton_Click(object sender, RoutedEventArgs e)
             GraphCanvas.AddVisual(rect);
         }
 
+        /// <summary>
+        /// Subscribes to graph connection notifications when the window loads.
+        /// </summary>
+        /// <param name="sender">The window that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void Window_Loaded(object sender, RoutedEventArgs e)
         {
             GraphCanvas.Graph.ConnectionsAdded += Graph_ConnectionsAdded;
             GraphCanvas.Graph.ConnectionsRemoved += Graph_ConnectionsRemoved;
         }
 
+        /// <summary>
+        /// Displays connection-removal feedback in the demo status text.
+        /// </summary>
+        /// <param name="connections">The connections that were removed.</param>
         private void Graph_ConnectionsRemoved(Tuple<OutConnector, InConnector>[] connections)
         {
             //Show update
@@ -136,6 +191,10 @@ private void Graph_ConnectionsRemoved(Tuple<OutConnector, InConnector>[] connect
             if (FindResource("animate") is Storyboard sb2) sb2.Begin(ConnectionText);
         }
 
+        /// <summary>
+        /// Displays connection-addition feedback in the demo status text.
+        /// </summary>
+        /// <param name="connections">The connections that were added.</param>
         private void Graph_ConnectionsAdded(Tuple<OutConnector, InConnector>[] connections)
         {
             //Show update
@@ -149,6 +208,10 @@ private void Graph_ConnectionsAdded(Tuple<OutConnector, InConnector>[] connectio
             if (FindResource("animate") is Storyboard sb3) sb3.Begin(ConnectionText);
         }
 
+        /// <summary>
+        /// Unsubscribes from graph notifications before the window closes.
+        /// </summary>
+        /// <param name="e">The close event data.</param>
         protected override void OnClosed(EventArgs e)
         {
             GraphCanvas.Graph.ConnectionsAdded -= Graph_ConnectionsAdded;
diff --git a/src/DAG/Graph.cs b/src/DAG/Graph.cs
index 94d885e1..240e7d7c 100644
--- a/src/DAG/Graph.cs
+++ b/src/DAG/Graph.cs
@@ -655,6 +655,11 @@ public bool RemoveConnection(Tuple<OutConnector, InConnector> connection)
 
         #region Event Handlers
 
+        /// <summary>
+        /// Updates connector subscriptions and removes invalid connections when nodes change.
+        /// </summary>
+        /// <param name="sender">The node collection that raised the event.</param>
+        /// <param name="e">The collection change details.</param>
         private void Nodes_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
         {
             if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Reset)
@@ -709,6 +714,11 @@ private void Nodes_CollectionChanged(object sender, System.Collections.Specializ
             }
         }
 
+        /// <summary>
+        /// Removes connections that target outputs removed from a node.
+        /// </summary>
+        /// <param name="sender">The output connector collection that changed.</param>
+        /// <param name="e">The collection change details.</param>
         private void Outputs_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
         {
             if (e.OldItems != null)
@@ -733,6 +743,11 @@ private void Outputs_CollectionChanged(object sender, System.Collections.Special
             }
         }
 
+        /// <summary>
+        /// Removes connections that target inputs removed from a node.
+        /// </summary>
+        /// <param name="sender">The input connector collection that changed.</param>
+        /// <param name="e">The collection change details.</param>
         private void Inputs_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
         {
             if (e.OldItems != null)
@@ -775,6 +790,10 @@ private void ForceRemoveConnections(IEnumerable<Tuple<OutConnector, InConnector>
             ConnectionsRemoved?.Invoke(toRemove);
         }
 
+        /// <summary>
+        /// Removes connections after giving subscribers a chance to cancel the operation.
+        /// </summary>
+        /// <param name="connectionsToRemove">The connections requested for removal.</param>
         private void RemoveConnections(Tuple<OutConnector, InConnector>[] connectionsToRemove)
         {
             if (connectionsToRemove == null || connectionsToRemove.Length == 0) { return; }
@@ -791,6 +810,10 @@ private void RemoveConnections(Tuple<OutConnector, InConnector>[] connectionsToR
             }
         }
 
+        /// <summary>
+        /// Adds valid, non-duplicate connections after preview subscribers approve the change.
+        /// </summary>
+        /// <param name="connectionsToAdd">The candidate connections to add.</param>
         private void AddConnections(Tuple<OutConnector, InConnector>[] connectionsToAdd)
         {
             if (connectionsToAdd == null || connectionsToAdd.Length == 0) { return; }
diff --git a/src/DAGControls/FlowGraphCanvas.xaml.cs b/src/DAGControls/FlowGraphCanvas.xaml.cs
index 18bb39c4..64693041 100644
--- a/src/DAGControls/FlowGraphCanvas.xaml.cs
+++ b/src/DAGControls/FlowGraphCanvas.xaml.cs
@@ -244,6 +244,11 @@ public FlowGraphCanvas()
             GraphCanvas.LostMouseCapture += GraphCanvas_LostMouseCapture;
         }
 
+        /// <summary>
+        /// Clears drag state when the canvas loses mouse capture.
+        /// </summary>
+        /// <param name="sender">The canvas that raised the event.</param>
+        /// <param name="e">The mouse event data.</param>
         private void GraphCanvas_LostMouseCapture(object sender, MouseEventArgs e)
         {
             _isPanning = false;
@@ -329,6 +334,11 @@ public ReadOnlyCollection<UIElement> GetVisuals()
 
         #region Private Methods - Graph Handling
 
+        /// <summary>
+        /// Rebinds graph event handlers when the <see cref="Graph"/> property changes.
+        /// </summary>
+        /// <param name="d">The canvas whose graph changed.</param>
+        /// <param name="e">The dependency-property change details.</param>
         private static void GraphPropertyChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
         {
             FlowGraphCanvas thisControl = (FlowGraphCanvas)d;
@@ -361,6 +371,9 @@ private static void GraphPropertyChangedCallback(DependencyObject d, DependencyP
             thisControl.RedrawGraph();
         }
 
+        /// <summary>
+        /// Rebuilds all node and connection visuals from the current graph model.
+        /// </summary>
         private void RedrawGraph()
         {
             // Unsubscribe event handlers before clearing
@@ -404,6 +417,10 @@ private void RedrawGraph()
             GraphRedrawn?.Invoke();
         }
 
+        /// <summary>
+        /// Removes visual paths for connections removed from the graph model.
+        /// </summary>
+        /// <param name="connections">The graph connections that were removed.</param>
         private void Graph_ConnectionsRemoved(Tuple<OutConnector, InConnector>[] connections)
         {
             foreach (var connection in connections)
@@ -416,6 +433,10 @@ private void Graph_ConnectionsRemoved(Tuple<OutConnector, InConnector>[] connect
             }
         }
 
+        /// <summary>
+        /// Adds visual paths for connections added to the graph model.
+        /// </summary>
+        /// <param name="connections">The graph connections that were added.</param>
         private void Graph_ConnectionsAdded(Tuple<OutConnector, InConnector>[] connections)
         {
             foreach (var connection in connections)
@@ -424,6 +445,10 @@ private void Graph_ConnectionsAdded(Tuple<OutConnector, InConnector>[] connectio
             }
         }
 
+        /// <summary>
+        /// Creates and registers the visual path for a graph connection.
+        /// </summary>
+        /// <param name="connection">The connection to render.</param>
         private void AddConnection(Tuple<OutConnector, InConnector> connection)
         {
             if (_connections.ContainsKey(connection)) { return; }
@@ -455,6 +480,11 @@ private void AddConnection(Tuple<OutConnector, InConnector> connection)
             ConnectionAdded?.Invoke(connection, p);
         }
 
+        /// <summary>
+        /// Synchronizes node controls with changes in the graph node collection.
+        /// </summary>
+        /// <param name="sender">The node collection that raised the event.</param>
+        /// <param name="e">The collection change details.</param>
         private void Nodes_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
         {
             if (e.OldItems != null)
@@ -483,6 +513,10 @@ private void Nodes_CollectionChanged(object sender, System.Collections.Specializ
             }
         }
 
+        /// <summary>
+        /// Creates and registers the visual control for a graph node.
+        /// </summary>
+        /// <param name="node">The node to render.</param>
         private void AddNode(NodeBase node)
         {
             if (node == null) { return; }
@@ -500,11 +534,21 @@ private void AddNode(NodeBase node)
 
         #region Private Methods - Mouse Handling
 
+        /// <summary>
+        /// Removes the node selected by the context menu.
+        /// </summary>
+        /// <param name="sender">The menu item that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void Cmi_Click(object sender, RoutedEventArgs e)
         {
             _ = Graph.Nodes.Remove(_targetNode);
         }
 
+        /// <summary>
+        /// Starts node movement, connection creation, context-menu display, or panning.
+        /// </summary>
+        /// <param name="sender">The canvas that raised the event.</param>
+        /// <param name="e">The mouse-button event data.</param>
         private void GraphCanvas_MouseDown(object sender, MouseButtonEventArgs e)
         {
             if (e.RightButton == MouseButtonState.Pressed)
@@ -596,6 +640,11 @@ private void GraphCanvas_MouseDown(object sender, MouseButtonEventArgs e)
             }
         }
 
+        /// <summary>
+        /// Updates the active drag, connection preview, or pan operation.
+        /// </summary>
+        /// <param name="sender">The canvas that raised the event.</param>
+        /// <param name="e">The mouse event data.</param>
         private void GraphCanvas_MouseMove(object sender, MouseEventArgs e)
         {
             Point pos = e.GetPosition(GraphCanvas);
@@ -680,6 +729,11 @@ private void GraphCanvas_MouseMove(object sender, MouseEventArgs e)
             _previousLocation = pos;
         }
 
+        /// <summary>
+        /// Completes the active mouse interaction and releases mouse capture.
+        /// </summary>
+        /// <param name="sender">The canvas that raised the event.</param>
+        /// <param name="e">The mouse-button event data.</param>
         private void GraphCanvas_MouseUp(object sender, MouseButtonEventArgs e)
         {
             _isPanning = false;
@@ -747,6 +801,11 @@ private void GraphCanvas_MouseUp(object sender, MouseButtonEventArgs e)
             GraphCanvas.ReleaseMouseCapture();
         }
 
+        /// <summary>
+        /// Zooms the graph around the current mouse position.
+        /// </summary>
+        /// <param name="sender">The canvas that raised the event.</param>
+        /// <param name="e">The mouse-wheel event data.</param>
         private void GraphCanvas_MouseWheel(object sender, MouseWheelEventArgs e)
         {
             if (Graph == null) return;
@@ -844,6 +903,11 @@ private void GraphCanvas_MouseWheel(object sender, MouseWheelEventArgs e)
 
         #region Private Methods - Event Handlers
 
+        /// <summary>
+        /// Redraws affected connection paths after a node size changes.
+        /// </summary>
+        /// <param name="sender">The node control that changed size.</param>
+        /// <param name="e">The size-change details.</param>
         private void Node_SizeChanged(object sender, SizeChangedEventArgs e)
         {
             if (!(sender is NodeControl nodeCntrl)) { return; }
@@ -858,6 +922,11 @@ private void Node_SizeChanged(object sender, SizeChangedEventArgs e)
             NodeSizeChanged?.Invoke(nodeCntrl.Node);
         }
 
+        /// <summary>
+        /// Removes the node whose delete command was clicked.
+        /// </summary>
+        /// <param name="sender">The node control that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void Node_Delete_Clicked(object sender, RoutedEventArgs e)
         {
             _ = Graph.Nodes.Remove(((NodeControl)sender).Node);
@@ -867,6 +936,11 @@ private void Node_Delete_Clicked(object sender, RoutedEventArgs e)
 
         #region Private Methods - Path Drawing
 
+        /// <summary>
+        /// Creates the initial bezier path for a connection source.
+        /// </summary>
+        /// <param name="connectionSource">The output connector visual that starts the path.</param>
+        /// <returns>The created path.</returns>
         private Path CreatePath(Ellipse connectionSource)
         {
             // Identify the center point of node connector. TransformToAncestor throws
@@ -904,6 +978,12 @@ private Path CreatePath(Ellipse connectionSource)
             return p;
         }
 
+        /// <summary>
+        /// Updates a connection path to span the specified start and end points.
+        /// </summary>
+        /// <param name="connector">The connection path to update.</param>
+        /// <param name="startPoint">The start point of the connection.</param>
+        /// <param name="endPoint">The end point of the connection.</param>
         private void DrawConnection(Path connector, Point startPoint, Point endPoint)
         {
             PathFigure pf = ((PathGeometry)connector.Data).Figures[0];
@@ -915,6 +995,12 @@ private void DrawConnection(Path connector, Point startPoint, Point endPoint)
             b.Point3 = endPoint;
         }
 
+        /// <summary>
+        /// Updates a connection path using output and input connector visuals.
+        /// </summary>
+        /// <param name="connector">The connection path to update.</param>
+        /// <param name="outConnector">The output connector visual.</param>
+        /// <param name="inConnector">The input connector visual.</param>
         private void DrawConnection(Path connector, Ellipse outConnector, Ellipse inConnector)
         {
             // Get Start Point
@@ -932,6 +1018,12 @@ private void DrawConnection(Path connector, Ellipse outConnector, Ellipse inConn
             DrawConnection(connector, startPoint, endPoint);
         }
 
+        /// <summary>
+        /// Translates every point in an existing connection path.
+        /// </summary>
+        /// <param name="connector">The connection path to translate.</param>
+        /// <param name="xTrans">The horizontal translation amount.</param>
+        /// <param name="yTrans">The vertical translation amount.</param>
         private void TranslateConnection(Path connector, double xTrans, double yTrans)
         {
             PathFigure pf = ((PathGeometry)connector.Data).Figures[0];
diff --git a/src/DAGControls/NodeControl.xaml.cs b/src/DAGControls/NodeControl.xaml.cs
index 8fa0e48b..b46617f9 100644
--- a/src/DAGControls/NodeControl.xaml.cs
+++ b/src/DAGControls/NodeControl.xaml.cs
@@ -212,12 +212,27 @@ public NodeControl(NodeBase node)
             _ = SetBinding(Canvas.TopProperty, b);
         }
 
+        /// <summary>
+        /// Refreshes input connector visuals after the node input collection changes.
+        /// </summary>
+        /// <param name="sender">The input connector collection that raised the event.</param>
+        /// <param name="e">The collection change details.</param>
         private void OnInputsCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
             => RefreshInConnectors();
 
+        /// <summary>
+        /// Refreshes output connector visuals after the node output collection changes.
+        /// </summary>
+        /// <param name="sender">The output connector collection that raised the event.</param>
+        /// <param name="e">The collection change details.</param>
         private void OnOutputsCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
             => RefreshOutConnectors();
 
+        /// <summary>
+        /// Releases node collection subscriptions when the control unloads.
+        /// </summary>
+        /// <param name="sender">The control that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void OnNodeControlUnloaded(object sender, RoutedEventArgs e)
         {
             if (Node != null)
@@ -278,17 +293,32 @@ public void RefreshOutConnectors()
 
         #region Private Methods
 
+        /// <summary>
+        /// Refreshes connector visual dictionaries after layout creates item containers.
+        /// </summary>
+        /// <param name="sender">The control that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void UserControl_Loaded(object sender, RoutedEventArgs e)
         {
             RefreshInConnectors();
             RefreshOutConnectors();
         }
 
+        /// <summary>
+        /// Raises the node delete request for the hosting canvas.
+        /// </summary>
+        /// <param name="sender">The button that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void DeleteButton_Click(object sender, RoutedEventArgs e)
         {
             Delete_Clicked?.Invoke(this, e);
         }
 
+        /// <summary>
+        /// Raises an automatic connection request from the clicked output connector.
+        /// </summary>
+        /// <param name="sender">The output connector host that raised the event.</param>
+        /// <param name="e">The mouse-button event data.</param>
         private void AddButton_MouseDown(object sender, MouseButtonEventArgs e)
         {
             Grid targetGrid = (Grid)sender;
diff --git a/src/DatabaseControls.Demo/DatabaseControls.Demo.csproj b/src/DatabaseControls.Demo/DatabaseControls.Demo.csproj
index 2538c5c0..d9a0ffdc 100644
--- a/src/DatabaseControls.Demo/DatabaseControls.Demo.csproj
+++ b/src/DatabaseControls.Demo/DatabaseControls.Demo.csproj
@@ -15,8 +15,8 @@
 
   	<!-- Shared packages -->
 	<ItemGroup>
-		<PackageReference Include="System.Data.SQLite" Version="2.0.2" />
-		<PackageReference Include="SourceGear.sqlite3" Version="3.50.4.5" />
+		<PackageReference Include="System.Data.SQLite" />
+		<PackageReference Include="SourceGear.sqlite3" />
 	</ItemGroup>
 	<ItemGroup>
 	  <ProjectReference Include="..\DatabaseControls\DatabaseControls.csproj" />
@@ -26,7 +26,7 @@
 	  <ProjectReference Include="..\Themes\Themes.csproj" />
 	</ItemGroup>
 	<ItemGroup>
-	  <PackageReference Include="RMC.Numerics" Version="2.0.1" />
+	  <PackageReference Include="RMC.Numerics" />
 	  <ProjectReference Include="..\OxyPlot\OxyPlot\OxyPlot.csproj" />
 	  <ProjectReference Include="..\OxyPlot\OxyPlot.Wpf\OxyPlot.Wpf.csproj" />
 	  <ProjectReference Include="..\OxyPlot\OxyPlot.Wpf.Shared\OxyPlot.Wpf.Shared.csproj" />
diff --git a/src/DatabaseControls/DatabaseControls.csproj b/src/DatabaseControls/DatabaseControls.csproj
index a4a03dfb..d4bab401 100644
--- a/src/DatabaseControls/DatabaseControls.csproj
+++ b/src/DatabaseControls/DatabaseControls.csproj
@@ -56,8 +56,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="$(RmcNumericsProject)" Condition="'$(UseLocalRmcNumericsProject)' == 'true' And Exists('$(RmcNumericsProject)')" />
-    <PackageReference Include="RMC.Numerics" Version="2.0.1" Condition="'$(UseLocalRmcNumericsProject)' != 'true' Or !Exists('$(RmcNumericsProject)')" />
+    <PackageReference Include="RMC.Numerics" />
     <ProjectReference Include="..\OxyPlot\OxyPlot\OxyPlot.csproj" />
     <ProjectReference Include="..\OxyPlot\OxyPlot.Wpf\OxyPlot.Wpf.csproj" />
     <ProjectReference Include="..\OxyPlot\OxyPlot.Wpf.Shared\OxyPlot.Wpf.Shared.csproj" />
diff --git a/src/DatabaseControls/FieldCalculator/CalculatorHelpWindow.xaml.cs b/src/DatabaseControls/FieldCalculator/CalculatorHelpWindow.xaml.cs
index b312de5e..6ff35945 100644
--- a/src/DatabaseControls/FieldCalculator/CalculatorHelpWindow.xaml.cs
+++ b/src/DatabaseControls/FieldCalculator/CalculatorHelpWindow.xaml.cs
@@ -27,16 +27,29 @@ public CalculatorHelpWindow(string helpType = "FieldCalculator")
             Closing += CalculatorHelpWindow_Closing;
         }
 
+        /// <summary>
+        /// Disposes the embedded help browser when the help window closes.
+        /// </summary>
+        /// <param name="sender">The help window that raised the event.</param>
+        /// <param name="e">The closing event data.</param>
         private void CalculatorHelpWindow_Closing(object? sender, System.ComponentModel.CancelEventArgs e)
         {
             HelpBrowser?.Dispose();
         }
 
+        /// <summary>
+        /// Loads embedded help content after the window has rendered.
+        /// </summary>
+        /// <param name="sender">The help window that raised the event.</param>
+        /// <param name="e">The event data.</param>
         private void CalculatorHelpWindow_ContentRendered(object? sender, EventArgs e)
         {
             LoadHelpContent();
         }
 
+        /// <summary>
+        /// Loads the selected embedded HTML help file and its image resources.
+        /// </summary>
         private void LoadHelpContent()
         {
             var assembly = Assembly.GetExecutingAssembly();
diff --git a/src/DatabaseControls/FieldCalculator/FieldCalculator.xaml.cs b/src/DatabaseControls/FieldCalculator/FieldCalculator.xaml.cs
index f848f6c5..073790cf 100644
--- a/src/DatabaseControls/FieldCalculator/FieldCalculator.xaml.cs
+++ b/src/DatabaseControls/FieldCalculator/FieldCalculator.xaml.cs
@@ -618,6 +618,11 @@ private class PreviewRow
             public int Row { get; }
             public string Result { get; }
 
+            /// <summary>
+            /// Initializes a preview row with the source row number and evaluated result.
+            /// </summary>
+            /// <param name="row">The one-based row number shown in the preview.</param>
+            /// <param name="result">The expression result for the row.</param>
             public PreviewRow(int row, string result)
             {
                 Row = row;
diff --git a/src/DatabaseControls/TableViewer.xaml.cs b/src/DatabaseControls/TableViewer.xaml.cs
index d6b8563b..f53676f8 100644
--- a/src/DatabaseControls/TableViewer.xaml.cs
+++ b/src/DatabaseControls/TableViewer.xaml.cs
@@ -23,6 +23,9 @@ public partial class TableViewer : UserControl
     {
         #region Enumerables
 
+        /// <summary>
+        /// Defines the selection states supported by the table viewer.
+        /// </summary>
         private enum SelectionMode : byte
         {
             CellSelect = 0,
@@ -33,6 +36,9 @@ private enum SelectionMode : byte
             EditSelect = 5
         }
 
+        /// <summary>
+        /// Defines the sort state applied to a table column.
+        /// </summary>
         private enum SortOrder : byte
         {
             Ascending = 2,
@@ -84,6 +90,11 @@ private enum SortOrder : byte
         public static readonly DependencyProperty AllCellsSelectedProperty = DependencyProperty.Register(
             nameof(AllCellsSelected), typeof(bool), typeof(TableViewer), new UIPropertyMetadata(false, OnAllCellsSelectedChanged));
 
+        /// <summary>
+        /// Updates the select-all button when the all-cells selection state changes.
+        /// </summary>
+        /// <param name="d">The table viewer whose property changed.</param>
+        /// <param name="e">The dependency-property change details.</param>
         private static void OnAllCellsSelectedChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
         {
             if (d is TableViewer viewer)
@@ -138,6 +149,11 @@ private static void OnAllCellsSelectedChanged(DependencyObject d, DependencyProp
         public static readonly DependencyProperty EditableProperty = DependencyProperty.Register(
             nameof(Editable), typeof(bool), typeof(TableViewer), new UIPropertyMetadata(false, OnEditableChanged));
 
+        /// <summary>
+        /// Updates paste availability when editability changes.
+        /// </summary>
+        /// <param name="d">The table viewer whose property changed.</param>
+        /// <param name="e">The dependency-property change details.</param>
         private static void OnEditableChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
         {
             if (d is TableViewer tv) tv.UpdatePasteButtonState();
@@ -680,6 +696,11 @@ public TableViewer()
 
         #region Loading
 
+        /// <summary>
+        /// Schedules a visual refresh after a styling dependency property changes.
+        /// </summary>
+        /// <param name="d">The table viewer whose visual property changed.</param>
+        /// <param name="e">The dependency-property change details.</param>
         private static void OnVisualPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
         {
             if (d is not TableViewer tv) return;
@@ -742,6 +763,11 @@ private void TableSelectionFocusWithinChanged(object sender, DependencyPropertyC
             RefreshSelectionVisuals();
         }
 
+        /// <summary>
+        /// Attaches a new <see cref="DataView"/> and rebuilds table state for it.
+        /// </summary>
+        /// <param name="d">The table viewer whose data view changed.</param>
+        /// <param name="e">The dependency-property change details.</param>
         private static void LoadView(DependencyObject d, DependencyPropertyChangedEventArgs e)
         {
             if (d == null || d.GetType() != typeof(TableViewer)) return;
@@ -1652,6 +1678,11 @@ private int GetTableRowIndex(Point gridPosition)
             return GridPanel.RowDefinitions.Count - 1;
         }
 
+        /// <summary>
+        /// Resolves a grid coordinate to the visible table column index.
+        /// </summary>
+        /// <param name="gridPosition">The position relative to the grid panel.</param>
+        /// <returns>The column index at the specified position.</returns>
         private int GetTableColumnIndex(Point gridPosition)
         {
             double runningSum = 0;
@@ -1766,6 +1797,11 @@ private void DeSelectAllCells()
             }
         }
 
+        /// <summary>
+        /// Applies selected styling to a visible cell.
+        /// </summary>
+        /// <param name="columnIndex">The visible column index.</param>
+        /// <param name="rowIndex">The visible row index.</param>
         private void SelectCell(int columnIndex, int rowIndex)
         {
             var cell = (Cell)GridPanel.Children[rowIndex * DataView.ColumnNames.Count() + columnIndex];
@@ -1774,6 +1810,11 @@ private void SelectCell(int columnIndex, int rowIndex)
             cell.Foreground = selectionActive ? SelectedForegroundColor : InactiveSelectedForegroundColor;
         }
 
+        /// <summary>
+        /// Applies deselected styling to a visible cell.
+        /// </summary>
+        /// <param name="columnIndex">The visible column index.</param>
+        /// <param name="rowIndex">The visible row index.</param>
         private void DeSelectCell(int columnIndex, int rowIndex)
         {
             var cell = (Cell)GridPanel.Children[rowIndex * DataView.ColumnNames.Count() + columnIndex];
@@ -1781,6 +1822,9 @@ private void DeSelectCell(int columnIndex, int rowIndex)
             cell.Foreground = DeSelectedForegroundColor;
         }
 
+        /// <summary>
+        /// Applies active-cell styling when the active cell is visible.
+        /// </summary>
         private void SetActiveCell()
         {
             if (!IsTableSelectionActive()) return;
@@ -2023,6 +2067,11 @@ private void TableViewer_Loaded(object sender, RoutedEventArgs e)
 
         }
 
+        /// <summary>
+        /// Releases data-view subscriptions when the table viewer unloads.
+        /// </summary>
+        /// <param name="sender">The table viewer that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void TableViewer_Unloaded(object sender, RoutedEventArgs e)
         {
             _isLoaded = false;
@@ -2164,6 +2213,11 @@ private void TestGridPanel_MouseWheel(object sender, MouseWheelEventArgs e)
             VerticalScrollbar.Value -= e.Delta / 10; // if e.Delta = 30 then table will go up 3 rows
         }
 
+        /// <summary>
+        /// Handles keyboard navigation, selection, editing, and clipboard shortcuts.
+        /// </summary>
+        /// <param name="sender">The grid panel that raised the event.</param>
+        /// <param name="e">The key event data.</param>
         private void Grid_PreviewKeyDown(object sender, KeyEventArgs e)
         {
             int firstRowDataIndex = (int)Math.Floor(VerticalScrollbar.Value);
@@ -2979,6 +3033,11 @@ public void ShowSelected_Checked(object? sender, RoutedEventArgs? e)
             GridPanel.Focus();
         }
 
+        /// <summary>
+        /// Clears all row, column, and cell selections.
+        /// </summary>
+        /// <param name="sender">The button or menu item that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void DeSelectAll_Click(object sender, RoutedEventArgs e)
         {
             if (_selectedDataRowIndices.Count > 0)
@@ -3003,6 +3062,11 @@ private void DeSelectAll_Click(object sender, RoutedEventArgs e)
             GridPanel.Focus();
         }
 
+        /// <summary>
+        /// Opens the field calculator in attribute-selection mode and applies matching rows.
+        /// </summary>
+        /// <param name="sender">The button or menu item that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void SelectByAttribute_Click(object sender, RoutedEventArgs e)
         {
             var attributeSelector = new FieldCalculator(DataView, _selectedDataRowIndices, null, null, true);
@@ -3043,12 +3107,22 @@ private void SelectByAttribute_Click(object sender, RoutedEventArgs e)
             GridPanel.Focus();
         }
 
+        /// <summary>
+        /// Restores the last attribute-selector expression after the dialog renders.
+        /// </summary>
+        /// <param name="sender">The rendered field calculator window.</param>
+        /// <param name="e">The render event data.</param>
         private void SelectorRendered(object? sender, EventArgs e)
         {
             if (sender is FieldCalculator fc)
                 fc.ExpressionCalculator.SetExpressionText(_attributeSelectorString);
         }
 
+        /// <summary>
+        /// Restores the last field-calculator expression after the dialog renders.
+        /// </summary>
+        /// <param name="sender">The rendered field calculator window.</param>
+        /// <param name="e">The render event data.</param>
         private void CalculatorRendered(object? sender, EventArgs e)
         {
             if (sender is FieldCalculator fc)
@@ -3298,6 +3372,11 @@ private void GridPanel_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
             ((UIElement)sender).ReleaseMouseCapture();
         }
 
+        /// <summary>
+        /// Builds and opens the column context menu for the clicked column.
+        /// </summary>
+        /// <param name="sender">The grid panel that raised the event.</param>
+        /// <param name="e">The mouse-button event data.</param>
         private void CreateColumnContextMenu(object sender, MouseButtonEventArgs e)
         {
             GridPanel.Focus();
@@ -3366,7 +3445,15 @@ private void CreateColumnContextMenu(object sender, MouseButtonEventArgs e)
 
         #region Sorting
 
+        /// <summary>
+        /// Handles the menu command that clears sorting.
+        /// </summary>
+        /// <param name="sender">The menu item that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void RemoveSort(object sender, RoutedEventArgs e) => RemoveSort();
+        /// <summary>
+        /// Clears all sort state and restores natural row order.
+        /// </summary>
         private void RemoveSort()
         {
             _columnSortOrder = SortOrder.None;
@@ -3383,7 +3470,15 @@ private void RemoveSort()
             UpdateRowHeaders();
         }
 
+        /// <summary>
+        /// Handles the menu command that sorts the current column descending.
+        /// </summary>
+        /// <param name="sender">The menu item that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void SortColumnDescending(object sender, RoutedEventArgs e) => SortColumnDescending();
+        /// <summary>
+        /// Sorts the current context-menu column in descending order.
+        /// </summary>
         private void SortColumnDescending()
         {
             try
@@ -3419,7 +3514,15 @@ private void SortColumnDescending()
             catch { Mouse.OverrideCursor = null; }
         }
 
+        /// <summary>
+        /// Handles the menu command that sorts the current column ascending.
+        /// </summary>
+        /// <param name="sender">The menu item that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void SortColumnAscending(object sender, RoutedEventArgs e) => SortColumnAscending();
+        /// <summary>
+        /// Sorts the current context-menu column in ascending order.
+        /// </summary>
         private void SortColumnAscending()
         {
             try
@@ -3454,6 +3557,11 @@ private void SortColumnAscending()
             catch { Mouse.OverrideCursor = null; }
         }
 
+        /// <summary>
+        /// Sorts row-index mappings for a column using the column data type.
+        /// </summary>
+        /// <param name="columnIndex">The column index to sort.</param>
+        /// <param name="ascending"><c>true</c> for ascending order; otherwise descending.</param>
         private void SortColumn(int columnIndex, bool ascending)
         {
             object[] columnData = DataView.GetColumn(columnIndex);
@@ -3523,12 +3631,22 @@ private void SortColumn(int columnIndex, bool ascending)
 
         #region Column Context Menu Actions
 
+        /// <summary>
+        /// Opens the statistics window for the current context-menu column.
+        /// </summary>
+        /// <param name="sender">The menu item that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void CalcColumnStatistics(object sender, RoutedEventArgs e)
         {
             var columnstats = new ColumnStatsWindow(this, _mouseDownColumnIndex) { Owner = Window.GetWindow(this) };
             columnstats.Show();
         }
 
+        /// <summary>
+        /// Opens find and replace for the current context-menu column.
+        /// </summary>
+        /// <param name="sender">The menu item that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void SearchText(object sender, RoutedEventArgs e)
         {
             if (DataView.NumberOfRows > 0)
@@ -3538,6 +3656,11 @@ private void SearchText(object sender, RoutedEventArgs e)
             }
         }
 
+        /// <summary>
+        /// Opens the field calculator targeting the current context-menu column.
+        /// </summary>
+        /// <param name="sender">The menu item that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void OpenFcForSpecificColumn(object sender, RoutedEventArgs e)
         {
             var f = new FieldCalculator(DataView, _selectedDataRowIndices, _readOnlyColumns, DataView.ColumnNames[_mouseDownColumnIndex]);
@@ -3548,6 +3671,11 @@ private void OpenFcForSpecificColumn(object sender, RoutedEventArgs e)
             }
         }
 
+        /// <summary>
+        /// Deletes selected editable columns from the data view.
+        /// </summary>
+        /// <param name="sender">The menu item that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void DeleteColumn(object sender, RoutedEventArgs e)
         {
             var columnIndices = _selectedColumnIndices.ToList();
@@ -3562,6 +3690,11 @@ private void DeleteColumn(object sender, RoutedEventArgs e)
         #endregion
 
         #region Clipboard
+        /// <summary>
+        /// Builds and opens the grid clipboard context menu.
+        /// </summary>
+        /// <param name="sender">The grid panel that raised the event.</param>
+        /// <param name="e">The mouse-button event data.</param>
         private void GridPanel_RightMouseUp(object sender, MouseButtonEventArgs e)
         {
             bool enableCopy = false;
@@ -3600,7 +3733,15 @@ private void GridPanel_RightMouseUp(object sender, MouseButtonEventArgs e)
             }
             gridMenu.IsOpen = true;
         }
+        /// <summary>
+        /// Handles the menu command that copies the current selection without headers.
+        /// </summary>
+        /// <param name="sender">The menu item that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void Copy(object sender, RoutedEventArgs e) => Copy();
+        /// <summary>
+        /// Copies the current selection without headers.
+        /// </summary>
         private void Copy()
         {
             try
@@ -3612,6 +3753,11 @@ private void Copy()
                 GenericControls.MessageBox.Show(ex.Message);
             }
         }
+        /// <summary>
+        /// Copies the current selection with column headers.
+        /// </summary>
+        /// <param name="sender">The menu item that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void CopyWithHeaders(object sender, RoutedEventArgs e)
         {
             try
@@ -3624,6 +3770,10 @@ private void CopyWithHeaders(object sender, RoutedEventArgs e)
             }
         }
 
+        /// <summary>
+        /// Writes the current uniform selection to the clipboard.
+        /// </summary>
+        /// <param name="includeHeaders">Whether to include column headers in the copied text.</param>
         private void CaptureSelectionToClipboard(bool includeHeaders)
         {
             if (!IsSelectionUniform())
@@ -3938,10 +4088,18 @@ private SortedDictionary<int, int> GetSelectedRowVirtualRowIndices()
             return sortedRowsIndices;
         }
 
+        /// <summary>
+        /// Handles the paste command from a menu item or button.
+        /// </summary>
+        /// <param name="sender">The command source.</param>
+        /// <param name="e">The routed event data.</param>
         private void Paste(object sender, RoutedEventArgs e)
         {
             Paste();
         }
+        /// <summary>
+        /// Pastes clipboard text into the current editable table selection.
+        /// </summary>
         private void Paste()
         {
             try
@@ -4243,6 +4401,9 @@ private void ExportTable()
 
         #region Undo/Redo
 
+        /// <summary>
+        /// Updates undo, redo, and save button enabled states.
+        /// </summary>
         private void UpdateUndoRedoButtons()
         {
             bool canUndo = DataView.CanUndo();
@@ -4261,6 +4422,11 @@ private void UpdateUndoRedoButtons()
         /// </summary>
         private void Redo_Click(object sender, RoutedEventArgs e) => RedoLastEdit();
 
+        /// <summary>
+        /// Prompts for confirmation and applies pending edits to the data view.
+        /// </summary>
+        /// <param name="sender">The save command source.</param>
+        /// <param name="e">The routed event data.</param>
         private void Save_Click(object sender, RoutedEventArgs e)
         {
             if (GenericControls.MessageBox.Show("Are you sure you want to save edits?", "Apply Edits", MessageBoxButton.OKCancel) == MessageBoxResult.OK)
@@ -4297,12 +4463,18 @@ private void OpenFC_Click(object sender, RoutedEventArgs e)
             }
         }
 
+        /// <summary>
+        /// Reapplies the last undone edit and refreshes the visible table.
+        /// </summary>
         private void RedoLastEdit()
         {
             DataView.RedoEdit();
             UpdateVisibleRows();
             UpdateUndoRedoButtons();
         }
+        /// <summary>
+        /// Reverts the last edit and refreshes the visible table.
+        /// </summary>
         private void UndoLastEdit()
         {
             DataView.UndoEdit();
@@ -4314,6 +4486,12 @@ private void UndoLastEdit()
 
         #region Helper Methods
 
+        /// <summary>
+        /// Updates the displayed text for a visible cell.
+        /// </summary>
+        /// <param name="rowIndex">The visible row index.</param>
+        /// <param name="columnIndex">The visible column index.</param>
+        /// <param name="newText">The text to display.</param>
         private void SetCellText(int rowIndex, int columnIndex, string newText)
         {
             ((Cell)GridPanel.Children[rowIndex * DataView.ColumnNames.Count() + columnIndex]).Text = newText;
@@ -4344,6 +4522,9 @@ private void UpdateSelectionButtonStates()
             }
         }
 
+        /// <summary>
+        /// Enables paste controls when editing is allowed and the clipboard has text.
+        /// </summary>
         private void UpdatePasteButtonState()
         {
             if (!Editable)
@@ -4364,6 +4545,11 @@ private void UpdatePasteButtonState()
             });
         }
 
+        /// <summary>
+        /// Deletes the currently selected rows from the data view.
+        /// </summary>
+        /// <param name="sender">The menu item that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void DeleteRows(object sender, RoutedEventArgs e)
         {
             DataView.DeleteRows(_selectedDataRowIndices.ToArray());
@@ -4373,6 +4559,9 @@ private void DeleteRows(object sender, RoutedEventArgs e)
 
         #region Nested Classes
 
+        /// <summary>
+        /// Renders a table column header with optional sort indicators.
+        /// </summary>
         private class ColumnHeader : Border
         {
             public static readonly DependencyProperty TextProperty = DependencyProperty.Register(
@@ -4405,6 +4594,11 @@ public Style HeaderBorderStyle
             private readonly Viewbox _sortDownViewBox = new Viewbox { Width = 9, Visibility = Visibility.Collapsed, Margin = new Thickness(2, 0, 2, 0) };
             private readonly Viewbox _sortUpViewBox = new Viewbox { Width = 9, Visibility = Visibility.Collapsed, Margin = new Thickness(2, 0, 2, 0) };
 
+            /// <summary>
+            /// Initializes a column header for the specified data column.
+            /// </summary>
+            /// <param name="columnName">The displayed column name.</param>
+            /// <param name="columnType">The column data type shown in the tooltip.</param>
             public ColumnHeader(string columnName, Type columnType)
             {
                 var g = new Grid();
@@ -4453,12 +4647,19 @@ public ColumnHeader(string columnName, Type columnType)
                 ToolTip = $"{columnName}\nType: {typeName}";
             }
 
+            /// <summary>
+            /// Hides all sort indicator visuals.
+            /// </summary>
             public void RemoveSorter()
             {
                 _sortDownViewBox.Visibility = Visibility.Collapsed;
                 _sortUpViewBox.Visibility = Visibility.Collapsed;
             }
 
+            /// <summary>
+            /// Shows the sort indicator for the current sort direction.
+            /// </summary>
+            /// <param name="ascending"><c>true</c> to show ascending; otherwise descending.</param>
             public void AddSorter(bool ascending)
             {
                 _sortDownViewBox.Visibility = ascending ? Visibility.Collapsed : Visibility.Visible;
@@ -4466,6 +4667,9 @@ public void AddSorter(bool ascending)
             }
         }
 
+        /// <summary>
+        /// Renders a table cell with bindable text and styling.
+        /// </summary>
         private class Cell : Border
         {
             public static readonly DependencyProperty TextProperty = DependencyProperty.Register(
@@ -4495,6 +4699,9 @@ public Brush Foreground
                 set => SetValue(ForegroundProperty, value);
             }
 
+            /// <summary>
+            /// Initializes a table cell visual.
+            /// </summary>
             public Cell()
             {
                 HorizontalAlignment = HorizontalAlignment.Stretch;
@@ -4510,6 +4717,9 @@ public Cell()
             }
         }
 
+        /// <summary>
+        /// Renders a table row header with bindable text and styling.
+        /// </summary>
         private class RowHeader : Border
         {
             public static readonly DependencyProperty TextProperty = DependencyProperty.Register(
@@ -4539,6 +4749,9 @@ public Style HeaderBorderStyle
                 set => SetValue(HeaderBorderStyleProperty, value);
             }
 
+            /// <summary>
+            /// Initializes a row header visual.
+            /// </summary>
             public RowHeader()
             {
                 var tBlock = new TextBlock
@@ -4559,6 +4772,10 @@ public RowHeader()
 
         #region Default Styles
 
+        /// <summary>
+        /// Creates the default text style used by table cells.
+        /// </summary>
+        /// <returns>The default cell text style.</returns>
         private static Style GetDefaultCellTextblockStyle()
         {
             var s = new Style(typeof(TextBlock));
@@ -4573,6 +4790,10 @@ private static Style GetDefaultCellTextblockStyle()
             return s;
         }
 
+        /// <summary>
+        /// Creates the default text style used by column headers.
+        /// </summary>
+        /// <returns>The default column-header text style.</returns>
         private static Style GetDefaultColumnHeaderTextblockStyle()
         {
             var s = new Style(typeof(TextBlock));
@@ -4588,6 +4809,10 @@ private static Style GetDefaultColumnHeaderTextblockStyle()
             return s;
         }
 
+        /// <summary>
+        /// Creates the default border style used by column headers.
+        /// </summary>
+        /// <returns>The default column-header border style.</returns>
         private static Style GetDefaultColumnHeaderBorderStyle()
         {
             var columnHeaderBackground = new LinearGradientBrush(
@@ -4616,6 +4841,10 @@ private static Style GetDefaultColumnHeaderBorderStyle()
             return s;
         }
 
+        /// <summary>
+        /// Creates the default text style used by row headers.
+        /// </summary>
+        /// <returns>The default row-header text style.</returns>
         private static Style GetDefaultRowHeaderTextblockStyle()
         {
             var s = new Style(typeof(TextBlock));
@@ -4629,6 +4858,10 @@ private static Style GetDefaultRowHeaderTextblockStyle()
             return s;
         }
 
+        /// <summary>
+        /// Creates the default border style used by row headers.
+        /// </summary>
+        /// <returns>The default row-header border style.</returns>
         private static Style GetDefaultRowHeaderBorderStyle()
         {
             var rowHeaderBackground = new LinearGradientBrush(
diff --git a/src/DatabaseManager.Tests/DatabaseManager.Tests.csproj b/src/DatabaseManager.Tests/DatabaseManager.Tests.csproj
index 264ae3ee..c3abca2f 100644
--- a/src/DatabaseManager.Tests/DatabaseManager.Tests.csproj
+++ b/src/DatabaseManager.Tests/DatabaseManager.Tests.csproj
@@ -11,13 +11,13 @@
 
 	<!-- Test packages -->
 	<ItemGroup>
-		<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
-		<PackageReference Include="xunit" Version="2.9.2" />
-		<PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+		<PackageReference Include="Microsoft.NET.Test.Sdk" />
+		<PackageReference Include="xunit" />
+		<PackageReference Include="xunit.runner.visualstudio">
 			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
 			<PrivateAssets>all</PrivateAssets>
 		</PackageReference>
-		<PackageReference Include="coverlet.collector" Version="6.0.2">
+		<PackageReference Include="coverlet.collector">
 			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
 			<PrivateAssets>all</PrivateAssets>
 		</PackageReference>
diff --git a/src/DatabaseManager/DataTableView.cs b/src/DatabaseManager/DataTableView.cs
index e06081fd..49736ccc 100644
--- a/src/DatabaseManager/DataTableView.cs
+++ b/src/DatabaseManager/DataTableView.cs
@@ -2752,15 +2752,28 @@ public void ExportToDbf(string filePath, int[] rowIndicesToExport = null, int[]
             }
         }
 
-        // Try CurrentCulture first (matches how the user typed/pasted), fall back to
-        // InvariantCulture so cross-machine data (e.g., a US-format CSV pasted on a German
-        // machine) is still readable.
+        /// <summary>
+        /// Parses a double using the current culture, then invariant culture.
+        /// </summary>
+        /// <param name="text">The text to parse.</param>
+        /// <param name="result">The parsed double value.</param>
+        /// <returns><c>true</c> if parsing succeeded; otherwise, <c>false</c>.</returns>
+        /// <remarks>
+        /// Current culture matches user-entered values; invariant culture keeps
+        /// cross-machine data such as US-format CSV values readable.
+        /// </remarks>
         private static bool TryParseDoubleDualCulture(string text, out double result)
         {
             return double.TryParse(text, NumberStyles.Any, CultureInfo.CurrentCulture, out result)
                 || double.TryParse(text, NumberStyles.Any, CultureInfo.InvariantCulture, out result);
         }
 
+        /// <summary>
+        /// Parses a single-precision value using the current culture, then invariant culture.
+        /// </summary>
+        /// <param name="text">The text to parse.</param>
+        /// <param name="result">The parsed single-precision value.</param>
+        /// <returns><c>true</c> if parsing succeeded; otherwise, <c>false</c>.</returns>
         private static bool TryParseSingleDualCulture(string text, out float result)
         {
             return float.TryParse(text, NumberStyles.Any, CultureInfo.CurrentCulture, out result)
@@ -3071,4 +3084,4 @@ public void Dispose()
 
         #endregion
     }
-}
\ No newline at end of file
+}
diff --git a/src/DatabaseManager/DatabaseManager.csproj b/src/DatabaseManager/DatabaseManager.csproj
index 7d9d971f..e48c5a22 100644
--- a/src/DatabaseManager/DatabaseManager.csproj
+++ b/src/DatabaseManager/DatabaseManager.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
 	<PropertyGroup>
 		<TargetFramework>net10.0</TargetFramework>
@@ -16,12 +16,12 @@
 
 	<!-- Shared packages -->
 	<ItemGroup>
-		<PackageReference Include="ClosedXML" Version="0.105.0" />
-		<PackageReference Include="DocumentFormat.OpenXml" Version="3.4.1" />
-		<PackageReference Include="ExcelNumberFormat" Version="1.1" />
-		<PackageReference Include="FastMember" Version="1.5.0" />
-		<PackageReference Include="System.Data.SQLite" Version="2.0.2" />
-		<PackageReference Include="SourceGear.sqlite3" Version="3.50.4.5" />
+		<PackageReference Include="ClosedXML" />
+		<PackageReference Include="DocumentFormat.OpenXml" />
+		<PackageReference Include="ExcelNumberFormat" />
+		<PackageReference Include="FastMember" />
+		<PackageReference Include="System.Data.SQLite" />
+		<PackageReference Include="SourceGear.sqlite3" />
 	</ItemGroup>
 
 </Project>
\ No newline at end of file
diff --git a/src/ExpressionParser.Tests/ExpressionParser.Tests.csproj b/src/ExpressionParser.Tests/ExpressionParser.Tests.csproj
index a6da6c49..462ec3a4 100644
--- a/src/ExpressionParser.Tests/ExpressionParser.Tests.csproj
+++ b/src/ExpressionParser.Tests/ExpressionParser.Tests.csproj
@@ -13,9 +13,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
-    <PackageReference Include="MSTest.TestAdapter" Version="3.5.2" />
-    <PackageReference Include="MSTest.TestFramework" Version="3.5.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="MSTest.TestAdapter" />
+    <PackageReference Include="MSTest.TestFramework" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/ExpressionParser/Parser/Parser.cs b/src/ExpressionParser/Parser/Parser.cs
index 748f5790..e65baec6 100644
--- a/src/ExpressionParser/Parser/Parser.cs
+++ b/src/ExpressionParser/Parser/Parser.cs
@@ -24,7 +24,7 @@ public static class Parser
         /// <b>Threading contract:</b> the static <see cref="Parse(List{Token}, bool, Dictionary{string, ResultType})"/> method is safe to invoke
         /// from multiple threads concurrently because each invocation builds an independent AST. However the
         /// returned <see cref="IParserNode"/> tree is <i>not</i> thread-safe per AST instance — some nodes (notably
-        /// <see cref="Numerics.IncrementNode"/>) carry mutable evaluation state. Once an AST is produced, treat it
+        /// <see cref="ExpressionParser.IncrementNode"/>) carry mutable evaluation state. Once an AST is produced, treat it
         /// as a single-threaded resource: confine all <c>Evaluate()</c>/<c>Simplify()</c> calls and variable-value
         /// updates on its <see cref="VariableNode"/>s to one thread, or wrap access in your own synchronization.
         /// </para>
@@ -56,7 +56,7 @@ public static IParserNode Parse(List<Token> tokens, bool ignoreCase = false, Dic
         /// <b>Threading contract:</b> the static <see cref="Parse(string, bool, Dictionary{string, ResultType})"/> method is safe to invoke
         /// from multiple threads concurrently because each invocation builds an independent AST. However the
         /// returned <see cref="IParserNode"/> tree is <i>not</i> thread-safe per AST instance — some nodes (notably
-        /// <see cref="Numerics.IncrementNode"/>) carry mutable evaluation state. Once an AST is produced, treat it
+        /// <see cref="ExpressionParser.IncrementNode"/>) carry mutable evaluation state. Once an AST is produced, treat it
         /// as a single-threaded resource: confine all <c>Evaluate()</c>/<c>Simplify()</c> calls and variable-value
         /// updates on its <see cref="VariableNode"/>s to one thread, or wrap access in your own synchronization.
         /// </para>
@@ -575,4 +575,4 @@ public static ResultType TypeToResultType(Type t)
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/ExpressionParserControls.Demo/App.xaml.cs b/src/ExpressionParserControls.Demo/App.xaml.cs
index b9a5bea6..f54bbe6a 100644
--- a/src/ExpressionParserControls.Demo/App.xaml.cs
+++ b/src/ExpressionParserControls.Demo/App.xaml.cs
@@ -8,6 +8,9 @@ namespace ExpressionParserControls.Demo
     /// </summary>
     public partial class App : Application
     {
+        /// <summary>
+        /// Initializes culture-aware WPF binding metadata for the demo application.
+        /// </summary>
         public App()
         {
             // Set WPF to use the current culture for all bindings (international number support)
@@ -19,6 +22,11 @@ public App()
                         System.Globalization.CultureInfo.CurrentCulture.IetfLanguageTag)));
         }
 
+        /// <summary>
+        /// Initializes the theme service and opens the demo main window.
+        /// </summary>
+        /// <param name="sender">The application that raised the event.</param>
+        /// <param name="e">The startup event data.</param>
         private void Application_Startup(object sender, StartupEventArgs e)
         {
             ThemeService.Instance.Initialize(Theme.Light);
diff --git a/src/ExpressionParserControls/ExpressionControl.xaml.cs b/src/ExpressionParserControls/ExpressionControl.xaml.cs
index 5b6f5dac..1a2ec033 100644
--- a/src/ExpressionParserControls/ExpressionControl.xaml.cs
+++ b/src/ExpressionParserControls/ExpressionControl.xaml.cs
@@ -38,38 +38,43 @@ public partial class ExpressionControl
         /// </summary>
         public static readonly DependencyProperty TextProperty = DependencyProperty.Register(nameof(Text), typeof(string), typeof(ExpressionControl), new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTextPropertyChanged));
 
-    private static void OnTextPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
-    {
-        var control = (ExpressionControl)d;
-        if (control._formattingExpression || !control.IsLoaded)
-            return;
+        /// <summary>
+        /// Synchronizes the rich text editor when the bound text value changes.
+        /// </summary>
+        /// <param name="d">The expression control whose text changed.</param>
+        /// <param name="e">The dependency-property change details.</param>
+        private static void OnTextPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var control = (ExpressionControl)d;
+            if (control._formattingExpression || !control.IsLoaded)
+                return;
 
-        string newText = (string)e.NewValue ?? "";
-        string currentText = new System.Windows.Documents.TextRange(
-            control.ExpressionTextBox.Document.ContentStart,
-            control.ExpressionTextBox.Document.ContentEnd).Text.Trim(Environment.NewLine.ToCharArray());
+            string newText = (string)e.NewValue ?? "";
+            string currentText = new System.Windows.Documents.TextRange(
+                control.ExpressionTextBox.Document.ContentStart,
+                control.ExpressionTextBox.Document.ContentEnd).Text.Trim(Environment.NewLine.ToCharArray());
 
-        if (currentText != newText)
-        {
-            // try/finally so an exception during document rebuild (Blocks.Clear/Add or
-            // the TextChanged reformat) doesn't leave _formattingExpression stuck at true,
-            // which would permanently lock the editor.
-            control._formattingExpression = true;
-            try
+            if (currentText != newText)
             {
-                control.ExpressionTextBox.Document.Blocks.Clear();
-                var p = new System.Windows.Documents.Paragraph();
-                p.Inlines.Add(new System.Windows.Documents.Run(newText));
-                control.ExpressionTextBox.Document.Blocks.Add(p);
-            }
-            finally
-            {
-                control._formattingExpression = false;
+                // try/finally so an exception during document rebuild (Blocks.Clear/Add or
+                // the TextChanged reformat) doesn't leave _formattingExpression stuck at true,
+                // which would permanently lock the editor.
+                control._formattingExpression = true;
+                try
+                {
+                    control.ExpressionTextBox.Document.Blocks.Clear();
+                    var p = new System.Windows.Documents.Paragraph();
+                    p.Inlines.Add(new System.Windows.Documents.Run(newText));
+                    control.ExpressionTextBox.Document.Blocks.Add(p);
+                }
+                finally
+                {
+                    control._formattingExpression = false;
+                }
+                // Trigger a TextChanged to reformat with syntax highlighting
+                control.ExpressionTextBox_TextChanged(control.ExpressionTextBox, new TextChangedEventArgs(System.Windows.Controls.RichTextBox.TextChangedEvent, UndoAction.None));
             }
-            // Trigger a TextChanged to reformat with syntax highlighting
-            control.ExpressionTextBox_TextChanged(control.ExpressionTextBox, new TextChangedEventArgs(System.Windows.Controls.RichTextBox.TextChangedEvent, UndoAction.None));
         }
-    }
 
         /// <summary>
         /// Gets or sets the text content of the expression editor.
@@ -283,4 +288,4 @@ private void ExpressionTextBox_SelectionChanged(object sender, RoutedEventArgs e
             // might want to allow some work here such as bolding the matching parenthesis if there is one.
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/FrameworkInterfaces/Messaging/BasicMessageItem.cs b/src/FrameworkInterfaces/Messaging/BasicMessageItem.cs
index 9c9918fa..bb772bfc 100644
--- a/src/FrameworkInterfaces/Messaging/BasicMessageItem.cs
+++ b/src/FrameworkInterfaces/Messaging/BasicMessageItem.cs
@@ -134,7 +134,7 @@ public BasicMessageItem(
 
         // Identity snapshot fields — set once in the constructor and never changed.
         // See ctor remarks for rationale.
-        private readonly string _identityCode;
+        private readonly string? _identityCode;
         private readonly string? _identityElementName;
         private readonly string? _identityParentCollectionName;
         private readonly string? _identityProjectName;
@@ -469,7 +469,7 @@ public override int GetHashCode()
         /// <param name="left">The first message item to compare.</param>
         /// <param name="right">The second message item to compare.</param>
         /// <returns><c>true</c> if the message items are equal; otherwise, <c>false</c>.</returns>
-        public static bool operator ==(BasicMessageItem left, BasicMessageItem right)
+        public static bool operator ==(BasicMessageItem? left, BasicMessageItem? right)
         {
             if (ReferenceEquals(left, null))
             {
@@ -484,7 +484,7 @@ public override int GetHashCode()
         /// <param name="left">The first message item to compare.</param>
         /// <param name="right">The second message item to compare.</param>
         /// <returns><c>true</c> if the message items are not equal; otherwise, <c>false</c>.</returns>
-        public static bool operator !=(BasicMessageItem left, BasicMessageItem right)
+        public static bool operator !=(BasicMessageItem? left, BasicMessageItem? right)
         {
             return !(left == right);
         }
diff --git a/src/FrameworkInterfaces/Messaging/Messenger.cs b/src/FrameworkInterfaces/Messaging/Messenger.cs
index 2327a259..c2d70dbd 100644
--- a/src/FrameworkInterfaces/Messaging/Messenger.cs
+++ b/src/FrameworkInterfaces/Messaging/Messenger.cs
@@ -88,6 +88,11 @@ public static Messenger GetInstance()
 
         #region Static Helpers
 
+        /// <summary>
+        /// Creates an immutable brush for use as a default message color.
+        /// </summary>
+        /// <param name="color">The color to apply to the brush.</param>
+        /// <returns>A frozen solid-color brush.</returns>
         private static SolidColorBrush CreateFrozenBrush(Color color)
         {
             var brush = new SolidColorBrush(color);
diff --git a/src/FrameworkInterfaces/Undo/UndoManager.cs b/src/FrameworkInterfaces/Undo/UndoManager.cs
index 37199052..d7e93099 100644
--- a/src/FrameworkInterfaces/Undo/UndoManager.cs
+++ b/src/FrameworkInterfaces/Undo/UndoManager.cs
@@ -428,6 +428,10 @@ public void RollbackTransaction()
 
         #region Private Methods
 
+        /// <summary>
+        /// Records an undoable action, merging or stacking it as appropriate.
+        /// </summary>
+        /// <param name="action">The action to record.</param>
         private void RecordActionInternal(IUndoableAction action)
         {
             lock (_lockObject)
@@ -462,6 +466,9 @@ private void RecordActionInternal(IUndoableAction action)
             OnStateChanged();
         }
 
+        /// <summary>
+        /// Removes oldest undo entries when the stack exceeds the configured limit.
+        /// </summary>
         private void TrimUndoStack()
         {
             lock (_lockObject)
@@ -494,6 +501,9 @@ private void TrimUndoStack()
             }
         }
 
+        /// <summary>
+        /// Raises property and state-change notifications for undo manager state.
+        /// </summary>
         private void OnStateChanged()
         {
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CanUndo)));
@@ -516,11 +526,18 @@ private class TransactionScope : IDisposable
             private readonly UndoManager _manager;
             private bool _disposed = false;
 
+            /// <summary>
+            /// Initializes a transaction scope for the specified manager.
+            /// </summary>
+            /// <param name="manager">The undo manager that owns the transaction.</param>
             public TransactionScope(UndoManager manager)
             {
                 _manager = manager;
             }
 
+            /// <summary>
+            /// Commits the active transaction once when the scope is disposed.
+            /// </summary>
             public void Dispose()
             {
                 if (!_disposed)
@@ -536,6 +553,9 @@ public void Dispose()
         /// </summary>
         private class NestedTransactionScope : IDisposable
         {
+            /// <summary>
+            /// Emits a diagnostic warning for an unsupported nested transaction.
+            /// </summary>
             public void Dispose()
             {
                 System.Diagnostics.Debug.WriteLine(
diff --git a/src/FrameworkUI.Demo/FrameworkUI.Demo.csproj b/src/FrameworkUI.Demo/FrameworkUI.Demo.csproj
index 46c3ccef..c716ad90 100644
--- a/src/FrameworkUI.Demo/FrameworkUI.Demo.csproj
+++ b/src/FrameworkUI.Demo/FrameworkUI.Demo.csproj
@@ -1,4 +1,4 @@
-<!-- FrameworkUI.Demo - Demo application for FrameworkUI -->
+<!-- FrameworkUI.Demo - Demo application for FrameworkUI -->
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
@@ -50,7 +50,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="RMC.Numerics" Version="2.0.1" />
+    <PackageReference Include="RMC.Numerics" />
     <ProjectReference Include="..\OxyPlot\OxyPlot\OxyPlot.csproj" />
     <ProjectReference Include="..\OxyPlot\OxyPlot.Wpf\OxyPlot.Wpf.csproj" />
     <ProjectReference Include="..\OxyPlot\OxyPlot.Wpf.Shared\OxyPlot.Wpf.Shared.csproj" />
diff --git a/src/FrameworkUI.Demo/Model/DemoProject.cs b/src/FrameworkUI.Demo/Model/DemoProject.cs
index 452c61c2..cfb002fd 100644
--- a/src/FrameworkUI.Demo/Model/DemoProject.cs
+++ b/src/FrameworkUI.Demo/Model/DemoProject.cs
@@ -204,6 +204,7 @@ public override string Description
 
         /// <inheritdoc/>
         private static readonly Lazy<ImageSource> s_projectIcon = new(() => { var img = new BitmapImage(new Uri("pack://application:,,,/FrameworkUI.Demo;component/Resources/Hazard_Icon.png")); img.Freeze(); return img; });
+        /// <inheritdoc/>
         public override ImageSource ProjectImage => s_projectIcon.Value;
 
         /// <summary>
diff --git a/src/FrameworkUI.Demo/Model/Hazard Elements/HazardElement.cs b/src/FrameworkUI.Demo/Model/Hazard Elements/HazardElement.cs
index c22a93e6..9da02535 100644
--- a/src/FrameworkUI.Demo/Model/Hazard Elements/HazardElement.cs	
+++ b/src/FrameworkUI.Demo/Model/Hazard Elements/HazardElement.cs	
@@ -214,6 +214,7 @@ public override string Description
 
         /// <inheritdoc/>
         private static readonly Lazy<ImageSource> s_icon = new(() => { var img = new BitmapImage(new Uri("pack://application:,,,/FrameworkUI.Demo;component/Resources/Hazard_Icon.png")); img.Freeze(); return img; });
+        /// <inheritdoc/>
         public override ImageSource ElementImage => s_icon.Value;
 
         /// <inheritdoc/>
@@ -1004,4 +1005,4 @@ private void ComputeMinMax(bool meanOnly)
         #endregion
 
     }
-}
\ No newline at end of file
+}
diff --git a/src/FrameworkUI.Demo/Model/Undo Demo/UndoDemoElement.cs b/src/FrameworkUI.Demo/Model/Undo Demo/UndoDemoElement.cs
index a511d5ee..25ccb24b 100644
--- a/src/FrameworkUI.Demo/Model/Undo Demo/UndoDemoElement.cs	
+++ b/src/FrameworkUI.Demo/Model/Undo Demo/UndoDemoElement.cs	
@@ -167,6 +167,7 @@ public DateTime DateValue
         /// Gets the image icon representing the element.
         /// </summary>
         private static readonly Lazy<ImageSource> s_icon = new(() => { var img = new BitmapImage(new Uri("pack://application:,,,/FrameworkUI.Demo;component/Resources/Hazard_Icon.png")); img.Freeze(); return img; });
+        /// <inheritdoc/>
         public override ImageSource ElementImage => s_icon.Value;
 
         /// <summary>
diff --git a/src/FrameworkUI.Demo/UI/DemoProjectNode.cs b/src/FrameworkUI.Demo/UI/DemoProjectNode.cs
index c33d4c73..ee08bffe 100644
--- a/src/FrameworkUI.Demo/UI/DemoProjectNode.cs
+++ b/src/FrameworkUI.Demo/UI/DemoProjectNode.cs
@@ -321,8 +321,8 @@ public override void PropertiesClosed(UIElement documentControl)
         /// <param name="element">The element to create a properties control for.</param>
         /// <returns>Always returns null as this method is not implemented.</returns>
         /// <remarks>
-        /// Properties controls in RMC-BestFit are created based on the active document control rather than
-        /// directly from elements. See <see cref="GetPropertiesControl(Control)"/> for the implemented approach.
+        /// Properties controls are created based on the active document control rather than
+        /// directly from elements. See <see cref="GetPropertiesControl(UIElement)"/> for the implemented approach.
         /// </remarks>
         public override Control GetPropertiesControl(IElement element)
         {
diff --git a/src/FrameworkUI.Demo/UI/Hazard Controls/HazardControl.xaml.cs b/src/FrameworkUI.Demo/UI/Hazard Controls/HazardControl.xaml.cs
index dec62785..7868e04e 100644
--- a/src/FrameworkUI.Demo/UI/Hazard Controls/HazardControl.xaml.cs	
+++ b/src/FrameworkUI.Demo/UI/Hazard Controls/HazardControl.xaml.cs	
@@ -62,7 +62,7 @@ public HazardControl()
         /// Gets the collection of data points for the mean line series.
         /// </summary>
         /// <value>
-        /// An observable collection of <see cref="DataPoint"/> objects representing the mean curve.
+        /// An observable collection of <see cref="OxyPlot.DataPoint"/> objects representing the mean curve.
         /// </value>
         public ObservableCollection<OxyPlot.DataPoint> MeanLinePoints { get; } = new ObservableCollection<OxyPlot.DataPoint>();
 
@@ -70,7 +70,7 @@ public HazardControl()
         /// Gets the collection of data points for the mode line series.
         /// </summary>
         /// <value>
-        /// An observable collection of <see cref="DataPoint"/> objects representing the mode (user-specified) curve.
+        /// An observable collection of <see cref="OxyPlot.DataPoint"/> objects representing the mode (user-specified) curve.
         /// </value>
         public ObservableCollection<OxyPlot.DataPoint> ModeLinePoints { get; } = new ObservableCollection<OxyPlot.DataPoint>();
 
@@ -93,9 +93,9 @@ public HazardControl()
         /// <summary>
         /// Occurs before a mouse click is processed on the control.
         /// </summary>
-        /// <param name="plotClicked">Indicates whether the plot area was clicked.</param>
-        /// <param name="toolbarClicked">Indicates whether the toolbar area was clicked.</param>
-        /// <param name="plot">The plot control that was interacted with.</param>
+        /// <remarks>
+        /// Handlers receive flags for plot and toolbar clicks plus the plot control involved.
+        /// </remarks>
         public event PreviewControlClickedEventHandler PreviewControlClicked;
 
         /// <summary>
@@ -151,7 +151,7 @@ private static void ElementPropertyChanged(DependencyObject d, DependencyPropert
         /// Gets or sets the parametric hazard element bound to this control.
         /// </summary>
         /// <value>
-        /// The <see cref="ParametricHazard"/> instance containing the hazard function data and settings.
+        /// The <see cref="HazardElement"/> instance containing the hazard function data and settings.
         /// </value>
         public HazardElement Element
         {
@@ -357,7 +357,7 @@ private void LoadPlotSettings()
         ///     <item><description>Mean curve line (if uncertainty is enabled)</description></item>
         ///     <item><description>Mode (user-specified) curve line</description></item>
         /// </list>
-        /// The axis orientation is determined by the <see cref="ProbabilityAxisCheckBox"/> state.
+        /// The axis orientation is determined by the <c>ProbabilityAxisCheckBox</c> state.
         /// </remarks>
         public void UpdatePlot()
         {
diff --git a/src/FrameworkUI/Help Menu/AboutWindow.xaml.cs b/src/FrameworkUI/Help Menu/AboutWindow.xaml.cs
index c69f7cce..d07ede3b 100644
--- a/src/FrameworkUI/Help Menu/AboutWindow.xaml.cs	
+++ b/src/FrameworkUI/Help Menu/AboutWindow.xaml.cs	
@@ -21,6 +21,11 @@ public AboutWindow()
             Loaded += AboutWindow_Loaded;
         }
 
+        /// <summary>
+        /// Sizes the name column and applies a window icon when the dialog loads.
+        /// </summary>
+        /// <param name="sender">The about window that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void AboutWindow_Loaded(object sender, RoutedEventArgs e)
         {
             // Measure the software name and widen the name column if needed
diff --git a/src/FrameworkUI/Help Menu/TermsAndConditionsWindow.xaml.cs b/src/FrameworkUI/Help Menu/TermsAndConditionsWindow.xaml.cs
index 3f45455f..0a13f3a0 100644
--- a/src/FrameworkUI/Help Menu/TermsAndConditionsWindow.xaml.cs	
+++ b/src/FrameworkUI/Help Menu/TermsAndConditionsWindow.xaml.cs	
@@ -20,6 +20,11 @@ public TermsAndConditionsWindow()
             Loaded += TermsAndConditionsWindow_Loaded;
         }
 
+        /// <summary>
+        /// Applies the inherited window icon and default terms document when the dialog loads.
+        /// </summary>
+        /// <param name="sender">The terms window that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void TermsAndConditionsWindow_Loaded(object sender, RoutedEventArgs e)
         {
             // Auto-populate window icon from owner or main window
@@ -78,12 +83,22 @@ public bool ShowButtons
 
         #region Event Handlers
 
+        /// <summary>
+        /// Accepts the dialog and records whether the user agreed.
+        /// </summary>
+        /// <param name="sender">The OK button that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void OKButton_Click(object sender, RoutedEventArgs e)
         {
             UserAgreed = IAgreeCheckbox.IsChecked == true;
             this.DialogResult = true;
         }
 
+        /// <summary>
+        /// Enables agreement once the user has scrolled to the end of the terms.
+        /// </summary>
+        /// <param name="sender">The terms document viewer that raised the event.</param>
+        /// <param name="e">The scroll-change details.</param>
         private void RichTextBox_ScrollChanged(object sender, ScrollChangedEventArgs e)
         {
             double verticalOffset = TCURichTextBox.VerticalOffset;
@@ -112,6 +127,11 @@ private void RichTextBox_ScrollChanged(object sender, ScrollChangedEventArgs e)
             }
         }
 
+        /// <summary>
+        /// Updates the OK button based on the agreement checkbox state.
+        /// </summary>
+        /// <param name="sender">The checkbox that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void IAgreeCheckbox_Changed(object sender, RoutedEventArgs e)
         {
             OKButton.IsEnabled = IAgreeCheckbox.IsChecked == true;
@@ -121,6 +141,9 @@ private void IAgreeCheckbox_Changed(object sender, RoutedEventArgs e)
 
         #region Helper Methods
 
+        /// <summary>
+        /// Applies the configured visibility for agreement and command buttons.
+        /// </summary>
         private void ApplyShowButtons()
         {
             // Guard against being called before InitializeComponent
@@ -140,6 +163,10 @@ private void ApplyShowButtons()
             }
         }
 
+        /// <summary>
+        /// Builds the default terms-and-conditions document.
+        /// </summary>
+        /// <returns>The generated terms document.</returns>
         private FlowDocument BuildDefaultTermsDocument()
         {
             string softwareName = ApplicationAttributes.Title;
@@ -188,6 +215,11 @@ private FlowDocument BuildDefaultTermsDocument()
             return doc;
         }
 
+        /// <summary>
+        /// Creates a heading paragraph for the terms document.
+        /// </summary>
+        /// <param name="text">The heading text.</param>
+        /// <returns>The formatted heading paragraph.</returns>
         private static Paragraph CreateHeading(string text)
         {
             var paragraph = new Paragraph(new Run(text))
@@ -199,6 +231,11 @@ private static Paragraph CreateHeading(string text)
             return paragraph;
         }
 
+        /// <summary>
+        /// Creates a body paragraph for the terms document.
+        /// </summary>
+        /// <param name="text">The paragraph text.</param>
+        /// <returns>The formatted body paragraph.</returns>
         private static Paragraph CreateParagraph(string text)
         {
             var paragraph = new Paragraph(new Run(text))
diff --git a/src/FrameworkUI/Project Explorer/View Models/Node.cs b/src/FrameworkUI/Project Explorer/View Models/Node.cs
index 34751e8e..318c04ab 100644
--- a/src/FrameworkUI/Project Explorer/View Models/Node.cs	
+++ b/src/FrameworkUI/Project Explorer/View Models/Node.cs	
@@ -619,6 +619,11 @@ protected virtual void Me_PreviewMouseLeftButtonDown(object sender, MouseButtonE
             _hitTestResult = VisualTreeHelper.HitTest(_nodeHeader.RenameTextBox, pt);
         }
 
+        /// <summary>
+        /// Updates tree selection before a right-click context menu opens.
+        /// </summary>
+        /// <param name="sender">The node that raised the event.</param>
+        /// <param name="e">The mouse-button event data.</param>
         private void Me_PreviewMouseRightButtonDown(object sender, MouseButtonEventArgs e)
         {
             // ExplorerTreeView pTree = ParentTreeView as ExplorerTreeView;
diff --git a/src/FrameworkUI/Recent Files/RecentFiles.cs b/src/FrameworkUI/Recent Files/RecentFiles.cs
index a8c64a81..88335d8d 100644
--- a/src/FrameworkUI/Recent Files/RecentFiles.cs	
+++ b/src/FrameworkUI/Recent Files/RecentFiles.cs	
@@ -492,13 +492,30 @@ private void MoreFilesMenuItem_Click(object sender, RoutedEventArgs e)
 
         #region File Icon Extraction
 
+        /// <summary>
+        /// Retrieves shell metadata, including icons, for a file system path.
+        /// </summary>
+        /// <param name="pszPath">The file system path to inspect.</param>
+        /// <param name="dwFileAttributes">The file attribute flags supplied to the shell.</param>
+        /// <param name="psfi">The structure that receives shell file information.</param>
+        /// <param name="cbSizeFileInfo">The size of <paramref name="psfi"/>.</param>
+        /// <param name="uFlags">The shell file information flags.</param>
+        /// <returns>A shell handle value for the requested information.</returns>
         [DllImport("shell32.dll", CharSet = CharSet.Auto)]
         private static extern IntPtr SHGetFileInfo(string pszPath, uint dwFileAttributes, ref SHFILEINFO psfi, uint cbSizeFileInfo, uint uFlags);
 
+        /// <summary>
+        /// Releases a native icon handle returned by the shell.
+        /// </summary>
+        /// <param name="hIcon">The icon handle to release.</param>
+        /// <returns><c>true</c> when the icon handle is destroyed; otherwise, <c>false</c>.</returns>
         [DllImport("user32.dll", SetLastError = true)]
         [return: MarshalAs(UnmanagedType.Bool)]
         private static extern bool DestroyIcon(IntPtr hIcon);
 
+        /// <summary>
+        /// Receives shell file information for native icon extraction.
+        /// </summary>
         [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
         private struct SHFILEINFO
         {
diff --git a/src/FrameworkUI/Utilities/ShellPublicVariables.cs b/src/FrameworkUI/Utilities/ShellPublicVariables.cs
index 9c6d1ce4..c66542aa 100644
--- a/src/FrameworkUI/Utilities/ShellPublicVariables.cs
+++ b/src/FrameworkUI/Utilities/ShellPublicVariables.cs
@@ -130,6 +130,10 @@ private static string GetBaseFolderPath()
         /// </summary>
         public static string SoftwareVersionDate = GetAssemblyDate();
 
+        /// <summary>
+        /// Gets the executing assembly's last-write month and year.
+        /// </summary>
+        /// <returns>The assembly date label, or an empty string when unavailable.</returns>
         private static string GetAssemblyDate()
         {
             try
diff --git a/src/GenericControls.Demo/MainWindow.xaml.cs b/src/GenericControls.Demo/MainWindow.xaml.cs
index 8adb8524..603e9adf 100644
--- a/src/GenericControls.Demo/MainWindow.xaml.cs
+++ b/src/GenericControls.Demo/MainWindow.xaml.cs
@@ -29,7 +29,7 @@ namespace GenericControls.Demo
     /// </para>
     /// <para>
     /// The window serves as its own ViewModel by implementing <see cref="INotifyPropertyChanged"/>,
-    /// with the <see cref="DataContext"/> set to itself. All controls bind directly to properties
+    /// with the <c>DataContext</c> set to itself. All controls bind directly to properties
     /// defined in this class.
     /// </para>
     /// <para>
@@ -428,6 +428,10 @@ private void InitializeSampleData()
             CPDataGrid2.ItemsSource = CreateSampleDataItems();
         }
 
+        /// <summary>
+        /// Creates sample rows for the copy-paste data-grid demos.
+        /// </summary>
+        /// <returns>A new sample data collection.</returns>
         private static ObservableCollection<SampleDataItem> CreateSampleDataItems()
         {
             return new ObservableCollection<SampleDataItem>
diff --git a/src/GenericControls/DataGrid/DataGridToolbar.xaml.cs b/src/GenericControls/DataGrid/DataGridToolbar.xaml.cs
index 8687448f..89809732 100644
--- a/src/GenericControls/DataGrid/DataGridToolbar.xaml.cs
+++ b/src/GenericControls/DataGrid/DataGridToolbar.xaml.cs
@@ -327,6 +327,10 @@ private static void StackPanelButtonStylePropertyCallback(DependencyObject d, De
         /// </summary>
         /// <returns>The default <see cref="Style"/> for toolbar buttons.</returns>
         private static Style _cachedDefaultButtonStyle;
+        /// <summary>
+        /// Creates or returns the cached default style for compact toolbar buttons.
+        /// </summary>
+        /// <returns>The default stack-panel button style.</returns>
         private static Style DefaultStackPanelButtonStyle()
         {
             if (_cachedDefaultButtonStyle != null)
@@ -482,6 +486,11 @@ private void DeleteRowsButton_Click(object sender, RoutedEventArgs e)
 
         private bool _allCellsSelected;
 
+        /// <summary>
+        /// Toggles selection of all cells in the associated data grid.
+        /// </summary>
+        /// <param name="sender">The select-all button that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void SelectAllButton_Click(object sender, RoutedEventArgs e)
         {
             if (DataGrid == null)
@@ -567,4 +576,4 @@ private void PasteButton_Click(object sender, RoutedEventArgs e)
         #endregion
 
     }
-}
\ No newline at end of file
+}
diff --git a/src/GenericControls/DataGrid/ValidationDataGridObjects/PropertyRule.cs b/src/GenericControls/DataGrid/ValidationDataGridObjects/PropertyRule.cs
index 1865f3b9..c4f98581 100644
--- a/src/GenericControls/DataGrid/ValidationDataGridObjects/PropertyRule.cs
+++ b/src/GenericControls/DataGrid/ValidationDataGridObjects/PropertyRule.cs
@@ -114,6 +114,11 @@ public class Rule
             /// </summary>
             public bool HasError;
 
+            /// <summary>
+            /// Initializes a validation rule with an expression and error message.
+            /// </summary>
+            /// <param name="expression">The expression that returns <c>true</c> when the rule fails.</param>
+            /// <param name="message">The message to display for the failed rule.</param>
             internal Rule(Func<bool> expression, string message)
             {
                 Expression = expression;
@@ -174,4 +179,4 @@ internal void ExecuteRules()
         #endregion
 
     }
-}
\ No newline at end of file
+}
diff --git a/src/NumericControls.Demo/NumericControls.Demo.csproj b/src/NumericControls.Demo/NumericControls.Demo.csproj
index f623b5f5..abecdd51 100644
--- a/src/NumericControls.Demo/NumericControls.Demo.csproj
+++ b/src/NumericControls.Demo/NumericControls.Demo.csproj
@@ -19,7 +19,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="RMC.Numerics" Version="2.0.1" />
+    <PackageReference Include="RMC.Numerics" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/NumericControls/Data/Time Series Editor/TimeSeriesTable.xaml.cs b/src/NumericControls/Data/Time Series Editor/TimeSeriesTable.xaml.cs
index 41ab8734..d48c4f77 100644
--- a/src/NumericControls/Data/Time Series Editor/TimeSeriesTable.xaml.cs	
+++ b/src/NumericControls/Data/Time Series Editor/TimeSeriesTable.xaml.cs	
@@ -752,6 +752,11 @@ public object ConvertBack(object value, Type targetType, object parameter, Cultu
     /// </remarks>
     public class DateToStringConverter : IValueConverter
     {
+        /// <summary>
+        /// Builds the date/time format pattern for the supplied culture.
+        /// </summary>
+        /// <param name="culture">The culture whose date and time patterns are used.</param>
+        /// <returns>The combined short date and short time pattern.</returns>
         private static string BuildPattern(CultureInfo culture)
         {
             return $"{culture.DateTimeFormat.ShortDatePattern} {culture.DateTimeFormat.ShortTimePattern}";
diff --git a/src/NumericControls/Distributions/Univariate/Distribution Selector/DistributionSelectorControl.xaml.cs b/src/NumericControls/Distributions/Univariate/Distribution Selector/DistributionSelectorControl.xaml.cs
index e05f13c0..c7073527 100644
--- a/src/NumericControls/Distributions/Univariate/Distribution Selector/DistributionSelectorControl.xaml.cs	
+++ b/src/NumericControls/Distributions/Univariate/Distribution Selector/DistributionSelectorControl.xaml.cs	
@@ -127,6 +127,11 @@ private void InitializeControl()
             Unloaded += DistributionSelectorControl_Unloaded;
         }
 
+        /// <summary>
+        /// Subscribes to theme changes and applies the current plot theme.
+        /// </summary>
+        /// <param name="sender">The selector control that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void DistributionSelectorControl_Loaded(object sender, RoutedEventArgs e)
         {
             ThemeService.Instance.ThemeChanged -= OnAppThemeChanged;
@@ -142,11 +147,21 @@ private void DistributionSelectorControl_Loaded(object sender, RoutedEventArgs e
             }
         }
 
+        /// <summary>
+        /// Removes the theme-change subscription when the selector unloads.
+        /// </summary>
+        /// <param name="sender">The selector control that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void DistributionSelectorControl_Unloaded(object sender, RoutedEventArgs e)
         {
             ThemeService.Instance.ThemeChanged -= OnAppThemeChanged;
         }
 
+        /// <summary>
+        /// Applies the new theme to the selector plot.
+        /// </summary>
+        /// <param name="sender">The theme service that raised the event.</param>
+        /// <param name="e">The theme-change details.</param>
         private void OnAppThemeChanged(object? sender, ThemeChangedEventArgs e)
         {
             if (Plot == null) return;
@@ -156,6 +171,9 @@ private void OnAppThemeChanged(object? sender, ThemeChangedEventArgs e)
             ApplyAxisVisibilityOverrides();
         }
 
+        /// <summary>
+        /// Applies axis title, label, and tick visibility settings after theming.
+        /// </summary>
         private void ApplyAxisVisibilityOverrides()
         {
             var transparentColor = Color.FromArgb(0, 0, 0, 0);
@@ -305,6 +323,11 @@ public bool ShowAxisLabel
             set => SetValue(ShowAxisLabelProperty, value);
         }
 
+        /// <summary>
+        /// Reapplies axis visibility when an axis visibility dependency property changes.
+        /// </summary>
+        /// <param name="d">The selector control whose property changed.</param>
+        /// <param name="e">The dependency-property change details.</param>
         private static void OnShowAxisPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
         {
             if (d is DistributionSelectorControl control && control._lastAppliedTheme != null)
diff --git a/src/NumericControls/Distributions/Univariate/Distribution Selector/Selector.xaml.cs b/src/NumericControls/Distributions/Univariate/Distribution Selector/Selector.xaml.cs
index 02d4b604..7f88f4f5 100644
--- a/src/NumericControls/Distributions/Univariate/Distribution Selector/Selector.xaml.cs	
+++ b/src/NumericControls/Distributions/Univariate/Distribution Selector/Selector.xaml.cs	
@@ -90,6 +90,11 @@ public Selector()
             Unloaded += Selector_Unloaded;
         }
 
+        /// <summary>
+        /// Subscribes to theme changes and applies the current plot theme.
+        /// </summary>
+        /// <param name="sender">The selector control that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void Selector_Loaded(object sender, RoutedEventArgs e)
         {
             ThemeService.Instance.ThemeChanged -= OnAppThemeChanged;
@@ -105,11 +110,21 @@ private void Selector_Loaded(object sender, RoutedEventArgs e)
             }
         }
 
+        /// <summary>
+        /// Removes the theme-change subscription when the selector unloads.
+        /// </summary>
+        /// <param name="sender">The selector control that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void Selector_Unloaded(object sender, RoutedEventArgs e)
         {
             ThemeService.Instance.ThemeChanged -= OnAppThemeChanged;
         }
 
+        /// <summary>
+        /// Applies the new theme to the selector plot.
+        /// </summary>
+        /// <param name="sender">The theme service that raised the event.</param>
+        /// <param name="e">The theme-change details.</param>
         private void OnAppThemeChanged(object? sender, ThemeChangedEventArgs e)
         {
             if (Plot == null) return;
@@ -119,6 +134,9 @@ private void OnAppThemeChanged(object? sender, ThemeChangedEventArgs e)
             ApplyAxisVisibilityOverrides();
         }
 
+        /// <summary>
+        /// Applies axis title, label, and tick visibility settings after theming.
+        /// </summary>
         private void ApplyAxisVisibilityOverrides()
         {
             var transparentColor = Color.FromArgb(0, 0, 0, 0);
@@ -239,6 +257,11 @@ public bool ShowAxisLabel
             set => SetValue(ShowAxisLabelProperty, value);
         }
 
+        /// <summary>
+        /// Reapplies axis visibility when an axis visibility dependency property changes.
+        /// </summary>
+        /// <param name="d">The selector control whose property changed.</param>
+        /// <param name="e">The dependency-property change details.</param>
         private static void OnShowAxisPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
         {
             if (d is Selector control && control._lastAppliedTheme != null)
diff --git a/src/NumericControls/NumericControls.csproj b/src/NumericControls/NumericControls.csproj
index 23108775..490926d1 100644
--- a/src/NumericControls/NumericControls.csproj
+++ b/src/NumericControls/NumericControls.csproj
@@ -24,8 +24,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="$(RmcNumericsProject)" Condition="'$(UseLocalRmcNumericsProject)' == 'true' And Exists('$(RmcNumericsProject)')" />
-    <PackageReference Include="RMC.Numerics" Version="2.0.1" Condition="'$(UseLocalRmcNumericsProject)' != 'true' Or !Exists('$(RmcNumericsProject)')" />
+    <PackageReference Include="RMC.Numerics" />
     <ProjectReference Include="..\OxyPlot\OxyPlot\OxyPlot.csproj" />
     <ProjectReference Include="..\OxyPlot\OxyPlot.Wpf\OxyPlot.Wpf.csproj" />
     <ProjectReference Include="..\OxyPlot\OxyPlot.Wpf.Shared\OxyPlot.Wpf.Shared.csproj" />
diff --git a/src/OxyPlotControls.Demo/MainWindow.xaml.cs b/src/OxyPlotControls.Demo/MainWindow.xaml.cs
index e4bf1c5c..dea46d2d 100644
--- a/src/OxyPlotControls.Demo/MainWindow.xaml.cs
+++ b/src/OxyPlotControls.Demo/MainWindow.xaml.cs
@@ -124,12 +124,22 @@ private void MainWindow_Loaded(object sender, RoutedEventArgs e)
             };
         }
 
+        /// <summary>
+        /// Updates the demo status text when a plot property changes.
+        /// </summary>
+        /// <param name="sender">The plot object that raised the event.</param>
+        /// <param name="e">The property-change details.</param>
         private void OnPlotPropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
         {
             _propertyChangedCount++;
             PropertyChangedLabel.Text = $"INPC #{_propertyChangedCount}: {e.PropertyName} at {DateTime.Now:HH:mm:ss.fff}";
         }
 
+        /// <summary>
+        /// Updates the demo status text when a plot collection changes.
+        /// </summary>
+        /// <param name="sender">The plot collection that raised the event.</param>
+        /// <param name="e">The collection-change details.</param>
         private void OnPlotCollectionChanged(object? sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
         {
             _propertyChangedCount++;
@@ -158,6 +168,15 @@ private void OnThemeChanged(object? sender, ThemeChangedEventArgs e)
             }));
         }
 
+        /// <summary>
+        /// Creates sample normal-distribution points for plot examples.
+        /// </summary>
+        /// <param name="x0">The first x-value.</param>
+        /// <param name="x1">The last x-value.</param>
+        /// <param name="mean">The distribution mean.</param>
+        /// <param name="variance">The distribution variance.</param>
+        /// <param name="n">The number of points to generate.</param>
+        /// <returns>The generated distribution points.</returns>
         private List<DataPoint> CreateNormalDist(double x0, double x1, double mean, double variance, int n = 1001)
         {
             var result = new List<DataPoint>();
@@ -177,11 +196,22 @@ private List<DataPoint> CreateNormalDist(double x0, double x1, double mean, doub
             return result;
         }
 
+        /// <summary>
+        /// Receives plot-property update notifications from the demo properties control.
+        /// </summary>
+        /// <param name="targetPlot">The plot whose properties were updated.</param>
         private void PlotPropertiesUpdated(Plot targetPlot)
         {
             System.Diagnostics.Debug.WriteLine("Plot Properties");
         }
 
+        /// <summary>
+        /// Expands the requested properties panel from the toolbar.
+        /// </summary>
+        /// <param name="targetPlot">The plot associated with the toolbar request.</param>
+        /// <param name="openProperties">Whether the caller requested opening the properties view.</param>
+        /// <param name="propertyExpander">The properties section to expand.</param>
+        /// <param name="selectedObject">The object to select in the properties view.</param>
         private void OxyPlotToolBar_PropertiesCalled(OxyPlot.Wpf.Plot targetPlot, bool openProperties, OxyPlotControls.OxyPlotPropertiesControl.PropertyEXP? propertyExpander, object selectedObject)
         {
             if (propertyExpander.HasValue)
@@ -190,6 +220,11 @@ private void OxyPlotToolBar_PropertiesCalled(OxyPlot.Wpf.Plot targetPlot, bool o
             }
         }
 
+        /// <summary>
+        /// Saves the current plot settings to an XML file.
+        /// </summary>
+        /// <param name="sender">The save button that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void SaveSettingsButton_Click(object sender, RoutedEventArgs e)
         {
             string saveFile = GenericControls.GeneralMethods.FileSaveDialog("Plot Settings(*.xml) |*.xml", true);
@@ -212,6 +247,11 @@ private void SaveSettingsButton_Click(object sender, RoutedEventArgs e)
             }
         }
 
+        /// <summary>
+        /// Loads plot settings from an XML file.
+        /// </summary>
+        /// <param name="sender">The load button that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void LoadSettingsButton_Click(object sender, RoutedEventArgs e)
         {
             string fileToOpen = GenericControls.GeneralMethods.FileOpenDialog("Plot Settings(*.xml) |*.xml");
@@ -556,6 +596,10 @@ private void RegisterCategoryAxisLabels(string axisKey, System.Collections.IEnum
             _categoryAxisLabelsRegistry[axisKey] = labels;
         }
 
+        /// <summary>
+        /// Handles the demo properties-control close request.
+        /// </summary>
+        /// <param name="propertiesControl">The properties control requesting closure.</param>
         private void PropertiesControl_ClosePropertiesCalled(OxyPlotControls.OxyPlotPropertiesControl propertiesControl)
         {
             GenericControls.MessageBox.Show("Close plot properties requested.", "Plot Properties", MessageBoxButton.OK, MessageBoxImage.Information);
@@ -818,6 +862,11 @@ private void ReRenderButton_Click(object sender, RoutedEventArgs e)
             RenderTimeLabel.Text = $"{backendName} | Re-render in {sw.ElapsedMilliseconds} ms";
         }
 
+        /// <summary>
+        /// Rebuilds the demo plot for the selected sample series type.
+        /// </summary>
+        /// <param name="sender">The combo box that raised the event.</param>
+        /// <param name="e">The selection-change details.</param>
         private void ComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
         {
             var selectedItem = Combobox1.SelectedItem as ComboBoxItem;
@@ -950,6 +999,10 @@ private class DummyMultiPurposePoint
             public OxyColor Color { get; set; }
         }
 
+        /// <summary>
+        /// Builds the line-series demo plot.
+        /// </summary>
+        /// <param name="boundBool">Whether to create the series from bound data.</param>
         private void LineSeries_Create(bool boundBool)
         {
             TestPlot.Series.Clear();
@@ -1045,6 +1098,10 @@ private void LineSeries_Create(bool boundBool)
             TestPlot.InvalidatePlot(true);
         }
 
+        /// <summary>
+        /// Builds the scatter-series demo plot.
+        /// </summary>
+        /// <param name="boundBool">Whether to create the series from bound data.</param>
         private void ScatterSeries_Create(bool boundBool)
         {
             TestPlot.Series.Clear();
@@ -1145,6 +1202,10 @@ private void ScatterSeries_Create(bool boundBool)
             TestPlot.InvalidatePlot(true);
         }
 
+        /// <summary>
+        /// Builds the scatter-error-series demo plot.
+        /// </summary>
+        /// <param name="boundBool">Whether to create the series from bound data.</param>
         private void ScatterErrorSeries_Create(bool boundBool)
         {
             TestPlot.Series.Clear();
@@ -1254,6 +1315,10 @@ private void ScatterErrorSeries_Create(bool boundBool)
             TestPlot.InvalidatePlot(true);
         }
 
+        /// <summary>
+        /// Builds the heat-map-series demo plot.
+        /// </summary>
+        /// <param name="boundBool">Whether to create the series from bound data.</param>
         private void HeatMapSeries_Create(bool boundBool)
         {
             TestPlot.Series.Clear();
@@ -1340,6 +1405,10 @@ private void HeatMapSeries_Create(bool boundBool)
             TestPlot.InvalidatePlot(true);
         }
 
+        /// <summary>
+        /// Builds the histogram-series demo plot.
+        /// </summary>
+        /// <param name="boundBool">Whether to create the series from bound data.</param>
         private void HistogramSeries_Create(bool boundBool)
         {
             TestPlot.Series.Clear();
@@ -1404,6 +1473,10 @@ private void HistogramSeries_Create(bool boundBool)
             TestPlot.InvalidatePlot(true);
         }
 
+        /// <summary>
+        /// Builds the box-plot-series demo plot.
+        /// </summary>
+        /// <param name="boundBool">Whether to create the series from bound data.</param>
         private void BoxPlotSeries_Create(bool boundBool)
         {
             TestPlot.Series.Clear();
@@ -1486,6 +1559,10 @@ private void BoxPlotSeries_Create(bool boundBool)
             TestPlot.InvalidatePlot(true);
         }
 
+        /// <summary>
+        /// Builds the column-series demo plot.
+        /// </summary>
+        /// <param name="boundBool">Whether to create the series from bound data.</param>
         private void ColumnSeries_Create(bool boundBool)
         {
             TestPlot.Series.Clear();
@@ -1558,6 +1635,10 @@ private void ColumnSeries_Create(bool boundBool)
             TestPlot.InvalidatePlot(true);
         }
 
+        /// <summary>
+        /// Builds the bar-series demo plot.
+        /// </summary>
+        /// <param name="boundBool">Whether to create the series from bound data.</param>
         private void BarSeries_Create(bool boundBool)
         {
             TestPlot.Series.Clear();
@@ -1649,6 +1730,10 @@ private void BarSeries_Create(bool boundBool)
             TestPlot.InvalidatePlot(true);
         }
 
+        /// <summary>
+        /// Builds the area-series demo plot.
+        /// </summary>
+        /// <param name="boundBool">Whether to create the series from bound data.</param>
         private void AreaSeries_Create(bool boundBool)
         {
             TestPlot.Series.Clear();
@@ -1728,6 +1813,10 @@ private void AreaSeries_Create(bool boundBool)
             TestPlot.InvalidatePlot(true);
         }
 
+        /// <summary>
+        /// Builds the date-time-series demo plot.
+        /// </summary>
+        /// <param name="boundBool">Whether to create the series from bound data.</param>
         private void DateTimeSeries_Create(bool boundBool)
         {
             TestPlot.Series.Clear();
diff --git a/src/OxyPlotControls.Demo/OxyPlotControls.Demo.csproj b/src/OxyPlotControls.Demo/OxyPlotControls.Demo.csproj
index 3a572a9e..ff509663 100644
--- a/src/OxyPlotControls.Demo/OxyPlotControls.Demo.csproj
+++ b/src/OxyPlotControls.Demo/OxyPlotControls.Demo.csproj
@@ -1,4 +1,4 @@
-<!-- OxyPlotControls.Demo - Demo application for OxyPlotControls -->
+<!-- OxyPlotControls.Demo - Demo application for OxyPlotControls -->
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net10.0-windows</TargetFramework>
@@ -26,7 +26,7 @@
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\DatabaseManager\DatabaseManager.csproj" />
-    <PackageReference Include="RMC.Numerics" Version="2.0.1" />
+    <PackageReference Include="RMC.Numerics" />
     <ProjectReference Include="..\OxyPlot\OxyPlot\OxyPlot.csproj" />
     <ProjectReference Include="..\OxyPlot\OxyPlot.Wpf\OxyPlot.Wpf.csproj" />
     <ProjectReference Include="..\OxyPlot\OxyPlot.Wpf.Shared\OxyPlot.Wpf.Shared.csproj" />
diff --git a/src/OxyPlotControls.Demo/OxyPlotPropertiesDialog.xaml.cs b/src/OxyPlotControls.Demo/OxyPlotPropertiesDialog.xaml.cs
index 6c3386ae..c7eba806 100644
--- a/src/OxyPlotControls.Demo/OxyPlotPropertiesDialog.xaml.cs
+++ b/src/OxyPlotControls.Demo/OxyPlotPropertiesDialog.xaml.cs
@@ -20,6 +20,11 @@ public OxyPlotPropertiesDialog(Plot plot)
             PropertiesControl.Plot = plot;
         }
 
+        /// <summary>
+        /// Reactivates the owner window after the properties dialog closes.
+        /// </summary>
+        /// <param name="sender">The dialog that raised the event.</param>
+        /// <param name="e">The closing event data.</param>
         private void OxyPlotPropertiesDialog_Closing(object sender, CancelEventArgs e)
         {
             if (Owner != null)
diff --git a/src/OxyPlotControls/OxyPlotToolbar.xaml.cs b/src/OxyPlotControls/OxyPlotToolbar.xaml.cs
index b8e7ba6f..a5e51cfb 100644
--- a/src/OxyPlotControls/OxyPlotToolbar.xaml.cs
+++ b/src/OxyPlotControls/OxyPlotToolbar.xaml.cs
@@ -57,6 +57,11 @@ private static class CursorCache
             internal static readonly Cursor PanHandClosed = LoadCursor(Properties.Resources.Pan_Hand_Closed);
             internal static readonly Cursor Zoom = LoadCursor(Properties.Resources.ZoomIn);
 
+            /// <summary>
+            /// Creates a WPF cursor from embedded cursor bytes.
+            /// </summary>
+            /// <param name="cursorBytes">The embedded cursor resource bytes.</param>
+            /// <returns>The loaded cursor.</returns>
             private static Cursor LoadCursor(byte[] cursorBytes)
             {
                 using (var ms = new MemoryStream(cursorBytes))
@@ -839,6 +844,11 @@ private void AttachAnnotationHandlers(Wpf.Annotation annotation)
                 new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, annotation));
         }
 
+        /// <summary>
+        /// Gets the current screen position for a text annotation.
+        /// </summary>
+        /// <param name="annotation">The text annotation to inspect.</param>
+        /// <returns>The annotation screen point, or the plot center when no position is defined.</returns>
         private ScreenPoint GetCurrentTextAnnotationScreenPoint(Wpf.TextAnnotation annotation)
         {
             return annotation.TextPosition.IsDefined()
@@ -3352,6 +3362,13 @@ private DataPoint ConvertScreenPointToDataPoint(ScreenPoint pt)
                 : DataPoint.Undefined;
         }
 
+        /// <summary>
+        /// Resolves the x and y axes used by an annotation.
+        /// </summary>
+        /// <param name="annotation">The annotation whose axes are needed.</param>
+        /// <param name="xAxis">The resolved x-axis.</param>
+        /// <param name="yAxis">The resolved y-axis.</param>
+        /// <returns><c>true</c> when both axes are available; otherwise, <c>false</c>.</returns>
         private bool TryGetAnnotationAxes(Wpf.Annotation annotation, out OxyPlot.Axes.Axis xAxis, out OxyPlot.Axes.Axis yAxis)
         {
             var resolvedXAxis = annotation.InternalAnnotation.XAxis ?? Plot?.ActualModel?.DefaultXAxis;
@@ -3368,6 +3385,13 @@ private bool TryGetAnnotationAxes(Wpf.Annotation annotation, out OxyPlot.Axes.Ax
             return true;
         }
 
+        /// <summary>
+        /// Converts a screen point to an annotation data point.
+        /// </summary>
+        /// <param name="annotation">The annotation that supplies axes.</param>
+        /// <param name="screenPoint">The screen point to convert.</param>
+        /// <param name="dataPoint">The converted data point.</param>
+        /// <returns><c>true</c> when conversion succeeds and the point is valid.</returns>
         private bool TryScreenPointToDataPoint(Wpf.Annotation annotation, ScreenPoint screenPoint, out DataPoint dataPoint)
         {
             dataPoint = DataPoint.Undefined;
@@ -3391,6 +3415,13 @@ private bool TryScreenPointToDataPoint(Wpf.Annotation annotation, ScreenPoint sc
             return true;
         }
 
+        /// <summary>
+        /// Converts an annotation data point to a screen point.
+        /// </summary>
+        /// <param name="annotation">The annotation that supplies axes.</param>
+        /// <param name="dataPoint">The data point to convert.</param>
+        /// <param name="screenPoint">The converted screen point.</param>
+        /// <returns><c>true</c> when conversion succeeds and the point is finite.</returns>
         private bool TryDataPointToScreenPoint(Wpf.Annotation annotation, DataPoint dataPoint, out ScreenPoint screenPoint)
         {
             screenPoint = ScreenPoint.Undefined;
@@ -3410,6 +3441,15 @@ private bool TryDataPointToScreenPoint(Wpf.Annotation annotation, DataPoint data
             return true;
         }
 
+        /// <summary>
+        /// Offsets an annotation data point by a screen-space delta.
+        /// </summary>
+        /// <param name="annotation">The annotation that supplies axes.</param>
+        /// <param name="dataPoint">The source data point.</param>
+        /// <param name="dx">The horizontal screen offset.</param>
+        /// <param name="dy">The vertical screen offset.</param>
+        /// <param name="offsetDataPoint">The offset data point.</param>
+        /// <returns><c>true</c> when the offset point remains valid.</returns>
         private bool TryOffsetDataPoint(Wpf.Annotation annotation, DataPoint dataPoint, double dx, double dy, out DataPoint offsetDataPoint)
         {
             offsetDataPoint = DataPoint.Undefined;
@@ -3424,6 +3464,15 @@ private bool TryOffsetDataPoint(Wpf.Annotation annotation, DataPoint dataPoint,
                 out offsetDataPoint);
         }
 
+        /// <summary>
+        /// Offsets multiple annotation data points by a screen-space delta.
+        /// </summary>
+        /// <param name="annotation">The annotation that supplies axes.</param>
+        /// <param name="dataPoints">The source data points.</param>
+        /// <param name="dx">The horizontal screen offset.</param>
+        /// <param name="dy">The vertical screen offset.</param>
+        /// <param name="offsetDataPoints">The offset data points.</param>
+        /// <returns><c>true</c> when every point can be offset.</returns>
         private bool TryOffsetDataPoints(Wpf.Annotation annotation, IList<DataPoint> dataPoints, double dx, double dy, out List<DataPoint> offsetDataPoints)
         {
             offsetDataPoints = new List<DataPoint>(dataPoints.Count);
@@ -3441,6 +3490,14 @@ private bool TryOffsetDataPoints(Wpf.Annotation annotation, IList<DataPoint> dat
             return true;
         }
 
+        /// <summary>
+        /// Creates minimum data bounds around a screen-space center point.
+        /// </summary>
+        /// <param name="annotation">The annotation that supplies axes.</param>
+        /// <param name="center">The screen-space center for the bounds.</param>
+        /// <param name="minimumPoint">The lower data bound.</param>
+        /// <param name="maximumPoint">The upper data bound.</param>
+        /// <returns><c>true</c> when both bounds are valid data points.</returns>
         private bool TryCreateMinimumScreenBounds(Wpf.Annotation annotation, ScreenPoint center, out DataPoint minimumPoint, out DataPoint maximumPoint)
         {
             minimumPoint = DataPoint.Undefined;
@@ -3485,18 +3542,39 @@ private bool TryCreateMinimumScreenBounds(Wpf.Annotation annotation, ScreenPoint
             return IsValidDataPoint(annotation, minimumPoint) && IsValidDataPoint(annotation, maximumPoint);
         }
 
+        /// <summary>
+        /// Determines whether the mouse is within a screen-space tolerance of a data point.
+        /// </summary>
+        /// <param name="annotation">The annotation that supplies axes.</param>
+        /// <param name="dataPoint">The data point to test.</param>
+        /// <param name="mousePosition">The current mouse position.</param>
+        /// <param name="tolerance">The screen-space tolerance.</param>
+        /// <returns><c>true</c> when the mouse is near the point.</returns>
         private bool IsMouseNearDataPoint(Wpf.Annotation annotation, DataPoint dataPoint, ScreenPoint mousePosition, double tolerance)
         {
             return TryDataPointToScreenPoint(annotation, dataPoint, out var screenPoint)
                 && (screenPoint - mousePosition).Length < tolerance;
         }
 
+        /// <summary>
+        /// Determines whether a data point is valid for an annotation's axes.
+        /// </summary>
+        /// <param name="annotation">The annotation that supplies axes.</param>
+        /// <param name="dataPoint">The data point to test.</param>
+        /// <returns><c>true</c> when the point is defined, finite, and valid for both axes.</returns>
         private bool IsValidDataPoint(Wpf.Annotation annotation, DataPoint dataPoint)
         {
             return TryGetAnnotationAxes(annotation, out var xAxis, out var yAxis)
                 && IsValidDataPoint(xAxis, yAxis, dataPoint);
         }
 
+        /// <summary>
+        /// Determines whether a data point is valid for the specified axes.
+        /// </summary>
+        /// <param name="xAxis">The x-axis.</param>
+        /// <param name="yAxis">The y-axis.</param>
+        /// <param name="dataPoint">The data point to test.</param>
+        /// <returns><c>true</c> when the point is defined, finite, and valid for both axes.</returns>
         private static bool IsValidDataPoint(OxyPlot.Axes.Axis xAxis, OxyPlot.Axes.Axis yAxis, DataPoint dataPoint)
         {
             return dataPoint.IsDefined()
@@ -3506,11 +3584,23 @@ private static bool IsValidDataPoint(OxyPlot.Axes.Axis xAxis, OxyPlot.Axes.Axis
                 && yAxis.IsValidValue(dataPoint.Y);
         }
 
+        /// <summary>
+        /// Determines whether a double is neither NaN nor infinite.
+        /// </summary>
+        /// <param name="value">The value to test.</param>
+        /// <returns><c>true</c> when the value is finite.</returns>
         private static bool IsFinite(double value)
         {
             return !double.IsNaN(value) && !double.IsInfinity(value);
         }
 
+        /// <summary>
+        /// Clamps a value to the supplied inclusive range.
+        /// </summary>
+        /// <param name="value">The value to clamp.</param>
+        /// <param name="minimum">The minimum allowed value.</param>
+        /// <param name="maximum">The maximum allowed value.</param>
+        /// <returns>The clamped value.</returns>
         private static double Clamp(double value, double minimum, double maximum)
         {
             if (maximum < minimum)
@@ -4007,6 +4097,10 @@ private void ExportDataButton_Click(object sender, RoutedEventArgs e)
             ExportDataTablesToFile(BuildExportDataTables(Plot));
         }
 
+        /// <summary>
+        /// Prompts for an export path and writes the supplied data tables.
+        /// </summary>
+        /// <param name="tableList">The data tables to export.</param>
         private void ExportDataTablesToFile(IList<DataTable> tableList)
         {
             // Show save dialog
@@ -4103,6 +4197,12 @@ private void ExportDataTablesToFile(IList<DataTable> tableList)
             }
         }
 
+        /// <summary>
+        /// Extracts x and y export values for a data-point series item.
+        /// </summary>
+        /// <param name="wpfSeries">The WPF data-point series.</param>
+        /// <param name="item">The item to export.</param>
+        /// <returns>The exported x and y values.</returns>
         private static (object X, object Y) GetDataPointExportValue(Wpf.DataPointSeries wpfSeries, object? item)
         {
             if (item != null)
@@ -4178,6 +4278,12 @@ private static (object X, object Y) GetDataPointExportValue(Wpf.DataPointSeries
             }
         }
 
+        /// <summary>
+        /// Extracts x and y export values for a scatter-series item.
+        /// </summary>
+        /// <param name="wpfSeries">The WPF scatter series.</param>
+        /// <param name="item">The item to export.</param>
+        /// <returns>The exported x and y values.</returns>
         private static (object X, object Y) GetScatterPointExportValue(Wpf.ScatterPointSeries wpfSeries, object? item)
         {
             if (item != null)
@@ -4245,11 +4351,21 @@ private static (object X, object Y) GetScatterPointExportValue(Wpf.ScatterPointS
             }
         }
 
+        /// <summary>
+        /// Extracts central and error-bound values from a scatter error point.
+        /// </summary>
+        /// <param name="point">The scatter error point to export.</param>
+        /// <returns>The lower, central, and upper x and y values.</returns>
         private static (object XLower, object X, object XUpper, object YLower, object Y, object YUpper) GetScatterErrorPointExportValue(OxyPlot.Series.ScatterErrorPoint point)
         {
             return (point.LowerErrorX, point.X, point.UpperErrorX, point.LowerErrorY, point.Y, point.UpperErrorY);
         }
 
+        /// <summary>
+        /// Adds category-axis labels to an exported series table when present.
+        /// </summary>
+        /// <param name="series">The series whose axes are inspected.</param>
+        /// <param name="dataTable">The export table to update.</param>
         private static void AddCategoryAxisLabels(OxyPlot.Series.XYAxisSeries? series, DataTable dataTable)
         {
             if (series?.XAxis is OxyPlot.Axes.CategoryAxis xCategoryAxis)
@@ -4262,6 +4378,12 @@ private static void AddCategoryAxisLabels(OxyPlot.Series.XYAxisSeries? series, D
             }
         }
 
+        /// <summary>
+        /// Adds a category-label column from an OxyPlot category axis.
+        /// </summary>
+        /// <param name="categoryAxis">The category axis that supplies labels.</param>
+        /// <param name="dataTable">The export table to update.</param>
+        /// <param name="columnName">The export column name.</param>
         private static void AddCategoryAxisLabelColumn(OxyPlot.Axes.CategoryAxis categoryAxis, DataTable dataTable, string columnName)
         {
             dataTable.Columns.Add(columnName, typeof(string));
@@ -4290,6 +4412,13 @@ private static void AddCategoryAxisLabelColumn(OxyPlot.Axes.CategoryAxis categor
             }
         }
 
+        /// <summary>
+        /// Gets a string export value from a preferred or fallback property.
+        /// </summary>
+        /// <param name="source">The source item.</param>
+        /// <param name="propertyName">The preferred property name.</param>
+        /// <param name="fallbackPropertyName">The fallback property name.</param>
+        /// <returns>The property value converted to text, or an empty string.</returns>
         private static string GetExportPropertyValue(object? source, string? propertyName, string? fallbackPropertyName = null)
         {
             if (!string.IsNullOrWhiteSpace(propertyName))
@@ -4302,6 +4431,12 @@ private static string GetExportPropertyValue(object? source, string? propertyNam
                 : "";
         }
 
+        /// <summary>
+        /// Gets a property value as text, returning an empty string when unavailable.
+        /// </summary>
+        /// <param name="source">The source item.</param>
+        /// <param name="propertyName">The property name.</param>
+        /// <returns>The property value text, or an empty string.</returns>
         private static string GetPropertyValueOrEmpty(object? source, string? propertyName)
         {
             if (source == null || string.IsNullOrWhiteSpace(propertyName))
@@ -4317,6 +4452,13 @@ private static string GetPropertyValueOrEmpty(object? source, string? propertyNa
             return "";
         }
 
+        /// <summary>
+        /// Attempts to read a property value from a data row, data-row view, or CLR object.
+        /// </summary>
+        /// <param name="source">The source item.</param>
+        /// <param name="propertyName">The property name to read.</param>
+        /// <param name="value">The resolved property value.</param>
+        /// <returns><c>true</c> when the property is found.</returns>
         private static bool TryGetPropertyValue(object source, string propertyName, out object? value)
         {
             if (source is DataRow row && row.Table.Columns.Contains(propertyName))
diff --git a/src/OxyPlotControls/SavePlotImageDialog.xaml.cs b/src/OxyPlotControls/SavePlotImageDialog.xaml.cs
index 8107606d..3cd62092 100644
--- a/src/OxyPlotControls/SavePlotImageDialog.xaml.cs
+++ b/src/OxyPlotControls/SavePlotImageDialog.xaml.cs
@@ -389,6 +389,12 @@ private void SaveAsButton_Click(object sender, RoutedEventArgs e)
             Close();
         }
 
+        /// <summary>
+        /// Validates that the plot and requested export dimensions can be saved.
+        /// </summary>
+        /// <param name="imageWidth">The validated image width.</param>
+        /// <param name="imageHeight">The validated image height.</param>
+        /// <returns><c>true</c> when export inputs are valid.</returns>
         private bool TryValidateExportInputs(out int imageWidth, out int imageHeight)
         {
             imageWidth = 0;
@@ -409,6 +415,10 @@ private bool TryValidateExportInputs(out int imageWidth, out int imageHeight)
             return true;
         }
 
+        /// <summary>
+        /// Creates the configured save-file dialog for image export.
+        /// </summary>
+        /// <returns>The configured save-file dialog.</returns>
         private SaveFileDialog CreateSaveFileDialog()
         {
             var saveFileDialog = new SaveFileDialog
@@ -433,6 +443,10 @@ private SaveFileDialog CreateSaveFileDialog()
             return saveFileDialog;
         }
 
+        /// <summary>
+        /// Gets the initial folder for the image save dialog.
+        /// </summary>
+        /// <returns>The last used folder, pictures folder, or documents folder.</returns>
         private static string GetInitialDirectory()
         {
             if (!string.IsNullOrEmpty(_lastUsedFolderPath) && Directory.Exists(_lastUsedFolderPath))
@@ -449,6 +463,11 @@ private static string GetInitialDirectory()
             return Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
         }
 
+        /// <summary>
+        /// Builds a safe default image file name from the plot title.
+        /// </summary>
+        /// <param name="plotTitle">The optional plot title.</param>
+        /// <returns>A sanitized file name without an extension.</returns>
         private static string GetDefaultFileName(string? plotTitle)
         {
             string source = string.IsNullOrWhiteSpace(plotTitle) ? "plot" : plotTitle.Trim();
@@ -469,6 +488,12 @@ private static string GetDefaultFileName(string? plotTitle)
             return string.IsNullOrWhiteSpace(sanitized) ? "plot" : sanitized;
         }
 
+        /// <summary>
+        /// Ensures the selected export path has a supported extension.
+        /// </summary>
+        /// <param name="filePath">The path selected by the user.</param>
+        /// <param name="filterIndex">The selected file-dialog filter index.</param>
+        /// <returns>The export path with a supported extension.</returns>
         private static string GetExportFilePath(string filePath, int filterIndex)
         {
             string extension = Path.GetExtension(filePath).ToLowerInvariant();
@@ -480,6 +505,11 @@ private static string GetExportFilePath(string filePath, int filterIndex)
             return Path.ChangeExtension(filePath, GetExportExtensionForFilterIndex(filterIndex));
         }
 
+        /// <summary>
+        /// Maps a file-dialog filter index to the export extension.
+        /// </summary>
+        /// <param name="filterIndex">The selected file-dialog filter index.</param>
+        /// <returns>The extension for the selected filter.</returns>
         private static string GetExportExtensionForFilterIndex(int filterIndex)
         {
             return filterIndex switch
@@ -490,6 +520,11 @@ private static string GetExportExtensionForFilterIndex(int filterIndex)
             };
         }
 
+        /// <summary>
+        /// Determines whether an image export extension is supported.
+        /// </summary>
+        /// <param name="extension">The extension to test.</param>
+        /// <returns><c>true</c> when the extension is supported.</returns>
         private static bool IsSupportedExportExtension(string extension)
         {
             return string.Equals(extension, ".png", StringComparison.OrdinalIgnoreCase)
diff --git a/src/OxyPlotControls/Series/GenericSeriesControl.xaml.cs b/src/OxyPlotControls/Series/GenericSeriesControl.xaml.cs
index dffffaa4..010eeda8 100644
--- a/src/OxyPlotControls/Series/GenericSeriesControl.xaml.cs
+++ b/src/OxyPlotControls/Series/GenericSeriesControl.xaml.cs
@@ -274,7 +274,17 @@ public GenericSeriesControl()
             Unloaded += OnUnloaded;
         }
 
+        /// <summary>
+        /// Enables plot-change notifications after the control has loaded.
+        /// </summary>
+        /// <param name="sender">The control that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void OnLoaded(object sender, RoutedEventArgs e) => _suppressPlotChanged = false;
+        /// <summary>
+        /// Suppresses plot-change notifications while the control is unloaded.
+        /// </summary>
+        /// <param name="sender">The control that raised the event.</param>
+        /// <param name="e">The routed event data.</param>
         private void OnUnloaded(object sender, RoutedEventArgs e) { _suppressPlotChanged = true; }
 
         /// <summary>
diff --git a/src/Packaging/RMC.Wpf.Framework.Controls/RMC.Wpf.Framework.Controls.csproj b/src/Packaging/RMC.Wpf.Framework.Controls/RMC.Wpf.Framework.Controls.csproj
new file mode 100644
index 00000000..fd49048e
--- /dev/null
+++ b/src/Packaging/RMC.Wpf.Framework.Controls/RMC.Wpf.Framework.Controls.csproj
@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0-windows</TargetFramework>
+    <IsPackable>true</IsPackable>
+    <IncludeBuildOutput>false</IncludeBuildOutput>
+    <Version>1.0.0</Version>
+    <NuspecFile>RMC.Wpf.Framework.Controls.nuspec</NuspecFile>
+    <NuspecBasePath>$(MSBuildProjectDirectory)</NuspecBasePath>
+    <NuspecProperties>configuration=$(Configuration);version=$(Version);rmcNumericsPackageDependencyVersion=$(RmcNumericsPackageDependencyVersion)</NuspecProperties>
+  </PropertyGroup>
+</Project>
diff --git a/src/Packaging/RMC.Wpf.Framework.Controls/RMC.Wpf.Framework.Controls.nuspec b/src/Packaging/RMC.Wpf.Framework.Controls/RMC.Wpf.Framework.Controls.nuspec
new file mode 100644
index 00000000..0cf01fb8
--- /dev/null
+++ b/src/Packaging/RMC.Wpf.Framework.Controls/RMC.Wpf.Framework.Controls.nuspec
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd">
+  <metadata>
+    <id>RMC.Wpf.Framework.Controls</id>
+    <version>$version$</version>
+    <authors>C. Haden Smith, Woodrow L. Fields, Julian Gonzalez</authors>
+    <owners>USACE-RMC</owners>
+    <license type="expression">0BSD</license>
+    <projectUrl>https://github.com/USACE-RMC/WPF-Framework</projectUrl>
+    <repository type="git" url="https://github.com/USACE-RMC/WPF-Framework" />
+    <readme>README.md</readme>
+    <description>WPF controls, framework UI, DAG controls, database controls, numeric controls, OxyPlot controls, and AvalonDock assemblies for the RMC WPF Framework.</description>
+    <tags>RMC WPF framework controls AvalonDock OxyPlot numeric database DAG</tags>
+    <dependencies>
+      <group targetFramework="net10.0-windows7.0">
+        <dependency id="RMC.Wpf.Framework.Core" version="$version$" />
+        <dependency id="RMC.Wpf.Framework.Models" version="$version$" />
+        <dependency id="RMC.Wpf.Framework.Support" version="$version$" />
+        <dependency id="RMC.Numerics" version="$rmcNumericsPackageDependencyVersion$" />
+      </group>
+    </dependencies>
+  </metadata>
+  <files>
+    <file src="..\..\..\README.md" target="" />
+    <file src="..\..\GenericControls\bin\$configuration$\net10.0-windows\GenericControls.dll" target="lib\net10.0-windows7.0" />
+    <file src="..\..\GenericControls\bin\$configuration$\net10.0-windows\GenericControls.xml" target="lib\net10.0-windows7.0" />
+    <file src="..\..\FrameworkUI\bin\$configuration$\net10.0-windows\FrameworkUI.dll" target="lib\net10.0-windows7.0" />
+    <file src="..\..\FrameworkUI\bin\$configuration$\net10.0-windows\FrameworkUI.xml" target="lib\net10.0-windows7.0" />
+    <file src="..\..\DAGControls\bin\$configuration$\net10.0-windows\DAGControls.dll" target="lib\net10.0-windows7.0" />
+    <file src="..\..\DAGControls\bin\$configuration$\net10.0-windows\DAGControls.xml" target="lib\net10.0-windows7.0" />
+    <file src="..\..\DatabaseControls\bin\$configuration$\net10.0-windows\DatabaseControls.dll" target="lib\net10.0-windows7.0" />
+    <file src="..\..\DatabaseControls\bin\$configuration$\net10.0-windows\DatabaseControls.xml" target="lib\net10.0-windows7.0" />
+    <file src="..\..\ExpressionParserControls\bin\$configuration$\net10.0-windows\ExpressionParserControls.dll" target="lib\net10.0-windows7.0" />
+    <file src="..\..\ExpressionParserControls\bin\$configuration$\net10.0-windows\ExpressionParserControls.xml" target="lib\net10.0-windows7.0" />
+    <file src="..\..\NumericControls\bin\$configuration$\net10.0-windows\NumericControls.dll" target="lib\net10.0-windows7.0" />
+    <file src="..\..\NumericControls\bin\$configuration$\net10.0-windows\NumericControls.xml" target="lib\net10.0-windows7.0" />
+    <file src="..\..\OxyPlotControls\bin\$configuration$\net10.0-windows\OxyPlotControls.dll" target="lib\net10.0-windows7.0" />
+    <file src="..\..\OxyPlotControls\bin\$configuration$\net10.0-windows\OxyPlotControls.xml" target="lib\net10.0-windows7.0" />
+    <file src="..\..\AvalonDock\Xceed.Wpf.AvalonDock\bin\$configuration$\net10.0-windows\Xceed.Wpf.AvalonDock.dll" target="lib\net10.0-windows7.0" />
+    <file src="..\..\AvalonDock\Xceed.Wpf.AvalonDock.Themes.VS2013\bin\$configuration$\net10.0-windows\Xceed.Wpf.AvalonDock.Themes.VS2013.dll" target="lib\net10.0-windows7.0" />
+  </files>
+</package>
diff --git a/src/Packaging/RMC.Wpf.Framework.Core/RMC.Wpf.Framework.Core.csproj b/src/Packaging/RMC.Wpf.Framework.Core/RMC.Wpf.Framework.Core.csproj
new file mode 100644
index 00000000..a06d7f63
--- /dev/null
+++ b/src/Packaging/RMC.Wpf.Framework.Core/RMC.Wpf.Framework.Core.csproj
@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0-windows</TargetFramework>
+    <IsPackable>true</IsPackable>
+    <IncludeBuildOutput>false</IncludeBuildOutput>
+    <Version>1.0.0</Version>
+    <NuspecFile>RMC.Wpf.Framework.Core.nuspec</NuspecFile>
+    <NuspecBasePath>$(MSBuildProjectDirectory)</NuspecBasePath>
+    <NuspecProperties>configuration=$(Configuration);version=$(Version)</NuspecProperties>
+  </PropertyGroup>
+</Project>
diff --git a/src/Packaging/RMC.Wpf.Framework.Core/RMC.Wpf.Framework.Core.nuspec b/src/Packaging/RMC.Wpf.Framework.Core/RMC.Wpf.Framework.Core.nuspec
new file mode 100644
index 00000000..c32a4f6b
--- /dev/null
+++ b/src/Packaging/RMC.Wpf.Framework.Core/RMC.Wpf.Framework.Core.nuspec
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd">
+  <metadata>
+    <id>RMC.Wpf.Framework.Core</id>
+    <version>$version$</version>
+    <authors>C. Haden Smith, Woodrow L. Fields, Julian Gonzalez</authors>
+    <owners>USACE-RMC</owners>
+    <license type="expression">0BSD</license>
+    <projectUrl>https://github.com/USACE-RMC/WPF-Framework</projectUrl>
+    <repository type="git" url="https://github.com/USACE-RMC/WPF-Framework" />
+    <readme>README.md</readme>
+    <description>Core interfaces, project model contracts, undo/redo infrastructure, messaging, and WPF themes for the RMC WPF Framework.</description>
+    <tags>RMC WPF framework themes undo-redo</tags>
+    <dependencies>
+      <group targetFramework="net10.0-windows7.0" />
+    </dependencies>
+  </metadata>
+  <files>
+    <file src="..\..\..\README.md" target="" />
+    <file src="..\..\FrameworkInterfaces\bin\$configuration$\net10.0-windows\FrameworkInterfaces.dll" target="lib\net10.0-windows7.0" />
+    <file src="..\..\FrameworkInterfaces\bin\$configuration$\net10.0-windows\FrameworkInterfaces.xml" target="lib\net10.0-windows7.0" />
+    <file src="..\..\Themes\bin\$configuration$\net10.0-windows\Themes.dll" target="lib\net10.0-windows7.0" />
+    <file src="..\..\Themes\bin\$configuration$\net10.0-windows\Themes.xml" target="lib\net10.0-windows7.0" />
+  </files>
+</package>
diff --git a/src/Packaging/RMC.Wpf.Framework.Models/RMC.Wpf.Framework.Models.csproj b/src/Packaging/RMC.Wpf.Framework.Models/RMC.Wpf.Framework.Models.csproj
new file mode 100644
index 00000000..d7fa2d5b
--- /dev/null
+++ b/src/Packaging/RMC.Wpf.Framework.Models/RMC.Wpf.Framework.Models.csproj
@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0-windows</TargetFramework>
+    <IsPackable>true</IsPackable>
+    <IncludeBuildOutput>false</IncludeBuildOutput>
+    <Version>1.0.0</Version>
+    <NuspecFile>RMC.Wpf.Framework.Models.nuspec</NuspecFile>
+    <NuspecBasePath>$(MSBuildProjectDirectory)</NuspecBasePath>
+    <NuspecProperties>configuration=$(Configuration);version=$(Version);closedXmlVersion=$(ClosedXmlVersion);documentFormatOpenXmlVersion=$(DocumentFormatOpenXmlVersion);excelNumberFormatVersion=$(ExcelNumberFormatVersion);fastMemberVersion=$(FastMemberVersion);sourceGearSqlite3Version=$(SourceGearSqlite3Version);systemDataSQLiteVersion=$(SystemDataSQLiteVersion)</NuspecProperties>
+  </PropertyGroup>
+</Project>
diff --git a/src/Packaging/RMC.Wpf.Framework.Models/RMC.Wpf.Framework.Models.nuspec b/src/Packaging/RMC.Wpf.Framework.Models/RMC.Wpf.Framework.Models.nuspec
new file mode 100644
index 00000000..26fde9aa
--- /dev/null
+++ b/src/Packaging/RMC.Wpf.Framework.Models/RMC.Wpf.Framework.Models.nuspec
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd">
+  <metadata>
+    <id>RMC.Wpf.Framework.Models</id>
+    <version>$version$</version>
+    <authors>C. Haden Smith, Woodrow L. Fields, Julian Gonzalez</authors>
+    <owners>USACE-RMC</owners>
+    <license type="expression">0BSD</license>
+    <projectUrl>https://github.com/USACE-RMC/WPF-Framework</projectUrl>
+    <repository type="git" url="https://github.com/USACE-RMC/WPF-Framework" />
+    <readme>README.md</readme>
+    <description>Model, graph, database, expression-parser, and vendored OxyPlot assemblies for the RMC WPF Framework.</description>
+    <tags>RMC WPF framework database expression-parser DAG OxyPlot</tags>
+    <dependencies>
+      <group targetFramework="net10.0-windows7.0">
+        <dependency id="ClosedXML" version="$closedXmlVersion$" />
+        <dependency id="DocumentFormat.OpenXml" version="$documentFormatOpenXmlVersion$" />
+        <dependency id="ExcelNumberFormat" version="$excelNumberFormatVersion$" />
+        <dependency id="FastMember" version="$fastMemberVersion$" />
+        <dependency id="SourceGear.sqlite3" version="$sourceGearSqlite3Version$" />
+        <dependency id="System.Data.SQLite" version="$systemDataSQLiteVersion$" />
+      </group>
+    </dependencies>
+  </metadata>
+  <files>
+    <file src="..\..\..\README.md" target="" />
+    <file src="..\..\DAG\bin\$configuration$\net10.0\DAG.dll" target="lib\net10.0-windows7.0" />
+    <file src="..\..\DAG\bin\$configuration$\net10.0\DAG.xml" target="lib\net10.0-windows7.0" />
+    <file src="..\..\DatabaseManager\bin\$configuration$\net10.0\DatabaseManager.dll" target="lib\net10.0-windows7.0" />
+    <file src="..\..\DatabaseManager\bin\$configuration$\net10.0\DatabaseManager.xml" target="lib\net10.0-windows7.0" />
+    <file src="..\..\ExpressionParser\bin\$configuration$\net10.0\ExpressionParser.dll" target="lib\net10.0-windows7.0" />
+    <file src="..\..\ExpressionParser\bin\$configuration$\net10.0\ExpressionParser.xml" target="lib\net10.0-windows7.0" />
+    <file src="..\..\OxyPlot\OxyPlot\bin\$configuration$\net10.0\OxyPlot.dll" target="lib\net10.0-windows7.0" />
+    <file src="..\..\OxyPlot\OxyPlot\bin\$configuration$\net10.0\OxyPlot.xml" target="lib\net10.0-windows7.0" />
+    <file src="..\..\OxyPlot\OxyPlot.Wpf\bin\$configuration$\net10.0-windows\OxyPlot.Wpf.dll" target="lib\net10.0-windows7.0" />
+    <file src="..\..\OxyPlot\OxyPlot.Wpf\bin\$configuration$\net10.0-windows\OxyPlot.Wpf.xml" target="lib\net10.0-windows7.0" />
+    <file src="..\..\OxyPlot\OxyPlot.Wpf.Shared\bin\$configuration$\net10.0-windows\OxyPlot.Wpf.Shared.dll" target="lib\net10.0-windows7.0" />
+    <file src="..\..\OxyPlot\OxyPlot.Wpf.Shared\bin\$configuration$\net10.0-windows\OxyPlot.Wpf.Shared.xml" target="lib\net10.0-windows7.0" />
+  </files>
+</package>
diff --git a/src/Packaging/RMC.Wpf.Framework.Support/RMC.Wpf.Framework.Support.csproj b/src/Packaging/RMC.Wpf.Framework.Support/RMC.Wpf.Framework.Support.csproj
new file mode 100644
index 00000000..1389cbd4
--- /dev/null
+++ b/src/Packaging/RMC.Wpf.Framework.Support/RMC.Wpf.Framework.Support.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0-windows</TargetFramework>
+    <IsPackable>true</IsPackable>
+    <IncludeBuildOutput>false</IncludeBuildOutput>
+    <Version>1.0.0</Version>
+    <!-- The updater executable payload is intentionally packaged as deployable content, not a compile reference. -->
+    <NoWarn>$(NoWarn);NU5100</NoWarn>
+    <NuspecFile>RMC.Wpf.Framework.Support.nuspec</NuspecFile>
+    <NuspecBasePath>$(MSBuildProjectDirectory)</NuspecBasePath>
+    <NuspecProperties>configuration=$(Configuration);version=$(Version)</NuspecProperties>
+  </PropertyGroup>
+</Project>
diff --git a/src/Packaging/RMC.Wpf.Framework.Support/RMC.Wpf.Framework.Support.nuspec b/src/Packaging/RMC.Wpf.Framework.Support/RMC.Wpf.Framework.Support.nuspec
new file mode 100644
index 00000000..f4706aa3
--- /dev/null
+++ b/src/Packaging/RMC.Wpf.Framework.Support/RMC.Wpf.Framework.Support.nuspec
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd">
+  <metadata>
+    <id>RMC.Wpf.Framework.Support</id>
+    <version>$version$</version>
+    <authors>C. Haden Smith, Woodrow L. Fields, Julian Gonzalez</authors>
+    <owners>USACE-RMC</owners>
+    <license type="expression">0BSD</license>
+    <projectUrl>https://github.com/USACE-RMC/WPF-Framework</projectUrl>
+    <repository type="git" url="https://github.com/USACE-RMC/WPF-Framework" />
+    <readme>README.md</readme>
+    <description>Software update services and deployable updater helper for the RMC WPF Framework.</description>
+    <tags>RMC WPF framework software-update updater</tags>
+    <dependencies>
+      <group targetFramework="net10.0-windows7.0" />
+    </dependencies>
+    <contentFiles>
+      <files include="any/net10.0-windows7.0/SoftwareUpdate.Updater.exe" buildAction="None" copyToOutput="true" flatten="true" />
+      <files include="any/net10.0-windows7.0/SoftwareUpdate.Updater.dll" buildAction="None" copyToOutput="true" flatten="true" />
+      <files include="any/net10.0-windows7.0/SoftwareUpdate.Updater.deps.json" buildAction="None" copyToOutput="true" flatten="true" />
+      <files include="any/net10.0-windows7.0/SoftwareUpdate.Updater.runtimeconfig.json" buildAction="None" copyToOutput="true" flatten="true" />
+    </contentFiles>
+  </metadata>
+  <files>
+    <file src="..\..\..\README.md" target="" />
+    <file src="..\..\SoftwareUpdate\bin\$configuration$\net10.0-windows\SoftwareUpdate.dll" target="lib\net10.0-windows7.0" />
+    <file src="..\..\SoftwareUpdate\bin\$configuration$\net10.0-windows\SoftwareUpdate.xml" target="lib\net10.0-windows7.0" />
+    <file src="..\..\SoftwareUpdate.Updater\bin\$configuration$\net10.0-windows\SoftwareUpdate.Updater.exe" target="contentFiles\any\net10.0-windows7.0" />
+    <file src="..\..\SoftwareUpdate.Updater\bin\$configuration$\net10.0-windows\SoftwareUpdate.Updater.dll" target="contentFiles\any\net10.0-windows7.0" />
+    <file src="..\..\SoftwareUpdate.Updater\bin\$configuration$\net10.0-windows\SoftwareUpdate.Updater.deps.json" target="contentFiles\any\net10.0-windows7.0" />
+    <file src="..\..\SoftwareUpdate.Updater\bin\$configuration$\net10.0-windows\SoftwareUpdate.Updater.runtimeconfig.json" target="contentFiles\any\net10.0-windows7.0" />
+  </files>
+</package>
diff --git a/tests/DAG.Tests/DAG.Tests.csproj b/tests/DAG.Tests/DAG.Tests.csproj
index 025b296d..0240742d 100644
--- a/tests/DAG.Tests/DAG.Tests.csproj
+++ b/tests/DAG.Tests/DAG.Tests.csproj
@@ -12,10 +12,10 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="MSTest.TestAdapter" Version="3.5.2" />
-    <PackageReference Include="MSTest.TestFramework" Version="3.5.2" />
-    <PackageReference Include="coverlet.collector" Version="6.0.0">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="MSTest.TestAdapter" />
+    <PackageReference Include="MSTest.TestFramework" />
+    <PackageReference Include="coverlet.collector">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
diff --git a/tests/Documentation.Tests/Snippets/DagSnippets.cs b/tests/Documentation.Tests/Snippets/DagSnippets.cs
index 0874edf2..f0580cbe 100644
--- a/tests/Documentation.Tests/Snippets/DagSnippets.cs
+++ b/tests/Documentation.Tests/Snippets/DagSnippets.cs
@@ -34,11 +34,6 @@ public double ManningsN
             }
         }
 
-        // NOTE: The doc shows `Utilities.SetDouble(value, ref _manningsN, PropertyChanged, this)`
-        // which works only inside NodeBase itself, not from a subclass. From a subclass, use
-        // RaisePropertyChanged() instead. This is a doc issue to fix.
-        // TODO: docs/dag-controls.md should show the RaisePropertyChanged pattern for subclasses.
-
         public HydraulicNode()
         {
             Inputs.Add(new InConnector("Upstream Flow", "cfs", this));
diff --git a/tests/Documentation.Tests/Snippets/DatabaseSnippets.cs b/tests/Documentation.Tests/Snippets/DatabaseSnippets.cs
index 6f521718..dc417be3 100644
--- a/tests/Documentation.Tests/Snippets/DatabaseSnippets.cs
+++ b/tests/Documentation.Tests/Snippets/DatabaseSnippets.cs
@@ -22,9 +22,6 @@ public void Snippet_OpenSQLite()
             var db = new SQLiteManager("data.sqlite");
             db.Open();
             DataTableView table = db.GetTableManager("MyTable");
-            // NOTE: The doc shows `table.GetValue(column: 0, row: 0)` but the actual API
-            // is `GetCell(columnIndex, rowIndex)`. This is a doc issue to fix.
-            // TODO: docs/database-controls.md should use GetCell instead of GetValue.
             object val = table.GetCell(0, 0);
 
             // SQLite with password
@@ -74,10 +71,6 @@ public void Snippet_EditTracking()
             db.Open();
             var table = db.GetTableManager("MyTable");
 
-            // NOTE: The doc shows `table.SetValue(0, 0, "NewValue")` but the actual API
-            // is `EditCell(rowIndex, columnIndex, value)`. The doc also shows `Undo()`/`Redo()`
-            // but the actual API is `UndoEdit()`/`RedoEdit()`. These are doc issues to fix.
-            // TODO: docs/database-controls.md should use EditCell, UndoEdit, RedoEdit, ApplyEdits.
             table.EditCell(0, 0, "NewValue");   // Records a CellEdit
             table.UndoEdit();                    // Reverts to previous value
             table.RedoEdit();                    // Reapplies "NewValue"
@@ -98,9 +91,6 @@ public void Snippet_ExpressionParser()
                 });
 
             // Set variable values before evaluation
-            // NOTE: The doc shows `varNode.Value = new ParseNodeResult(...)` but the actual API
-            // is `varNode.SetValue(object)` which accepts a raw value, not a ParseNodeResult.
-            // TODO: docs/database-controls.md should use varNode.SetValue(42.0) instead.
             foreach (var varNode in node.GetVariableNodes())
             {
                 varNode.SetValue(42.0);
diff --git a/tests/Documentation.Tests/Snippets/GettingStartedSnippets.cs b/tests/Documentation.Tests/Snippets/GettingStartedSnippets.cs
index 70697224..c596274d 100644
--- a/tests/Documentation.Tests/Snippets/GettingStartedSnippets.cs
+++ b/tests/Documentation.Tests/Snippets/GettingStartedSnippets.cs
@@ -49,13 +49,13 @@ private MyProject()
 
         public override string Name
         {
-            get => NameField;
+            get => _name;
             set
             {
-                if (NameField != value)
+                if (_name != value)
                 {
-                    var oldValue = NameField;
-                    NameField = value;
+                    var oldValue = _name;
+                    _name = value;
                     RecordPropertyChange(nameof(Name), oldValue, value);
                 }
             }
@@ -283,10 +283,6 @@ protected override void DefineProjectExplorerMenuItems()
         public override Control GetDocumentControl(IElement element)
         {
             // Return the editor control for the given element
-            // NOTE: The doc shows `return new TextBlock { Text = element.Name }` but TextBlock
-            // does not inherit from Control in WPF. The correct approach is to use a ContentControl
-            // or UserControl wrapper. This is a doc issue to fix.
-            // TODO: docs/getting-started.md should return a Control subclass, not TextBlock.
             return new ContentControl { Content = new TextBlock { Text = element.Name } };
         }
 
diff --git a/tests/Documentation.Tests/Snippets/UndoRedoSnippets.cs b/tests/Documentation.Tests/Snippets/UndoRedoSnippets.cs
index 0dfe4f0f..7f446388 100644
--- a/tests/Documentation.Tests/Snippets/UndoRedoSnippets.cs
+++ b/tests/Documentation.Tests/Snippets/UndoRedoSnippets.cs
@@ -4,6 +4,7 @@
 #pragma warning disable CS8603 // Possible null reference return
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value
 #pragma warning disable CS0414 // Field is assigned but its value is never used
+#pragma warning disable CS0067 // Event is declared to satisfy an interface in snippet stubs
 
 using System.Collections.ObjectModel;
 using System.ComponentModel;
@@ -285,10 +286,6 @@ public void Snippet_NestedTransactions(IUndoManager undoManager)
         // ---------------------------------------------------------------
         // Snippet: Transaction rollback
         // ---------------------------------------------------------------
-        // NOTE: The doc shows CommitTransaction/RollbackTransaction on IUndoManager, but
-        // these methods only exist on the concrete UndoManager class.
-        // TODO: docs/undo-redo.md should either use UndoManager instead of IUndoManager in
-        // the rollback example, or add these methods to IUndoManager.
         public void Snippet_TransactionRollback(UndoManager undoManager)
         {
             var transaction = undoManager.BeginTransaction("Risky operation");
diff --git a/tests/FrameworkInterfaces.Tests/FrameworkInterfaces.Tests.csproj b/tests/FrameworkInterfaces.Tests/FrameworkInterfaces.Tests.csproj
index 38ebe1ef..b1a427d7 100644
--- a/tests/FrameworkInterfaces.Tests/FrameworkInterfaces.Tests.csproj
+++ b/tests/FrameworkInterfaces.Tests/FrameworkInterfaces.Tests.csproj
@@ -10,13 +10,13 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="coverlet.collector" Version="6.0.2">
+    <PackageReference Include="coverlet.collector">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="xunit" Version="2.9.2" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
diff --git a/tests/FrameworkUI.Tests/FrameworkUI.Tests.csproj b/tests/FrameworkUI.Tests/FrameworkUI.Tests.csproj
index fe391f7f..a7559a0c 100644
--- a/tests/FrameworkUI.Tests/FrameworkUI.Tests.csproj
+++ b/tests/FrameworkUI.Tests/FrameworkUI.Tests.csproj
@@ -10,14 +10,14 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="coverlet.collector" Version="6.0.2">
+    <PackageReference Include="coverlet.collector">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="xunit" Version="2.9.2" />
-    <PackageReference Include="Xunit.StaFact" Version="1.1.11" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="Xunit.StaFact" />
+    <PackageReference Include="xunit.runner.visualstudio">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
diff --git a/tests/GenericControls.Tests/GenericControls.Tests.csproj b/tests/GenericControls.Tests/GenericControls.Tests.csproj
index 04518ea8..7d21d66f 100644
--- a/tests/GenericControls.Tests/GenericControls.Tests.csproj
+++ b/tests/GenericControls.Tests/GenericControls.Tests.csproj
@@ -10,13 +10,13 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="coverlet.collector" Version="6.0.2">
+    <PackageReference Include="coverlet.collector">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="xunit" Version="2.9.2" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
diff --git a/tests/NumericControls.Tests/NumericControls.Tests.csproj b/tests/NumericControls.Tests/NumericControls.Tests.csproj
index 52948f23..dea9544b 100644
--- a/tests/NumericControls.Tests/NumericControls.Tests.csproj
+++ b/tests/NumericControls.Tests/NumericControls.Tests.csproj
@@ -10,14 +10,14 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="coverlet.collector" Version="6.0.2">
+    <PackageReference Include="coverlet.collector">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="xunit" Version="2.9.2" />
-    <PackageReference Include="Xunit.StaFact" Version="1.1.11" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="Xunit.StaFact" />
+    <PackageReference Include="xunit.runner.visualstudio">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
@@ -29,7 +29,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="RMC.Numerics" Version="2.0.1" />
+    <PackageReference Include="RMC.Numerics" />
   </ItemGroup>
 
 </Project>
diff --git a/tests/OxyPlot.Tests/OxyPlot.Tests.csproj b/tests/OxyPlot.Tests/OxyPlot.Tests.csproj
index 26ec73cd..0868e859 100644
--- a/tests/OxyPlot.Tests/OxyPlot.Tests.csproj
+++ b/tests/OxyPlot.Tests/OxyPlot.Tests.csproj
@@ -13,10 +13,10 @@
     <ProjectReference Include="..\..\src\OxyPlot\OxyPlot\OxyPlot.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="NSubstitute" Version="4.2.1" />
-    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="NSubstitute" />
+    <PackageReference Include="NUnit" />
+    <PackageReference Include="NUnit3TestAdapter" />
   </ItemGroup>
   <ItemGroup>
     <Content Include="Schemas\svg.xsd">
diff --git a/tests/OxyPlot.Wpf.Tests/OxyPlot.Wpf.Tests.csproj b/tests/OxyPlot.Wpf.Tests/OxyPlot.Wpf.Tests.csproj
index aa6e6495..d74f7cd3 100644
--- a/tests/OxyPlot.Wpf.Tests/OxyPlot.Wpf.Tests.csproj
+++ b/tests/OxyPlot.Wpf.Tests/OxyPlot.Wpf.Tests.csproj
@@ -13,9 +13,9 @@
     <ProjectReference Include="..\..\src\OxyPlot\OxyPlot.Wpf\OxyPlot.Wpf.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="NSubstitute" Version="4.2.1" />
-    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="NSubstitute" />
+    <PackageReference Include="NUnit" />
+    <PackageReference Include="NUnit3TestAdapter" />
   </ItemGroup>
 </Project>
diff --git a/tests/OxyPlotControls.Tests/OxyPlotControls.Tests.csproj b/tests/OxyPlotControls.Tests/OxyPlotControls.Tests.csproj
index ecea9a71..0a353e78 100644
--- a/tests/OxyPlotControls.Tests/OxyPlotControls.Tests.csproj
+++ b/tests/OxyPlotControls.Tests/OxyPlotControls.Tests.csproj
@@ -10,14 +10,14 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="coverlet.collector" Version="6.0.2">
+    <PackageReference Include="coverlet.collector">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="xunit" Version="2.9.2" />
-    <PackageReference Include="Xunit.StaFact" Version="1.1.11" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="Xunit.StaFact" />
+    <PackageReference Include="xunit.runner.visualstudio">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
diff --git a/tests/SoftwareUpdate.Tests/SoftwareUpdate.Tests.csproj b/tests/SoftwareUpdate.Tests/SoftwareUpdate.Tests.csproj
index f4d4e187..704da8f1 100644
--- a/tests/SoftwareUpdate.Tests/SoftwareUpdate.Tests.csproj
+++ b/tests/SoftwareUpdate.Tests/SoftwareUpdate.Tests.csproj
@@ -10,13 +10,13 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="coverlet.collector" Version="6.0.2">
+    <PackageReference Include="coverlet.collector">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="xunit" Version="2.9.2" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
diff --git a/tests/SoftwareUpdate.Updater.Tests/SoftwareUpdate.Updater.Tests.csproj b/tests/SoftwareUpdate.Updater.Tests/SoftwareUpdate.Updater.Tests.csproj
index 64fff4cb..24b437f5 100644
--- a/tests/SoftwareUpdate.Updater.Tests/SoftwareUpdate.Updater.Tests.csproj
+++ b/tests/SoftwareUpdate.Updater.Tests/SoftwareUpdate.Updater.Tests.csproj
@@ -9,13 +9,13 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="coverlet.collector" Version="6.0.2">
+    <PackageReference Include="coverlet.collector">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="xunit" Version="2.9.2" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
diff --git a/tests/Themes.Tests/Themes.Tests.csproj b/tests/Themes.Tests/Themes.Tests.csproj
index 6ecfce84..bf9f04de 100644
--- a/tests/Themes.Tests/Themes.Tests.csproj
+++ b/tests/Themes.Tests/Themes.Tests.csproj
@@ -10,13 +10,13 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="coverlet.collector" Version="6.0.2">
+    <PackageReference Include="coverlet.collector">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="xunit" Version="2.9.2" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>

From 51b839f99a225e8badaaf0dc05889156c98c8041 Mon Sep 17 00:00:00 2001
From: HadenSmith <cole.h.smith@usace.army.mil>
Date: Tue, 30 Jun 2026 11:28:02 -0600
Subject: [PATCH 10/11] chore: update packaging workflows and docs

---
 .github/workflows/Integration.yml             |  43 +--
 .github/workflows/NuGetPublish.yml            |  70 +++++
 .github/workflows/Release.yml                 |  55 ++++
 README.md                                     |  15 +-
 docs/assets/gallery/README.md                 |  54 ++++
 docs/gallery.md                               | 245 ++++++++++++++++++
 docs/index.md                                 |   1 +
 scripts/pack-wpf-framework.ps1                |  10 +-
 .../Serialization/AnnotationSerializer.cs     |   4 +-
 9 files changed, 452 insertions(+), 45 deletions(-)
 create mode 100644 .github/workflows/NuGetPublish.yml
 create mode 100644 .github/workflows/Release.yml
 create mode 100644 docs/assets/gallery/README.md
 create mode 100644 docs/gallery.md

diff --git a/.github/workflows/Integration.yml b/.github/workflows/Integration.yml
index 827688b7..e324cb8f 100644
--- a/.github/workflows/Integration.yml
+++ b/.github/workflows/Integration.yml
@@ -2,43 +2,14 @@ name: Integration
 
 on:
   pull_request:
-    branches: [main]
+    branches: [ main ]
   push:
-    branches: [main]
+    branches: [ main ]
   workflow_dispatch:
 
 jobs:
-  build-and-test:
-    name: Build and Test
-    runs-on: windows-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup .NET
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: 10.0.x
-
-      - name: Restore
-        run: dotnet restore WPF-Framework.sln
-
-      - name: Build
-        run: dotnet build WPF-Framework.sln --no-restore --configuration Release
-
-      - name: Test
-        run: >-
-          dotnet test WPF-Framework.sln
-          --no-build
-          --configuration Release
-          --logger "trx;LogFileName=TestResults.trx"
-          --results-directory TestResults
-
-      - name: Upload test results
-        if: failure()
-        uses: actions/upload-artifact@v4
-        with:
-          name: test-results
-          path: TestResults/**/*.trx
-          retention-days: 14
+  CI:
+    uses: HydrologicEngineeringCenter/dotnet-workflows/.github/workflows/integration.yml@main
+    with:
+      dotnet-version: '10.0.x'
+      run-tests: true
diff --git a/.github/workflows/NuGetPublish.yml b/.github/workflows/NuGetPublish.yml
new file mode 100644
index 00000000..62e683d4
--- /dev/null
+++ b/.github/workflows/NuGetPublish.yml
@@ -0,0 +1,70 @@
+name: Publish to NuGet.org
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  publish:
+    runs-on: windows-latest
+    timeout-minutes: 90
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup .NET SDK
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Extract version from tag
+        shell: pwsh
+        run: |
+          $version = $env:GITHUB_REF_NAME -replace '^v', ''
+          "VERSION=$version" >> $env:GITHUB_ENV
+
+      - name: Restore
+        run: dotnet restore WPF-Framework.sln
+
+      - name: Build
+        shell: pwsh
+        run: dotnet build WPF-Framework.sln -c Release --no-restore /p:Version=$env:VERSION
+
+      - name: Test
+        env:
+          VSTEST_CONNECTION_TIMEOUT: '600'
+        run: dotnet test WPF-Framework.sln -c Release --no-build
+
+      - name: Pack
+        shell: pwsh
+        run: .\scripts\pack-wpf-framework.ps1 -Configuration Release -Version $env:VERSION -OutputDirectory packages -SkipRestore -SkipBuild
+
+      - name: Push to NuGet.org
+        shell: pwsh
+        env:
+          NUGET_API_KEY: ${{ secrets.NUGET_ORG_API_KEY }}
+        run: |
+          $packageIds = @(
+            "RMC.Wpf.Framework.Core",
+            "RMC.Wpf.Framework.Models",
+            "RMC.Wpf.Framework.Support",
+            "RMC.Wpf.Framework.Controls"
+          )
+
+          foreach ($packageId in $packageIds) {
+            $packagePath = Join-Path "packages" "$packageId.$env:VERSION.nupkg"
+            if (-not (Test-Path $packagePath)) {
+              throw "Missing package: $packagePath"
+            }
+
+            dotnet nuget push $packagePath --api-key $env:NUGET_API_KEY --source "https://api.nuget.org/v3/index.json" --skip-duplicate
+            if ($LASTEXITCODE -ne 0) {
+              throw "NuGet push failed for $packagePath."
+            }
+          }
diff --git a/.github/workflows/Release.yml b/.github/workflows/Release.yml
new file mode 100644
index 00000000..90c22d0c
--- /dev/null
+++ b/.github/workflows/Release.yml
@@ -0,0 +1,55 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: windows-latest
+    timeout-minutes: 90
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup .NET SDK
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Create version number
+        shell: pwsh
+        run: |
+          $tag = $env:GITHUB_REF -replace 'refs/tags/', ''
+          $version = $tag -replace '^v', ''
+          "VERSION=$version" >> $env:GITHUB_ENV
+
+      - name: Restore
+        run: dotnet restore WPF-Framework.sln
+
+      - name: Build
+        shell: pwsh
+        run: dotnet build WPF-Framework.sln -c Release --no-restore /p:Version=$env:VERSION
+
+      - name: Test
+        env:
+          VSTEST_CONNECTION_TIMEOUT: '600'
+        run: dotnet test WPF-Framework.sln -c Release --no-build
+
+      - name: Pack
+        shell: pwsh
+        run: .\scripts\pack-wpf-framework.ps1 -Configuration Release -Version $env:VERSION -OutputDirectory packages -SkipRestore -SkipBuild
+
+      - name: Upload packages
+        uses: actions/upload-artifact@v4
+        with:
+          name: wpf-framework-packages
+          path: packages/*.nupkg
+          retention-days: 30
diff --git a/README.md b/README.md
index cd049bda..0a305636 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,14 @@
 # WPF Framework
 
 [![CI](https://github.com/USACE-RMC/WPF-Framework/actions/workflows/Integration.yml/badge.svg)](https://github.com/USACE-RMC/WPF-Framework/actions/workflows/Integration.yml)
+[![NuGet](https://img.shields.io/nuget/v/RMC.Wpf.Framework.Controls)](https://www.nuget.org/packages/RMC.Wpf.Framework.Controls/)
 [![License: 0BSD](https://img.shields.io/badge/License-0BSD-blue.svg)](LICENSE)
 
 WPF Framework is a free and open-source .NET 10.0 application framework for building desktop project management applications, developed by the U.S. Army Corps of Engineers Risk Management Center ([USACE-RMC](https://www.rmc.usace.army.mil/)). It provides a complete application shell with docking layout, project explorer, theme switching, undo/redo, and specialized controls for charting, databases, expression parsing, and directed acyclic graphs.
 
+> [!NOTE]
+> This repository is under active development. Expect ongoing bug fixes and minor enhancements as the framework is prepared for broader public use.
+
 ## Supported Frameworks
 
 | Platform | Version |
@@ -46,17 +50,17 @@ dotnet test WPF-Framework.sln
 ### Build Packages
 
 ```bash
-.\scripts\pack-wpf-framework.ps1 -Configuration Release
+.\scripts\pack-wpf-framework.ps1 -Configuration Release -Version 1.0.0
 ```
 
 This creates and validates the following NuGet packages in `artifacts/packages/`:
 
 | Package | Includes | Depends on |
 |---------|----------|------------|
-| `RMC.Wpf.Framework.Core` | FrameworkInterfaces, Themes | None |
-| `RMC.Wpf.Framework.Models` | DAG, DatabaseManager, ExpressionParser, OxyPlot libraries | ClosedXML, DocumentFormat.OpenXml, ExcelNumberFormat, FastMember, SourceGear.sqlite3, System.Data.SQLite |
-| `RMC.Wpf.Framework.Support` | SoftwareUpdate and updater content files | None |
-| `RMC.Wpf.Framework.Controls` | FrameworkUI, control libraries, AvalonDock fork | Core, Models, Support, RMC.Numerics 2.x |
+| [`RMC.Wpf.Framework.Core`](https://www.nuget.org/packages/RMC.Wpf.Framework.Core/) | FrameworkInterfaces, Themes | None |
+| [`RMC.Wpf.Framework.Models`](https://www.nuget.org/packages/RMC.Wpf.Framework.Models/) | DAG, DatabaseManager, ExpressionParser, OxyPlot libraries | ClosedXML, DocumentFormat.OpenXml, ExcelNumberFormat, FastMember, SourceGear.sqlite3, System.Data.SQLite |
+| [`RMC.Wpf.Framework.Support`](https://www.nuget.org/packages/RMC.Wpf.Framework.Support/) | SoftwareUpdate and updater content files | None |
+| [`RMC.Wpf.Framework.Controls`](https://www.nuget.org/packages/RMC.Wpf.Framework.Controls/) | FrameworkUI, control libraries, AvalonDock fork | Core, Models, Support, RMC.Numerics 2.x |
 
 ### Minimal Application
 
@@ -82,6 +86,7 @@ Comprehensive documentation is available in the [docs/](docs/index.md) folder:
 
 | Document | Description |
 |----------|-------------|
+| [Gallery](docs/gallery.md) | Screenshot guide to the framework control libraries |
 | [Getting Started](docs/getting-started.md) | Step-by-step guide to building your first application |
 | [Architecture](docs/architecture.md) | Solution structure, dependencies, and design patterns |
 | [Themes](docs/themes.md) | Runtime theme switching with Light, Dark, and Blue themes |
diff --git a/docs/assets/gallery/README.md b/docs/assets/gallery/README.md
new file mode 100644
index 00000000..9be6eb33
--- /dev/null
+++ b/docs/assets/gallery/README.md
@@ -0,0 +1,54 @@
+# Gallery Screenshot Checklist
+
+Save screenshots in this folder using the filenames below. Blue theme is the default capture style.
+
+## FrameworkUI
+
+- `frameworkui-shell-blue.png`
+- `frameworkui-shell-light.png`
+- `frameworkui-shell-dark.png`
+- `frameworkui-hazard-document-blue.png`
+
+## GenericControls
+
+- `generic-input-controls-blue.png`
+- `generic-date-time-color-blue.png`
+- `generic-property-editors-blue.png`
+- `generic-datagrid-blue.png`
+- `generic-color-collection-blue.png`
+
+## NumericControls
+
+- `numeric-distribution-selector-blue.png`
+- `numeric-uncertain-curve-editor-blue.png`
+- `numeric-uncertain-table-editor-blue.png`
+- `numeric-curve-editor-blue.png`
+- `numeric-probability-ordinates-blue.png`
+- `numeric-time-series-blue.png`
+- `numeric-bin-definitions-blue.png`
+- `numeric-bivariate-cdf-blue.png`
+
+## OxyPlotControls
+
+- `oxyplot-toolbar-blue.png`
+- `oxyplot-properties-blue.png`
+- `oxyplot-series-selector-blue.png`
+
+## DatabaseControls
+
+- `database-table-viewer-blue.png`
+
+## ExpressionParserControls
+
+- `expression-calculator-blue.png`
+
+## DAGControls
+
+- `dag-flowgraph-canvas-blue.png`
+
+## Capture Notes
+
+- Capture from the demo apps in `src/`.
+- Keep screenshots focused on the relevant control.
+- Prefer 1200-1600 px wide PNGs.
+- Avoid local paths, personal data, debug windows, and unrelated desktop content.
diff --git a/docs/gallery.md b/docs/gallery.md
new file mode 100644
index 00000000..dd08e173
--- /dev/null
+++ b/docs/gallery.md
@@ -0,0 +1,245 @@
+# Control Gallery
+
+This gallery outlines the screenshots used to show the visible controls in the WPF Framework demo applications. Blue theme is the default capture style. Light and Dark screenshots are included only where they show theme coverage.
+
+Screenshots belong in `docs/assets/gallery/` using the filenames shown below.
+
+## Contents
+
+- [FrameworkUI](#frameworkui)
+  - [Application Shell](#application-shell)
+  - [Theme Comparison](#theme-comparison)
+  - [Hazard Document](#hazard-document)
+- [GenericControls](#genericcontrols)
+  - [Input Controls](#input-controls)
+  - [Date, Time, and Color](#date-time-and-color)
+  - [Property Editors](#property-editors)
+  - [Data Grid](#data-grid)
+  - [Color Collection](#color-collection)
+- [NumericControls](#numericcontrols)
+  - [Distribution Selector](#distribution-selector)
+  - [Uncertain Curve Editor](#uncertain-curve-editor)
+  - [Uncertain Table Editor](#uncertain-table-editor)
+  - [Curve Editor](#curve-editor)
+  - [Probability Ordinates](#probability-ordinates)
+  - [Time Series](#time-series)
+  - [Bin Definitions](#bin-definitions)
+  - [Bivariate CDF](#bivariate-cdf)
+- [OxyPlotControls](#oxyplotcontrols)
+  - [Plot Toolbar](#plot-toolbar)
+  - [Plot Properties](#plot-properties)
+  - [Series Selector](#series-selector)
+- [DatabaseControls](#databasecontrols)
+  - [Table Viewer](#table-viewer)
+- [ExpressionParserControls](#expressionparsercontrols)
+  - [Calculator Control](#calculator-control)
+- [DAGControls](#dagcontrols)
+  - [Flow Graph Canvas](#flow-graph-canvas)
+
+## FrameworkUI
+
+Demo source: `src/FrameworkUI.Demo/`
+
+### Application Shell
+
+![FrameworkUI shell in blue theme](assets/gallery/frameworkui-shell-blue.png)
+
+Application shell with project explorer, docking documents, properties, messages, menus, and toolbar.
+
+See: [Architecture](architecture.md), [Themes](themes.md)
+
+### Theme Comparison
+
+![FrameworkUI shell in light theme](assets/gallery/frameworkui-shell-light.png)
+
+Light theme capture of the same shell layout.
+
+![FrameworkUI shell in dark theme](assets/gallery/frameworkui-shell-dark.png)
+
+Dark theme capture of the same shell layout.
+
+See: [Themes](themes.md)
+
+### Hazard Document
+
+![FrameworkUI hazard document in blue theme](assets/gallery/frameworkui-hazard-document-blue.png)
+
+Document view with an OxyPlot chart, vertical plot toolbar, tabular results, and properties workflow.
+
+See: [OxyPlot Controls](oxyplot-controls.md), [Generic Controls](generic-controls.md)
+
+## GenericControls
+
+Demo source: `src/GenericControls.Demo/`
+
+### Input Controls
+
+![Generic input controls in blue theme](assets/gallery/generic-input-controls-blue.png)
+
+Name, numeric, slider, resizable text, grid length, and thickness input controls.
+
+See: [Generic Controls](generic-controls.md)
+
+### Date, Time, and Color
+
+![Generic date, time, and color controls in blue theme](assets/gallery/generic-date-time-color-blue.png)
+
+Clock, date/time inputs, color picker, and color picker popup.
+
+See: [Generic Controls](generic-controls.md)
+
+### Property Editors
+
+![Generic property editors in blue theme](assets/gallery/generic-property-editors-blue.png)
+
+Property editors for text, numbers, booleans, fonts, colors, lines, alignment, points, dates, and custom content.
+
+See: [Generic Controls](generic-controls.md)
+
+### Data Grid
+
+![Generic data grid controls in blue theme](assets/gallery/generic-datagrid-blue.png)
+
+Data grid toolbar and copy/paste data grid controls for editable tabular workflows.
+
+See: [Generic Controls](generic-controls.md)
+
+### Color Collection
+
+![Generic color collection editor in blue theme](assets/gallery/generic-color-collection-blue.png)
+
+Editable color collection with popup color editing.
+
+See: [Generic Controls](generic-controls.md)
+
+## NumericControls
+
+Demo source: `src/NumericControls.Demo/`
+
+### Distribution Selector
+
+![Numeric distribution selector in blue theme](assets/gallery/numeric-distribution-selector-blue.png)
+
+Distribution selector with fitting options, parameters, plot, and statistics.
+
+See: [Numeric Controls](numeric-controls.md)
+
+### Uncertain Curve Editor
+
+![Numeric uncertain curve editor in blue theme](assets/gallery/numeric-uncertain-curve-editor-blue.png)
+
+Curve editor for ordered data with uncertainty.
+
+See: [Numeric Controls](numeric-controls.md)
+
+### Uncertain Table Editor
+
+![Numeric uncertain table editor in blue theme](assets/gallery/numeric-uncertain-table-editor-blue.png)
+
+Table editor for uncertain ordered data.
+
+See: [Numeric Controls](numeric-controls.md)
+
+### Curve Editor
+
+![Numeric curve editor in blue theme](assets/gallery/numeric-curve-editor-blue.png)
+
+Curve editor for ordered numeric data.
+
+See: [Numeric Controls](numeric-controls.md)
+
+### Probability Ordinates
+
+![Numeric probability ordinates in blue theme](assets/gallery/numeric-probability-ordinates-blue.png)
+
+Editor for probability ordinate sets.
+
+See: [Numeric Controls](numeric-controls.md)
+
+### Time Series
+
+![Numeric time series table in blue theme](assets/gallery/numeric-time-series-blue.png)
+
+Time series table with selectable sample data sets.
+
+See: [Numeric Controls](numeric-controls.md)
+
+### Bin Definitions
+
+![Numeric bin definitions in blue theme](assets/gallery/numeric-bin-definitions-blue.png)
+
+Editor for bin definitions used by numeric workflows.
+
+See: [Numeric Controls](numeric-controls.md)
+
+### Bivariate CDF
+
+![Numeric bivariate CDF in blue theme](assets/gallery/numeric-bivariate-cdf-blue.png)
+
+Bivariate empirical CDF control.
+
+See: [Numeric Controls](numeric-controls.md)
+
+## OxyPlotControls
+
+Demo source: `src/OxyPlotControls.Demo/`
+
+### Plot Toolbar
+
+![OxyPlot toolbar in blue theme](assets/gallery/oxyplot-toolbar-blue.png)
+
+Plot view with vertical toolbar for pan, zoom, annotation, export, and properties.
+
+See: [OxyPlot Controls](oxyplot-controls.md)
+
+### Plot Properties
+
+![OxyPlot properties in blue theme](assets/gallery/oxyplot-properties-blue.png)
+
+Properties panel for axes, series, annotations, legends, and layout settings.
+
+See: [OxyPlot Controls](oxyplot-controls.md)
+
+### Series Selector
+
+![OxyPlot series selector in blue theme](assets/gallery/oxyplot-series-selector-blue.png)
+
+Series selector for line, scatter, histogram, bar, box plot, area, heat map, pie, and large-data examples.
+
+See: [OxyPlot Controls](oxyplot-controls.md)
+
+## DatabaseControls
+
+Demo source: `src/DatabaseControls.Demo/`
+
+### Table Viewer
+
+![Database table viewer in blue theme](assets/gallery/database-table-viewer-blue.png)
+
+Table viewer with file/table selection, editable cells, row/column/cell selection, autofit columns, and field calculator access.
+
+See: [Database Controls](database-controls.md)
+
+## ExpressionParserControls
+
+Demo source: `src/ExpressionParserControls.Demo/`
+
+### Calculator Control
+
+![Expression calculator in blue theme](assets/gallery/expression-calculator-blue.png)
+
+Calculator control with expression editor, operator buttons, function browser, expression builder, and result output.
+
+See: [Database Controls](database-controls.md)
+
+## DAGControls
+
+Demo source: `src/DAG.Demo/`
+
+### Flow Graph Canvas
+
+![DAG flow graph canvas in blue theme](assets/gallery/dag-flowgraph-canvas-blue.png)
+
+Flow graph canvas with nodes, connectors, add-node workflow, and connection feedback.
+
+See: [DAG Controls](dag-controls.md)
diff --git a/docs/index.md b/docs/index.md
index ccbd9450..875dd9fa 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -6,6 +6,7 @@ The WPF Framework is a .NET 10.0 desktop application framework developed by the
 
 | Guide | Description |
 |-------|-------------|
+| [Gallery](gallery.md) | Screenshot guide to the framework control libraries |
 | [Getting Started](getting-started.md) | Step-by-step guide to building your first application |
 | [Architecture](architecture.md) | Solution structure, dependencies, and design patterns |
 | [Themes](themes.md) | Runtime theme switching with Light, Dark, and Blue themes |
diff --git a/scripts/pack-wpf-framework.ps1 b/scripts/pack-wpf-framework.ps1
index 940d97b5..b75c0107 100644
--- a/scripts/pack-wpf-framework.ps1
+++ b/scripts/pack-wpf-framework.ps1
@@ -1,6 +1,7 @@
 param(
     [string]$Configuration = "Release",
     [string]$OutputDirectory = "artifacts/packages",
+    [string]$Version,
     [switch]$SkipRestore,
     [switch]$SkipBuild
 )
@@ -11,6 +12,11 @@ $repoRoot = Resolve-Path (Join-Path $PSScriptRoot "..")
 $outputPath = Join-Path $repoRoot $OutputDirectory
 New-Item -ItemType Directory -Force -Path $outputPath | Out-Null
 
+$versionArgs = @()
+if (-not [string]::IsNullOrWhiteSpace($Version)) {
+    $versionArgs = @("/p:Version=$Version")
+}
+
 if (-not $SkipRestore) {
     & dotnet restore (Join-Path $repoRoot "WPF-Framework.sln")
     if ($LASTEXITCODE -ne 0) {
@@ -19,7 +25,7 @@ if (-not $SkipRestore) {
 }
 
 if (-not $SkipBuild) {
-    & dotnet build (Join-Path $repoRoot "WPF-Framework.sln") -c $Configuration --no-restore
+    & dotnet build (Join-Path $repoRoot "WPF-Framework.sln") -c $Configuration --no-restore @versionArgs
     if ($LASTEXITCODE -ne 0) {
         throw "Build failed before packing."
     }
@@ -33,7 +39,7 @@ $packageProjects = @(
 )
 
 foreach ($project in $packageProjects) {
-    & dotnet pack (Join-Path $repoRoot $project) -c $Configuration --no-build --no-restore -o $outputPath
+    & dotnet pack (Join-Path $repoRoot $project) -c $Configuration --no-build --no-restore -o $outputPath @versionArgs
     if ($LASTEXITCODE -ne 0) {
         throw "Package creation failed for $project."
     }
diff --git a/src/OxyPlot/OxyPlot.Wpf/Serialization/AnnotationSerializer.cs b/src/OxyPlot/OxyPlot.Wpf/Serialization/AnnotationSerializer.cs
index d751450a..49d90b46 100644
--- a/src/OxyPlot/OxyPlot.Wpf/Serialization/AnnotationSerializer.cs
+++ b/src/OxyPlot/OxyPlot.Wpf/Serialization/AnnotationSerializer.cs
@@ -83,7 +83,7 @@ public static XElement AnnotationsToXElement(Plot plot)
                 var textualAnnotation = annotation as TextualAnnotation;
                 if (textualAnnotation == null)
                 {
-                    System.Diagnostics.Debug.WriteLine(
+                    System.Diagnostics.Trace.WriteLine(
                         $"[AnnotationSerializer] Annotation of type '{annotation?.GetType().FullName}' is not a TextualAnnotation and will not be persisted. " +
                         "Save/Open will lose this annotation. (Issue D-001 — full round-trip pending.)");
                     continue;
@@ -335,7 +335,7 @@ public static XElement AnnotationToXElement(TextualAnnotation annotation)
                 // which silently substituted a phantom empty text annotation in the user's
                 // plot. Return null instead — the caller (XElementToAnnotations) already
                 // skips null entries, matching the SeriesSerializer pattern.
-                System.Diagnostics.Debug.WriteLine(
+                System.Diagnostics.Trace.WriteLine(
                     $"[AnnotationSerializer] Unknown AnnotationType '{annotationTypeString}'; skipping.");
                 return null;
             }

From c578ace1a7c3106a74692683ad095b3a117b58be Mon Sep 17 00:00:00 2001
From: HadenSmith <cole.h.smith@usace.army.mil>
Date: Tue, 30 Jun 2026 12:15:04 -0600
Subject: [PATCH 11/11] Ignore local agent guidance files

---
 .gitignore | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/.gitignore b/.gitignore
index 735cd521..ee38a49f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -417,3 +417,10 @@ FodyWeavers.xsd
 *.msm
 *.msp
 /nul
+
+# AI-assistant metadata (not tracked in this repo)
+CLAUDE.md
+**/CLAUDE.md
+AGENTS.md
+**/AGENTS.md
+.claude/