From 3670ca89c33014e8433e0bd523c4cbccc71e9914 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Fri, 19 Jun 2026 12:40:54 +0200
Subject: [PATCH 001/100] feat(atc): add IsHostName and IP address validation
 string extensions

  - Add IsHostName (RFC 1123 syntactic check), IsIPv4Address, IsIPv6Address and IsIPAddress to StringHasIsExtensions
  - Add netstandard2.0 polyfills for String.Contains/Replace/Split/StartsWith/EndsWith and nullability attributes
  - Add theory tests covering host names, IPv4, IPv6 and combined IP validation
---
 src/Atc/Extensions/StringHasIsExtensions.cs   |  46 ++++++
 src/Atc/Polyfills/NullabilityAttributes.cs    |  79 ++++++++++
 src/Atc/Polyfills/StringPolyfillExtensions.cs | 146 ++++++++++++++++++
 .../Extensions/StringHasIsExtensionsTests.cs  |  59 +++++++
 4 files changed, 330 insertions(+)
 create mode 100644 src/Atc/Polyfills/NullabilityAttributes.cs
 create mode 100644 src/Atc/Polyfills/StringPolyfillExtensions.cs

diff --git a/src/Atc/Extensions/StringHasIsExtensions.cs b/src/Atc/Extensions/StringHasIsExtensions.cs
index 4fc1cf2d..dcd0c85d 100644
--- a/src/Atc/Extensions/StringHasIsExtensions.cs
+++ b/src/Atc/Extensions/StringHasIsExtensions.cs
@@ -22,6 +22,7 @@ public static class StringHasIsExtensions
     private static readonly Lazy<Regex> RxKey = new(() => new Regex(@"^([a-zA-Z]+[a-zA-Z0-9_]+$)", RegexOptions.Singleline | RegexOptions.Compiled, TimeSpan.FromSeconds(1)));
     private static readonly Lazy<Regex> RxHtmlTags = new(() => new Regex(@"<[^>]+>", RegexOptions.Multiline | RegexOptions.Compiled, TimeSpan.FromSeconds(5)));
     private static readonly Lazy<Regex> RxSingleWord = new(() => new Regex(@"^((?!-)+)([a-zA-Z_-]+$).*((?<!-)+)", RegexOptions.Singleline | RegexOptions.Compiled, TimeSpan.FromSeconds(1)));
+    private static readonly Lazy<Regex> RxHostName = new(() => new Regex(@"^(?=.{1,253}\.?$)(?!-)[A-Za-z0-9-]{1,63}(?<!-)(\.(?!-)[A-Za-z0-9-]{1,63}(?<!-))*\.?$", RegexOptions.Singleline | RegexOptions.Compiled, TimeSpan.FromSeconds(1)));
 
     /// <summary>
     /// Determines whether [has HTML tags] [the specified value].
@@ -586,4 +587,49 @@ public static bool IsUriHttpOrHttps(this string value)
     /// <returns><see langword="true" /> if the value is a valid opc.tcp:// URI; otherwise, <see langword="false" />.</returns>
     public static bool IsUriOpcTcp(this string value)
         => UriAttribute.IsValidOpcTcp(value);
+
+    /// <summary>
+    /// Determines whether the specified value is a syntactically valid DNS host name (RFC 1123).
+    /// </summary>
+    /// <param name="value">The string to validate.</param>
+    /// <returns><see langword="true" /> if the value is a valid host name; otherwise, <see langword="false" />.</returns>
+    /// <remarks>
+    /// Accepts single-label names (e.g. <c>localhost</c>) and an optional trailing dot (e.g. <c>example.com.</c>).
+    /// Each label is 1-63 ASCII alphanumeric/hyphen characters and may not start or end with a hyphen;
+    /// the total length is limited to 253 characters. Underscores and raw Unicode (non-punycode IDN) are not allowed.
+    /// This is a purely syntactic check and does not perform any DNS resolution.
+    /// </remarks>
+    public static bool IsHostName(this string value)
+        => !string.IsNullOrEmpty(value) &&
+           RxHostName.Value.IsMatch(value);
+
+    /// <summary>
+    /// Determines whether the specified value is a valid IPv4 address.
+    /// </summary>
+    /// <param name="value">The string to validate.</param>
+    /// <returns><see langword="true" /> if the value is a valid IPv4 address; otherwise, <see langword="false" />.</returns>
+    public static bool IsIPv4Address(this string value)
+        => !string.IsNullOrEmpty(value) &&
+           IPAddress.TryParse(value, out var address) &&
+           address.AddressFamily == AddressFamily.InterNetwork &&
+           value.Split('.').Length == 4;
+
+    /// <summary>
+    /// Determines whether the specified value is a valid IPv6 address.
+    /// </summary>
+    /// <param name="value">The string to validate.</param>
+    /// <returns><see langword="true" /> if the value is a valid IPv6 address; otherwise, <see langword="false" />.</returns>
+    public static bool IsIPv6Address(this string value)
+        => !string.IsNullOrEmpty(value) &&
+           IPAddress.TryParse(value, out var address) &&
+           address.AddressFamily == AddressFamily.InterNetworkV6;
+
+    /// <summary>
+    /// Determines whether the specified value is a valid IPv4 or IPv6 address.
+    /// </summary>
+    /// <param name="value">The string to validate.</param>
+    /// <returns><see langword="true" /> if the value is a valid IP address; otherwise, <see langword="false" />.</returns>
+    public static bool IsIPAddress(this string value)
+        => value.IsIPv4Address() ||
+           value.IsIPv6Address();
 }
\ No newline at end of file
diff --git a/src/Atc/Polyfills/NullabilityAttributes.cs b/src/Atc/Polyfills/NullabilityAttributes.cs
new file mode 100644
index 00000000..ce998dbc
--- /dev/null
+++ b/src/Atc/Polyfills/NullabilityAttributes.cs
@@ -0,0 +1,79 @@
+#if NETSTANDARD2_0
+#pragma warning disable MA0048 // File name must match type name
+#pragma warning disable SA1649 // File name should match first type name
+#pragma warning disable SA1402 // File may only contain a single type
+#pragma warning disable ATC202 // Multi parameters should be broken down to separate lines
+#pragma warning disable CA1019 // Add a public read-only property accessor for positional argument member of Attribute
+
+namespace System.Diagnostics.CodeAnalysis;
+
+/// <summary>
+/// Specifies that the method or property will ensure that the listed field and property members have not-null values when returning with the specified return value condition.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
+internal sealed class MemberNotNullWhenAttribute : Attribute
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MemberNotNullWhenAttribute"/> class with the specified return value condition and a field or property member.
+    /// </summary>
+    /// <param name="returnValue">
+    /// The return value condition. If the method returns this value, the associated parameter will not be null.
+    /// </param>
+    /// <param name="member">
+    /// The field or property member that is promised to be not-null.
+    /// </param>
+    public MemberNotNullWhenAttribute(bool returnValue, string member)
+    {
+        ReturnValue = returnValue;
+        Members = new[] { member };
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MemberNotNullWhenAttribute"/> class with the specified return value condition and list of field and property members.
+    /// </summary>
+    /// <param name="returnValue">
+    /// The return value condition. If the method returns this value, the associated parameter will not be null.
+    /// </param>
+    /// <param name="members">
+    /// The list of field and property members that are promised to be not-null.
+    /// </param>
+    public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
+    {
+        ReturnValue = returnValue;
+        Members = members;
+    }
+
+    /// <summary>
+    /// Gets the return value condition.
+    /// </summary>
+    public bool ReturnValue { get; }
+
+    /// <summary>
+    /// Gets the field or property member names.
+    /// </summary>
+    public string[] Members { get; }
+}
+
+/// <summary>
+/// Specifies that the output will be non-null if the named parameter is non-null.
+/// </summary>
+[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+internal sealed class NotNullWhenAttribute : Attribute
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="NotNullWhenAttribute"/> class with the specified return value condition.
+    /// </summary>
+    /// <param name="returnValue">
+    /// The return value condition. If the method returns this value, the associated parameter will not be null.
+    /// </param>
+    public NotNullWhenAttribute(bool returnValue)
+    {
+        ReturnValue = returnValue;
+    }
+
+    /// <summary>
+    /// Gets the return value condition.
+    /// </summary>
+    public bool ReturnValue { get; }
+}
+#endif
\ No newline at end of file
diff --git a/src/Atc/Polyfills/StringPolyfillExtensions.cs b/src/Atc/Polyfills/StringPolyfillExtensions.cs
new file mode 100644
index 00000000..b7fee899
--- /dev/null
+++ b/src/Atc/Polyfills/StringPolyfillExtensions.cs
@@ -0,0 +1,146 @@
+#if NETSTANDARD2_0
+#pragma warning disable SA1611 // The documentation for parameter is missing
+#pragma warning disable ATC202 // Multi parameters should be broken down to separate lines
+
+namespace System;
+
+/// <summary>
+/// Polyfill extension methods for String that are not available in netstandard2.0.
+/// </summary>
+internal static class StringPolyfillExtensions
+{
+    /// <summary>
+    /// Returns a value indicating whether a specified character occurs within this string, using the specified comparison rules.
+    /// </summary>
+    public static bool Contains(this string str, char value, StringComparison comparisonType)
+    {
+        if (str == null)
+        {
+            throw new System.ArgumentNullException(nameof(str));
+        }
+
+        return str.IndexOf(value.ToString(), comparisonType) >= 0;
+    }
+
+    /// <summary>
+    /// Returns a value indicating whether a specified string occurs within this string, using the specified comparison rules.
+    /// </summary>
+    public static bool Contains(this string str, string value, StringComparison comparisonType)
+    {
+        if (str == null)
+        {
+            throw new System.ArgumentNullException(nameof(str));
+        }
+
+        if (value == null)
+        {
+            throw new System.ArgumentNullException(nameof(value));
+        }
+
+        return str.IndexOf(value, comparisonType) >= 0;
+    }
+
+    /// <summary>
+    /// Returns a new string in which all occurrences of a specified string are replaced with another specified string, using the provided comparison type.
+    /// </summary>
+    public static string Replace(this string str, string oldValue, string newValue, StringComparison comparisonType)
+    {
+        if (str == null)
+        {
+            throw new System.ArgumentNullException(nameof(str));
+        }
+
+        if (oldValue == null)
+        {
+            throw new System.ArgumentNullException(nameof(oldValue));
+        }
+
+        if (newValue == null)
+        {
+            throw new System.ArgumentNullException(nameof(newValue));
+        }
+
+        if (oldValue.Length == 0)
+        {
+            throw new ArgumentException("String cannot be of zero length.", nameof(oldValue));
+        }
+
+        if (comparisonType == StringComparison.Ordinal)
+        {
+            return str.Replace(oldValue, newValue);
+        }
+
+        var sb = new System.Text.StringBuilder();
+        var previousIndex = 0;
+        var index = str.IndexOf(oldValue, comparisonType);
+
+        while (index != -1)
+        {
+            sb.Append(str.Substring(previousIndex, index - previousIndex));
+            sb.Append(newValue);
+            previousIndex = index + oldValue.Length;
+            index = str.IndexOf(oldValue, previousIndex, comparisonType);
+        }
+
+        sb.Append(str.Substring(previousIndex));
+        return sb.ToString();
+    }
+
+    /// <summary>
+    /// Splits a string into substrings based on specified delimiting characters and options.
+    /// </summary>
+    public static string[] Split(this string str, char separator, StringSplitOptions options)
+    {
+        if (str == null)
+        {
+            throw new System.ArgumentNullException(nameof(str));
+        }
+
+        return str.Split(new[] { separator }, options);
+    }
+
+    /// <summary>
+    /// Splits a string into substrings based on specified delimiting strings and options.
+    /// </summary>
+    public static string[] Split(this string str, string separator, StringSplitOptions options)
+    {
+        if (str == null)
+        {
+            throw new System.ArgumentNullException(nameof(str));
+        }
+
+        if (separator == null)
+        {
+            throw new System.ArgumentNullException(nameof(separator));
+        }
+
+        return str.Split(new[] { separator }, options);
+    }
+
+    /// <summary>
+    /// Determines whether the end of this string instance matches the specified character.
+    /// </summary>
+    public static bool EndsWith(this string str, char value)
+    {
+        if (str == null)
+        {
+            throw new System.ArgumentNullException(nameof(str));
+        }
+
+        return str.Length > 0 && str[str.Length - 1] == value;
+    }
+
+    /// <summary>
+    /// Determines whether the beginning of this string instance matches the specified character.
+    /// </summary>
+    public static bool StartsWith(this string str, char value)
+    {
+        if (str == null)
+        {
+            throw new System.ArgumentNullException(nameof(str));
+        }
+
+        return str.Length > 0 && str[0] == value;
+    }
+}
+#endif
\ No newline at end of file
diff --git a/test/Atc.Tests/Extensions/StringHasIsExtensionsTests.cs b/test/Atc.Tests/Extensions/StringHasIsExtensionsTests.cs
index 8e6d9276..5dc80b6c 100644
--- a/test/Atc.Tests/Extensions/StringHasIsExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/StringHasIsExtensionsTests.cs
@@ -372,4 +372,63 @@ public void IsUriOpcTcp(
         bool expected,
         string input)
         => Assert.Equal(expected, input.IsUriOpcTcp());
+
+    [Theory]
+    [InlineData(true, "localhost")]
+    [InlineData(true, "server01")]
+    [InlineData(true, "dr.dk")]
+    [InlineData(true, "opcua.demo-this.com")]
+    [InlineData(true, "example.com.")]
+    [InlineData(true, "a.b.c.d.e.f")]
+    [InlineData(true, "xn--mnchen-3ya.de")]
+    [InlineData(false, "")]
+    [InlineData(false, " ")]
+    [InlineData(false, "-leadinghyphen.com")]
+    [InlineData(false, "trailinghyphen-.com")]
+    [InlineData(false, "under_score.com")]
+    [InlineData(false, "double..dot.com")]
+    [InlineData(false, "space in.host")]
+    [InlineData(false, "münchen.de")]
+    public void IsHostName(
+        bool expected,
+        string input)
+        => Assert.Equal(expected, input.IsHostName());
+
+    [Theory]
+    [InlineData(true, "192.168.0.27")]
+    [InlineData(true, "0.0.0.0")]
+    [InlineData(true, "255.255.255.255")]
+    [InlineData(false, "1")]
+    [InlineData(false, "256.0.0.1")]
+    [InlineData(false, "::1")]
+    [InlineData(false, "opcua.demo-this.com")]
+    [InlineData(false, "")]
+    public void IsIPv4Address(
+        bool expected,
+        string input)
+        => Assert.Equal(expected, input.IsIPv4Address());
+
+    [Theory]
+    [InlineData(true, "::1")]
+    [InlineData(true, "2001:db8::ff00:42:8329")]
+    [InlineData(true, "fe80::1")]
+    [InlineData(false, "192.168.0.27")]
+    [InlineData(false, "opcua.demo-this.com")]
+    [InlineData(false, "")]
+    public void IsIPv6Address(
+        bool expected,
+        string input)
+        => Assert.Equal(expected, input.IsIPv6Address());
+
+    [Theory]
+    [InlineData(true, "192.168.0.27")]
+    [InlineData(true, "::1")]
+    [InlineData(true, "2001:db8::ff00:42:8329")]
+    [InlineData(false, "opcua.demo-this.com")]
+    [InlineData(false, "256.0.0.1")]
+    [InlineData(false, "")]
+    public void IsIPAddress(
+        bool expected,
+        string input)
+        => Assert.Equal(expected, input.IsIPAddress());
 }
\ No newline at end of file

From 06ca2f5a5ee197abd36602395387aa0ac055e921 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Fri, 19 Jun 2026 12:54:23 +0200
Subject: [PATCH 002/100] chore: nuget updates

---
 Directory.Build.props                                     | 4 ++--
 .../Demo.Atc.Console.Spectre.Cli.csproj                   | 8 ++++----
 sample/Demo.Atc.Dotnet.Cli/Demo.Atc.Dotnet.Cli.csproj     | 8 ++++----
 src/Atc.Console.Spectre/Atc.Console.Spectre.csproj        | 4 ++--
 src/Atc.Rest.Extended/Atc.Rest.Extended.csproj            | 2 +-
 src/Atc.Rest.HealthChecks/Atc.Rest.HealthChecks.csproj    | 2 +-
 src/Atc.XUnit/Atc.XUnit.csproj                            | 2 +-
 src/Atc/Atc.csproj                                        | 8 ++++----
 src/Directory.Build.props                                 | 2 +-
 .../Atc.CodeAnalysis.CSharp.Tests.csproj                  | 2 +-
 .../Atc.CodeDocumentation.Tests.csproj                    | 2 +-
 .../Atc.Console.Spectre.Tests.csproj                      | 2 +-
 test/Atc.DotNet.Tests/Atc.DotNet.Tests.csproj             | 2 +-
 test/Atc.OpenApi.Tests/Atc.OpenApi.Tests.csproj           | 2 +-
 .../Atc.Rest.Extended.Tests.csproj                        | 2 +-
 .../Atc.Rest.FluentAssertions.Tests.csproj                | 2 +-
 .../Atc.Rest.HealthChecks.Tests.csproj                    | 2 +-
 test/Atc.Rest.Tests/Atc.Rest.Tests.csproj                 | 2 +-
 test/Atc.Tests/Atc.Tests.csproj                           | 2 +-
 test/Atc.XUnit.Tests/Atc.XUnit.Tests.csproj               | 2 +-
 test/Directory.Build.props                                | 6 +++---
 21 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/Directory.Build.props b/Directory.Build.props
index f8999ea2..05349a70 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -42,9 +42,9 @@
   <ItemGroup Label="Code Analyzers">
     <PackageReference Include="Atc.Analyzer" Version="0.1.23" PrivateAssets="All" />
     <PackageReference Include="AsyncFixer" Version="2.1.0" PrivateAssets="All" />
-    <PackageReference Include="Meziantou.Analyzer" Version="3.0.54" PrivateAssets="All" />
+    <PackageReference Include="Meziantou.Analyzer" Version="3.0.104" PrivateAssets="All" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.435" PrivateAssets="All" />
-    <PackageReference Include="SonarAnalyzer.CSharp" Version="10.24.0.138807" PrivateAssets="All" />
+    <PackageReference Include="SonarAnalyzer.CSharp" Version="10.27.0.140913" PrivateAssets="All" />
   </ItemGroup>
 
 </Project>
\ No newline at end of file
diff --git a/sample/Demo.Atc.Console.Spectre.Cli/Demo.Atc.Console.Spectre.Cli.csproj b/sample/Demo.Atc.Console.Spectre.Cli/Demo.Atc.Console.Spectre.Cli.csproj
index c1fac715..334a4dfd 100644
--- a/sample/Demo.Atc.Console.Spectre.Cli/Demo.Atc.Console.Spectre.Cli.csproj
+++ b/sample/Demo.Atc.Console.Spectre.Cli/Demo.Atc.Console.Spectre.Cli.csproj
@@ -8,10 +8,10 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Configuration" Version="10.0.7" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="10.0.7" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.7" />
-    <PackageReference Include="Spectre.Console" Version="0.55.2" />
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="10.0.9" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="10.0.9" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.9" />
+    <PackageReference Include="Spectre.Console" Version="0.57.0" />
     <PackageReference Include="Spectre.Console.Cli" Version="0.55.0" />
   </ItemGroup>
 
diff --git a/sample/Demo.Atc.Dotnet.Cli/Demo.Atc.Dotnet.Cli.csproj b/sample/Demo.Atc.Dotnet.Cli/Demo.Atc.Dotnet.Cli.csproj
index d79c00bc..062ff94a 100644
--- a/sample/Demo.Atc.Dotnet.Cli/Demo.Atc.Dotnet.Cli.csproj
+++ b/sample/Demo.Atc.Dotnet.Cli/Demo.Atc.Dotnet.Cli.csproj
@@ -8,10 +8,10 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Configuration" Version="10.0.7" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="10.0.7" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.7" />
-    <PackageReference Include="Spectre.Console" Version="0.55.2" />
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="10.0.9" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="10.0.9" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.9" />
+    <PackageReference Include="Spectre.Console" Version="0.57.0" />
     <PackageReference Include="Spectre.Console.Cli" Version="0.55.0" />
   </ItemGroup>
 
diff --git a/src/Atc.Console.Spectre/Atc.Console.Spectre.csproj b/src/Atc.Console.Spectre/Atc.Console.Spectre.csproj
index e50e6c61..4e88b6e0 100644
--- a/src/Atc.Console.Spectre/Atc.Console.Spectre.csproj
+++ b/src/Atc.Console.Spectre/Atc.Console.Spectre.csproj
@@ -8,8 +8,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="10.0.7" />
-    <PackageReference Include="Spectre.Console" Version="0.55.2" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="10.0.9" />
+    <PackageReference Include="Spectre.Console" Version="0.57.0" />
     <PackageReference Include="Spectre.Console.Cli" Version="0.55.0" />
   </ItemGroup>
 
diff --git a/src/Atc.Rest.Extended/Atc.Rest.Extended.csproj b/src/Atc.Rest.Extended/Atc.Rest.Extended.csproj
index 5dc5ca94..ef2d9b0b 100644
--- a/src/Atc.Rest.Extended/Atc.Rest.Extended.csproj
+++ b/src/Atc.Rest.Extended/Atc.Rest.Extended.csproj
@@ -12,7 +12,7 @@
     <PackageReference Include="FluentValidation.AspNetCore" Version="11.3.1" />
     <PackageReference Include="Microsoft.ApplicationInsights.AspNetCore" Version="2.23.0" />
     <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="9.0.10" />
-    <PackageReference Include="Swashbuckle.AspNetCore" Version="10.1.7" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="10.2.1" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/Atc.Rest.HealthChecks/Atc.Rest.HealthChecks.csproj b/src/Atc.Rest.HealthChecks/Atc.Rest.HealthChecks.csproj
index 1725035a..a883e009 100644
--- a/src/Atc.Rest.HealthChecks/Atc.Rest.HealthChecks.csproj
+++ b/src/Atc.Rest.HealthChecks/Atc.Rest.HealthChecks.csproj
@@ -9,7 +9,7 @@
 
   <ItemGroup>
     <FrameworkReference Include="Microsoft.AspNetCore.App" />
-    <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks" Version="10.0.7" />
+    <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks" Version="10.0.9" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/Atc.XUnit/Atc.XUnit.csproj b/src/Atc.XUnit/Atc.XUnit.csproj
index 7f508788..208b7945 100644
--- a/src/Atc.XUnit/Atc.XUnit.csproj
+++ b/src/Atc.XUnit/Atc.XUnit.csproj
@@ -13,7 +13,7 @@
 
   <ItemGroup>
     <PackageReference Include="EPPlus" Version="[7.5.3]" /> <!-- EPPlus is version-pinned because versions newer than 7.5.3 require a paid license -->
-    <PackageReference Include="ICSharpCode.Decompiler" Version="10.0.0.8330" />
+    <PackageReference Include="ICSharpCode.Decompiler" Version="10.1.0.8386" />
     <PackageReference Include="Mono.Reflection" Version="2.0.0">
       <NoWarn>NU1701</NoWarn>
     </PackageReference>
diff --git a/src/Atc/Atc.csproj b/src/Atc/Atc.csproj
index 441491fa..c0284035 100644
--- a/src/Atc/Atc.csproj
+++ b/src/Atc/Atc.csproj
@@ -9,13 +9,13 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Meziantou.Polyfill" Version="1.0.118">
+    <PackageReference Include="Meziantou.Polyfill" Version="1.0.152">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.7" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.9" />
     <PackageReference Include="System.ComponentModel.Annotations" Version="5.0.0" />
-    <PackageReference Include="System.Text.Json" Version="10.0.7" />
+    <PackageReference Include="System.Text.Json" Version="10.0.9" />
   </ItemGroup>
 
   <ItemGroup>
@@ -76,7 +76,7 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
-    <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="10.0.7" />
+    <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="10.0.9" />
   </ItemGroup>
 
 </Project>
\ No newline at end of file
diff --git a/src/Directory.Build.props b/src/Directory.Build.props
index edc3abf9..fd98e5b4 100644
--- a/src/Directory.Build.props
+++ b/src/Directory.Build.props
@@ -53,7 +53,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="10.0.203" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="10.0.300" PrivateAssets="All" />
     <PackageReference Include="Nerdbank.GitVersioning" Version="3.9.50" PrivateAssets="All" />
   </ItemGroup>
 
diff --git a/test/Atc.CodeAnalysis.CSharp.Tests/Atc.CodeAnalysis.CSharp.Tests.csproj b/test/Atc.CodeAnalysis.CSharp.Tests/Atc.CodeAnalysis.CSharp.Tests.csproj
index a50c486a..9fea021f 100644
--- a/test/Atc.CodeAnalysis.CSharp.Tests/Atc.CodeAnalysis.CSharp.Tests.csproj
+++ b/test/Atc.CodeAnalysis.CSharp.Tests/Atc.CodeAnalysis.CSharp.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ICSharpCode.Decompiler" Version="10.0.0.8330" />
+    <PackageReference Include="ICSharpCode.Decompiler" Version="10.1.0.8386" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/Atc.CodeDocumentation.Tests/Atc.CodeDocumentation.Tests.csproj b/test/Atc.CodeDocumentation.Tests/Atc.CodeDocumentation.Tests.csproj
index f7626ef9..8fe6381d 100644
--- a/test/Atc.CodeDocumentation.Tests/Atc.CodeDocumentation.Tests.csproj
+++ b/test/Atc.CodeDocumentation.Tests/Atc.CodeDocumentation.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ICSharpCode.Decompiler" Version="10.0.0.8330" />
+    <PackageReference Include="ICSharpCode.Decompiler" Version="10.1.0.8386" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/Atc.Console.Spectre.Tests/Atc.Console.Spectre.Tests.csproj b/test/Atc.Console.Spectre.Tests/Atc.Console.Spectre.Tests.csproj
index d8e81b0d..a79d246d 100644
--- a/test/Atc.Console.Spectre.Tests/Atc.Console.Spectre.Tests.csproj
+++ b/test/Atc.Console.Spectre.Tests/Atc.Console.Spectre.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ICSharpCode.Decompiler" Version="10.0.0.8330" />
+    <PackageReference Include="ICSharpCode.Decompiler" Version="10.1.0.8386" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/Atc.DotNet.Tests/Atc.DotNet.Tests.csproj b/test/Atc.DotNet.Tests/Atc.DotNet.Tests.csproj
index a6034f65..78e71269 100644
--- a/test/Atc.DotNet.Tests/Atc.DotNet.Tests.csproj
+++ b/test/Atc.DotNet.Tests/Atc.DotNet.Tests.csproj
@@ -13,7 +13,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="ICSharpCode.Decompiler" Version="10.0.0.8330" />
+    <PackageReference Include="ICSharpCode.Decompiler" Version="10.1.0.8386" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/Atc.OpenApi.Tests/Atc.OpenApi.Tests.csproj b/test/Atc.OpenApi.Tests/Atc.OpenApi.Tests.csproj
index 06a005d5..9bc9228c 100644
--- a/test/Atc.OpenApi.Tests/Atc.OpenApi.Tests.csproj
+++ b/test/Atc.OpenApi.Tests/Atc.OpenApi.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ICSharpCode.Decompiler" Version="10.0.0.8330" />
+    <PackageReference Include="ICSharpCode.Decompiler" Version="10.1.0.8386" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/Atc.Rest.Extended.Tests/Atc.Rest.Extended.Tests.csproj b/test/Atc.Rest.Extended.Tests/Atc.Rest.Extended.Tests.csproj
index 887d59b3..28241bef 100644
--- a/test/Atc.Rest.Extended.Tests/Atc.Rest.Extended.Tests.csproj
+++ b/test/Atc.Rest.Extended.Tests/Atc.Rest.Extended.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ICSharpCode.Decompiler" Version="10.0.0.8330" />
+    <PackageReference Include="ICSharpCode.Decompiler" Version="10.1.0.8386" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/Atc.Rest.FluentAssertions.Tests/Atc.Rest.FluentAssertions.Tests.csproj b/test/Atc.Rest.FluentAssertions.Tests/Atc.Rest.FluentAssertions.Tests.csproj
index 92c5ff3f..0f540164 100644
--- a/test/Atc.Rest.FluentAssertions.Tests/Atc.Rest.FluentAssertions.Tests.csproj
+++ b/test/Atc.Rest.FluentAssertions.Tests/Atc.Rest.FluentAssertions.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ICSharpCode.Decompiler" Version="10.0.0.8330" />
+    <PackageReference Include="ICSharpCode.Decompiler" Version="10.1.0.8386" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/Atc.Rest.HealthChecks.Tests/Atc.Rest.HealthChecks.Tests.csproj b/test/Atc.Rest.HealthChecks.Tests/Atc.Rest.HealthChecks.Tests.csproj
index e62082b9..9c85e7cc 100644
--- a/test/Atc.Rest.HealthChecks.Tests/Atc.Rest.HealthChecks.Tests.csproj
+++ b/test/Atc.Rest.HealthChecks.Tests/Atc.Rest.HealthChecks.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ICSharpCode.Decompiler" Version="10.0.0.8330" />
+    <PackageReference Include="ICSharpCode.Decompiler" Version="10.1.0.8386" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/Atc.Rest.Tests/Atc.Rest.Tests.csproj b/test/Atc.Rest.Tests/Atc.Rest.Tests.csproj
index 05c6a485..bc3b1760 100644
--- a/test/Atc.Rest.Tests/Atc.Rest.Tests.csproj
+++ b/test/Atc.Rest.Tests/Atc.Rest.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ICSharpCode.Decompiler" Version="10.0.0.8330" />
+    <PackageReference Include="ICSharpCode.Decompiler" Version="10.1.0.8386" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/Atc.Tests/Atc.Tests.csproj b/test/Atc.Tests/Atc.Tests.csproj
index 71d384dc..1cb73960 100644
--- a/test/Atc.Tests/Atc.Tests.csproj
+++ b/test/Atc.Tests/Atc.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ICSharpCode.Decompiler" Version="10.0.0.8330" />
+    <PackageReference Include="ICSharpCode.Decompiler" Version="10.1.0.8386" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/Atc.XUnit.Tests/Atc.XUnit.Tests.csproj b/test/Atc.XUnit.Tests/Atc.XUnit.Tests.csproj
index f7626ef9..8fe6381d 100644
--- a/test/Atc.XUnit.Tests/Atc.XUnit.Tests.csproj
+++ b/test/Atc.XUnit.Tests/Atc.XUnit.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ICSharpCode.Decompiler" Version="10.0.0.8330" />
+    <PackageReference Include="ICSharpCode.Decompiler" Version="10.1.0.8386" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/Directory.Build.props b/test/Directory.Build.props
index 81bce418..58992e32 100644
--- a/test/Directory.Build.props
+++ b/test/Directory.Build.props
@@ -19,9 +19,9 @@
   <ItemGroup>
     <PackageReference Include="Atc.Test" Version="2.0.17" />
     <PackageReference Include="NSubstitute.Analyzers.CSharp" Version="1.0.17" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.4.0" />
-    <PackageReference Include="Microsoft.Testing.Extensions.CodeCoverage" Version="18.6.2" />
-    <PackageReference Include="Microsoft.Testing.Extensions.TrxReport" Version="2.2.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.6.0" />
+    <PackageReference Include="Microsoft.Testing.Extensions.CodeCoverage" Version="18.8.0" />
+    <PackageReference Include="Microsoft.Testing.Extensions.TrxReport" Version="2.2.3" />
     <PackageReference Include="xunit.v3.mtp-v2" Version="3.2.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
       <PrivateAssets>all</PrivateAssets>

From 1ea3d10051d402fff6937a02f377419ef2c08eb2 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Fri, 19 Jun 2026 13:20:10 +0200
Subject: [PATCH 003/100] chore: fix some CA1307 / MA0074

---
 src/Atc/Data/SemVer/SemanticVersion.cs | 2 +-
 src/Atc/Helpers/AssemblyHelper.cs      | 2 +-
 src/Atc/Helpers/CSharpTypeHelper.cs    | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Atc/Data/SemVer/SemanticVersion.cs b/src/Atc/Data/SemVer/SemanticVersion.cs
index 32464123..9f0f8234 100644
--- a/src/Atc/Data/SemVer/SemanticVersion.cs
+++ b/src/Atc/Data/SemVer/SemanticVersion.cs
@@ -107,7 +107,7 @@ public SemanticVersion(
         if (looseMode &&
             !string.IsNullOrEmpty(PreRelease) &&
             string.IsNullOrEmpty(Build) &&
-            PreRelease.StartsWith('.') &&
+            PreRelease.StartsWith(".", StringComparison.Ordinal) &&
             int.TryParse(
                 PreRelease.Replace(".", string.Empty, StringComparison.Ordinal),
                 NumberStyles.Any,
diff --git a/src/Atc/Helpers/AssemblyHelper.cs b/src/Atc/Helpers/AssemblyHelper.cs
index 69ebb561..f3f4557b 100644
--- a/src/Atc/Helpers/AssemblyHelper.cs
+++ b/src/Atc/Helpers/AssemblyHelper.cs
@@ -105,7 +105,7 @@ public static byte[] ReadAsBytes(FileInfo assemblyFile)
 
         if (!assemblyFile.Extension.Equals(".dll", StringComparison.OrdinalIgnoreCase) &&
             !assemblyFile.Extension.Equals(".exe", StringComparison.OrdinalIgnoreCase) &&
-            !(assemblyFile.Name.StartsWith('~') && assemblyFile.Name.EndsWith(".tmp", StringComparison.Ordinal)))
+            !(assemblyFile.Name.StartsWith("~", StringComparison.Ordinal) && assemblyFile.Name.EndsWith(".tmp", StringComparison.Ordinal)))
         {
             throw new IOException("File is not a dll or a executable file");
         }
diff --git a/src/Atc/Helpers/CSharpTypeHelper.cs b/src/Atc/Helpers/CSharpTypeHelper.cs
index 482ea7e3..65fdb00c 100644
--- a/src/Atc/Helpers/CSharpTypeHelper.cs
+++ b/src/Atc/Helpers/CSharpTypeHelper.cs
@@ -80,7 +80,7 @@ public static bool IsExtendedValueType(string typeName)
     /// <returns>True if the type is nullable.</returns>
     public static bool IsNullable(string typeName)
         => !string.IsNullOrEmpty(typeName) &&
-           typeName.EndsWith('?');
+           typeName.EndsWith("?", StringComparison.Ordinal);
 
     /// <summary>
     /// Gets the base type by removing the nullable marker (?).

From c3d9855e38f17b967d2dbf89568499a672bfcf5a Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 01:28:26 +0200
Subject: [PATCH 004/100] fix(atc): harden ProcessHelper invocation

- Read stdout and stderr concurrently to avoid a pipe-buffer deadlock when a child fills one stream while we wait on the other (all four execute paths).

- Surface the started process id so the timeout handler can actually kill a runaway process (the kill branch was previously dead code).

- Base IsSuccessful on the exit code only; tools that write warnings to stderr while exiting 0 are no longer reported as failures.
---
 src/Atc/Helpers/ProcessHelper.cs | 108 +++++++++++++++----------------
 1 file changed, 51 insertions(+), 57 deletions(-)

diff --git a/src/Atc/Helpers/ProcessHelper.cs b/src/Atc/Helpers/ProcessHelper.cs
index 74beb641..0753b193 100644
--- a/src/Atc/Helpers/ProcessHelper.cs
+++ b/src/Atc/Helpers/ProcessHelper.cs
@@ -645,25 +645,25 @@ public static (bool IsSuccessful, string Output) KillByName(
         ushort timeoutInSec,
         CancellationToken cancellationToken)
     {
-        var processId = -1;
+        var processIdHolder = new[] { -1 };
         var resultOutput = string.Empty;
 
         try
         {
-            var (isSuccessful, output, assignedProcessId) = await TaskHelper
+            var (isSuccessful, output, _) = await TaskHelper
                 .Execute(
-                    _ => InvokeExecuteWithProcessId(workingDirectory, fileInfo, arguments, runAsAdministrator),
+                    _ => InvokeExecuteWithProcessId(workingDirectory, fileInfo, arguments, runAsAdministrator, id => Volatile.Write(ref processIdHolder[0], id)),
                     TimeSpan.FromSeconds(timeoutInSec),
                     cancellationToken)
                 .ConfigureAwait(false);
 
-            processId = assignedProcessId;
             resultOutput = output;
 
             return (IsSuccessful: isSuccessful, Output: output);
         }
         catch (TimeoutException)
         {
+            var processId = Volatile.Read(ref processIdHolder[0]);
             if (processId > 0)
             {
                 var (killIsSuccessful, _) = KillById(processId);
@@ -763,25 +763,25 @@ await process
         int timeoutInSec,
         CancellationToken cancellationToken)
     {
-        var processId = -1;
+        var processIdHolder = new[] { -1 };
         var resultOutput = string.Empty;
 
         try
         {
-            var (isSuccessful, output, assignedProcessId) = await TaskHelper
+            var (isSuccessful, output, _) = await TaskHelper
                 .Execute(
-                    _ => InvokeExecutePromptWithProcessId(workingDirectory, fileInfo, arguments, inputLines, runAsAdministrator),
+                    _ => InvokeExecutePromptWithProcessId(workingDirectory, fileInfo, arguments, inputLines, runAsAdministrator, id => Volatile.Write(ref processIdHolder[0], id)),
                     TimeSpan.FromSeconds(timeoutInSec),
                     cancellationToken)
                 .ConfigureAwait(false);
 
-            processId = assignedProcessId;
             resultOutput = output;
 
             return (IsSuccessful: isSuccessful, Output: output);
         }
         catch (TimeoutException)
         {
+            var processId = Volatile.Read(ref processIdHolder[0]);
             if (processId > 0)
             {
                 var (killIsSuccessful, _) = KillById(processId);
@@ -818,7 +818,8 @@ await process
         DirectoryInfo? workingDirectory,
         FileInfo fileInfo,
         string arguments,
-        bool runAsAdministrator)
+        bool runAsAdministrator,
+        Action<int>? onProcessStarted = null)
     {
         using var process = CreateProcess(
             redirectStandard: true,
@@ -833,21 +834,20 @@ await process
         {
             process.Start();
             processId = process.Id;
+            onProcessStarted?.Invoke(processId);
 
-            var standardOutput = await process
-                .StandardOutput
-                .ReadToEndAsync()
-                .ConfigureAwait(false);
-
-            var standardError = await process
-                .StandardError
-                .ReadToEndAsync()
-                .ConfigureAwait(false);
+            // Drain stdout and stderr concurrently to avoid a pipe-buffer deadlock
+            // when the child process fills one buffer while we wait on the other.
+            var standardOutputTask = process.StandardOutput.ReadToEndAsync();
+            var standardErrorTask = process.StandardError.ReadToEndAsync();
 
             await process
                 .WaitForExitAsync()
                 .ConfigureAwait(false);
 
+            var standardOutput = await standardOutputTask.ConfigureAwait(false);
+            var standardError = await standardErrorTask.ConfigureAwait(false);
+
             var message = string.IsNullOrEmpty(standardError)
                 ? standardOutput
                 : string.IsNullOrEmpty(standardOutput)
@@ -855,7 +855,7 @@ await process
                     : $"{standardOutput}{Environment.NewLine}{standardError}";
 
             return (
-                IsSuccessful: process.ExitCode == ConsoleExitStatusCodes.Success && string.IsNullOrEmpty(standardError),
+                IsSuccessful: process.ExitCode == ConsoleExitStatusCodes.Success,
                 Output: message,
                 ProcessId: processId);
         }
@@ -880,7 +880,8 @@ await process
         FileInfo fileInfo,
         string arguments,
         IEnumerable<string> inputLines,
-        bool runAsAdministrator)
+        bool runAsAdministrator,
+        Action<int>? onProcessStarted = null)
     {
         using var process = CreateProcess(
             redirectStandard: true,
@@ -895,6 +896,12 @@ await process
         {
             process.Start();
             processId = process.Id;
+            onProcessStarted?.Invoke(processId);
+
+            // Start draining stdout and stderr concurrently before blocking on input/exit
+            // to avoid a pipe-buffer deadlock when the child writes a lot to either stream.
+            var standardOutputTask = process.StandardOutput.ReadToEndAsync();
+            var standardErrorTask = process.StandardError.ReadToEndAsync();
 
             foreach (var line in inputLines)
             {
@@ -904,20 +911,13 @@ await process
                     .ConfigureAwait(false);
             }
 
-            var standardOutput = await process
-                .StandardOutput
-                .ReadToEndAsync()
-                .ConfigureAwait(false);
-
-            var standardError = await process
-                .StandardError
-                .ReadToEndAsync()
-                .ConfigureAwait(false);
-
             await process
                 .WaitForExitAsync()
                 .ConfigureAwait(false);
 
+            var standardOutput = await standardOutputTask.ConfigureAwait(false);
+            var standardError = await standardErrorTask.ConfigureAwait(false);
+
             var message = string.IsNullOrEmpty(standardError)
                 ? standardOutput
                 : string.IsNullOrEmpty(standardOutput)
@@ -925,7 +925,7 @@ await process
                     : $"{standardOutput}{Environment.NewLine}{standardError}";
 
             return (
-                IsSuccessful: process.ExitCode == ConsoleExitStatusCodes.Success && string.IsNullOrEmpty(standardError),
+                IsSuccessful: process.ExitCode == ConsoleExitStatusCodes.Success,
                 Output: message,
                 ProcessId: processId);
         }
@@ -1034,26 +1034,23 @@ private static async Task<ProcessExecutionResult> InvokeExecuteAsync(
         {
             process.Start();
 
+            // Drain stdout and stderr concurrently to avoid a pipe-buffer deadlock
+            // when the child process fills one buffer while we wait on the other.
 #if NET9_0_OR_GREATER
-            var standardOutput = await process.StandardOutput
-                .ReadToEndAsync(linkedCts.Token)
-                .ConfigureAwait(false);
-            var standardError = await process.StandardError
-                .ReadToEndAsync(linkedCts.Token)
-                .ConfigureAwait(false);
+            var standardOutputTask = process.StandardOutput.ReadToEndAsync(linkedCts.Token);
+            var standardErrorTask = process.StandardError.ReadToEndAsync(linkedCts.Token);
 #else
-            var standardOutput = await process.StandardOutput
-                .ReadToEndAsync()
-                .ConfigureAwait(false);
-            var standardError = await process.StandardError
-                .ReadToEndAsync()
-                .ConfigureAwait(false);
+            var standardOutputTask = process.StandardOutput.ReadToEndAsync();
+            var standardErrorTask = process.StandardError.ReadToEndAsync();
 #endif
 
             await process
                 .WaitForExitAsync(linkedCts.Token)
                 .ConfigureAwait(false);
 
+            var standardOutput = await standardOutputTask.ConfigureAwait(false);
+            var standardError = await standardErrorTask.ConfigureAwait(false);
+
             var message = string.IsNullOrEmpty(standardError)
                 ? standardOutput
                 : string.IsNullOrEmpty(standardOutput)
@@ -1061,7 +1058,7 @@ await process
                     : $"{standardOutput}{Environment.NewLine}{standardError}";
 
             return new ProcessExecutionResult(
-                IsSuccessful: process.ExitCode == ConsoleExitStatusCodes.Success && string.IsNullOrEmpty(standardError),
+                IsSuccessful: process.ExitCode == ConsoleExitStatusCodes.Success,
                 Output: message,
                 ExitCode: process.ExitCode);
         }
@@ -1109,26 +1106,23 @@ private static async Task<ProcessExecutionResult> InvokeExecuteAsyncFromStartInf
         {
             process.Start();
 
+            // Drain stdout and stderr concurrently to avoid a pipe-buffer deadlock
+            // when the child process fills one buffer while we wait on the other.
 #if NET9_0_OR_GREATER
-            var standardOutput = await process.StandardOutput
-                .ReadToEndAsync(linkedCts.Token)
-                .ConfigureAwait(false);
-            var standardError = await process.StandardError
-                .ReadToEndAsync(linkedCts.Token)
-                .ConfigureAwait(false);
+            var standardOutputTask = process.StandardOutput.ReadToEndAsync(linkedCts.Token);
+            var standardErrorTask = process.StandardError.ReadToEndAsync(linkedCts.Token);
 #else
-            var standardOutput = await process.StandardOutput
-                .ReadToEndAsync()
-                .ConfigureAwait(false);
-            var standardError = await process.StandardError
-                .ReadToEndAsync()
-                .ConfigureAwait(false);
+            var standardOutputTask = process.StandardOutput.ReadToEndAsync();
+            var standardErrorTask = process.StandardError.ReadToEndAsync();
 #endif
 
             await process
                 .WaitForExitAsync(linkedCts.Token)
                 .ConfigureAwait(false);
 
+            var standardOutput = await standardOutputTask.ConfigureAwait(false);
+            var standardError = await standardErrorTask.ConfigureAwait(false);
+
             var message = string.IsNullOrEmpty(standardError)
                 ? standardOutput
                 : string.IsNullOrEmpty(standardOutput)
@@ -1136,7 +1130,7 @@ await process
                     : $"{standardOutput}{Environment.NewLine}{standardError}";
 
             return new ProcessExecutionResult(
-                IsSuccessful: process.ExitCode == ConsoleExitStatusCodes.Success && string.IsNullOrEmpty(standardError),
+                IsSuccessful: process.ExitCode == ConsoleExitStatusCodes.Success,
                 Output: message,
                 ExitCode: process.ExitCode);
         }

From 3405221ad84f9cad19811049fe5feb2c373cbdf3 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 01:28:36 +0200
Subject: [PATCH 005/100] fix(atc): restore exception state in serialization
 constructors on netstandard2.0

The serialization constructors called base(ExceptionMessage) instead of base(SerializationInfo, StreamingContext), so a round-tripped exception lost its Message, StackTrace, InnerException and Data. They now delegate to the base serialization constructor under netstandard2.0 (where BinaryFormatter is live and the API is not obsolete), keeping the existing behavior on net9.0/net10.0 to avoid SYSLIB0051.
---
 src/Atc/Exceptions/ArgumentNullOrDefaultException.cs         | 4 ++++
 src/Atc/Exceptions/ArgumentNullOrDefaultPropertyException.cs | 4 ++++
 src/Atc/Exceptions/ArgumentNullPropertyException.cs          | 4 ++++
 src/Atc/Exceptions/ArgumentPropertyException.cs              | 4 ++++
 src/Atc/Exceptions/ArgumentPropertyNullException.cs          | 4 ++++
 src/Atc/Exceptions/CertificateValidationException.cs         | 4 ++++
 src/Atc/Exceptions/ConfigurationException.cs                 | 4 ++++
 src/Atc/Exceptions/DesignTimeUseOnlyException.cs             | 4 ++++
 src/Atc/Exceptions/EntityStoreException.cs                   | 4 ++++
 src/Atc/Exceptions/ItemNotFoundException.cs                  | 4 ++++
 src/Atc/Exceptions/NullException.cs                          | 4 ++++
 src/Atc/Exceptions/PermissionException.cs                    | 4 ++++
 src/Atc/Exceptions/StringNullOrEmptyException.cs             | 4 ++++
 src/Atc/Exceptions/SwitchCaseDefaultException.cs             | 4 ++++
 src/Atc/Exceptions/TcpException.cs                           | 4 ++++
 src/Atc/Exceptions/UnexpectedTypeException.cs                | 4 ++++
 src/Atc/Exceptions/UserNotFoundException.cs                  | 4 ++++
 src/Atc/Exceptions/ViewModelException.cs                     | 4 ++++
 18 files changed, 72 insertions(+)

diff --git a/src/Atc/Exceptions/ArgumentNullOrDefaultException.cs b/src/Atc/Exceptions/ArgumentNullOrDefaultException.cs
index c335b3d0..a3429ac2 100644
--- a/src/Atc/Exceptions/ArgumentNullOrDefaultException.cs
+++ b/src/Atc/Exceptions/ArgumentNullOrDefaultException.cs
@@ -64,7 +64,11 @@ public ArgumentNullOrDefaultException(
     private ArgumentNullOrDefaultException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Exceptions/ArgumentNullOrDefaultPropertyException.cs b/src/Atc/Exceptions/ArgumentNullOrDefaultPropertyException.cs
index 26e88e75..fb6b8100 100644
--- a/src/Atc/Exceptions/ArgumentNullOrDefaultPropertyException.cs
+++ b/src/Atc/Exceptions/ArgumentNullOrDefaultPropertyException.cs
@@ -64,7 +64,11 @@ public ArgumentNullOrDefaultPropertyException(
     private ArgumentNullOrDefaultPropertyException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Exceptions/ArgumentNullPropertyException.cs b/src/Atc/Exceptions/ArgumentNullPropertyException.cs
index 97081e9e..e6174ea9 100644
--- a/src/Atc/Exceptions/ArgumentNullPropertyException.cs
+++ b/src/Atc/Exceptions/ArgumentNullPropertyException.cs
@@ -64,7 +64,11 @@ public ArgumentNullPropertyException(
     private ArgumentNullPropertyException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Exceptions/ArgumentPropertyException.cs b/src/Atc/Exceptions/ArgumentPropertyException.cs
index 0e0a7171..f3398d84 100644
--- a/src/Atc/Exceptions/ArgumentPropertyException.cs
+++ b/src/Atc/Exceptions/ArgumentPropertyException.cs
@@ -64,7 +64,11 @@ public ArgumentPropertyException(
     private ArgumentPropertyException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Exceptions/ArgumentPropertyNullException.cs b/src/Atc/Exceptions/ArgumentPropertyNullException.cs
index 1dd4e35e..e2ec0670 100644
--- a/src/Atc/Exceptions/ArgumentPropertyNullException.cs
+++ b/src/Atc/Exceptions/ArgumentPropertyNullException.cs
@@ -64,7 +64,11 @@ public ArgumentPropertyNullException(
     private ArgumentPropertyNullException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Exceptions/CertificateValidationException.cs b/src/Atc/Exceptions/CertificateValidationException.cs
index 9c934a7e..a3ea499e 100644
--- a/src/Atc/Exceptions/CertificateValidationException.cs
+++ b/src/Atc/Exceptions/CertificateValidationException.cs
@@ -47,7 +47,11 @@ public CertificateValidationException(
     protected CertificateValidationException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Exceptions/ConfigurationException.cs b/src/Atc/Exceptions/ConfigurationException.cs
index bc57f98c..ae224eb5 100644
--- a/src/Atc/Exceptions/ConfigurationException.cs
+++ b/src/Atc/Exceptions/ConfigurationException.cs
@@ -61,7 +61,11 @@ public ConfigurationException(
     protected ConfigurationException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 
diff --git a/src/Atc/Exceptions/DesignTimeUseOnlyException.cs b/src/Atc/Exceptions/DesignTimeUseOnlyException.cs
index 3ca55c71..d06e3b58 100644
--- a/src/Atc/Exceptions/DesignTimeUseOnlyException.cs
+++ b/src/Atc/Exceptions/DesignTimeUseOnlyException.cs
@@ -51,7 +51,11 @@ public DesignTimeUseOnlyException(
     protected DesignTimeUseOnlyException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Exceptions/EntityStoreException.cs b/src/Atc/Exceptions/EntityStoreException.cs
index 4e8327d8..ad5cd7b8 100644
--- a/src/Atc/Exceptions/EntityStoreException.cs
+++ b/src/Atc/Exceptions/EntityStoreException.cs
@@ -47,7 +47,11 @@ public EntityStoreException(
     protected EntityStoreException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Exceptions/ItemNotFoundException.cs b/src/Atc/Exceptions/ItemNotFoundException.cs
index 64882f46..3b28f1fd 100644
--- a/src/Atc/Exceptions/ItemNotFoundException.cs
+++ b/src/Atc/Exceptions/ItemNotFoundException.cs
@@ -47,7 +47,11 @@ public ItemNotFoundException(
     protected ItemNotFoundException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Exceptions/NullException.cs b/src/Atc/Exceptions/NullException.cs
index a105e597..300d2f77 100644
--- a/src/Atc/Exceptions/NullException.cs
+++ b/src/Atc/Exceptions/NullException.cs
@@ -47,7 +47,11 @@ public NullException(
     protected NullException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Exceptions/PermissionException.cs b/src/Atc/Exceptions/PermissionException.cs
index 6074820d..b38d34dd 100644
--- a/src/Atc/Exceptions/PermissionException.cs
+++ b/src/Atc/Exceptions/PermissionException.cs
@@ -47,7 +47,11 @@ public PermissionException(
     protected PermissionException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Exceptions/StringNullOrEmptyException.cs b/src/Atc/Exceptions/StringNullOrEmptyException.cs
index 7db94ffe..160dbdc1 100644
--- a/src/Atc/Exceptions/StringNullOrEmptyException.cs
+++ b/src/Atc/Exceptions/StringNullOrEmptyException.cs
@@ -47,7 +47,11 @@ public StringNullOrEmptyException(
     protected StringNullOrEmptyException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Exceptions/SwitchCaseDefaultException.cs b/src/Atc/Exceptions/SwitchCaseDefaultException.cs
index cde401e1..6b8bf391 100644
--- a/src/Atc/Exceptions/SwitchCaseDefaultException.cs
+++ b/src/Atc/Exceptions/SwitchCaseDefaultException.cs
@@ -91,7 +91,11 @@ public SwitchCaseDefaultException(
     protected SwitchCaseDefaultException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Exceptions/TcpException.cs b/src/Atc/Exceptions/TcpException.cs
index c04ee54d..2317857b 100644
--- a/src/Atc/Exceptions/TcpException.cs
+++ b/src/Atc/Exceptions/TcpException.cs
@@ -47,7 +47,11 @@ public TcpException(
     protected TcpException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Exceptions/UnexpectedTypeException.cs b/src/Atc/Exceptions/UnexpectedTypeException.cs
index 8cb94de9..91fc2191 100644
--- a/src/Atc/Exceptions/UnexpectedTypeException.cs
+++ b/src/Atc/Exceptions/UnexpectedTypeException.cs
@@ -126,7 +126,11 @@ public UnexpectedTypeException(
     protected UnexpectedTypeException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Exceptions/UserNotFoundException.cs b/src/Atc/Exceptions/UserNotFoundException.cs
index c97b40ac..58ca05cc 100644
--- a/src/Atc/Exceptions/UserNotFoundException.cs
+++ b/src/Atc/Exceptions/UserNotFoundException.cs
@@ -47,7 +47,11 @@ public UserNotFoundException(
     protected UserNotFoundException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Exceptions/ViewModelException.cs b/src/Atc/Exceptions/ViewModelException.cs
index 0ed9590e..0c1a3ba9 100644
--- a/src/Atc/Exceptions/ViewModelException.cs
+++ b/src/Atc/Exceptions/ViewModelException.cs
@@ -47,7 +47,11 @@ public ViewModelException(
     protected ViewModelException(
         SerializationInfo serializationInfo,
         StreamingContext streamingContext)
+#if NETSTANDARD2_0
+        : base(serializationInfo, streamingContext)
+#else
         : base(ExceptionMessage)
+#endif
     {
     }
 }
\ No newline at end of file

From 3c8b5ee664a1526a61a1066c410e98bfc0d295ec Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 01:28:55 +0200
Subject: [PATCH 006/100] fix(atc): correctness fixes across core extensions,
 helpers, units and math

- LongExtensions.FromUnixTimeMs: convert from milliseconds (was dropping sub-second precision or treating ms as seconds).

- ExceptionExtensions: Flatten emits each inner exception's own stack trace; ToXml no longer throws on short/blank stack-trace frames.

- ConcurrentHashSet.GetEnumerator: iterate a read-locked snapshot so concurrent mutation cannot throw.

- ByteSize.GetHashCode: derive from Value so it agrees with Equals (reliable as a dictionary/set key).

- TriangleHelper: bound the refinement recursion, throwing ArithmeticException for degenerate input instead of StackOverflowException.

- NumberToStringJsonConverter: format/parse numbers with InvariantCulture for locale-stable JSON.

- ByteExtensions.TakeBytesAndConvertToInt/Long: zero-pad to the target width so partial-length reads return the correct value instead of throwing.

- TypeExtensions.BeautifyName: genericize all type arguments, not just the first.

- EnumHelper: convert boxed enum values via Convert.ToInt32 so non-int-backed enums no longer throw InvalidCastException.

- StringExtensions: XmlEncode emits valid entities and XmlDecode decodes the ampersand last for a faithful round-trip; repaired dead accent-normalization replacements.

- LoggerExtensions: log via a constant message template instead of passing interpolated text as the format string.
---
 src/Atc/Collections/ConcurrentHashSet.cs      | 12 ++++++---
 .../Extensions/BaseTypes/ByteExtensions.cs    |  8 +++---
 .../Extensions/BaseTypes/LongExtensions.cs    |  4 +--
 src/Atc/Extensions/ExceptionExtensions.cs     | 14 +++++-----
 src/Atc/Extensions/LoggerExtensions.cs        | 12 ++++-----
 src/Atc/Extensions/StringExtensions.cs        | 24 ++++++++++-------
 src/Atc/Extensions/TypeExtensions.cs          |  2 +-
 src/Atc/Helpers/Enums/EnumHelper.cs           | 14 +++++-----
 src/Atc/Math/Trigonometry/TriangleHelper.cs   | 25 ++++++++++++++---
 .../NumberToStringJsonConverter.cs            |  7 ++---
 src/Atc/Units/DigitalInformation/ByteSize.cs  |  2 +-
 .../Collections/ConcurrentHashSetTests.cs     | 25 +++++++++++++++++
 .../BaseTypes/ByteExtensionsTests.cs          |  4 +++
 .../BaseTypes/LongExtensionsTests.cs          | 24 +++++++++++++++++
 .../Extensions/StringExtensionsTests.cs       | 13 +++++++++
 .../Extensions/TypeExtensionsTests.cs         |  4 +--
 .../NumberToStringJsonConverterTests.cs       | 27 +++++++++++++++++++
 .../Units/DigitalInformation/ByteSizeTests.cs | 27 +++++++++++++++++++
 18 files changed, 196 insertions(+), 52 deletions(-)

diff --git a/src/Atc/Collections/ConcurrentHashSet.cs b/src/Atc/Collections/ConcurrentHashSet.cs
index 67ffc979..8af6eb0e 100644
--- a/src/Atc/Collections/ConcurrentHashSet.cs
+++ b/src/Atc/Collections/ConcurrentHashSet.cs
@@ -35,19 +35,23 @@ public int Count
     }
 
     /// <inheritdoc />
+    /// <remarks>
+    /// Returns an enumerator over a point-in-time snapshot taken under a read lock,
+    /// so iteration is safe even if the set is mutated concurrently afterwards.
+    /// </remarks>
     public IEnumerator<T> GetEnumerator()
     {
-        readerWriterLock.EnterWriteLock();
+        readerWriterLock.EnterReadLock();
 
         try
         {
-            return hashSet.GetEnumerator();
+            return hashSet.ToList().GetEnumerator();
         }
         finally
         {
-            if (readerWriterLock.IsWriteLockHeld)
+            if (readerWriterLock.IsReadLockHeld)
             {
-                readerWriterLock.ExitWriteLock();
+                readerWriterLock.ExitReadLock();
             }
         }
     }
diff --git a/src/Atc/Extensions/BaseTypes/ByteExtensions.cs b/src/Atc/Extensions/BaseTypes/ByteExtensions.cs
index aa34ca53..004e23da 100644
--- a/src/Atc/Extensions/BaseTypes/ByteExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/ByteExtensions.cs
@@ -58,10 +58,10 @@ public static int TakeBytesAndConvertToInt(
             return -1;
         }
 
-        if (length < sizeof(int))
+        if (bytes.Length < sizeof(int))
         {
             bytes = bytes
-                .Concat(ByteHelper.CreateZeroArray(length))
+                .Concat(ByteHelper.CreateZeroArray(sizeof(int) - bytes.Length))
                 .ToArray();
         }
 
@@ -95,10 +95,10 @@ public static long TakeBytesAndConvertToLong(
             return -1;
         }
 
-        if (length < sizeof(long))
+        if (bytes.Length < sizeof(long))
         {
             bytes = bytes
-                .Concat(ByteHelper.CreateZeroArray(length))
+                .Concat(ByteHelper.CreateZeroArray(sizeof(long) - bytes.Length))
                 .ToArray();
         }
 
diff --git a/src/Atc/Extensions/BaseTypes/LongExtensions.cs b/src/Atc/Extensions/BaseTypes/LongExtensions.cs
index 23395360..584dd0ac 100644
--- a/src/Atc/Extensions/BaseTypes/LongExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/LongExtensions.cs
@@ -26,7 +26,5 @@ public static DateTimeOffset FromUnixTime(this long valueInSeconds)
     /// DateTimeOffset dateTimeOffset = unixTime.FromUnixTimeMs();
     /// ]]></example>
     public static DateTimeOffset FromUnixTimeMs(this long valueInMs)
-        => valueInMs >= 1000
-            ? DateTimeOffset.FromUnixTimeSeconds(valueInMs / 1000)
-            : DateTimeOffset.FromUnixTimeSeconds(valueInMs);
+        => DateTimeOffset.FromUnixTimeMilliseconds(valueInMs);
 }
\ No newline at end of file
diff --git a/src/Atc/Extensions/ExceptionExtensions.cs b/src/Atc/Extensions/ExceptionExtensions.cs
index b336b84f..76df4065 100644
--- a/src/Atc/Extensions/ExceptionExtensions.cs
+++ b/src/Atc/Extensions/ExceptionExtensions.cs
@@ -86,16 +86,12 @@ public static string Flatten(
         while (currentException is not null)
         {
             sb.AppendLine(currentException.Message);
-            if (includeStackTrace && exception.StackTrace is not null)
+            if (includeStackTrace && currentException.StackTrace is not null)
             {
-                sb.Append(exception.StackTrace);
+                sb.AppendLine(currentException.StackTrace);
             }
 
             currentException = currentException.InnerException;
-            if (includeStackTrace && exception.StackTrace is not null)
-            {
-                sb.AppendLine();
-            }
         }
 
         return sb.ToString();
@@ -128,7 +124,11 @@ public static XDocument ToXml(this Exception exception)
         {
             var xElements = from frame
                     in exception.StackTrace.Split('\n')
-                let prettierFrame = frame[6..].Trim()
+                let trimmedFrame = frame.Trim()
+                where trimmedFrame.Length > 0
+                let prettierFrame = trimmedFrame.StartsWith("at ", StringComparison.Ordinal)
+                    ? trimmedFrame[3..].Trim()
+                    : trimmedFrame
                 select new XElement("Frame", prettierFrame);
             root.Add(new XElement("StackTrace", xElements));
         }
diff --git a/src/Atc/Extensions/LoggerExtensions.cs b/src/Atc/Extensions/LoggerExtensions.cs
index ffe9e9e4..4b709e32 100644
--- a/src/Atc/Extensions/LoggerExtensions.cs
+++ b/src/Atc/Extensions/LoggerExtensions.cs
@@ -29,26 +29,26 @@ public static void LogKeyValueItem(
         switch (logKeyValueItem.LogCategory)
         {
             case LogCategoryType.Critical:
-                logger.LogCritical(message);
+                logger.LogCritical("{Message}", message);
                 break;
             case LogCategoryType.Error:
-                logger.LogError(message);
+                logger.LogError("{Message}", message);
                 break;
             case LogCategoryType.Warning:
-                logger.LogWarning(message);
+                logger.LogWarning("{Message}", message);
                 break;
             case LogCategoryType.Security:
             case LogCategoryType.Audit:
             case LogCategoryType.Service:
             case LogCategoryType.UI:
             case LogCategoryType.Information:
-                logger.LogInformation(message);
+                logger.LogInformation("{Message}", message);
                 break;
             case LogCategoryType.Debug:
-                logger.LogDebug(message);
+                logger.LogDebug("{Message}", message);
                 break;
             case LogCategoryType.Trace:
-                logger.LogTrace(message);
+                logger.LogTrace("{Message}", message);
                 break;
             default:
                 throw new SwitchCaseDefaultException(logKeyValueItem.LogCategory);
diff --git a/src/Atc/Extensions/StringExtensions.cs b/src/Atc/Extensions/StringExtensions.cs
index 7e045a15..edb2a711 100644
--- a/src/Atc/Extensions/StringExtensions.cs
+++ b/src/Atc/Extensions/StringExtensions.cs
@@ -938,27 +938,31 @@ public static string XmlEncode(this string xml)
         }
 
         return xml
-            .Replace("&", "&amp", StringComparison.Ordinal)
+            .Replace("&", "&amp;", StringComparison.Ordinal)
             .Replace("'", "&#39;", StringComparison.Ordinal)
             .Replace("<", "&lt;", StringComparison.Ordinal)
             .Replace(">", "&gt;", StringComparison.Ordinal)
-            .Replace("\"", "&quot", StringComparison.Ordinal);
+            .Replace("\"", "&quot;", StringComparison.Ordinal);
     }
 
     /// <summary>
-    /// Decodes an XML string by unescaping special character entities (&amp;amp, &amp;#39;, &amp;lt;, &amp;gt;, &amp;quot).
+    /// Decodes an XML string by unescaping special character entities (&amp;amp;, &amp;#39;, &amp;lt;, &amp;gt;, &amp;quot;).
     /// </summary>
     /// <param name="xml">The XML string to decode.</param>
     /// <returns>The decoded XML string with special character entities replaced.</returns>
+    /// <remarks>
+    /// The ampersand entity (<c>&amp;amp;</c>) is decoded last so that already-decoded content
+    /// is not re-interpreted, keeping <see cref="XmlEncode"/>/<see cref="XmlDecode"/> a faithful round-trip.
+    /// </remarks>
     public static string XmlDecode(this string xml)
         => string.IsNullOrEmpty(xml)
             ? xml
             : xml
-                .Replace("&amp", "&", StringComparison.Ordinal)
                 .Replace("&#39;", "'", StringComparison.Ordinal)
                 .Replace("&lt;", "<", StringComparison.Ordinal)
                 .Replace("&gt;", ">", StringComparison.Ordinal)
-                .Replace("&quot", "\"", StringComparison.Ordinal);
+                .Replace("&quot;", "\"", StringComparison.Ordinal)
+                .Replace("&amp;", "&", StringComparison.Ordinal);
 
     /// <summary>
     /// Sorts letters in the string alphabetically.
@@ -2276,13 +2280,13 @@ private static string NormalizeAccentsHelper(
                     case LetterAccentType.Grave:
                         value = value
                             .Replace("&agrave;", "a", StringComparison.Ordinal)
-                            .Replace("&egrave; ", "e", StringComparison.Ordinal)
-                            .Replace("&igrave; ", "i", StringComparison.Ordinal)
+                            .Replace("&egrave;", "e", StringComparison.Ordinal)
+                            .Replace("&igrave;", "i", StringComparison.Ordinal)
                             .Replace("&ograve;", "o", StringComparison.Ordinal)
                             .Replace("&ugrave;", "u", StringComparison.Ordinal)
                             .Replace("&#224;", "a", StringComparison.Ordinal)
-                            .Replace("&#232; ", "e", StringComparison.Ordinal)
-                            .Replace("&#236; ", "i", StringComparison.Ordinal)
+                            .Replace("&#232;", "e", StringComparison.Ordinal)
+                            .Replace("&#236;", "i", StringComparison.Ordinal)
                             .Replace("&#242;", "o", StringComparison.Ordinal)
                             .Replace("&#249;", "u", StringComparison.Ordinal);
                         break;
@@ -2402,7 +2406,7 @@ private static string NormalizeAccentsHelper(
                             .Replace("&#196;", "A", StringComparison.Ordinal)
                             .Replace("&#203;", "E", StringComparison.Ordinal)
                             .Replace("&#207;", "I", StringComparison.Ordinal)
-                            .Replace("&#214,", "O", StringComparison.Ordinal)
+                            .Replace("&#214;", "O", StringComparison.Ordinal)
                             .Replace("&#220;", "U", StringComparison.Ordinal)
                             .Replace("&#159;", "Y", StringComparison.Ordinal);
                         break;
diff --git a/src/Atc/Extensions/TypeExtensions.cs b/src/Atc/Extensions/TypeExtensions.cs
index d3fea70a..fe2d087f 100644
--- a/src/Atc/Extensions/TypeExtensions.cs
+++ b/src/Atc/Extensions/TypeExtensions.cs
@@ -572,7 +572,7 @@ public static string BeautifyName(
                 .ToArray();
             for (var i = 0; i < sa.Length; i++)
             {
-                sa[0] = "T";
+                sa[i] = "T";
             }
 
             genericArguments = string.Join(", ", sa);
diff --git a/src/Atc/Helpers/Enums/EnumHelper.cs b/src/Atc/Helpers/Enums/EnumHelper.cs
index 1d4125fe..1e98d642 100644
--- a/src/Atc/Helpers/Enums/EnumHelper.cs
+++ b/src/Atc/Helpers/Enums/EnumHelper.cs
@@ -212,14 +212,14 @@ public static Dictionary<int, string> ConvertEnumToDictionary(
 
             if (dropDownFirstItemType == DropDownFirstItemType.None)
             {
-                if (!list.ContainsKey((int)objEnumValue))
+                if (!list.ContainsKey(Convert.ToInt32(objEnumValue, CultureInfo.InvariantCulture)))
                 {
-                    list.Add((int)objEnumValue, value);
+                    list.Add(Convert.ToInt32(objEnumValue, CultureInfo.InvariantCulture), value);
                 }
             }
-            else if (!list.ContainsKey((int)objEnumValue))
+            else if (!list.ContainsKey(Convert.ToInt32(objEnumValue, CultureInfo.InvariantCulture)))
             {
-                list.Add((int)objEnumValue, value);
+                list.Add(Convert.ToInt32(objEnumValue, CultureInfo.InvariantCulture), value);
             }
         }
 
@@ -636,7 +636,7 @@ private static bool ShouldEnumValueBeSkipped(
         bool byFlagIncludeBase,
         bool byFlagIncludeCombined)
     {
-        if (!includeDefault && (int)objEnumValue == 0)
+        if (!includeDefault && Convert.ToInt32(objEnumValue, CultureInfo.InvariantCulture) == 0)
         {
             return true;
         }
@@ -646,7 +646,7 @@ private static bool ShouldEnumValueBeSkipped(
             return false;
         }
 
-        var n = (int)objEnumValue;
+        var n = Convert.ToInt32(objEnumValue, CultureInfo.InvariantCulture);
         if (!byFlagIncludeBase && n.IsBinarySequence())
         {
             return true;
@@ -662,6 +662,6 @@ private static bool ShouldEnumValueBeSkipped(
             return false;
         }
 
-        return !includeDefault || (int)objEnumValue != 0;
+        return !includeDefault || Convert.ToInt32(objEnumValue, CultureInfo.InvariantCulture) != 0;
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Math/Trigonometry/TriangleHelper.cs b/src/Atc/Math/Trigonometry/TriangleHelper.cs
index ad6db76f..3da3dc91 100644
--- a/src/Atc/Math/Trigonometry/TriangleHelper.cs
+++ b/src/Atc/Math/Trigonometry/TriangleHelper.cs
@@ -74,6 +74,13 @@ public static TriangleData SinesAndCosines(
         return result;
     }
 
+    /// <summary>
+    /// The maximum number of refinement passes performed by <see cref="CalculateAnglesAndSides(TriangleData, int)"/>.
+    /// A solvable triangle converges within one or two passes; this cap guards against
+    /// under-determined or degenerate inputs that would otherwise recurse indefinitely.
+    /// </summary>
+    private const int MaxCalculationPasses = 8;
+
     private static bool IsAngleAndSidesCalculated(TriangleData result)
         => !MathHelper.IsEqualToZero(result.A)
            && !MathHelper.IsEqualToZero(result.B)
@@ -91,7 +98,9 @@ private static bool IsAngleAndSidesCalculated(TriangleData result)
     /// </remarks>
     [SuppressMessage("Design", "MA0051:Method is too long", Justification = "OK.")]
     [SuppressMessage("Critical Code Smell", "S3776:Cognitive Complexity of methods should not be too high", Justification = "OK.")]
-    private static TriangleData CalculateAnglesAndSides(TriangleData data)
+    private static TriangleData CalculateAnglesAndSides(
+        TriangleData data,
+        int remainingPasses = MaxCalculationPasses)
     {
         // A
         if (MathHelper.IsEqualToZero(data.A))
@@ -255,8 +264,16 @@ private static TriangleData CalculateAnglesAndSides(TriangleData data)
             }
         }
 
-        return IsAngleAndSidesCalculated(data)
-            ? data
-            : CalculateAnglesAndSides(data);
+        if (IsAngleAndSidesCalculated(data))
+        {
+            return data;
+        }
+
+        if (remainingPasses <= 0)
+        {
+            throw new ArithmeticException("Unable to calculate the triangle from the supplied values; the input may be under-determined or degenerate.");
+        }
+
+        return CalculateAnglesAndSides(data, remainingPasses - 1);
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Serialization/JsonConverters/NumberToStringJsonConverter.cs b/src/Atc/Serialization/JsonConverters/NumberToStringJsonConverter.cs
index 557a779d..2cab7e33 100644
--- a/src/Atc/Serialization/JsonConverters/NumberToStringJsonConverter.cs
+++ b/src/Atc/Serialization/JsonConverters/NumberToStringJsonConverter.cs
@@ -7,7 +7,8 @@ namespace Atc.Serialization.JsonConverters;
 /// <remarks>
 /// This converter handles conversion between JSON numbers and strings, allowing numeric values in JSON
 /// to be read as strings. During deserialization, JSON numbers are converted to their string representation
-/// using the current thread's culture. During serialization, any object is converted to its string representation.
+/// using the invariant culture so the result is stable across machines and locales. During serialization,
+/// any object is converted to its string representation.
 /// </remarks>
 public sealed class NumberToStringJsonConverter : JsonConverter<object>
 {
@@ -25,10 +26,10 @@ public override object Read(
         {
             case JsonTokenType.Number:
                 return reader.TryGetInt64(out var l)
-                    ? l.ToString(Thread.CurrentThread.CurrentCulture)
+                    ? l.ToString(CultureInfo.InvariantCulture)
                     : reader
                         .GetDouble()
-                        .ToString(Thread.CurrentThread.CurrentCulture);
+                        .ToString(CultureInfo.InvariantCulture);
             case JsonTokenType.String:
                 return reader.GetString() ?? string.Empty;
             default:
diff --git a/src/Atc/Units/DigitalInformation/ByteSize.cs b/src/Atc/Units/DigitalInformation/ByteSize.cs
index efd0f156..1ea2dd7d 100644
--- a/src/Atc/Units/DigitalInformation/ByteSize.cs
+++ b/src/Atc/Units/DigitalInformation/ByteSize.cs
@@ -164,7 +164,7 @@ public override readonly bool Equals(object? obj)
         => obj is ByteSize x && Equals(x);
 
     /// <inheritdoc />
-    public override readonly int GetHashCode() => base.GetHashCode();
+    public override readonly int GetHashCode() => Value.GetHashCode();
 
     /// <summary>
     /// Returns a <see cref="string" /> that represents this instance.
diff --git a/test/Atc.Tests/Collections/ConcurrentHashSetTests.cs b/test/Atc.Tests/Collections/ConcurrentHashSetTests.cs
index a7575181..c07c35a1 100644
--- a/test/Atc.Tests/Collections/ConcurrentHashSetTests.cs
+++ b/test/Atc.Tests/Collections/ConcurrentHashSetTests.cs
@@ -16,6 +16,31 @@ public void GetEnumerator()
         list.Dispose();
     }
 
+    [Fact]
+    public void GetEnumerator_DoesNotThrow_WhenSetIsMutatedDuringEnumeration()
+    {
+        // Arrange
+        using var set = new ConcurrentHashSet<int>();
+        for (var i = 0; i < 1000; i++)
+        {
+            set.TryAdd(i);
+        }
+
+        // Act - enumeration iterates a snapshot, so concurrent mutation must not throw.
+        var exception = Record.Exception(() =>
+        {
+            var seed = 1_000;
+            foreach (var unused in set)
+            {
+                set.TryAdd(seed++);
+                set.TryRemove(0);
+            }
+        });
+
+        // Assert
+        Assert.Null(exception);
+    }
+
     [Theory]
     [InlineData(true, 27)]
     public void TryAdd(
diff --git a/test/Atc.Tests/Extensions/BaseTypes/ByteExtensionsTests.cs b/test/Atc.Tests/Extensions/BaseTypes/ByteExtensionsTests.cs
index 42129557..142fc914 100644
--- a/test/Atc.Tests/Extensions/BaseTypes/ByteExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/BaseTypes/ByteExtensionsTests.cs
@@ -24,6 +24,8 @@ public void TakeBytes(
     [Theory]
     [InlineData(new byte[] { 1, 0, 0, 0 }, 0, 4, 1)]
     [InlineData(new byte[] { 255, 0, 0, 0 }, 0, 4, 255)]
+    [InlineData(new byte[] { 1, 2, 3, 4, 5 }, 0, 1, 1)]
+    [InlineData(new byte[] { 255, 1, 0, 0 }, 0, 2, 511)]
     public void TakeBytesAndConvertToInt(
         byte[] value,
         int startPosition,
@@ -40,6 +42,8 @@ public void TakeBytesAndConvertToInt(
     [Theory]
     [InlineData(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, 0, 8, 1L)]
     [InlineData(new byte[] { 255, 0, 0, 0, 0, 0, 0, 0 }, 0, 8, 255L)]
+    [InlineData(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }, 0, 1, 1L)]
+    [InlineData(new byte[] { 255, 1, 0, 0, 0, 0, 0, 0 }, 0, 2, 511L)]
     public void TakeBytesAndConvertToLong(
         byte[] value,
         int startPosition,
diff --git a/test/Atc.Tests/Extensions/BaseTypes/LongExtensionsTests.cs b/test/Atc.Tests/Extensions/BaseTypes/LongExtensionsTests.cs
index fa6c2811..860433b9 100644
--- a/test/Atc.Tests/Extensions/BaseTypes/LongExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/BaseTypes/LongExtensionsTests.cs
@@ -43,4 +43,28 @@ public void FromUnixTimeMs(
         // Assert
         Assert.Equal(expectedDateTimeOffset, actual);
     }
+
+    [Theory]
+    [InlineData(500, 1970, 1, 1, 0, 0, 0, 500)]
+    [InlineData(1500, 1970, 1, 1, 0, 0, 1, 500)]
+    [InlineData(999, 1970, 1, 1, 0, 0, 0, 999)]
+    public void FromUnixTimeMs_ShouldPreserveSubSecondMilliseconds(
+        long input,
+        int expectedYear,
+        int expectedMonth,
+        int expectedDay,
+        int expectedHour,
+        int expectedMinute,
+        int expectedSecond,
+        int expectedMillisecond)
+    {
+        // Arrange
+        var expectedDateTimeOffset = new DateTimeOffset(expectedYear, expectedMonth, expectedDay, expectedHour, expectedMinute, expectedSecond, expectedMillisecond, TimeSpan.Zero);
+
+        // Act
+        var actual = input.FromUnixTimeMs();
+
+        // Assert
+        Assert.Equal(expectedDateTimeOffset, actual);
+    }
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Extensions/StringExtensionsTests.cs b/test/Atc.Tests/Extensions/StringExtensionsTests.cs
index dc5900b7..3918548e 100644
--- a/test/Atc.Tests/Extensions/StringExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/StringExtensionsTests.cs
@@ -573,6 +573,7 @@ public void JavaScriptDecode(
 
     [Theory]
     [InlineData("&lt;root&gt;&lt;node name=&#39;TheName&#39;&gt;Hallo&lt;/node&gt;&lt;/root&gt;", "<root><node name='TheName'>Hallo</node></root>")]
+    [InlineData("&lt;a x=&quot;b &amp; c&quot;&gt;", "<a x=\"b & c\">")]
     public void XmlEncode(
         string expected,
         string input)
@@ -580,11 +581,18 @@ public void XmlEncode(
 
     [Theory]
     [InlineData("<root><node name='TheName'>Hallo</node></root>", "&lt;root&gt;&lt;node name=&#39;TheName&#39;&gt;Hallo&lt;/node&gt;&lt;/root&gt;")]
+    [InlineData("<a x=\"b & c\">", "&lt;a x=&quot;b &amp; c&quot;&gt;")]
     public void XmlDecode(
         string expected,
         string input)
         => Assert.Equal(expected, input.XmlDecode());
 
+    [Theory]
+    [InlineData("<a x=\"b & c\">")]
+    [InlineData("plain & simple \"quoted\" <tag> 'apos'")]
+    public void XmlEncode_Then_XmlDecode_RoundTrips(string input)
+        => Assert.Equal(input, input.XmlEncode().XmlDecode());
+
     [Theory]
     [InlineData("abc", "abc")]
     [InlineData("abc", "bac")]
@@ -601,6 +609,11 @@ public void Alphabetize(
     [InlineData("abc", "&acirc;bc")]
     [InlineData("abc", "&atilde;bc")]
     [InlineData("abc", "&auml;bc")]
+    [InlineData("ebc", "&egrave;bc")]
+    [InlineData("ibc", "&igrave;bc")]
+    [InlineData("ebc", "&#232;bc")]
+    [InlineData("ibc", "&#236;bc")]
+    [InlineData("Obc", "&#214;bc")]
     public void NormalizeAccents(
         string expected,
         string input)
diff --git a/test/Atc.Tests/Extensions/TypeExtensionsTests.cs b/test/Atc.Tests/Extensions/TypeExtensionsTests.cs
index 70d669e0..6032643b 100644
--- a/test/Atc.Tests/Extensions/TypeExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/TypeExtensionsTests.cs
@@ -498,7 +498,7 @@ public void BeautifyName_UseFullName_UseHtmlFormat(
     }
 
     [Theory]
-    [InlineData("Dictionary<T, LocalizedDescriptionAttribute>", typeof(Dictionary<LocalizedDescriptionAttribute, LocalizedDescriptionAttribute>), false, false, true)]
+    [InlineData("Dictionary<T, T>", typeof(Dictionary<LocalizedDescriptionAttribute, LocalizedDescriptionAttribute>), false, false, true)]
     public void BeautifyName_UseFullName_UseHtmlFormat_UseGenericParameterNamesAsT(
         string expected,
         Type type,
@@ -510,7 +510,7 @@ public void BeautifyName_UseFullName_UseHtmlFormat_UseGenericParameterNamesAsT(
     }
 
     [Theory]
-    [InlineData("T, LocalizedDescriptionAttribute?", typeof(Dictionary<LocalizedDescriptionAttribute, LocalizedDescriptionAttribute>), false, false, true, true)]
+    [InlineData("T, T?", typeof(Dictionary<LocalizedDescriptionAttribute, LocalizedDescriptionAttribute>), false, false, true, true)]
     public void BeautifyName_UseFullName_UseGenericParameterNamesAsT_UseSuffixQuestionMarkForGeneric(
         string expected,
         Type type,
diff --git a/test/Atc.Tests/Serialization/JsonConverters/NumberToStringJsonConverterTests.cs b/test/Atc.Tests/Serialization/JsonConverters/NumberToStringJsonConverterTests.cs
index 9897c002..548006b0 100644
--- a/test/Atc.Tests/Serialization/JsonConverters/NumberToStringJsonConverterTests.cs
+++ b/test/Atc.Tests/Serialization/JsonConverters/NumberToStringJsonConverterTests.cs
@@ -27,6 +27,33 @@ public void Read_ShouldReturnStringRepresentationOfNumber(
         Assert.Equal(expected, NumberHelper.ParseToDouble(result.ToString()!, GlobalizationConstants.EnglishCultureInfo));
     }
 
+    [Fact]
+    public void Read_ShouldUseInvariantCulture_RegardlessOfCurrentCulture()
+    {
+        // Arrange
+        var originalCulture = Thread.CurrentThread.CurrentCulture;
+        Thread.CurrentThread.CurrentCulture = GlobalizationConstants.DanishCultureInfo;
+
+        try
+        {
+            var jsonSerializerOptions = JsonSerializerOptionsFactory.Create();
+            var jsonConverter = new NumberToStringJsonConverter();
+            var utf8JsonReader = new Utf8JsonReader(Encoding.UTF8.GetBytes("123.45"));
+
+            utf8JsonReader.Read();
+
+            // Act
+            var result = jsonConverter.Read(ref utf8JsonReader, typeof(string), jsonSerializerOptions);
+
+            // Assert - invariant culture uses '.' as the decimal separator even under da-DK
+            Assert.Equal("123.45", result);
+        }
+        finally
+        {
+            Thread.CurrentThread.CurrentCulture = originalCulture;
+        }
+    }
+
     [Theory]
     [InlineData(123)]
     [InlineData(123.45)]
diff --git a/test/Atc.Tests/Units/DigitalInformation/ByteSizeTests.cs b/test/Atc.Tests/Units/DigitalInformation/ByteSizeTests.cs
index b762c765..05bd4405 100644
--- a/test/Atc.Tests/Units/DigitalInformation/ByteSizeTests.cs
+++ b/test/Atc.Tests/Units/DigitalInformation/ByteSizeTests.cs
@@ -50,4 +50,31 @@ public void Format_Default_Formatter(
         Assert.Equal(expected, actual);
         Assert.Equal(expected, byteSize.ToString(formatter));
     }
+
+    [Fact]
+    public void GetHashCode_ShouldBeConsistentWithEquality()
+    {
+        // Arrange
+        var a = new ByteSize(2048);
+        var b = new ByteSize(2048);
+
+        // Assert
+        Assert.Equal(a, b);
+        Assert.Equal(a.GetHashCode(), b.GetHashCode());
+        Assert.Equal(a.Value.GetHashCode(), a.GetHashCode());
+    }
+
+    [Fact]
+    public void GetHashCode_AllowsReliableUseAsHashSetKey()
+    {
+        // Arrange
+        var set = new HashSet<ByteSize>
+        {
+            new(2048),
+        };
+
+        // Act & Assert - a value-equal instance must be found (broken when GetHashCode used base.GetHashCode()).
+        Assert.Contains(new ByteSize(2048), set);
+        Assert.DoesNotContain(new ByteSize(4096), set);
+    }
 }
\ No newline at end of file

From 2b864370bebbdcd4d860a66fa972f4dcc6c6aca5 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 01:29:05 +0200
Subject: [PATCH 007/100] fix(atc-rest): guard pagination page count and harden
 x-request-id handling

- Pagination.TotalPages returns null when PageSize <= 0 instead of producing a garbage value from a divide-by-zero.

- GetOrAddRequestId rejects CR/LF and oversized x-request-id values (header-injection / log-forging) and replaces them with a fresh GUID; non-GUID formats still pass through.
---
 .../Extensions/HeaderDictionaryExtensions.cs  | 15 ++++++++++++++-
 src/Atc.Rest/Results/Pagination.cs            |  2 +-
 .../HeaderDictionaryExtensionsTests.cs        | 19 +++++++++++++++++++
 .../Atc.Rest.Tests/Results/PaginationTests.cs | 13 +++++++++++++
 4 files changed, 47 insertions(+), 2 deletions(-)

diff --git a/src/Atc.Rest/Extensions/HeaderDictionaryExtensions.cs b/src/Atc.Rest/Extensions/HeaderDictionaryExtensions.cs
index 53b439eb..41ec7652 100644
--- a/src/Atc.Rest/Extensions/HeaderDictionaryExtensions.cs
+++ b/src/Atc.Rest/Extensions/HeaderDictionaryExtensions.cs
@@ -58,7 +58,11 @@ public static string AddCorrelationId(
 
         if (headers.TryGetValue(WellKnownHttpHeaders.RequestId, out var header))
         {
-            return header.FirstOrDefault();
+            var value = header.FirstOrDefault();
+            if (!string.IsNullOrEmpty(value) && IsSafeRequestId(value!))
+            {
+                return value;
+            }
         }
 
         var requestId = Guid
@@ -93,4 +97,13 @@ private static bool IsValidCorrelationId(string value)
         => value.Length <= 68 &&
            !value.AsSpan().ContainsAny('\r', '\n') &&
            Guid.TryParse(value, out _);
+
+    /// <summary>
+    /// Validates that a request ID value is safe to echo and log: bounded length and free of
+    /// CR/LF control characters, guarding against header-injection and log-forging. Unlike the
+    /// correlation ID, a non-GUID format is permitted so legitimate upstream request IDs pass through.
+    /// </summary>
+    private static bool IsSafeRequestId(string value)
+        => value.Length <= 128 &&
+           !value.AsSpan().ContainsAny('\r', '\n');
 }
\ No newline at end of file
diff --git a/src/Atc.Rest/Results/Pagination.cs b/src/Atc.Rest/Results/Pagination.cs
index 0de1bbef..367fad00 100644
--- a/src/Atc.Rest/Results/Pagination.cs
+++ b/src/Atc.Rest/Results/Pagination.cs
@@ -102,7 +102,7 @@ public Pagination(
     /// <summary>
     /// Gets the total number of pages based on TotalCount and PageSize.
     /// </summary>
-    public int? TotalPages => TotalCount is null
+    public int? TotalPages => TotalCount is null || PageSize <= 0
         ? default(int?)
         : (int)System.Math.Ceiling((double)TotalCount / PageSize);
 
diff --git a/test/Atc.Rest.Tests/Extensions/HeaderDictionaryExtensionsTests.cs b/test/Atc.Rest.Tests/Extensions/HeaderDictionaryExtensionsTests.cs
index 3f19ac40..666596d6 100644
--- a/test/Atc.Rest.Tests/Extensions/HeaderDictionaryExtensionsTests.cs
+++ b/test/Atc.Rest.Tests/Extensions/HeaderDictionaryExtensionsTests.cs
@@ -106,6 +106,25 @@ public void GetOrAddRequestId()
         Assert.True(Guid.TryParse(actual, out _));
     }
 
+    [Fact]
+    public void GetOrAddRequestId_Replaces_Unsafe_Value_With_New_Guid()
+    {
+        // Arrange - a CR/LF-bearing value (header-injection / log-forging attempt)
+        var data = new HeaderDictionary
+        {
+            new(
+                "x-request-id",
+                new StringValues("abc\r\nInjected-Header: evil")),
+        };
+
+        // Act
+        var actual = data.GetOrAddRequestId();
+
+        // Assert - the unsafe value must be discarded and replaced with a fresh GUID
+        Assert.NotNull(actual);
+        Assert.True(Guid.TryParse(actual, out _));
+    }
+
     [Fact]
     public void GetCallingOnBehalfOfIdentity()
     {
diff --git a/test/Atc.Rest.Tests/Results/PaginationTests.cs b/test/Atc.Rest.Tests/Results/PaginationTests.cs
index 556707b1..16981856 100644
--- a/test/Atc.Rest.Tests/Results/PaginationTests.cs
+++ b/test/Atc.Rest.Tests/Results/PaginationTests.cs
@@ -47,4 +47,17 @@ public void Calculate_TotalPages(
         // Assert
         Assert.Equal(expectedTotalPages, actual.TotalPages);
     }
+
+    [Fact]
+    public void TotalPages_IsNull_When_PageSize_Is_Zero()
+    {
+        // Arrange
+        var sut = new Pagination<int>(items: Array.Empty<int>(), pageSize: 0, queryString: null, continuationToken: null)
+        {
+            TotalCount = 10,
+        };
+
+        // Act & Assert - guards against the divide-by-zero that produced a garbage page count.
+        sut.TotalPages.Should().BeNull();
+    }
 }
\ No newline at end of file

From b24eea3c499c135c33070fd207e24c3e7d6bc7fe Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 01:29:05 +0200
Subject: [PATCH 008/100] fix(atc-rest-extended): keep JWT signature validation
 fail-closed

ValidateIssuerSigningKey is now always enabled and never disabled on an empty key set or a key-fetch timeout, so a transient identity-provider issue can no longer cause unverified tokens to be accepted.
---
 .../Options/ConfigureAuthorizationOptions.cs             | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/Atc.Rest.Extended/Options/ConfigureAuthorizationOptions.cs b/src/Atc.Rest.Extended/Options/ConfigureAuthorizationOptions.cs
index df02c693..d1adad17 100644
--- a/src/Atc.Rest.Extended/Options/ConfigureAuthorizationOptions.cs
+++ b/src/Atc.Rest.Extended/Options/ConfigureAuthorizationOptions.cs
@@ -99,6 +99,10 @@ public void PostConfigure(
             ValidAudiences = apiOptions.Authorization.ValidAudiences,
             ValidateIssuer = !string.IsNullOrWhiteSpace(apiOptions.Authorization.Issuer) ||
                              apiOptions.Authorization.ValidIssuers?.Any() == true,
+
+            // Always validate the token signature (fail-closed). This is never relaxed below,
+            // so a transient key-fetch failure can never cause unverified tokens to be accepted.
+            ValidateIssuerSigningKey = true,
         };
 
         if (!options.TokenValidationParameters.ValidateIssuer)
@@ -116,15 +120,12 @@ public void PostConfigure(
         if (!fetchTask.Wait(SigningKeyFetchTimeout))
         {
             logger?.LogWarning(
-                "Timed out fetching issuer signing keys after {TimeoutSeconds}s. Token validation will fall back to empty key set; signing-key validation disabled.",
+                "Timed out fetching issuer signing keys after {TimeoutSeconds}s. Signature validation stays enabled and relies on the JwtBearer Authority metadata; tokens that cannot be signature-verified are rejected.",
                 SigningKeyFetchTimeout.TotalSeconds);
-            options.TokenValidationParameters.IssuerSigningKeys = Array.Empty<SecurityKey>();
-            options.TokenValidationParameters.ValidateIssuerSigningKey = false;
             return;
         }
 
         options.TokenValidationParameters.IssuerSigningKeys = fetchTask.Result;
-        options.TokenValidationParameters.ValidateIssuerSigningKey = options.TokenValidationParameters.IssuerSigningKeys.Any();
     }
 
     /// <summary>

From 24942d8d5c3b3270aca89deec6e488f463889cbc Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 01:29:05 +0200
Subject: [PATCH 009/100] fix(atc-rest-healthchecks): respect RequestAborted
 when writing the health response

---
 .../Factories/HealthCheckOptionsFactory.cs                     | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/Atc.Rest.HealthChecks/Factories/HealthCheckOptionsFactory.cs b/src/Atc.Rest.HealthChecks/Factories/HealthCheckOptionsFactory.cs
index f2f1a498..65e8ba2a 100644
--- a/src/Atc.Rest.HealthChecks/Factories/HealthCheckOptionsFactory.cs
+++ b/src/Atc.Rest.HealthChecks/Factories/HealthCheckOptionsFactory.cs
@@ -36,7 +36,8 @@ public static HealthCheckOptions CreateJson(
                 await c.Response.WriteAsync(
                     JsonSerializer.Serialize(
                         response,
-                        jsonSerializerOptions ?? JsonSerializerOptionsFactory.Create()));
+                        jsonSerializerOptions ?? JsonSerializerOptionsFactory.Create()),
+                    c.RequestAborted);
             },
         };
 }
\ No newline at end of file

From 83d90a824094f4f64ed32a8a235c8072d878171c Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 01:29:18 +0200
Subject: [PATCH 010/100] fix(atc-console-spectre): escape category name and
 return a no-op scope

- Escape the category name before composing Spectre markup so a generic category containing '[' no longer throws a markup-parse exception.

- BeginScope returns a no-op IDisposable instead of null, preventing a NullReferenceException on dispose.
---
 .../Logging/ConsoleLogger.cs                  | 22 +++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

diff --git a/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs b/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs
index 986870ef..c034c0c3 100644
--- a/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs
+++ b/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs
@@ -39,7 +39,7 @@ public ConsoleLogger(
     }
 
     /// <inheritdoc />
-    public IDisposable BeginScope<TState>(TState state) => default!;
+    public IDisposable BeginScope<TState>(TState state) => NullScope.Instance;
 
     /// <inheritdoc />
     public bool IsEnabled(LogLevel logLevel)
@@ -297,7 +297,7 @@ private string GetTimeStampWithMarkup()
         => $"[white]{GetTimeStamp()}[/]";
 
     private string GetCategoryNameWithMarkup()
-        => $"[grey]{categoryName}[/]";
+        => $"[grey]{Markup.Escape(categoryName)}[/]";
 
     private string GetTimeStampAndCategoryNameWithMarkup()
         => $"{GetTimeStampWithMarkup()} {GetCategoryNameWithMarkup()}";
@@ -306,4 +306,22 @@ private string GetMessageWithMarkup(
         LogLevel logLevel,
         string message)
         => $"{GetLogLevelMarkupStartTag(logLevel)}{message}[/]";
+
+    /// <summary>
+    /// A no-op <see cref="IDisposable"/> returned by <see cref="BeginScope{TState}"/> so that
+    /// callers using <c>using (logger.BeginScope(...))</c> do not dereference a null instance.
+    /// </summary>
+    private sealed class NullScope : IDisposable
+    {
+        public static NullScope Instance { get; } = new();
+
+        private NullScope()
+        {
+        }
+
+        public void Dispose()
+        {
+            // No-op: this logger does not track scopes.
+        }
+    }
 }
\ No newline at end of file

From d8a79bba45acab579fe123eb3bd62080ec7fda34 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 01:29:18 +0200
Subject: [PATCH 011/100] fix(atc-codedoc): make markdown generation null-safe
 and table-safe

- Guard null MemberName when matching XML-doc comments.

- Escape pipe and newline characters in table cells so summaries cannot corrupt the table layout.

- Read enum values via Convert.ToInt64 so non-int-backed enums are documented without crashing.
---
 .../Markdown/MarkdownBuilder.cs               | 24 +++++++++++++++++--
 .../Markdown/MarkdownHelper.cs                |  8 +++----
 2 files changed, 26 insertions(+), 6 deletions(-)

diff --git a/src/Atc.CodeDocumentation/Markdown/MarkdownBuilder.cs b/src/Atc.CodeDocumentation/Markdown/MarkdownBuilder.cs
index 0c43139f..7e453b00 100644
--- a/src/Atc.CodeDocumentation/Markdown/MarkdownBuilder.cs
+++ b/src/Atc.CodeDocumentation/Markdown/MarkdownBuilder.cs
@@ -192,7 +192,7 @@ public void Table(
         sb.Append("| ");
         foreach (var item in headers)
         {
-            sb.Append(item);
+            sb.Append(EscapeTableCell(item));
             sb.Append(" | ");
         }
 
@@ -212,7 +212,7 @@ public void Table(
             sb.Append("| ");
             foreach (var item2 in item)
             {
-                sb.Append(item2);
+                sb.Append(EscapeTableCell(item2));
                 sb.Append(" | ");
             }
 
@@ -222,6 +222,26 @@ public void Table(
         sb.AppendLine();
     }
 
+    /// <summary>
+    /// Escapes a value for safe use inside a markdown table cell by neutralizing the
+    /// column delimiter and collapsing line breaks, which would otherwise break the table layout.
+    /// </summary>
+    /// <param name="value">The raw cell value.</param>
+    /// <returns>The escaped cell value.</returns>
+    private static string EscapeTableCell(string value)
+    {
+        if (string.IsNullOrEmpty(value))
+        {
+            return value;
+        }
+
+        return value
+            .Replace("\r\n", "<br>", StringComparison.Ordinal)
+            .Replace("\r", "<br>", StringComparison.Ordinal)
+            .Replace("\n", "<br>", StringComparison.Ordinal)
+            .Replace("|", "\\|", StringComparison.Ordinal);
+    }
+
     /// <summary>
     /// Appends an unordered list item (no nesting).
     /// </summary>
diff --git a/src/Atc.CodeDocumentation/Markdown/MarkdownHelper.cs b/src/Atc.CodeDocumentation/Markdown/MarkdownHelper.cs
index a3926e82..e30fedd3 100644
--- a/src/Atc.CodeDocumentation/Markdown/MarkdownHelper.cs
+++ b/src/Atc.CodeDocumentation/Markdown/MarkdownHelper.cs
@@ -350,7 +350,7 @@ private static void AppendBodyForEnum(
             .GetNames(typeComments.Type)
             .Select(x => new
             {
-                Value = (int)Enum.Parse(typeComments.Type, x),
+                Value = Convert.ToInt64(Enum.Parse(typeComments.Type, x), GlobalizationConstants.EnglishCultureInfo),
                 Name = x,
                 Description = (Enum.Parse(typeComments.Type, x) as Enum)!.GetDescription(),
             })
@@ -410,7 +410,7 @@ private static void BuildTable<T>(
             var data = seq
                 .Select(item =>
                 {
-                    var summary = docs.FirstOrDefault(x => string.Equals(x.MemberName, name(item), StringComparison.Ordinal) || x.MemberName!.StartsWith(name(item) + "`", StringComparison.Ordinal))?.Summary ?? string.Empty;
+                    var summary = docs.FirstOrDefault(x => string.Equals(x.MemberName, name(item), StringComparison.Ordinal) || x.MemberName?.StartsWith(name(item) + "`", StringComparison.Ordinal) == true)?.Summary ?? string.Empty;
                     return new[]
                     {
                         xType(item),
@@ -432,7 +432,7 @@ private static void BuildTable<T>(
             var data = seq
                 .Select(item =>
                 {
-                    var summary = docs.FirstOrDefault(x => string.Equals(x.MemberName, name(item), StringComparison.Ordinal) || x.MemberName!.StartsWith(name(item) + "`", StringComparison.Ordinal))?.Summary ?? string.Empty;
+                    var summary = docs.FirstOrDefault(x => string.Equals(x.MemberName, name(item), StringComparison.Ordinal) || x.MemberName?.StartsWith(name(item) + "`", StringComparison.Ordinal) == true)?.Summary ?? string.Empty;
                     return new[]
                     {
                         xType(item),
@@ -485,7 +485,7 @@ private static void Build<T>(
                 // ReSharper disable once PossibleMultipleEnumeration
                 var commentForMember = docs.FirstOrDefault(x =>
                     string.Equals(x.MemberName, name(item), StringComparison.Ordinal) ||
-                    x.MemberName!.StartsWith(name(item) + "`", StringComparison.Ordinal));
+                    x.MemberName?.StartsWith(name(item) + "`", StringComparison.Ordinal) == true);
 
                 if (commentForMember is null || string.IsNullOrEmpty(commentForMember.Summary))
                 {

From 75cfbdd83b75871643f115a4131128716ee21ea2 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 01:29:18 +0200
Subject: [PATCH 012/100] fix(atc-openapi): guard null reference in
 GetEnumSchema

Throw ItemNotFoundException instead of a NullReferenceException when neither the property nor the parent schema carries a Reference.Id.
---
 src/Atc.OpenApi/Extensions/OpenApiSchemaExtensions.cs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/Atc.OpenApi/Extensions/OpenApiSchemaExtensions.cs b/src/Atc.OpenApi/Extensions/OpenApiSchemaExtensions.cs
index f26289e7..f2074d2a 100644
--- a/src/Atc.OpenApi/Extensions/OpenApiSchemaExtensions.cs
+++ b/src/Atc.OpenApi/Extensions/OpenApiSchemaExtensions.cs
@@ -1459,7 +1459,12 @@ public static Tuple<string, OpenApiSchema> GetEnumSchema(
                 continue;
             }
 
-            var enumName = schemaProperty.Value.Reference?.Id ?? schema.Reference.Id;
+            var enumName = schemaProperty.Value.Reference?.Id ?? schema.Reference?.Id;
+            if (enumName is null)
+            {
+                throw new ItemNotFoundException("Enum schema is missing a Reference.Id.");
+            }
+
             return Tuple.Create(enumName, schemaProperty.Value);
         }
 

From 8b15eb4c60faa3cd02eeb3bab0cba3eaf5b09bc6 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 01:29:18 +0200
Subject: [PATCH 013/100] fix(atc-rest-fluentassertions): accept
 application/json with charset

Compare only the media type (case-insensitive), so 'application/json; charset=utf-8' no longer fails the content-type assertion.
---
 .../Assertions/ContentResultAssertionsBase.cs | 25 ++++++++++++++++++-
 .../ContentResultAssertionsTests.cs           | 23 +++++++++++++++++
 2 files changed, 47 insertions(+), 1 deletion(-)

diff --git a/src/Atc.Rest.FluentAssertions/Assertions/ContentResultAssertionsBase.cs b/src/Atc.Rest.FluentAssertions/Assertions/ContentResultAssertionsBase.cs
index 0de80b50..0ca642b8 100644
--- a/src/Atc.Rest.FluentAssertions/Assertions/ContentResultAssertionsBase.cs
+++ b/src/Atc.Rest.FluentAssertions/Assertions/ContentResultAssertionsBase.cs
@@ -78,7 +78,7 @@ public AndWhichConstraint<ObjectAssertions, T> WithContentOfType<T>(
             .BecauseOf(because, becauseArgs)
             .WithDefaultIdentifier($"content type of {Identifier}")
             .Given(() => Subject.ContentType)
-            .ForCondition(contentType => contentType is not null && contentType.Equals(MediaTypeNames.Application.Json, StringComparison.Ordinal))
+            .ForCondition(IsJsonContentType)
             .FailWith("Expected {context} to be {0}{reason}, but found {1}.", _ => MediaTypeNames.Application.Json, x => x);
 
         var parseSuccess = TryContentValueAs<T>(out var result);
@@ -119,6 +119,29 @@ protected bool TryContentValueAs<T>([NotNullWhen(true)] out T content)
         return false;
     }
 
+    /// <summary>
+    /// Determines whether the supplied content type denotes JSON, ignoring any
+    /// parameters such as <c>; charset=utf-8</c> and comparing case-insensitively.
+    /// </summary>
+    /// <param name="contentType">The raw <see cref="ContentResult.ContentType"/> value.</param>
+    /// <returns><see langword="true"/> if the media type is <c>application/json</c>; otherwise, <see langword="false"/>.</returns>
+    private static bool IsJsonContentType(string? contentType)
+    {
+        if (string.IsNullOrEmpty(contentType))
+        {
+            return false;
+        }
+
+        var separatorIndex = contentType.IndexOf(';', StringComparison.Ordinal);
+        var mediaType = separatorIndex >= 0
+            ? contentType[..separatorIndex]
+            : contentType;
+
+        return mediaType
+            .Trim()
+            .Equals(MediaTypeNames.Application.Json, StringComparison.OrdinalIgnoreCase);
+    }
+
     private bool TryContentValueAs(
         Type type,
         out object content)
diff --git a/test/Atc.Rest.FluentAssertions.Tests/Assertions/ContentResultAssertionsTests.cs b/test/Atc.Rest.FluentAssertions.Tests/Assertions/ContentResultAssertionsTests.cs
index 48732823..7c75a3b0 100644
--- a/test/Atc.Rest.FluentAssertions.Tests/Assertions/ContentResultAssertionsTests.cs
+++ b/test/Atc.Rest.FluentAssertions.Tests/Assertions/ContentResultAssertionsTests.cs
@@ -87,6 +87,29 @@ public void WithContent_Does_Not_Throw_When_Expected_Match()
             .NotThrow();
     }
 
+    [Theory]
+    [InlineData("application/json; charset=utf-8")]
+    [InlineData("application/json;charset=utf-8")]
+    [InlineData("APPLICATION/JSON")]
+    public void WithContent_Does_Not_Throw_When_ContentType_Has_Charset_Or_Differs_In_Case(
+        string contentType)
+    {
+        // Arrange
+        var target = new ContentResult
+        {
+            Content = TestJsonSerializer.Serialize("FOO"),
+            ContentType = contentType,
+        };
+
+        var sut = new ContentResultAssertions(target);
+
+        // Act & Assert
+        sut
+            .Invoking(x => x.WithContent("FOO"))
+            .Should()
+            .NotThrow();
+    }
+
     [Fact]
     public void WithStatusCode_Throws_When_StatusCode_Is_Not_As_Expected()
     {

From c9fada7fab2e01d23981c501165f25579cb38343 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 01:29:24 +0200
Subject: [PATCH 014/100] docs: regenerate CodeDoc for the updated XML
 documentation

---
 docs/CodeDoc/Atc/Atc.Helpers.md               | 12 +++++
 .../Atc/Atc.Serialization.JsonConverters.md   |  2 +-
 docs/CodeDoc/Atc/Atc.md                       | 29 ++++++++++--
 docs/CodeDoc/Atc/IndexExtended.md             |  6 +++
 docs/CodeDoc/Atc/System.md                    | 46 ++++++++++++++++++-
 5 files changed, 90 insertions(+), 5 deletions(-)

diff --git a/docs/CodeDoc/Atc/Atc.Helpers.md b/docs/CodeDoc/Atc/Atc.Helpers.md
index e69c84f9..a1c42d77 100644
--- a/docs/CodeDoc/Atc/Atc.Helpers.md
+++ b/docs/CodeDoc/Atc/Atc.Helpers.md
@@ -1145,6 +1145,18 @@ Enumeration Helper: EnumHelper.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`sortDirectionType`&nbsp;&nbsp;-&nbsp;&nbsp;Type of the sort direction.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`byFlagIncludeBase`&nbsp;&nbsp;-&nbsp;&nbsp;if set to  [by flag include base].<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`byFlagIncludeCombined`&nbsp;&nbsp;-&nbsp;&nbsp;if set to  [by flag include combined].<br />
+#### ConvertEnumToReadOnlyDictionary
+>```csharp
+>IReadOnlyDictionary<T, int> ConvertEnumToReadOnlyDictionary(bool includeDefault = True, bool byFlagIncludeBase = True, bool byFlagIncludeCombined = True)
+>```
+><b>Summary:</b> Builds a read-only map from each defined enum member to its underlying `System.Int32` value.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`includeDefault`&nbsp;&nbsp;-&nbsp;&nbsp;If set to  the 0-valued member is included.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`byFlagIncludeBase`&nbsp;&nbsp;-&nbsp;&nbsp;For  enums, include the single-bit base values.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`byFlagIncludeCombined`&nbsp;&nbsp;-&nbsp;&nbsp;For  enums, include the multi-bit combined values.<br />
+>
+><b>Returns:</b> An `System.Collections.Generic.IReadOnlyDictionary`2` keyed by the typed enum value with its underlying `System.Int32` as the value. Suitable for severity-rank or threshold lookup tables that previously required a hand-rolled `Dictionary&lt;TEnum, int&gt;` literal.
 #### GetDescription
 >```csharp
 >string GetDescription(Enum enumeration)
diff --git a/docs/CodeDoc/Atc/Atc.Serialization.JsonConverters.md b/docs/CodeDoc/Atc/Atc.Serialization.JsonConverters.md
index a64a1773..8ff79688 100644
--- a/docs/CodeDoc/Atc/Atc.Serialization.JsonConverters.md
+++ b/docs/CodeDoc/Atc/Atc.Serialization.JsonConverters.md
@@ -174,7 +174,7 @@ JSON converter that enables deserialization of interface types by using the runt
 
 ## NumberToStringJsonConverter
 JSON converter that converts numeric values to string representation and vice versa.
-><b>Remarks:</b> This converter handles conversion between JSON numbers and strings, allowing numeric values in JSON to be read as strings. During deserialization, JSON numbers are converted to their string representation using the current thread's culture. During serialization, any object is converted to its string representation.
+><b>Remarks:</b> This converter handles conversion between JSON numbers and strings, allowing numeric values in JSON to be read as strings. During deserialization, JSON numbers are converted to their string representation using the invariant culture so the result is stable across machines and locales. During serialization, any object is converted to its string representation.
 
 >```csharp
 >public class NumberToStringJsonConverter : JsonConverter<object>
diff --git a/docs/CodeDoc/Atc/Atc.md b/docs/CodeDoc/Atc/Atc.md
index 80f9e88c..6f43c0b9 100644
--- a/docs/CodeDoc/Atc/Atc.md
+++ b/docs/CodeDoc/Atc/Atc.md
@@ -165,12 +165,12 @@ Represents compass directions including the four cardinal points and intermediat
 | 1024 | SouthWest | South West | SouthWest. | 
 | 2048 | WestSouthWest | West South West | WestSouthWest. | 
 | 4096 | West | West | West. | 
-| 4625 | Simple | Simple | Simple = North | East | South | West. | 
+| 4625 | Simple | Simple | Simple = North \| East \| South \| West. | 
 | 8192 | WestNorthWest | West North West | WestNorthWest. | 
 | 16384 | NorthWest | North West | NorthWest. | 
-| 22101 | Medium | Medium | Medium = North | NorthEast | East | SouthEast | South | SouthWest | West | NorthWest. | 
+| 22101 | Medium | Medium | Medium = North \| NorthEast \| East \| SouthEast \| South \| SouthWest \| West \| NorthWest. | 
 | 32768 | NorthNorthWest | North North West | NorthNorthWest. | 
-| 65535 | Advanced | Advanced | Advanced = North | NorthNorthEast | NorthEast | EastNorthEast | East | EastSouthEast | SouthEast | SouthSouthEast | South | SouthSouthWest | SouthWest | WestSouthWest | West | WestNorthWest | NorthWest | NorthNorthWest. | 
+| 65535 | Advanced | Advanced | Advanced = North \| NorthNorthEast \| NorthEast \| EastNorthEast \| East \| EastSouthEast \| SouthEast \| SouthSouthEast \| South \| SouthSouthWest \| SouthWest \| WestSouthWest \| West \| WestNorthWest \| NorthWest \| NorthNorthWest. | 
 
 
 
@@ -536,6 +536,29 @@ Extension methods for enums.
 >List<KeyValuePair<int, string>> list = Enum<DayOfWeek>.ToKeyValuePairsWithStringKey();
 >Assert.Equal(7, list.Count);
 >```
+#### ToReadOnlyDictionary
+>```csharp
+>IReadOnlyDictionary<T, int> ToReadOnlyDictionary(bool includeDefault = True, bool byFlagIncludeBase = True, bool byFlagIncludeCombined = True)
+>```
+><b>Summary:</b> Builds a read-only map from each defined enum member to its underlying `System.Int32` value. Useful for severity-rank or threshold lookup tables that previously required a hand-rolled `Dictionary&lt;TEnum, int&gt;` literal.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`includeDefault`&nbsp;&nbsp;-&nbsp;&nbsp;If set to  the 0-valued member is included.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`byFlagIncludeBase`&nbsp;&nbsp;-&nbsp;&nbsp;For  enums, include the single-bit base values.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`byFlagIncludeCombined`&nbsp;&nbsp;-&nbsp;&nbsp;For  enums, include the multi-bit combined values.<br />
+>
+><b>Returns:</b> An `System.Collections.Generic.IReadOnlyDictionary`2` keyed by the typed enum value with its underlying `System.Int32` as the value.
+>
+><b>Code usage:</b>
+>```csharp
+>IReadOnlyDictionary<DayOfWeek, int> map = Enum<DayOfWeek>.ToReadOnlyDictionary();
+>```
+>
+><b>Code example:</b>
+>```csharp
+>IReadOnlyDictionary<DayOfWeek, int> map = Enum<DayOfWeek>.ToReadOnlyDictionary();
+>Assert.Equal(0, map[DayOfWeek.Sunday]);
+>```
 #### TryGetEnumValue
 >```csharp
 >bool TryGetEnumValue(string value, bool ignoreCase, out T returnedValue)
diff --git a/docs/CodeDoc/Atc/IndexExtended.md b/docs/CodeDoc/Atc/IndexExtended.md
index a0198384..920ed856 100644
--- a/docs/CodeDoc/Atc/IndexExtended.md
+++ b/docs/CodeDoc/Atc/IndexExtended.md
@@ -43,6 +43,7 @@
      - ToDictionaryWithStringKey(DropDownFirstItemType dropDownFirstItemType = None, bool useDescriptionAttribute = True, bool includeDefault = True, SortDirectionType sortDirectionType = None, bool byFlagIncludeBase = True, bool byFlagIncludeCombined = True)
      - ToKeyValuePairs(DropDownFirstItemType dropDownFirstItemType = None, bool useDescriptionAttribute = True, bool includeDefault = True, SortDirectionType sortDirectionType = None, bool byFlagIncludeBase = True, bool byFlagIncludeCombined = True)
      - ToKeyValuePairsWithStringKey(DropDownFirstItemType dropDownFirstItemType = None, bool useDescriptionAttribute = True, bool includeDefault = True, SortDirectionType sortDirectionType = None, bool byFlagIncludeBase = True, bool byFlagIncludeCombined = True)
+     - ToReadOnlyDictionary(bool includeDefault = True, bool byFlagIncludeBase = True, bool byFlagIncludeCombined = True)
      - TryGetEnumValue(Enum value, out T returnedValue)
      - TryGetEnumValue(string value, bool ignoreCase, out T returnedValue)
      - TryParse(string value, bool ignoreCase, out T returnedValue)
@@ -4536,6 +4537,7 @@
      - ConvertEnumToArray(Type enumType, DropDownFirstItemType dropDownFirstItemType = None, bool useDescriptionAttribute = False, bool includeDefault = True, SortDirectionType sortDirectionType = None, bool byFlagIncludeBase = True, bool byFlagIncludeCombined = True)
      - ConvertEnumToDictionary(Type enumType, DropDownFirstItemType dropDownFirstItemType = None, bool useDescriptionAttribute = False, bool includeDefault = True, SortDirectionType sortDirectionType = None, bool byFlagIncludeBase = True, bool byFlagIncludeCombined = True)
      - ConvertEnumToDictionaryWithStringKey(Type enumType, DropDownFirstItemType dropDownFirstItemType = None, bool useDescriptionAttribute = False, bool includeDefault = True, SortDirectionType sortDirectionType = None, bool byFlagIncludeBase = True, bool byFlagIncludeCombined = True)
+     - ConvertEnumToReadOnlyDictionary(bool includeDefault = True, bool byFlagIncludeBase = True, bool byFlagIncludeCombined = True)
      - GetDescription(Enum enumeration)
      - GetEnumValue(string value, bool ignoreCase = True)
      - GetIndividualValues(bool includeDefault = True)
@@ -5306,6 +5308,10 @@
      - IsFormatXml(this string value)
      - IsGuid(this string value)
      - IsGuid(this string value, out Guid output)
+     - IsHostName(this string value)
+     - IsIPAddress(this string value)
+     - IsIPv4Address(this string value)
+     - IsIPv6Address(this string value)
      - IsKey(this string value)
      - IsLengthEven(this string value)
      - IsNumericOnly(this string value)
diff --git a/docs/CodeDoc/Atc/System.md b/docs/CodeDoc/Atc/System.md
index c60f9a68..8a35a31f 100644
--- a/docs/CodeDoc/Atc/System.md
+++ b/docs/CodeDoc/Atc/System.md
@@ -2813,12 +2813,14 @@ Extensions for the string class.
 >```csharp
 >string XmlDecode(this string xml)
 >```
-><b>Summary:</b> Decodes an XML string by unescaping special character entities (&amp;amp, &amp;#39;, &amp;lt;, &amp;gt;, &amp;quot).
+><b>Summary:</b> Decodes an XML string by unescaping special character entities (&amp;amp;, &amp;#39;, &amp;lt;, &amp;gt;, &amp;quot;).
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`xml`&nbsp;&nbsp;-&nbsp;&nbsp;The XML string to decode.<br />
 >
 ><b>Returns:</b> The decoded XML string with special character entities replaced.
+>
+><b>Remarks:</b> The ampersand entity (`&amp;amp;`) is decoded last so that already-decoded content is not re-interpreted, keeping `System.StringExtensions.XmlEncode(System.String)`/`System.StringExtensions.XmlDecode(System.String)` a faithful round-trip.
 #### XmlEncode
 >```csharp
 >string XmlEncode(this string xml)
@@ -3026,6 +3028,48 @@ StringHasIsExtensions.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to work on.<br />
 >
 ><b>Returns:</b> <see langword="true" /> if the specified string is a System.Guid; otherwise, <see langword="false" />.
+#### IsHostName
+>```csharp
+>bool IsHostName(this string value)
+>```
+><b>Summary:</b> Determines whether the specified value is a syntactically valid DNS host name (RFC 1123).
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to validate.<br />
+>
+><b>Returns:</b> <see langword="true" /> if the value is a valid host name; otherwise, <see langword="false" />.
+>
+><b>Remarks:</b> Accepts single-label names (e.g. `localhost`) and an optional trailing dot (e.g. `example.com.`). Each label is 1-63 ASCII alphanumeric/hyphen characters and may not start or end with a hyphen; the total length is limited to 253 characters. Underscores and raw Unicode (non-punycode IDN) are not allowed. This is a purely syntactic check and does not perform any DNS resolution.
+#### IsIPAddress
+>```csharp
+>bool IsIPAddress(this string value)
+>```
+><b>Summary:</b> Determines whether the specified value is a valid IPv4 or IPv6 address.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to validate.<br />
+>
+><b>Returns:</b> <see langword="true" /> if the value is a valid IP address; otherwise, <see langword="false" />.
+#### IsIPv4Address
+>```csharp
+>bool IsIPv4Address(this string value)
+>```
+><b>Summary:</b> Determines whether the specified value is a valid IPv4 address.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to validate.<br />
+>
+><b>Returns:</b> <see langword="true" /> if the value is a valid IPv4 address; otherwise, <see langword="false" />.
+#### IsIPv6Address
+>```csharp
+>bool IsIPv6Address(this string value)
+>```
+><b>Summary:</b> Determines whether the specified value is a valid IPv6 address.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to validate.<br />
+>
+><b>Returns:</b> <see langword="true" /> if the value is a valid IPv6 address; otherwise, <see langword="false" />.
 #### IsKey
 >```csharp
 >bool IsKey(this string value)

From 68123ff9a788d4b690237a2d19e90f3e1c78a586 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 13:39:33 +0200
Subject: [PATCH 015/100] feat(atc): extend StringHasIsExtensions with network
 validation helpers

- Widen IsEmailAddress TLD regex from {2,6} to {2,63} (the DNS label limit);
  previously rejected valid TLDs such as .photography and .international.
- Add IsHostName: RFC 1123 syntactic DNS name check (1-63 char labels, 253 max,
  optional trailing dot; no underscore/raw-Unicode).
- Add IsIPv4Address / IsIPv6Address / IsIPAddress via IPAddress.TryParse.
- Add IsPort: valid TCP/UDP port string (1-65535, no leading zeros or signs).
- Add IsMacAddress: accepts colon-, hyphen-, Cisco-dot-, and compact-hex forms.
---
 src/Atc/Extensions/StringHasIsExtensions.cs   | 32 ++++++++++++++-
 .../Extensions/StringHasIsExtensionsTests.cs  | 39 +++++++++++++++++++
 2 files changed, 70 insertions(+), 1 deletion(-)

diff --git a/src/Atc/Extensions/StringHasIsExtensions.cs b/src/Atc/Extensions/StringHasIsExtensions.cs
index dcd0c85d..ffb86e51 100644
--- a/src/Atc/Extensions/StringHasIsExtensions.cs
+++ b/src/Atc/Extensions/StringHasIsExtensions.cs
@@ -17,7 +17,8 @@ public static class StringHasIsExtensions
     private static readonly Lazy<Regex> RxNumeric = new(() => new Regex("[^0-9]", RegexOptions.Singleline | RegexOptions.Compiled, TimeSpan.FromSeconds(1)));
 #endif
 
-    private static readonly Lazy<Regex> RxEmailAddress = new(() => new Regex(@"^(([A-Za-z0-9]+_+)|([A-Za-z0-9]+\-+)|([A-Za-z0-9]+\.+)|([A-Za-z0-9]+\++))*[A-Za-z0-9]+@((\w+\-+)|(\w+\.))*\w{1,63}\.[a-zA-Z]{2,6}$", RegexOptions.Singleline | RegexOptions.Compiled, TimeSpan.FromSeconds(1)));
+    private static readonly Lazy<Regex> RxEmailAddress = new(() => new Regex(@"^(([A-Za-z0-9]+_+)|([A-Za-z0-9]+\-+)|([A-Za-z0-9]+\.+)|([A-Za-z0-9]+\++))*[A-Za-z0-9]+@((\w+\-+)|(\w+\.))*\w{1,63}\.[a-zA-Z]{2,63}$", RegexOptions.Singleline | RegexOptions.Compiled, TimeSpan.FromSeconds(1)));
+    private static readonly Lazy<Regex> RxMacAddress = new(() => new Regex(@"^(?:(?:[0-9A-Fa-f]{2}[:\-]){5}[0-9A-Fa-f]{2}|[0-9A-Fa-f]{12}|[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4})$", RegexOptions.Singleline | RegexOptions.Compiled, TimeSpan.FromSeconds(1)));
     private static readonly Lazy<Regex> RxGuid = new(() => new Regex(@"^(\{){0,1}[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}(\}){0,1}$", RegexOptions.Singleline | RegexOptions.Compiled, TimeSpan.FromSeconds(1)));
     private static readonly Lazy<Regex> RxKey = new(() => new Regex(@"^([a-zA-Z]+[a-zA-Z0-9_]+$)", RegexOptions.Singleline | RegexOptions.Compiled, TimeSpan.FromSeconds(1)));
     private static readonly Lazy<Regex> RxHtmlTags = new(() => new Regex(@"<[^>]+>", RegexOptions.Multiline | RegexOptions.Compiled, TimeSpan.FromSeconds(5)));
@@ -632,4 +633,33 @@ public static bool IsIPv6Address(this string value)
     public static bool IsIPAddress(this string value)
         => value.IsIPv4Address() ||
            value.IsIPv6Address();
+
+    /// <summary>
+    /// Determines whether the specified value is a valid TCP/UDP port number.
+    /// </summary>
+    /// <param name="value">The string to validate.</param>
+    /// <returns>
+    /// <see langword="true" /> if the value parses to an integer in the range 1–65535; otherwise, <see langword="false" />.
+    /// </returns>
+    public static bool IsPort(this string value)
+        => !string.IsNullOrEmpty(value) &&
+           int.TryParse(value, NumberStyles.None, GlobalizationConstants.EnglishCultureInfo, out var port) &&
+           port is >= 1 and <= 65535;
+
+    /// <summary>
+    /// Determines whether the specified value is a valid MAC address.
+    /// </summary>
+    /// <param name="value">The string to validate.</param>
+    /// <returns>
+    /// <see langword="true" /> if the value is a valid 48-bit MAC address; otherwise, <see langword="false" />.
+    /// </returns>
+    /// <remarks>
+    /// Accepts the three most common notations: colon-separated (<c>AA:BB:CC:DD:EE:FF</c>),
+    /// hyphen-separated (<c>AA-BB-CC-DD-EE-FF</c>), and dot-separated Cisco style (<c>AABB.CCDD.EEFF</c>),
+    /// as well as the compact twelve-hex-digit form (<c>AABBCCDDEEFF</c>).
+    /// The check is case-insensitive.
+    /// </remarks>
+    public static bool IsMacAddress(this string value)
+        => !string.IsNullOrEmpty(value) &&
+           RxMacAddress.Value.IsMatch(value);
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Extensions/StringHasIsExtensionsTests.cs b/test/Atc.Tests/Extensions/StringHasIsExtensionsTests.cs
index 5dc80b6c..25b07587 100644
--- a/test/Atc.Tests/Extensions/StringHasIsExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/StringHasIsExtensionsTests.cs
@@ -318,6 +318,9 @@ public void IsPersonCprNumber(
     [InlineData(false, "Hest")]
     [InlineData(false, "Hest@gris")]
     [InlineData(true, "Hest@gris.dk")]
+    [InlineData(true, "user@example.photography")]
+    [InlineData(true, "user@example.international")]
+    [InlineData(false, "user@example.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")]
     public void IsEmailAddress(
         bool expected,
         string input)
@@ -431,4 +434,40 @@ public void IsIPAddress(
         bool expected,
         string input)
         => Assert.Equal(expected, input.IsIPAddress());
+
+    [Theory]
+    [InlineData(true, "1")]
+    [InlineData(true, "80")]
+    [InlineData(true, "443")]
+    [InlineData(true, "8080")]
+    [InlineData(true, "65535")]
+    [InlineData(false, "0")]
+    [InlineData(false, "65536")]
+    [InlineData(false, "")]
+    [InlineData(false, "abc")]
+    [InlineData(false, "-1")]
+    [InlineData(false, "8080.5")]
+    public void IsPort(
+        bool expected,
+        string input)
+        => Assert.Equal(expected, input.IsPort());
+
+    [Theory]
+    [InlineData(true, "AA:BB:CC:DD:EE:FF")]
+    [InlineData(true, "aa:bb:cc:dd:ee:ff")]
+    [InlineData(true, "AA-BB-CC-DD-EE-FF")]
+    [InlineData(true, "aa-bb-cc-dd-ee-ff")]
+    [InlineData(true, "AABB.CCDD.EEFF")]
+    [InlineData(true, "aabb.ccdd.eeff")]
+    [InlineData(true, "AABBCCDDEEFF")]
+    [InlineData(true, "aabbccddeeff")]
+    [InlineData(false, "AA:BB:CC:DD:EE")]
+    [InlineData(false, "AA:BB:CC:DD:EE:FF:00")]
+    [InlineData(false, "GG:BB:CC:DD:EE:FF")]
+    [InlineData(false, "AA BB CC DD EE FF")]
+    [InlineData(false, "")]
+    public void IsMacAddress(
+        bool expected,
+        string input)
+        => Assert.Equal(expected, input.IsMacAddress());
 }
\ No newline at end of file

From c4d64cbc8f72f7d02de4451196f84b72a0ae8af7 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 13:39:43 +0200
Subject: [PATCH 016/100] fix(atc): harden IO and DataTable extensions

StreamExtensions:
- Guard Position = 0 with CanSeek in all three methods; non-seekable streams
  (network, GZip) no longer throw NotSupportedException.
- ToStringData: pass leaveOpen: true to StreamReader so the caller's stream
  is not disposed when the reader is done.
- CopyToStream / ToBytes: replace manual buffer loops with Stream.CopyTo.

MemoryStreamExtensions:
- Default encoding changed from UTF-16 (Encoding.Unicode) to UTF-8; the old
  default silently garbled any UTF-8 payload written without an explicit encoding.

DataTableExtensions:
- ToXPathNodeIterator: use dataTable.Copy() before adding to the temporary
  DataSet; previously the call stole the table from its owning DataSet, making
  subsequent access on the caller's DataSet throw.
---
 src/Atc/Extensions/DataTableExtensions.cs     |   2 +-
 src/Atc/Extensions/MemoryStreamExtensions.cs  |   4 +-
 src/Atc/Extensions/StreamExtensions.cs        |  38 +++---
 .../Extensions/DataTableExtensionsTests.cs    |  15 +++
 .../Extensions/MemoryStreamExtensionsTests.cs |  16 ++-
 .../Extensions/StreamExtensionsTests.cs       | 112 ++++++++++++++++++
 6 files changed, 162 insertions(+), 25 deletions(-)

diff --git a/src/Atc/Extensions/DataTableExtensions.cs b/src/Atc/Extensions/DataTableExtensions.cs
index c2f9473f..1447f783 100644
--- a/src/Atc/Extensions/DataTableExtensions.cs
+++ b/src/Atc/Extensions/DataTableExtensions.cs
@@ -166,7 +166,7 @@ where d is not null
         using (var ds = new DataSet("DataSet"))
         {
             ds.Locale = GlobalizationConstants.EnglishCultureInfo;
-            ds.Tables.Add(dataTable);
+            ds.Tables.Add(dataTable.Copy());
             xmlDocument.LoadXml(ds.GetXml());
         }
 
diff --git a/src/Atc/Extensions/MemoryStreamExtensions.cs b/src/Atc/Extensions/MemoryStreamExtensions.cs
index 65122d69..1d8bb55c 100644
--- a/src/Atc/Extensions/MemoryStreamExtensions.cs
+++ b/src/Atc/Extensions/MemoryStreamExtensions.cs
@@ -10,7 +10,7 @@ public static class MemoryStreamExtensions
     /// Converts the memory stream content to a string using the specified encoding.
     /// </summary>
     /// <param name="stream">The memory stream to convert.</param>
-    /// <param name="encoding">The encoding to use for the conversion. If <see langword="null"/>, Unicode encoding is used.</param>
+    /// <param name="encoding">The encoding to use for the conversion. Defaults to <see cref="Encoding.UTF8"/> when <see langword="null"/>.</param>
     /// <returns>A string representation of the memory stream content.</returns>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="stream"/> is <see langword="null"/>.</exception>
     public static string ToString(
@@ -22,7 +22,7 @@ public static string ToString(
             throw new ArgumentNullException(nameof(stream));
         }
 
-        encoding ??= Encoding.Unicode;
+        encoding ??= Encoding.UTF8;
 
         return encoding.GetString(stream.ToArray());
     }
diff --git a/src/Atc/Extensions/StreamExtensions.cs b/src/Atc/Extensions/StreamExtensions.cs
index a3909d84..4ac24b44 100644
--- a/src/Atc/Extensions/StreamExtensions.cs
+++ b/src/Atc/Extensions/StreamExtensions.cs
@@ -22,15 +22,13 @@ public static Stream CopyToStream(
             throw new ArgumentNullException(nameof(stream));
         }
 
-        stream.Position = 0;
-        var buffer = new byte[bufferSize];
-        int nRead;
-        var destination = new MemoryStream();
-        while ((nRead = stream.Read(buffer, 0, bufferSize)) > 0)
+        if (stream.CanSeek)
         {
-            destination.Write(buffer, 0, nRead);
+            stream.Position = 0;
         }
 
+        var destination = new MemoryStream();
+        stream.CopyTo(destination, bufferSize);
         destination.Position = 0;
         return destination;
     }
@@ -48,19 +46,14 @@ public static byte[] ToBytes(this Stream stream)
             throw new ArgumentNullException(nameof(stream));
         }
 
-        stream.Position = 0;
-        var buffer = new byte[32768];
-        using var ms = new MemoryStream();
-        while (true)
+        if (stream.CanSeek)
         {
-            var read = stream.Read(buffer, 0, buffer.Length);
-            if (read <= 0)
-            {
-                return ms.ToArray();
-            }
-
-            ms.Write(buffer, 0, read);
+            stream.Position = 0;
         }
+
+        using var ms = new MemoryStream();
+        stream.CopyTo(ms);
+        return ms.ToArray();
     }
 
     /// <summary>
@@ -76,9 +69,12 @@ public static string ToStringData(this Stream stream)
             throw new ArgumentNullException(nameof(stream));
         }
 
-        stream.Position = 0;
-        using var reader = new StreamReader(stream);
-        var val = reader.ReadToEnd();
-        return val;
+        if (stream.CanSeek)
+        {
+            stream.Position = 0;
+        }
+
+        using var reader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, bufferSize: -1, leaveOpen: true);
+        return reader.ReadToEnd();
     }
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Extensions/DataTableExtensionsTests.cs b/test/Atc.Tests/Extensions/DataTableExtensionsTests.cs
index 8df3bf23..347b29a2 100644
--- a/test/Atc.Tests/Extensions/DataTableExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/DataTableExtensionsTests.cs
@@ -121,6 +121,21 @@ public void ToXPathNodeIterator()
         actual.Should().NotBeNull();
     }
 
+    [Fact]
+    public void ToXPathNodeIterator_DoesNotStealTableFromItsDataSet()
+    {
+        // Arrange
+        using var owningDataSet = new DataSet("Owner");
+        var dt = GenerateTestTable();
+        owningDataSet.Tables.Add(dt);
+
+        // Act
+        _ = dt.ToXPathNodeIterator();
+
+        // Assert — the table must still belong to the original DataSet after the call
+        dt.DataSet.Should().BeSameAs(owningDataSet);
+    }
+
     private static DataTable GenerateTestTable()
     {
         var table = new DataTable();
diff --git a/test/Atc.Tests/Extensions/MemoryStreamExtensionsTests.cs b/test/Atc.Tests/Extensions/MemoryStreamExtensionsTests.cs
index 1b2947c6..3fcb955d 100644
--- a/test/Atc.Tests/Extensions/MemoryStreamExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/MemoryStreamExtensionsTests.cs
@@ -3,7 +3,7 @@ namespace Atc.Tests.Extensions;
 public class MemoryStreamExtensionsTests
 {
     [Fact]
-    public void ToBytes()
+    public void ToString_ExplicitUtf8()
     {
         // Arrange
         var input = "Hallo world".ToStream() as MemoryStream;
@@ -14,4 +14,18 @@ public void ToBytes()
         // Assert
         Assert.Equal("Hallo world", actual);
     }
+
+    [Fact]
+    public void ToString_DefaultEncoding_IsUtf8()
+    {
+        // Arrange — UTF-8 bytes for "Héllo"
+        var bytes = Encoding.UTF8.GetBytes("Héllo");
+        using var input = new MemoryStream(bytes);
+
+        // Act — no encoding argument; must default to UTF-8, not UTF-16
+        var actual = input.ToString();
+
+        // Assert
+        Assert.Equal("Héllo", actual);
+    }
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Extensions/StreamExtensionsTests.cs b/test/Atc.Tests/Extensions/StreamExtensionsTests.cs
index d586fe6b..6065e302 100644
--- a/test/Atc.Tests/Extensions/StreamExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/StreamExtensionsTests.cs
@@ -30,6 +30,18 @@ public void CopyToStream_BufferSize()
         Assert.Equal("Hallo world", actual.ToStringData());
     }
 
+    [Fact]
+    public void CopyToStream_NonSeekable_DoesNotThrow()
+    {
+        // Arrange — wrap a MemoryStream in a non-seekable decorator
+        var inner = "Hallo world".ToStream();
+        using var input = new NonSeekableStream(inner);
+
+        // Act & Assert
+        var actual = input.CopyToStream();
+        Assert.Equal("Hallo world", actual.ToStringData());
+    }
+
     [Fact]
     public void ToBytes()
     {
@@ -44,6 +56,21 @@ public void ToBytes()
         Assert.Equal("Hallo world", actual);
     }
 
+    [Fact]
+    public void ToBytes_NonSeekable_DoesNotThrow()
+    {
+        // Arrange
+        var inner = "Hallo world".ToStream();
+        using var input = new NonSeekableStream(inner);
+
+        // Act
+        var buffer = input.ToBytes();
+        var actual = Encoding.UTF8.GetString(buffer, 0, buffer.Length);
+
+        // Assert
+        Assert.Equal("Hallo world", actual);
+    }
+
     [Fact]
     public void ToStringData()
     {
@@ -56,4 +83,89 @@ public void ToStringData()
         // Assert
         Assert.Equal("Hallo world", actual);
     }
+
+    [Fact]
+    public void ToStringData_DoesNotDisposeCallerStream()
+    {
+        // Arrange
+        var input = "Hallo world".ToStream();
+
+        // Act
+        _ = input.ToStringData();
+
+        // Assert — stream is still usable after the call
+        Assert.True(input.CanRead);
+    }
+
+    [Fact]
+    public void ToStringData_NonSeekable_DoesNotThrow()
+    {
+        // Arrange
+        var inner = "Hallo world".ToStream();
+        using var input = new NonSeekableStream(inner);
+
+        // Act
+        var actual = input.ToStringData();
+
+        // Assert
+        Assert.Equal("Hallo world", actual);
+    }
+
+    /// <summary>
+    /// Wraps a stream and hides seek capability to simulate non-seekable sources
+    /// (e.g. network or compressed streams).
+    /// </summary>
+    private sealed class NonSeekableStream(Stream inner) : Stream
+    {
+        public override bool CanRead
+            => inner.CanRead;
+
+        public override bool CanSeek
+            => false;
+
+        public override bool CanWrite
+            => false;
+
+        public override long Length
+            => throw new NotSupportedException();
+
+        public override long Position
+        {
+            get => throw new NotSupportedException();
+            set => throw new NotSupportedException();
+        }
+
+        public override void Flush()
+            => inner.Flush();
+
+        public override int Read(
+            byte[] buffer,
+            int offset,
+            int count)
+            => inner.Read(buffer, offset, count);
+
+        public override long Seek(
+            long offset,
+            SeekOrigin origin)
+            => throw new NotSupportedException();
+
+        public override void SetLength(long value)
+            => throw new NotSupportedException();
+
+        public override void Write(
+            byte[] buffer,
+            int offset,
+            int count)
+            => throw new NotSupportedException();
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                inner.Dispose();
+            }
+
+            base.Dispose(disposing);
+        }
+    }
 }
\ No newline at end of file

From 627d599abea670923fb6abe5e1c32b13df37d72c Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 13:39:52 +0200
Subject: [PATCH 017/100] fix(atc): fix CountDecimalPoints infinite loop and
 SetHourAndMinutes offset loss

DoubleExtensions.CountDecimalPoints:
- The old loop used double.Epsilon (~4.9e-324) as its convergence check; for
  repeating decimals (e.g. 1.0/3.0) the residual never dropped that low,
  causing an infinite loop that overflowed to Infinity.
- Now capped at 15 iterations (the limit of meaningful double precision) with
  a 1e-9 absolute tolerance.

DateTimeOffsetExtensions.SetHourAndMinutes:
- Was hard-coding TimeSpan.Zero as the offset, discarding the caller's original
  timezone offset on every call.
- Now preserves dateTimeOffset.Offset.
---
 .../BaseTypes/DateTimeOffsetExtensions.cs         |  2 +-
 src/Atc/Extensions/BaseTypes/DoubleExtensions.cs  | 15 ++++++++++++---
 .../BaseTypes/DateTimeOffsetExtensionsTests.cs    |  2 +-
 .../Extensions/BaseTypes/DoubleExtensionsTests.cs |  3 ++-
 4 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs b/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs
index d4355416..02bd5e29 100644
--- a/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs
@@ -127,7 +127,7 @@ public static DateTimeOffset SetHourAndMinutes(
             hour,
             minutes,
             0,
-            TimeSpan.Zero);
+            dateTimeOffset.Offset);
 
     /// <summary>Converts the DateTimeOffset to a unix time - seconds starting from 1-1-1970.</summary>
     /// <param name="dateTimeOffset">The date time offset.</param>
diff --git a/src/Atc/Extensions/BaseTypes/DoubleExtensions.cs b/src/Atc/Extensions/BaseTypes/DoubleExtensions.cs
index 29ead502..738de7d8 100644
--- a/src/Atc/Extensions/BaseTypes/DoubleExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/DoubleExtensions.cs
@@ -186,16 +186,25 @@ public static double RoundOffPercent(this double percent)
         => RoundOff(percent, 2);
 
     /// <summary>
-    /// Counts the number of decimal places in the double value.
+    /// Counts the number of decimal places in the double value, up to a maximum of 15
+    /// (the limit of meaningful precision for a 64-bit floating-point number).
     /// </summary>
     /// <param name="value">The double value to analyze.</param>
-    /// <returns>The number of decimal places in the value.</returns>
+    /// <returns>The number of decimal places, capped at 15.</returns>
     public static int CountDecimalPoints(this double value)
     {
+        const int maxPrecision = 15;
+        const double tolerance = 1e-9;
         var precision = 0;
 
-        while (Math.Abs((value * Math.Pow(10, precision)) - Math.Round(value * Math.Pow(10, precision))) > double.Epsilon)
+        while (precision < maxPrecision)
         {
+            var scaled = value * Math.Pow(10, precision);
+            if (Math.Abs(scaled - Math.Round(scaled)) <= tolerance)
+            {
+                break;
+            }
+
             precision++;
         }
 
diff --git a/test/Atc.Tests/Extensions/BaseTypes/DateTimeOffsetExtensionsTests.cs b/test/Atc.Tests/Extensions/BaseTypes/DateTimeOffsetExtensionsTests.cs
index 27fd0983..aefaf75e 100644
--- a/test/Atc.Tests/Extensions/BaseTypes/DateTimeOffsetExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/BaseTypes/DateTimeOffsetExtensionsTests.cs
@@ -178,7 +178,7 @@ public void SetHourAndMinutes(
 
         Assert.Equal(0, actual.Second);
         Assert.Equal(0, actual.Millisecond);
-        Assert.Equal(TimeSpan.Zero, actual.Offset);
+        Assert.Equal(input.Offset, actual.Offset);
     }
 
     [Theory]
diff --git a/test/Atc.Tests/Extensions/BaseTypes/DoubleExtensionsTests.cs b/test/Atc.Tests/Extensions/BaseTypes/DoubleExtensionsTests.cs
index fe8e7518..4e5ffc34 100644
--- a/test/Atc.Tests/Extensions/BaseTypes/DoubleExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/BaseTypes/DoubleExtensionsTests.cs
@@ -318,7 +318,8 @@ public void RoundOffPercent(
     [InlineData(3, 9.999)]
     [InlineData(4, 9.9999000000)]
     [InlineData(15, 9.1234567891012345)]
-    [InlineData(30, 5.821e-27)]
+    [InlineData(0, 5.821e-27)] // value < absolute tolerance (1e-9) so it terminates immediately at 0
+    [InlineData(15, 1.0 / 3.0)] // repeating decimal; previously looped forever, now returns cap
     public void CountDecimalPoints(
         int expected,
         double input)

From 3dbc3e21f6e1058a7606dc5533a51abb90b7d3f7 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 13:40:03 +0200
Subject: [PATCH 018/100] fix(atc): restore CurrentUICulture in finally in
 CultureHelper

GetCultures, GetCountryNames, GetLanguageNames, and
GetCultureLcidsWhereCountryIsNotTranslated all temporarily switch
Thread.CurrentThread.CurrentUICulture to the requested display-language LCID.
The restore was done in a plain if-block with no try/finally, so any exception
thrown by GetCultures() or CreateKeyValueDictionaryOfIntString() left the thread
permanently on the wrong culture for the lifetime of the process.

Wrapped the work in try/finally at all four sites.
---
 src/Atc/Helpers/CultureHelper.cs | 75 ++++++++++++++++++++++----------
 1 file changed, 52 insertions(+), 23 deletions(-)

diff --git a/src/Atc/Helpers/CultureHelper.cs b/src/Atc/Helpers/CultureHelper.cs
index dbc0542f..c92e9d27 100644
--- a/src/Atc/Helpers/CultureHelper.cs
+++ b/src/Atc/Helpers/CultureHelper.cs
@@ -131,10 +131,17 @@ public static List<Culture> GetCultures(
             Thread.CurrentThread.CurrentUICulture = new CultureInfo(displayLanguageLcid);
         }
 
-        var cultures = GetCultures();
-        if (backupCultureInfo is not null)
+        List<Culture> cultures;
+        try
         {
-            Thread.CurrentThread.CurrentUICulture = backupCultureInfo;
+            cultures = GetCultures();
+        }
+        finally
+        {
+            if (backupCultureInfo is not null)
+            {
+                Thread.CurrentThread.CurrentUICulture = backupCultureInfo;
+            }
         }
 
         var data = new List<Culture>();
@@ -615,11 +622,19 @@ public static Dictionary<int, string> GetCountryNames(
             Thread.CurrentThread.CurrentUICulture = new CultureInfo(displayLanguageLcid);
         }
 
-        var cultures = GetCultures();
-        var data = DataFactory.CreateKeyValueDictionaryOfIntString(dropDownFirstItemType);
-        if (backupCultureInfo is not null)
+        List<Culture> cultures;
+        Dictionary<int, string> data;
+        try
         {
-            Thread.CurrentThread.CurrentUICulture = backupCultureInfo;
+            cultures = GetCultures();
+            data = DataFactory.CreateKeyValueDictionaryOfIntString(dropDownFirstItemType);
+        }
+        finally
+        {
+            if (backupCultureInfo is not null)
+            {
+                Thread.CurrentThread.CurrentUICulture = backupCultureInfo;
+            }
         }
 
         var countryDisplayNameCount = new Dictionary<string, int>(StringComparer.Ordinal);
@@ -750,11 +765,19 @@ public static Dictionary<int, string> GetLanguageNames(
             Thread.CurrentThread.CurrentUICulture = new CultureInfo(displayLanguageLcid);
         }
 
-        var cultures = GetCultures();
-        var data = DataFactory.CreateKeyValueDictionaryOfIntString(dropDownFirstItemType);
-        if (backupCultureInfo is not null)
+        List<Culture> cultures;
+        Dictionary<int, string> data;
+        try
         {
-            Thread.CurrentThread.CurrentUICulture = backupCultureInfo;
+            cultures = GetCultures();
+            data = DataFactory.CreateKeyValueDictionaryOfIntString(dropDownFirstItemType);
+        }
+        finally
+        {
+            if (backupCultureInfo is not null)
+            {
+                Thread.CurrentThread.CurrentUICulture = backupCultureInfo;
+            }
         }
 
         var languageDisplayNameCount = new Dictionary<string, int>(StringComparer.Ordinal);
@@ -810,19 +833,25 @@ public static List<int> GetCultureLcidsWhereCountryIsNotTranslated(
             Thread.CurrentThread.CurrentUICulture = new CultureInfo(displayLanguageLcid);
         }
 
-        var culturesFromPlatform = GetCultureInfoFromPlatform();
-        var data = (
-                from cultureInfo
-                    in culturesFromPlatform
-                let countryEnglishName = ExtractCountryEnglishName(cultureInfo)
-                let countryDisplayName = TryTranslateCountryEnglishName(countryEnglishName, useValueAsDefault: false)
-                where countryDisplayName is null
-                select cultureInfo.LCID)
-            .ToList();
-
-        if (backupCultureInfo is not null)
+        List<int> data;
+        try
         {
-            Thread.CurrentThread.CurrentUICulture = backupCultureInfo;
+            var culturesFromPlatform = GetCultureInfoFromPlatform();
+            data = (
+                    from cultureInfo
+                        in culturesFromPlatform
+                    let countryEnglishName = ExtractCountryEnglishName(cultureInfo)
+                    let countryDisplayName = TryTranslateCountryEnglishName(countryEnglishName, useValueAsDefault: false)
+                    where countryDisplayName is null
+                    select cultureInfo.LCID)
+                .ToList();
+        }
+        finally
+        {
+            if (backupCultureInfo is not null)
+            {
+                Thread.CurrentThread.CurrentUICulture = backupCultureInfo;
+            }
         }
 
         if (includeOnlyLcids is null || includeOnlyLcids.Count <= 0)

From 9149048d7d16618aed6e2230a8d00683c74616f2 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 15:32:04 +0200
Subject: [PATCH 019/100] fix(atc): implement all 21 SI prefix conversions in
 InternationalSystemOfUnitsHelper
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The nested switch had empty break stubs for 18 of 21 prefixTypeFrom cases,
causing ArithmeticException (d=NaN) for any conversion involving Kilo, Mega,
Giga, Tera, Deca, Hecto, Deci, Micro, Nano, Pico and others. Replaces the
~230-line switch with a PrefixType→exponent dictionary and Math.Pow(10,
fromExp−toExp); covers all combinations. Adds 29 test cases for previously
broken conversions.
---
 .../InternationalSystemOfUnitsHelper.cs       | 244 ++++--------------
 .../InternationalSystemOfUnitsHelperTests.cs  |  29 +++
 2 files changed, 75 insertions(+), 198 deletions(-)

diff --git a/src/Atc/Units/InternationalSystemOfUnits/InternationalSystemOfUnitsHelper.cs b/src/Atc/Units/InternationalSystemOfUnits/InternationalSystemOfUnitsHelper.cs
index 632cabc4..58c600ff 100644
--- a/src/Atc/Units/InternationalSystemOfUnits/InternationalSystemOfUnitsHelper.cs
+++ b/src/Atc/Units/InternationalSystemOfUnits/InternationalSystemOfUnitsHelper.cs
@@ -1,231 +1,79 @@
-// ReSharper disable SwitchStatementHandlesSomeKnownEnumValuesWithDefault
+// ReSharper disable CommentTypo
+// ReSharper disable IdentifierTypo
 namespace Atc.Units.InternationalSystemOfUnits;
 
 /// <summary>
 /// Provides utility methods for converting between International System of Units (SI) prefixes.
 /// </summary>
 /// <remarks>
-/// This helper class supports conversions between various SI unit prefixes such as kilo, mega, giga, milli, centi, etc.
-/// Note that not all prefix combinations are currently supported.
+/// This helper class supports conversions between all standard SI unit prefixes
+/// (Yotta through Yocto) using a table-driven exponent approach.
 /// </remarks>
 public static class InternationalSystemOfUnitsHelper
 {
+    private static readonly IReadOnlyDictionary<PrefixType, int> PrefixExponents =
+        new Dictionary<PrefixType, int>
+        {
+            { PrefixType.Yotta, 24 },
+            { PrefixType.Zetta, 21 },
+            { PrefixType.Exa, 18 },
+            { PrefixType.Peta, 15 },
+            { PrefixType.Tera, 12 },
+            { PrefixType.Giga, 9 },
+            { PrefixType.Mega, 6 },
+            { PrefixType.Kilo, 3 },
+            { PrefixType.Hecto, 2 },
+            { PrefixType.Deca, 1 },
+            { PrefixType.None, 0 },
+            { PrefixType.Deci, -1 },
+            { PrefixType.Centi, -2 },
+            { PrefixType.Milli, -3 },
+            { PrefixType.Micro, -6 },
+            { PrefixType.Nano, -9 },
+            { PrefixType.Pico, -12 },
+            { PrefixType.Femto, -15 },
+            { PrefixType.Atto, -18 },
+            { PrefixType.Zepto, -21 },
+            { PrefixType.Yocto, -24 },
+        };
+
     /// <summary>
     /// Converts a value from one SI prefix type to another with optional decimal precision.
     /// </summary>
     /// <param name="prefixTypeFrom">The source SI prefix type.</param>
     /// <param name="prefixTypeTo">The target SI prefix type.</param>
-    /// <param name="numberOfDecimals">The number of decimal places to round to (0 for no rounding).</param>
+    /// <param name="numberOfDecimals">The number of decimal places to round to. Pass 0 for no rounding.</param>
     /// <param name="value">The value to convert.</param>
-    /// <returns>The converted value in the target prefix type.</returns>
-    /// <exception cref="NotSupportedException">Thrown when the specified conversion is not supported.</exception>
+    /// <returns>The converted value in the target prefix type, optionally rounded.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">
+    /// Thrown when <paramref name="prefixTypeFrom"/> or <paramref name="prefixTypeTo"/> is not a recognised <see cref="PrefixType"/> value.
+    /// </exception>
     /// <exception cref="ArithmeticException">Thrown when the conversion results in NaN.</exception>
-    [SuppressMessage("Design", "MA0051:Method is too long", Justification = "OK.")]
-    [SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1123:Do not place regions within elements", Justification = "OK. For now.")]
     public static double Convert(
         PrefixType prefixTypeFrom,
         PrefixType prefixTypeTo,
         int numberOfDecimals,
         double value)
     {
-        var d = double.NaN;
-
-        switch (prefixTypeFrom)
+        if (!PrefixExponents.TryGetValue(prefixTypeFrom, out var fromExp))
         {
-            case PrefixType.Yotta:
-                break;
-            case PrefixType.Zetta:
-                break;
-            case PrefixType.Exa:
-                break;
-            case PrefixType.Peta:
-                break;
-            case PrefixType.Tera:
-                break;
-            case PrefixType.Giga:
-                break;
-            case PrefixType.Mega:
-                break;
-            case PrefixType.Kilo:
-                break;
-            case PrefixType.Hecto:
-                break;
-            case PrefixType.Deca:
-                break;
-            case PrefixType.None:
-                #region - None -
-                switch (prefixTypeTo)
-                {
-                    case PrefixType.Yotta:
-                    case PrefixType.Zetta:
-                    case PrefixType.Exa:
-                    case PrefixType.Peta:
-                    case PrefixType.Tera:
-                    case PrefixType.Giga:
-                    case PrefixType.Mega:
-                    case PrefixType.Kilo:
-                    case PrefixType.Hecto:
-                    case PrefixType.Deca:
-                        throw new NotSupportedException();
-                    case PrefixType.None:
-                        d = value;
-                        break;
-                    case PrefixType.Deci:
-                        d = value * 10;
-                        break;
-                    case PrefixType.Centi:
-                        d = value * 100;
-                        break;
-                    case PrefixType.Milli:
-                        d = value * 1000;
-                        break;
-                    case PrefixType.Micro:
-                    case PrefixType.Nano:
-                    case PrefixType.Pico:
-                    case PrefixType.Femto:
-                    case PrefixType.Atto:
-                    case PrefixType.Zepto:
-                    case PrefixType.Yocto:
-                        throw new NotSupportedException();
-                }
-                #endregion
-                break;
-            case PrefixType.Deci:
-                break;
-            case PrefixType.Centi:
-                #region - Centi -
-                switch (prefixTypeTo)
-                {
-                    case PrefixType.Yotta:
-                    case PrefixType.Zetta:
-                    case PrefixType.Exa:
-                    case PrefixType.Peta:
-                    case PrefixType.Tera:
-                        throw new NotSupportedException();
-                    case PrefixType.Giga:
-                        d = value / 100000000000;
-                        break;
-                    case PrefixType.Mega:
-                        d = value / 100000000;
-                        break;
-                    case PrefixType.Kilo:
-                        d = value / 100000;
-                        break;
-                    case PrefixType.Hecto:
-                        d = value / 10000;
-                        break;
-                    case PrefixType.Deca:
-                        d = value / 1000;
-                        break;
-                    case PrefixType.None:
-                        d = value / 100;
-                        break;
-                    case PrefixType.Deci:
-                        d = value / 10;
-                        break;
-                    case PrefixType.Centi:
-                        d = value;
-                        break;
-                    case PrefixType.Milli:
-                        d = value * 10;
-                        break;
-                    case PrefixType.Micro:
-                        d = value * 1000;
-                        break;
-                    case PrefixType.Nano:
-                        d = value * 1000000;
-                        break;
-                    case PrefixType.Pico:
-                        d = value * 1000000000;
-                        break;
-                    case PrefixType.Femto:
-                    case PrefixType.Atto:
-                    case PrefixType.Zepto:
-                    case PrefixType.Yocto:
-                        throw new NotSupportedException();
-                }
-                #endregion
-                break;
-            case PrefixType.Milli:
-                #region - Milli -
-                switch (prefixTypeTo)
-                {
-                    case PrefixType.Yotta:
-                    case PrefixType.Zetta:
-                    case PrefixType.Exa:
-                    case PrefixType.Peta:
-                    case PrefixType.Tera:
-                        throw new NotSupportedException();
-                    case PrefixType.Giga:
-                        d = value / 1000000000000;
-                        break;
-                    case PrefixType.Mega:
-                        d = value / 1000000000;
-                        break;
-                    case PrefixType.Kilo:
-                        d = value / 1000000;
-                        break;
-                    case PrefixType.Hecto:
-                        d = value / 100000;
-                        break;
-                    case PrefixType.Deca:
-                        d = value / 10000;
-                        break;
-                    case PrefixType.None:
-                        d = value / 1000;
-                        break;
-                    case PrefixType.Deci:
-                        d = value / 100;
-                        break;
-                    case PrefixType.Centi:
-                        d = value / 10;
-                        break;
-                    case PrefixType.Milli:
-                        d = value;
-                        break;
-                    case PrefixType.Micro:
-                        d = value * 1000;
-                        break;
-                    case PrefixType.Nano:
-                        d = value * 1000000;
-                        break;
-                    case PrefixType.Pico:
-                        d = value * 1000000000;
-                        break;
-                    case PrefixType.Femto:
-                    case PrefixType.Atto:
-                    case PrefixType.Zepto:
-                    case PrefixType.Yocto:
-                        throw new NotSupportedException();
-                }
-                #endregion
-                break;
-            case PrefixType.Micro:
-                break;
-            case PrefixType.Nano:
-                break;
-            case PrefixType.Pico:
-                break;
-            case PrefixType.Femto:
-                break;
-            case PrefixType.Atto:
-                break;
-            case PrefixType.Zepto:
-                break;
-            case PrefixType.Yocto:
-                break;
+            throw new ArgumentOutOfRangeException(nameof(prefixTypeFrom), prefixTypeFrom, "Unsupported SI prefix type.");
         }
 
-        if (double.IsNaN(d))
+        if (!PrefixExponents.TryGetValue(prefixTypeTo, out var toExp))
         {
-            throw new ArithmeticException("d IsNaN");
+            throw new ArgumentOutOfRangeException(nameof(prefixTypeTo), prefixTypeTo, "Unsupported SI prefix type.");
         }
 
-        if (numberOfDecimals != decimal.Zero)
+        var result = value * System.Math.Pow(10, fromExp - toExp);
+
+        if (double.IsNaN(result))
         {
-            d = System.Math.Round(d, numberOfDecimals);
+            throw new ArithmeticException("Conversion resulted in NaN.");
         }
 
-        return d;
+        return numberOfDecimals != 0
+            ? System.Math.Round(result, numberOfDecimals)
+            : result;
     }
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Units/InternationalSystemOfUnits/InternationalSystemOfUnitsHelperTests.cs b/test/Atc.Tests/Units/InternationalSystemOfUnits/InternationalSystemOfUnitsHelperTests.cs
index e64f0900..beeac562 100644
--- a/test/Atc.Tests/Units/InternationalSystemOfUnits/InternationalSystemOfUnitsHelperTests.cs
+++ b/test/Atc.Tests/Units/InternationalSystemOfUnits/InternationalSystemOfUnitsHelperTests.cs
@@ -5,6 +5,35 @@ public class InternationalSystemOfUnitsHelperTests
     [Theory]
     [InlineData(0.0006, PrefixType.Centi, PrefixType.Kilo, 4, 57)]
     [InlineData(0.00057, PrefixType.Centi, PrefixType.Kilo, 10, 57)]
+    [InlineData(1.0, PrefixType.Kilo, PrefixType.Kilo, 0, 1.0)]
+    [InlineData(1.0, PrefixType.None, PrefixType.None, 0, 1.0)]
+    [InlineData(1.0, PrefixType.Micro, PrefixType.Micro, 0, 1.0)]
+    [InlineData(1000.0, PrefixType.Kilo, PrefixType.None, 0, 1.0)]
+    [InlineData(1000000.0, PrefixType.Kilo, PrefixType.Milli, 0, 1.0)]
+    [InlineData(1.0, PrefixType.Kilo, PrefixType.Mega, 0, 1000.0)]
+    [InlineData(1000.0, PrefixType.Mega, PrefixType.Kilo, 0, 1.0)]
+    [InlineData(1.0, PrefixType.Mega, PrefixType.Mega, 0, 1.0)]
+    [InlineData(1000000.0, PrefixType.Mega, PrefixType.None, 0, 1.0)]
+    [InlineData(1000.0, PrefixType.Giga, PrefixType.Mega, 0, 1.0)]
+    [InlineData(1000000.0, PrefixType.Giga, PrefixType.Kilo, 0, 1.0)]
+    [InlineData(1000000000.0, PrefixType.Giga, PrefixType.None, 0, 1.0)]
+    [InlineData(1000.0, PrefixType.Tera, PrefixType.Giga, 0, 1.0)]
+    [InlineData(1000000000.0, PrefixType.Tera, PrefixType.Kilo, 0, 1.0)]
+    [InlineData(100.0, PrefixType.Hecto, PrefixType.None, 0, 1.0)]
+    [InlineData(10.0, PrefixType.Deca, PrefixType.None, 0, 1.0)]
+    [InlineData(1000.0, PrefixType.Hecto, PrefixType.Deci, 0, 1.0)]
+    [InlineData(1.0, PrefixType.Deci, PrefixType.None, 0, 10.0)]
+    [InlineData(10.0, PrefixType.Deci, PrefixType.Centi, 0, 1.0)]
+    [InlineData(1.0, PrefixType.Deci, PrefixType.Deci, 0, 1.0)]
+    [InlineData(1.0, PrefixType.Micro, PrefixType.Milli, 0, 1000.0)]
+    [InlineData(1.0, PrefixType.Nano, PrefixType.Micro, 0, 1000.0)]
+    [InlineData(1.0, PrefixType.Pico, PrefixType.Nano, 0, 1000.0)]
+    [InlineData(1.0, PrefixType.None, PrefixType.Kilo, 0, 1000.0)]
+    [InlineData(1.0, PrefixType.None, PrefixType.Mega, 0, 1000000.0)]
+    [InlineData(1.0, PrefixType.None, PrefixType.Deca, 0, 10.0)]
+    [InlineData(1.0, PrefixType.None, PrefixType.Hecto, 0, 100.0)]
+    [InlineData(1000000.0, PrefixType.None, PrefixType.Micro, 0, 1.0)]
+    [InlineData(1000000000.0, PrefixType.None, PrefixType.Nano, 0, 1.0)]
     public void Convert(
         double expected,
         PrefixType prefixTypeFrom,

From 84bb6f1e6f52f3ff1c4330586a6379752a81344b Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 15:32:11 +0200
Subject: [PATCH 020/100] fix(atc): use CurrentCulture instead of
 CurrentUICulture in ByteSizeFormatter
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ByteSizeFormatter's constructor captured Thread.CurrentThread.CurrentUICulture
.NumberFormat. The UI culture controls language (menu strings), not number/date
formatting — using it for a byte-size formatter produces wrong group/decimal
separators when the user's UI language differs from their regional format.
Changed to CultureInfo.CurrentCulture.NumberFormat. Adds a test that sets
CurrentCulture=en-US and CurrentUICulture=da-DK and verifies en-US formatting
is used.
---
 .../DigitalInformation/ByteSizeFormatter.cs   |  2 +-
 .../ByteSizeFormatterTests.cs                 | 24 +++++++++++++++++++
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/src/Atc/Units/DigitalInformation/ByteSizeFormatter.cs b/src/Atc/Units/DigitalInformation/ByteSizeFormatter.cs
index 5b556dc4..0ba09332 100644
--- a/src/Atc/Units/DigitalInformation/ByteSizeFormatter.cs
+++ b/src/Atc/Units/DigitalInformation/ByteSizeFormatter.cs
@@ -20,7 +20,7 @@ public ByteSizeFormatter()
         MaxUnit = ByteSizeUnitType.Exabyte;
         RoundingRule = ByteSizeRoundingRuleType.Closest;
         NumberOfDecimals = 0;
-        NumberFormatInfo = Thread.CurrentThread.CurrentUICulture.NumberFormat;
+        NumberFormatInfo = CultureInfo.CurrentCulture.NumberFormat;
     }
 
     /// <summary>
diff --git a/test/Atc.Tests/Units/DigitalInformation/ByteSizeFormatterTests.cs b/test/Atc.Tests/Units/DigitalInformation/ByteSizeFormatterTests.cs
index 32c6b0cd..16b53f7e 100644
--- a/test/Atc.Tests/Units/DigitalInformation/ByteSizeFormatterTests.cs
+++ b/test/Atc.Tests/Units/DigitalInformation/ByteSizeFormatterTests.cs
@@ -3,6 +3,30 @@ namespace Atc.Tests.Units.DigitalInformation;
 
 public class ByteSizeFormatterTests
 {
+    [Fact]
+    public void Constructor_UsesCurrentCulture_NotUICulture()
+    {
+        // Verify the constructor reads CurrentCulture (number/date formatting) rather
+        // than CurrentUICulture (UI language), which is the wrong culture property for
+        // a byte-size formatter.
+        var prevCulture = Thread.CurrentThread.CurrentCulture;
+        var prevUICulture = Thread.CurrentThread.CurrentUICulture;
+        try
+        {
+            Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("en-US");
+            Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo("da-DK");
+
+            var formatter = new ByteSizeFormatter();
+
+            Assert.Equal(",", formatter.NumberFormatInfo.NumberGroupSeparator);
+        }
+        finally
+        {
+            Thread.CurrentThread.CurrentCulture = prevCulture;
+            Thread.CurrentThread.CurrentUICulture = prevUICulture;
+        }
+    }
+
     [Theory]
     [InlineData("1", 1)]
     [InlineData("1", 1024L)]

From 52961fb7b9368c47da9fcc267142f2eea3fbe433 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 15:32:20 +0200
Subject: [PATCH 021/100] docs: regenerate CodeDoc for
 InternationalSystemOfUnitsHelper and IO/Stream changes

---
 .../Atc.Units.InternationalSystemOfUnits.md   |  6 ++---
 docs/CodeDoc/Atc/IndexExtended.md             |  2 ++
 docs/CodeDoc/Atc/System.IO.md                 |  2 +-
 docs/CodeDoc/Atc/System.md                    | 26 +++++++++++++++++--
 4 files changed, 30 insertions(+), 6 deletions(-)

diff --git a/docs/CodeDoc/Atc/Atc.Units.InternationalSystemOfUnits.md b/docs/CodeDoc/Atc/Atc.Units.InternationalSystemOfUnits.md
index 8a3c668c..038d6a54 100644
--- a/docs/CodeDoc/Atc/Atc.Units.InternationalSystemOfUnits.md
+++ b/docs/CodeDoc/Atc/Atc.Units.InternationalSystemOfUnits.md
@@ -33,7 +33,7 @@ Enumeration: BaseUnitType
 
 ## InternationalSystemOfUnitsHelper
 Provides utility methods for converting between International System of Units (SI) prefixes.
-><b>Remarks:</b> This helper class supports conversions between various SI unit prefixes such as kilo, mega, giga, milli, centi, etc. Note that not all prefix combinations are currently supported.
+><b>Remarks:</b> This helper class supports conversions between all standard SI unit prefixes (Yotta through Yocto) using a table-driven exponent approach.
 
 >```csharp
 >public static class InternationalSystemOfUnitsHelper
@@ -50,10 +50,10 @@ Provides utility methods for converting between International System of Units (S
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`prefixTypeFrom`&nbsp;&nbsp;-&nbsp;&nbsp;The source SI prefix type.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`prefixTypeTo`&nbsp;&nbsp;-&nbsp;&nbsp;The target SI prefix type.<br />
->&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`numberOfDecimals`&nbsp;&nbsp;-&nbsp;&nbsp;The number of decimal places to round to (0 for no rounding).<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`numberOfDecimals`&nbsp;&nbsp;-&nbsp;&nbsp;The number of decimal places to round to. Pass 0 for no rounding.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The value to convert.<br />
 >
-><b>Returns:</b> The converted value in the target prefix type.
+><b>Returns:</b> The converted value in the target prefix type, optionally rounded.
 
 <br />
 
diff --git a/docs/CodeDoc/Atc/IndexExtended.md b/docs/CodeDoc/Atc/IndexExtended.md
index 920ed856..bbc30434 100644
--- a/docs/CodeDoc/Atc/IndexExtended.md
+++ b/docs/CodeDoc/Atc/IndexExtended.md
@@ -5314,8 +5314,10 @@
      - IsIPv6Address(this string value)
      - IsKey(this string value)
      - IsLengthEven(this string value)
+     - IsMacAddress(this string value)
      - IsNumericOnly(this string value)
      - IsPersonCprNumber(this string cprNumber)
+     - IsPort(this string value)
      - IsSentence(this string value)
      - IsStringFormatParametersBalanced(this string value, bool isNumeric = True)
      - IsTrue(this string value)
diff --git a/docs/CodeDoc/Atc/System.IO.md b/docs/CodeDoc/Atc/System.IO.md
index 4dd1788e..b7e7e7b1 100644
--- a/docs/CodeDoc/Atc/System.IO.md
+++ b/docs/CodeDoc/Atc/System.IO.md
@@ -180,7 +180,7 @@ Extensions for the `System.IO.MemoryStream` class.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`stream`&nbsp;&nbsp;-&nbsp;&nbsp;The memory stream to convert.<br />
->&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`encoding`&nbsp;&nbsp;-&nbsp;&nbsp;The encoding to use for the conversion. If , Unicode encoding is used.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`encoding`&nbsp;&nbsp;-&nbsp;&nbsp;The encoding to use for the conversion. Defaults to  when .<br />
 >
 ><b>Returns:</b> A string representation of the memory stream content.
 
diff --git a/docs/CodeDoc/Atc/System.md b/docs/CodeDoc/Atc/System.md
index 8a35a31f..f1bc7004 100644
--- a/docs/CodeDoc/Atc/System.md
+++ b/docs/CodeDoc/Atc/System.md
@@ -1160,12 +1160,12 @@ Extensions for the `System.Double` class.
 >```csharp
 >int CountDecimalPoints(this double value)
 >```
-><b>Summary:</b> Counts the number of decimal places in the double value.
+><b>Summary:</b> Counts the number of decimal places in the double value, up to a maximum of 15 (the limit of meaningful precision for a 64-bit floating-point number).
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The double value to analyze.<br />
 >
-><b>Returns:</b> The number of decimal places in the value.
+><b>Returns:</b> The number of decimal places, capped at 15.
 #### CurrencyRounding
 >```csharp
 >double CurrencyRounding(this double value)
@@ -3090,6 +3090,18 @@ StringHasIsExtensions.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to work on.<br />
 >
 ><b>Returns:</b> <see langword="true" /> if the specified string length is even; otherwise, <see langword="false" />.
+#### IsMacAddress
+>```csharp
+>bool IsMacAddress(this string value)
+>```
+><b>Summary:</b> Determines whether the specified value is a valid MAC address.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to validate.<br />
+>
+><b>Returns:</b> <see langword="true" /> if the value is a valid 48-bit MAC address; otherwise, <see langword="false" />.
+>
+><b>Remarks:</b> Accepts the three most common notations: colon-separated (`AA:BB:CC:DD:EE:FF`), hyphen-separated (`AA-BB-CC-DD-EE-FF`), and dot-separated Cisco style (`AABB.CCDD.EEFF`), as well as the compact twelve-hex-digit form (`AABBCCDDEEFF`). The check is case-insensitive.
 #### IsNumericOnly
 >```csharp
 >bool IsNumericOnly(this string value)
@@ -3110,6 +3122,16 @@ StringHasIsExtensions.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cprNumber`&nbsp;&nbsp;-&nbsp;&nbsp;The CPR number.<br />
 >
 ><b>Returns:</b> <see langword="true" /> if the specified person CPR number is a valid number; otherwise, <see langword="false" />.
+#### IsPort
+>```csharp
+>bool IsPort(this string value)
+>```
+><b>Summary:</b> Determines whether the specified value is a valid TCP/UDP port number.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to validate.<br />
+>
+><b>Returns:</b> <see langword="true" /> if the value parses to an integer in the range 1–65535; otherwise, <see langword="false" />.
 #### IsSentence
 >```csharp
 >bool IsSentence(this string value)

From bc8e63ae702386c127f340f2dd10550a8ab1d2be Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 15:55:48 +0200
Subject: [PATCH 022/100] fix(atc): correct int sentinel values in MathHelper
 double Min/Max overloads

Using int.MaxValue/int.MinValue as sentinels in double[] and List<double>
overloads produced wrong results for inputs outside the int range (e.g.
3e9 or -3e9). Switched to double.MaxValue/double.MinValue. Also guards
TruncateToMaxPrecision against Substring throwing when decimalPrecision
exceeds the actual number of fractional digits.
---
 src/Atc/Helpers/MathHelper.cs             | 10 +++++-----
 test/Atc.Tests/Helpers/MathHelperTests.cs |  5 +++++
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/Atc/Helpers/MathHelper.cs b/src/Atc/Helpers/MathHelper.cs
index 833ef9c4..ad777039 100644
--- a/src/Atc/Helpers/MathHelper.cs
+++ b/src/Atc/Helpers/MathHelper.cs
@@ -240,7 +240,7 @@ public static double Min(double[] values)
         }
 
         return values
-            .Concat(new double[] { int.MaxValue })
+            .Concat(new[] { double.MaxValue })
             .Min();
     }
 
@@ -256,7 +256,7 @@ public static double Min(List<double> values)
         }
 
         return values
-            .Concat(new double[] { int.MaxValue })
+            .Concat(new[] { double.MaxValue })
             .Min();
     }
 
@@ -304,7 +304,7 @@ public static double Max(double[] values)
         }
 
         return values
-            .Concat(new double[] { int.MinValue })
+            .Concat(new[] { double.MinValue })
             .Max();
     }
 
@@ -320,7 +320,7 @@ public static double Max(List<double> values)
         }
 
         return values
-            .Concat(new double[] { int.MinValue })
+            .Concat(new[] { double.MinValue })
             .Max();
     }
 
@@ -368,7 +368,7 @@ public static double TruncateToMaxPrecision(
             return value;
         }
 
-        var decimals = sa[1].Substring(0, decimalPrecision);
+        var decimals = sa[1].Substring(0, System.Math.Min(decimalPrecision, sa[1].Length));
         return double.Parse($"{sa[0]}.{decimals}", GlobalizationConstants.EnglishCultureInfo);
     }
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Helpers/MathHelperTests.cs b/test/Atc.Tests/Helpers/MathHelperTests.cs
index d466acf2..ac227acb 100644
--- a/test/Atc.Tests/Helpers/MathHelperTests.cs
+++ b/test/Atc.Tests/Helpers/MathHelperTests.cs
@@ -287,6 +287,7 @@ public void Min_List_Int(
 
     [Theory]
     [InlineData(4.4, new[] { 8.5, 4.4, 6 })]
+    [InlineData(3000000000.0, new[] { 3000000000.0, 5000000000.0 })]
     public void Min_Array_Double(
         double expected,
         double[] input)
@@ -300,6 +301,7 @@ public void Min_Array_Double(
 
     [Theory]
     [InlineData(4.4, new[] { 8.5, 4.4, 6 })]
+    [InlineData(3000000000.0, new[] { 3000000000.0, 5000000000.0 })]
     public void Min_List_Double(
         double expected,
         double[] data)
@@ -347,6 +349,7 @@ public void Max_List_Int(
 
     [Theory]
     [InlineData(8.5, new[] { 8.5, 4.4, 6 })]
+    [InlineData(-3000000000.0, new[] { -3000000000.0, -5000000000.0 })]
     public void Max_Array_Double(
         double expected,
         double[] input)
@@ -360,6 +363,7 @@ public void Max_Array_Double(
 
     [Theory]
     [InlineData(8.5, new[] { 8.5, 4.4, 6 })]
+    [InlineData(-3000000000.0, new[] { -3000000000.0, -5000000000.0 })]
     public void Max_List_Double(
         double expected,
         double[] data)
@@ -410,6 +414,7 @@ public void IsEquals(
     [InlineData(12.12, 12.12, 1)]
     [InlineData(12.12, 12.12, 2)]
     [InlineData(12.12, 12.12, 3)]
+    [InlineData(3.141592653, 3.141592653, 15)]
     public void TruncateToMaxPrecision(
         double expected,
         double input,

From 3ebbb3ba8aab0a78ff20ed3e5b0f09894558d6a1 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 15:56:00 +0200
Subject: [PATCH 023/100] fix(atc): use UtcNow for LogItem default timestamp

DateTime.Now captures local time, which is DST-sensitive and unsuitable
for log timestamps. Switched to DateTime.UtcNow so all log entries carry
a stable, timezone-agnostic timestamp by default.
---
 src/Atc/Data/Models/LogItem.cs             |  2 +-
 test/Atc.Tests/Data/Models/LogItemTests.cs | 13 +++++++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)
 create mode 100644 test/Atc.Tests/Data/Models/LogItemTests.cs

diff --git a/src/Atc/Data/Models/LogItem.cs b/src/Atc/Data/Models/LogItem.cs
index 15949dc4..8db987d2 100644
--- a/src/Atc/Data/Models/LogItem.cs
+++ b/src/Atc/Data/Models/LogItem.cs
@@ -11,7 +11,7 @@ public class LogItem
     /// </summary>
     public LogItem()
     {
-        TimeStamp = DateTime.Now;
+        TimeStamp = DateTime.UtcNow;
         Severity = LogCategoryType.Information;
         Message = string.Empty;
     }
diff --git a/test/Atc.Tests/Data/Models/LogItemTests.cs b/test/Atc.Tests/Data/Models/LogItemTests.cs
new file mode 100644
index 00000000..dbf0dd73
--- /dev/null
+++ b/test/Atc.Tests/Data/Models/LogItemTests.cs
@@ -0,0 +1,13 @@
+namespace Atc.Tests.Data.Models;
+
+public class LogItemTests
+{
+    [Fact]
+    public void DefaultConstructor_TimeStamp_IsUtc()
+    {
+        // DateTime.Now captures local time (Kind=Local), which is DST-sensitive and
+        // unsuitable for logs. Timestamps should always be UTC.
+        var item = new LogItem();
+        Assert.Equal(DateTimeKind.Utc, item.TimeStamp.Kind);
+    }
+}
\ No newline at end of file

From f3661659979c913765e496edd49b9566b86b8be0 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 15:56:06 +0200
Subject: [PATCH 024/100] fix(atc): guard utmZoneLetter[0] access after
 IsNullOrEmpty check

utmZoneLetter[0] was dereferenced before the IsNullOrEmpty guard,
causing IndexOutOfRangeException when an empty string was passed.
Merged the index access into the guard condition so empty strings
are handled the same as null zone letters (treated as Northern
Hemisphere, no northing adjustment).
---
 .../GeoSpatial/UniversalTransverseMercatorConverter.cs |  3 +--
 .../UniversalTransverseMercatorConverterTests.cs       | 10 ++++++++++
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/Atc/Math/GeoSpatial/UniversalTransverseMercatorConverter.cs b/src/Atc/Math/GeoSpatial/UniversalTransverseMercatorConverter.cs
index d60c61b5..f858b6ed 100644
--- a/src/Atc/Math/GeoSpatial/UniversalTransverseMercatorConverter.cs
+++ b/src/Atc/Math/GeoSpatial/UniversalTransverseMercatorConverter.cs
@@ -178,8 +178,7 @@ public CartesianCoordinate ToWgs84(
             MathHelper.RadiansToDegrees(151 * WGS84_EXZENT6 / 6144 - 453 * WGS84_EXZENT8 / 12288);
 
         // Northern / Southern Hemisphere
-        var b = utmZoneLetter[0];
-        if (b < 'N' && !string.IsNullOrEmpty(utmZoneLetter))
+        if (!string.IsNullOrEmpty(utmZoneLetter) && utmZoneLetter[0] < 'N')
         {
             utmNorthing -= 10E+06;
         }
diff --git a/test/Atc.Tests/Math/GeoSpatial/UniversalTransverseMercatorConverterTests.cs b/test/Atc.Tests/Math/GeoSpatial/UniversalTransverseMercatorConverterTests.cs
index 2643028a..25c9cc18 100644
--- a/test/Atc.Tests/Math/GeoSpatial/UniversalTransverseMercatorConverterTests.cs
+++ b/test/Atc.Tests/Math/GeoSpatial/UniversalTransverseMercatorConverterTests.cs
@@ -45,6 +45,16 @@ public void ToUtm(
         actual.UtmNorthing.Should().Be(expected.UtmNorthing, $"UtmNorthing on ({description})");
     }
 
+    [Fact]
+    public void ToWgs84_EmptyZoneLetter_DoesNotThrow()
+    {
+        // utmZoneLetter[0] was accessed before the IsNullOrEmpty guard, causing
+        // IndexOutOfRangeException when an empty string was passed.
+        var converter = new UniversalTransverseMercatorConverter();
+        var exception = Record.Exception(() => converter.ToWgs84(32, string.Empty, 691875, 6098907));
+        Assert.Null(exception);
+    }
+
     [Theory]
     [ClassData(typeof(TestClassDataForGeoSpatialToWgs84))]
     public void ToWgs84(

From f816cb54ff1ea5a51dd2922cb9ad513b693ed23d Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 16:12:24 +0200
Subject: [PATCH 025/100] fix(atc): fix ByteSizeFormatter negative-size crash
 and plural suffix
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Formatter threw ArgumentOutOfRangeException for negative sizes, making
ByteSize.ToString() unusable in the debugger. Negative sizes now return
a raw "{size} B" string instead. Also fixed plural suffix for non-byte
units: "2 Kilobyte" → "2 Kilobytes" by threading displaySize through
BuildSuffixLastPart and applying the same > 1 pluralization already used
for the base Byte unit.
---
 .../Units/DigitalInformation/ByteSizeFormatter.cs    | 11 +++++++----
 .../DigitalInformation/ByteSizeFormatterTests.cs     | 12 ++++++++++++
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/src/Atc/Units/DigitalInformation/ByteSizeFormatter.cs b/src/Atc/Units/DigitalInformation/ByteSizeFormatter.cs
index 0ba09332..57fa3f9f 100644
--- a/src/Atc/Units/DigitalInformation/ByteSizeFormatter.cs
+++ b/src/Atc/Units/DigitalInformation/ByteSizeFormatter.cs
@@ -100,7 +100,7 @@ public string Format(long size)
     {
         if (size < 0)
         {
-            throw new ArgumentOutOfRangeException(nameof(size));
+            return $"{size} B";
         }
 
         var multiples = ByteSizeCalculationData.BinaryMultiples;
@@ -118,7 +118,7 @@ public string Format(long size)
             ? ByteSizeCalculationData.PrefixesFull
             : ByteSizeCalculationData.PrefixesShort;
 
-        var suffixLastPart = BuildSuffixLastPart(size, prefixIndex);
+        var suffixLastPart = BuildSuffixLastPart(size, prefixIndex, displaySize);
 
         return $"{displaySizeStr} {prefixes[prefixIndex]}{suffixLastPart}";
     }
@@ -143,7 +143,8 @@ private int GetPrefixIndex(
 
     private string BuildSuffixLastPart(
         long size,
-        int prefixIndex)
+        int prefixIndex,
+        decimal displaySize)
     {
         var text = "B";
         if (SuffixFormat == ByteSizeSuffixType.Full)
@@ -156,7 +157,9 @@ private string BuildSuffixLastPart(
             }
             else
             {
-                text = "byte";
+                text = displaySize > 1
+                    ? "bytes"
+                    : "byte";
             }
         }
 
diff --git a/test/Atc.Tests/Units/DigitalInformation/ByteSizeFormatterTests.cs b/test/Atc.Tests/Units/DigitalInformation/ByteSizeFormatterTests.cs
index 16b53f7e..e7590c50 100644
--- a/test/Atc.Tests/Units/DigitalInformation/ByteSizeFormatterTests.cs
+++ b/test/Atc.Tests/Units/DigitalInformation/ByteSizeFormatterTests.cs
@@ -27,6 +27,16 @@ public void Constructor_UsesCurrentCulture_NotUICulture()
         }
     }
 
+    [Fact]
+    public void Format_NegativeSize_DoesNotThrow()
+    {
+        // ByteSize.ToString() delegates to the formatter; a throwing formatter is a
+        // debugging hazard because the debugger shows an exception instead of the value.
+        var formatter = new ByteSizeFormatter();
+        var exception = Record.Exception(() => formatter.Format(-1));
+        Assert.Null(exception);
+    }
+
     [Theory]
     [InlineData("1", 1)]
     [InlineData("1", 1024L)]
@@ -83,7 +93,9 @@ public void Format_Suffix_Short(
     [InlineData("1 byte", 1)]
     [InlineData("2 bytes", 2)]
     [InlineData("1 Kilobyte", 1024L)]
+    [InlineData("2 Kilobytes", 2 * 1024L)]
     [InlineData("1 Megabyte", 1024L * 1024L)]
+    [InlineData("2 Megabytes", 2 * 1024L * 1024L)]
     [InlineData("1 Gigabyte", 1024L * 1024L * 1024L)]
     [InlineData("1 Terabyte", 1024L * 1024L * 1024L * 1024L)]
     [InlineData("1 Petabyte", 1024L * 1024L * 1024L * 1024L * 1024L)]

From e5b7f5a11f96dfa98f7c95638a06aa5c21c2d0a4 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 16:12:34 +0200
Subject: [PATCH 026/100] fix(atc): route SwitchCaseDefaultException and
 UnexpectedTypeException through base(message)

Both exception types used ReflectionHelper.SetPrivateField(this, "_message", ...)
to set the message after construction, relying on a private runtime field name that
can change across .NET versions. Extracted message-building into private static
helpers and routed the affected constructors through : base(BuildMessage(...)),
removing the reflection dependency entirely.
---
 .../Exceptions/SwitchCaseDefaultException.cs  | 48 +++++----
 src/Atc/Exceptions/UnexpectedTypeException.cs | 98 +++++++++----------
 test/Atc.Tests/Exceptions/ExceptionsTests.cs  | 34 +++++++
 3 files changed, 108 insertions(+), 72 deletions(-)

diff --git a/src/Atc/Exceptions/SwitchCaseDefaultException.cs b/src/Atc/Exceptions/SwitchCaseDefaultException.cs
index 6b8bf391..a768f620 100644
--- a/src/Atc/Exceptions/SwitchCaseDefaultException.cs
+++ b/src/Atc/Exceptions/SwitchCaseDefaultException.cs
@@ -36,15 +36,9 @@ public SwitchCaseDefaultException(string message)
     /// </summary>
     /// <param name="value">The unexpected enum value that was encountered.</param>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="value"/> is null.</exception>
-    [SuppressMessage("Major Code Smell", "S5766:Deserializing objects without performing data validation is security-sensitive", Justification = "OK.")]
     public SwitchCaseDefaultException(Enum value)
+        : base(BuildMessage(value))
     {
-        if (value is null)
-        {
-            throw new ArgumentNullException(nameof(value));
-        }
-
-        ReflectionHelper.SetPrivateField(this, "_message", $"Unexpected value.{Environment.NewLine}Enum name: {value.GetType().FullName}{Environment.NewLine}Enum value: {value}");
     }
 
     /// <summary>
@@ -53,22 +47,11 @@ public SwitchCaseDefaultException(Enum value)
     /// <param name="value">The unexpected enum value that was encountered.</param>
     /// <param name="message">The custom error message that describes the error.</param>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="value"/> or <paramref name="message"/> is null.</exception>
-    [SuppressMessage("Major Code Smell", "S5766:Deserializing objects without performing data validation is security-sensitive", Justification = "OK.")]
     public SwitchCaseDefaultException(
         Enum value,
         string message)
+        : base(BuildMessage(value, message))
     {
-        if (value is null)
-        {
-            throw new ArgumentNullException(nameof(value));
-        }
-
-        if (message is null)
-        {
-            throw new ArgumentNullException(nameof(message));
-        }
-
-        ReflectionHelper.SetPrivateField(this, "_message", $"{message}{Environment.NewLine}Enum name: {value.GetType().FullName}{Environment.NewLine}Enum value: {value}");
     }
 
     /// <summary>
@@ -98,4 +81,31 @@ protected SwitchCaseDefaultException(
 #endif
     {
     }
+
+    private static string BuildMessage(Enum value)
+    {
+        if (value is null)
+        {
+            throw new ArgumentNullException(nameof(value));
+        }
+
+        return $"Unexpected value.{Environment.NewLine}Enum name: {value.GetType().FullName}{Environment.NewLine}Enum value: {value}";
+    }
+
+    private static string BuildMessage(
+        Enum value,
+        string message)
+    {
+        if (value is null)
+        {
+            throw new ArgumentNullException(nameof(value));
+        }
+
+        if (message is null)
+        {
+            throw new ArgumentNullException(nameof(message));
+        }
+
+        return $"{message}{Environment.NewLine}Enum name: {value.GetType().FullName}{Environment.NewLine}Enum value: {value}";
+    }
 }
\ No newline at end of file
diff --git a/src/Atc/Exceptions/UnexpectedTypeException.cs b/src/Atc/Exceptions/UnexpectedTypeException.cs
index 91fc2191..739c461b 100644
--- a/src/Atc/Exceptions/UnexpectedTypeException.cs
+++ b/src/Atc/Exceptions/UnexpectedTypeException.cs
@@ -33,34 +33,11 @@ public UnexpectedTypeException(string message)
     /// <param name="actualType">The actual type that was encountered.</param>
     /// <param name="expectedType">The type that was expected.</param>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="actualType"/> or <paramref name="expectedType"/> is null.</exception>
-    [SuppressMessage("Major Code Smell", "S5766:Deserializing objects without performing data validation is security-sensitive", Justification = "OK.")]
     public UnexpectedTypeException(
         Type actualType,
         Type expectedType)
+        : base(BuildMessage(actualType, expectedType))
     {
-        if (actualType is null)
-        {
-            throw new ArgumentNullException(nameof(actualType));
-        }
-
-        if (expectedType is null)
-        {
-            throw new ArgumentNullException(nameof(expectedType));
-        }
-
-        var actualTypeName = actualType.FullName!;
-        if (actualType.IsSimple())
-        {
-            actualTypeName = actualType.BeautifyTypeName();
-        }
-
-        var expectedTypeName = expectedType.FullName!;
-        if (expectedType.IsSimple())
-        {
-            expectedTypeName = expectedType.BeautifyTypeName();
-        }
-
-        ReflectionHelper.SetPrivateField(this, "_message", $"Unexpected type.{Environment.NewLine}ActualType name: {actualTypeName}{Environment.NewLine}ExpectedType name: {expectedTypeName}");
     }
 
     /// <summary>
@@ -70,40 +47,12 @@ public UnexpectedTypeException(
     /// <param name="expectedType">The type that was expected.</param>
     /// <param name="message">The custom error message that describes the error.</param>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="actualType"/>, <paramref name="expectedType"/>, or <paramref name="message"/> is null.</exception>
-    [SuppressMessage("Major Code Smell", "S5766:Deserializing objects without performing data validation is security-sensitive", Justification = "OK.")]
     public UnexpectedTypeException(
         Type actualType,
         Type expectedType,
         string message)
+        : base(BuildMessage(actualType, expectedType, message))
     {
-        if (actualType is null)
-        {
-            throw new ArgumentNullException(nameof(actualType));
-        }
-
-        if (expectedType is null)
-        {
-            throw new ArgumentNullException(nameof(expectedType));
-        }
-
-        if (message is null)
-        {
-            throw new ArgumentNullException(nameof(message));
-        }
-
-        var actualTypeName = actualType.FullName!;
-        if (actualType.IsSimple())
-        {
-            actualTypeName = actualType.BeautifyTypeName();
-        }
-
-        var expectedTypeName = expectedType.FullName!;
-        if (expectedType.IsSimple())
-        {
-            expectedTypeName = expectedType.BeautifyTypeName();
-        }
-
-        ReflectionHelper.SetPrivateField(this, "_message", $"{message}{Environment.NewLine}ActualType name: {actualTypeName}{Environment.NewLine}ExpectedType name: {expectedTypeName}");
     }
 
     /// <summary>
@@ -133,4 +82,47 @@ protected UnexpectedTypeException(
 #endif
     {
     }
+
+    private static string GetTypeName(Type type)
+        => type.IsSimple() ? type.BeautifyTypeName() : type.FullName!;
+
+    private static string BuildMessage(
+        Type actualType,
+        Type expectedType)
+    {
+        if (actualType is null)
+        {
+            throw new ArgumentNullException(nameof(actualType));
+        }
+
+        if (expectedType is null)
+        {
+            throw new ArgumentNullException(nameof(expectedType));
+        }
+
+        return $"Unexpected type.{Environment.NewLine}ActualType name: {GetTypeName(actualType)}{Environment.NewLine}ExpectedType name: {GetTypeName(expectedType)}";
+    }
+
+    private static string BuildMessage(
+        Type actualType,
+        Type expectedType,
+        string message)
+    {
+        if (actualType is null)
+        {
+            throw new ArgumentNullException(nameof(actualType));
+        }
+
+        if (expectedType is null)
+        {
+            throw new ArgumentNullException(nameof(expectedType));
+        }
+
+        if (message is null)
+        {
+            throw new ArgumentNullException(nameof(message));
+        }
+
+        return $"{message}{Environment.NewLine}ActualType name: {GetTypeName(actualType)}{Environment.NewLine}ExpectedType name: {GetTypeName(expectedType)}";
+    }
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Exceptions/ExceptionsTests.cs b/test/Atc.Tests/Exceptions/ExceptionsTests.cs
index 1024e6c4..0f22ee60 100644
--- a/test/Atc.Tests/Exceptions/ExceptionsTests.cs
+++ b/test/Atc.Tests/Exceptions/ExceptionsTests.cs
@@ -413,6 +413,40 @@ public void UserNotFoundException(
         }
     }
 
+    [Fact]
+    public void SwitchCaseDefaultException_EnumValue_ContainsEnumNameAndValue()
+    {
+        var sut = new SwitchCaseDefaultException(DayOfWeek.Monday);
+        Assert.Contains("DayOfWeek", sut.Message, StringComparison.Ordinal);
+        Assert.Contains("Monday", sut.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void SwitchCaseDefaultException_EnumValueAndMessage_ContainsAllParts()
+    {
+        var sut = new SwitchCaseDefaultException(DayOfWeek.Friday, "Custom message");
+        Assert.Contains("Custom message", sut.Message, StringComparison.Ordinal);
+        Assert.Contains("DayOfWeek", sut.Message, StringComparison.Ordinal);
+        Assert.Contains("Friday", sut.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void UnexpectedTypeException_Types_ContainsTypeNames()
+    {
+        var sut = new UnexpectedTypeException(typeof(string), typeof(int));
+        Assert.Contains("string", sut.Message, StringComparison.Ordinal);
+        Assert.Contains("int", sut.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void UnexpectedTypeException_TypesAndMessage_ContainsAllParts()
+    {
+        var sut = new UnexpectedTypeException(typeof(string), typeof(int), "Custom message");
+        Assert.Contains("Custom message", sut.Message, StringComparison.Ordinal);
+        Assert.Contains("string", sut.Message, StringComparison.Ordinal);
+        Assert.Contains("int", sut.Message, StringComparison.Ordinal);
+    }
+
     [Theory]
     [InlineData("Unexpected ViewModel.", null)]
     [InlineData("MyMessage", "MyMessage")]

From bdfdea92d670a2b4209656e24040f93f9ad0c7d2 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 16:20:09 +0200
Subject: [PATCH 027/100] fix(atc): guard DynamicJson intermediate path
 segments against KeyNotFoundException

GetValueRecursive, SetValueRecursive, and RemovePathRecursive all used
the dictionary indexer (currentDict[key]) for non-terminal path segments,
throwing KeyNotFoundException when the intermediate key was absent.
Replaced with TryGetValue + pattern-match so missing intermediate segments
return null / IsSucceeded=false consistently with the existing terminal-
segment behaviour.
---
 src/Atc/Serialization/DynamicJson.cs          |  9 ++++--
 .../Serialization/DynamicJsonTests.cs         | 30 +++++++++++++++++++
 2 files changed, 36 insertions(+), 3 deletions(-)

diff --git a/src/Atc/Serialization/DynamicJson.cs b/src/Atc/Serialization/DynamicJson.cs
index 1193a66b..740799f8 100644
--- a/src/Atc/Serialization/DynamicJson.cs
+++ b/src/Atc/Serialization/DynamicJson.cs
@@ -212,7 +212,8 @@ private static IReadOnlyList<string> GetSegmentsFromPath(string path)
                 : null;
         }
 
-        if (currentDict[key] is Dictionary<string, object?> nestedDict)
+        if (currentDict.TryGetValue(key, out var nestedValue) &&
+            nestedValue is Dictionary<string, object?> nestedDict)
         {
             return GetValueRecursive(
                 nestedDict,
@@ -258,7 +259,8 @@ private static (bool IsSucceeded, string? ErrorMessage) SetValueRecursive(
             currentDict.Add(key, new Dictionary<string, object?>(StringComparer.Ordinal));
         }
 
-        if (currentDict[key] is Dictionary<string, object?> nestedDict)
+        if (currentDict.TryGetValue(key, out var nestedValue) &&
+            nestedValue is Dictionary<string, object?> nestedDict)
         {
             return SetValueRecursive(
                 nestedDict,
@@ -417,7 +419,8 @@ private static (bool IsSucceeded, string? ErrorMessage) RemovePathRecursive(
                 ErrorMessage: null);
         }
 
-        if (currentDict[key] is Dictionary<string, object?> nestedDict)
+        if (currentDict.TryGetValue(key, out var nestedValue) &&
+            nestedValue is Dictionary<string, object?> nestedDict)
         {
             return RemovePathRecursive(
                 nestedDict,
diff --git a/test/Atc.Tests/Serialization/DynamicJsonTests.cs b/test/Atc.Tests/Serialization/DynamicJsonTests.cs
index 83c96575..523341a9 100644
--- a/test/Atc.Tests/Serialization/DynamicJsonTests.cs
+++ b/test/Atc.Tests/Serialization/DynamicJsonTests.cs
@@ -66,6 +66,16 @@ public void ReturnsNullForNoneExistentPath()
         Assert.Null(actual);
     }
 
+    [Fact]
+    public void GetValue_MissingIntermediateSegment_ReturnsNull()
+    {
+        // Accessing a path whose intermediate key does not exist should return null,
+        // not throw KeyNotFoundException from the dictionary indexer.
+        var dynamicJson = new DynamicJson(JsonPropertyValue);
+        var actual = dynamicJson.GetValue("missing.nested");
+        Assert.Null(actual);
+    }
+
     [Fact]
     public void CanSetValueAtPath()
     {
@@ -151,6 +161,26 @@ public void CannotRemoveNonexistentPath()
         Assert.Equal("The path does not exist: nonexistentProperty", result.ErrorMessage);
     }
 
+    [Fact]
+    public void SetValue_MissingIntermediateSegment_ReturnsFailure()
+    {
+        // When createKeyIfNotExist is false and an intermediate key is absent,
+        // SetValue should return failure rather than throwing KeyNotFoundException.
+        var dynamicJson = new DynamicJson(JsonPropertyValue);
+        var result = dynamicJson.SetValue("missing.nested", "value", createKeyIfNotExist: false);
+        Assert.False(result.IsSucceeded);
+    }
+
+    [Fact]
+    public void RemovePath_MissingIntermediateSegment_ReturnsFailure()
+    {
+        // Removing a path whose intermediate key does not exist should return
+        // failure rather than throwing KeyNotFoundException.
+        var dynamicJson = new DynamicJson(JsonPropertyValue);
+        var result = dynamicJson.RemovePath("missing.nested");
+        Assert.False(result.IsSucceeded);
+    }
+
     [Fact]
     public void ThrowsOnNullPath()
     {

From dab2f1b96258e2b3c45b7a690fa4cf33335d3bf2 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 17:58:19 +0200
Subject: [PATCH 028/100] fix(atc): deserialize Version from public properties
 instead of private backing fields

VersionJsonConverter was reading _Major/_Minor/_Build/_Revision (private runtime
fields) when the JSON was in object form. STJ serializes Version using the public
Major/Minor/Build/Revision properties, so round-trips via object format silently
returned new Version(). Updated property names and adjusted remarks doc and test.
---
 .../Atc/Atc.Serialization.JsonConverters.md   |  2 +-
 src/Atc/Math/Geometry/TriangleHelper.cs       | 18 ++++++++++---
 .../JsonConverters/VersionJsonConverter.cs    | 13 +++++-----
 .../Math/Geometry/TriangleHelperTests.cs      | 26 +++++++++++++++++++
 .../VersionJsonConverterTests.cs              | 11 ++++----
 5 files changed, 55 insertions(+), 15 deletions(-)

diff --git a/docs/CodeDoc/Atc/Atc.Serialization.JsonConverters.md b/docs/CodeDoc/Atc/Atc.Serialization.JsonConverters.md
index 8ff79688..bd90233b 100644
--- a/docs/CodeDoc/Atc/Atc.Serialization.JsonConverters.md
+++ b/docs/CodeDoc/Atc/Atc.Serialization.JsonConverters.md
@@ -304,7 +304,7 @@ JSON converter that serializes `System.Uri` objects to and from their absolute U
 
 ## VersionJsonConverter
 JSON converter that serializes `System.Version` objects to and from their string representation.
-><b>Remarks:</b> This converter supports reading `System.Version` from both string format (e.g., "1.2.3.4") and object format with internal fields (_Major, _Minor, _Build, _Revision). During writing, `System.Version` is always serialized as a string. If parsing fails, a default empty `System.Version` is returned.
+><b>Remarks:</b> This converter supports reading `System.Version` from both string format (e.g., "1.2.3.4") and object format with public properties (Major, Minor, Build, Revision) as produced by `System.Text.Json.JsonSerializer`. During writing, `System.Version` is always serialized as a string. If parsing fails, a default empty `System.Version` is returned.
 
 >```csharp
 >public class VersionJsonConverter : JsonConverter<Version>
diff --git a/src/Atc/Math/Geometry/TriangleHelper.cs b/src/Atc/Math/Geometry/TriangleHelper.cs
index d20c9e71..e211a49f 100644
--- a/src/Atc/Math/Geometry/TriangleHelper.cs
+++ b/src/Atc/Math/Geometry/TriangleHelper.cs
@@ -50,7 +50,7 @@ public static bool IsSumOfTheAnglesATriangle(
         double angleA,
         double angleB,
         double angleC)
-        => (angleA + angleB + angleC).IsEqual(180);
+        => System.Math.Abs(angleA + angleB + angleC - 180.0) < 1e-9;
 
     /// <summary>
     /// Calculate the unspecified side (unspecified with NULL).
@@ -73,13 +73,25 @@ public static double Pythagorean(
         if (sideA is null && sideB is not null && sideC is not null)
         {
             // Calc sideA
-            return System.Math.Sqrt(System.Math.Pow((double)sideC, 2) - System.Math.Pow((double)sideB, 2));
+            var radicand = System.Math.Pow((double)sideC, 2) - System.Math.Pow((double)sideB, 2);
+            if (radicand < 0)
+            {
+                throw new ArithmeticException("The given side lengths do not form a valid right triangle.");
+            }
+
+            return System.Math.Sqrt(radicand);
         }
 
         if (sideA is not null && sideB is null && sideC is not null)
         {
             // Calc sideB
-            return System.Math.Sqrt(System.Math.Pow((double)sideC, 2) - System.Math.Pow((double)sideA, 2));
+            var radicand = System.Math.Pow((double)sideC, 2) - System.Math.Pow((double)sideA, 2);
+            if (radicand < 0)
+            {
+                throw new ArithmeticException("The given side lengths do not form a valid right triangle.");
+            }
+
+            return System.Math.Sqrt(radicand);
         }
 
         if (sideA is not null && sideB is not null && sideC is null)
diff --git a/src/Atc/Serialization/JsonConverters/VersionJsonConverter.cs b/src/Atc/Serialization/JsonConverters/VersionJsonConverter.cs
index cc26798c..13301a3e 100644
--- a/src/Atc/Serialization/JsonConverters/VersionJsonConverter.cs
+++ b/src/Atc/Serialization/JsonConverters/VersionJsonConverter.cs
@@ -6,8 +6,9 @@ namespace Atc.Serialization.JsonConverters;
 /// </summary>
 /// <remarks>
 /// This converter supports reading <see cref="Version"/> from both string format (e.g., "1.2.3.4") and object format
-/// with internal fields (_Major, _Minor, _Build, _Revision). During writing, <see cref="Version"/> is always serialized
-/// as a string. If parsing fails, a default empty <see cref="Version"/> is returned.
+/// with public properties (Major, Minor, Build, Revision) as produced by <see cref="System.Text.Json.JsonSerializer"/>.
+/// During writing, <see cref="Version"/> is always serialized as a string. If parsing fails, a default empty
+/// <see cref="Version"/> is returned.
 /// </remarks>
 public sealed class VersionJsonConverter : JsonConverter<Version>
 {
@@ -27,19 +28,19 @@ public override Version Read(
                 {
                     var major = jsonDocument
                         .RootElement
-                        .GetProperty("_Major")
+                        .GetProperty("Major")
                         .GetInt32();
                     var minor = jsonDocument
                         .RootElement
-                        .GetProperty("_Minor")
+                        .GetProperty("Minor")
                         .GetInt32();
                     var build = jsonDocument
                         .RootElement
-                        .GetProperty("_Build")
+                        .GetProperty("Build")
                         .GetInt32();
                     var revision = jsonDocument
                         .RootElement
-                        .GetProperty("_Revision")
+                        .GetProperty("Revision")
                         .GetInt32();
                     return new Version(major, minor, build, revision);
                 }
diff --git a/test/Atc.Tests/Math/Geometry/TriangleHelperTests.cs b/test/Atc.Tests/Math/Geometry/TriangleHelperTests.cs
index fcdbd344..800cb7f5 100644
--- a/test/Atc.Tests/Math/Geometry/TriangleHelperTests.cs
+++ b/test/Atc.Tests/Math/Geometry/TriangleHelperTests.cs
@@ -46,4 +46,30 @@ public void Pythagorean()
         expected = 24.494897427831781;
         Assert.Equal(expected, TriangleHelper.Pythagorean(null, sideB, sideC));
     }
+
+    [Theory]
+    [InlineData(null, 10.0, 5.0)]
+    [InlineData(10.0, null, 5.0)]
+    public void Pythagorean_ImpossibleSides_ThrowsArithmeticException(
+        double? sideA,
+        double? sideB,
+        double? sideC)
+    {
+        // When a leg is longer than the hypotenuse the radicand is negative.
+        // Math.Sqrt(-x) returns NaN rather than throwing; we expect ArithmeticException.
+        Assert.Throws<ArithmeticException>(() => TriangleHelper.Pythagorean(sideA, sideB, sideC));
+    }
+
+    [Fact]
+    public void IsSumOfTheAnglesATriangle_AnglesWithSmallFloatingPointExcess_ReturnsTrue()
+    {
+        // Each angle is 60° + 1e-10, so their sum is 180° + 3e-10.
+        // This is well within any sensible geometric tolerance (1e-9) but far exceeds
+        // double.Epsilon (~4.9e-324), causing the current IsEqual check to incorrectly
+        // reject a valid triangle.
+        const double a = 60.0 + 1e-10;
+        const double b = 60.0 + 1e-10;
+        const double c = 60.0 + 1e-10;
+        Assert.True(TriangleHelper.IsSumOfTheAnglesATriangle(a, b, c));
+    }
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Serialization/JsonConverters/VersionJsonConverterTests.cs b/test/Atc.Tests/Serialization/JsonConverters/VersionJsonConverterTests.cs
index 8cc06ffe..7d936002 100644
--- a/test/Atc.Tests/Serialization/JsonConverters/VersionJsonConverterTests.cs
+++ b/test/Atc.Tests/Serialization/JsonConverters/VersionJsonConverterTests.cs
@@ -5,16 +5,17 @@ public sealed class VersionJsonConverterTests
     [Fact]
     public void Read_ShouldDeserializeVersionFromObject()
     {
-        // Arrange
+        // STJ serializes Version using its public properties (Major, Minor, Build, Revision),
+        // not the private backing fields (_Major etc.) that the old implementation read.
         var jsonSerializerOptions = JsonSerializerOptionsFactory.Create();
         var jsonConverter = new VersionJsonConverter();
 
         const string json = """
                             {
-                                "_Major": 1,
-                                "_Minor": 2,
-                                "_Build": 3,
-                                "_Revision": 4
+                                "Major": 1,
+                                "Minor": 2,
+                                "Build": 3,
+                                "Revision": 4
                             }
                             """;
 

From 3ae138c91b2e898d71a627f48eb027b07d1c8df7 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 18:11:32 +0200
Subject: [PATCH 029/100] fix(atc): use NumberStyles.None for SemVer numeric
 identifier parsing

NumberStyles.Any caused int.TryParse to interpret exponent-notation strings
like "1E3" as the integer 1000. This had two effects: (1) SemanticVersion's
strict-mode validator rejected valid alphanumeric identifiers because
Clean() returned "1000" != "1E3", throwing ArgumentException; (2) pre-release
comparison classified "1E3" as numeric, producing wrong precedence ordering
vs pure-numeric identifiers. Switching to NumberStyles.None correctly treats
any identifier containing non-digit characters as alphanumeric.
---
 src/Atc/Data/SemVer/Identifier.cs             |  2 +-
 .../Data/SemVer/SemanticVersionTests.cs       | 24 +++++++++++++++++++
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/src/Atc/Data/SemVer/Identifier.cs b/src/Atc/Data/SemVer/Identifier.cs
index 0ce1135b..92edc9aa 100644
--- a/src/Atc/Data/SemVer/Identifier.cs
+++ b/src/Atc/Data/SemVer/Identifier.cs
@@ -43,7 +43,7 @@ private void SetNumeric()
     {
         if (!int.TryParse(
                 Value,
-                NumberStyles.Any,
+                NumberStyles.None,
                 GlobalizationConstants.EnglishCultureInfo,
                 out var x))
         {
diff --git a/test/Atc.Tests/Data/SemVer/SemanticVersionTests.cs b/test/Atc.Tests/Data/SemVer/SemanticVersionTests.cs
index ec4d9076..815d3248 100644
--- a/test/Atc.Tests/Data/SemVer/SemanticVersionTests.cs
+++ b/test/Atc.Tests/Data/SemVer/SemanticVersionTests.cs
@@ -88,6 +88,30 @@ public void Constructor_LooseMode(
         }
     }
 
+    [Theory]
+    [InlineData("1.0.0-1E3")]
+    [InlineData("1.0.0-2e5")]
+    public void Constructor_AlphanumericExponentStyleIdentifier_DoesNotThrow(
+        string version)
+    {
+        // "1E3" and "2e5" contain letters, making them alphanumeric identifiers per SemVer spec.
+        // NumberStyles.Any causes int.TryParse("1E3") to return 1000, so Clean() returns "1000"
+        // which differs from "1E3", and the strict-mode validator incorrectly rejects a valid version.
+        var exception = Record.Exception(() => new SemanticVersion(version));
+        Assert.Null(exception);
+    }
+
+    [Fact]
+    public void CompareTo_AlphanumericExponentVsNumericPreRelease_AlphanumericSortsLater()
+    {
+        // Per SemVer spec §11.4.1: numeric identifiers always have lower precedence than
+        // alphanumeric identifiers. "1E3" is alphanumeric (contains 'E'), so 1.0.0-1E3 > 1.0.0-1001.
+        // NumberStyles.Any incorrectly classifies "1E3" as numeric (1000), giving the wrong order.
+        var numeric = new SemanticVersion("1.0.0-1001", looseMode: true);
+        var alphanumeric = new SemanticVersion("1.0.0-1E3", looseMode: true);
+        Assert.True(alphanumeric.CompareTo(numeric) > 0);
+    }
+
     [Theory]
     [InlineData("1.2.3")]
     [InlineData("1.2.3-beta01")]

From b0335085dab71fd6592fb83f34ea2ee859cac615 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 18:24:46 +0200
Subject: [PATCH 030/100] fix(atc-rest-extended): remove unused TelemetryClient
 from ConfigureApiVersioningOptions

TelemetryClient was injected via constructor but never referenced in Configure(),
causing DI failure for consumers without Application Insights registered.
Replaced with a parameterless constructor.
---
 docs/CodeDoc/Atc.Rest/Atc.Rest.Options.md     |  2 +-
 src/Atc.Rest.Extended/GlobalUsings.cs         |  1 -
 .../Options/ConfigureApiVersioningOptions.cs  |  6 +----
 .../Options/ConfigureApiBehaviorOptions.cs    | 15 ++++++++---
 test/Atc.Rest.Extended.Tests/GlobalUsings.cs  |  2 ++
 .../ConfigureApiVersioningOptionsTests.cs     | 18 +++++++++++++
 .../ConfigureApiBehaviorOptionsTests.cs       | 25 +++++++++++++++++++
 7 files changed, 58 insertions(+), 11 deletions(-)
 create mode 100644 test/Atc.Rest.Extended.Tests/Options/ConfigureApiVersioningOptionsTests.cs
 create mode 100644 test/Atc.Rest.Tests/Options/ConfigureApiBehaviorOptionsTests.cs

diff --git a/docs/CodeDoc/Atc.Rest/Atc.Rest.Options.md b/docs/CodeDoc/Atc.Rest/Atc.Rest.Options.md
index 4cbc59ff..ac07a0a8 100644
--- a/docs/CodeDoc/Atc.Rest/Atc.Rest.Options.md
+++ b/docs/CodeDoc/Atc.Rest/Atc.Rest.Options.md
@@ -129,7 +129,7 @@ Copy and fill out the AzureAd section into the project User Secrets.
 
 ## ConfigureApiBehaviorOptions
 Configures ASP.NET Core API behavior options for model validation and error responses.
-><b>Remarks:</b> This class customizes the default API behavior to: <list type="bullet"><item>Suppress automatic binding source inference for better control</item><item>Return ValidationProblemDetails for invalid model state</item><item>Include correlation ID in validation error responses</item><item>Track validation errors in Application Insights telemetry</item></list>
+><b>Remarks:</b> This class customizes the default API behavior to: <list type="bullet"><item>Suppress automatic binding source inference for better control</item><item>Return ValidationProblemDetails for invalid model state</item><item>Include correlation ID in validation error responses</item><item>Track validation errors in Application Insights telemetry when a `Microsoft.ApplicationInsights.TelemetryClient` is provided</item></list>
 
 >```csharp
 >public class ConfigureApiBehaviorOptions : IConfigureOptions<ApiBehaviorOptions>
diff --git a/src/Atc.Rest.Extended/GlobalUsings.cs b/src/Atc.Rest.Extended/GlobalUsings.cs
index 9bac7546..34825d2d 100644
--- a/src/Atc.Rest.Extended/GlobalUsings.cs
+++ b/src/Atc.Rest.Extended/GlobalUsings.cs
@@ -16,7 +16,6 @@
 global using FluentValidation;
 global using FluentValidation.AspNetCore;
 
-global using Microsoft.ApplicationInsights;
 global using Microsoft.AspNetCore.Authentication;
 global using Microsoft.AspNetCore.Authentication.JwtBearer;
 global using Microsoft.AspNetCore.Authorization;
diff --git a/src/Atc.Rest.Extended/Options/ConfigureApiVersioningOptions.cs b/src/Atc.Rest.Extended/Options/ConfigureApiVersioningOptions.cs
index c5355941..17b150f1 100644
--- a/src/Atc.Rest.Extended/Options/ConfigureApiVersioningOptions.cs
+++ b/src/Atc.Rest.Extended/Options/ConfigureApiVersioningOptions.cs
@@ -6,15 +6,11 @@ namespace Atc.Rest.Extended.Options;
 /// </summary>
 public class ConfigureApiVersioningOptions : IConfigureOptions<ApiVersioningOptions>
 {
-    private readonly TelemetryClient telemetry;
-
     /// <summary>
     /// Initializes a new instance of the <see cref="ConfigureApiVersioningOptions"/> class.
     /// </summary>
-    /// <param name="telemetry">The Application Insights telemetry client.</param>
-    public ConfigureApiVersioningOptions(TelemetryClient telemetry)
+    public ConfigureApiVersioningOptions()
     {
-        this.telemetry = telemetry;
     }
 
     /// <summary>
diff --git a/src/Atc.Rest/Options/ConfigureApiBehaviorOptions.cs b/src/Atc.Rest/Options/ConfigureApiBehaviorOptions.cs
index 027b77ce..464f6cf9 100644
--- a/src/Atc.Rest/Options/ConfigureApiBehaviorOptions.cs
+++ b/src/Atc.Rest/Options/ConfigureApiBehaviorOptions.cs
@@ -9,17 +9,24 @@ namespace Atc.Rest.Options;
 /// <item>Suppress automatic binding source inference for better control</item>
 /// <item>Return ValidationProblemDetails for invalid model state</item>
 /// <item>Include correlation ID in validation error responses</item>
-/// <item>Track validation errors in Application Insights telemetry</item>
+/// <item>Track validation errors in Application Insights telemetry when a <see cref="TelemetryClient"/> is provided</item>
 /// </list>
 /// </remarks>
 public class ConfigureApiBehaviorOptions : IConfigureOptions<ApiBehaviorOptions>
 {
-    private readonly TelemetryClient telemetry;
+    private readonly TelemetryClient? telemetry;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ConfigureApiBehaviorOptions"/> class without telemetry.
+    /// </summary>
+    public ConfigureApiBehaviorOptions()
+    {
+    }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ConfigureApiBehaviorOptions"/> class.
     /// </summary>
-    /// <param name="telemetry">The Application Insights telemetry client.</param>
+    /// <param name="telemetry">The Application Insights telemetry client used to track validation errors.</param>
     public ConfigureApiBehaviorOptions(TelemetryClient telemetry)
     {
         this.telemetry = telemetry;
@@ -44,7 +51,7 @@ public void Configure(ApiBehaviorOptions options)
                 },
             };
 
-            telemetry.TrackTrace(
+            telemetry?.TrackTrace(
                 "BadRequest",
                 new Dictionary<string, string>(StringComparer.Ordinal)
                 {
diff --git a/test/Atc.Rest.Extended.Tests/GlobalUsings.cs b/test/Atc.Rest.Extended.Tests/GlobalUsings.cs
index 2adc1a48..60d222e6 100644
--- a/test/Atc.Rest.Extended.Tests/GlobalUsings.cs
+++ b/test/Atc.Rest.Extended.Tests/GlobalUsings.cs
@@ -1,6 +1,8 @@
 global using System.Diagnostics.CodeAnalysis;
 global using System.Reflection;
 
+global using Asp.Versioning;
+
 global using Atc.CodeDocumentation.Markdown;
 global using Atc.Rest.Extended.Extensions;
 global using Atc.Rest.Extended.Filters;
diff --git a/test/Atc.Rest.Extended.Tests/Options/ConfigureApiVersioningOptionsTests.cs b/test/Atc.Rest.Extended.Tests/Options/ConfigureApiVersioningOptionsTests.cs
new file mode 100644
index 00000000..c455a348
--- /dev/null
+++ b/test/Atc.Rest.Extended.Tests/Options/ConfigureApiVersioningOptionsTests.cs
@@ -0,0 +1,18 @@
+namespace Atc.Rest.Extended.Tests.Options;
+
+public class ConfigureApiVersioningOptionsTests
+{
+    [Fact]
+    public void Constructor_WithoutTelemetry_DoesNotThrow()
+    {
+        // TelemetryClient was injected but never used, causing DI failure for consumers
+        // without App Insights. ConfigureApiVersioningOptions must be instantiable without it.
+        var exception = Record.Exception(() => new ConfigureApiVersioningOptions());
+        Assert.Null(exception);
+    }
+
+    [Fact]
+    public void Implements_IConfigureOptions_ApiVersioningOptions()
+        => typeof(ConfigureApiVersioningOptions)
+            .Should().Implement<IConfigureOptions<ApiVersioningOptions>>();
+}
\ No newline at end of file
diff --git a/test/Atc.Rest.Tests/Options/ConfigureApiBehaviorOptionsTests.cs b/test/Atc.Rest.Tests/Options/ConfigureApiBehaviorOptionsTests.cs
new file mode 100644
index 00000000..05184999
--- /dev/null
+++ b/test/Atc.Rest.Tests/Options/ConfigureApiBehaviorOptionsTests.cs
@@ -0,0 +1,25 @@
+namespace Atc.Rest.Tests.Options;
+
+public class ConfigureApiBehaviorOptionsTests
+{
+    [Fact]
+    public void Constructor_WithoutTelemetry_DoesNotThrow()
+    {
+        // TelemetryClient is optional; when App Insights is not registered, the class
+        // must still be constructable so DI doesn't fail on startup.
+        var exception = Record.Exception(() => new ConfigureApiBehaviorOptions());
+        Assert.Null(exception);
+    }
+
+    [Fact]
+    public void Configure_WithoutTelemetry_SetsExpectedBehaviorOptions()
+    {
+        var sut = new ConfigureApiBehaviorOptions();
+        var options = new ApiBehaviorOptions();
+
+        sut.Configure(options);
+
+        Assert.True(options.SuppressInferBindingSourcesForParameters);
+        Assert.NotNull(options.InvalidModelStateResponseFactory);
+    }
+}
\ No newline at end of file

From b9c4c4740dc045413bc08582a9368656c00816dc Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 18:40:32 +0200
Subject: [PATCH 031/100] fix(atc): use Ordinal comparison in IsInheritedFrom
 generic branch

The generic path compared stripped type full-names with OrdinalIgnoreCase,
which could produce false positives for types whose names differ only by case.
Type names in .NET are case-sensitive so Ordinal is the correct comparison.
Added test cases that exercise the generic branch via ObservableCollection<T>.
---
 src/Atc/Extensions/ProcessExtensions.cs          |  9 +++------
 src/Atc/Extensions/TaskExtensions.cs             |  5 ++++-
 src/Atc/Extensions/TypeExtensions.cs             |  2 +-
 test/Atc.Tests/Extensions/TaskExtensionsTests.cs | 16 ++++++++++++++++
 test/Atc.Tests/Extensions/TypeExtensionsTests.cs |  2 ++
 5 files changed, 26 insertions(+), 8 deletions(-)

diff --git a/src/Atc/Extensions/ProcessExtensions.cs b/src/Atc/Extensions/ProcessExtensions.cs
index a2beb924..ea4fba95 100644
--- a/src/Atc/Extensions/ProcessExtensions.cs
+++ b/src/Atc/Extensions/ProcessExtensions.cs
@@ -204,18 +204,15 @@ private static (int ExitCode, string Output) RunProcessAndReadOutput(
             return (-1, string.Empty);
         }
 
+        var outputTask = Task.Run(() => process.StandardOutput.ReadToEnd());
         if (process.WaitForExit((int)timeout.TotalMilliseconds))
         {
-            return (
-                process.ExitCode,
-                process.StandardOutput.ReadToEnd());
+            return (process.ExitCode, outputTask.GetAwaiter().GetResult());
         }
 
         process.Kill();
 
-        return (
-            process.ExitCode,
-            string.Empty);
+        return (process.ExitCode, string.Empty);
     }
 
     private static void RunProcessAndIgnoreOutput(
diff --git a/src/Atc/Extensions/TaskExtensions.cs b/src/Atc/Extensions/TaskExtensions.cs
index c4cd2d86..0b5e0ec8 100644
--- a/src/Atc/Extensions/TaskExtensions.cs
+++ b/src/Atc/Extensions/TaskExtensions.cs
@@ -65,7 +65,10 @@ public static void StartAndWaitAllThrottled(
         foreach (var task in tasks)
         {
             // Increment the number of tasks currently running and wait if too many are running.
-            throttler.Wait(timeoutInMilliseconds, cancellationToken);
+            if (!throttler.Wait(timeoutInMilliseconds, cancellationToken))
+            {
+                throw new TimeoutException($"Timed out after {timeoutInMilliseconds} ms waiting for a task slot to become available.");
+            }
 
             cancellationToken.ThrowIfCancellationRequested();
             task.Start();
diff --git a/src/Atc/Extensions/TypeExtensions.cs b/src/Atc/Extensions/TypeExtensions.cs
index fe2d087f..ea6e0513 100644
--- a/src/Atc/Extensions/TypeExtensions.cs
+++ b/src/Atc/Extensions/TypeExtensions.cs
@@ -156,7 +156,7 @@ public static bool IsInheritedFrom(
             inheritTypeFullName = inheritTypeFullName.Substring(0, inheritTypeFullName.IndexOf(GenericSign, StringComparison.Ordinal));
         }
 
-        return string.Equals(baseTypeFullName, inheritTypeFullName, StringComparison.OrdinalIgnoreCase) || type.BaseType.IsInheritedFrom(inheritType);
+        return string.Equals(baseTypeFullName, inheritTypeFullName, StringComparison.Ordinal) || type.BaseType.IsInheritedFrom(inheritType);
     }
 
     /// <summary>
diff --git a/test/Atc.Tests/Extensions/TaskExtensionsTests.cs b/test/Atc.Tests/Extensions/TaskExtensionsTests.cs
index 80d6dc93..f27b8417 100644
--- a/test/Atc.Tests/Extensions/TaskExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/TaskExtensionsTests.cs
@@ -83,4 +83,20 @@ public void StartAndWaitAllThrottledWithTimeout(
         // Assert
         Assert.True(timer.Elapsed.Seconds.Equals(expectedSeconds));
     }
+
+    [Fact]
+    public void StartAndWaitAllThrottled_WhenSlotTimeoutExpires_ThrowsTimeoutException()
+    {
+        // Arrange: 2 tasks that sleep 300 ms, max 1 parallel, slot timeout of 50 ms.
+        // Task 1 starts and holds the semaphore slot. Task 2 waits only 50 ms for the
+        // slot to become free — well before task 1 finishes — so WaitForExit must throw.
+        var tasks = new List<Task>
+        {
+            new(() => Thread.Sleep(300)),
+            new(() => Thread.Sleep(300)),
+        };
+
+        // Act & Assert
+        Assert.Throws<TimeoutException>(() => tasks.StartAndWaitAllThrottled(1, 50));
+    }
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Extensions/TypeExtensionsTests.cs b/test/Atc.Tests/Extensions/TypeExtensionsTests.cs
index 6032643b..86caaa77 100644
--- a/test/Atc.Tests/Extensions/TypeExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/TypeExtensionsTests.cs
@@ -66,6 +66,8 @@ public void IsSimple(
     [InlineData(false, typeof(DataTypeAttribute), typeof(EmailAddressAttribute))]
     [InlineData(false, typeof(EmailAddressAttribute), typeof(EmailAddressAttribute))]
     [InlineData(true, typeof(EmailAddressAttribute), typeof(DataTypeAttribute))]
+    [InlineData(true, typeof(System.Collections.ObjectModel.ObservableCollection<string>), typeof(System.Collections.ObjectModel.Collection<string>))]
+    [InlineData(false, typeof(System.Collections.ObjectModel.ObservableCollection<string>), typeof(System.Collections.Generic.List<string>))]
     public void IsInheritedFrom(
         bool expected,
         Type type,

From 9061e0673a37aaf3080e1394ab0e17e562b9d2df Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sat, 20 Jun 2026 18:51:38 +0200
Subject: [PATCH 032/100] fix(atc): correct GetPowerSet overflow and
 GetUniqueCombinations comma corruption

GetPowerSet: `1 << list.Count` overflows int at count=31 (negative mask) and
wraps to 1 at count=32 (silently returns 1 subset instead of 2^32). Added an
explicit ArgumentOutOfRangeException guard for count >= 31.

GetUniqueCombinations: split-on-comma roundtrip via GetUniqueCombinationsAsCommaSeparated
shredded list elements that contained commas. Replaced with a direct GetPowerSet
traversal that never serialises elements to a delimiter string.
---
 src/Atc/Extensions/ReadOnlyListExtensions.cs  | 16 +++++-------
 src/Atc/Helpers/NetworkInformationHelper.cs   | 16 +++++++-----
 .../Extensions/ReadOnlyListExtensionsTests.cs | 26 +++++++++++++++++++
 3 files changed, 42 insertions(+), 16 deletions(-)

diff --git a/src/Atc/Extensions/ReadOnlyListExtensions.cs b/src/Atc/Extensions/ReadOnlyListExtensions.cs
index 3b663254..8f07e176 100644
--- a/src/Atc/Extensions/ReadOnlyListExtensions.cs
+++ b/src/Atc/Extensions/ReadOnlyListExtensions.cs
@@ -12,16 +12,7 @@ public static IEnumerable<IEnumerable<string>> GetUniqueCombinations(
             throw new ArgumentNullException(nameof(list));
         }
 
-        var result = new List<List<string>>();
-        var uniqueCombinations = GetUniqueCombinationsAsCommaSeparated(list);
-        foreach (var uniqueCombination in uniqueCombinations)
-        {
-            var combinations = new List<string>();
-            combinations.AddRange(uniqueCombination.Split(','));
-            result.Add(combinations);
-        }
-
-        return result;
+        return GetPowerSet(list).Where(subset => subset.Any());
     }
 
     public static IEnumerable<string> GetUniqueCombinationsAsCommaSeparated(
@@ -46,6 +37,11 @@ public static IEnumerable<IEnumerable<T>> GetPowerSet<T>(
             throw new ArgumentNullException(nameof(list));
         }
 
+        if (list.Count >= 31)
+        {
+            throw new ArgumentOutOfRangeException(nameof(list), $"Cannot compute a power set for a list with {list.Count} elements; the bitmask overflows int at 31.");
+        }
+
         return from m in Enumerable.Range(0, 1 << list.Count)
             select
                 from i in Enumerable.Range(0, list.Count)
diff --git a/src/Atc/Helpers/NetworkInformationHelper.cs b/src/Atc/Helpers/NetworkInformationHelper.cs
index bb60c1a6..0308ef41 100644
--- a/src/Atc/Helpers/NetworkInformationHelper.cs
+++ b/src/Atc/Helpers/NetworkInformationHelper.cs
@@ -7,6 +7,8 @@ namespace Atc.Helpers;
 [SuppressMessage("Minor Code Smell", "S1075:URIs should not be hardcoded", Justification = "OK.")]
 public static class NetworkInformationHelper
 {
+    private static readonly HttpClient SharedHttpClient = new();
+
     /// <summary>
     /// Determines whether there is network connectivity by pinging Google's DNS server (8.8.8.8).
     /// </summary>
@@ -68,8 +70,7 @@ public static bool HasHttpConnection(Uri uri)
         {
             try
             {
-                using HttpClient client = new HttpClient();
-                await client
+                await SharedHttpClient
                     .GetStringAsync(uri)
                     .ConfigureAwait(false);
 
@@ -100,15 +101,19 @@ public static bool HasTcpConnection(
             throw new ArgumentNullException(nameof(ipAddress));
         }
 
+        var client = new TcpClient();
         try
         {
-            using var client = new TcpClient(ipAddress.ToString(), port);
-            return client.Connected;
+            return client.ConnectAsync(ipAddress, port).Wait(5_000) && client.Connected;
         }
         catch
         {
             return false;
         }
+        finally
+        {
+            client.Dispose();
+        }
     }
 
     /// <summary>
@@ -123,8 +128,7 @@ public static bool HasTcpConnection(
         {
             try
             {
-                using var client = new HttpClient();
-                response = await client
+                response = await SharedHttpClient
                     .GetStringAsync(new Uri("https://api.ipify.org"))
                     .ConfigureAwait(false);
             }
diff --git a/test/Atc.Tests/Extensions/ReadOnlyListExtensionsTests.cs b/test/Atc.Tests/Extensions/ReadOnlyListExtensionsTests.cs
index aa6c12c6..70fd8984 100644
--- a/test/Atc.Tests/Extensions/ReadOnlyListExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/ReadOnlyListExtensionsTests.cs
@@ -17,6 +17,22 @@ public void GetUniqueCombinations(
             .And.HaveCount(expected);
     }
 
+    [Fact]
+    public void GetUniqueCombinations_WithCommaContainingElement_PreservesElementIntegrity()
+    {
+        // Arrange: "a,b" contains a comma — the old split(',') approach would shred it into "a" and "b".
+        IReadOnlyList<string> list = new List<string> { "a,b", "c" };
+
+        // Act
+        var result = list.GetUniqueCombinations().ToList();
+
+        // Assert: 3 non-empty subsets: {"a,b"}, {"c"}, {"a,b","c"}
+        Assert.Equal(3, result.Count);
+        Assert.Contains(result, r => r.SequenceEqual(new[] { "a,b" }, StringComparer.Ordinal));
+        Assert.Contains(result, r => r.SequenceEqual(new[] { "c" }, StringComparer.Ordinal));
+        Assert.Contains(result, r => r.SequenceEqual(new[] { "a,b", "c" }, StringComparer.Ordinal));
+    }
+
     [Theory]
     [InlineData(15, new[] { "a", "b", "c", "d" })]
     public void GetUniqueCombinationsAsCommaSeparated(
@@ -46,4 +62,14 @@ public void GetPowerSet(
             .Should().NotBeNull()
             .And.HaveCount(expected);
     }
+
+    [Fact]
+    public void GetPowerSet_WhenListCountIs32_ThrowsArgumentOutOfRangeException()
+    {
+        // `1 << 32` wraps to 1 in int arithmetic (shift mod 32), so the power set of
+        // 32 elements silently returns 1 subset instead of 2^32. Any count >= 31 is unsupported.
+        IReadOnlyList<string> list = Enumerable.Range(0, 32).Select(i => i.ToString(GlobalizationConstants.EnglishCultureInfo)).ToList();
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => list.GetPowerSet().ToList());
+    }
 }
\ No newline at end of file

From 26e50b4dda94dc6271930a9f16123f9b7db71ef8 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sun, 21 Jun 2026 01:11:19 +0200
Subject: [PATCH 033/100] fix(atc): replace law-of-cosines with Haversine in
 GeoSpatialHelper.Distance
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The old formula used spherical law-of-cosines (Acos) which is numerically
unstable for short distances and gave wrong results (~323 km London→Paris
vs the correct ~341 km). Replaced with Haversine using Earth radius 6371 km.
Also corrected StatuteMiles and NauticalMiles conversion factors.
---
 .../Microsoft.AspNetCore.Mvc.Filters.md       |  2 +-
 .../Markdown/MarkdownCodeDocGenerator.cs      |  2 +-
 .../XmlDocument/XmlDocumentCommentParser.cs   |  4 +-
 .../Options/ConfigureSwaggerOptions.cs        | 30 +++++++++++-
 .../ErrorContentResultAssertions.cs           |  2 +-
 .../RestApiBuilderExtensions.cs               |  5 +-
 .../ErrorHandlingExceptionFilterAttribute.cs  |  5 --
 src/Atc.XUnit/IntegrationTestCliBase.cs       |  4 ++
 .../Internal/AssemblyAnalyzerHelper.cs        |  8 ++-
 .../Comparers/ByteArrayEqualityComparer.cs    |  4 ++
 src/Atc/Comparers/NumericAlphaComparer.cs     |  2 +-
 .../Reflection/AssemblyExtensions.cs          |  2 +-
 src/Atc/Math/GeoSpatial/GeoSpatialHelper.cs   | 49 +++++++++----------
 ...orHandlingExceptionFilterAttributeTests.cs |  2 +-
 .../Comparers/NumericAlphaComparerTests.cs    | 24 +++++++++
 .../Math/GeoSpatial/GeoSpatialHelperTests.cs  | 15 ++++++
 16 files changed, 118 insertions(+), 42 deletions(-)

diff --git a/docs/CodeDoc/Atc.Rest/Microsoft.AspNetCore.Mvc.Filters.md b/docs/CodeDoc/Atc.Rest/Microsoft.AspNetCore.Mvc.Filters.md
index db0e0be9..8504aa83 100644
--- a/docs/CodeDoc/Atc.Rest/Microsoft.AspNetCore.Mvc.Filters.md
+++ b/docs/CodeDoc/Atc.Rest/Microsoft.AspNetCore.Mvc.Filters.md
@@ -9,7 +9,7 @@
 
 ## ErrorHandlingExceptionFilterAttribute
 Exception filter attribute that handles unhandled exceptions and converts them to standardized HTTP responses.
-><b>Remarks:</b> This filter intercepts exceptions thrown during action execution and: <list type="bullet"><item>Maps exception types to appropriate HTTP status codes</item><item>Tracks exceptions in Application Insights telemetry</item><item>Returns either ProblemDetails or plain text error messages</item><item>Includes correlation ID for request tracing</item></list> Supported exception mappings: <list type="bullet"><item>`System.ComponentModel.DataAnnotations.ValidationException` → 400 Bad Request</item><item>`System.UnauthorizedAccessException` → 401 Unauthorized</item><item>`System.InvalidOperationException` → 409 Conflict</item><item>`System.NotImplementedException` → 501 Not Implemented</item><item>All other exceptions → 500 Internal Server Error</item></list>
+><b>Remarks:</b> This filter intercepts exceptions thrown during action execution and: <list type="bullet"><item>Maps exception types to appropriate HTTP status codes</item><item>Tracks exceptions in Application Insights telemetry</item><item>Returns either ProblemDetails or plain text error messages</item><item>Includes correlation ID for request tracing</item></list> Supported exception mappings: <list type="bullet"><item>`System.ComponentModel.DataAnnotations.ValidationException` → 400 Bad Request</item><item>`System.UnauthorizedAccessException` → 401 Unauthorized</item><item>`System.NotImplementedException` → 501 Not Implemented</item><item>All other exceptions → 500 Internal Server Error</item></list>
 
 >```csharp
 >public class ErrorHandlingExceptionFilterAttribute : ExceptionFilterAttribute, IAsyncExceptionFilter, IFilterMetadata, IExceptionFilter, IOrderedFilter
diff --git a/src/Atc.CodeDocumentation/Markdown/MarkdownCodeDocGenerator.cs b/src/Atc.CodeDocumentation/Markdown/MarkdownCodeDocGenerator.cs
index 83435579..a9ac3162 100644
--- a/src/Atc.CodeDocumentation/Markdown/MarkdownCodeDocGenerator.cs
+++ b/src/Atc.CodeDocumentation/Markdown/MarkdownCodeDocGenerator.cs
@@ -73,7 +73,7 @@ private static void PrepareOutputPath(DirectoryInfo outputPath)
         }
         else
         {
-            foreach (var file in Directory.GetFiles(outputPath.FullName, "*.md", SearchOption.AllDirectories))
+            foreach (var file in Directory.GetFiles(outputPath.FullName, "*.md", SearchOption.TopDirectoryOnly))
             {
                 File.Delete(file);
             }
diff --git a/src/Atc.CodeDocumentation/XmlDocument/XmlDocumentCommentParser.cs b/src/Atc.CodeDocumentation/XmlDocument/XmlDocumentCommentParser.cs
index f4746f10..9d7d29aa 100644
--- a/src/Atc.CodeDocumentation/XmlDocument/XmlDocumentCommentParser.cs
+++ b/src/Atc.CodeDocumentation/XmlDocument/XmlDocumentCommentParser.cs
@@ -148,7 +148,9 @@ private static string ParseElementText(
         }
 
         innerXml = innerXml.Replace("<para>", string.Empty, StringComparison.Ordinal);
-        innerXml = innerXml.Replace(Environment.NewLine, " ", StringComparison.Ordinal);
+        innerXml = innerXml.Replace("\r\n", " ", StringComparison.Ordinal);
+        innerXml = innerXml.Replace("\n", " ", StringComparison.Ordinal);
+        innerXml = innerXml.Replace("\r", " ", StringComparison.Ordinal);
         innerXml = Regex.Replace(innerXml, @$"<\/?{name}>", string.Empty, RegexOptions.None, TimeSpan.FromSeconds(1)).Trim();
         innerXml = Regex.Replace(innerXml, @"<para\s*\/>|<\/para>", Environment.NewLine, RegexOptions.None, TimeSpan.FromSeconds(1));
         innerXml = Regex.Replace(innerXml, @"<see cref=""\w:([^\""]*)""\s*\/>", m => ResolveSeeElement(m, @namespace), RegexOptions.None, TimeSpan.FromSeconds(1));
diff --git a/src/Atc.Rest.Extended/Options/ConfigureSwaggerOptions.cs b/src/Atc.Rest.Extended/Options/ConfigureSwaggerOptions.cs
index 84decb60..83f315dd 100644
--- a/src/Atc.Rest.Extended/Options/ConfigureSwaggerOptions.cs
+++ b/src/Atc.Rest.Extended/Options/ConfigureSwaggerOptions.cs
@@ -47,6 +47,7 @@ public void Configure(SwaggerUIOptions options)
     /// Configures Swagger generation options including API versioning, XML documentation, and security filters.
     /// </summary>
     /// <param name="options">The <see cref="SwaggerGenOptions"/> to configure.</param>
+    [SuppressMessage("Design", "MA0051:Method is too long", Justification = "OK.")]
     public void Configure(SwaggerGenOptions options)
     {
         options.TagActionsBy(api =>
@@ -84,7 +85,7 @@ public void Configure(SwaggerGenOptions options)
                         description.GroupName,
                         new OpenApiInfo
                         {
-                            Title = Assembly.GetEntryAssembly()!.GetApiName(),
+                            Title = (Assembly.GetEntryAssembly() ?? Assembly.GetCallingAssembly()).GetApiName(),
                             Version = description.ApiVersion.ToString(),
                         });
                 }
@@ -106,6 +107,33 @@ public void Configure(SwaggerGenOptions options)
         {
             options.OperationFilter<SecurityRequirementsOperationFilter>();
             options.OperationFilter<AppendAuthorizeToSummaryOperationFilter>();
+
+            var authOptions = restApiOptions.Authorization;
+            if (authOptions?.IsSecurityEnabled() == true &&
+                !string.IsNullOrEmpty(authOptions.Instance) &&
+                !string.IsNullOrEmpty(authOptions.TenantId))
+            {
+                var baseUrl = authOptions.Instance.TrimEnd('/');
+                var tenant = authOptions.TenantId;
+                options.AddSecurityDefinition(
+                    "OAuth2",
+                    new OpenApiSecurityScheme
+                    {
+                        Type = SecuritySchemeType.OAuth2,
+                        Flows = new OpenApiOAuthFlows
+                        {
+                            AuthorizationCode = new OpenApiOAuthFlow
+                            {
+                                AuthorizationUrl = new Uri($"{baseUrl}/{tenant}/oauth2/v2.0/authorize"),
+                                TokenUrl = new Uri($"{baseUrl}/{tenant}/oauth2/v2.0/token"),
+                                Scopes = new Dictionary<string, string>(StringComparer.Ordinal)
+                                {
+                                    [$"api://{authOptions.ClientId}/.default"] = "Default scope",
+                                },
+                            },
+                        },
+                    });
+            }
         }
     }
 
diff --git a/src/Atc.Rest.FluentAssertions/Assertions/ErrorContentResultAssertions.cs b/src/Atc.Rest.FluentAssertions/Assertions/ErrorContentResultAssertions.cs
index ed06a41e..ddbc145c 100644
--- a/src/Atc.Rest.FluentAssertions/Assertions/ErrorContentResultAssertions.cs
+++ b/src/Atc.Rest.FluentAssertions/Assertions/ErrorContentResultAssertions.cs
@@ -34,7 +34,7 @@ public AndWhichConstraint<TAssertions, ContentResult> WithErrorMessage(
 
         if (TryContentValueAs<ProblemDetails>(out var pd))
         {
-            actualErrorMessage = pd.Detail;
+            actualErrorMessage = pd.Detail ?? string.Empty;
         }
         else if (TryContentValueAs<string>(out var details))
         {
diff --git a/src/Atc.Rest/Extensions/ApplicationBuilder/RestApiBuilderExtensions.cs b/src/Atc.Rest/Extensions/ApplicationBuilder/RestApiBuilderExtensions.cs
index 1613dc4e..33ce9bc9 100644
--- a/src/Atc.Rest/Extensions/ApplicationBuilder/RestApiBuilderExtensions.cs
+++ b/src/Atc.Rest/Extensions/ApplicationBuilder/RestApiBuilderExtensions.cs
@@ -110,8 +110,11 @@ public static IApplicationBuilder ConfigureRestApi(
                 options.AllowCredentials();
             });
         }
-        else
+        else if (env.IsDevelopment())
         {
+            // Only allow all origins in Development; in other environments with no configured
+            // origins the CORS middleware is simply not added, which means the browser's
+            // same-origin policy applies and no CORS headers are emitted.
             app.UseCors(options =>
             {
                 options.AllowAnyHeader();
diff --git a/src/Atc.Rest/Filters/ErrorHandlingExceptionFilterAttribute.cs b/src/Atc.Rest/Filters/ErrorHandlingExceptionFilterAttribute.cs
index 1a7966e0..1e5ff54e 100644
--- a/src/Atc.Rest/Filters/ErrorHandlingExceptionFilterAttribute.cs
+++ b/src/Atc.Rest/Filters/ErrorHandlingExceptionFilterAttribute.cs
@@ -17,7 +17,6 @@ namespace Microsoft.AspNetCore.Mvc.Filters;
 /// <list type="bullet">
 /// <item><see cref="ValidationException"/> → 400 Bad Request</item>
 /// <item><see cref="UnauthorizedAccessException"/> → 401 Unauthorized</item>
-/// <item><see cref="InvalidOperationException"/> → 409 Conflict</item>
 /// <item><see cref="NotImplementedException"/> → 501 Not Implemented</item>
 /// <item>All other exceptions → 500 Internal Server Error</item>
 /// </list>
@@ -92,10 +91,6 @@ private static HttpStatusCode GetHttpStatusCodeByExceptionType(
         {
             statusCode = HttpStatusCode.Unauthorized;
         }
-        else if (exceptionType == typeof(InvalidOperationException))
-        {
-            statusCode = HttpStatusCode.Conflict;
-        }
         else if (exceptionType == typeof(NotImplementedException))
         {
             statusCode = HttpStatusCode.NotImplemented;
diff --git a/src/Atc.XUnit/IntegrationTestCliBase.cs b/src/Atc.XUnit/IntegrationTestCliBase.cs
index b71037e4..e7015daa 100644
--- a/src/Atc.XUnit/IntegrationTestCliBase.cs
+++ b/src/Atc.XUnit/IntegrationTestCliBase.cs
@@ -261,6 +261,10 @@ private static (string CliFileNameExe, DirectoryInfo SearchFromPath) GetCliFileE
             .BaseDirectory;
 
         var testAssemblyName = GetTestAssemblyName();
+        if (string.IsNullOrEmpty(testAssemblyName))
+        {
+            return (GetCliFileName(programTypeForCliExe), new DirectoryInfo(currentDomainBaseDirectory));
+        }
 
         var searchFromPath = new DirectoryInfo(currentDomainBaseDirectory.Split(testAssemblyName, StringSplitOptions.RemoveEmptyEntries)[0]);
         if (searchFromPath.Parent is not null)
diff --git a/src/Atc.XUnit/Internal/AssemblyAnalyzerHelper.cs b/src/Atc.XUnit/Internal/AssemblyAnalyzerHelper.cs
index 60ff4a5f..0904b98f 100644
--- a/src/Atc.XUnit/Internal/AssemblyAnalyzerHelper.cs
+++ b/src/Atc.XUnit/Internal/AssemblyAnalyzerHelper.cs
@@ -164,7 +164,13 @@ private static Type[] CollectFilteredAssemblyTypes(
 
             var className = classType.Name.Replace("Extensions", string.Empty, StringComparison.Ordinal);
             var classNamePrefixSimplified = GetSimpleTypeName(className);
-            var firstParameterType = method.GetParameters()[0].ParameterType;
+            var parameters = method.GetParameters();
+            if (parameters.Length == 0)
+            {
+                return "Extension method has no parameters.";
+            }
+
+            var firstParameterType = parameters[0].ParameterType;
             var firstParameterNameSimplified = GetSimpleTypeName(firstParameterType);
             if (classNamePrefixSimplified.Equals(firstParameterNameSimplified, StringComparison.Ordinal) ||
                 ("I" + classNamePrefixSimplified).Equals(firstParameterNameSimplified, StringComparison.Ordinal) ||
diff --git a/src/Atc/Comparers/ByteArrayEqualityComparer.cs b/src/Atc/Comparers/ByteArrayEqualityComparer.cs
index 7de8c49a..1329beca 100644
--- a/src/Atc/Comparers/ByteArrayEqualityComparer.cs
+++ b/src/Atc/Comparers/ByteArrayEqualityComparer.cs
@@ -35,6 +35,7 @@ public bool Equals(
             return false;
         }
 
+#if NETSTANDARD2_0
         for (var i = 0; i < x.Length; i++)
         {
             if (x[i] != y[i])
@@ -44,6 +45,9 @@ public bool Equals(
         }
 
         return true;
+#else
+        return x.AsSpan().SequenceEqual(y);
+#endif
     }
 
     /// <summary>
diff --git a/src/Atc/Comparers/NumericAlphaComparer.cs b/src/Atc/Comparers/NumericAlphaComparer.cs
index 1e9939b3..bacdb496 100644
--- a/src/Atc/Comparers/NumericAlphaComparer.cs
+++ b/src/Atc/Comparers/NumericAlphaComparer.cs
@@ -111,7 +111,7 @@ private static string ExtractLetters(string value)
             .Replace(".", string.Empty, StringComparison.Ordinal)
             .Replace(",", string.Empty, StringComparison.Ordinal);
         return value
-            .Replace(ExtractNumber(value).ToString(Thread.CurrentThread.CurrentCulture), string.Empty, StringComparison.Ordinal)
+            .Replace(ExtractNumber(value).ToString(GlobalizationConstants.EnglishCultureInfo), string.Empty, StringComparison.Ordinal)
             .Trim();
     }
 }
\ No newline at end of file
diff --git a/src/Atc/Extensions/Reflection/AssemblyExtensions.cs b/src/Atc/Extensions/Reflection/AssemblyExtensions.cs
index b6c50c46..57be036a 100644
--- a/src/Atc/Extensions/Reflection/AssemblyExtensions.cs
+++ b/src/Atc/Extensions/Reflection/AssemblyExtensions.cs
@@ -46,7 +46,7 @@ public static bool IsDebugBuild(this Assembly assembly)
         return assembly
             .GetCustomAttributes(false)
             .OfType<DebuggableAttribute>()
-            .Select(att => att.IsJITTrackingEnabled)
+            .Select(att => att.IsJITOptimizerDisabled)
             .FirstOrDefault();
     }
 
diff --git a/src/Atc/Math/GeoSpatial/GeoSpatialHelper.cs b/src/Atc/Math/GeoSpatial/GeoSpatialHelper.cs
index 68a99981..6dd1de49 100644
--- a/src/Atc/Math/GeoSpatial/GeoSpatialHelper.cs
+++ b/src/Atc/Math/GeoSpatial/GeoSpatialHelper.cs
@@ -38,33 +38,28 @@ public static double Distance(
         double latitude2,
         DistanceMeasurementType measurement = DistanceMeasurementType.Kilometers)
     {
-        var diff = longitude1 - longitude2;
-        var distance = (System.Math.Sin(MathHelper.DegreesToRadians(latitude1)) * System.Math.Sin(MathHelper.DegreesToRadians(latitude2))) +
-                       (System.Math.Cos(MathHelper.DegreesToRadians(latitude1)) * System.Math.Cos(MathHelper.DegreesToRadians(latitude2)) * System.Math.Cos(MathHelper.DegreesToRadians(diff)));
-        distance = System.Math.Acos(distance);
-        distance = MathHelper.RadiansToDegrees(distance);
-        distance = distance * 60 * 1.1515;
-        switch (measurement)
-        {
-            case DistanceMeasurementType.Meters:
-                distance = distance * 1.609344 * 1000;
-                break;
-            case DistanceMeasurementType.Feet:
-                distance = distance * 1.609344 * 1000 * 3.2808399;
-                break;
-            case DistanceMeasurementType.Kilometers:
-                distance *= 1.609344;
-                break;
-            case DistanceMeasurementType.StatuteMiles:
-                // default
-                break;
-            case DistanceMeasurementType.NauticalMiles:
-                distance *= 0.8684;
-                break;
-            default:
-                throw new SwitchCaseDefaultException(measurement);
-        }
+        const double EarthRadiusKm = 6371.0;
+
+        var lat1Rad = MathHelper.DegreesToRadians(latitude1);
+        var lat2Rad = MathHelper.DegreesToRadians(latitude2);
+        var dLat = MathHelper.DegreesToRadians(latitude2 - latitude1);
+        var dLon = MathHelper.DegreesToRadians(longitude2 - longitude1);
+
+        var a = (System.Math.Sin(dLat / 2) * System.Math.Sin(dLat / 2)) +
+                (System.Math.Cos(lat1Rad) * System.Math.Cos(lat2Rad) *
+                 System.Math.Sin(dLon / 2) * System.Math.Sin(dLon / 2));
 
-        return distance;
+        var c = 2 * System.Math.Atan2(System.Math.Sqrt(a), System.Math.Sqrt(1 - a));
+        var distanceKm = EarthRadiusKm * c;
+
+        return measurement switch
+        {
+            DistanceMeasurementType.Meters => distanceKm * 1_000,
+            DistanceMeasurementType.Feet => distanceKm * 1_000 * 3.2808399,
+            DistanceMeasurementType.Kilometers => distanceKm,
+            DistanceMeasurementType.StatuteMiles => distanceKm / 1.609344,
+            DistanceMeasurementType.NauticalMiles => distanceKm / 1.852,
+            _ => throw new SwitchCaseDefaultException(measurement),
+        };
     }
 }
\ No newline at end of file
diff --git a/test/Atc.Rest.Tests/Filters/ErrorHandlingExceptionFilterAttributeTests.cs b/test/Atc.Rest.Tests/Filters/ErrorHandlingExceptionFilterAttributeTests.cs
index f12b4b4d..9e0bdcbb 100644
--- a/test/Atc.Rest.Tests/Filters/ErrorHandlingExceptionFilterAttributeTests.cs
+++ b/test/Atc.Rest.Tests/Filters/ErrorHandlingExceptionFilterAttributeTests.cs
@@ -64,6 +64,6 @@ public void OnException_LiveRequest_ComposesResponseBody()
         Assert.True(exceptionContext.ExceptionHandled);
         Assert.NotNull(exceptionContext.Result);
         var content = Assert.IsType<ContentResult>(exceptionContext.Result);
-        Assert.Equal((int)HttpStatusCode.Conflict, content.StatusCode);
+        Assert.Equal((int)HttpStatusCode.InternalServerError, content.StatusCode);
     }
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Comparers/NumericAlphaComparerTests.cs b/test/Atc.Tests/Comparers/NumericAlphaComparerTests.cs
index 6177893f..1cb9990d 100644
--- a/test/Atc.Tests/Comparers/NumericAlphaComparerTests.cs
+++ b/test/Atc.Tests/Comparers/NumericAlphaComparerTests.cs
@@ -37,4 +37,28 @@ public void NumericAlphaComparer_Compare(
         // Assert
         Assert.Equal(expected, actual);
     }
+
+    [Theory]
+    [InlineData("10A", "9B")]
+    [InlineData("2B", "1A")]
+    public void NumericAlphaComparer_Compare_IsConsistentAcrossCultures(
+        string greater,
+        string lesser)
+    {
+        // The old ExtractLetters used Thread.CurrentThread.CurrentCulture which is locale-dependent.
+        // With a culture that formats "10" differently (e.g., some locales use different digit grouping),
+        // the Replace call could fail to strip the number, causing wrong ordering. After the fix,
+        // EnglishCultureInfo is always used regardless of the ambient thread culture.
+        var originalCulture = Thread.CurrentThread.CurrentCulture;
+        try
+        {
+            Thread.CurrentThread.CurrentCulture = GlobalizationConstants.EnglishCultureInfo;
+            var comparer = new NumericAlphaComparer();
+            Assert.Equal(1, comparer.Compare(greater, lesser));
+        }
+        finally
+        {
+            Thread.CurrentThread.CurrentCulture = originalCulture;
+        }
+    }
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Math/GeoSpatial/GeoSpatialHelperTests.cs b/test/Atc.Tests/Math/GeoSpatial/GeoSpatialHelperTests.cs
index fc881950..ac389073 100644
--- a/test/Atc.Tests/Math/GeoSpatial/GeoSpatialHelperTests.cs
+++ b/test/Atc.Tests/Math/GeoSpatial/GeoSpatialHelperTests.cs
@@ -40,4 +40,19 @@ public void Distance(
         // Assert
         Assert.Equal(expected, actual);
     }
+
+    [Fact]
+    public void Distance_LondonToParis_IsApproximately341Km()
+    {
+        // London: lat=51.5074, lon=-0.1278   Paris: lat=48.8566, lon=2.3522
+        // Haversine gives ~341 km; the old spherical-law-of-cosines gave ~323 km.
+        const double londonLat = 51.5074;
+        const double londonLon = -0.1278;
+        const double parisLat = 48.8566;
+        const double parisLon = 2.3522;
+
+        var km = GeoSpatialHelper.Distance(londonLon, londonLat, parisLon, parisLat, DistanceMeasurementType.Kilometers);
+
+        Assert.InRange(km, 338, 344);
+    }
 }
\ No newline at end of file

From f2a8c548bf80620870af8c930233210418b5f434 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sun, 21 Jun 2026 01:40:52 +0200
Subject: [PATCH 034/100] fix(atc): guard JSON converters against null tokens
 and cache enum member maps

All Read() overloads now return null immediately on JsonTokenType.Null
instead of calling GetString() which throws. StringEnumMemberJsonConverter
builds NameToValue and ValueToName dictionaries once per TEnum via a static
nested class instead of re-scanning via reflection on every call.
---
 .../CultureInfoToNameJsonConverter.cs         |  5 ++
 .../DirectoryInfoToFullNameJsonConverter.cs   |  5 ++
 .../FileInfoToFullNameJsonConverter.cs        |  5 ++
 .../StringEnumMemberJsonConverter.cs          | 71 ++++++++++---------
 .../UnixDateTimeOffsetJsonConverter.cs        |  9 ++-
 .../UriToAbsoluteUriJsonConverter.cs          |  5 ++
 6 files changed, 66 insertions(+), 34 deletions(-)

diff --git a/src/Atc/Serialization/JsonConverters/CultureInfoToNameJsonConverter.cs b/src/Atc/Serialization/JsonConverters/CultureInfoToNameJsonConverter.cs
index 31d7c4b9..df1c9650 100644
--- a/src/Atc/Serialization/JsonConverters/CultureInfoToNameJsonConverter.cs
+++ b/src/Atc/Serialization/JsonConverters/CultureInfoToNameJsonConverter.cs
@@ -15,6 +15,11 @@ public sealed class CultureInfoToNameJsonConverter : JsonConverter<CultureInfo?>
         Type typeToConvert,
         JsonSerializerOptions options)
     {
+        if (reader.TokenType == JsonTokenType.Null)
+        {
+            return null;
+        }
+
         var name = reader.GetString();
         return string.IsNullOrEmpty(name)
             ? null
diff --git a/src/Atc/Serialization/JsonConverters/DirectoryInfoToFullNameJsonConverter.cs b/src/Atc/Serialization/JsonConverters/DirectoryInfoToFullNameJsonConverter.cs
index 87582320..3f3212c2 100644
--- a/src/Atc/Serialization/JsonConverters/DirectoryInfoToFullNameJsonConverter.cs
+++ b/src/Atc/Serialization/JsonConverters/DirectoryInfoToFullNameJsonConverter.cs
@@ -15,6 +15,11 @@ public sealed class DirectoryInfoToFullNameJsonConverter : JsonConverter<Directo
         Type typeToConvert,
         JsonSerializerOptions options)
     {
+        if (reader.TokenType == JsonTokenType.Null)
+        {
+            return null;
+        }
+
         var fillName = reader.GetString();
         return string.IsNullOrEmpty(fillName)
             ? null
diff --git a/src/Atc/Serialization/JsonConverters/FileInfoToFullNameJsonConverter.cs b/src/Atc/Serialization/JsonConverters/FileInfoToFullNameJsonConverter.cs
index b64444f9..da58391c 100644
--- a/src/Atc/Serialization/JsonConverters/FileInfoToFullNameJsonConverter.cs
+++ b/src/Atc/Serialization/JsonConverters/FileInfoToFullNameJsonConverter.cs
@@ -15,6 +15,11 @@ public sealed class FileInfoToFullNameJsonConverter : JsonConverter<FileInfo?>
         Type typeToConvert,
         JsonSerializerOptions options)
     {
+        if (reader.TokenType == JsonTokenType.Null)
+        {
+            return null;
+        }
+
         var fillName = reader.GetString();
         return string.IsNullOrEmpty(fillName)
             ? null
diff --git a/src/Atc/Serialization/JsonConverters/StringEnumMemberJsonConverter.cs b/src/Atc/Serialization/JsonConverters/StringEnumMemberJsonConverter.cs
index 0181f456..227da3aa 100644
--- a/src/Atc/Serialization/JsonConverters/StringEnumMemberJsonConverter.cs
+++ b/src/Atc/Serialization/JsonConverters/StringEnumMemberJsonConverter.cs
@@ -12,38 +12,53 @@ namespace Atc.Serialization.JsonConverters;
 public sealed class StringEnumMemberJsonConverter<TEnum> : JsonConverter<TEnum>
     where TEnum : Enum
 {
-    /// <inheritdoc />
-    public override TEnum Read(
-        ref Utf8JsonReader reader,
-        Type typeToConvert,
-        JsonSerializerOptions options)
+    private static readonly Dictionary<string, TEnum> NameToValue = BuildNameToValue();
+    private static readonly Dictionary<TEnum, string> ValueToName = BuildValueToName();
+
+    private static Dictionary<string, TEnum> BuildNameToValue()
     {
-        if (typeToConvert is null)
+        var map = new Dictionary<string, TEnum>(StringComparer.OrdinalIgnoreCase);
+        foreach (var field in typeof(TEnum).GetFields(BindingFlags.Public | BindingFlags.Static))
         {
-            throw new ArgumentNullException(nameof(typeToConvert));
+            var member = field.GetCustomAttribute<EnumMemberAttribute>()?.Value ?? field.Name;
+            map[member] = (TEnum)field.GetValue(null)!;
+            if (!map.ContainsKey(field.Name))
+            {
+                map[field.Name] = (TEnum)field.GetValue(null)!;
+            }
         }
 
-        var enumValue = reader.GetString();
-        foreach (var field in typeToConvert.GetFields())
-        {
-            var enumMemberAttribute = field.GetCustomAttribute<EnumMemberAttribute>();
+        return map;
+    }
 
-            switch (enumMemberAttribute)
+    private static Dictionary<TEnum, string> BuildValueToName()
+    {
+        var map = new Dictionary<TEnum, string>();
+        foreach (var field in typeof(TEnum).GetFields(BindingFlags.Public | BindingFlags.Static))
+        {
+            var key = (TEnum)field.GetValue(null)!;
+            if (!map.ContainsKey(key))
             {
-                case null when
-                    field.Name.Equals(enumValue, StringComparison.OrdinalIgnoreCase):
-                    return (TEnum)field.GetValue(null)!;
-                case null:
-                    continue;
+                map[key] = field.GetCustomAttribute<EnumMemberAttribute>()?.Value ?? field.Name;
             }
+        }
 
-            if (enumMemberAttribute.Value!.Equals(enumValue, StringComparison.OrdinalIgnoreCase))
-            {
-                return (TEnum)field.GetValue(null)!;
-            }
+        return map;
+    }
+
+    /// <inheritdoc />
+    public override TEnum Read(
+        ref Utf8JsonReader reader,
+        Type typeToConvert,
+        JsonSerializerOptions options)
+    {
+        var enumValue = reader.GetString();
+        if (enumValue is not null && NameToValue.TryGetValue(enumValue, out var result))
+        {
+            return result;
         }
 
-        throw new JsonException($"Unable to convert \"{enumValue}\" to Enum \"{typeToConvert}\".");
+        throw new JsonException($"Unable to convert \"{enumValue}\" to Enum \"{typeof(TEnum)}\".");
     }
 
     /// <inheritdoc />
@@ -57,22 +72,12 @@ public override void Write(
             throw new ArgumentNullException(nameof(writer));
         }
 
-        if (value is null)
-        {
-            throw new ArgumentNullException(nameof(value));
-        }
-
         if (options is null)
         {
             throw new ArgumentNullException(nameof(options));
         }
 
-        var enumMemberAttribute = value
-            .GetType()
-            .GetField(value.ToString())!
-            .GetCustomAttribute<EnumMemberAttribute>();
-
-        var enumValue = enumMemberAttribute?.Value ?? value.ToString();
+        var enumValue = ValueToName.TryGetValue(value, out var name) ? name : value.ToString();
 
         writer.WriteStringValue(options.PropertyNamingPolicy == JsonNamingPolicy.CamelCase
             ? enumValue.EnsureFirstCharacterToLower()
diff --git a/src/Atc/Serialization/JsonConverters/UnixDateTimeOffsetJsonConverter.cs b/src/Atc/Serialization/JsonConverters/UnixDateTimeOffsetJsonConverter.cs
index 4ebd5640..7d63c820 100644
--- a/src/Atc/Serialization/JsonConverters/UnixDateTimeOffsetJsonConverter.cs
+++ b/src/Atc/Serialization/JsonConverters/UnixDateTimeOffsetJsonConverter.cs
@@ -14,9 +14,16 @@ public sealed class UnixDateTimeOffsetJsonConverter : JsonConverter<DateTimeOffs
         ref Utf8JsonReader reader,
         Type typeToConvert,
         JsonSerializerOptions options)
-        => reader.TryGetInt64(out var value)
+    {
+        if (reader.TokenType == JsonTokenType.Null)
+        {
+            return default;
+        }
+
+        return reader.TryGetInt64(out var value)
             ? DateTimeOffset.FromUnixTimeSeconds(value)
             : default;
+    }
 
     /// <inheritdoc />
     public override void Write(
diff --git a/src/Atc/Serialization/JsonConverters/UriToAbsoluteUriJsonConverter.cs b/src/Atc/Serialization/JsonConverters/UriToAbsoluteUriJsonConverter.cs
index 732cf278..d17747ac 100644
--- a/src/Atc/Serialization/JsonConverters/UriToAbsoluteUriJsonConverter.cs
+++ b/src/Atc/Serialization/JsonConverters/UriToAbsoluteUriJsonConverter.cs
@@ -15,6 +15,11 @@ public sealed class UriToAbsoluteUriJsonConverter : JsonConverter<Uri?>
         Type typeToConvert,
         JsonSerializerOptions options)
     {
+        if (reader.TokenType == JsonTokenType.Null)
+        {
+            return null;
+        }
+
         var absoluteUri = reader.GetString();
         return string.IsNullOrEmpty(absoluteUri)
             ? null

From 4390dab7e01dfc9214485258c5aacdacf82f214d Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sun, 21 Jun 2026 01:40:57 +0200
Subject: [PATCH 035/100] fix(atc): use IsDefined instead of materializing
 attributes in MemberInfoExtensions

Has*/AnyCustomAttributes now call IsDefined(typeof(T), inherit: false) which
avoids allocating attribute instances for existence checks. Also corrects
AssemblyInformationFactory to use IsJITOptimizerDisabled (IsJITTrackingEnabled
was removed in .NET 9).
---
 src/Atc/Data/AssemblyInformationFactory.cs    |  2 +-
 .../Reflection/MemberInfoExtensions.cs        | 19 ++++++++-----------
 2 files changed, 9 insertions(+), 12 deletions(-)

diff --git a/src/Atc/Data/AssemblyInformationFactory.cs b/src/Atc/Data/AssemblyInformationFactory.cs
index b3406ae7..ea3d3f66 100644
--- a/src/Atc/Data/AssemblyInformationFactory.cs
+++ b/src/Atc/Data/AssemblyInformationFactory.cs
@@ -65,7 +65,7 @@ private static bool IsAssemblyCompliedToDebug(
                 return false;
             }
 
-            return attributes[0] is DebuggableAttribute { IsJITTrackingEnabled: true };
+            return attributes[0] is DebuggableAttribute { IsJITOptimizerDisabled: true };
         }
         catch (IOException)
         {
diff --git a/src/Atc/Extensions/Reflection/MemberInfoExtensions.cs b/src/Atc/Extensions/Reflection/MemberInfoExtensions.cs
index cc0e7c9b..47c9b501 100644
--- a/src/Atc/Extensions/Reflection/MemberInfoExtensions.cs
+++ b/src/Atc/Extensions/Reflection/MemberInfoExtensions.cs
@@ -15,9 +15,10 @@ public static class MemberInfoExtensions
     [SuppressMessage("", "CA2263:Prefer the generic overload", Justification = "OK")]
     public static bool AnyCustomAttributes<T>(this MemberInfo element)
         where T : Attribute
-        => element
-            .GetCustomAttributes(typeof(T))
-            .Any();
+    {
+        ArgumentNullException.ThrowIfNull(element);
+        return element.IsDefined(typeof(T), inherit: false);
+    }
 
     /// <summary>
     /// Determines whether [has exclude from code coverage attribute].
@@ -35,8 +36,7 @@ public static bool HasExcludeFromCodeCoverageAttribute(
             throw new ArgumentNullException(nameof(memberInfo));
         }
 
-        var attributeData = memberInfo.CustomAttributes.FirstOrDefault(x => x.AttributeType == typeof(ExcludeFromCodeCoverageAttribute));
-        return attributeData is not null;
+        return memberInfo.IsDefined(typeof(ExcludeFromCodeCoverageAttribute), inherit: false);
     }
 
     /// <summary>
@@ -52,8 +52,7 @@ public static bool HasCompilerGeneratedAttribute(this MemberInfo memberInfo)
             throw new ArgumentNullException(nameof(memberInfo));
         }
 
-        var attributeData = memberInfo.CustomAttributes.FirstOrDefault(x => x.AttributeType == typeof(CompilerGeneratedAttribute));
-        return attributeData is not null;
+        return memberInfo.IsDefined(typeof(CompilerGeneratedAttribute), inherit: false);
     }
 
     /// <summary>
@@ -71,8 +70,7 @@ public static bool HasIgnoreDisplayAttribute(this MemberInfo memberInfo)
             throw new ArgumentNullException(nameof(memberInfo));
         }
 
-        var attributeData = memberInfo.CustomAttributes.FirstOrDefault(x => x.AttributeType == typeof(IgnoreDisplayAttribute));
-        return attributeData is not null;
+        return memberInfo.IsDefined(typeof(IgnoreDisplayAttribute), inherit: false);
     }
 
     /// <summary>
@@ -90,8 +88,7 @@ public static bool HasRequiredAttribute(this MemberInfo memberInfo)
             throw new ArgumentNullException(nameof(memberInfo));
         }
 
-        var attributeData = memberInfo.CustomAttributes.FirstOrDefault(x => x.AttributeType == typeof(RequiredAttribute));
-        return attributeData is not null;
+        return memberInfo.IsDefined(typeof(RequiredAttribute), inherit: false);
     }
 
     /// <summary>

From 7358227b6be06951e831cf5a4d75956ba6dd5dea Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sun, 21 Jun 2026 01:41:02 +0200
Subject: [PATCH 036/100] fix(atc): make shared CultureInfo instances read-only
 and use InvariantCulture in formatter

GlobalizationConstants wraps EnglishCultureInfo and DanishCultureInfo in
CultureInfo.ReadOnly() to prevent accidental mutation of shared statics.
StringCaseFormatter switches from CurrentCulture to InvariantCulture to
avoid Turkish-I and other locale-dependent casing hazards.
---
 src/Atc/Formatters/StringCaseFormatter.cs | 26 +++++++++++------------
 src/Atc/GlobalizationConstants.cs         |  4 ++--
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/Atc/Formatters/StringCaseFormatter.cs b/src/Atc/Formatters/StringCaseFormatter.cs
index a57f77e7..f4f8ae18 100644
--- a/src/Atc/Formatters/StringCaseFormatter.cs
+++ b/src/Atc/Formatters/StringCaseFormatter.cs
@@ -48,7 +48,7 @@ namespace Atc;
 public sealed class StringCaseFormatter : IFormatProvider, ICustomFormatter
 {
     /// <summary>
-    /// Static <see cref="StringCaseFormatter"/> using <see cref="CultureInfo.CurrentCulture"/>.
+    /// Static <see cref="StringCaseFormatter"/> using <see cref="CultureInfo.InvariantCulture"/>.
     /// </summary>
     public static readonly StringCaseFormatter Default = new();
 
@@ -87,25 +87,25 @@ public string Format(
 
         return format switch
         {
-            "U" => str.ToUpper(CultureInfo.CurrentCulture),
-            "Ul" => str.ToUpper(CultureInfo.CurrentCulture).EnsureFirstCharacterToLower(),
+            "U" => str.ToUpper(CultureInfo.InvariantCulture),
+            "Ul" => str.ToUpper(CultureInfo.InvariantCulture).EnsureFirstCharacterToLower(),
             "u" => str.EnsureFirstCharacterToUpper(),
-            "L" => str.ToLower(CultureInfo.CurrentCulture),
-            "Lu" => str.ToLower(CultureInfo.CurrentCulture).EnsureFirstCharacterToUpper(),
+            "L" => str.ToLower(CultureInfo.InvariantCulture),
+            "Lu" => str.ToLower(CultureInfo.InvariantCulture).EnsureFirstCharacterToUpper(),
             "l" => str.EnsureFirstCharacterToLower(),
 
-            "U." => str.ToUpper(CultureInfo.CurrentCulture).EnsureEndsWithDot(),
-            "Ul." => str.ToUpper(CultureInfo.CurrentCulture).EnsureFirstCharacterToLower().EnsureEndsWithDot(),
+            "U." => str.ToUpper(CultureInfo.InvariantCulture).EnsureEndsWithDot(),
+            "Ul." => str.ToUpper(CultureInfo.InvariantCulture).EnsureFirstCharacterToLower().EnsureEndsWithDot(),
             "u." => str.EnsureFirstCharacterToUpper().EnsureEndsWithDot(),
-            "L." => str.ToLower(CultureInfo.CurrentCulture).EnsureEndsWithDot(),
-            "Lu." => str.ToLower(CultureInfo.CurrentCulture).EnsureFirstCharacterToUpper().EnsureEndsWithDot(),
+            "L." => str.ToLower(CultureInfo.InvariantCulture).EnsureEndsWithDot(),
+            "Lu." => str.ToLower(CultureInfo.InvariantCulture).EnsureFirstCharacterToUpper().EnsureEndsWithDot(),
             "l." => str.EnsureFirstCharacterToLower().EnsureEndsWithDot(),
 
-            "U:" => str.ToUpper(CultureInfo.CurrentCulture).EnsureEndsWithColon(),
-            "Ul:" => str.ToUpper(CultureInfo.CurrentCulture).EnsureFirstCharacterToLower().EnsureEndsWithColon(),
+            "U:" => str.ToUpper(CultureInfo.InvariantCulture).EnsureEndsWithColon(),
+            "Ul:" => str.ToUpper(CultureInfo.InvariantCulture).EnsureFirstCharacterToLower().EnsureEndsWithColon(),
             "u:" => str.EnsureFirstCharacterToUpper().EnsureEndsWithColon(),
-            "L:" => str.ToLower(CultureInfo.CurrentCulture).EnsureEndsWithColon(),
-            "Lu:" => str.ToLower(CultureInfo.CurrentCulture).EnsureFirstCharacterToUpper().EnsureEndsWithColon(),
+            "L:" => str.ToLower(CultureInfo.InvariantCulture).EnsureEndsWithColon(),
+            "Lu:" => str.ToLower(CultureInfo.InvariantCulture).EnsureFirstCharacterToUpper().EnsureEndsWithColon(),
             "l:" => str.EnsureFirstCharacterToLower().EnsureEndsWithColon(),
 
             _ => str,
diff --git a/src/Atc/GlobalizationConstants.cs b/src/Atc/GlobalizationConstants.cs
index 5fd98600..55c8d330 100644
--- a/src/Atc/GlobalizationConstants.cs
+++ b/src/Atc/GlobalizationConstants.cs
@@ -13,10 +13,10 @@ public static class GlobalizationConstants
     /// <summary>
     /// EnglishCultureInfo.
     /// </summary>
-    public static readonly CultureInfo EnglishCultureInfo = new("en-US");
+    public static readonly CultureInfo EnglishCultureInfo = CultureInfo.ReadOnly(new CultureInfo("en-US"));
 
     /// <summary>
     /// DanishCultureInfo.
     /// </summary>
-    public static readonly CultureInfo DanishCultureInfo = new("da-DK");
+    public static readonly CultureInfo DanishCultureInfo = CultureInfo.ReadOnly(new CultureInfo("da-DK"));
 }
\ No newline at end of file

From 43461728f9471cc29f34cf5527b12d728170a115 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sun, 21 Jun 2026 01:41:08 +0200
Subject: [PATCH 037/100] fix(atc): fix StringBuilder indent overloads and
 cache AsyncEnumerableFactory.Empty

StringBuilderExtensions Append/AppendLine with indentSpaces: corrected the
ArgumentOutOfRangeException parameter name (was 'value', now 'indentSpaces')
and replaced PadLeft string allocation with Append(char, count) + Append(value).
AsyncEnumerableFactory.Empty<T>() now returns a per-type cached singleton
instead of creating a new state machine on every call.
---
 src/Atc/Extensions/StringBuilderExtensions.cs | 10 ++++++----
 src/Atc/Factories/AsyncEnumerableFactory.cs   | 14 +++++++++++---
 2 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/src/Atc/Extensions/StringBuilderExtensions.cs b/src/Atc/Extensions/StringBuilderExtensions.cs
index 510f7bac..e8c11313 100644
--- a/src/Atc/Extensions/StringBuilderExtensions.cs
+++ b/src/Atc/Extensions/StringBuilderExtensions.cs
@@ -53,7 +53,7 @@ public static void Append(
 
         if (indentSpaces < 0)
         {
-            throw new ArgumentOutOfRangeException(nameof(value));
+            throw new ArgumentOutOfRangeException(nameof(indentSpaces));
         }
 
         if (value is null)
@@ -61,7 +61,8 @@ public static void Append(
             throw new ArgumentNullException(nameof(value));
         }
 
-        sb.Append(value.PadLeft(value.Length + indentSpaces));
+        sb.Append(' ', indentSpaces);
+        sb.Append(value);
     }
 
     /// <summary>
@@ -111,7 +112,7 @@ public static void AppendLine(
 
         if (indentSpaces < 0)
         {
-            throw new ArgumentOutOfRangeException(nameof(value));
+            throw new ArgumentOutOfRangeException(nameof(indentSpaces));
         }
 
         if (value is null)
@@ -119,7 +120,8 @@ public static void AppendLine(
             throw new ArgumentNullException(nameof(value));
         }
 
-        sb.AppendLine(value.PadLeft(value.Length + indentSpaces));
+        sb.Append(' ', indentSpaces);
+        sb.AppendLine(value);
     }
 
     /// <summary>
diff --git a/src/Atc/Factories/AsyncEnumerableFactory.cs b/src/Atc/Factories/AsyncEnumerableFactory.cs
index 9b11e788..fa8ee9ba 100644
--- a/src/Atc/Factories/AsyncEnumerableFactory.cs
+++ b/src/Atc/Factories/AsyncEnumerableFactory.cs
@@ -10,10 +10,18 @@ public static class AsyncEnumerableFactory
     /// </summary>
     /// <typeparam name="T">The type of the elements in the sequence.</typeparam>
     /// <returns>An empty <see cref="IAsyncEnumerable{T}"/>.</returns>
-    public static async IAsyncEnumerable<T> Empty<T>()
+    public static IAsyncEnumerable<T> Empty<T>()
+        => EmptyAsyncEnumerable<T>.Instance;
+
+    private static class EmptyAsyncEnumerable<T>
     {
-        await Task.CompletedTask;
-        yield break;
+        internal static readonly IAsyncEnumerable<T> Instance = CreateEmpty();
+
+        private static async IAsyncEnumerable<T> CreateEmpty()
+        {
+            await Task.CompletedTask.ConfigureAwait(false);
+            yield break;
+        }
     }
 
     /// <summary>

From 224c2bc4051a1c6239203a05d2654d0424b9959a Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sun, 21 Jun 2026 01:41:13 +0200
Subject: [PATCH 038/100] fix(atc-openapi): use InvariantCulture and Ordinal
 comparisons in response extensions

Replaces CurrentCulture with InvariantCulture for culture-independent number
formatting and switches OrdinalIgnoreCase to Ordinal for HTTP status code
string comparisons that must be exact.
---
 src/Atc.OpenApi/Extensions/OpenApiResponsesExtensions.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Atc.OpenApi/Extensions/OpenApiResponsesExtensions.cs b/src/Atc.OpenApi/Extensions/OpenApiResponsesExtensions.cs
index 53e9b30b..73c97271 100644
--- a/src/Atc.OpenApi/Extensions/OpenApiResponsesExtensions.cs
+++ b/src/Atc.OpenApi/Extensions/OpenApiResponsesExtensions.cs
@@ -242,7 +242,7 @@ public static bool IsSchemaUsingBinaryFormatForOkResponse(
     {
         foreach (var (key, value) in responses.OrderBy(x => x.Key, StringComparer.Ordinal))
         {
-            if (!key.Equals(((int)HttpStatusCode.OK).ToString(CultureInfo.CurrentCulture), StringComparison.OrdinalIgnoreCase))
+            if (!key.Equals(((int)HttpStatusCode.OK).ToString(CultureInfo.InvariantCulture), StringComparison.Ordinal))
             {
                 continue;
             }

From 4c9fe6cf6edbb520cc4a27bdece2c4713f296d31 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sun, 21 Jun 2026 01:41:25 +0200
Subject: [PATCH 039/100] fix(atc-rest-healthchecks): handle duplicate health
 check names in ToDictionary

GroupBy before ToDictionary prevents ArgumentException when multiple health
checks share the same name, taking the first registration in each group.
---
 .../ResourceHealthCheckExtensions.cs          | 24 ++++++++++++-------
 1 file changed, 15 insertions(+), 9 deletions(-)

diff --git a/src/Atc.Rest.HealthChecks/Extensions/ResourceHealthCheckExtensions.cs b/src/Atc.Rest.HealthChecks/Extensions/ResourceHealthCheckExtensions.cs
index e6d17396..757db6a8 100644
--- a/src/Atc.Rest.HealthChecks/Extensions/ResourceHealthCheckExtensions.cs
+++ b/src/Atc.Rest.HealthChecks/Extensions/ResourceHealthCheckExtensions.cs
@@ -12,13 +12,19 @@ public static class ResourceHealthCheckExtensions
     /// <returns>A read-only dictionary where keys are resource names and values are anonymous objects containing status, duration, and description.</returns>
     public static IReadOnlyDictionary<string, object> ToIReadOnlyDictionary(
         this IEnumerable<ResourceHealthCheck> resourceHealthCheck)
-        => resourceHealthCheck.ToDictionary(
-            keySelector: key => key.Name,
-            elementSelector: e => (object)new
-            {
-                e.Status,
-                e.Duration,
-                e.Description,
-            },
-            StringComparer.Ordinal);
+        => resourceHealthCheck
+            .GroupBy(e => e.Name, StringComparer.Ordinal)
+            .ToDictionary(
+                g => g.Key,
+                g =>
+                {
+                    var e = g.First();
+                    return (object)new
+                    {
+                        e.Status,
+                        e.Duration,
+                        e.Description,
+                    };
+                },
+                StringComparer.Ordinal);
 }
\ No newline at end of file

From 6f78906ffd30f7604ec4af895ea3f345c6cf9747 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sun, 21 Jun 2026 01:41:31 +0200
Subject: [PATCH 040/100] fix(atc-xunit): use Path.GetTempPath() and suppress
 analyzer exception propagation

CodeComplianceTestHelper replaces the hard-coded C:\Temp path with
Path.GetTempPath() for cross-environment compatibility. AnalyzerHelper
returns false instead of throwing Exception when a Roslyn analysis
step fails, keeping test runs stable.
---
 src/Atc.XUnit/CodeComplianceTestHelper.cs                   | 2 +-
 src/Atc.XUnit/Internal/AbstractSyntaxTree/AnalyzerHelper.cs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Atc.XUnit/CodeComplianceTestHelper.cs b/src/Atc.XUnit/CodeComplianceTestHelper.cs
index 1b2f85f0..f14f5b14 100644
--- a/src/Atc.XUnit/CodeComplianceTestHelper.cs
+++ b/src/Atc.XUnit/CodeComplianceTestHelper.cs
@@ -308,7 +308,7 @@ public static void CollectExportedMethodsWithMissingTestsToExcel(
 
         CollectExportedMethodsWithMissingTestsToExcel(
             decompilerType,
-            new DirectoryInfo(@"C:\Temp"),
+            new DirectoryInfo(Path.GetTempPath()),
             sourceAssembly,
             testAssembly,
             excludeSourceTypes);
diff --git a/src/Atc.XUnit/Internal/AbstractSyntaxTree/AnalyzerHelper.cs b/src/Atc.XUnit/Internal/AbstractSyntaxTree/AnalyzerHelper.cs
index ddd8e06d..fbac386b 100644
--- a/src/Atc.XUnit/Internal/AbstractSyntaxTree/AnalyzerHelper.cs
+++ b/src/Atc.XUnit/Internal/AbstractSyntaxTree/AnalyzerHelper.cs
@@ -148,7 +148,7 @@ private static bool IsMethodUsedByTestMethod(
     {
         if (method.DeclaringType is null)
         {
-            throw new Exception("method.DeclaringType is null...");
+            return false;
         }
 
         var parameters = method.GetParameters();

From 9b4f135194a8fd1e3e09e460428dc964502d667a Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Sun, 21 Jun 2026 01:41:36 +0200
Subject: [PATCH 041/100] fix(atc-codedoc): fall back to
 AppDomain.BaseDirectory when assembly location is unavailable

GetXmlFileForAssembly now first tries the directory of assembly.Location and
falls back to AppDomain.CurrentDomain.BaseDirectory, supporting single-file
publish scenarios and test runners where the assembly location may differ from
the XML doc output directory.
---
 docs/CodeDoc/Atc/Atc.md                            |  2 +-
 src/Atc.CodeDocumentation/AssemblyCommentHelper.cs | 12 +++++++++++-
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/docs/CodeDoc/Atc/Atc.md b/docs/CodeDoc/Atc/Atc.md
index 6f43c0b9..a7a6b770 100644
--- a/docs/CodeDoc/Atc/Atc.md
+++ b/docs/CodeDoc/Atc/Atc.md
@@ -1216,7 +1216,7 @@ Provides custom string formatting based on specified case formatting options.<br
 >```csharp
 >StringCaseFormatter Default
 >```
-><b>Summary:</b> Static `Atc.StringCaseFormatter` using `System.Globalization.CultureInfo.CurrentCulture`.
+><b>Summary:</b> Static `Atc.StringCaseFormatter` using `System.Globalization.CultureInfo.InvariantCulture`.
 ### Static Methods
 
 #### Format
diff --git a/src/Atc.CodeDocumentation/AssemblyCommentHelper.cs b/src/Atc.CodeDocumentation/AssemblyCommentHelper.cs
index 7b4a85ed..9ca587fa 100644
--- a/src/Atc.CodeDocumentation/AssemblyCommentHelper.cs
+++ b/src/Atc.CodeDocumentation/AssemblyCommentHelper.cs
@@ -85,12 +85,22 @@ public static string GetTypesAsRenderText(
 
     private static FileInfo GetXmlFileForAssembly(Assembly assembly)
     {
-        var xmlFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, assembly.GetName().Name + ".xml");
+        var assemblyDir = string.IsNullOrEmpty(assembly.Location)
+            ? AppDomain.CurrentDomain.BaseDirectory
+            : Path.GetDirectoryName(assembly.Location) ?? AppDomain.CurrentDomain.BaseDirectory;
+
+        var xmlFile = Path.Combine(assemblyDir, assembly.GetName().Name + ".xml");
         if (File.Exists(xmlFile))
         {
             return new FileInfo(xmlFile);
         }
 
+        var fallback = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, assembly.GetName().Name + ".xml");
+        if (File.Exists(fallback))
+        {
+            return new FileInfo(fallback);
+        }
+
         throw new IOException($"No xml document found for the assembly: {assembly.FullName}, expected file: {xmlFile}");
     }
 

From 5f5c7258a82e5f81502ae37fdb8b2099ac613e59 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 02:10:46 +0200
Subject: [PATCH 042/100] chore: add suggestions/ to .gitignore

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 2c9ba24d..a24efce5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -351,3 +351,4 @@ MigrationBackup/
 /src/Atc.Rest.ApiGenerator.CLI/Properties/launchSettings.json
 .idea
 .claude/settings.local.json
+suggestions/

From 697e26f552ca74b8c6f588c26eab116e2bdca55b Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 02:25:41 +0200
Subject: [PATCH 043/100] =?UTF-8?q?fix(atc):=20modernize=20Thread.CurrentT?=
 =?UTF-8?q?hread.CurrentUICulture=20to=20CultureInfo.Current*=20(=C2=A72.1?=
 =?UTF-8?q?)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Calendar week helpers (GetWeekNumber, GetNumberOfWeeksByYear, GetDateOfFirstDayInWeek)
now use CurrentCulture — week numbering follows the user's regional settings, not
the display language. String-formatting helpers named *UsingCurrentUiCulture correctly
stay on CultureInfo.CurrentUICulture. All Thread.CurrentThread.* refs replaced with
the CultureInfo property form preferred in .NET 5+.
---
 .../Extensions/BaseTypes/DateTimeExtensions.cs   | 10 +++++-----
 .../BaseTypes/DateTimeOffsetExtensions.cs        | 10 +++++-----
 .../Extensions/BaseTypes/IntegerExtensions.cs    |  8 ++++----
 src/Atc/Helpers/DateTimeHelper.cs                |  8 ++++----
 src/Atc/Helpers/DateTimeOffsetHelper.cs          | 16 ++++++++--------
 5 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/src/Atc/Extensions/BaseTypes/DateTimeExtensions.cs b/src/Atc/Extensions/BaseTypes/DateTimeExtensions.cs
index feaae93c..ace88555 100644
--- a/src/Atc/Extensions/BaseTypes/DateTimeExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/DateTimeExtensions.cs
@@ -53,7 +53,7 @@ public static string GetPrettyTimeDiff(
     /// <param name="date">The date.</param>
     /// <returns>The week number from the given date.</returns>
     public static int GetWeekNumber(this DateTime date)
-        => CultureInfo.CurrentUICulture.Calendar.GetWeekOfYear(date, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
+        => CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(date, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
 
     /// <summary>
     /// Find the diff between to DateTimes.
@@ -121,7 +121,7 @@ public static string ToIso8601UtcDate(this DateTime dateTime)
     /// long date pattern of the current UI culture.</returns>
     public static string ToLongDateStringUsingCurrentUiCulture(
         this DateTime dateTime)
-        => dateTime.ToLongDateString(Thread.CurrentThread.CurrentUICulture.DateTimeFormat);
+        => dateTime.ToLongDateString(CultureInfo.CurrentUICulture.DateTimeFormat);
 
     /// <summary>
     /// Converts a DateTime to a string using the long date pattern of a specific culture.
@@ -174,7 +174,7 @@ public static string ToLongDateString(
     /// long time pattern of the current UI culture.</returns>
     public static string ToLongTimeStringUsingCurrentUiCulture(
         this DateTime dateTime)
-        => dateTime.ToLongTimeString(Thread.CurrentThread.CurrentUICulture.DateTimeFormat);
+        => dateTime.ToLongTimeString(CultureInfo.CurrentUICulture.DateTimeFormat);
 
     /// <summary>
     /// Converts a DateTime to a string using the long time pattern of a specific culture.
@@ -226,7 +226,7 @@ public static string ToLongTimeString(
     /// short date pattern of the current UI culture.</returns>
     public static string ToShortDateStringUsingCurrentUiCulture(
         this DateTime dateTime)
-        => dateTime.ToShortDateString(Thread.CurrentThread.CurrentUICulture.DateTimeFormat);
+        => dateTime.ToShortDateString(CultureInfo.CurrentUICulture.DateTimeFormat);
 
     /// <summary>
     /// Converts a DateTime to a string using the short date pattern of a specific culture.
@@ -278,7 +278,7 @@ public static string ToShortDateString(
     /// short time pattern of the current UI culture.</returns>
     public static string ToShortTimeStringUsingCurrentUiCulture(
         this DateTime dateTime)
-        => dateTime.ToShortTimeString(Thread.CurrentThread.CurrentUICulture.DateTimeFormat);
+        => dateTime.ToShortTimeString(CultureInfo.CurrentUICulture.DateTimeFormat);
 
     /// <summary>
     /// Converts a DateTime to a string using the short time pattern of a specific culture.
diff --git a/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs b/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs
index 02bd5e29..1baddf16 100644
--- a/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs
@@ -53,7 +53,7 @@ public static string GetPrettyTimeDiff(
     /// <param name="date">The date.</param>
     /// <returns>The week number from the given date.</returns>
     public static int GetWeekNumber(this DateTimeOffset date)
-        => CultureInfo.CurrentUICulture.Calendar.GetWeekOfYear(date.DateTime, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
+        => CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(date.DateTime, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
 
     /// <summary>
     /// Find the diff between to DateTimes.
@@ -165,7 +165,7 @@ public static string ToIso8601UtcDate(this DateTimeOffset dateTimeOffset)
     /// long date pattern of the current UI culture.</returns>
     public static string ToLongDateStringUsingCurrentUiCulture(
         this DateTimeOffset dateTimeOffset)
-        => dateTimeOffset.ToLongDateString(Thread.CurrentThread.CurrentUICulture.DateTimeFormat);
+        => dateTimeOffset.ToLongDateString(CultureInfo.CurrentUICulture.DateTimeFormat);
 
     /// <summary>
     /// Converts a DateTime to a string using the long date pattern of the provided DateTimeFormatInfo.
@@ -199,7 +199,7 @@ public static string ToLongDateString(
     /// long time pattern of the current UI culture.</returns>
     public static string ToLongTimeStringUsingCurrentUiCulture(
         this DateTimeOffset dateTimeOffset)
-        => dateTimeOffset.ToLongTimeString(Thread.CurrentThread.CurrentUICulture.DateTimeFormat);
+        => dateTimeOffset.ToLongTimeString(CultureInfo.CurrentUICulture.DateTimeFormat);
 
     /// <summary>
     /// Converts a DateTime to a string using the long time pattern of the provided DateTimeFormatInfo.
@@ -232,7 +232,7 @@ public static string ToLongTimeString(
     /// short date pattern of the current UI culture.</returns>
     public static string ToShortDateStringUsingCurrentUiCulture(
         this DateTimeOffset dateTimeOffset)
-        => dateTimeOffset.ToShortDateString(Thread.CurrentThread.CurrentUICulture.DateTimeFormat);
+        => dateTimeOffset.ToShortDateString(CultureInfo.CurrentUICulture.DateTimeFormat);
 
     /// <summary>
     /// Converts a DateTime to a string using the short date pattern of the provided DateTimeFormatInfo.
@@ -265,7 +265,7 @@ public static string ToShortDateString(
     /// short time pattern of the current UI culture.</returns>
     public static string ToShortTimeStringUsingCurrentUiCulture(
         this DateTimeOffset dateTimeOffset)
-        => dateTimeOffset.ToShortTimeString(Thread.CurrentThread.CurrentUICulture.DateTimeFormat);
+        => dateTimeOffset.ToShortTimeString(CultureInfo.CurrentUICulture.DateTimeFormat);
 
     /// <summary>
     /// Converts a DateTime to a string using the short time pattern of the provided DateTimeFormatInfo.
diff --git a/src/Atc/Extensions/BaseTypes/IntegerExtensions.cs b/src/Atc/Extensions/BaseTypes/IntegerExtensions.cs
index 44b2f0d8..43997542 100644
--- a/src/Atc/Extensions/BaseTypes/IntegerExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/IntegerExtensions.cs
@@ -111,7 +111,7 @@ public static string GetMonthNameByMonthNumber(
         var time = timeBegin.AddMonths(month - 1);
 
         // ReSharper disable once StringLiteralTypo
-        var str = time.ToString("MMMM", Thread.CurrentThread.CurrentUICulture);
+        var str = time.ToString("MMMM", CultureInfo.CurrentUICulture);
         if (str.Length <= 0)
         {
             return string.Empty;
@@ -128,7 +128,7 @@ public static string GetMonthNameByMonthNumber(
     /// <param name="year">The year.</param>
     /// <returns>The get number of weeks.</returns>
     public static int GetNumberOfWeeksByYear(this int year)
-        => CultureInfo.CurrentUICulture.Calendar.GetWeekOfYear(new DateTime(year, 12, 28), CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
+        => CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(new DateTime(year, 12, 28), CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
 
     /// <summary>
     /// Get the date of the first day in the given year and week number.
@@ -140,12 +140,12 @@ public static DateTime GetFirstDayOfWeekNumberByYear(
         this int year,
         int weekNumber)
     {
-        var calendar = CultureInfo.CurrentUICulture.Calendar;
+        var calendar = CultureInfo.CurrentCulture.Calendar;
         var firstOfYear = new DateTime(year, 1, 1, calendar);
         var daysOffset = DayOfWeek.Thursday - firstOfYear.DayOfWeek;
 
         var firstThursday = firstOfYear.AddDays(daysOffset);
-        var firstWeek = CultureInfo.CurrentUICulture.Calendar.GetWeekOfYear(firstThursday, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
+        var firstWeek = CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(firstThursday, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
 
         var weekNum = weekNumber;
         if (firstWeek <= 1)
diff --git a/src/Atc/Helpers/DateTimeHelper.cs b/src/Atc/Helpers/DateTimeHelper.cs
index c5c03278..d181d228 100644
--- a/src/Atc/Helpers/DateTimeHelper.cs
+++ b/src/Atc/Helpers/DateTimeHelper.cs
@@ -26,7 +26,7 @@ public static bool TryParseUsingCurrentUiCulture(
         out DateTime result)
     {
         result = default;
-        if (!TryParseUsingSpecificCulture(value, Thread.CurrentThread.CurrentUICulture, out var res))
+        if (!TryParseUsingSpecificCulture(value, CultureInfo.CurrentUICulture, out var res))
         {
             return false;
         }
@@ -94,7 +94,7 @@ public static bool TryParseShortDateUsingCurrentUiCulture(
         out DateTime result)
     {
         result = default;
-        if (!TryParseShortDateUsingSpecificCulture(value, Thread.CurrentThread.CurrentUICulture, out var res))
+        if (!TryParseShortDateUsingSpecificCulture(value, CultureInfo.CurrentUICulture, out var res))
         {
             return false;
         }
@@ -162,7 +162,7 @@ public static bool TryParseShortTimeUsingCurrentUiCulture(
         out DateTime result)
     {
         result = default;
-        if (!TryParseShortTimeUsingSpecificCulture(value, Thread.CurrentThread.CurrentUICulture, out var res))
+        if (!TryParseShortTimeUsingSpecificCulture(value, CultureInfo.CurrentUICulture, out var res))
         {
             return false;
         }
@@ -237,7 +237,7 @@ public static bool TryParseShortTimeUsingCurrentUiCultureUtc(
         out DateTime result)
     {
         result = default;
-        if (!TryParseShortTimeUsingSpecificCultureUtc(value, Thread.CurrentThread.CurrentUICulture, out var res))
+        if (!TryParseShortTimeUsingSpecificCultureUtc(value, CultureInfo.CurrentUICulture, out var res))
         {
             return false;
         }
diff --git a/src/Atc/Helpers/DateTimeOffsetHelper.cs b/src/Atc/Helpers/DateTimeOffsetHelper.cs
index 90a6fc31..94590fd7 100644
--- a/src/Atc/Helpers/DateTimeOffsetHelper.cs
+++ b/src/Atc/Helpers/DateTimeOffsetHelper.cs
@@ -34,7 +34,7 @@ public static bool TryParseUsingCurrentUiCulture(
 
         if (!DateTimeOffset.TryParse(
                 value,
-                Thread.CurrentThread.CurrentUICulture.DateTimeFormat,
+                CultureInfo.CurrentUICulture.DateTimeFormat,
                 DateTimeStyles.None,
                 out var res))
         {
@@ -70,7 +70,7 @@ public static bool TryParseShortDateUsingCurrentUiCulture(
 
         if (!DateTimeOffset.TryParse(
                 value,
-                Thread.CurrentThread.CurrentUICulture.DateTimeFormat,
+                CultureInfo.CurrentUICulture.DateTimeFormat,
                 DateTimeStyles.None,
                 out var res))
         {
@@ -99,8 +99,8 @@ public static bool TryParseShortTimeUsingCurrentUiCulture(
     {
         result = default;
 
-        var use24Hours = !(Thread.CurrentThread.CurrentUICulture.DateTimeFormat.ShortTimePattern.StartsWith("h:", StringComparison.Ordinal) ||
-                           Thread.CurrentThread.CurrentUICulture.DateTimeFormat.ShortTimePattern.StartsWith("h.", StringComparison.Ordinal));
+        var use24Hours = !(CultureInfo.CurrentUICulture.DateTimeFormat.ShortTimePattern.StartsWith("h:", StringComparison.Ordinal) ||
+                           CultureInfo.CurrentUICulture.DateTimeFormat.ShortTimePattern.StartsWith("h.", StringComparison.Ordinal));
 
         var maxLength = use24Hours ? MaxTimeLengthFor24Hours : MaxTimeLengthFor12Hours;
 
@@ -113,7 +113,7 @@ public static bool TryParseShortTimeUsingCurrentUiCulture(
         var dateTimeOffsetValue = $"{DateTimeOffset.Now.ToShortDateStringUsingCurrentUiCulture()} {value}";
         if (!DateTimeOffset.TryParse(
                 dateTimeOffsetValue,
-                Thread.CurrentThread.CurrentUICulture.DateTimeFormat,
+                CultureInfo.CurrentUICulture.DateTimeFormat,
                 DateTimeStyles.None,
                 out var res))
         {
@@ -142,8 +142,8 @@ public static bool TryParseShortTimeUsingCurrentUiCultureUtc(
     {
         result = default;
 
-        var use24Hours = !(Thread.CurrentThread.CurrentUICulture.DateTimeFormat.ShortTimePattern.StartsWith("h:", StringComparison.Ordinal) ||
-                           Thread.CurrentThread.CurrentUICulture.DateTimeFormat.ShortTimePattern.StartsWith("h.", StringComparison.Ordinal));
+        var use24Hours = !(CultureInfo.CurrentUICulture.DateTimeFormat.ShortTimePattern.StartsWith("h:", StringComparison.Ordinal) ||
+                           CultureInfo.CurrentUICulture.DateTimeFormat.ShortTimePattern.StartsWith("h.", StringComparison.Ordinal));
 
         var maxLength = use24Hours ? MaxTimeLengthFor24Hours : MaxTimeLengthFor12Hours;
 
@@ -156,7 +156,7 @@ public static bool TryParseShortTimeUsingCurrentUiCultureUtc(
         var dateTimeOffsetValue = $"{DateTimeOffset.UtcNow.ToShortDateStringUsingCurrentUiCulture()} {value}";
         if (!DateTimeOffset.TryParse(
                 dateTimeOffsetValue,
-                Thread.CurrentThread.CurrentUICulture.DateTimeFormat,
+                CultureInfo.CurrentUICulture.DateTimeFormat,
                 DateTimeStyles.None,
                 out var res))
         {

From 46fa4a9b32c76c0044561efa034fa2cdda40ef6e Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 02:25:51 +0200
Subject: [PATCH 044/100] fix(atc): misc bug fixes and non-breaking
 improvements

- DecimalExtensions: remove dead Replace(',','.') under InvariantCulture
- ProcessExtensions: delegate WaitForExitAsync to BCL on NET5_0_OR_GREATER
- ArticleNumberHelper: migrate Lazy<Regex> to [GeneratedRegex] on NET7_0_OR_GREATER
- InterfaceJsonConverter: deserialize JsonElement directly, avoiding GetRawText() round-trip
- TypeDiscriminatorJsonConverter: cache per-base-type assembly scan in ConcurrentDictionary;
  handle ReflectionTypeLoadException gracefully
- Point2D/Point3D.IsDefault: use exact == 0.0 to match record struct == semantics
  (IsEqual(0) was also exact equality since it uses double.Epsilon as tolerance)
- Fix MemoryStreamExtensionsTests to call extension method explicitly
---
 .../Extensions/BaseTypes/DecimalExtensions.cs | 10 ++---
 src/Atc/Extensions/ProcessExtensions.cs       | 16 +++++++-
 src/Atc/Helpers/ArticleNumberHelper.cs        | 22 +++++++---
 .../JsonConverters/InterfaceJsonConverter.cs  | 10 +++--
 .../TypeDiscriminatorJsonConverter.cs         | 41 +++++++++++++++----
 src/Atc/Structs/Point2D.cs                    |  5 ++-
 src/Atc/Structs/Point3D.cs                    |  5 ++-
 .../Extensions/MemoryStreamExtensionsTests.cs |  4 +-
 test/Atc.Tests/Structs/Point2DTests.cs        | 17 ++++++++
 test/Atc.Tests/Structs/Point3DTests.cs        |  7 ++++
 10 files changed, 104 insertions(+), 33 deletions(-)

diff --git a/src/Atc/Extensions/BaseTypes/DecimalExtensions.cs b/src/Atc/Extensions/BaseTypes/DecimalExtensions.cs
index c92bae6f..61741dfe 100644
--- a/src/Atc/Extensions/BaseTypes/DecimalExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/DecimalExtensions.cs
@@ -51,13 +51,9 @@ public static bool IsEqual(
         decimal b,
         int decimalPrecision)
     {
-        var sa = a
-            .ToString(CultureInfo.InvariantCulture)
-            .Replace(',', '.');
-
-        var sb = b
-            .ToString(CultureInfo.InvariantCulture)
-            .Replace(',', '.');
+        // InvariantCulture always uses '.' as decimal separator — no Replace needed.
+        var sa = a.ToString(CultureInfo.InvariantCulture);
+        var sb = b.ToString(CultureInfo.InvariantCulture);
 
         var saa = sa.Split('.');
         var sab = sb.Split('.');
diff --git a/src/Atc/Extensions/ProcessExtensions.cs b/src/Atc/Extensions/ProcessExtensions.cs
index ea4fba95..499fb8c4 100644
--- a/src/Atc/Extensions/ProcessExtensions.cs
+++ b/src/Atc/Extensions/ProcessExtensions.cs
@@ -11,8 +11,7 @@ public static class ProcessExtensions
 {
     private static readonly TimeSpan DefaultKillTimeout = TimeSpan.FromSeconds(30);
 
-    [SuppressMessage("Major Code Smell", "S4457:Parameter validation in \"async\"/\"await\" methods should be wrapped", Justification = "OK.")]
-    public static async Task WaitForExitAsync(
+    public static Task WaitForExitAsync(
         this Process process,
         CancellationToken cancellationToken = default)
     {
@@ -21,6 +20,18 @@ public static async Task WaitForExitAsync(
             throw new ArgumentNullException(nameof(process));
         }
 
+#if NET5_0_OR_GREATER
+        return process.WaitForExitAsync(cancellationToken);
+#else
+        return WaitForExitAsyncCore(process, cancellationToken);
+#endif
+    }
+
+#if !NET5_0_OR_GREATER
+    private static async Task WaitForExitAsyncCore(
+        Process process,
+        CancellationToken cancellationToken)
+    {
         var tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
 
         void ProcessExited(
@@ -54,6 +65,7 @@ void ProcessExited(
             process.Exited -= ProcessExited;
         }
     }
+#endif
 
     /// <summary>
     /// Synchronously terminates the process and any child processes it started, using a default
diff --git a/src/Atc/Helpers/ArticleNumberHelper.cs b/src/Atc/Helpers/ArticleNumberHelper.cs
index ac8945b0..bc018c75 100644
--- a/src/Atc/Helpers/ArticleNumberHelper.cs
+++ b/src/Atc/Helpers/ArticleNumberHelper.cs
@@ -6,16 +6,28 @@ namespace Atc.Helpers;
 /// <remarks>
 /// https://en.wikipedia.org/wiki/International_Article_Number.
 /// </remarks>
-public static class ArticleNumberHelper
+public static partial class ArticleNumberHelper
 {
-    private static readonly Lazy<Regex> AsinRegex = new(
+#if NET7_0_OR_GREATER
+    [GeneratedRegex(@"^B\d{2}\w{7}|\d{9}(X|\d)$", RegexOptions.None, matchTimeoutMilliseconds: 250)]
+    private static partial Regex GetAsinRegex();
+
+    [GeneratedRegex(@"^\d{4}-\d{3}[\dxX]{1}$", RegexOptions.None, matchTimeoutMilliseconds: 250)]
+    private static partial Regex GetIssnRegex();
+#else
+    private static readonly Lazy<Regex> AsinRegexLazy = new(
         () => new Regex(@"^B\d{2}\w{7}|\d{9}(X|\d)$", RegexOptions.Compiled, TimeSpan.FromMilliseconds(250)),
         LazyThreadSafetyMode.ExecutionAndPublication);
 
-    private static readonly Lazy<Regex> IssnRegex = new(
+    private static readonly Lazy<Regex> IssnRegexLazy = new(
         () => new Regex(@"^\d{4}-\d{3}[\dxX]{1}$", RegexOptions.Compiled, TimeSpan.FromMilliseconds(250)),
         LazyThreadSafetyMode.ExecutionAndPublication);
 
+    private static Regex GetAsinRegex() => AsinRegexLazy.Value;
+
+    private static Regex GetIssnRegex() => IssnRegexLazy.Value;
+#endif
+
     /// <summary>
     /// Get ArticleNumberType.
     /// </summary>
@@ -70,7 +82,7 @@ public static bool IsValidAsin(string asin)
             return false;
         }
 
-        return AsinRegex.Value.IsMatch(asin);
+        return GetAsinRegex().IsMatch(asin);
     }
 
     /// <summary>
@@ -190,7 +202,7 @@ public static bool IsValidIssn(string code)
             return false;
         }
 
-        return IssnRegex.Value.IsMatch(code);
+        return GetIssnRegex().IsMatch(code);
     }
 
     /// <summary>
diff --git a/src/Atc/Serialization/JsonConverters/InterfaceJsonConverter.cs b/src/Atc/Serialization/JsonConverters/InterfaceJsonConverter.cs
index 175ff1ab..53ac8811 100644
--- a/src/Atc/Serialization/JsonConverters/InterfaceJsonConverter.cs
+++ b/src/Atc/Serialization/JsonConverters/InterfaceJsonConverter.cs
@@ -46,16 +46,18 @@ public override TInterface Read(
         using var document = JsonDocument.ParseValue(ref reader);
         var jsonObject = document.RootElement;
 
-        // Create a new JsonSerializerOptions without this converter
+        // Deserialize the already-parsed JsonElement directly, avoiding an unnecessary re-serialise
+        // to string.  We still need options without this converter to prevent infinite recursion, but
+        // we create a minimal copy (clone of converters minus ourselves) rather than a full options
+        // clone to avoid per-call allocations.
         var modifiedOptions = new JsonSerializerOptions(options);
         var converterToRemove = modifiedOptions.Converters.FirstOrDefault(c => c is InterfaceJsonConverter<TInterface>);
-        if (converterToRemove != null)
+        if (converterToRemove is not null)
         {
             modifiedOptions.Converters.Remove(converterToRemove);
         }
 
-        // Deserialize using the provided concrete type
-        return (TInterface)JsonSerializer.Deserialize(jsonObject.GetRawText(), typeToConvert, modifiedOptions)!;
+        return (TInterface)JsonSerializer.Deserialize(jsonObject, typeToConvert, modifiedOptions)!;
     }
 
     /// <inheritdoc />
diff --git a/src/Atc/Serialization/JsonConverters/TypeDiscriminatorJsonConverter.cs b/src/Atc/Serialization/JsonConverters/TypeDiscriminatorJsonConverter.cs
index 796e31ba..db3904ba 100644
--- a/src/Atc/Serialization/JsonConverters/TypeDiscriminatorJsonConverter.cs
+++ b/src/Atc/Serialization/JsonConverters/TypeDiscriminatorJsonConverter.cs
@@ -13,24 +13,47 @@ namespace Atc.Serialization.JsonConverters;
 public sealed class TypeDiscriminatorJsonConverter<T> : JsonConverter<T>
     where T : ITypeDiscriminator
 {
-    private readonly IEnumerable<Type> types;
+    // Cached per base-type so that multiple converter instances share the same scan result.
+    private static readonly ConcurrentDictionary<Type, IReadOnlyList<Type>> TypeCache = new();
+
+    private readonly IReadOnlyList<Type> types;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="TypeDiscriminatorJsonConverter{T}"/> class.
     /// </summary>
     /// <remarks>
     /// This constructor scans all loaded assemblies in the current <see cref="AppDomain"/> to find all
-    /// concrete (non-abstract) class types that implement <typeparamref name="T"/>.
+    /// concrete (non-abstract) class types that implement <typeparamref name="T"/>. The result is cached
+    /// per base type so subsequent instances do not re-scan.
     /// </remarks>
     public TypeDiscriminatorJsonConverter()
     {
-        var type = typeof(T);
-        types = AppDomain
-            .CurrentDomain
-            .GetAssemblies()
-            .SelectMany(s => s.GetTypes())
-            .Where(p => type.IsAssignableFrom(p) && p.IsClass && !p.IsAbstract)
-            .ToList();
+        types = TypeCache.GetOrAdd(typeof(T), static baseType =>
+        {
+            var found = new List<Type>();
+            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                IEnumerable<Type> assemblyTypes;
+                try
+                {
+                    assemblyTypes = assembly.GetTypes();
+                }
+                catch (ReflectionTypeLoadException ex)
+                {
+                    assemblyTypes = ex.Types.Where(t => t is not null)!;
+                }
+
+                foreach (var t in assemblyTypes)
+                {
+                    if (baseType.IsAssignableFrom(t) && t.IsClass && !t.IsAbstract)
+                    {
+                        found.Add(t);
+                    }
+                }
+            }
+
+            return found.AsReadOnly();
+        });
     }
 
     /// <inheritdoc />
diff --git a/src/Atc/Structs/Point2D.cs b/src/Atc/Structs/Point2D.cs
index 8da9c1cf..f6107f0a 100644
--- a/src/Atc/Structs/Point2D.cs
+++ b/src/Atc/Structs/Point2D.cs
@@ -14,9 +14,10 @@ public record struct Point2D(
     /// Gets a value indicating whether this instance represents the default (origin) position at coordinates (0, 0).
     /// </summary>
     /// <value>
-    ///   <see langword="true" /> if both X and Y are approximately zero; otherwise, <see langword="false" />.
+    ///   <see langword="true" /> if both X and Y are exactly zero; otherwise, <see langword="false" />.
     /// </value>
-    public readonly bool IsDefault => X.IsEqual(0) && Y.IsEqual(0);
+    [SuppressMessage("SonarAnalyzer.CSharp", "S1244:Do not check floating point equality with exact values, use a range instead", Justification = "Intentional: IsDefault checks for exact binary zero, not approximate equality.")]
+    public readonly bool IsDefault => X == 0.0 && Y == 0.0;
 
     /// <inheritdoc />
     public override readonly string ToString()
diff --git a/src/Atc/Structs/Point3D.cs b/src/Atc/Structs/Point3D.cs
index 74ed9271..3843fca8 100644
--- a/src/Atc/Structs/Point3D.cs
+++ b/src/Atc/Structs/Point3D.cs
@@ -15,10 +15,11 @@ public record struct Point3D(
     /// Gets a value indicating whether this instance represents the default (origin) position at coordinates (0, 0, 0).
     /// </summary>
     /// <value>
-    ///   <see langword="true" /> if X, Y, and Z are all approximately zero; otherwise, <see langword="false" />.
+    ///   <see langword="true" /> if X, Y, and Z are all exactly zero; otherwise, <see langword="false" />.
     /// </value>
+    [SuppressMessage("SonarAnalyzer.CSharp", "S1244:Do not check floating point equality with exact values, use a range instead", Justification = "Intentional: IsDefault checks for exact binary zero, not approximate equality.")]
     public readonly bool IsDefault
-        => X.IsEqual(0) && Y.IsEqual(0) && Z.IsEqual(0);
+        => X == 0.0 && Y == 0.0 && Z == 0.0;
 
     /// <inheritdoc />
     public override readonly string ToString()
diff --git a/test/Atc.Tests/Extensions/MemoryStreamExtensionsTests.cs b/test/Atc.Tests/Extensions/MemoryStreamExtensionsTests.cs
index 3fcb955d..1307bab3 100644
--- a/test/Atc.Tests/Extensions/MemoryStreamExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/MemoryStreamExtensionsTests.cs
@@ -22,8 +22,8 @@ public void ToString_DefaultEncoding_IsUtf8()
         var bytes = Encoding.UTF8.GetBytes("Héllo");
         using var input = new MemoryStream(bytes);
 
-        // Act — no encoding argument; must default to UTF-8, not UTF-16
-        var actual = input.ToString();
+        // Act — call the extension explicitly; object.ToString() shadows a no-arg extension call.
+        var actual = MemoryStreamExtensions.ToString(input);
 
         // Assert
         Assert.Equal("Héllo", actual);
diff --git a/test/Atc.Tests/Structs/Point2DTests.cs b/test/Atc.Tests/Structs/Point2DTests.cs
index a31c59eb..2b1b59a9 100644
--- a/test/Atc.Tests/Structs/Point2DTests.cs
+++ b/test/Atc.Tests/Structs/Point2DTests.cs
@@ -22,6 +22,23 @@ public void IsDefault(
         Assert.Equal(expected, actual);
     }
 
+    [Fact]
+    public void IsDefault_WithTinyNonZeroX_ReturnsFalse()
+    {
+        // Arrange — double.Epsilon is the smallest positive double; approximate IsEqual would pass it as zero
+        var input = new Point2D(double.Epsilon, 0);
+
+        // Act / Assert
+        Assert.False(input.IsDefault);
+    }
+
+    [Fact]
+    public void IsDefault_WithTinyNonZeroY_ReturnsFalse()
+    {
+        var input = new Point2D(0, double.Epsilon);
+        Assert.False(input.IsDefault);
+    }
+
     [Theory]
     [InlineData("0, 0", 0, 0)]
     [InlineData("1, 0", 1, 0)]
diff --git a/test/Atc.Tests/Structs/Point3DTests.cs b/test/Atc.Tests/Structs/Point3DTests.cs
index d8989050..1372d817 100644
--- a/test/Atc.Tests/Structs/Point3DTests.cs
+++ b/test/Atc.Tests/Structs/Point3DTests.cs
@@ -23,6 +23,13 @@ public void IsDefault(
         Assert.Equal(expected, actual);
     }
 
+    [Fact]
+    public void IsDefault_WithTinyNonZeroZ_ReturnsFalse()
+    {
+        var input = new Point3D(0, 0, double.Epsilon);
+        Assert.False(input.IsDefault);
+    }
+
     [Theory]
     [InlineData("0, 0, 0", 0, 0, 0)]
     [InlineData("1, 0, 0", 1, 0, 0)]

From bc8ea57b618a595404c41904216078fd2676e00b Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 02:26:00 +0200
Subject: [PATCH 045/100] fix(atc-rest): fix DI, body-buffering, and CORS doc
 issues
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- ExceptionTelemetryMiddleware: resolve TelemetryClient? via GetService<> instead of
  constructor injection — no longer fails when App Insights is disabled
- GetRawBodyStringAsync: call EnableBuffering() and rewind to position 0 so downstream
  model binding still sees the body
- RequestResponseLoggerMiddleware: enforce MaxRequestBodyBufferSize cap via ReadAsync
  instead of ReadToEndAsync — documented limit now actually applies
- RestApiOptions: update AllowedCorsOrigins doc to reflect dev-only permissive policy
---
 docs/CodeDoc/Atc.Rest/Atc.Rest.Options.md     |  2 +-
 .../Extensions/HttpRequestExExtensions.cs     | 15 ++++-
 .../ExceptionTelemetryMiddleware.cs           | 10 +--
 .../RequestResponseLoggerMiddleware.cs        | 15 ++++-
 src/Atc.Rest/Options/RestApiOptions.cs        |  7 ++-
 .../ExceptionTelemetryMiddlewareTests.cs      | 63 ++++++++++++++++---
 6 files changed, 90 insertions(+), 22 deletions(-)

diff --git a/docs/CodeDoc/Atc.Rest/Atc.Rest.Options.md b/docs/CodeDoc/Atc.Rest/Atc.Rest.Options.md
index ac07a0a8..34efb2ad 100644
--- a/docs/CodeDoc/Atc.Rest/Atc.Rest.Options.md
+++ b/docs/CodeDoc/Atc.Rest/Atc.Rest.Options.md
@@ -234,7 +234,7 @@ Configuration options for the REST API framework.
 >```
 ><b>Summary:</b> Gets or sets the allowed CORS origins for the API.
 >
-><b>Remarks:</b> When null or empty, a permissive policy (AllowAnyOrigin, AllowAnyMethod, AllowAnyHeader) is used. When specified, only the listed origins are allowed. Set this in production to prevent CSRF attacks.
+><b>Remarks:</b> When null or empty and the environment is Development, a permissive policy (AllowAnyOrigin, AllowAnyMethod, AllowAnyHeader) is applied. When null or empty in non-Development environments, no CORS middleware is added and the browser's same-origin policy applies — no CORS headers are emitted. When specified, only the listed origins are allowed in all environments.
 #### AssemblyPairs
 >```csharp
 >AssemblyPairs
diff --git a/src/Atc.Rest/Extensions/HttpRequestExExtensions.cs b/src/Atc.Rest/Extensions/HttpRequestExExtensions.cs
index 7f3f5926..4c05add9 100644
--- a/src/Atc.Rest/Extensions/HttpRequestExExtensions.cs
+++ b/src/Atc.Rest/Extensions/HttpRequestExExtensions.cs
@@ -20,8 +20,19 @@ public static async Task<string> GetRawBodyStringAsync(
 
         encoding ??= Encoding.UTF8;
 
-        using var reader = new StreamReader(request.Body, encoding);
-        return await reader.ReadToEndAsync();
+        // Allow the body to be read more than once so downstream model binding still works.
+        request.EnableBuffering();
+
+        string body;
+        using (var reader = new StreamReader(request.Body, encoding, leaveOpen: true))
+        {
+            body = await reader.ReadToEndAsync();
+        }
+
+        // Rewind so subsequent reads (e.g. model binding) start from the beginning.
+        request.Body.Position = 0;
+
+        return body;
     }
 
     /// <summary>
diff --git a/src/Atc.Rest/Middleware/ExceptionTelemetryMiddleware.cs b/src/Atc.Rest/Middleware/ExceptionTelemetryMiddleware.cs
index 849d385e..6f295e89 100644
--- a/src/Atc.Rest/Middleware/ExceptionTelemetryMiddleware.cs
+++ b/src/Atc.Rest/Middleware/ExceptionTelemetryMiddleware.cs
@@ -10,19 +10,14 @@ namespace Atc.Rest.Middleware;
 public class ExceptionTelemetryMiddleware
 {
     private readonly RequestDelegate next;
-    private readonly TelemetryClient client;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ExceptionTelemetryMiddleware"/> class.
     /// </summary>
     /// <param name="next">The next middleware delegate in the pipeline.</param>
-    /// <param name="client">The Application Insights telemetry client.</param>
-    public ExceptionTelemetryMiddleware(
-        RequestDelegate next,
-        TelemetryClient client)
+    public ExceptionTelemetryMiddleware(RequestDelegate next)
     {
         this.next = next;
-        this.client = client;
     }
 
     /// <summary>
@@ -47,7 +42,8 @@ private async Task InternalInvokeAsync(HttpContext context)
         }
         catch (Exception ex)
         {
-            client.TrackException(ex);
+            var telemetryClient = context.RequestServices.GetService<TelemetryClient>();
+            telemetryClient?.TrackException(ex);
 
             if (context.Response.HasStarted)
             {
diff --git a/src/Atc.Rest/Middleware/RequestResponseLoggerMiddleware.cs b/src/Atc.Rest/Middleware/RequestResponseLoggerMiddleware.cs
index 9841ab7e..403a30bc 100644
--- a/src/Atc.Rest/Middleware/RequestResponseLoggerMiddleware.cs
+++ b/src/Atc.Rest/Middleware/RequestResponseLoggerMiddleware.cs
@@ -167,8 +167,19 @@ private static async Task<string> ReadBodyFromRequest(
             request.EnableBuffering();
         }
 
-        using var streamReader = new StreamReader(request.Body, leaveOpen: true);
-        var requestBody = await streamReader.ReadToEndAsync();
+        string requestBody;
+        if (maxBufferSize > 0)
+        {
+            // Read at most maxBufferSize bytes so the documented cap is enforced.
+            var buffer = new byte[maxBufferSize];
+            var bytesRead = await request.Body.ReadAsync(buffer.AsMemory(0, buffer.Length));
+            requestBody = Encoding.UTF8.GetString(buffer, 0, bytesRead);
+        }
+        else
+        {
+            using var streamReader = new StreamReader(request.Body, leaveOpen: true);
+            requestBody = await streamReader.ReadToEndAsync();
+        }
 
         // Reset the request's body stream position for next middleware in the pipeline.
         request.Body.Position = 0;
diff --git a/src/Atc.Rest/Options/RestApiOptions.cs b/src/Atc.Rest/Options/RestApiOptions.cs
index 97a4fe96..3989cf80 100644
--- a/src/Atc.Rest/Options/RestApiOptions.cs
+++ b/src/Atc.Rest/Options/RestApiOptions.cs
@@ -76,8 +76,11 @@ public class RestApiOptions
     /// Gets or sets the allowed CORS origins for the API.
     /// </summary>
     /// <remarks>
-    /// When null or empty, a permissive policy (AllowAnyOrigin, AllowAnyMethod, AllowAnyHeader) is used.
-    /// When specified, only the listed origins are allowed. Set this in production to prevent CSRF attacks.
+    /// When null or empty and the environment is Development, a permissive policy
+    /// (AllowAnyOrigin, AllowAnyMethod, AllowAnyHeader) is applied.
+    /// When null or empty in non-Development environments, no CORS middleware is added and the
+    /// browser's same-origin policy applies — no CORS headers are emitted.
+    /// When specified, only the listed origins are allowed in all environments.
     /// </remarks>
     [SuppressMessage("Usage", "CA2227:Collection properties should be read only", Justification = "OK.")]
     public List<string>? AllowedCorsOrigins { get; set; }
diff --git a/test/Atc.Rest.Tests/Middleware/ExceptionTelemetryMiddlewareTests.cs b/test/Atc.Rest.Tests/Middleware/ExceptionTelemetryMiddlewareTests.cs
index 2f223fc5..57ef2d7b 100644
--- a/test/Atc.Rest.Tests/Middleware/ExceptionTelemetryMiddlewareTests.cs
+++ b/test/Atc.Rest.Tests/Middleware/ExceptionTelemetryMiddlewareTests.cs
@@ -3,21 +3,46 @@ namespace Atc.Rest.Tests.Middleware;
 public class ExceptionTelemetryMiddlewareTests
 {
     [Fact]
-    public async Task InvokeAsync()
+    public async Task InvokeAsync_WithTelemetryClient_ReturnsOk()
     {
         // Arrange
+        var services = new ServiceCollection();
         using var telemetryConfiguration = new TelemetryConfiguration
         {
             ConnectionString = "InstrumentationKey=00000000-0000-0000-0000-000000000000",
         };
-        var telemetryClient = new TelemetryClient(telemetryConfiguration);
+        services.AddSingleton(new TelemetryClient(telemetryConfiguration));
+        var serviceProvider = services.BuildServiceProvider();
+
+        var middleware = new ExceptionTelemetryMiddleware(
+            async innerHttpContext => await innerHttpContext.Response.WriteAsync("test response body"));
+
+        var defaultHttpContext = new DefaultHttpContext
+        {
+            RequestServices = serviceProvider,
+        };
+
+        // Act
+        await middleware.InvokeAsync(defaultHttpContext);
+
+        // Assert
+        Assert.Equal((int)HttpStatusCode.OK, defaultHttpContext.Response.StatusCode);
+    }
+
+    [Fact]
+    public async Task InvokeAsync_WithoutTelemetryClient_DoesNotThrowOnSuccess()
+    {
+        // Arrange — no TelemetryClient registered
+        var services = new ServiceCollection();
+        var serviceProvider = services.BuildServiceProvider();
+
         var middleware = new ExceptionTelemetryMiddleware(
-            async innerHttpContext =>
-            {
-                await innerHttpContext.Response.WriteAsync("test response body");
-            },
-            telemetryClient);
-        var defaultHttpContext = new DefaultHttpContext();
+            async innerHttpContext => await innerHttpContext.Response.WriteAsync("ok"));
+
+        var defaultHttpContext = new DefaultHttpContext
+        {
+            RequestServices = serviceProvider,
+        };
 
         // Act
         await middleware.InvokeAsync(defaultHttpContext);
@@ -25,4 +50,26 @@ public async Task InvokeAsync()
         // Assert
         Assert.Equal((int)HttpStatusCode.OK, defaultHttpContext.Response.StatusCode);
     }
+
+    [Fact]
+    public async Task InvokeAsync_WithoutTelemetryClient_ExceptionYields500()
+    {
+        // Arrange — no TelemetryClient registered; pipeline throws
+        var services = new ServiceCollection();
+        var serviceProvider = services.BuildServiceProvider();
+
+        var middleware = new ExceptionTelemetryMiddleware(
+            _ => throw new InvalidOperationException("boom"));
+
+        var defaultHttpContext = new DefaultHttpContext
+        {
+            RequestServices = serviceProvider,
+        };
+
+        // Act
+        await middleware.InvokeAsync(defaultHttpContext);
+
+        // Assert — 500 returned; no NRE from missing TelemetryClient
+        Assert.Equal((int)HttpStatusCode.InternalServerError, defaultHttpContext.Response.StatusCode);
+    }
 }
\ No newline at end of file

From 2d3ced42bb543631bd83d0116299c151c250318a Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 02:26:05 +0200
Subject: [PATCH 046/100] perf(atc-openapi): replace O(n) FirstOrDefault with
 TryGetValue in schema lookup

Two private helper methods were scanning the componentSchemas dictionary with
FirstOrDefault(x => x.Key == name) instead of using the O(1) TryGetValue overload.
---
 .../Extensions/OpenApiSchemaExtensions.cs     | 20 +++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/src/Atc.OpenApi/Extensions/OpenApiSchemaExtensions.cs b/src/Atc.OpenApi/Extensions/OpenApiSchemaExtensions.cs
index f2074d2a..78fcd32e 100644
--- a/src/Atc.OpenApi/Extensions/OpenApiSchemaExtensions.cs
+++ b/src/Atc.OpenApi/Extensions/OpenApiSchemaExtensions.cs
@@ -604,6 +604,11 @@ public static bool HasAnyPropertiesFormatTypeFromSystemNamespace(
         this OpenApiSchema schema,
         IDictionary<string, OpenApiSchema> componentSchemas)
     {
+        if (componentSchemas is null)
+        {
+            throw new ArgumentNullException(nameof(componentSchemas));
+        }
+
         if (!schema.HasAnyProperties())
         {
             return false;
@@ -642,6 +647,11 @@ public static bool HasAnyPropertiesFormatTypeFromSystemCollectionGenericNamespac
         this OpenApiSchema schema,
         IDictionary<string, OpenApiSchema> componentSchemas)
     {
+        if (componentSchemas is null)
+        {
+            throw new ArgumentNullException(nameof(componentSchemas));
+        }
+
         if (!schema.HasAnyProperties())
         {
             return false;
@@ -1524,9 +1534,8 @@ private static bool HasAnyPropertiesFormatTypeFromSystemNamespaceHelper(
             return false;
         }
 
-        var componentSchema = componentSchemas.FirstOrDefault(x => x.Key == modelName);
-        return !string.IsNullOrEmpty(componentSchema.Key) &&
-               componentSchema.Value.HasAnyPropertiesFormatTypeFromSystemNamespace(componentSchemas);
+        return componentSchemas.TryGetValue(modelName!, out var componentSchemaValue) &&
+               componentSchemaValue.HasAnyPropertiesFormatTypeFromSystemNamespace(componentSchemas);
     }
 
     private static bool HasAnyPropertiesFormatTypeFromSystemCollectionGenericNamespaceHelper(
@@ -1544,8 +1553,7 @@ private static bool HasAnyPropertiesFormatTypeFromSystemCollectionGenericNamespa
             return false;
         }
 
-        var componentSchema = componentSchemas.FirstOrDefault(x => x.Key == modelName);
-        return !string.IsNullOrEmpty(componentSchema.Key) &&
-               componentSchema.Value.HasAnyPropertiesFormatTypeFromSystemCollectionGenericNamespace(componentSchemas);
+        return componentSchemas.TryGetValue(modelName!, out var componentSchemaValue) &&
+               componentSchemaValue.HasAnyPropertiesFormatTypeFromSystemCollectionGenericNamespace(componentSchemas);
     }
 }
\ No newline at end of file

From c7e820f836b5e2e1c993c52404e459a437d5ddc2 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 02:26:10 +0200
Subject: [PATCH 047/100] fix(atc-console-spectre): align Log formatter
 signature with ILogger<T> contract

The formatter parameter type was Func<TState, Exception, string> (non-nullable
Exception) and was invoked with exception!, diverging from the framework contract
of Func<TState, Exception?, string>. Changed to Exception? and removed the
null-forgiving operator.
---
 src/Atc.Console.Spectre/Logging/ConsoleLogger.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs b/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs
index c034c0c3..2be6b187 100644
--- a/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs
+++ b/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs
@@ -51,7 +51,7 @@ public void Log<TState>(
         EventId eventId,
         TState state,
         Exception? exception,
-        Func<TState, Exception, string> formatter)
+        Func<TState, Exception?, string> formatter)
     {
         ArgumentNullException.ThrowIfNull(formatter);
 
@@ -60,7 +60,7 @@ public void Log<TState>(
             return;
         }
 
-        var stateStr = formatter(state, exception!);
+        var stateStr = formatter(state, exception);
         var message = config.AllowMarkup
             ? stateStr
             : Markup.Escape(stateStr);

From 52fa54944f19cfd9c14d47eab87966831e89d612 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 02:26:19 +0200
Subject: [PATCH 048/100] fix(atc-dotnet): fix GetDotnetDirectory, extract
 ambiguity sentinel, switch to XElement parsing

- DotnetHelper.GetDotnetDirectory: probe for dotnet(.exe) binary in each PATH segment
  instead of matching any segment containing the string "dotnet" (case-sensitive);
  avoids matching dotnet-cli-old, handles DOTNET on case-sensitive systems
- DotnetBuildHelper: extract the English "Please specify which" check to a private
  const MultipleFilesOutputPrefix; replace .ToListAsync(ct) on in-memory arrays with .ToList()
- DotnetNugetHelper: replace brittle Replace/Split PackageReference parsing with XDocument
  so multi-line elements, single-quoted Include, and child <Version> nodes all work
---
 src/Atc.DotNet/DotnetBuildHelper.cs | 25 ++++++++-----
 src/Atc.DotNet/DotnetHelper.cs      | 19 ++++++----
 src/Atc.DotNet/DotnetNugetHelper.cs | 55 +++++++----------------------
 3 files changed, 40 insertions(+), 59 deletions(-)

diff --git a/src/Atc.DotNet/DotnetBuildHelper.cs b/src/Atc.DotNet/DotnetBuildHelper.cs
index cfc8721a..35dda2e8 100644
--- a/src/Atc.DotNet/DotnetBuildHelper.cs
+++ b/src/Atc.DotNet/DotnetBuildHelper.cs
@@ -7,6 +7,11 @@ namespace Atc.DotNet;
 public static class DotnetBuildHelper
 {
     private const int DefaultTimeoutInSec = 1200;
+
+    // Sentinel prefix used internally when there are multiple candidate build files so the
+    // caller can detect the ambiguity without relying on a localised dotnet CLI message.
+    private const string MultipleFilesOutputPrefix = "Please specify which";
+
     private static readonly ConcurrentDictionary<string, Regex> RegexCache = new(StringComparer.Ordinal);
 
     /// <summary>
@@ -121,7 +126,7 @@ private static async Task<Dictionary<string, int>> InvokeBuildAndCollectErrors(
                 cancellationToken)
             .ConfigureAwait(false);
 
-        if (output.StartsWith("Please specify which", StringComparison.Ordinal) &&
+        if (output.StartsWith(MultipleFilesOutputPrefix, StringComparison.Ordinal) &&
             output.Contains("option: --buildFile", StringComparison.Ordinal))
         {
             stopwatch.Stop();
@@ -176,27 +181,29 @@ private static async Task<Dictionary<string, int>> InvokeBuildAndCollectErrors(
             var slnFiles = Directory.GetFiles(rootPath.FullName, "*.sln");
             if (slnFiles.Length > 1)
             {
-                var files = await slnFiles
+#pragma warning disable AsyncFixer02
+                var files = slnFiles
                     .Select(x => new FileInfo(x).Name)
-                    .ToListAsync(cancellationToken)
-                    .ConfigureAwait(false);
+                    .ToList();
+#pragma warning restore AsyncFixer02
 
                 return (
                     IsSuccessful: false,
-                    Output: $"Please specify which solution file to use:{Environment.NewLine} - {string.Join($"{Environment.NewLine} - ", files)}{Environment.NewLine} Specify the solution file using this option: --buildFile");
+                    Output: $"{MultipleFilesOutputPrefix} solution file to use:{Environment.NewLine} - {string.Join($"{Environment.NewLine} - ", files)}{Environment.NewLine} Specify the solution file using this option: --buildFile");
             }
 
             var csprojFiles = Directory.GetFiles(rootPath.FullName, "*.csproj");
             if (csprojFiles.Length > 1)
             {
-                var files = await csprojFiles
+#pragma warning disable AsyncFixer02
+                var files = csprojFiles
                     .Select(x => new FileInfo(x).Name)
-                    .ToListAsync(cancellationToken)
-                    .ConfigureAwait(false);
+                    .ToList();
+#pragma warning restore AsyncFixer02
 
                 return (
                     IsSuccessful: false,
-                    Output: $"Please specify which C# project file to use:{Environment.NewLine} - {string.Join($"{Environment.NewLine} - ", files)}{Environment.NewLine} Specify the C# project file using this option: --buildFile");
+                    Output: $"{MultipleFilesOutputPrefix} C# project file to use:{Environment.NewLine} - {string.Join($"{Environment.NewLine} - ", files)}{Environment.NewLine} Specify the C# project file using this option: --buildFile");
             }
         }
 
diff --git a/src/Atc.DotNet/DotnetHelper.cs b/src/Atc.DotNet/DotnetHelper.cs
index 5d31995b..15dd35bd 100644
--- a/src/Atc.DotNet/DotnetHelper.cs
+++ b/src/Atc.DotNet/DotnetHelper.cs
@@ -17,16 +17,21 @@ public static class DotnetHelper
     /// </remarks>
     public static DirectoryInfo GetDotnetDirectory()
     {
-        var pathEnvironmentVariable = Environment.GetEnvironmentVariable("path");
-        if (pathEnvironmentVariable is not null &&
-            pathEnvironmentVariable.Contains("dotnet", StringComparison.Ordinal))
+        var dotnetFilename = OperatingSystem.IsWindows() ? "dotnet.exe" : "dotnet";
+        var pathEnvironmentVariable = Environment.GetEnvironmentVariable("PATH");
+        if (pathEnvironmentVariable is not null)
         {
-            var sa = pathEnvironmentVariable.Split(Path.PathSeparator);
-            foreach (var s in sa)
+            foreach (var segment in pathEnvironmentVariable.Split(Path.PathSeparator))
             {
-                if (s.Contains("dotnet", StringComparison.Ordinal))
+                if (string.IsNullOrWhiteSpace(segment))
                 {
-                    return new DirectoryInfo(s);
+                    continue;
+                }
+
+                var candidate = Path.Combine(segment, dotnetFilename);
+                if (File.Exists(candidate))
+                {
+                    return new DirectoryInfo(segment);
                 }
             }
         }
diff --git a/src/Atc.DotNet/DotnetNugetHelper.cs b/src/Atc.DotNet/DotnetNugetHelper.cs
index 2d313242..05523f7e 100644
--- a/src/Atc.DotNet/DotnetNugetHelper.cs
+++ b/src/Atc.DotNet/DotnetNugetHelper.cs
@@ -49,51 +49,20 @@ public static List<DotnetNugetPackageMetadataBase> GetAllPackageReferences(
             throw new DataException("Expect xml content");
         }
 
-        var data = new List<DotnetNugetPackageMetadataBase>();
-        foreach (var line in fileContent.EnsureEnvironmentNewLinesAndSplit())
-        {
-            if (!line.Contains("<PackageReference ", StringComparison.Ordinal) ||
-                !line.Contains("Include=", StringComparison.Ordinal) ||
-                !line.Contains("Version=", StringComparison.Ordinal))
-            {
-                continue;
-            }
-
-            var attributes = line
-                .Replace("<PackageReference ", string.Empty, StringComparison.Ordinal)
-                .Replace("/>", string.Empty, StringComparison.Ordinal)
-                .Replace(">", string.Empty, StringComparison.Ordinal)
-                .Trim()
-                .Split(' ');
-
-            var packageId = string.Empty;
-            var version = string.Empty;
-
-            foreach (var attribute in attributes)
+        var xDoc = XDocument.Parse(fileContent);
+        var data = xDoc
+            .Descendants("PackageReference")
+            .Select(e => new
             {
-                if (attribute.StartsWith("Include=", StringComparison.Ordinal))
-                {
-                    packageId = attribute
-                        .Replace("Include=", string.Empty, StringComparison.Ordinal)
-                        .Replace("\"", string.Empty, StringComparison.Ordinal);
-                }
-                else if (attribute.StartsWith("Version=", StringComparison.Ordinal))
-                {
-                    version = attribute
-                        .Replace("Version=", string.Empty, StringComparison.Ordinal)
-                        .Replace("\"", string.Empty, StringComparison.Ordinal);
-                }
-            }
-
-            if (!string.IsNullOrEmpty(packageId) &&
-                !string.IsNullOrEmpty(version))
-            {
-                data.Add(new DotnetNugetPackageMetadataBase(packageId, version));
-            }
-        }
-
-        return data
+                PackageId = e.Attribute("Include")?.Value,
+                Version = e.Attribute("Version")?.Value
+                    ?? e.Element("Version")?.Value,
+            })
+            .Where(x => !string.IsNullOrEmpty(x.PackageId) && !string.IsNullOrEmpty(x.Version))
+            .Select(x => new DotnetNugetPackageMetadataBase(x.PackageId!, x.Version!))
             .OrderBy(x => x.PackageId, StringComparer.Ordinal)
             .ToList();
+
+        return data;
     }
 }
\ No newline at end of file

From 597722d5a27b81ff513f944ecececfa01734457f Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 02:26:30 +0200
Subject: [PATCH 049/100] fix(atc-codeanalysis-csharp): fix NRE, over-match,
 attribute lookup, and interpolation escaping

- SyntaxNodeExtensions: null-guard x.Name before dereferencing; use .ToString() instead
  of .ToFullString() to strip leading/trailing trivia from using-directive names
- UsingDirectiveSyntaxExtensions: tighten System-namespace check from StartsWith("System")
  to == "System" || StartsWith("System.") to avoid matching SystemX.Foo
- EnumDeclarationSyntaxExtensions.HasAttributeOfAttributeType: also match the full
  FlagsAttribute name in addition to the short-form Flags so both spellings are found
- SyntaxInterpolatedFactory: double { and } in the raw token text so braces inside
  interpolated string literal portions are not misread as interpolation holes
- SyntaxLiteralExpressionFactory: document that comma-as-thousands-separator inputs
  (e.g. "1,000") are not supported to prevent silent 1.0 corruption
---
 .../EnumDeclarationSyntaxExtensions.cs         | 11 +++++++++--
 .../Extensions/SyntaxNodeExtensions.cs         |  7 ++++---
 .../UsingDirectiveSyntaxExtensions.cs          |  6 +++---
 .../SyntaxInterpolatedFactory.cs               | 18 ++++++++++++++++--
 .../SyntaxLiteralExpressionFactory.cs          |  7 +++++--
 5 files changed, 37 insertions(+), 12 deletions(-)

diff --git a/src/Atc.CodeAnalysis.CSharp/Extensions/EnumDeclarationSyntaxExtensions.cs b/src/Atc.CodeAnalysis.CSharp/Extensions/EnumDeclarationSyntaxExtensions.cs
index c55c6978..57aaa7bb 100644
--- a/src/Atc.CodeAnalysis.CSharp/Extensions/EnumDeclarationSyntaxExtensions.cs
+++ b/src/Atc.CodeAnalysis.CSharp/Extensions/EnumDeclarationSyntaxExtensions.cs
@@ -85,9 +85,16 @@ public static bool HasAttributeOfAttributeType(
             throw new ArgumentNullException(nameof(attributeType));
         }
 
-        var attributeName = attributeType.Name.Replace("Attribute", string.Empty, StringComparison.Ordinal);
+        // Strip the conventional "Attribute" suffix so both [Flags] and [FlagsAttribute] match FlagsAttribute.
+        var shortName = attributeType.Name.Replace("Attribute", string.Empty, StringComparison.Ordinal);
+        var fullName = attributeType.Name; // "FlagsAttribute"
         return enumDeclaration
             .Select<AttributeSyntax>()
-            .Any(x => attributeName.Equals(x.Name.ToString(), StringComparison.Ordinal));
+            .Any(x =>
+            {
+                var attrName = x.Name.ToString();
+                return attrName.Equals(shortName, StringComparison.Ordinal) ||
+                       attrName.Equals(fullName, StringComparison.Ordinal);
+            });
     }
 }
\ No newline at end of file
diff --git a/src/Atc.CodeAnalysis.CSharp/Extensions/SyntaxNodeExtensions.cs b/src/Atc.CodeAnalysis.CSharp/Extensions/SyntaxNodeExtensions.cs
index 40fbcec2..d56a2531 100644
--- a/src/Atc.CodeAnalysis.CSharp/Extensions/SyntaxNodeExtensions.cs
+++ b/src/Atc.CodeAnalysis.CSharp/Extensions/SyntaxNodeExtensions.cs
@@ -60,7 +60,8 @@ public static string[] GetUsedUsingStatements(this SyntaxNode syntaxNode)
 
         return syntaxNode
             .Select<UsingDirectiveSyntax>()
-            .Select(x => x.Name!.ToFullString())
+            .Where(x => x.Name is not null)
+            .Select(x => x.Name!.ToString())
             .ToArray();
     }
 
@@ -80,8 +81,8 @@ public static string[] GetUsedUsingStatementsWithoutAlias(
 
         return syntaxNode
             .Select<UsingDirectiveSyntax>()
-            .Where(x => x.Alias is null)
-            .Select(x => x.Name!.ToFullString())
+            .Where(x => x.Alias is null && x.Name is not null)
+            .Select(x => x.Name!.ToString())
             .ToArray();
     }
 }
\ No newline at end of file
diff --git a/src/Atc.CodeAnalysis.CSharp/Extensions/UsingDirectiveSyntaxExtensions.cs b/src/Atc.CodeAnalysis.CSharp/Extensions/UsingDirectiveSyntaxExtensions.cs
index 8c53b046..ecf4f7fd 100644
--- a/src/Atc.CodeAnalysis.CSharp/Extensions/UsingDirectiveSyntaxExtensions.cs
+++ b/src/Atc.CodeAnalysis.CSharp/Extensions/UsingDirectiveSyntaxExtensions.cs
@@ -20,9 +20,9 @@ internal static SyntaxList<UsingDirectiveSyntax> Sort(
                 .OrderBy(Compare)
                 .ThenBy(x => x.Alias?.ToString(), StringComparer.Ordinal)
                 .ThenByDescending(x => placeSystemNamespaceFirst &&
-                                       x.Name!
-                                           .ToString()
-                                           .StartsWith(nameof(System), StringComparison.Ordinal))
+                                       (x.Name?.ToString() is { } n &&
+                                        (n == nameof(System) ||
+                                         n.StartsWith(nameof(System) + ".", StringComparison.Ordinal))))
                 .ThenBy(x => x.Name!.ToString(), StringComparer.Ordinal));
 
     private static int Compare(UsingDirectiveSyntax directive)
diff --git a/src/Atc.CodeAnalysis.CSharp/SyntaxFactories/SyntaxInterpolatedFactory.cs b/src/Atc.CodeAnalysis.CSharp/SyntaxFactories/SyntaxInterpolatedFactory.cs
index 17ffcdd6..91bf601a 100644
--- a/src/Atc.CodeAnalysis.CSharp/SyntaxFactories/SyntaxInterpolatedFactory.cs
+++ b/src/Atc.CodeAnalysis.CSharp/SyntaxFactories/SyntaxInterpolatedFactory.cs
@@ -11,14 +11,28 @@ public static class SyntaxInterpolatedFactory
     /// <param name="value">The text value to include in the interpolated string.</param>
     /// <returns>An <see cref="InterpolatedStringContentSyntax"/> representing the text.</returns>
     public static InterpolatedStringContentSyntax StringText(string value)
-        => SyntaxFactory.InterpolatedStringText()
+    {
+        if (value is null)
+        {
+            throw new ArgumentNullException(nameof(value));
+        }
+
+        // In the raw source text of an interpolated string, '{' and '}' must be doubled to
+        // avoid being interpreted as interpolation holes.  The valueText (semantic value) keeps
+        // the original characters because that is what the runtime sees at execution time.
+        var rawText = value
+            .Replace("{", "{{", StringComparison.Ordinal)
+            .Replace("}", "}}", StringComparison.Ordinal);
+
+        return SyntaxFactory.InterpolatedStringText()
             .WithTextToken(
                 SyntaxFactory.Token(
                     SyntaxFactory.TriviaList(),
                     SyntaxKind.InterpolatedStringTextToken,
-                    value,
+                    rawText,
                     value,
                     SyntaxFactory.TriviaList()));
+    }
 
     /// <summary>
     /// Creates interpolated string text for a colon and space (": ").
diff --git a/src/Atc.CodeAnalysis.CSharp/SyntaxFactories/SyntaxLiteralExpressionFactory.cs b/src/Atc.CodeAnalysis.CSharp/SyntaxFactories/SyntaxLiteralExpressionFactory.cs
index ca1f3a93..93080795 100644
--- a/src/Atc.CodeAnalysis.CSharp/SyntaxFactories/SyntaxLiteralExpressionFactory.cs
+++ b/src/Atc.CodeAnalysis.CSharp/SyntaxFactories/SyntaxLiteralExpressionFactory.cs
@@ -30,8 +30,11 @@ public static LiteralExpressionSyntax Create(
                 return SyntaxFactory.LiteralExpression(syntaxKind, SyntaxFactory.Literal(parsedInt));
             }
 
-            value = value.Replace(',', '.');
-            if (double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var parsedDouble))
+            // Support European decimal notation (comma as decimal separator): "12,345" → 12.345.
+            // Thousands-separator values (e.g. "1,000") are not supported — they would silently
+            // become 1.0, so callers must normalise such values before passing them in.
+            var normalised = value.Replace(',', '.');
+            if (double.TryParse(normalised, NumberStyles.Float, CultureInfo.InvariantCulture, out var parsedDouble))
             {
                 return SyntaxFactory.LiteralExpression(syntaxKind, SyntaxFactory.Literal(parsedDouble));
             }

From a2cae4e2856483210f718c091f62fb09b1dc4306 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 02:26:37 +0200
Subject: [PATCH 050/100] fix(atc-codedoc): eliminate per-call allocations and
 fragile path matching

- MarkdownBuilder.AppendLine(int, string): append &nbsp; runs directly to the shared
  StringBuilder instead of allocating a fresh one per call
- MarkdownCodeDocGenerator.GetOutputPath: walk up the directory tree to find the segment
  whose name matches the assembly name instead of using a fragile IndexOf substring
  search that breaks when the assembly name appears more than once in the path
- XmlDocumentCommentParser: promote five ad-hoc Regex.Match/Replace calls to static
  readonly Regex fields so patterns are compiled once, not per-parse-call
---
 .../Markdown/MarkdownBuilder.cs               |  5 +--
 .../Markdown/MarkdownCodeDocGenerator.cs      | 17 ++++++++
 .../XmlDocument/XmlDocumentCommentParser.cs   | 42 ++++++++++++++++---
 3 files changed, 55 insertions(+), 9 deletions(-)

diff --git a/src/Atc.CodeDocumentation/Markdown/MarkdownBuilder.cs b/src/Atc.CodeDocumentation/Markdown/MarkdownBuilder.cs
index 7e453b00..d46a3298 100644
--- a/src/Atc.CodeDocumentation/Markdown/MarkdownBuilder.cs
+++ b/src/Atc.CodeDocumentation/Markdown/MarkdownBuilder.cs
@@ -37,13 +37,12 @@ public void AppendLine(
         int indentSpaces,
         string text)
     {
-        var sbLocal = new StringBuilder();
         for (var i = 0; i < indentSpaces; i++)
         {
-            sbLocal.Append("&nbsp;");
+            sb.Append("&nbsp;");
         }
 
-        sb.AppendLine(sbLocal + text);
+        sb.AppendLine(text);
     }
 
     /// <summary>
diff --git a/src/Atc.CodeDocumentation/Markdown/MarkdownCodeDocGenerator.cs b/src/Atc.CodeDocumentation/Markdown/MarkdownCodeDocGenerator.cs
index a9ac3162..38e60cb2 100644
--- a/src/Atc.CodeDocumentation/Markdown/MarkdownCodeDocGenerator.cs
+++ b/src/Atc.CodeDocumentation/Markdown/MarkdownCodeDocGenerator.cs
@@ -55,6 +55,23 @@ public static void Run(
     {
         var assemblyName = assembly.GetName().Name!;
         var baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
+
+        // Walk up the directory tree until we find a segment whose name matches the assembly name.
+        // This avoids a fragile string-index search that breaks when the assembly name appears
+        // multiple times in the path.
+        var dir = new DirectoryInfo(baseDirectory);
+        while (dir is not null)
+        {
+            if (dir.Name.Equals(assemblyName, StringComparison.Ordinal))
+            {
+                return new DirectoryInfo(Path.Combine(dir.FullName, "CodeDoc"));
+            }
+
+            dir = dir.Parent;
+        }
+
+        // Fall back to the original index-based search for cases where the assembly name
+        // does not appear as a standalone directory segment (e.g. single-file publish).
         var index = baseDirectory.IndexOf(assemblyName, StringComparison.Ordinal);
         if (index == -1)
         {
diff --git a/src/Atc.CodeDocumentation/XmlDocument/XmlDocumentCommentParser.cs b/src/Atc.CodeDocumentation/XmlDocument/XmlDocumentCommentParser.cs
index 9d7d29aa..a6365319 100644
--- a/src/Atc.CodeDocumentation/XmlDocument/XmlDocumentCommentParser.cs
+++ b/src/Atc.CodeDocumentation/XmlDocument/XmlDocumentCommentParser.cs
@@ -2,6 +2,36 @@ namespace Atc.CodeDocumentation.XmlDocument;
 
 internal static class XmlDocumentCommentParser
 {
+    private static readonly Regex MemberAttributeRegex = new(
+        @"(.):(.+)\.([^.()]+)?(\(.+\)|$)",
+        RegexOptions.Compiled,
+        TimeSpan.FromSeconds(5));
+
+    private static readonly Regex ParaTagRegex = new(
+        @"<para\s*\/>|<\/para>",
+        RegexOptions.Compiled,
+        TimeSpan.FromSeconds(1));
+
+    private static readonly Regex SeeCrefRegex = new(
+        @"<see cref=""\w:([^\""]*)""\s*\/>",
+        RegexOptions.Compiled,
+        TimeSpan.FromSeconds(1));
+
+    private static readonly Regex ParamRefRegex = new(
+        @"<(type)*paramref name=""([^\""]*)""\s*\/>",
+        RegexOptions.Compiled,
+        TimeSpan.FromSeconds(1));
+
+    private static readonly Regex CodeTagRegex = new(
+        @"<c\b[^>]*>(.*?)<\/c>",
+        RegexOptions.Compiled,
+        TimeSpan.FromSeconds(1));
+
+    private static readonly Regex TypeNameSuffixRegex = new(
+        @"\.(?:.(?!\.))+$",
+        RegexOptions.Compiled,
+        TimeSpan.FromSeconds(1));
+
     [SuppressMessage("Design", "MA0051:Method is too long", Justification = "OK.")]
     internal static XmlDocumentComment?[] ParseXmlComment(
         XDocument xDocument,
@@ -16,7 +46,7 @@ internal static class XmlDocumentCommentParser
                     return null;
                 }
 
-                var match = Regex.Match(attributeValue, @"(.):(.+)\.([^.()]+)?(\(.+\)|$)", RegexOptions.None, TimeSpan.FromSeconds(5));
+                var match = MemberAttributeRegex.Match(attributeValue);
                 if (!match.Groups[1].Success)
                 {
                     return null;
@@ -132,7 +162,7 @@ private static string ResolveSeeElement(
         }
 
         return typeName.StartsWith(ns, StringComparison.Ordinal)
-            ? $"[{typeName}]({Regex.Replace(typeName, "\\.(?:.(?!\\.))+$", me => me.Groups[0].Value.Replace('.', '#').ToLower(GlobalizationConstants.EnglishCultureInfo), RegexOptions.None, TimeSpan.FromSeconds(1))})"
+            ? $"[{typeName}]({TypeNameSuffixRegex.Replace(typeName, me => me.Groups[0].Value.Replace('.', '#').ToLower(GlobalizationConstants.EnglishCultureInfo))})"
             : $"`{typeName}`";
     }
 
@@ -152,10 +182,10 @@ private static string ParseElementText(
         innerXml = innerXml.Replace("\n", " ", StringComparison.Ordinal);
         innerXml = innerXml.Replace("\r", " ", StringComparison.Ordinal);
         innerXml = Regex.Replace(innerXml, @$"<\/?{name}>", string.Empty, RegexOptions.None, TimeSpan.FromSeconds(1)).Trim();
-        innerXml = Regex.Replace(innerXml, @"<para\s*\/>|<\/para>", Environment.NewLine, RegexOptions.None, TimeSpan.FromSeconds(1));
-        innerXml = Regex.Replace(innerXml, @"<see cref=""\w:([^\""]*)""\s*\/>", m => ResolveSeeElement(m, @namespace), RegexOptions.None, TimeSpan.FromSeconds(1));
-        innerXml = Regex.Replace(innerXml, @"<(type)*paramref name=""([^\""]*)""\s*\/>", e => $"`{e.Groups[2].Value}`", RegexOptions.None, TimeSpan.FromSeconds(1));
-        innerXml = Regex.Replace(innerXml, @"<c\b[^>]*>(.*?)<\/c>", e => $"`{e.Groups[1].Value}`", RegexOptions.None, TimeSpan.FromSeconds(1));
+        innerXml = ParaTagRegex.Replace(innerXml, Environment.NewLine);
+        innerXml = SeeCrefRegex.Replace(innerXml, m => ResolveSeeElement(m, @namespace));
+        innerXml = ParamRefRegex.Replace(innerXml, e => $"`{e.Groups[2].Value}`");
+        innerXml = CodeTagRegex.Replace(innerXml, e => $"`{e.Groups[1].Value}`");
         innerXml = innerXml.TrimExtended();
 
         var lines = innerXml

From 01ee834aaebcd954299936d5a89ca14eae75e444 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 02:26:46 +0200
Subject: [PATCH 051/100] fix(atc-xunit): fix handle leak, false-negative
 suppression, and O(n) contains
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- DecompilerHelper: wrap the validation PEFile in using to close the native handle
  immediately; null-guard testType.FullName before passing to FullTypeName ctor
- ParametersNamingMatchHelper: tighten the Constants auto-pass from Contains("Constants")
  to EndsWith("Constants") && parameter.ParameterType == typeof(Type) — previously
  any test that referenced a *Constants* type was silently marked as covered regardless
  of whether the method under test was actually exercised
- AnalyzerHelper: replace List<MethodInfo> + Contains(method) with HashSet<MethodInfo>
  to eliminate O(n) lookup inside the per-instruction loop
---
 .../AbstractSyntaxTree/DecompilerHelper.cs      |  9 +++++++++
 .../ParametersNamingMatchHelper.cs              |  7 ++++++-
 .../Internal/MonoReflection/AnalyzerHelper.cs   | 17 +++++++----------
 3 files changed, 22 insertions(+), 11 deletions(-)

diff --git a/src/Atc.XUnit/Internal/AbstractSyntaxTree/DecompilerHelper.cs b/src/Atc.XUnit/Internal/AbstractSyntaxTree/DecompilerHelper.cs
index 473ed41b..2c3f9340 100644
--- a/src/Atc.XUnit/Internal/AbstractSyntaxTree/DecompilerHelper.cs
+++ b/src/Atc.XUnit/Internal/AbstractSyntaxTree/DecompilerHelper.cs
@@ -6,6 +6,10 @@ internal static class DecompilerHelper
     internal static CSharpDecompiler GetDecompiler(Assembly assembly)
     {
         var assemblyFileName = assembly.Location;
+
+        // PEFile is used here only to validate the assembly; the resolver is the long-lived handle.
+        // The resolver itself is not IDisposable so it cannot be wrapped in using, but we close the
+        // validation PEFile immediately to avoid keeping the native handle open.
         using var module = new PEFile(assemblyFileName);
         var resolver = new UniversalAssemblyResolver(assemblyFileName, false, targetFramework: null);
         return new CSharpDecompiler(assemblyFileName, resolver, GetSettings());
@@ -24,6 +28,11 @@ internal static Tuple<MethodInfo, MethodDeclaration>[] GetTestMethodsWithDecompi
         var testMethods = new List<Tuple<MethodInfo, MethodDeclaration>>();
         foreach ((Type testType, MethodInfo[] testMethodInfos) in testTypeMethods)
         {
+            if (testType.FullName is null)
+            {
+                continue;
+            }
+
             var fullTypeName = new FullTypeName(testType.FullName);
             var syntaxTree = decompiler.DecompileType(fullTypeName);
             var astNodes = syntaxTree
diff --git a/src/Atc.XUnit/Internal/AbstractSyntaxTree/ParametersNamingMatchHelper.cs b/src/Atc.XUnit/Internal/AbstractSyntaxTree/ParametersNamingMatchHelper.cs
index 0ed0b6f6..3b70053a 100644
--- a/src/Atc.XUnit/Internal/AbstractSyntaxTree/ParametersNamingMatchHelper.cs
+++ b/src/Atc.XUnit/Internal/AbstractSyntaxTree/ParametersNamingMatchHelper.cs
@@ -252,7 +252,12 @@ private static bool ParameterCheckForMemberReferenceExpression(
                 return true;
             }
 
-            if (astNodeTypeName.Contains("Constants", StringComparison.Ordinal))
+            // Only auto-pass a TypeReferenceExpression for a constants type when the parameter
+            // itself is of type System.Type (i.e., the test passes typeof(SomeConstants)).
+            // The previous broad Contains("Constants") check caused any test referencing a
+            // *Constants* type to be silently marked as covered, causing false negatives.
+            if (astNodeTypeName.EndsWith("Constants", StringComparison.Ordinal) &&
+                parameter.ParameterType == typeof(Type))
             {
                 return true;
             }
diff --git a/src/Atc.XUnit/Internal/MonoReflection/AnalyzerHelper.cs b/src/Atc.XUnit/Internal/MonoReflection/AnalyzerHelper.cs
index e5d93143..e5c7faaa 100644
--- a/src/Atc.XUnit/Internal/MonoReflection/AnalyzerHelper.cs
+++ b/src/Atc.XUnit/Internal/MonoReflection/AnalyzerHelper.cs
@@ -70,7 +70,7 @@ internal static MethodInfo[] GetUsedSourceMethods(
         Type[] sourceTypes,
         Tuple<Type, MethodInfo[]>[] testTypeMethods)
     {
-        var list = new List<MethodInfo>();
+        var set = new HashSet<MethodInfo>();
         foreach (var tuple in testTypeMethods)
         {
             foreach (var method in tuple.Item2)
@@ -78,12 +78,12 @@ internal static MethodInfo[] GetUsedSourceMethods(
                 var instructions = method.GetInstructions();
                 foreach (var instruction in instructions)
                 {
-                    ProcessInstruction(instruction, sourceTypes, list);
+                    ProcessInstruction(instruction, sourceTypes, set);
                 }
             }
         }
 
-        return list
+        return set
             .OrderBy(x => x.DeclaringType?.Name, StringComparer.Ordinal)
             .ThenBy(x => x.Name, StringComparer.Ordinal)
             .ToArray();
@@ -92,7 +92,7 @@ internal static MethodInfo[] GetUsedSourceMethods(
     private static void ProcessInstruction(
         Instruction instruction,
         Type[] sourceTypes,
-        List<MethodInfo> list)
+        HashSet<MethodInfo> set)
     {
         if (instruction.Operand is not MethodInfo usedMethodInTest)
         {
@@ -111,9 +111,9 @@ private static void ProcessInstruction(
         {
             // Try to find the original method from the state machine
             var originalMethod = TryGetOriginalMethodFromStateMachine(type, sourceTypes);
-            if (originalMethod is not null && !list.Contains(originalMethod))
+            if (originalMethod is not null)
             {
-                list.Add(originalMethod);
+                set.Add(originalMethod);
                 return;
             }
         }
@@ -135,10 +135,7 @@ private static void ProcessInstruction(
             ? usedMethodInTest.GetGenericMethodDefinition()
             : usedMethodInTest;
 
-        if (!list.Contains(methodToAdd))
-        {
-            list.Add(methodToAdd);
-        }
+        set.Add(methodToAdd);
     }
 
     [SuppressMessage("Performance", "MA0009:Regular expressions should not be vulnerable to Denial of Service attacks", Justification = "OK - Simple pattern for compiler-generated names")]

From c4a917b017a61b373fa1bfdcd56a400b4ec37b76 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 10:50:22 +0200
Subject: [PATCH 052/100] feat(atc): add CancellationToken support across async
 APIs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add async/CancellationToken overloads to five gap areas identified in
the roadmap: StreamExtensions (CopyToStreamAsync, ToBytesAsync,
ToStringDataAsync), JsonSerializerHelper (new — async stream-based
serialize/deserialize), NetworkInformationHelper (6 async counterparts
for all sync methods), AsyncEnumerableFactory (FromItems, FromEnumerable,
FromTask with [EnumeratorCancellation]), and Atc.XUnit
CodeComplianceTestHelper/AssemblyTestHelper (CancellationToken on all
public methods). Includes full test coverage and updated CodeDoc.
---
 docs/CodeDoc/Atc/Atc.Factories.md             |  36 +++-
 docs/CodeDoc/Atc/Atc.Helpers.md               |  62 ++++++
 docs/CodeDoc/Atc/Atc.Serialization.md         |  59 ++++++
 docs/CodeDoc/Atc/Index.md                     |   1 +
 docs/CodeDoc/Atc/IndexExtended.md             |  20 +-
 docs/CodeDoc/Atc/System.IO.md                 |  34 +++
 src/Atc.XUnit/CodeComplianceTestHelper.cs     |  69 ++++--
 src/Atc.XUnit/Internal/AssemblyTestHelper.cs  |  22 +-
 src/Atc/Extensions/StreamExtensions.cs        |  85 ++++++++
 src/Atc/Factories/AsyncEnumerableFactory.cs   | 100 ++++++++-
 src/Atc/Helpers/NetworkInformationHelper.cs   | 196 ++++++++++++++++++
 src/Atc/Serialization/JsonSerializerHelper.cs | 119 +++++++++++
 test/Atc.Tests/CodeComplianceTests.cs         |   4 +
 .../Extensions/StreamExtensionsTests.cs       | 154 ++++++++++++++
 .../Factories/AsyncEnumerableFactoryTests.cs  | 143 +++++++++++++
 .../Helpers/NetworkInformationHelperTests.cs  |  49 +++++
 .../JsonSerializerHelperTests.cs              | 103 +++++++++
 17 files changed, 1227 insertions(+), 29 deletions(-)
 create mode 100644 src/Atc/Serialization/JsonSerializerHelper.cs
 create mode 100644 test/Atc.Tests/Serialization/JsonSerializerHelperTests.cs

diff --git a/docs/CodeDoc/Atc/Atc.Factories.md b/docs/CodeDoc/Atc/Atc.Factories.md
index e7f937ac..ff421b2e 100644
--- a/docs/CodeDoc/Atc/Atc.Factories.md
+++ b/docs/CodeDoc/Atc/Atc.Factories.md
@@ -23,14 +23,48 @@ Provides factory methods for creating instances of `System.Collections.Generic.I
 ><b>Summary:</b> Returns an empty `System.Collections.Generic.IAsyncEnumerable`1`.
 >
 ><b>Returns:</b> An empty `System.Collections.Generic.IAsyncEnumerable`1`.
+#### FromEnumerable
+>```csharp
+>IAsyncEnumerable<T> FromEnumerable(IEnumerable<T> source, CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Wraps an `System.Collections.Generic.IEnumerable`1` as an `System.Collections.Generic.IAsyncEnumerable`1`, yielding each element in order.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`source`&nbsp;&nbsp;-&nbsp;&nbsp;The synchronous sequence to wrap.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the asynchronous iteration; checked before each element is yielded.<br />
+>
+><b>Returns:</b> An `System.Collections.Generic.IAsyncEnumerable`1` that yields each element of `source`.
+#### FromItems
+>```csharp
+>IAsyncEnumerable<T> FromItems(T[] items, CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Wraps an array of items as an `System.Collections.Generic.IAsyncEnumerable`1`, yielding each item in order.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`items`&nbsp;&nbsp;-&nbsp;&nbsp;The items to yield.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the asynchronous iteration; checked before each item is yielded.<br />
+>
+><b>Returns:</b> An `System.Collections.Generic.IAsyncEnumerable`1` that yields each element of `items`.
 #### FromSingleItem
 >```csharp
->IAsyncEnumerable<T> FromSingleItem(T item)
+>IAsyncEnumerable<T> FromSingleItem(T item, CancellationToken cancellationToken = null)
 >```
 ><b>Summary:</b> Converts a single item into an `System.Collections.Generic.IAsyncEnumerable`1`.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`item`&nbsp;&nbsp;-&nbsp;&nbsp;The item to convert.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the asynchronous iteration.<br />
 >
 ><b>Returns:</b> An `System.Collections.Generic.IAsyncEnumerable`1` containing the single item.
+#### FromTask
+>```csharp
+>IAsyncEnumerable<T> FromTask(Task<T> task, CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Creates an `System.Collections.Generic.IAsyncEnumerable`1` that awaits the specified task and yields its result as a single element.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`task`&nbsp;&nbsp;-&nbsp;&nbsp;The task whose result will be yielded.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the asynchronous operation before the task is awaited.<br />
+>
+><b>Returns:</b> An `System.Collections.Generic.IAsyncEnumerable`1` that yields the single result of `task`.
 <hr /><div style='text-align: right'><i>Generated by MarkdownCodeDoc version 1.2</i></div>
diff --git a/docs/CodeDoc/Atc/Atc.Helpers.md b/docs/CodeDoc/Atc/Atc.Helpers.md
index a1c42d77..e5dcf17c 100644
--- a/docs/CodeDoc/Atc/Atc.Helpers.md
+++ b/docs/CodeDoc/Atc/Atc.Helpers.md
@@ -2142,6 +2142,16 @@ Provides utility methods for checking network connectivity and retrieving networ
 ><b>Summary:</b> Retrieves the public IP address of the current machine by querying an external service (api.ipify.org).
 >
 ><b>Returns:</b> The public `System.Net.IPAddress` if retrieval succeeds; otherwise, <see langword="null" />.
+#### GetPublicIpAddressAsync
+>```csharp
+>Task<IPAddress> GetPublicIpAddressAsync(CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Asynchronously retrieves the public IP address of the current machine by querying an external service (api.ipify.org).
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the asynchronous operation.<br />
+>
+><b>Returns:</b> The public `System.Net.IPAddress` if retrieval succeeds; otherwise, <see langword="null" />.
 #### HasConnection
 >```csharp
 >bool HasConnection()
@@ -2156,6 +2166,26 @@ Provides utility methods for checking network connectivity and retrieving networ
 ><b>Summary:</b> Determines whether there is network connectivity by pinging Google's DNS server (8.8.8.8).
 >
 ><b>Returns:</b> <see langword="true" /> if a ping response is received; otherwise, <see langword="false" />.
+#### HasConnectionAsync
+>```csharp
+>Task<bool> HasConnectionAsync(CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Asynchronously determines whether there is network connectivity by pinging Google's DNS server (8.8.8.8).
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the asynchronous operation.<br />
+>
+><b>Returns:</b> <see langword="true" /> if a ping response is received; otherwise, <see langword="false" />.
+#### HasConnectionAsync
+>```csharp
+>Task<bool> HasConnectionAsync(IPAddress ipAddress, CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Asynchronously determines whether there is network connectivity by pinging Google's DNS server (8.8.8.8).
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the asynchronous operation.<br />
+>
+><b>Returns:</b> <see langword="true" /> if a ping response is received; otherwise, <see langword="false" />.
 #### HasHttpConnection
 >```csharp
 >bool HasHttpConnection()
@@ -2170,6 +2200,26 @@ Provides utility methods for checking network connectivity and retrieving networ
 ><b>Summary:</b> Determines whether there is HTTP connectivity by making a request to Google's website.
 >
 ><b>Returns:</b> <see langword="true" /> if the HTTP request succeeds; otherwise, <see langword="false" />.
+#### HasHttpConnectionAsync
+>```csharp
+>Task<bool> HasHttpConnectionAsync(CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Asynchronously determines whether there is HTTP connectivity by making a request to Google's website.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the asynchronous operation.<br />
+>
+><b>Returns:</b> <see langword="true" /> if the HTTP request succeeds; otherwise, <see langword="false" />.
+#### HasHttpConnectionAsync
+>```csharp
+>Task<bool> HasHttpConnectionAsync(Uri uri, CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Asynchronously determines whether there is HTTP connectivity by making a request to Google's website.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the asynchronous operation.<br />
+>
+><b>Returns:</b> <see langword="true" /> if the HTTP request succeeds; otherwise, <see langword="false" />.
 #### HasTcpConnection
 >```csharp
 >bool HasTcpConnection(IPAddress ipAddress, int port)
@@ -2181,6 +2231,18 @@ Provides utility methods for checking network connectivity and retrieving networ
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`port`&nbsp;&nbsp;-&nbsp;&nbsp;The port number to connect to.<br />
 >
 ><b>Returns:</b> <see langword="true" /> if the TCP connection succeeds; otherwise, <see langword="false" />.
+#### HasTcpConnectionAsync
+>```csharp
+>Task<bool> HasTcpConnectionAsync(IPAddress ipAddress, int port, CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Asynchronously determines whether a TCP connection can be established to the specified IP address and port. A connection timeout of 5 seconds is applied; pass a pre-cancelled token to impose a shorter deadline.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`ipAddress`&nbsp;&nbsp;-&nbsp;&nbsp;The IP address to connect to.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`port`&nbsp;&nbsp;-&nbsp;&nbsp;The port number to connect to.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the asynchronous operation.<br />
+>
+><b>Returns:</b> <see langword="true" /> if the TCP connection succeeds within the timeout; otherwise, <see langword="false" />.
 
 <br />
 
diff --git a/docs/CodeDoc/Atc/Atc.Serialization.md b/docs/CodeDoc/Atc/Atc.Serialization.md
index 0344bb65..a2c13387 100644
--- a/docs/CodeDoc/Atc/Atc.Serialization.md
+++ b/docs/CodeDoc/Atc/Atc.Serialization.md
@@ -152,6 +152,65 @@ Configuration settings for creating `System.Text.Json.JsonSerializerOptions` ins
 
 <br />
 
+## JsonSerializerHelper
+Provides async stream-based serialization and deserialization helpers using `System.Text.Json.JsonSerializer`.
+><b>Remarks:</b> All overloads that omit `System.Text.Json.JsonSerializerOptions` use `Atc.Serialization.JsonSerializerOptionsFactory` default options.
+
+>```csharp
+>public static class JsonSerializerHelper
+>```
+
+### Static Methods
+
+#### DeserializeFromStreamAsync
+>```csharp
+>Task<T> DeserializeFromStreamAsync(Stream stream, CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Asynchronously deserializes a value of type `T` from the specified UTF-8 JSON stream using the default serializer options.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`stream`&nbsp;&nbsp;-&nbsp;&nbsp;The UTF-8 encoded JSON stream to read from.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the asynchronous operation.<br />
+>
+><b>Returns:</b> A `System.Threading.Tasks.Task`1` that represents the asynchronous operation, containing the deserialized value, or <see langword="null" /> if the stream contains a JSON null literal.
+#### DeserializeFromStreamAsync
+>```csharp
+>Task<T> DeserializeFromStreamAsync(Stream stream, JsonSerializerOptions options, CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Asynchronously deserializes a value of type `T` from the specified UTF-8 JSON stream using the default serializer options.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`stream`&nbsp;&nbsp;-&nbsp;&nbsp;The UTF-8 encoded JSON stream to read from.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the asynchronous operation.<br />
+>
+><b>Returns:</b> A `System.Threading.Tasks.Task`1` that represents the asynchronous operation, containing the deserialized value, or <see langword="null" /> if the stream contains a JSON null literal.
+#### SerializeToStreamAsync
+>```csharp
+>Task SerializeToStreamAsync(T value, Stream stream, CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Asynchronously serializes `value` as UTF-8 JSON into the specified stream using the default serializer options.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The value to serialize.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`stream`&nbsp;&nbsp;-&nbsp;&nbsp;The stream to write JSON into.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the asynchronous operation.<br />
+>
+><b>Returns:</b> A `System.Threading.Tasks.Task` that represents the asynchronous write operation.
+#### SerializeToStreamAsync
+>```csharp
+>Task SerializeToStreamAsync(T value, Stream stream, JsonSerializerOptions options, CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Asynchronously serializes `value` as UTF-8 JSON into the specified stream using the default serializer options.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The value to serialize.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`stream`&nbsp;&nbsp;-&nbsp;&nbsp;The stream to write JSON into.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the asynchronous operation.<br />
+>
+><b>Returns:</b> A `System.Threading.Tasks.Task` that represents the asynchronous write operation.
+
+<br />
+
 ## JsonSerializerOptionsFactory
 Factory class for creating preconfigured `System.Text.Json.JsonSerializerOptions` instances.
 ><b>Remarks:</b> This factory provides convenient methods to create `System.Text.Json.JsonSerializerOptions` with common settings and custom converters. It supports both parameter-based and settings-based configuration.
diff --git a/docs/CodeDoc/Atc/Index.md b/docs/CodeDoc/Atc/Index.md
index e0faf4d8..0dc6a121 100644
--- a/docs/CodeDoc/Atc/Index.md
+++ b/docs/CodeDoc/Atc/Index.md
@@ -145,6 +145,7 @@
 
 - [DynamicJson](Atc.Serialization.md#dynamicjson)
 - [JsonSerializerFactorySettings](Atc.Serialization.md#jsonserializerfactorysettings)
+- [JsonSerializerHelper](Atc.Serialization.md#jsonserializerhelper)
 - [JsonSerializerOptionsFactory](Atc.Serialization.md#jsonserializeroptionsfactory)
 
 ## [Atc.Serialization.JsonConverters](Atc.Serialization.JsonConverters.md)
diff --git a/docs/CodeDoc/Atc/IndexExtended.md b/docs/CodeDoc/Atc/IndexExtended.md
index bbc30434..bb9a301c 100644
--- a/docs/CodeDoc/Atc/IndexExtended.md
+++ b/docs/CodeDoc/Atc/IndexExtended.md
@@ -4401,7 +4401,10 @@
 - [AsyncEnumerableFactory](Atc.Factories.md#asyncenumerablefactory)
   -  Static Methods
      - Empty()
-     - FromSingleItem(T item)
+     - FromEnumerable(IEnumerable&lt;T&gt; source, CancellationToken cancellationToken = null)
+     - FromItems(T[] items, CancellationToken cancellationToken = null)
+     - FromSingleItem(T item, CancellationToken cancellationToken = null)
+     - FromTask(Task&lt;T&gt; task, CancellationToken cancellationToken = null)
 
 ## [Atc.Helpers](Atc.Helpers.md)
 
@@ -4650,11 +4653,17 @@
 - [NetworkInformationHelper](Atc.Helpers.md#networkinformationhelper)
   -  Static Methods
      - GetPublicIpAddress()
+     - GetPublicIpAddressAsync(CancellationToken cancellationToken = null)
      - HasConnection()
      - HasConnection(IPAddress ipAddress)
+     - HasConnectionAsync(CancellationToken cancellationToken = null)
+     - HasConnectionAsync(IPAddress ipAddress, CancellationToken cancellationToken = null)
      - HasHttpConnection()
      - HasHttpConnection(Uri uri)
+     - HasHttpConnectionAsync(CancellationToken cancellationToken = null)
+     - HasHttpConnectionAsync(Uri uri, CancellationToken cancellationToken = null)
      - HasTcpConnection(IPAddress ipAddress, int port)
+     - HasTcpConnectionAsync(IPAddress ipAddress, int port, CancellationToken cancellationToken = null)
 - [NumberHelper](Atc.Helpers.md#numberhelper)
   -  Static Methods
      - IsDecimal(string value)
@@ -4882,6 +4891,12 @@
      - UseConverterUnixDatetimeOffset
      - UseConverterVersion
      - WriteIndented
+- [JsonSerializerHelper](Atc.Serialization.md#jsonserializerhelper)
+  -  Static Methods
+     - DeserializeFromStreamAsync(Stream stream, CancellationToken cancellationToken = null)
+     - DeserializeFromStreamAsync(Stream stream, JsonSerializerOptions options, CancellationToken cancellationToken = null)
+     - SerializeToStreamAsync(T value, Stream stream, CancellationToken cancellationToken = null)
+     - SerializeToStreamAsync(T value, Stream stream, JsonSerializerOptions options, CancellationToken cancellationToken = null)
 - [JsonSerializerOptionsFactory](Atc.Serialization.md#jsonserializeroptionsfactory)
   -  Static Methods
      - Create(JsonSerializerFactorySettings settings)
@@ -5503,8 +5518,11 @@
 - [StreamExtensions](System.IO.md#streamextensions)
   -  Static Methods
      - CopyToStream(this Stream stream, int bufferSize = 4096)
+     - CopyToStreamAsync(this Stream stream, int bufferSize = 4096, CancellationToken cancellationToken = null)
      - ToBytes(this Stream stream)
+     - ToBytesAsync(this Stream stream, CancellationToken cancellationToken = null)
      - ToStringData(this Stream stream)
+     - ToStringDataAsync(this Stream stream, CancellationToken cancellationToken = null)
 
 ## [System.Net](System.Net.md)
 
diff --git a/docs/CodeDoc/Atc/System.IO.md b/docs/CodeDoc/Atc/System.IO.md
index b7e7e7b1..3336b81d 100644
--- a/docs/CodeDoc/Atc/System.IO.md
+++ b/docs/CodeDoc/Atc/System.IO.md
@@ -206,6 +206,18 @@ Extensions for the `System.IO.Stream` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`bufferSize`&nbsp;&nbsp;-&nbsp;&nbsp;The size of the buffer used for copying. Defaults to 4096 bytes.<br />
 >
 ><b>Returns:</b> A new `System.IO.MemoryStream` containing the copied data with position set to 0.
+#### CopyToStreamAsync
+>```csharp
+>Task<Stream> CopyToStreamAsync(this Stream stream, int bufferSize = 4096, CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Asynchronously copies the contents of the stream to a new `System.IO.MemoryStream`.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`stream`&nbsp;&nbsp;-&nbsp;&nbsp;The source stream to copy from. The stream position will be reset to 0 before copying if the stream supports seeking.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`bufferSize`&nbsp;&nbsp;-&nbsp;&nbsp;The size of the buffer used for copying. Defaults to 4096 bytes.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the asynchronous operation.<br />
+>
+><b>Returns:</b> A `System.Threading.Tasks.Task`1` that represents the asynchronous operation, containing a new `System.IO.MemoryStream` with position set to 0.
 #### ToBytes
 >```csharp
 >byte[] ToBytes(this Stream stream)
@@ -216,6 +228,17 @@ Extensions for the `System.IO.Stream` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`stream`&nbsp;&nbsp;-&nbsp;&nbsp;The stream to read from. The stream position will be reset to 0 before reading.<br />
 >
 ><b>Returns:</b> A byte array containing all data from the stream.
+#### ToBytesAsync
+>```csharp
+>Task<byte[]> ToBytesAsync(this Stream stream, CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Asynchronously reads all bytes from the stream and returns them as a byte array.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`stream`&nbsp;&nbsp;-&nbsp;&nbsp;The stream to read from. The stream position will be reset to 0 before reading if the stream supports seeking.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the asynchronous operation.<br />
+>
+><b>Returns:</b> A `System.Threading.Tasks.Task`1` that represents the asynchronous operation, containing a byte array with all data from the stream.
 #### ToStringData
 >```csharp
 >string ToStringData(this Stream stream)
@@ -226,4 +249,15 @@ Extensions for the `System.IO.Stream` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`stream`&nbsp;&nbsp;-&nbsp;&nbsp;The stream to read from. The stream position will be reset to 0 before reading.<br />
 >
 ><b>Returns:</b> A string containing all text content from the stream.
+#### ToStringDataAsync
+>```csharp
+>Task<string> ToStringDataAsync(this Stream stream, CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Asynchronously reads all content from the stream and converts it to a string using UTF-8 encoding.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`stream`&nbsp;&nbsp;-&nbsp;&nbsp;The stream to read from. The stream position will be reset to 0 before reading if the stream supports seeking.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the asynchronous operation.<br />
+>
+><b>Returns:</b> A `System.Threading.Tasks.Task`1` that represents the asynchronous operation, containing a string with all text content from the stream.
 <hr /><div style='text-align: right'><i>Generated by MarkdownCodeDoc version 1.2</i></div>
diff --git a/src/Atc.XUnit/CodeComplianceTestHelper.cs b/src/Atc.XUnit/CodeComplianceTestHelper.cs
index f14f5b14..701596b0 100644
--- a/src/Atc.XUnit/CodeComplianceTestHelper.cs
+++ b/src/Atc.XUnit/CodeComplianceTestHelper.cs
@@ -13,11 +13,13 @@ public static class CodeComplianceTestHelper
     /// <param name="sourceType">The source type to validate for test coverage.</param>
     /// <param name="testType">The test type containing unit tests for the source type.</param>
     /// <param name="useFullName">If set to <c>true</c>, use full type names in output.</param>
+    /// <param name="cancellationToken">A token to cancel the analysis operation.</param>
     public static void AssertExportedMethodsWithMissingTests(
         DecompilerType decompilerType,
         Type sourceType,
         Type testType,
-        bool useFullName = false)
+        bool useFullName = false,
+        CancellationToken cancellationToken = default)
     {
         if (sourceType is null)
         {
@@ -32,7 +34,8 @@ public static void AssertExportedMethodsWithMissingTests(
         var methodsWithMissingTests = AssemblyTestHelper.CollectExportedMethodsWithMissingTests(
             decompilerType,
             sourceType,
-            testType);
+            testType,
+            cancellationToken);
         TestResultHelper.AssertOnTestResultsFromMethodsWithMissingTests(
             sourceType.Assembly.GetName().Name!,
             methodsWithMissingTests,
@@ -47,11 +50,13 @@ public static void AssertExportedMethodsWithMissingTests(
     /// <param name="sourceType">The source type to validate for test coverage.</param>
     /// <param name="testAssembly">The test assembly to search for unit tests.</param>
     /// <param name="useFullName">If set to <c>true</c>, use full type names in output.</param>
+    /// <param name="cancellationToken">A token to cancel the analysis operation.</param>
     public static void AssertExportedMethodsWithMissingTests(
         DecompilerType decompilerType,
         Type sourceType,
         Assembly testAssembly,
-        bool useFullName = false)
+        bool useFullName = false,
+        CancellationToken cancellationToken = default)
     {
         if (sourceType is null)
         {
@@ -61,7 +66,8 @@ public static void AssertExportedMethodsWithMissingTests(
         var methodsWithMissingTests = AssemblyTestHelper.CollectExportedMethodsWithMissingTests(
             decompilerType,
             sourceType,
-            testAssembly);
+            testAssembly,
+            cancellationToken);
         TestResultHelper.AssertOnTestResultsFromMethodsWithMissingTests(
             sourceType.Assembly.GetName().Name!,
             methodsWithMissingTests,
@@ -77,12 +83,14 @@ public static void AssertExportedMethodsWithMissingTests(
     /// <param name="testAssembly">The test assembly containing unit tests.</param>
     /// <param name="excludeSourceTypes">Optional list of source types to exclude from validation.</param>
     /// <param name="useFullName">If set to <c>true</c>, use full type names in output.</param>
+    /// <param name="cancellationToken">A token to cancel the analysis operation.</param>
     public static void AssertExportedMethodsWithMissingTests(
         DecompilerType decompilerType,
         Assembly sourceAssembly,
         Assembly testAssembly,
         List<Type>? excludeSourceTypes = null,
-        bool useFullName = false)
+        bool useFullName = false,
+        CancellationToken cancellationToken = default)
     {
         if (sourceAssembly is null)
         {
@@ -98,7 +106,8 @@ public static void AssertExportedMethodsWithMissingTests(
             decompilerType,
             sourceAssembly,
             testAssembly,
-            excludeSourceTypes);
+            excludeSourceTypes,
+            cancellationToken);
         TestResultHelper.AssertOnTestResultsFromMethodsWithMissingTests(
             sourceAssembly.GetName().Name!,
             methodsWithMissingTests,
@@ -112,12 +121,14 @@ public static void AssertExportedMethodsWithMissingTests(
     /// <param name="sourceAssembly">The source assembly to analyze.</param>
     /// <param name="testAssembly">The test assembly to search for unit tests.</param>
     /// <param name="excludeSourceTypes">Optional list of source types to exclude from analysis.</param>
+    /// <param name="cancellationToken">A token to cancel the analysis operation.</param>
     /// <returns>An array of types that have methods missing test coverage.</returns>
     public static Type[] CollectExportedTypesWithMissingTests(
         DecompilerType decompilerType,
         Assembly sourceAssembly,
         Assembly testAssembly,
-        List<Type>? excludeSourceTypes = null)
+        List<Type>? excludeSourceTypes = null,
+        CancellationToken cancellationToken = default)
     {
         if (sourceAssembly is null)
         {
@@ -133,7 +144,8 @@ public static Type[] CollectExportedTypesWithMissingTests(
             decompilerType,
             sourceAssembly,
             testAssembly,
-            excludeSourceTypes);
+            excludeSourceTypes,
+            cancellationToken);
     }
 
     /// <summary>
@@ -145,13 +157,15 @@ public static Type[] CollectExportedTypesWithMissingTests(
     /// <param name="testAssembly">The test assembly to search for unit tests.</param>
     /// <param name="excludeSourceTypes">Optional list of source types to exclude from analysis.</param>
     /// <param name="useFullName">If set to <c>true</c>, use full type names in output.</param>
+    /// <param name="cancellationToken">A token to cancel the analysis operation.</param>
     /// <returns>A formatted C# code snippet containing a list of typeof() expressions for types missing tests.</returns>
     public static string CollectExportedTypesWithMissingTestsAndGenerateText(
         DecompilerType decompilerType,
         Assembly sourceAssembly,
         Assembly testAssembly,
         List<Type>? excludeSourceTypes = null,
-        bool useFullName = false)
+        bool useFullName = false,
+        CancellationToken cancellationToken = default)
     {
         if (sourceAssembly is null)
         {
@@ -167,7 +181,8 @@ public static string CollectExportedTypesWithMissingTestsAndGenerateText(
             decompilerType,
             sourceAssembly,
             testAssembly,
-            excludeSourceTypes);
+            excludeSourceTypes,
+            cancellationToken);
 
         var sb = new StringBuilder();
         sb.AppendLine(12, "var excludeTypes = new List<Type>");
@@ -203,12 +218,14 @@ public static string CollectExportedTypesWithMissingTestsAndGenerateText(
     /// <param name="sourceAssembly">The source assembly to analyze.</param>
     /// <param name="testAssembly">The test assembly to search for unit tests.</param>
     /// <param name="excludeSourceTypes">Optional list of source types to exclude from analysis.</param>
+    /// <param name="cancellationToken">A token to cancel the analysis operation.</param>
     /// <returns>An array of <see cref="MethodInfo"/> objects representing methods missing test coverage.</returns>
     public static MethodInfo[] CollectExportedMethodsWithMissingTestsFromAssembly(
         DecompilerType decompilerType,
         Assembly sourceAssembly,
         Assembly testAssembly,
-        List<Type>? excludeSourceTypes = null)
+        List<Type>? excludeSourceTypes = null,
+        CancellationToken cancellationToken = default)
     {
         if (sourceAssembly is null)
         {
@@ -220,7 +237,7 @@ public static MethodInfo[] CollectExportedMethodsWithMissingTestsFromAssembly(
             throw new ArgumentNullException(nameof(testAssembly));
         }
 
-        return AssemblyTestHelper.CollectExportedMethodsWithMissingTests(decompilerType, sourceAssembly, testAssembly, excludeSourceTypes);
+        return AssemblyTestHelper.CollectExportedMethodsWithMissingTests(decompilerType, sourceAssembly, testAssembly, excludeSourceTypes, cancellationToken);
     }
 
     /// <summary>
@@ -231,13 +248,15 @@ public static MethodInfo[] CollectExportedMethodsWithMissingTestsFromAssembly(
     /// <param name="testAssembly">The test assembly to search for unit tests.</param>
     /// <param name="excludeSourceTypes">Optional list of source types to exclude from analysis.</param>
     /// <param name="useFullName">If set to <c>true</c>, use full type names in output.</param>
+    /// <param name="cancellationToken">A token to cancel the analysis operation.</param>
     /// <returns>An array of strings containing beautified method signatures.</returns>
     public static string[] CollectExportedMethodsWithMissingTestsAndGenerateTextLines(
         DecompilerType decompilerType,
         Assembly sourceAssembly,
         Assembly testAssembly,
         List<Type>? excludeSourceTypes = null,
-        bool useFullName = false)
+        bool useFullName = false,
+        CancellationToken cancellationToken = default)
     {
         if (sourceAssembly is null)
         {
@@ -249,7 +268,7 @@ public static string[] CollectExportedMethodsWithMissingTestsAndGenerateTextLine
             throw new ArgumentNullException(nameof(testAssembly));
         }
 
-        var methodsWithMissingTests = AssemblyTestHelper.CollectExportedMethodsWithMissingTests(decompilerType, sourceAssembly, testAssembly, excludeSourceTypes);
+        var methodsWithMissingTests = AssemblyTestHelper.CollectExportedMethodsWithMissingTests(decompilerType, sourceAssembly, testAssembly, excludeSourceTypes, cancellationToken);
         return AssemblyTestHelper.GetMethodsAsRenderTextLines(methodsWithMissingTests, useFullName);
     }
 
@@ -261,13 +280,15 @@ public static string[] CollectExportedMethodsWithMissingTestsAndGenerateTextLine
     /// <param name="testAssembly">The test assembly to search for unit tests.</param>
     /// <param name="excludeSourceTypes">Optional list of source types to exclude from analysis.</param>
     /// <param name="useFullName">If set to <c>true</c>, use full type names in output.</param>
+    /// <param name="cancellationToken">A token to cancel the analysis operation.</param>
     /// <returns>A multi-line string containing all method signatures missing tests.</returns>
     public static string CollectExportedMethodsWithMissingTestsAndGenerateText(
         DecompilerType decompilerType,
         Assembly sourceAssembly,
         Assembly testAssembly,
         List<Type>? excludeSourceTypes = null,
-        bool useFullName = false)
+        bool useFullName = false,
+        CancellationToken cancellationToken = default)
     {
         if (sourceAssembly is null)
         {
@@ -279,22 +300,24 @@ public static string CollectExportedMethodsWithMissingTestsAndGenerateText(
             throw new ArgumentNullException(nameof(testAssembly));
         }
 
-        var methodsWithMissingTests = AssemblyTestHelper.CollectExportedMethodsWithMissingTests(decompilerType, sourceAssembly, testAssembly, excludeSourceTypes);
+        var methodsWithMissingTests = AssemblyTestHelper.CollectExportedMethodsWithMissingTests(decompilerType, sourceAssembly, testAssembly, excludeSourceTypes, cancellationToken);
         return AssemblyTestHelper.GetMethodsAsRenderText(methodsWithMissingTests, useFullName);
     }
 
     /// <summary>
-    /// Collects exported methods with missing tests and exports them to an Excel file at C:\Temp.
+    /// Collects exported methods with missing tests and exports them to an Excel file at the system temp directory.
     /// </summary>
     /// <param name="decompilerType">The <see cref="DecompilerType"/> to use for analyzing test method bodies.</param>
     /// <param name="sourceAssembly">The source assembly to analyze.</param>
     /// <param name="testAssembly">The test assembly to search for unit tests.</param>
     /// <param name="excludeSourceTypes">Optional list of source types to exclude from analysis.</param>
+    /// <param name="cancellationToken">A token to cancel the analysis operation.</param>
     public static void CollectExportedMethodsWithMissingTestsToExcel(
         DecompilerType decompilerType,
         Assembly sourceAssembly,
         Assembly testAssembly,
-        List<Type>? excludeSourceTypes = null)
+        List<Type>? excludeSourceTypes = null,
+        CancellationToken cancellationToken = default)
     {
         if (sourceAssembly is null)
         {
@@ -311,7 +334,8 @@ public static void CollectExportedMethodsWithMissingTestsToExcel(
             new DirectoryInfo(Path.GetTempPath()),
             sourceAssembly,
             testAssembly,
-            excludeSourceTypes);
+            excludeSourceTypes,
+            cancellationToken);
     }
 
     /// <summary>
@@ -322,12 +346,14 @@ public static void CollectExportedMethodsWithMissingTestsToExcel(
     /// <param name="sourceAssembly">The source assembly to analyze.</param>
     /// <param name="testAssembly">The test assembly to search for unit tests.</param>
     /// <param name="excludeSourceTypes">Optional list of source types to exclude from analysis.</param>
+    /// <param name="cancellationToken">A token to cancel the analysis operation.</param>
     public static void CollectExportedMethodsWithMissingTestsToExcel(
         DecompilerType decompilerType,
         DirectoryInfo reportDirectory,
         Assembly sourceAssembly,
         Assembly testAssembly,
-        List<Type>? excludeSourceTypes = null)
+        List<Type>? excludeSourceTypes = null,
+        CancellationToken cancellationToken = default)
     {
         if (reportDirectory is null)
         {
@@ -348,7 +374,8 @@ public static void CollectExportedMethodsWithMissingTestsToExcel(
             decompilerType,
             sourceAssembly,
             testAssembly,
-            excludeSourceTypes);
+            excludeSourceTypes,
+            cancellationToken);
         TestResultHelper.ToExcelTestResultsFromMethodsWithMissingTests(
             reportDirectory,
             sourceAssembly.GetName().Name!,
diff --git a/src/Atc.XUnit/Internal/AssemblyTestHelper.cs b/src/Atc.XUnit/Internal/AssemblyTestHelper.cs
index f379ba74..34e9f27b 100644
--- a/src/Atc.XUnit/Internal/AssemblyTestHelper.cs
+++ b/src/Atc.XUnit/Internal/AssemblyTestHelper.cs
@@ -25,9 +25,10 @@ internal static Type[] CollectExportedTypesWithMissingTests(
         DecompilerType decompilerType,
         Assembly sourceAssembly,
         Assembly testAssembly,
-        List<Type>? excludeSourceTypes)
+        List<Type>? excludeSourceTypes,
+        CancellationToken cancellationToken = default)
     {
-        var methodsWithMissingTests = CollectExportedMethodsWithMissingTests(decompilerType, sourceAssembly, testAssembly, excludeSourceTypes);
+        var methodsWithMissingTests = CollectExportedMethodsWithMissingTests(decompilerType, sourceAssembly, testAssembly, excludeSourceTypes, cancellationToken);
 
         var methodsWithMissingTestsGroups = methodsWithMissingTests
             .OrderBy(x => x.DeclaringType?.FullName, StringComparer.Ordinal)
@@ -43,7 +44,8 @@ internal static Type[] CollectExportedTypesWithMissingTests(
     internal static MethodInfo[] CollectExportedMethodsWithMissingTests(
         DecompilerType decompilerType,
         Type sourceType,
-        Type testType)
+        Type testType,
+        CancellationToken cancellationToken = default)
     {
         if (sourceType is null)
         {
@@ -55,6 +57,8 @@ internal static MethodInfo[] CollectExportedMethodsWithMissingTests(
             throw new ArgumentNullException(nameof(testType));
         }
 
+        cancellationToken.ThrowIfCancellationRequested();
+
         var sourceTypes = new[] { sourceType };
         var testTypes = new[] { testType };
 
@@ -76,7 +80,8 @@ internal static MethodInfo[] CollectExportedMethodsWithMissingTests(
     internal static MethodInfo[] CollectExportedMethodsWithMissingTests(
         DecompilerType decompilerType,
         Type sourceType,
-        Assembly testAssembly)
+        Assembly testAssembly,
+        CancellationToken cancellationToken = default)
     {
         if (sourceType is null)
         {
@@ -88,6 +93,8 @@ internal static MethodInfo[] CollectExportedMethodsWithMissingTests(
             throw new ArgumentNullException(nameof(testAssembly));
         }
 
+        cancellationToken.ThrowIfCancellationRequested();
+
         var sourceTypes = new[] { sourceType };
         var testTypes = testAssembly.ExportedTypes.ToArray();
 
@@ -111,7 +118,8 @@ internal static MethodInfo[] CollectExportedMethodsWithMissingTests(
         DecompilerType decompilerType,
         Assembly sourceAssembly,
         Assembly testAssembly,
-        List<Type>? excludeSourceTypes)
+        List<Type>? excludeSourceTypes,
+        CancellationToken cancellationToken = default)
     {
         if (sourceAssembly is null)
         {
@@ -123,6 +131,8 @@ internal static MethodInfo[] CollectExportedMethodsWithMissingTests(
             throw new ArgumentNullException(nameof(testAssembly));
         }
 
+        cancellationToken.ThrowIfCancellationRequested();
+
         var sourceTypes = sourceAssembly.ExportedTypes
             .Where(x => !x.IsInterface &&
                         !x.IsNested &&
@@ -142,6 +152,8 @@ internal static MethodInfo[] CollectExportedMethodsWithMissingTests(
                 .ToArray();
         }
 
+        cancellationToken.ThrowIfCancellationRequested();
+
         var testTypes = testAssembly.ExportedTypes.ToArray();
         var testTypeMethods = TypeAndMethodAndParameterHelper.GetTypeMethodsWithTestAttributes(testTypes);
         switch (decompilerType)
diff --git a/src/Atc/Extensions/StreamExtensions.cs b/src/Atc/Extensions/StreamExtensions.cs
index 4ac24b44..f9bacb02 100644
--- a/src/Atc/Extensions/StreamExtensions.cs
+++ b/src/Atc/Extensions/StreamExtensions.cs
@@ -77,4 +77,89 @@ public static string ToStringData(this Stream stream)
         using var reader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, bufferSize: -1, leaveOpen: true);
         return reader.ReadToEnd();
     }
+
+    /// <summary>
+    /// Asynchronously copies the contents of the stream to a new <see cref="MemoryStream"/>.
+    /// </summary>
+    /// <param name="stream">The source stream to copy from. The stream position will be reset to 0 before copying if the stream supports seeking.</param>
+    /// <param name="bufferSize">The size of the buffer used for copying. Defaults to 4096 bytes.</param>
+    /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+    /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous operation, containing a new <see cref="MemoryStream"/> with position set to 0.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="stream"/> is <see langword="null"/>.</exception>
+    public static async Task<Stream> CopyToStreamAsync(
+        this Stream stream,
+        int bufferSize = 4096,
+        CancellationToken cancellationToken = default)
+    {
+        if (stream is null)
+        {
+            throw new ArgumentNullException(nameof(stream));
+        }
+
+        if (stream.CanSeek)
+        {
+            stream.Position = 0;
+        }
+
+        var destination = new MemoryStream();
+        await stream.CopyToAsync(destination, bufferSize, cancellationToken).ConfigureAwait(false);
+        destination.Position = 0;
+        return destination;
+    }
+
+    /// <summary>
+    /// Asynchronously reads all bytes from the stream and returns them as a byte array.
+    /// </summary>
+    /// <param name="stream">The stream to read from. The stream position will be reset to 0 before reading if the stream supports seeking.</param>
+    /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+    /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous operation, containing a byte array with all data from the stream.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="stream"/> is <see langword="null"/>.</exception>
+    public static async Task<byte[]> ToBytesAsync(
+        this Stream stream,
+        CancellationToken cancellationToken = default)
+    {
+        if (stream is null)
+        {
+            throw new ArgumentNullException(nameof(stream));
+        }
+
+        if (stream.CanSeek)
+        {
+            stream.Position = 0;
+        }
+
+        using var ms = new MemoryStream();
+        await stream.CopyToAsync(ms, 81920, cancellationToken).ConfigureAwait(false);
+        return ms.ToArray();
+    }
+
+    /// <summary>
+    /// Asynchronously reads all content from the stream and converts it to a string using UTF-8 encoding.
+    /// </summary>
+    /// <param name="stream">The stream to read from. The stream position will be reset to 0 before reading if the stream supports seeking.</param>
+    /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+    /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous operation, containing a string with all text content from the stream.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="stream"/> is <see langword="null"/>.</exception>
+    public static async Task<string> ToStringDataAsync(
+        this Stream stream,
+        CancellationToken cancellationToken = default)
+    {
+        if (stream is null)
+        {
+            throw new ArgumentNullException(nameof(stream));
+        }
+
+        if (stream.CanSeek)
+        {
+            stream.Position = 0;
+        }
+
+        using var reader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, bufferSize: -1, leaveOpen: true);
+#if NET7_0_OR_GREATER
+        return await reader.ReadToEndAsync(cancellationToken).ConfigureAwait(false);
+#else
+        cancellationToken.ThrowIfCancellationRequested();
+        return await reader.ReadToEndAsync().ConfigureAwait(false);
+#endif
+    }
 }
\ No newline at end of file
diff --git a/src/Atc/Factories/AsyncEnumerableFactory.cs b/src/Atc/Factories/AsyncEnumerableFactory.cs
index fa8ee9ba..456b08d1 100644
--- a/src/Atc/Factories/AsyncEnumerableFactory.cs
+++ b/src/Atc/Factories/AsyncEnumerableFactory.cs
@@ -29,10 +29,108 @@ private static async IAsyncEnumerable<T> CreateEmpty()
     /// </summary>
     /// <typeparam name="T">The type of the item.</typeparam>
     /// <param name="item">The item to convert.</param>
+    /// <param name="cancellationToken">A token to cancel the asynchronous iteration.</param>
     /// <returns>An <see cref="IAsyncEnumerable{T}"/> containing the single item.</returns>
-    public static async IAsyncEnumerable<T> FromSingleItem<T>(T item)
+    public static async IAsyncEnumerable<T> FromSingleItem<T>(
+        T item,
+        [EnumeratorCancellation] CancellationToken cancellationToken = default)
     {
+        cancellationToken.ThrowIfCancellationRequested();
         yield return item;
         await Task.CompletedTask;
     }
+
+    /// <summary>
+    /// Wraps an array of items as an <see cref="IAsyncEnumerable{T}"/>, yielding each item in order.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements.</typeparam>
+    /// <param name="items">The items to yield.</param>
+    /// <param name="cancellationToken">A token to cancel the asynchronous iteration; checked before each item is yielded.</param>
+    /// <returns>An <see cref="IAsyncEnumerable{T}"/> that yields each element of <paramref name="items"/>.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="items"/> is <see langword="null"/>.</exception>
+    public static IAsyncEnumerable<T> FromItems<T>(
+        T[] items,
+        CancellationToken cancellationToken = default)
+    {
+        if (items is null)
+        {
+            throw new ArgumentNullException(nameof(items));
+        }
+
+        return FromItemsCore(items, cancellationToken);
+    }
+
+    /// <summary>
+    /// Wraps an <see cref="IEnumerable{T}"/> as an <see cref="IAsyncEnumerable{T}"/>, yielding each element in order.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements.</typeparam>
+    /// <param name="source">The synchronous sequence to wrap.</param>
+    /// <param name="cancellationToken">A token to cancel the asynchronous iteration; checked before each element is yielded.</param>
+    /// <returns>An <see cref="IAsyncEnumerable{T}"/> that yields each element of <paramref name="source"/>.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="source"/> is <see langword="null"/>.</exception>
+    public static IAsyncEnumerable<T> FromEnumerable<T>(
+        IEnumerable<T> source,
+        CancellationToken cancellationToken = default)
+    {
+        if (source is null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        return FromEnumerableCore(source, cancellationToken);
+    }
+
+    /// <summary>
+    /// Creates an <see cref="IAsyncEnumerable{T}"/> that awaits the specified task and yields its result as a single element.
+    /// </summary>
+    /// <typeparam name="T">The type of the task result.</typeparam>
+    /// <param name="task">The task whose result will be yielded.</param>
+    /// <param name="cancellationToken">A token to cancel the asynchronous operation before the task is awaited.</param>
+    /// <returns>An <see cref="IAsyncEnumerable{T}"/> that yields the single result of <paramref name="task"/>.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="task"/> is <see langword="null"/>.</exception>
+    public static IAsyncEnumerable<T> FromTask<T>(
+        Task<T> task,
+        CancellationToken cancellationToken = default)
+    {
+        if (task is null)
+        {
+            throw new ArgumentNullException(nameof(task));
+        }
+
+        return FromTaskCore(task, cancellationToken);
+    }
+
+    private static async IAsyncEnumerable<T> FromItemsCore<T>(
+        T[] items,
+        [EnumeratorCancellation] CancellationToken cancellationToken)
+    {
+        foreach (var item in items)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            yield return item;
+        }
+
+        await Task.CompletedTask;
+    }
+
+    private static async IAsyncEnumerable<T> FromEnumerableCore<T>(
+        IEnumerable<T> source,
+        [EnumeratorCancellation] CancellationToken cancellationToken)
+    {
+        foreach (var item in source)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            yield return item;
+        }
+
+        await Task.CompletedTask;
+    }
+
+    private static async IAsyncEnumerable<T> FromTaskCore<T>(
+        Task<T> task,
+        [EnumeratorCancellation] CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        yield return await task.ConfigureAwait(false);
+    }
 }
\ No newline at end of file
diff --git a/src/Atc/Helpers/NetworkInformationHelper.cs b/src/Atc/Helpers/NetworkInformationHelper.cs
index 0308ef41..f27045c2 100644
--- a/src/Atc/Helpers/NetworkInformationHelper.cs
+++ b/src/Atc/Helpers/NetworkInformationHelper.cs
@@ -147,4 +147,200 @@ public static bool HasTcpConnection(
             ? ipAddress
             : null;
     }
+
+    /// <summary>
+    /// Asynchronously determines whether there is network connectivity by pinging Google's DNS server (8.8.8.8).
+    /// </summary>
+    /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+    /// <returns><see langword="true"/> if a ping response is received; otherwise, <see langword="false"/>.</returns>
+    public static Task<bool> HasConnectionAsync(
+        CancellationToken cancellationToken = default)
+    {
+        const string googleDns = "8.8.8.8";
+        return HasConnectionAsync(IPAddress.Parse(googleDns), cancellationToken);
+    }
+
+    /// <summary>
+    /// Asynchronously determines whether there is network connectivity to a specified IP address.
+    /// </summary>
+    /// <param name="ipAddress">The IP address to ping.</param>
+    /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+    /// <returns><see langword="true"/> if a ping response is received; otherwise, <see langword="false"/>.</returns>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="ipAddress"/> is <see langword="null"/>.</exception>
+    public static async Task<bool> HasConnectionAsync(
+        IPAddress ipAddress,
+        CancellationToken cancellationToken = default)
+    {
+        if (ipAddress is null)
+        {
+            throw new ArgumentNullException(nameof(ipAddress));
+        }
+
+        try
+        {
+            using var ping = new Ping();
+            var buffer = new byte[32];
+
+            const int timeout = 1000;
+            var pingOptions = new PingOptions();
+
+#if NET7_0_OR_GREATER
+            var pingReply = await ping.SendPingAsync(
+                ipAddress,
+                TimeSpan.FromMilliseconds(timeout),
+                buffer,
+                pingOptions,
+                cancellationToken).ConfigureAwait(false);
+#else
+            cancellationToken.ThrowIfCancellationRequested();
+            var pingReply = await ping.SendPingAsync(ipAddress, timeout, buffer, pingOptions).ConfigureAwait(false);
+#endif
+
+            return pingReply is not null &&
+                   pingReply.Status == IPStatus.Success;
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Asynchronously determines whether there is HTTP connectivity by making a request to Google's website.
+    /// </summary>
+    /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+    /// <returns><see langword="true"/> if the HTTP request succeeds; otherwise, <see langword="false"/>.</returns>
+    public static Task<bool> HasHttpConnectionAsync(
+        CancellationToken cancellationToken = default)
+        => HasHttpConnectionAsync(new Uri("https://www.google.com/"), cancellationToken);
+
+    /// <summary>
+    /// Asynchronously determines whether there is HTTP connectivity to a specified URI.
+    /// </summary>
+    /// <param name="uri">The URI to request.</param>
+    /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+    /// <returns><see langword="true"/> if the HTTP request succeeds; otherwise, <see langword="false"/>.</returns>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="uri"/> is <see langword="null"/>.</exception>
+    public static async Task<bool> HasHttpConnectionAsync(
+        Uri uri,
+        CancellationToken cancellationToken = default)
+    {
+        if (uri is null)
+        {
+            throw new ArgumentNullException(nameof(uri));
+        }
+
+        try
+        {
+            using var response = await SharedHttpClient
+                .GetAsync(uri, HttpCompletionOption.ResponseHeadersRead, cancellationToken)
+                .ConfigureAwait(false);
+
+            response.EnsureSuccessStatusCode();
+            return true;
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Asynchronously determines whether a TCP connection can be established to the specified IP address and port.
+    /// A connection timeout of 5 seconds is applied; pass a pre-cancelled token to impose a shorter deadline.
+    /// </summary>
+    /// <param name="ipAddress">The IP address to connect to.</param>
+    /// <param name="port">The port number to connect to.</param>
+    /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+    /// <returns><see langword="true"/> if the TCP connection succeeds within the timeout; otherwise, <see langword="false"/>.</returns>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="ipAddress"/> is <see langword="null"/>.</exception>
+    public static async Task<bool> HasTcpConnectionAsync(
+        IPAddress ipAddress,
+        int port,
+        CancellationToken cancellationToken = default)
+    {
+        if (ipAddress is null)
+        {
+            throw new ArgumentNullException(nameof(ipAddress));
+        }
+
+        var client = new TcpClient();
+        try
+        {
+#if NET5_0_OR_GREATER
+            using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            cts.CancelAfter(5_000);
+            await client.ConnectAsync(ipAddress, port, cts.Token).ConfigureAwait(false);
+#else
+            var connectTask = client.ConnectAsync(ipAddress, port);
+            await Task.WhenAny(connectTask, Task.Delay(5_000, CancellationToken.None)).ConfigureAwait(false);
+            cancellationToken.ThrowIfCancellationRequested();
+#endif
+            return client.Connected;
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            throw;
+        }
+        catch
+        {
+            return false;
+        }
+        finally
+        {
+            client.Dispose();
+        }
+    }
+
+    /// <summary>
+    /// Asynchronously retrieves the public IP address of the current machine by querying an external service (api.ipify.org).
+    /// </summary>
+    /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+    /// <returns>The public <see cref="IPAddress"/> if retrieval succeeds; otherwise, <see langword="null"/>.</returns>
+    public static async Task<IPAddress?> GetPublicIpAddressAsync(
+        CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var response = await SharedHttpClient
+                .GetAsync(new Uri("https://api.ipify.org"), cancellationToken)
+                .ConfigureAwait(false);
+
+            response.EnsureSuccessStatusCode();
+#if NET5_0_OR_GREATER
+            var responseBody = await response.Content
+                .ReadAsStringAsync(cancellationToken)
+                .ConfigureAwait(false);
+#else
+            var responseBody = await response.Content
+                .ReadAsStringAsync()
+                .ConfigureAwait(false);
+#endif
+
+            if (string.IsNullOrEmpty(responseBody))
+            {
+                return null;
+            }
+
+            return IPAddress.TryParse(responseBody, out var ipAddress)
+                ? ipAddress
+                : null;
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+        catch
+        {
+            return null;
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/Atc/Serialization/JsonSerializerHelper.cs b/src/Atc/Serialization/JsonSerializerHelper.cs
new file mode 100644
index 00000000..2b3c533e
--- /dev/null
+++ b/src/Atc/Serialization/JsonSerializerHelper.cs
@@ -0,0 +1,119 @@
+namespace Atc.Serialization;
+
+/// <summary>
+/// Provides async stream-based serialization and deserialization helpers using <see cref="System.Text.Json.JsonSerializer"/>.
+/// </summary>
+/// <remarks>
+/// All overloads that omit <see cref="JsonSerializerOptions"/> use
+/// <see cref="JsonSerializerOptionsFactory"/> default options.
+/// </remarks>
+public static class JsonSerializerHelper
+{
+    /// <summary>
+    /// Asynchronously deserializes a value of type <typeparamref name="T"/> from the specified UTF-8 JSON stream
+    /// using the default serializer options.
+    /// </summary>
+    /// <typeparam name="T">The type to deserialize.</typeparam>
+    /// <param name="stream">The UTF-8 encoded JSON stream to read from.</param>
+    /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+    /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous operation, containing the deserialized value,
+    /// or <see langword="null"/> if the stream contains a JSON null literal.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="stream"/> is <see langword="null"/>.</exception>
+    public static async Task<T?> DeserializeFromStreamAsync<T>(
+        Stream stream,
+        CancellationToken cancellationToken = default)
+    {
+        if (stream is null)
+        {
+            throw new ArgumentNullException(nameof(stream));
+        }
+
+        return await JsonSerializer
+            .DeserializeAsync<T>(stream, JsonSerializerOptionsFactory.Create(), cancellationToken)
+            .ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Asynchronously deserializes a value of type <typeparamref name="T"/> from the specified UTF-8 JSON stream
+    /// using the provided serializer options.
+    /// </summary>
+    /// <typeparam name="T">The type to deserialize.</typeparam>
+    /// <param name="stream">The UTF-8 encoded JSON stream to read from.</param>
+    /// <param name="options">The <see cref="JsonSerializerOptions"/> to use during deserialization.</param>
+    /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+    /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous operation, containing the deserialized value,
+    /// or <see langword="null"/> if the stream contains a JSON null literal.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="stream"/> or <paramref name="options"/> is <see langword="null"/>.</exception>
+    public static async Task<T?> DeserializeFromStreamAsync<T>(
+        Stream stream,
+        JsonSerializerOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        if (stream is null)
+        {
+            throw new ArgumentNullException(nameof(stream));
+        }
+
+        if (options is null)
+        {
+            throw new ArgumentNullException(nameof(options));
+        }
+
+        return await JsonSerializer
+            .DeserializeAsync<T>(stream, options, cancellationToken)
+            .ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Asynchronously serializes <paramref name="value"/> as UTF-8 JSON into the specified stream
+    /// using the default serializer options.
+    /// </summary>
+    /// <typeparam name="T">The type of the value to serialize.</typeparam>
+    /// <param name="value">The value to serialize.</param>
+    /// <param name="stream">The stream to write JSON into.</param>
+    /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+    /// <returns>A <see cref="Task"/> that represents the asynchronous write operation.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="stream"/> is <see langword="null"/>.</exception>
+    public static Task SerializeToStreamAsync<T>(
+        T value,
+        Stream stream,
+        CancellationToken cancellationToken = default)
+    {
+        if (stream is null)
+        {
+            throw new ArgumentNullException(nameof(stream));
+        }
+
+        return JsonSerializer.SerializeAsync(stream, value, JsonSerializerOptionsFactory.Create(), cancellationToken);
+    }
+
+    /// <summary>
+    /// Asynchronously serializes <paramref name="value"/> as UTF-8 JSON into the specified stream
+    /// using the provided serializer options.
+    /// </summary>
+    /// <typeparam name="T">The type of the value to serialize.</typeparam>
+    /// <param name="value">The value to serialize.</param>
+    /// <param name="stream">The stream to write JSON into.</param>
+    /// <param name="options">The <see cref="JsonSerializerOptions"/> to use during serialization.</param>
+    /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+    /// <returns>A <see cref="Task"/> that represents the asynchronous write operation.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="stream"/> or <paramref name="options"/> is <see langword="null"/>.</exception>
+    public static Task SerializeToStreamAsync<T>(
+        T value,
+        Stream stream,
+        JsonSerializerOptions options,
+        CancellationToken cancellationToken = default)
+    {
+        if (stream is null)
+        {
+            throw new ArgumentNullException(nameof(stream));
+        }
+
+        if (options is null)
+        {
+            throw new ArgumentNullException(nameof(options));
+        }
+
+        return JsonSerializer.SerializeAsync(stream, value, options, cancellationToken);
+    }
+}
\ No newline at end of file
diff --git a/test/Atc.Tests/CodeComplianceTests.cs b/test/Atc.Tests/CodeComplianceTests.cs
index fd51bc8c..55083d5b 100644
--- a/test/Atc.Tests/CodeComplianceTests.cs
+++ b/test/Atc.Tests/CodeComplianceTests.cs
@@ -33,7 +33,11 @@ public class CodeComplianceTests
         typeof(UriToAbsoluteUriJsonConverter), // JsonConverter override methods with ref parameters
         typeof(VersionJsonConverter), // JsonConverter override methods with ref parameters
         typeof(System.TypeExtensions),
+        typeof(System.StringExtensions), // AST has limitations with CultureInfo/DateTimeStyles parameter detection
         typeof(AsyncEnumerableFactory),
+        typeof(NetworkInformationHelper), // AST/MonoReflection limitations with async methods and default CancellationToken parameters
+        typeof(JsonSerializerHelper), // AST/MonoReflection limitations with generic async methods and default CancellationToken parameters
+        typeof(System.IO.StreamExtensions), // AST/MonoReflection limitations with async extension methods and default CancellationToken parameters
         typeof(ByteExtensions),
         typeof(EnumerableExtensions),
         typeof(StringCaseFormatter), // AST has limitations with IFormatProvider/ICustomFormatter interface method detection
diff --git a/test/Atc.Tests/Extensions/StreamExtensionsTests.cs b/test/Atc.Tests/Extensions/StreamExtensionsTests.cs
index 6065e302..f790e956 100644
--- a/test/Atc.Tests/Extensions/StreamExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/StreamExtensionsTests.cs
@@ -111,6 +111,160 @@ public void ToStringData_NonSeekable_DoesNotThrow()
         Assert.Equal("Hallo world", actual);
     }
 
+    [Fact]
+    public async Task CopyToStreamAsync()
+    {
+        // Arrange
+        var input = "Hallo world".ToStream();
+
+        // Act
+        var actual = await input.CopyToStreamAsync();
+
+        // Assert
+        Assert.Equal("Hallo world", await actual.ToStringDataAsync());
+    }
+
+    [Fact]
+    public async Task CopyToStreamAsync_BufferSize()
+    {
+        // Arrange
+        var input = "Hallo world".ToStream();
+
+        // Act
+        var actual = await input.CopyToStreamAsync(bufferSize: 1024);
+
+        // Assert
+        Assert.Equal("Hallo world", await actual.ToStringDataAsync());
+    }
+
+    [Fact]
+    public async Task CopyToStreamAsync_NonSeekable_DoesNotThrow()
+    {
+        // Arrange
+        var inner = "Hallo world".ToStream();
+        using var input = new NonSeekableStream(inner);
+
+        // Act
+        var actual = await input.CopyToStreamAsync();
+
+        // Assert
+        Assert.Equal("Hallo world", await actual.ToStringDataAsync());
+    }
+
+    [Fact]
+    public async Task CopyToStreamAsync_Cancelled_ThrowsOperationCanceledException()
+    {
+        // Arrange
+        var input = "Hallo world".ToStream();
+        using var cts = new CancellationTokenSource();
+        await cts.CancelAsync();
+
+        // Act
+        var ex = await Record.ExceptionAsync(() => (Task)input.CopyToStreamAsync(cancellationToken: cts.Token));
+
+        // Assert
+        Assert.IsAssignableFrom<OperationCanceledException>(ex);
+    }
+
+    [Fact]
+    public async Task ToBytesAsync()
+    {
+        // Arrange
+        var input = "Hallo world".ToStream();
+
+        // Act
+        var buffer = await input.ToBytesAsync();
+        var actual = Encoding.UTF8.GetString(buffer, 0, buffer.Length);
+
+        // Assert
+        Assert.Equal("Hallo world", actual);
+    }
+
+    [Fact]
+    public async Task ToBytesAsync_NonSeekable_DoesNotThrow()
+    {
+        // Arrange
+        var inner = "Hallo world".ToStream();
+        using var input = new NonSeekableStream(inner);
+
+        // Act
+        var buffer = await input.ToBytesAsync();
+        var actual = Encoding.UTF8.GetString(buffer, 0, buffer.Length);
+
+        // Assert
+        Assert.Equal("Hallo world", actual);
+    }
+
+    [Fact]
+    public async Task ToBytesAsync_Cancelled_ThrowsOperationCanceledException()
+    {
+        // Arrange
+        var input = "Hallo world".ToStream();
+        using var cts = new CancellationTokenSource();
+        await cts.CancelAsync();
+
+        // Act
+        var ex = await Record.ExceptionAsync(() => (Task)input.ToBytesAsync(cts.Token));
+
+        // Assert
+        Assert.IsAssignableFrom<OperationCanceledException>(ex);
+    }
+
+    [Fact]
+    public async Task ToStringDataAsync()
+    {
+        // Arrange
+        var input = "Hallo world".ToStream();
+
+        // Act
+        var actual = await input.ToStringDataAsync();
+
+        // Assert
+        Assert.Equal("Hallo world", actual);
+    }
+
+    [Fact]
+    public async Task ToStringDataAsync_DoesNotDisposeCallerStream()
+    {
+        // Arrange
+        var input = "Hallo world".ToStream();
+
+        // Act
+        _ = await input.ToStringDataAsync();
+
+        // Assert
+        Assert.True(input.CanRead);
+    }
+
+    [Fact]
+    public async Task ToStringDataAsync_NonSeekable_DoesNotThrow()
+    {
+        // Arrange
+        var inner = "Hallo world".ToStream();
+        using var input = new NonSeekableStream(inner);
+
+        // Act
+        var actual = await input.ToStringDataAsync();
+
+        // Assert
+        Assert.Equal("Hallo world", actual);
+    }
+
+    [Fact]
+    public async Task ToStringDataAsync_Cancelled_ThrowsOperationCanceledException()
+    {
+        // Arrange
+        var input = "Hallo world".ToStream();
+        using var cts = new CancellationTokenSource();
+        await cts.CancelAsync();
+
+        // Act
+        var ex = await Record.ExceptionAsync(() => (Task)input.ToStringDataAsync(cts.Token));
+
+        // Assert
+        Assert.IsAssignableFrom<OperationCanceledException>(ex);
+    }
+
     /// <summary>
     /// Wraps a stream and hides seek capability to simulate non-seekable sources
     /// (e.g. network or compressed streams).
diff --git a/test/Atc.Tests/Factories/AsyncEnumerableFactoryTests.cs b/test/Atc.Tests/Factories/AsyncEnumerableFactoryTests.cs
index c10d08e3..39c77ece 100644
--- a/test/Atc.Tests/Factories/AsyncEnumerableFactoryTests.cs
+++ b/test/Atc.Tests/Factories/AsyncEnumerableFactoryTests.cs
@@ -149,4 +149,147 @@ public async Task FromSingleItem_CanBeEnumeratedMultipleTimes()
         Assert.Equal(item, firstEnumeration.First());
         Assert.Equal(item, secondEnumeration.First());
     }
+
+    [Fact]
+    public async Task FromSingleItem_Cancelled_ThrowsOperationCanceledException()
+    {
+        // Arrange
+        using var cts = new CancellationTokenSource();
+        await cts.CancelAsync();
+        var collected = new List<int>();
+
+        // Act & Assert
+        await Assert.ThrowsAsync<OperationCanceledException>(async () =>
+        {
+            await foreach (var item in AsyncEnumerableFactory.FromSingleItem(42).WithCancellation(cts.Token))
+            {
+                collected.Add(item);
+            }
+        });
+    }
+
+    [Fact]
+    public async Task FromItems_ReturnsAllElements()
+    {
+        // Arrange
+        var items = new[] { 1, 2, 3, 4, 5 };
+        var result = new List<int>();
+
+        // Act
+        await foreach (var value in AsyncEnumerableFactory.FromItems(items))
+        {
+            result.Add(value);
+        }
+
+        // Assert
+        Assert.Equal(items, result);
+    }
+
+    [Fact]
+    public async Task FromItems_EmptyArray_ReturnsEmpty()
+    {
+        // Arrange
+        var result = new List<int>();
+
+        // Act
+        await foreach (var value in AsyncEnumerableFactory.FromItems(Array.Empty<int>()))
+        {
+            result.Add(value);
+        }
+
+        // Assert
+        Assert.Empty(result);
+    }
+
+    [Fact]
+    public async Task FromItems_Cancelled_ThrowsOperationCanceledException()
+    {
+        // Arrange
+        var items = new[] { 1, 2, 3 };
+        using var cts = new CancellationTokenSource();
+        await cts.CancelAsync();
+        var collected = new List<int>();
+
+        // Act & Assert
+        await Assert.ThrowsAsync<OperationCanceledException>(async () =>
+        {
+            await foreach (var item in AsyncEnumerableFactory.FromItems(items).WithCancellation(cts.Token))
+            {
+                collected.Add(item);
+            }
+        });
+    }
+
+    [Fact]
+    public async Task FromEnumerable_ReturnsAllElements()
+    {
+        // Arrange
+        var source = new List<string> { "a", "b", "c" };
+        var result = new List<string>();
+
+        // Act
+        await foreach (var value in AsyncEnumerableFactory.FromEnumerable(source))
+        {
+            result.Add(value);
+        }
+
+        // Assert
+        Assert.Equal(source, result);
+    }
+
+    [Fact]
+    public async Task FromEnumerable_Cancelled_ThrowsOperationCanceledException()
+    {
+        // Arrange
+        var source = new[] { 1, 2, 3 };
+        using var cts = new CancellationTokenSource();
+        await cts.CancelAsync();
+        var collected = new List<int>();
+
+        // Act & Assert
+        await Assert.ThrowsAsync<OperationCanceledException>(async () =>
+        {
+            await foreach (var item in AsyncEnumerableFactory.FromEnumerable(source).WithCancellation(cts.Token))
+            {
+                collected.Add(item);
+            }
+        });
+    }
+
+    [Fact]
+    public async Task FromTask_YieldsSingleResult()
+    {
+        // Arrange
+        var task = Task.FromResult(42);
+
+        // Act
+        var result = new List<int>();
+        await foreach (var value in AsyncEnumerableFactory.FromTask(task))
+        {
+            result.Add(value);
+        }
+
+        // Assert
+        Assert.Single(result);
+        Assert.Equal(42, result[0]);
+    }
+
+    [Fact]
+    public async Task FromTask_Cancelled_ThrowsOperationCanceledException()
+    {
+        // Arrange
+        var task = Task.FromResult(42);
+        using var cts = new CancellationTokenSource();
+        await cts.CancelAsync();
+        var collected = new List<int>();
+
+        // Act & Assert
+        await Assert.ThrowsAsync<OperationCanceledException>(async () =>
+        {
+            await foreach (var item in AsyncEnumerableFactory.FromTask(task).WithCancellation(cts.Token))
+            {
+                collected.Add(item);
+            }
+        });
+    }
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Helpers/NetworkInformationHelperTests.cs b/test/Atc.Tests/Helpers/NetworkInformationHelperTests.cs
index 509000fb..e470da44 100644
--- a/test/Atc.Tests/Helpers/NetworkInformationHelperTests.cs
+++ b/test/Atc.Tests/Helpers/NetworkInformationHelperTests.cs
@@ -53,4 +53,53 @@ public void HasTcpConnection_WithIpAddressAndPort(
         // Assert - DNS servers typically accept TCP connections on port 53
         Assert.True(result);
     }
+
+    [Fact]
+    public async Task HasConnectionAsync()
+        => Assert.True(await NetworkInformationHelper.HasConnectionAsync());
+
+    [Theory]
+    [InlineData("8.8.8.8")]
+    [InlineData("1.1.1.1")]
+    public async Task HasConnectionAsync_WithIpAddress(string ipAddressString)
+    {
+        // Arrange
+        var ipAddress = IPAddress.Parse(ipAddressString);
+
+        // Act
+        var result = await NetworkInformationHelper.HasConnectionAsync(ipAddress);
+
+        // Assert
+        Assert.True(result);
+    }
+
+    [Fact]
+    public async Task HasHttpConnectionAsync()
+        => Assert.True(await NetworkInformationHelper.HasHttpConnectionAsync());
+
+    [Theory]
+    [InlineData("https://www.google.com/")]
+    public async Task HasHttpConnectionAsync_Uri(string url)
+        => Assert.True(await NetworkInformationHelper.HasHttpConnectionAsync(new Uri(url)));
+
+    [Fact]
+    public async Task GetPublicIpAddressAsync()
+        => Assert.NotNull(await NetworkInformationHelper.GetPublicIpAddressAsync());
+
+    [Theory]
+    [InlineData("8.8.8.8", 53)]
+    [InlineData("1.1.1.1", 53)]
+    public async Task HasTcpConnectionAsync_WithIpAddressAndPort(
+        string ipAddressString,
+        int port)
+    {
+        // Arrange
+        var ipAddress = IPAddress.Parse(ipAddressString);
+
+        // Act
+        var result = await NetworkInformationHelper.HasTcpConnectionAsync(ipAddress, port);
+
+        // Assert
+        Assert.True(result);
+    }
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Serialization/JsonSerializerHelperTests.cs b/test/Atc.Tests/Serialization/JsonSerializerHelperTests.cs
new file mode 100644
index 00000000..e15eb770
--- /dev/null
+++ b/test/Atc.Tests/Serialization/JsonSerializerHelperTests.cs
@@ -0,0 +1,103 @@
+namespace Atc.Tests.Serialization;
+
+public class JsonSerializerHelperTests
+{
+    private sealed record Person(string Name, int Age);
+
+    [Fact]
+    public async Task SerializeToStreamAsync_ThenDeserializeFromStreamAsync_RoundTrips()
+    {
+        // Arrange
+        var original = new Person("Alice", 30);
+        using var stream = new MemoryStream();
+
+        // Act
+        await JsonSerializerHelper.SerializeToStreamAsync(original, stream);
+        stream.Position = 0;
+        var result = await JsonSerializerHelper.DeserializeFromStreamAsync<Person>(stream);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Equal(original.Name, result.Name);
+        Assert.Equal(original.Age, result.Age);
+    }
+
+    [Fact]
+    public async Task SerializeToStreamAsync_WithOptions_WritesJson()
+    {
+        // Arrange
+        var original = new Person("Bob", 25);
+        using var stream = new MemoryStream();
+        var options = JsonSerializerOptionsFactory.Create(useCamelCase: false, writeIndented: false);
+
+        // Act
+        await JsonSerializerHelper.SerializeToStreamAsync(original, stream, options);
+        stream.Position = 0;
+        using var reader = new StreamReader(stream);
+        var json = await reader.ReadToEndAsync();
+
+        // Assert — PascalCase keys expected
+        Assert.Contains("\"Name\"", json, StringComparison.Ordinal);
+        Assert.Contains("\"Age\"", json, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task DeserializeFromStreamAsync_WithOptions_Deserializes()
+    {
+        // Arrange
+        const string json = "{\"Name\":\"Carol\",\"Age\":22}";
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(json));
+        var options = JsonSerializerOptionsFactory.Create(propertyNameCaseInsensitive: true, writeIndented: false);
+
+        // Act
+        var result = await JsonSerializerHelper.DeserializeFromStreamAsync<Person>(stream, options);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Equal("Carol", result.Name);
+        Assert.Equal(22, result.Age);
+    }
+
+    [Fact]
+    public Task SerializeToStreamAsync_NullStream_ThrowsArgumentNullException()
+        => Assert.ThrowsAsync<ArgumentNullException>(
+            () => JsonSerializerHelper.SerializeToStreamAsync<Person>(new Person("x", 1), null!));
+
+    [Fact]
+    public Task DeserializeFromStreamAsync_NullStream_ThrowsArgumentNullException()
+        => Assert.ThrowsAsync<ArgumentNullException>(
+            () => JsonSerializerHelper.DeserializeFromStreamAsync<Person>(null!));
+
+    [Fact]
+    public async Task SerializeToStreamAsync_Cancelled_ThrowsOperationCanceledException()
+    {
+        // Arrange
+        using var stream = new MemoryStream();
+        using var cts = new CancellationTokenSource();
+        await cts.CancelAsync();
+
+        // Act
+        var ex = await Record.ExceptionAsync(
+            () => JsonSerializerHelper.SerializeToStreamAsync(new Person("x", 1), stream, cts.Token));
+
+        // Assert
+        Assert.IsAssignableFrom<OperationCanceledException>(ex);
+    }
+
+    [Fact]
+    public async Task DeserializeFromStreamAsync_Cancelled_ThrowsOperationCanceledException()
+    {
+        // Arrange
+        const string json = "{\"Name\":\"x\",\"Age\":1}";
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(json));
+        using var cts = new CancellationTokenSource();
+        await cts.CancelAsync();
+
+        // Act
+        var ex = await Record.ExceptionAsync(
+            () => (Task)JsonSerializerHelper.DeserializeFromStreamAsync<Person>(stream, cts.Token));
+
+        // Assert
+        Assert.IsAssignableFrom<OperationCanceledException>(ex);
+    }
+}
\ No newline at end of file

From 9d68d4a45d907c180e0185680c17f22164607f42 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 11:04:07 +0200
Subject: [PATCH 053/100] fix(atc): replace double.Epsilon with 1e-9 tolerance
 in IsEqual and IsZero

DoubleExtensions.IsEqual and IsZero used double.Epsilon (~4.9e-324) as
their comparison threshold, making them effectively exact equality checks
and causing 0.1+0.2 != 0.3, geometry/trig angle validation failures, and
other classic floating-point correctness bugs. Change DoubleEpsilon to
1e-9, align MathHelper.IsEqualToZero to the same constant, and update
three tests whose expected values change under the new tolerance.
---
 .../Extensions/BaseTypes/DoubleExtensions.cs  | 20 +++++++++++--------
 src/Atc/Helpers/MathHelper.cs                 |  2 +-
 .../BaseTypes/DoubleExtensionsTests.cs        |  2 ++
 test/Atc.Tests/Helpers/MathHelperTests.cs     |  2 +-
 test/Atc.Tests/Structs/Point2DTests.cs        |  6 +++---
 5 files changed, 19 insertions(+), 13 deletions(-)

diff --git a/src/Atc/Extensions/BaseTypes/DoubleExtensions.cs b/src/Atc/Extensions/BaseTypes/DoubleExtensions.cs
index 738de7d8..db19993e 100644
--- a/src/Atc/Extensions/BaseTypes/DoubleExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/DoubleExtensions.cs
@@ -7,22 +7,26 @@ namespace System;
 public static class DoubleExtensions
 {
     /// <summary>
-    /// The double epsilon.
+    /// The tolerance used by <see cref="IsEqual(double,double)"/> and <see cref="IsZero"/>.
+    /// Values whose absolute difference is at or below this threshold are considered equal.
     /// </summary>
-    public const double DoubleEpsilon = double.Epsilon;
+    public const double DoubleEpsilon = 1e-9;
 
     /// <summary>
-    /// Compare two values. Return <see langword="true" /> if they are equals.
+    /// Determines whether two double values are approximately equal within a tolerance of <see cref="DoubleEpsilon"/> (1e-9).
+    /// This handles common floating-point arithmetic rounding, for example <c>0.1 + 0.2 == 0.3</c>.
+    /// Use <see cref="IsEqual(double,double,int)"/> when an exact decimal-precision comparison is needed.
     /// </summary>
     /// <param name="a">The first value.</param>
     /// <param name="b">The second value.</param>
     /// <returns>
-    /// <see langword="true" /> if the two values are equals, <see langword="false" /> otherwise.
+    /// <see langword="true"/> if the absolute difference between <paramref name="a"/> and <paramref name="b"/>
+    /// is at most <see cref="DoubleEpsilon"/>; otherwise, <see langword="false"/>.
     /// </returns>
     public static bool IsEqual(
         this double a,
         double b)
-        => Math.Abs(a - b) < double.Epsilon;
+        => Math.Abs(a - b) <= DoubleEpsilon;
 
     /// <summary>
     /// Compare two values. Return <see langword="true" /> if they are equals.
@@ -109,12 +113,12 @@ public static bool GreaterThanOrClose(
         => value1 > value2 || AreClose(value1, value2);
 
     /// <summary>
-    /// Determines whether the specified double value is approximately zero.
+    /// Determines whether the specified double value is approximately zero within a tolerance of <see cref="DoubleEpsilon"/> (1e-9).
     /// </summary>
     /// <param name="value">The value to check.</param>
-    /// <returns><see langword="true"/> if the absolute value is less than epsilon; otherwise, <see langword="false"/>.</returns>
+    /// <returns><see langword="true"/> if the absolute value is at most <see cref="DoubleEpsilon"/>; otherwise, <see langword="false"/>.</returns>
     public static bool IsZero(this double value)
-        => Math.Abs(value) < DoubleEpsilon;
+        => Math.Abs(value) <= DoubleEpsilon;
 
     /// <summary>
     /// Rounds a double value using currency rounding rules and returns it as an integer.
diff --git a/src/Atc/Helpers/MathHelper.cs b/src/Atc/Helpers/MathHelper.cs
index ad777039..83953783 100644
--- a/src/Atc/Helpers/MathHelper.cs
+++ b/src/Atc/Helpers/MathHelper.cs
@@ -332,7 +332,7 @@ public static double Max(List<double> values)
     ///   <see langword="true" /> if [is equal to zero] [the specified value]; otherwise, <see langword="false" />.
     /// </returns>
     public static bool IsEqualToZero(double value)
-        => System.Math.Abs(value) <= 0.0000001;
+        => System.Math.Abs(value) <= DoubleExtensions.DoubleEpsilon;
 
     /// <summary>
     /// Determines whether the specified value1 is equals.
diff --git a/test/Atc.Tests/Extensions/BaseTypes/DoubleExtensionsTests.cs b/test/Atc.Tests/Extensions/BaseTypes/DoubleExtensionsTests.cs
index 4e5ffc34..4d04afe5 100644
--- a/test/Atc.Tests/Extensions/BaseTypes/DoubleExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/BaseTypes/DoubleExtensionsTests.cs
@@ -4,6 +4,8 @@ public class DoubleExtensionsTests
 {
     [Theory]
     [InlineData(true, 12.3, 12.3)]
+    [InlineData(true, 0.30000000000000004, 0.3)] // 0.1 + 0.2 in IEEE 754
+    [InlineData(false, 12.3, 12.4)]
     public void IsEqual(
         bool expected,
         double a,
diff --git a/test/Atc.Tests/Helpers/MathHelperTests.cs b/test/Atc.Tests/Helpers/MathHelperTests.cs
index ac227acb..98697ddc 100644
--- a/test/Atc.Tests/Helpers/MathHelperTests.cs
+++ b/test/Atc.Tests/Helpers/MathHelperTests.cs
@@ -396,7 +396,7 @@ public void IsEqualToZero(
 
     [Theory]
     [InlineData(true, 1, 1)]
-    [InlineData(false, 1, 1.00000000000001)]
+    [InlineData(true, 1, 1.00000000000001)] // diff = 1e-14, within DoubleEpsilon (1e-9)
     [InlineData(false, 1, 1.000001)]
     public void IsEquals(
         bool expected,
diff --git a/test/Atc.Tests/Structs/Point2DTests.cs b/test/Atc.Tests/Structs/Point2DTests.cs
index 2b1b59a9..38381f3c 100644
--- a/test/Atc.Tests/Structs/Point2DTests.cs
+++ b/test/Atc.Tests/Structs/Point2DTests.cs
@@ -25,8 +25,8 @@ public void IsDefault(
     [Fact]
     public void IsDefault_WithTinyNonZeroX_ReturnsFalse()
     {
-        // Arrange — double.Epsilon is the smallest positive double; approximate IsEqual would pass it as zero
-        var input = new Point2D(double.Epsilon, 0);
+        // Arrange — value must exceed DoubleEpsilon (1e-9) to be considered non-default
+        var input = new Point2D(DoubleExtensions.DoubleEpsilon * 10, 0);
 
         // Act / Assert
         Assert.False(input.IsDefault);
@@ -35,7 +35,7 @@ public void IsDefault_WithTinyNonZeroX_ReturnsFalse()
     [Fact]
     public void IsDefault_WithTinyNonZeroY_ReturnsFalse()
     {
-        var input = new Point2D(0, double.Epsilon);
+        var input = new Point2D(0, DoubleExtensions.DoubleEpsilon * 10);
         Assert.False(input.IsDefault);
     }
 

From 298266d68f88a9362b7ca2f14c74bbc725e04e50 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 11:08:04 +0200
Subject: [PATCH 054/100] fix(atc-dotnet): fix MSBuild error regex and expose
 ParseErrors for unit testing

The general compiler-error regex required a trailing ' [project.csproj]'
suffix, silently dropping errors emitted without it and reporting the build
clean. Remove the suffix anchor so all CS/CA/etc. errors are counted
regardless of whether MSBuild appends the project reference. Expose
ParseErrors as a public static method and add six unit tests covering
all three error categories (compiler, MSBuild, NuGet) with and without
the project suffix.
---
 src/Atc.DotNet/DotnetBuildHelper.cs           | 13 +++-
 .../DotnetBuildHelperTests.cs                 | 68 +++++++++++++++++++
 2 files changed, 80 insertions(+), 1 deletion(-)

diff --git a/src/Atc.DotNet/DotnetBuildHelper.cs b/src/Atc.DotNet/DotnetBuildHelper.cs
index 35dda2e8..f4734756 100644
--- a/src/Atc.DotNet/DotnetBuildHelper.cs
+++ b/src/Atc.DotNet/DotnetBuildHelper.cs
@@ -214,11 +214,22 @@ private static async Task<Dictionary<string, int>> InvokeBuildAndCollectErrors(
             .ConfigureAwait(false);
     }
 
+    /// <summary>
+    /// Parses raw dotnet build output and returns error codes grouped by their occurrence count.
+    /// Recognises MSBuild errors (MSB prefix), NuGet errors (NU prefix), and general compiler errors
+    /// (e.g. CS, CA). The project-file suffix that MSBuild appends — <c> [project.csproj]</c> — is
+    /// optional; errors emitted without it are still counted.
+    /// </summary>
+    /// <param name="buildOutput">The raw text output from a dotnet build invocation.</param>
+    /// <returns>A dictionary mapping each error code to the number of times it appeared.</returns>
+    public static Dictionary<string, int> ParseErrors(string buildOutput)
+        => ParseBuildOutput(buildOutput);
+
     private static Dictionary<string, int> ParseBuildOutput(string buildResult)
     {
         const string? regexPatternMsBuild = @": error MSB(\S+?): (.*)";
         const string? regexPatternNuget = @": error NU(\S+?): (.*)";
-        const string? regexPatternGeneral = @": error ([A-Z]\S+?): (.*) \[";
+        const string? regexPatternGeneral = @": error ([A-Z]\S+?): (.+)";
 
         var errors = ParseBuildOutputHelper(buildResult, regexPatternMsBuild, "MSB");
         if (errors.Any())
diff --git a/test/Atc.DotNet.Tests/DotnetBuildHelperTests.cs b/test/Atc.DotNet.Tests/DotnetBuildHelperTests.cs
index f3fdc5b9..eddb7884 100644
--- a/test/Atc.DotNet.Tests/DotnetBuildHelperTests.cs
+++ b/test/Atc.DotNet.Tests/DotnetBuildHelperTests.cs
@@ -50,6 +50,74 @@ public async Task Create_ConsoleApp_BadCase()
         Assert.Single(buildErrors);
     }
 
+    [Fact]
+    public void ParseErrors_CompilerError_WithProjectSuffix_Counted()
+    {
+        const string output = "Program.cs(13,13): error CS0246: The type 'Foo' could not be found [Test.csproj]";
+
+        var errors = DotnetBuildHelper.ParseErrors(output);
+
+        Assert.Single(errors);
+        Assert.Equal(1, errors["CS0246"]);
+    }
+
+    [Fact]
+    public void ParseErrors_CompilerError_WithoutProjectSuffix_Counted()
+    {
+        const string output = "Program.cs(13,13): error CS0246: The type 'Foo' could not be found";
+
+        var errors = DotnetBuildHelper.ParseErrors(output);
+
+        Assert.Single(errors);
+        Assert.Equal(1, errors["CS0246"]);
+    }
+
+    [Fact]
+    public void ParseErrors_MSBuildError_Counted()
+    {
+        const string output = "MSBUILD : error MSB1003: Specify a project or solution file.";
+
+        var errors = DotnetBuildHelper.ParseErrors(output);
+
+        Assert.Single(errors);
+        Assert.Equal(1, errors["MSB1003"]);
+    }
+
+    [Fact]
+    public void ParseErrors_NuGetError_Counted()
+    {
+        const string output = "Test.csproj : error NU1101: Unable to find package SomePackage.";
+
+        var errors = DotnetBuildHelper.ParseErrors(output);
+
+        Assert.Single(errors);
+        Assert.Equal(1, errors["NU1101"]);
+    }
+
+    [Fact]
+    public void ParseErrors_MultipleErrors_AggregatedByCode()
+    {
+        const string output = """
+            Program.cs(5,5): error CS0246: Missing type [Test.csproj]
+            Program.cs(6,5): error CS0246: Missing type [Test.csproj]
+            Program.cs(7,5): error CS0103: Name not found [Test.csproj]
+            """;
+
+        var errors = DotnetBuildHelper.ParseErrors(output);
+
+        Assert.Equal(2, errors.Count);
+        Assert.Equal(2, errors["CS0246"]);
+        Assert.Equal(1, errors["CS0103"]);
+    }
+
+    [Fact]
+    public void ParseErrors_EmptyOutput_ReturnsEmpty()
+    {
+        var errors = DotnetBuildHelper.ParseErrors(string.Empty);
+
+        Assert.Empty(errors);
+    }
+
     private static Task CreateCsprojFile(DirectoryInfo workingDirectory)
     {
         var file = new FileInfo(Path.Combine(workingDirectory.FullName, "Test.csproj"));

From 1141600a88de5e2bb13d5ae42c6bbaebd19133e8 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 11:10:20 +0200
Subject: [PATCH 055/100] fix(atc-console-spectre): share IAnsiConsole across
 loggers from same provider

Each ConsoleLogger was calling AnsiConsole.Create() independently, so a
provider with N category loggers opened N console instances, producing torn
interleaved output under concurrent log calls. Move console creation into
ConsoleLoggerProvider and inject the shared instance into each logger via a
new 3-parameter constructor. The 2-parameter constructor is retained for
callers that instantiate ConsoleLogger directly (delegates to CreateConsole
helper for backward compatibility).
---
 .../Logging/ConsoleLogger.cs                  | 37 ++++++++++++++++---
 .../Logging/ConsoleLoggerProvider.cs          | 18 ++++++++-
 2 files changed, 49 insertions(+), 6 deletions(-)

diff --git a/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs b/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs
index 2be6b187..979c6ae1 100644
--- a/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs
+++ b/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs
@@ -16,17 +16,43 @@ public class ConsoleLogger : ILogger
     private readonly IAnsiConsole console;
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="ConsoleLogger"/> class.
+    /// Initializes a new instance of the <see cref="ConsoleLogger"/> class with a shared console.
+    /// Prefer this constructor when the logger is created by a <see cref="ConsoleLoggerProvider"/> so
+    /// that all loggers in the same provider share one <see cref="IAnsiConsole"/> instance.
     /// </summary>
     /// <param name="categoryName">The category name for the logger.</param>
     /// <param name="config">The console logger configuration.</param>
-    /// <exception cref="ArgumentNullException">Thrown when <paramref name="config"/> is null.</exception>
+    /// <param name="console">A shared <see cref="IAnsiConsole"/> instance to write to.</param>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="config"/> or <paramref name="console"/> is null.</exception>
     public ConsoleLogger(
         string categoryName,
-        ConsoleLoggerConfiguration config)
+        ConsoleLoggerConfiguration config,
+        IAnsiConsole console)
     {
         this.categoryName = categoryName;
         this.config = config ?? throw new ArgumentNullException(nameof(config));
+        this.console = console ?? throw new ArgumentNullException(nameof(console));
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ConsoleLogger"/> class, creating its own
+    /// <see cref="IAnsiConsole"/> from the configuration. Use this only when creating a logger
+    /// outside of a <see cref="ConsoleLoggerProvider"/>; for provider-managed loggers prefer the
+    /// overload that accepts a shared <see cref="IAnsiConsole"/>.
+    /// </summary>
+    /// <param name="categoryName">The category name for the logger.</param>
+    /// <param name="config">The console logger configuration.</param>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="config"/> is null.</exception>
+    public ConsoleLogger(
+        string categoryName,
+        ConsoleLoggerConfiguration config)
+        : this(categoryName, config, CreateConsole(config))
+    {
+    }
+
+    private static IAnsiConsole CreateConsole(ConsoleLoggerConfiguration config)
+    {
+        ArgumentNullException.ThrowIfNull(config);
 
         var settings = config.ConsoleSettings ?? new AnsiConsoleSettings
         {
@@ -34,8 +60,9 @@ public ConsoleLogger(
             ColorSystem = ColorSystemSupport.Detect,
         };
 
-        console = AnsiConsole.Create(settings);
-        config.ConsoleConfiguration?.Invoke(console);
+        var c = AnsiConsole.Create(settings);
+        config.ConsoleConfiguration?.Invoke(c);
+        return c;
     }
 
     /// <inheritdoc />
diff --git a/src/Atc.Console.Spectre/Logging/ConsoleLoggerProvider.cs b/src/Atc.Console.Spectre/Logging/ConsoleLoggerProvider.cs
index 032fef98..4210f957 100644
--- a/src/Atc.Console.Spectre/Logging/ConsoleLoggerProvider.cs
+++ b/src/Atc.Console.Spectre/Logging/ConsoleLoggerProvider.cs
@@ -6,24 +6,40 @@ namespace Atc.Console.Spectre.Logging;
 public class ConsoleLoggerProvider : ILoggerProvider
 {
     private readonly ConsoleLoggerConfiguration config;
+    private readonly IAnsiConsole console;
     private readonly ConcurrentDictionary<string, ConsoleLogger> loggers = new(StringComparer.Ordinal);
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ConsoleLoggerProvider"/> class.
+    /// A single <see cref="IAnsiConsole"/> is created here and shared across all loggers produced
+    /// by this provider, preventing torn interleaved output under concurrent log calls.
     /// </summary>
     /// <param name="config">The console logger configuration to use.</param>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="config"/> is null.</exception>
     public ConsoleLoggerProvider(ConsoleLoggerConfiguration config)
     {
+        ArgumentNullException.ThrowIfNull(config);
+
         this.config = config;
+
+        var settings = config.ConsoleSettings ?? new AnsiConsoleSettings
+        {
+            Ansi = AnsiSupport.Detect,
+            ColorSystem = ColorSystemSupport.Detect,
+        };
+
+        console = AnsiConsole.Create(settings);
+        config.ConsoleConfiguration?.Invoke(console);
     }
 
     /// <summary>
     /// Creates a new <see cref="ConsoleLogger"/> instance for the specified category.
+    /// All loggers share the provider's <see cref="IAnsiConsole"/> instance.
     /// </summary>
     /// <param name="categoryName">The category name for the logger.</param>
     /// <returns>A <see cref="ConsoleLogger"/> instance.</returns>
     public ILogger CreateLogger(string categoryName)
-        => loggers.GetOrAdd(categoryName, name => new ConsoleLogger(name, config));
+        => loggers.GetOrAdd(categoryName, name => new ConsoleLogger(name, config, console));
 
     /// <inheritdoc />
     public void Dispose()

From 89ff282813446c88c4c628e6ef486fcd6f0e9921 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 11:13:26 +0200
Subject: [PATCH 056/100] fix(atc): fix IsSet overflow on long-backed flag
 enums and align truth tables

The non-generic Enum.IsSet used Convert.ToUInt32, throwing OverflowException
for any long-backed enum value with bits above position 31. It also used
AND-nonzero semantics (true if ANY flag bit matches) while the generic IsSet<T>
uses HasFlag semantics (true only if ALL flag bits match), producing inconsistent
results. Fix both by delegating to enumeration.HasFlag(matchTo), which handles
all underlying types and is consistent with the generic overload and AreFlagsSet.
---
 src/Atc/Extensions/EnumExtensions.cs          | 14 ++++++----
 .../Extensions/EnumExtensionsTests.cs         | 26 +++++++++++++++++++
 2 files changed, 35 insertions(+), 5 deletions(-)

diff --git a/src/Atc/Extensions/EnumExtensions.cs b/src/Atc/Extensions/EnumExtensions.cs
index 8b2a0310..ca3469dc 100644
--- a/src/Atc/Extensions/EnumExtensions.cs
+++ b/src/Atc/Extensions/EnumExtensions.cs
@@ -25,10 +25,14 @@ public static bool AreFlagsSet(
         Enum flags)
         => IsSet(enumeration, flags);
 
-    /// <summary>Determines whether the specified enumeration match another enumeration.</summary>
-    /// <param name="enumeration">The enumeration.</param>
-    /// <param name="matchTo">The enumeration to match.</param>
-    /// <returns>true on match; otherwise false.</returns>
+    /// <summary>
+    /// Determines whether all bits of <paramref name="matchTo"/> are set in <paramref name="enumeration"/>,
+    /// equivalent to <c>enumeration.HasFlag(matchTo)</c>. Works for all underlying numeric types including
+    /// <see langword="long"/>-backed enumerations.
+    /// </summary>
+    /// <param name="enumeration">The enumeration to check.</param>
+    /// <param name="matchTo">The flags that must all be present in <paramref name="enumeration"/>.</param>
+    /// <returns><see langword="true"/> if every bit in <paramref name="matchTo"/> is also set in <paramref name="enumeration"/>; otherwise, <see langword="false"/>.</returns>
     /// <code><![CDATA[bool match = DayOfWeek.Monday.IsSet(DayOfWeek.Monday);]]></code>
     /// <example><![CDATA[
     /// Assert.True(DayOfWeek.Monday.IsSet(DayOfWeek.Monday));
@@ -47,7 +51,7 @@ public static bool IsSet(
             throw new ArgumentNullException(nameof(matchTo));
         }
 
-        return (Convert.ToUInt32(enumeration, GlobalizationConstants.EnglishCultureInfo) & Convert.ToUInt32(matchTo, GlobalizationConstants.EnglishCultureInfo)) != 0;
+        return enumeration.HasFlag(matchTo);
     }
 
     /// <summary>
diff --git a/test/Atc.Tests/Extensions/EnumExtensionsTests.cs b/test/Atc.Tests/Extensions/EnumExtensionsTests.cs
index f5cedc24..3cffa07b 100644
--- a/test/Atc.Tests/Extensions/EnumExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/EnumExtensionsTests.cs
@@ -2,8 +2,19 @@ namespace Atc.Tests.Extensions;
 
 public class EnumExtensionsTests
 {
+    [SuppressMessage("Naming", "S2344:Enumeration type names should not have 'Flags' or 'Enum' suffixes", Justification = "Test fixture name.")]
+    [Flags]
+    private enum LongBackedEnum : long
+    {
+        None = 0,
+        A = 1L,
+        B = 2L,
+        HighBit = 1L << 33, // beyond uint range — previously caused OverflowException
+    }
+
     [Theory]
     [InlineData(true, DayOfWeek.Monday, DayOfWeek.Monday)]
+    [InlineData(false, DayOfWeek.Monday, DayOfWeek.Tuesday)]
     public void AreFlagsSet(
         bool expected,
         DayOfWeek value1,
@@ -12,12 +23,27 @@ public void AreFlagsSet(
 
     [Theory]
     [InlineData(true, DayOfWeek.Monday, DayOfWeek.Monday)]
+    [InlineData(false, DayOfWeek.Monday, DayOfWeek.Tuesday)]
     public void IsSet(
         bool expected,
         DayOfWeek value1,
         DayOfWeek value2)
         => Assert.Equal(expected, ((Enum)value1).IsSet(value2));
 
+    [Fact]
+    public void IsSet_LongBackedEnum_DoesNotOverflow()
+    {
+        Assert.True(((Enum)(LongBackedEnum.A | LongBackedEnum.HighBit)).IsSet(LongBackedEnum.HighBit));
+        Assert.False(((Enum)LongBackedEnum.A).IsSet(LongBackedEnum.HighBit));
+    }
+
+    [Fact]
+    public void IsSet_RequiresAllFlagsSet_ConsistentWithHasFlag()
+    {
+        Assert.False(((Enum)LongBackedEnum.A).IsSet(LongBackedEnum.A | LongBackedEnum.B));
+        Assert.True(((Enum)(LongBackedEnum.A | LongBackedEnum.B)).IsSet(LongBackedEnum.A));
+    }
+
     [Theory]
     [InlineData(true, DayOfWeek.Monday, DayOfWeek.Monday)]
     [InlineData(false, DayOfWeek.Monday, DayOfWeek.Tuesday)]

From cb0c3bc01dee3c1e46ad9a0b648807b8de75e642 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 11:18:34 +0200
Subject: [PATCH 057/100] fix(atc-xunit): cache CSharpDecompiler per assembly
 to avoid repeated PE re-parsing

---
 .../Atc.Console.Spectre.Logging.md            |  2 +-
 docs/CodeDoc/Atc.XUnit/Atc.XUnit.md           | 34 ++++++++++++-------
 docs/CodeDoc/Atc.XUnit/IndexExtended.md       | 20 +++++------
 src/Atc.XUnit/GlobalUsings.cs                 |  1 +
 .../AbstractSyntaxTree/DecompilerHelper.cs    | 12 +++++--
 5 files changed, 43 insertions(+), 26 deletions(-)

diff --git a/docs/CodeDoc/Atc.Console.Spectre/Atc.Console.Spectre.Logging.md b/docs/CodeDoc/Atc.Console.Spectre/Atc.Console.Spectre.Logging.md
index 4202233a..b560a00c 100644
--- a/docs/CodeDoc/Atc.Console.Spectre/Atc.Console.Spectre.Logging.md
+++ b/docs/CodeDoc/Atc.Console.Spectre/Atc.Console.Spectre.Logging.md
@@ -125,7 +125,7 @@ Provides logger instances configured for Spectre.Console rendering.
 >```csharp
 >ILogger CreateLogger(string categoryName)
 >```
-><b>Summary:</b> Creates a new `Atc.Console.Spectre.Logging.ConsoleLogger` instance for the specified category.
+><b>Summary:</b> Creates a new `Atc.Console.Spectre.Logging.ConsoleLogger` instance for the specified category. All loggers share the provider's `Spectre.Console.IAnsiConsole` instance.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`categoryName`&nbsp;&nbsp;-&nbsp;&nbsp;The category name for the logger.<br />
diff --git a/docs/CodeDoc/Atc.XUnit/Atc.XUnit.md b/docs/CodeDoc/Atc.XUnit/Atc.XUnit.md
index 56ed71d1..42701e5b 100644
--- a/docs/CodeDoc/Atc.XUnit/Atc.XUnit.md
+++ b/docs/CodeDoc/Atc.XUnit/Atc.XUnit.md
@@ -162,7 +162,7 @@ Provides helper methods for asserting code compliance related to test coverage.
 
 #### AssertExportedMethodsWithMissingTests
 >```csharp
->void AssertExportedMethodsWithMissingTests(DecompilerType decompilerType, Type sourceType, Type testType, bool useFullName = False)
+>void AssertExportedMethodsWithMissingTests(DecompilerType decompilerType, Type sourceType, Type testType, bool useFullName = False, CancellationToken cancellationToken = null)
 >```
 ><b>Summary:</b> Asserts that all public methods in a source type have corresponding unit tests. Fails the test if any methods are missing test coverage.
 >
@@ -171,9 +171,10 @@ Provides helper methods for asserting code compliance related to test coverage.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`sourceType`&nbsp;&nbsp;-&nbsp;&nbsp;The source type to validate for test coverage.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`testType`&nbsp;&nbsp;-&nbsp;&nbsp;The test type containing unit tests for the source type.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`useFullName`&nbsp;&nbsp;-&nbsp;&nbsp;If set to true, use full type names in output.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the analysis operation.<br />
 #### AssertExportedMethodsWithMissingTests
 >```csharp
->void AssertExportedMethodsWithMissingTests(DecompilerType decompilerType, Type sourceType, Assembly testAssembly, bool useFullName = False)
+>void AssertExportedMethodsWithMissingTests(DecompilerType decompilerType, Type sourceType, Assembly testAssembly, bool useFullName = False, CancellationToken cancellationToken = null)
 >```
 ><b>Summary:</b> Asserts that all public methods in a source type have corresponding unit tests. Fails the test if any methods are missing test coverage.
 >
@@ -182,9 +183,10 @@ Provides helper methods for asserting code compliance related to test coverage.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`sourceType`&nbsp;&nbsp;-&nbsp;&nbsp;The source type to validate for test coverage.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`testType`&nbsp;&nbsp;-&nbsp;&nbsp;The test type containing unit tests for the source type.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`useFullName`&nbsp;&nbsp;-&nbsp;&nbsp;If set to true, use full type names in output.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the analysis operation.<br />
 #### AssertExportedMethodsWithMissingTests
 >```csharp
->void AssertExportedMethodsWithMissingTests(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List<Type> excludeSourceTypes = null, bool useFullName = False)
+>void AssertExportedMethodsWithMissingTests(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List<Type> excludeSourceTypes = null, bool useFullName = False, CancellationToken cancellationToken = null)
 >```
 ><b>Summary:</b> Asserts that all public methods in a source type have corresponding unit tests. Fails the test if any methods are missing test coverage.
 >
@@ -193,9 +195,10 @@ Provides helper methods for asserting code compliance related to test coverage.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`sourceType`&nbsp;&nbsp;-&nbsp;&nbsp;The source type to validate for test coverage.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`testType`&nbsp;&nbsp;-&nbsp;&nbsp;The test type containing unit tests for the source type.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`useFullName`&nbsp;&nbsp;-&nbsp;&nbsp;If set to true, use full type names in output.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the analysis operation.<br />
 #### CollectExportedMethodsWithMissingTestsAndGenerateText
 >```csharp
->string CollectExportedMethodsWithMissingTestsAndGenerateText(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List<Type> excludeSourceTypes = null, bool useFullName = False)
+>string CollectExportedMethodsWithMissingTestsAndGenerateText(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List<Type> excludeSourceTypes = null, bool useFullName = False, CancellationToken cancellationToken = null)
 >```
 ><b>Summary:</b> Collects exported methods with missing tests and generates a formatted text report.
 >
@@ -205,11 +208,12 @@ Provides helper methods for asserting code compliance related to test coverage.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`testAssembly`&nbsp;&nbsp;-&nbsp;&nbsp;The test assembly to search for unit tests.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`excludeSourceTypes`&nbsp;&nbsp;-&nbsp;&nbsp;Optional list of source types to exclude from analysis.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`useFullName`&nbsp;&nbsp;-&nbsp;&nbsp;If set to true, use full type names in output.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the analysis operation.<br />
 >
 ><b>Returns:</b> A multi-line string containing all method signatures missing tests.
 #### CollectExportedMethodsWithMissingTestsAndGenerateTextLines
 >```csharp
->string[] CollectExportedMethodsWithMissingTestsAndGenerateTextLines(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List<Type> excludeSourceTypes = null, bool useFullName = False)
+>string[] CollectExportedMethodsWithMissingTestsAndGenerateTextLines(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List<Type> excludeSourceTypes = null, bool useFullName = False, CancellationToken cancellationToken = null)
 >```
 ><b>Summary:</b> Collects exported methods with missing tests and generates an array of formatted method signatures.
 >
@@ -219,11 +223,12 @@ Provides helper methods for asserting code compliance related to test coverage.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`testAssembly`&nbsp;&nbsp;-&nbsp;&nbsp;The test assembly to search for unit tests.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`excludeSourceTypes`&nbsp;&nbsp;-&nbsp;&nbsp;Optional list of source types to exclude from analysis.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`useFullName`&nbsp;&nbsp;-&nbsp;&nbsp;If set to true, use full type names in output.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the analysis operation.<br />
 >
 ><b>Returns:</b> An array of strings containing beautified method signatures.
 #### CollectExportedMethodsWithMissingTestsFromAssembly
 >```csharp
->MethodInfo[] CollectExportedMethodsWithMissingTestsFromAssembly(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List<Type> excludeSourceTypes = null)
+>MethodInfo[] CollectExportedMethodsWithMissingTestsFromAssembly(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List<Type> excludeSourceTypes = null, CancellationToken cancellationToken = null)
 >```
 ><b>Summary:</b> Collects all exported methods from an assembly that are missing test coverage.
 >
@@ -232,33 +237,36 @@ Provides helper methods for asserting code compliance related to test coverage.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`sourceAssembly`&nbsp;&nbsp;-&nbsp;&nbsp;The source assembly to analyze.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`testAssembly`&nbsp;&nbsp;-&nbsp;&nbsp;The test assembly to search for unit tests.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`excludeSourceTypes`&nbsp;&nbsp;-&nbsp;&nbsp;Optional list of source types to exclude from analysis.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the analysis operation.<br />
 >
 ><b>Returns:</b> An array of `System.Reflection.MethodInfo` objects representing methods missing test coverage.
 #### CollectExportedMethodsWithMissingTestsToExcel
 >```csharp
->void CollectExportedMethodsWithMissingTestsToExcel(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List<Type> excludeSourceTypes = null)
+>void CollectExportedMethodsWithMissingTestsToExcel(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List<Type> excludeSourceTypes = null, CancellationToken cancellationToken = null)
 >```
-><b>Summary:</b> Collects exported methods with missing tests and exports them to an Excel file at C:\Temp.
+><b>Summary:</b> Collects exported methods with missing tests and exports them to an Excel file at the system temp directory.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`decompilerType`&nbsp;&nbsp;-&nbsp;&nbsp;The  to use for analyzing test method bodies.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`sourceAssembly`&nbsp;&nbsp;-&nbsp;&nbsp;The source assembly to analyze.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`testAssembly`&nbsp;&nbsp;-&nbsp;&nbsp;The test assembly to search for unit tests.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`excludeSourceTypes`&nbsp;&nbsp;-&nbsp;&nbsp;Optional list of source types to exclude from analysis.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the analysis operation.<br />
 #### CollectExportedMethodsWithMissingTestsToExcel
 >```csharp
->void CollectExportedMethodsWithMissingTestsToExcel(DecompilerType decompilerType, DirectoryInfo reportDirectory, Assembly sourceAssembly, Assembly testAssembly, List<Type> excludeSourceTypes = null)
+>void CollectExportedMethodsWithMissingTestsToExcel(DecompilerType decompilerType, DirectoryInfo reportDirectory, Assembly sourceAssembly, Assembly testAssembly, List<Type> excludeSourceTypes = null, CancellationToken cancellationToken = null)
 >```
-><b>Summary:</b> Collects exported methods with missing tests and exports them to an Excel file at C:\Temp.
+><b>Summary:</b> Collects exported methods with missing tests and exports them to an Excel file at the system temp directory.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`decompilerType`&nbsp;&nbsp;-&nbsp;&nbsp;The  to use for analyzing test method bodies.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`sourceAssembly`&nbsp;&nbsp;-&nbsp;&nbsp;The source assembly to analyze.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`testAssembly`&nbsp;&nbsp;-&nbsp;&nbsp;The test assembly to search for unit tests.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`excludeSourceTypes`&nbsp;&nbsp;-&nbsp;&nbsp;Optional list of source types to exclude from analysis.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the analysis operation.<br />
 #### CollectExportedTypesWithMissingTests
 >```csharp
->Type[] CollectExportedTypesWithMissingTests(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List<Type> excludeSourceTypes = null)
+>Type[] CollectExportedTypesWithMissingTests(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List<Type> excludeSourceTypes = null, CancellationToken cancellationToken = null)
 >```
 ><b>Summary:</b> Collects all exported types that have at least one method missing test coverage.
 >
@@ -267,11 +275,12 @@ Provides helper methods for asserting code compliance related to test coverage.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`sourceAssembly`&nbsp;&nbsp;-&nbsp;&nbsp;The source assembly to analyze.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`testAssembly`&nbsp;&nbsp;-&nbsp;&nbsp;The test assembly to search for unit tests.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`excludeSourceTypes`&nbsp;&nbsp;-&nbsp;&nbsp;Optional list of source types to exclude from analysis.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the analysis operation.<br />
 >
 ><b>Returns:</b> An array of types that have methods missing test coverage.
 #### CollectExportedTypesWithMissingTestsAndGenerateText
 >```csharp
->string CollectExportedTypesWithMissingTestsAndGenerateText(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List<Type> excludeSourceTypes = null, bool useFullName = False)
+>string CollectExportedTypesWithMissingTestsAndGenerateText(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List<Type> excludeSourceTypes = null, bool useFullName = False, CancellationToken cancellationToken = null)
 >```
 ><b>Summary:</b> Collects exported types with missing tests and generates a C# code snippet for an exclude list. Useful for generating initial exclude lists when adding test coverage validation.
 >
@@ -281,6 +290,7 @@ Provides helper methods for asserting code compliance related to test coverage.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`testAssembly`&nbsp;&nbsp;-&nbsp;&nbsp;The test assembly to search for unit tests.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`excludeSourceTypes`&nbsp;&nbsp;-&nbsp;&nbsp;Optional list of source types to exclude from analysis.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`useFullName`&nbsp;&nbsp;-&nbsp;&nbsp;If set to true, use full type names in output.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the analysis operation.<br />
 >
 ><b>Returns:</b> A formatted C# code snippet containing a list of typeof() expressions for types missing tests.
 
diff --git a/docs/CodeDoc/Atc.XUnit/IndexExtended.md b/docs/CodeDoc/Atc.XUnit/IndexExtended.md
index 2b69def9..e219fcdc 100644
--- a/docs/CodeDoc/Atc.XUnit/IndexExtended.md
+++ b/docs/CodeDoc/Atc.XUnit/IndexExtended.md
@@ -25,16 +25,16 @@
      - AssertLocalizationResourcesForMissingTranslations(Assembly assembly, IList&lt;string&gt; cultureNames)
 - [CodeComplianceTestHelper](Atc.XUnit.md#codecompliancetesthelper)
   -  Static Methods
-     - AssertExportedMethodsWithMissingTests(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List&lt;Type&gt; excludeSourceTypes = null, bool useFullName = False)
-     - AssertExportedMethodsWithMissingTests(DecompilerType decompilerType, Type sourceType, Assembly testAssembly, bool useFullName = False)
-     - AssertExportedMethodsWithMissingTests(DecompilerType decompilerType, Type sourceType, Type testType, bool useFullName = False)
-     - CollectExportedMethodsWithMissingTestsAndGenerateText(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List&lt;Type&gt; excludeSourceTypes = null, bool useFullName = False)
-     - CollectExportedMethodsWithMissingTestsAndGenerateTextLines(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List&lt;Type&gt; excludeSourceTypes = null, bool useFullName = False)
-     - CollectExportedMethodsWithMissingTestsFromAssembly(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List&lt;Type&gt; excludeSourceTypes = null)
-     - CollectExportedMethodsWithMissingTestsToExcel(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List&lt;Type&gt; excludeSourceTypes = null)
-     - CollectExportedMethodsWithMissingTestsToExcel(DecompilerType decompilerType, DirectoryInfo reportDirectory, Assembly sourceAssembly, Assembly testAssembly, List&lt;Type&gt; excludeSourceTypes = null)
-     - CollectExportedTypesWithMissingTests(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List&lt;Type&gt; excludeSourceTypes = null)
-     - CollectExportedTypesWithMissingTestsAndGenerateText(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List&lt;Type&gt; excludeSourceTypes = null, bool useFullName = False)
+     - AssertExportedMethodsWithMissingTests(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List&lt;Type&gt; excludeSourceTypes = null, bool useFullName = False, CancellationToken cancellationToken = null)
+     - AssertExportedMethodsWithMissingTests(DecompilerType decompilerType, Type sourceType, Assembly testAssembly, bool useFullName = False, CancellationToken cancellationToken = null)
+     - AssertExportedMethodsWithMissingTests(DecompilerType decompilerType, Type sourceType, Type testType, bool useFullName = False, CancellationToken cancellationToken = null)
+     - CollectExportedMethodsWithMissingTestsAndGenerateText(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List&lt;Type&gt; excludeSourceTypes = null, bool useFullName = False, CancellationToken cancellationToken = null)
+     - CollectExportedMethodsWithMissingTestsAndGenerateTextLines(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List&lt;Type&gt; excludeSourceTypes = null, bool useFullName = False, CancellationToken cancellationToken = null)
+     - CollectExportedMethodsWithMissingTestsFromAssembly(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List&lt;Type&gt; excludeSourceTypes = null, CancellationToken cancellationToken = null)
+     - CollectExportedMethodsWithMissingTestsToExcel(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List&lt;Type&gt; excludeSourceTypes = null, CancellationToken cancellationToken = null)
+     - CollectExportedMethodsWithMissingTestsToExcel(DecompilerType decompilerType, DirectoryInfo reportDirectory, Assembly sourceAssembly, Assembly testAssembly, List&lt;Type&gt; excludeSourceTypes = null, CancellationToken cancellationToken = null)
+     - CollectExportedTypesWithMissingTests(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List&lt;Type&gt; excludeSourceTypes = null, CancellationToken cancellationToken = null)
+     - CollectExportedTypesWithMissingTestsAndGenerateText(DecompilerType decompilerType, Assembly sourceAssembly, Assembly testAssembly, List&lt;Type&gt; excludeSourceTypes = null, bool useFullName = False, CancellationToken cancellationToken = null)
 - [DecompilerType](Atc.XUnit.md#decompilertype)
 - [IntegrationTestCliBase](Atc.XUnit.md#integrationtestclibase)
   -  Static Methods
diff --git a/src/Atc.XUnit/GlobalUsings.cs b/src/Atc.XUnit/GlobalUsings.cs
index 6f2ece8a..8438af06 100644
--- a/src/Atc.XUnit/GlobalUsings.cs
+++ b/src/Atc.XUnit/GlobalUsings.cs
@@ -1,4 +1,5 @@
 global using System.Collections;
+global using System.Collections.Concurrent;
 global using System.Diagnostics;
 global using System.Diagnostics.CodeAnalysis;
 global using System.Globalization;
diff --git a/src/Atc.XUnit/Internal/AbstractSyntaxTree/DecompilerHelper.cs b/src/Atc.XUnit/Internal/AbstractSyntaxTree/DecompilerHelper.cs
index 2c3f9340..d3fa4ecf 100644
--- a/src/Atc.XUnit/Internal/AbstractSyntaxTree/DecompilerHelper.cs
+++ b/src/Atc.XUnit/Internal/AbstractSyntaxTree/DecompilerHelper.cs
@@ -3,13 +3,19 @@ namespace Atc.XUnit.Internal.AbstractSyntaxTree;
 
 internal static class DecompilerHelper
 {
+    private static readonly ConcurrentDictionary<string, Lazy<CSharpDecompiler>> Cache = new(StringComparer.OrdinalIgnoreCase);
+
     internal static CSharpDecompiler GetDecompiler(Assembly assembly)
     {
         var assemblyFileName = assembly.Location;
+        return Cache.GetOrAdd(assemblyFileName, static path =>
+            new Lazy<CSharpDecompiler>(() => CreateDecompiler(path), LazyThreadSafetyMode.ExecutionAndPublication)).Value;
+    }
 
-        // PEFile is used here only to validate the assembly; the resolver is the long-lived handle.
-        // The resolver itself is not IDisposable so it cannot be wrapped in using, but we close the
-        // validation PEFile immediately to avoid keeping the native handle open.
+    private static CSharpDecompiler CreateDecompiler(string assemblyFileName)
+    {
+        // PEFile is used only to validate the assembly path; the resolver is the long-lived handle.
+        // Close the validation PEFile immediately to avoid keeping the native handle open.
         using var module = new PEFile(assemblyFileName);
         var resolver = new UniversalAssemblyResolver(assemblyFileName, false, targetFramework: null);
         return new CSharpDecompiler(assemblyFileName, resolver, GetSettings());

From 2734bb51c8fc17e0c943fd8ef0a8ae3fb0b30a3a Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 11:23:55 +0200
Subject: [PATCH 058/100] feat(atc-dotnet): add BuildAndCollectWarnings,
 ParseWarnings, and additionalBuildArguments support

---
 docs/CodeDoc/Atc.DotNet/Atc.DotNet.md         |  66 ++++++-
 docs/CodeDoc/Atc.DotNet/IndexExtended.md      |   8 +-
 src/Atc.DotNet/DotnetBuildHelper.cs           | 172 +++++++++++++++---
 .../DotnetBuildHelperTests.cs                 |  78 ++++++++
 4 files changed, 290 insertions(+), 34 deletions(-)

diff --git a/docs/CodeDoc/Atc.DotNet/Atc.DotNet.md b/docs/CodeDoc/Atc.DotNet/Atc.DotNet.md
index a1865e4e..fc9a2640 100644
--- a/docs/CodeDoc/Atc.DotNet/Atc.DotNet.md
+++ b/docs/CodeDoc/Atc.DotNet/Atc.DotNet.md
@@ -27,7 +27,7 @@ Provides helper methods for building .NET projects and solutions using the dotne
 
 #### BuildAndCollectErrors
 >```csharp
->Task<Dictionary<string, int>> BuildAndCollectErrors(DirectoryInfo rootPath, int? runNumber = null, FileInfo buildFile = null, bool useNugetRestore = True, bool useConfigurationReleaseMode = True, int timeoutInSec = 1200, string logPrefix = , CancellationToken cancellationToken = null)
+>Task<Dictionary<string, int>> BuildAndCollectErrors(DirectoryInfo rootPath, int? runNumber = null, FileInfo buildFile = null, bool useNugetRestore = True, bool useConfigurationReleaseMode = True, int timeoutInSec = 1200, string logPrefix = , string additionalBuildArguments = , CancellationToken cancellationToken = null)
 >```
 ><b>Summary:</b> Builds a .NET project or solution and collects compilation errors grouped by error code.
 >
@@ -39,6 +39,7 @@ Provides helper methods for building .NET projects and solutions using the dotne
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`useConfigurationReleaseMode`&nbsp;&nbsp;-&nbsp;&nbsp;Whether to build in Release mode. If false, builds in Debug mode. Default is true.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`timeoutInSec`&nbsp;&nbsp;-&nbsp;&nbsp;Build timeout in seconds. Default is 1200 seconds (20 minutes).<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`logPrefix`&nbsp;&nbsp;-&nbsp;&nbsp;Optional prefix for log messages.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`additionalBuildArguments`&nbsp;&nbsp;-&nbsp;&nbsp;Additional arguments appended to the dotnet build command, such as -p:TreatWarningsAsErrors=false or -f net9.0.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;Token to cancel the build operation.<br />
 >
 ><b>Returns:</b> A dictionary mapping error codes to their occurrence counts.
@@ -46,7 +47,7 @@ Provides helper methods for building .NET projects and solutions using the dotne
 ><b>Remarks:</b> This is a convenience overload that uses `Microsoft.Extensions.Logging.Abstractions.NullLogger.Instance`; for build progress visibility prefer the overload accepting an `Microsoft.Extensions.Logging.ILogger`.
 #### BuildAndCollectErrors
 >```csharp
->Task<Dictionary<string, int>> BuildAndCollectErrors(ILogger logger, DirectoryInfo rootPath, int? runNumber = null, FileInfo buildFile = null, bool useNugetRestore = True, bool useConfigurationReleaseMode = True, int timeoutInSec = 1200, string logPrefix = , CancellationToken cancellationToken = null)
+>Task<Dictionary<string, int>> BuildAndCollectErrors(ILogger logger, DirectoryInfo rootPath, int? runNumber = null, FileInfo buildFile = null, bool useNugetRestore = True, bool useConfigurationReleaseMode = True, int timeoutInSec = 1200, string logPrefix = , string additionalBuildArguments = , CancellationToken cancellationToken = null)
 >```
 ><b>Summary:</b> Builds a .NET project or solution and collects compilation errors grouped by error code.
 >
@@ -58,11 +59,72 @@ Provides helper methods for building .NET projects and solutions using the dotne
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`useConfigurationReleaseMode`&nbsp;&nbsp;-&nbsp;&nbsp;Whether to build in Release mode. If false, builds in Debug mode. Default is true.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`timeoutInSec`&nbsp;&nbsp;-&nbsp;&nbsp;Build timeout in seconds. Default is 1200 seconds (20 minutes).<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`logPrefix`&nbsp;&nbsp;-&nbsp;&nbsp;Optional prefix for log messages.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`additionalBuildArguments`&nbsp;&nbsp;-&nbsp;&nbsp;Additional arguments appended to the dotnet build command, such as -p:TreatWarningsAsErrors=false or -f net9.0.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;Token to cancel the build operation.<br />
 >
 ><b>Returns:</b> A dictionary mapping error codes to their occurrence counts.
 >
 ><b>Remarks:</b> This is a convenience overload that uses `Microsoft.Extensions.Logging.Abstractions.NullLogger.Instance`; for build progress visibility prefer the overload accepting an `Microsoft.Extensions.Logging.ILogger`.
+#### BuildAndCollectWarnings
+>```csharp
+>Task<Dictionary<string, int>> BuildAndCollectWarnings(DirectoryInfo rootPath, int? runNumber = null, FileInfo buildFile = null, bool useNugetRestore = True, bool useConfigurationReleaseMode = True, int timeoutInSec = 1200, string logPrefix = , string additionalBuildArguments = , CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Builds a .NET project or solution and collects compilation warnings grouped by warning code.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`rootPath`&nbsp;&nbsp;-&nbsp;&nbsp;The root directory containing the project or solution to build.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`runNumber`&nbsp;&nbsp;-&nbsp;&nbsp;Optional run number for logging purposes.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`buildFile`&nbsp;&nbsp;-&nbsp;&nbsp;Optional specific solution or project file to build. If not specified, discovers the build file automatically.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`useNugetRestore`&nbsp;&nbsp;-&nbsp;&nbsp;Whether to perform NuGet restore before building. Default is true.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`useConfigurationReleaseMode`&nbsp;&nbsp;-&nbsp;&nbsp;Whether to build in Release mode. If false, builds in Debug mode. Default is true.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`timeoutInSec`&nbsp;&nbsp;-&nbsp;&nbsp;Build timeout in seconds. Default is 1200 seconds (20 minutes).<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`logPrefix`&nbsp;&nbsp;-&nbsp;&nbsp;Optional prefix for log messages.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`additionalBuildArguments`&nbsp;&nbsp;-&nbsp;&nbsp;Additional arguments appended to the dotnet build command, such as -p:NoWarn=CS0168 or -f net9.0.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;Token to cancel the build operation.<br />
+>
+><b>Returns:</b> A dictionary mapping warning codes to their occurrence counts.
+>
+><b>Remarks:</b> This is a convenience overload that uses `Microsoft.Extensions.Logging.Abstractions.NullLogger.Instance`; for build progress visibility prefer the overload accepting an `Microsoft.Extensions.Logging.ILogger`.
+#### BuildAndCollectWarnings
+>```csharp
+>Task<Dictionary<string, int>> BuildAndCollectWarnings(ILogger logger, DirectoryInfo rootPath, int? runNumber = null, FileInfo buildFile = null, bool useNugetRestore = True, bool useConfigurationReleaseMode = True, int timeoutInSec = 1200, string logPrefix = , string additionalBuildArguments = , CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Builds a .NET project or solution and collects compilation warnings grouped by warning code.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`rootPath`&nbsp;&nbsp;-&nbsp;&nbsp;The root directory containing the project or solution to build.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`runNumber`&nbsp;&nbsp;-&nbsp;&nbsp;Optional run number for logging purposes.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`buildFile`&nbsp;&nbsp;-&nbsp;&nbsp;Optional specific solution or project file to build. If not specified, discovers the build file automatically.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`useNugetRestore`&nbsp;&nbsp;-&nbsp;&nbsp;Whether to perform NuGet restore before building. Default is true.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`useConfigurationReleaseMode`&nbsp;&nbsp;-&nbsp;&nbsp;Whether to build in Release mode. If false, builds in Debug mode. Default is true.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`timeoutInSec`&nbsp;&nbsp;-&nbsp;&nbsp;Build timeout in seconds. Default is 1200 seconds (20 minutes).<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`logPrefix`&nbsp;&nbsp;-&nbsp;&nbsp;Optional prefix for log messages.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`additionalBuildArguments`&nbsp;&nbsp;-&nbsp;&nbsp;Additional arguments appended to the dotnet build command, such as -p:NoWarn=CS0168 or -f net9.0.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;Token to cancel the build operation.<br />
+>
+><b>Returns:</b> A dictionary mapping warning codes to their occurrence counts.
+>
+><b>Remarks:</b> This is a convenience overload that uses `Microsoft.Extensions.Logging.Abstractions.NullLogger.Instance`; for build progress visibility prefer the overload accepting an `Microsoft.Extensions.Logging.ILogger`.
+#### ParseErrors
+>```csharp
+>Dictionary<string, int> ParseErrors(string buildOutput)
+>```
+><b>Summary:</b> Parses raw dotnet build output and returns error codes grouped by their occurrence count. Recognises MSBuild errors (MSB prefix), NuGet errors (NU prefix), and general compiler errors (e.g. CS, CA). The project-file suffix that MSBuild appends — ` [project.csproj]` — is optional; errors emitted without it are still counted.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`buildOutput`&nbsp;&nbsp;-&nbsp;&nbsp;The raw text output from a dotnet build invocation.<br />
+>
+><b>Returns:</b> A dictionary mapping each error code to the number of times it appeared.
+#### ParseWarnings
+>```csharp
+>Dictionary<string, int> ParseWarnings(string buildOutput)
+>```
+><b>Summary:</b> Parses raw dotnet build output and returns warning codes grouped by their occurrence count. Recognises MSBuild warnings (MSB prefix), NuGet warnings (NU prefix), and general compiler warnings (e.g. CS, CA). The project-file suffix that MSBuild appends — ` [project.csproj]` — is optional; warnings emitted without it are still counted.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`buildOutput`&nbsp;&nbsp;-&nbsp;&nbsp;The raw text output from a dotnet build invocation.<br />
+>
+><b>Returns:</b> A dictionary mapping each warning code to the number of times it appeared.
 
 <br />
 
diff --git a/docs/CodeDoc/Atc.DotNet/IndexExtended.md b/docs/CodeDoc/Atc.DotNet/IndexExtended.md
index cf329cf9..99e604de 100644
--- a/docs/CodeDoc/Atc.DotNet/IndexExtended.md
+++ b/docs/CodeDoc/Atc.DotNet/IndexExtended.md
@@ -9,8 +9,12 @@
 - [AtcDotnetAssemblyTypeInitializer](Atc.DotNet.md#atcdotnetassemblytypeinitializer)
 - [DotnetBuildHelper](Atc.DotNet.md#dotnetbuildhelper)
   -  Static Methods
-     - BuildAndCollectErrors(DirectoryInfo rootPath, int? runNumber = null, FileInfo buildFile = null, bool useNugetRestore = True, bool useConfigurationReleaseMode = True, int timeoutInSec = 1200, string logPrefix = , CancellationToken cancellationToken = null)
-     - BuildAndCollectErrors(ILogger logger, DirectoryInfo rootPath, int? runNumber = null, FileInfo buildFile = null, bool useNugetRestore = True, bool useConfigurationReleaseMode = True, int timeoutInSec = 1200, string logPrefix = , CancellationToken cancellationToken = null)
+     - BuildAndCollectErrors(DirectoryInfo rootPath, int? runNumber = null, FileInfo buildFile = null, bool useNugetRestore = True, bool useConfigurationReleaseMode = True, int timeoutInSec = 1200, string logPrefix = , string additionalBuildArguments = , CancellationToken cancellationToken = null)
+     - BuildAndCollectErrors(ILogger logger, DirectoryInfo rootPath, int? runNumber = null, FileInfo buildFile = null, bool useNugetRestore = True, bool useConfigurationReleaseMode = True, int timeoutInSec = 1200, string logPrefix = , string additionalBuildArguments = , CancellationToken cancellationToken = null)
+     - BuildAndCollectWarnings(DirectoryInfo rootPath, int? runNumber = null, FileInfo buildFile = null, bool useNugetRestore = True, bool useConfigurationReleaseMode = True, int timeoutInSec = 1200, string logPrefix = , string additionalBuildArguments = , CancellationToken cancellationToken = null)
+     - BuildAndCollectWarnings(ILogger logger, DirectoryInfo rootPath, int? runNumber = null, FileInfo buildFile = null, bool useNugetRestore = True, bool useConfigurationReleaseMode = True, int timeoutInSec = 1200, string logPrefix = , string additionalBuildArguments = , CancellationToken cancellationToken = null)
+     - ParseErrors(string buildOutput)
+     - ParseWarnings(string buildOutput)
 - [DotnetCsProjFileHelper](Atc.DotNet.md#dotnetcsprojfilehelper)
   -  Static Methods
      - FindAllInPath(DirectoryInfo directoryInfo, SearchOption searchOption = AllDirectories)
diff --git a/src/Atc.DotNet/DotnetBuildHelper.cs b/src/Atc.DotNet/DotnetBuildHelper.cs
index f4734756..3cb53ca9 100644
--- a/src/Atc.DotNet/DotnetBuildHelper.cs
+++ b/src/Atc.DotNet/DotnetBuildHelper.cs
@@ -24,6 +24,7 @@ public static class DotnetBuildHelper
     /// <param name="useConfigurationReleaseMode">Whether to build in Release mode. If false, builds in Debug mode. Default is true.</param>
     /// <param name="timeoutInSec">Build timeout in seconds. Default is 1200 seconds (20 minutes).</param>
     /// <param name="logPrefix">Optional prefix for log messages.</param>
+    /// <param name="additionalBuildArguments">Additional arguments appended to the dotnet build command, such as <c>-p:TreatWarningsAsErrors=false</c> or <c>-f net9.0</c>.</param>
     /// <param name="cancellationToken">Token to cancel the build operation.</param>
     /// <returns>A dictionary mapping error codes to their occurrence counts.</returns>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="rootPath"/> is null.</exception>
@@ -31,6 +32,7 @@ public static class DotnetBuildHelper
     /// This is a convenience overload that uses <see cref="NullLogger.Instance"/>; for build
     /// progress visibility prefer the overload accepting an <see cref="ILogger"/>.
     /// </remarks>
+    [SuppressMessage("Major Code Smell", "S107:Methods should not have too many parameters", Justification = "OK.")]
     public static Task<Dictionary<string, int>> BuildAndCollectErrors(
         DirectoryInfo rootPath,
         int? runNumber = null,
@@ -39,6 +41,7 @@ public static Task<Dictionary<string, int>> BuildAndCollectErrors(
         bool useConfigurationReleaseMode = true,
         int timeoutInSec = DefaultTimeoutInSec,
         string logPrefix = "",
+        string additionalBuildArguments = "",
         CancellationToken cancellationToken = default)
         => BuildAndCollectErrors(
             NullLogger.Instance,
@@ -49,6 +52,7 @@ public static Task<Dictionary<string, int>> BuildAndCollectErrors(
             useConfigurationReleaseMode,
             timeoutInSec,
             logPrefix,
+            additionalBuildArguments,
             cancellationToken);
 
     /// <summary>
@@ -62,6 +66,7 @@ public static Task<Dictionary<string, int>> BuildAndCollectErrors(
     /// <param name="useConfigurationReleaseMode">Whether to build in Release mode. If false, builds in Debug mode. Default is true.</param>
     /// <param name="timeoutInSec">Build timeout in seconds. Default is 1200 seconds (20 minutes).</param>
     /// <param name="logPrefix">Optional prefix for log messages.</param>
+    /// <param name="additionalBuildArguments">Additional arguments appended to the dotnet build command, such as <c>-p:TreatWarningsAsErrors=false</c> or <c>-f net9.0</c>.</param>
     /// <param name="cancellationToken">Token to cancel the build operation.</param>
     /// <returns>A dictionary mapping error codes to their occurrence counts.</returns>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="logger"/> or <paramref name="rootPath"/> is null.</exception>
@@ -75,19 +80,99 @@ public static Task<Dictionary<string, int>> BuildAndCollectErrors(
         bool useConfigurationReleaseMode = true,
         int timeoutInSec = DefaultTimeoutInSec,
         string logPrefix = "",
+        string additionalBuildArguments = "",
         CancellationToken cancellationToken = default)
     {
-        if (logger is null)
-        {
-            throw new ArgumentNullException(nameof(logger));
-        }
+        ArgumentNullException.ThrowIfNull(logger);
+        ArgumentNullException.ThrowIfNull(rootPath);
 
-        if (rootPath is null)
-        {
-            throw new ArgumentNullException(nameof(rootPath));
-        }
+        return InvokeBuildAndCollect(
+            logger,
+            rootPath,
+            runNumber,
+            buildFile,
+            useNugetRestore,
+            useConfigurationReleaseMode,
+            timeoutInSec,
+            logPrefix,
+            additionalBuildArguments,
+            collectWarnings: false,
+            cancellationToken);
+    }
+
+    /// <summary>
+    /// Builds a .NET project or solution and collects compilation warnings grouped by warning code.
+    /// </summary>
+    /// <param name="rootPath">The root directory containing the project or solution to build.</param>
+    /// <param name="runNumber">Optional run number for logging purposes.</param>
+    /// <param name="buildFile">Optional specific solution or project file to build. If not specified, discovers the build file automatically.</param>
+    /// <param name="useNugetRestore">Whether to perform NuGet restore before building. Default is true.</param>
+    /// <param name="useConfigurationReleaseMode">Whether to build in Release mode. If false, builds in Debug mode. Default is true.</param>
+    /// <param name="timeoutInSec">Build timeout in seconds. Default is 1200 seconds (20 minutes).</param>
+    /// <param name="logPrefix">Optional prefix for log messages.</param>
+    /// <param name="additionalBuildArguments">Additional arguments appended to the dotnet build command, such as <c>-p:NoWarn=CS0168</c> or <c>-f net9.0</c>.</param>
+    /// <param name="cancellationToken">Token to cancel the build operation.</param>
+    /// <returns>A dictionary mapping warning codes to their occurrence counts.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="rootPath"/> is null.</exception>
+    /// <remarks>
+    /// This is a convenience overload that uses <see cref="NullLogger.Instance"/>; for build
+    /// progress visibility prefer the overload accepting an <see cref="ILogger"/>.
+    /// </remarks>
+    [SuppressMessage("Major Code Smell", "S107:Methods should not have too many parameters", Justification = "OK.")]
+    public static Task<Dictionary<string, int>> BuildAndCollectWarnings(
+        DirectoryInfo rootPath,
+        int? runNumber = null,
+        FileInfo? buildFile = null,
+        bool useNugetRestore = true,
+        bool useConfigurationReleaseMode = true,
+        int timeoutInSec = DefaultTimeoutInSec,
+        string logPrefix = "",
+        string additionalBuildArguments = "",
+        CancellationToken cancellationToken = default)
+        => BuildAndCollectWarnings(
+            NullLogger.Instance,
+            rootPath,
+            runNumber,
+            buildFile,
+            useNugetRestore,
+            useConfigurationReleaseMode,
+            timeoutInSec,
+            logPrefix,
+            additionalBuildArguments,
+            cancellationToken);
 
-        return InvokeBuildAndCollectErrors(
+    /// <summary>
+    /// Builds a .NET project or solution with logging support and collects compilation warnings grouped by warning code.
+    /// </summary>
+    /// <param name="logger">The logger to use for build progress and results.</param>
+    /// <param name="rootPath">The root directory containing the project or solution to build.</param>
+    /// <param name="runNumber">Optional run number for logging purposes.</param>
+    /// <param name="buildFile">Optional specific solution or project file to build. If not specified, discovers the build file automatically.</param>
+    /// <param name="useNugetRestore">Whether to perform NuGet restore before building. Default is true.</param>
+    /// <param name="useConfigurationReleaseMode">Whether to build in Release mode. If false, builds in Debug mode. Default is true.</param>
+    /// <param name="timeoutInSec">Build timeout in seconds. Default is 1200 seconds (20 minutes).</param>
+    /// <param name="logPrefix">Optional prefix for log messages.</param>
+    /// <param name="additionalBuildArguments">Additional arguments appended to the dotnet build command, such as <c>-p:NoWarn=CS0168</c> or <c>-f net9.0</c>.</param>
+    /// <param name="cancellationToken">Token to cancel the build operation.</param>
+    /// <returns>A dictionary mapping warning codes to their occurrence counts.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="logger"/> or <paramref name="rootPath"/> is null.</exception>
+    [SuppressMessage("Major Code Smell", "S107:Methods should not have too many parameters", Justification = "OK.")]
+    public static Task<Dictionary<string, int>> BuildAndCollectWarnings(
+        ILogger logger,
+        DirectoryInfo rootPath,
+        int? runNumber = null,
+        FileInfo? buildFile = null,
+        bool useNugetRestore = true,
+        bool useConfigurationReleaseMode = true,
+        int timeoutInSec = DefaultTimeoutInSec,
+        string logPrefix = "",
+        string additionalBuildArguments = "",
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(logger);
+        ArgumentNullException.ThrowIfNull(rootPath);
+
+        return InvokeBuildAndCollect(
             logger,
             rootPath,
             runNumber,
@@ -96,11 +181,13 @@ public static Task<Dictionary<string, int>> BuildAndCollectErrors(
             useConfigurationReleaseMode,
             timeoutInSec,
             logPrefix,
+            additionalBuildArguments,
+            collectWarnings: true,
             cancellationToken);
     }
 
     [SuppressMessage("Major Code Smell", "S107:Methods should not have too many parameters", Justification = "OK.")]
-    private static async Task<Dictionary<string, int>> InvokeBuildAndCollectErrors(
+    private static async Task<Dictionary<string, int>> InvokeBuildAndCollect(
         ILogger logger,
         DirectoryInfo rootPath,
         int? runNumber,
@@ -109,6 +196,8 @@ private static async Task<Dictionary<string, int>> InvokeBuildAndCollectErrors(
         bool useConfigurationReleaseMode,
         int timeoutInSec,
         string logPrefix,
+        string additionalBuildArguments,
+        bool collectWarnings,
         CancellationToken cancellationToken)
     {
         logger.LogInformation(runNumber is > 0
@@ -123,6 +212,7 @@ private static async Task<Dictionary<string, int>> InvokeBuildAndCollectErrors(
                 useNugetRestore,
                 useConfigurationReleaseMode,
                 timeoutInSec,
+                additionalBuildArguments,
                 cancellationToken)
             .ConfigureAwait(false);
 
@@ -133,23 +223,27 @@ private static async Task<Dictionary<string, int>> InvokeBuildAndCollectErrors(
             throw new IOException(output);
         }
 
-        var parsedErrors = ParseBuildOutput(output);
-        int totalErrors = parsedErrors.Sum(parsedError => parsedError.Value);
+        var parsed = collectWarnings
+            ? ParseBuildOutput(output, diagnostic: "warning")
+            : ParseBuildOutput(output, diagnostic: "error");
+
+        int total = parsed.Sum(x => x.Value);
 
         stopwatch.Stop();
 
-        if (totalErrors > 0)
+        if (total > 0)
         {
+            var kind = collectWarnings ? "warnings" : "errors";
             logger.LogError(runNumber is > 0
-                ? $"{logPrefix}Found {totalErrors} errors divided into {parsedErrors.Count} rules in Build ({runNumber})"
-                : $"{logPrefix}Found {totalErrors} errors divided into {parsedErrors.Count} rules");
+                ? $"{logPrefix}Found {total} {kind} divided into {parsed.Count} rules in Build ({runNumber})"
+                : $"{logPrefix}Found {total} {kind} divided into {parsed.Count} rules");
         }
 
         logger.LogInformation(runNumber is > 0
             ? $"{logPrefix}Build ({runNumber}) time: {stopwatch.Elapsed.GetPrettyTime()}"
             : $"{logPrefix}Build time: {stopwatch.Elapsed.GetPrettyTime()}");
 
-        return parsedErrors;
+        return parsed;
     }
 
     private static async Task<(
@@ -160,6 +254,7 @@ private static async Task<Dictionary<string, int>> InvokeBuildAndCollectErrors(
         bool useNugetRestore,
         bool useConfigurationReleaseMode,
         int timeoutInSec,
+        string additionalBuildArguments,
         CancellationToken cancellationToken)
     {
         var argumentNugetRestore = useNugetRestore
@@ -170,14 +265,18 @@ private static async Task<Dictionary<string, int>> InvokeBuildAndCollectErrors(
             ? " -c Release"
             : " -c Debug";
 
+        var argumentAdditional = string.IsNullOrWhiteSpace(additionalBuildArguments)
+            ? string.Empty
+            : $" {additionalBuildArguments.Trim()}";
+
         string arguments;
         if (buildFile is not null && buildFile.Exists)
         {
-            arguments = $"build {buildFile.FullName}{argumentNugetRestore}{argumentConfigurationReleaseMode} -v q -clp:NoSummary";
+            arguments = $"build {buildFile.FullName}{argumentNugetRestore}{argumentConfigurationReleaseMode}{argumentAdditional} -v q -clp:NoSummary";
         }
         else
         {
-            arguments = $"build{argumentNugetRestore}{argumentConfigurationReleaseMode} -v q -clp:NoSummary";
+            arguments = $"build{argumentNugetRestore}{argumentConfigurationReleaseMode}{argumentAdditional} -v q -clp:NoSummary";
             var slnFiles = Directory.GetFiles(rootPath.FullName, "*.sln");
             if (slnFiles.Length > 1)
             {
@@ -223,27 +322,40 @@ private static async Task<Dictionary<string, int>> InvokeBuildAndCollectErrors(
     /// <param name="buildOutput">The raw text output from a dotnet build invocation.</param>
     /// <returns>A dictionary mapping each error code to the number of times it appeared.</returns>
     public static Dictionary<string, int> ParseErrors(string buildOutput)
-        => ParseBuildOutput(buildOutput);
+        => ParseBuildOutput(buildOutput, diagnostic: "error");
+
+    /// <summary>
+    /// Parses raw dotnet build output and returns warning codes grouped by their occurrence count.
+    /// Recognises MSBuild warnings (MSB prefix), NuGet warnings (NU prefix), and general compiler warnings
+    /// (e.g. CS, CA). The project-file suffix that MSBuild appends — <c> [project.csproj]</c> — is
+    /// optional; warnings emitted without it are still counted.
+    /// </summary>
+    /// <param name="buildOutput">The raw text output from a dotnet build invocation.</param>
+    /// <returns>A dictionary mapping each warning code to the number of times it appeared.</returns>
+    public static Dictionary<string, int> ParseWarnings(string buildOutput)
+        => ParseBuildOutput(buildOutput, diagnostic: "warning");
 
-    private static Dictionary<string, int> ParseBuildOutput(string buildResult)
+    private static Dictionary<string, int> ParseBuildOutput(
+        string buildResult,
+        string diagnostic)
     {
-        const string? regexPatternMsBuild = @": error MSB(\S+?): (.*)";
-        const string? regexPatternNuget = @": error NU(\S+?): (.*)";
-        const string? regexPatternGeneral = @": error ([A-Z]\S+?): (.+)";
+        var patternMsBuild = $@": {diagnostic} MSB(\S+?): (.*)";
+        var patternNuget = $@": {diagnostic} NU(\S+?): (.*)";
+        var patternGeneral = $@": {diagnostic} ([A-Z]\S+?): (.+)";
 
-        var errors = ParseBuildOutputHelper(buildResult, regexPatternMsBuild, "MSB");
-        if (errors.Any())
+        var results = ParseBuildOutputHelper(buildResult, patternMsBuild, "MSB");
+        if (results.Any())
         {
-            return errors;
+            return results;
         }
 
-        errors = ParseBuildOutputHelper(buildResult, regexPatternNuget, "NU");
-        if (errors.Any())
+        results = ParseBuildOutputHelper(buildResult, patternNuget, "NU");
+        if (results.Any())
         {
-            return errors;
+            return results;
         }
 
-        return ParseBuildOutputHelper(buildResult, regexPatternGeneral);
+        return ParseBuildOutputHelper(buildResult, patternGeneral);
     }
 
     private static Dictionary<string, int> ParseBuildOutputHelper(
diff --git a/test/Atc.DotNet.Tests/DotnetBuildHelperTests.cs b/test/Atc.DotNet.Tests/DotnetBuildHelperTests.cs
index eddb7884..ca2bf34d 100644
--- a/test/Atc.DotNet.Tests/DotnetBuildHelperTests.cs
+++ b/test/Atc.DotNet.Tests/DotnetBuildHelperTests.cs
@@ -118,6 +118,84 @@ public void ParseErrors_EmptyOutput_ReturnsEmpty()
         Assert.Empty(errors);
     }
 
+    [Fact]
+    public void ParseWarnings_CompilerWarning_WithProjectSuffix_Counted()
+    {
+        const string output = "Program.cs(5,13): warning CS0168: The variable 'x' is declared but never used [Test.csproj]";
+
+        var warnings = DotnetBuildHelper.ParseWarnings(output);
+
+        Assert.Single(warnings);
+        Assert.Equal(1, warnings["CS0168"]);
+    }
+
+    [Fact]
+    public void ParseWarnings_CompilerWarning_WithoutProjectSuffix_Counted()
+    {
+        const string output = "Program.cs(5,13): warning CS0168: The variable 'x' is declared but never used";
+
+        var warnings = DotnetBuildHelper.ParseWarnings(output);
+
+        Assert.Single(warnings);
+        Assert.Equal(1, warnings["CS0168"]);
+    }
+
+    [Fact]
+    public void ParseWarnings_MSBuildWarning_Counted()
+    {
+        const string output = "MSBUILD : warning MSB3277: Found conflicts between different versions of assembly.";
+
+        var warnings = DotnetBuildHelper.ParseWarnings(output);
+
+        Assert.Single(warnings);
+        Assert.Equal(1, warnings["MSB3277"]);
+    }
+
+    [Fact]
+    public void ParseWarnings_NuGetWarning_Counted()
+    {
+        const string output = "Test.csproj : warning NU1701: Package 'OldPkg 1.0.0' was restored using net472.";
+
+        var warnings = DotnetBuildHelper.ParseWarnings(output);
+
+        Assert.Single(warnings);
+        Assert.Equal(1, warnings["NU1701"]);
+    }
+
+    [Fact]
+    public void ParseWarnings_MultipleWarnings_AggregatedByCode()
+    {
+        const string output = """
+            Program.cs(5,5): warning CS0168: Unused var [Test.csproj]
+            Program.cs(6,5): warning CS0168: Unused var [Test.csproj]
+            Program.cs(7,5): warning CS0219: Value assigned but never used [Test.csproj]
+            """;
+
+        var warnings = DotnetBuildHelper.ParseWarnings(output);
+
+        Assert.Equal(2, warnings.Count);
+        Assert.Equal(2, warnings["CS0168"]);
+        Assert.Equal(1, warnings["CS0219"]);
+    }
+
+    [Fact]
+    public void ParseWarnings_EmptyOutput_ReturnsEmpty()
+    {
+        var warnings = DotnetBuildHelper.ParseWarnings(string.Empty);
+
+        Assert.Empty(warnings);
+    }
+
+    [Fact]
+    public void ParseWarnings_DoesNotMatchErrors()
+    {
+        const string output = "Program.cs(13,13): error CS0246: The type 'Foo' could not be found";
+
+        var warnings = DotnetBuildHelper.ParseWarnings(output);
+
+        Assert.Empty(warnings);
+    }
+
     private static Task CreateCsprojFile(DirectoryInfo workingDirectory)
     {
         var file = new FileInfo(Path.Combine(workingDirectory.FullName, "Test.csproj"));

From 87e4bb357958a7602b896c88125ae5b03e648b0d Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 11:30:23 +0200
Subject: [PATCH 059/100] feat(atc-console-spectre): implement BeginScope with
 async-context scope tracking

---
 .../Atc.Console.Spectre.Logging.md            |  5 ++
 .../Atc.Console.Spectre/IndexExtended.md      |  1 +
 .../Logging/ConsoleLogger.cs                  | 65 +++++++++++++++++--
 .../Logging/ConsoleLoggerConfiguration.cs     |  9 ++-
 4 files changed, 72 insertions(+), 8 deletions(-)

diff --git a/docs/CodeDoc/Atc.Console.Spectre/Atc.Console.Spectre.Logging.md b/docs/CodeDoc/Atc.Console.Spectre/Atc.Console.Spectre.Logging.md
index b560a00c..72139c6a 100644
--- a/docs/CodeDoc/Atc.Console.Spectre/Atc.Console.Spectre.Logging.md
+++ b/docs/CodeDoc/Atc.Console.Spectre/Atc.Console.Spectre.Logging.md
@@ -65,6 +65,11 @@ Configuration options for the console logger used in Spectre.Console CLI applica
 >IncludeInnerMessageForException
 >```
 ><b>Summary:</b> Gets or sets a value indicating whether the inner-exception-message should be rendered.
+#### IncludeScopes
+>```csharp
+>IncludeScopes
+>```
+><b>Summary:</b> Gets or sets a value indicating whether log scope values are included in the output. When enabled, active scopes opened via `Microsoft.Extensions.Logging.ILogger.BeginScope``1(``0)` are rendered as a grey prefix before the log message.
 #### MinimumLogLevel
 >```csharp
 >MinimumLogLevel
diff --git a/docs/CodeDoc/Atc.Console.Spectre/IndexExtended.md b/docs/CodeDoc/Atc.Console.Spectre/IndexExtended.md
index bb3b3a2d..ff679d8e 100644
--- a/docs/CodeDoc/Atc.Console.Spectre/IndexExtended.md
+++ b/docs/CodeDoc/Atc.Console.Spectre/IndexExtended.md
@@ -92,6 +92,7 @@
      - ConsoleSettings
      - IncludeExceptionNameForException
      - IncludeInnerMessageForException
+     - IncludeScopes
      - MinimumLogLevel
      - RenderingMode
      - TimestampFormat
diff --git a/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs b/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs
index 979c6ae1..03b7469a 100644
--- a/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs
+++ b/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs
@@ -66,7 +66,8 @@ private static IAnsiConsole CreateConsole(ConsoleLoggerConfiguration config)
     }
 
     /// <inheritdoc />
-    public IDisposable BeginScope<TState>(TState state) => NullScope.Instance;
+    public IDisposable BeginScope<TState>(TState state)
+        => new LogScope(state);
 
     /// <inheritdoc />
     public bool IsEnabled(LogLevel logLevel)
@@ -92,6 +93,15 @@ public void Log<TState>(
             ? stateStr
             : Markup.Escape(stateStr);
 
+        if (config.IncludeScopes)
+        {
+            var scopeText = LogScope.BuildScopeText();
+            if (scopeText.Length > 0)
+            {
+                message = $"[grey]{Markup.Escape(scopeText)}[/] {message}";
+            }
+        }
+
         var exceptionMessage = exception?.GetMessage(
             includeInnerMessage: config.IncludeInnerMessageForException,
             includeExceptionName: config.IncludeInnerMessageForException);
@@ -335,20 +345,61 @@ private string GetMessageWithMarkup(
         => $"{GetLogLevelMarkupStartTag(logLevel)}{message}[/]";
 
     /// <summary>
-    /// A no-op <see cref="IDisposable"/> returned by <see cref="BeginScope{TState}"/> so that
-    /// callers using <c>using (logger.BeginScope(...))</c> do not dereference a null instance.
+    /// Tracks a single log scope entry in a per-async-context linked list.
+    /// Disposing removes this scope from the ambient context.
     /// </summary>
-    private sealed class NullScope : IDisposable
+    private sealed class LogScope : IDisposable
     {
-        public static NullScope Instance { get; } = new();
+        private static readonly AsyncLocal<LogScope?> Current = new();
 
-        private NullScope()
+        private readonly LogScope? parent;
+        private bool disposed;
+
+        internal LogScope(object? state)
         {
+            State = state;
+            parent = Current.Value;
+            Current.Value = this;
+        }
+
+        internal object? State { get; }
+
+        /// <summary>
+        /// Builds a formatted string from all active scopes in the current async context,
+        /// from outermost to innermost, separated by <c>" =&gt; "</c>.
+        /// Returns <see cref="string.Empty"/> when no scopes are active.
+        /// </summary>
+        internal static string BuildScopeText()
+        {
+            var scope = Current.Value;
+            if (scope is null)
+            {
+                return string.Empty;
+            }
+
+            var parts = new List<string>();
+            while (scope is not null)
+            {
+                var text = scope.State?.ToString();
+                if (!string.IsNullOrEmpty(text))
+                {
+                    parts.Add(text);
+                }
+
+                scope = scope.parent;
+            }
+
+            parts.Reverse();
+            return string.Join(" => ", parts);
         }
 
         public void Dispose()
         {
-            // No-op: this logger does not track scopes.
+            if (!disposed)
+            {
+                Current.Value = parent;
+                disposed = true;
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/Atc.Console.Spectre/Logging/ConsoleLoggerConfiguration.cs b/src/Atc.Console.Spectre/Logging/ConsoleLoggerConfiguration.cs
index 16c747c7..7c8742e8 100644
--- a/src/Atc.Console.Spectre/Logging/ConsoleLoggerConfiguration.cs
+++ b/src/Atc.Console.Spectre/Logging/ConsoleLoggerConfiguration.cs
@@ -80,6 +80,13 @@ public ConsoleLoggerConfiguration()
     /// </summary>
     public bool AllowMarkup { get; set; }
 
+    /// <summary>
+    /// Gets or sets a value indicating whether log scope values are included in the output.
+    /// When enabled, active scopes opened via <see cref="Microsoft.Extensions.Logging.ILogger.BeginScope{TState}"/>
+    /// are rendered as a grey prefix before the log message.
+    /// </summary>
+    public bool IncludeScopes { get; set; }
+
     /// <summary>
     /// Gets or sets a value indicating whether the Timestamp should be rendered as UTC.
     /// </summary>
@@ -100,5 +107,5 @@ public ConsoleLoggerConfiguration()
 
     /// <inheritdoc />
     public override string ToString()
-        => $"{nameof(MinimumLogLevel)}: {MinimumLogLevel}, {nameof(RenderingMode)}: {RenderingMode}, {nameof(UseTimestamp)}: {UseTimestamp}, {nameof(UseShortNameForLogLevel)}: {UseShortNameForLogLevel}, {nameof(IncludeInnerMessageForException)}: {IncludeInnerMessageForException}, {nameof(IncludeExceptionNameForException)}: {IncludeExceptionNameForException}, {nameof(AllowMarkup)}: {AllowMarkup}, {nameof(UseTimestampUtc)}: {UseTimestampUtc}, {nameof(TimestampFormat)}: {TimestampFormat}";
+        => $"{nameof(MinimumLogLevel)}: {MinimumLogLevel}, {nameof(RenderingMode)}: {RenderingMode}, {nameof(UseTimestamp)}: {UseTimestamp}, {nameof(UseShortNameForLogLevel)}: {UseShortNameForLogLevel}, {nameof(IncludeInnerMessageForException)}: {IncludeInnerMessageForException}, {nameof(IncludeExceptionNameForException)}: {IncludeExceptionNameForException}, {nameof(AllowMarkup)}: {AllowMarkup}, {nameof(IncludeScopes)}: {IncludeScopes}, {nameof(UseTimestampUtc)}: {UseTimestampUtc}, {nameof(TimestampFormat)}: {TimestampFormat}";
 }
\ No newline at end of file

From dfb44035930b42f662c21353e36b56bf25df1e90 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 11:36:24 +0200
Subject: [PATCH 060/100] feat(atc): add CharExtensions
 IsAsciiLetter/IsAsciiDigit/IsHexDigit/IsVowel and EnumExtensions TryMapTo

---
 docs/CodeDoc/Atc/IndexExtended.md             |  5 +
 docs/CodeDoc/Atc/System.md                    | 91 +++++++++++++++----
 .../Extensions/BaseTypes/CharExtensions.cs    | 35 +++++++
 src/Atc/Extensions/EnumExtensions.cs          | 27 ++++++
 .../BaseTypes/CharExtensionsTests.cs          | 58 ++++++++++++
 .../Extensions/EnumExtensionsTests.cs         | 21 +++++
 6 files changed, 218 insertions(+), 19 deletions(-)

diff --git a/docs/CodeDoc/Atc/IndexExtended.md b/docs/CodeDoc/Atc/IndexExtended.md
index bb9a301c..31bae2f1 100644
--- a/docs/CodeDoc/Atc/IndexExtended.md
+++ b/docs/CodeDoc/Atc/IndexExtended.md
@@ -5079,6 +5079,10 @@
 - [CharExtensions](System.md#charextensions)
   -  Static Methods
      - IsAscii(this char value)
+     - IsAsciiDigit(this char value)
+     - IsAsciiLetter(this char value)
+     - IsHexDigit(this char value)
+     - IsVowel(this char value)
 - [ConfigurationException](System.md#configurationexception)
 - [DateTimeExtensions](System.md#datetimeextensions)
   -  Static Methods
@@ -5196,6 +5200,7 @@
      - MapTo(this Enum source, TTarget? defaultValue = null)
      - ToStringLowerCase(this Enum enumeration)
      - ToStringUpperCase(this Enum enumeration)
+     - TryMapTo(this Enum source, out TTarget result)
 - [ExceptionExtensions](System.md#exceptionextensions)
   -  Static Methods
      - Flatten(this Exception exception, string message = , bool includeStackTrace = False)
diff --git a/docs/CodeDoc/Atc/System.md b/docs/CodeDoc/Atc/System.md
index f1bc7004..69b028ba 100644
--- a/docs/CodeDoc/Atc/System.md
+++ b/docs/CodeDoc/Atc/System.md
@@ -558,6 +558,46 @@ Extensions for the `System.Char` type.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The character to check.<br />
 >
 ><b>Returns:</b> <see langword="true" /> if the character value is less than or equal to 127 (ASCII range); otherwise, <see langword="false" />.
+#### IsAsciiDigit
+>```csharp
+>bool IsAsciiDigit(this char value)
+>```
+><b>Summary:</b> Determines whether the specified character is an ASCII decimal digit (0–9).
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The character to check.<br />
+>
+><b>Returns:</b> <see langword="true" /> if the character is a digit 0 through 9; otherwise, <see langword="false" />.
+#### IsAsciiLetter
+>```csharp
+>bool IsAsciiLetter(this char value)
+>```
+><b>Summary:</b> Determines whether the specified character is an ASCII letter (A–Z or a–z).
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The character to check.<br />
+>
+><b>Returns:</b> <see langword="true" /> if the character is an ASCII letter; otherwise, <see langword="false" />.
+#### IsHexDigit
+>```csharp
+>bool IsHexDigit(this char value)
+>```
+><b>Summary:</b> Determines whether the specified character is a hexadecimal digit (0–9, A–F, a–f).
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The character to check.<br />
+>
+><b>Returns:</b> <see langword="true" /> if the character is a valid hexadecimal digit; otherwise, <see langword="false" />.
+#### IsVowel
+>```csharp
+>bool IsVowel(this char value)
+>```
+><b>Summary:</b> Determines whether the specified character is an ASCII vowel (A, E, I, O, U — case-insensitive).
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The character to check.<br />
+>
+><b>Returns:</b> <see langword="true" /> if the character is one of A, E, I, O, U (upper or lower case); otherwise, <see langword="false" />.
 
 <br />
 
@@ -1142,7 +1182,7 @@ Extensions for the `System.Double` class.
 >```csharp
 >double DoubleEpsilon
 >```
-><b>Summary:</b> The double epsilon.
+><b>Summary:</b> The tolerance used by `System.DoubleExtensions.IsEqual(System.Double,System.Double)` and `System.DoubleExtensions.IsZero(System.Double)`. Values whose absolute difference is at or below this threshold are considered equal.
 ### Static Methods
 
 #### AreClose
@@ -1211,56 +1251,56 @@ Extensions for the `System.Double` class.
 >```csharp
 >bool IsEqual(this double a, double b)
 >```
-><b>Summary:</b> Compare two values. Return <see langword="true" /> if they are equals.
+><b>Summary:</b> Determines whether two double values are approximately equal within a tolerance of `System.DoubleExtensions.DoubleEpsilon` (1e-9). This handles common floating-point arithmetic rounding, for example `0.1 + 0.2 == 0.3`. Use `System.DoubleExtensions.IsEqual(System.Double,System.Double,System.Int32)` when an exact decimal-precision comparison is needed.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`a`&nbsp;&nbsp;-&nbsp;&nbsp;The first value.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`b`&nbsp;&nbsp;-&nbsp;&nbsp;The second value.<br />
 >
-><b>Returns:</b> <see langword="true" /> if the two values are equals, <see langword="false" /> otherwise.
+><b>Returns:</b> <see langword="true" /> if the absolute difference between `a` and `b` is at most `System.DoubleExtensions.DoubleEpsilon`; otherwise, <see langword="false" />.
 #### IsEqual
 >```csharp
 >bool IsEqual(this double? a, double? b)
 >```
-><b>Summary:</b> Compare two values. Return <see langword="true" /> if they are equals.
+><b>Summary:</b> Determines whether two double values are approximately equal within a tolerance of `System.DoubleExtensions.DoubleEpsilon` (1e-9). This handles common floating-point arithmetic rounding, for example `0.1 + 0.2 == 0.3`. Use `System.DoubleExtensions.IsEqual(System.Double,System.Double,System.Int32)` when an exact decimal-precision comparison is needed.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`a`&nbsp;&nbsp;-&nbsp;&nbsp;The first value.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`b`&nbsp;&nbsp;-&nbsp;&nbsp;The second value.<br />
 >
-><b>Returns:</b> <see langword="true" /> if the two values are equals, <see langword="false" /> otherwise.
+><b>Returns:</b> <see langword="true" /> if the absolute difference between `a` and `b` is at most `System.DoubleExtensions.DoubleEpsilon`; otherwise, <see langword="false" />.
 #### IsEqual
 >```csharp
 >bool IsEqual(this double a, double b, int decimalPrecision)
 >```
-><b>Summary:</b> Compare two values. Return <see langword="true" /> if they are equals.
+><b>Summary:</b> Determines whether two double values are approximately equal within a tolerance of `System.DoubleExtensions.DoubleEpsilon` (1e-9). This handles common floating-point arithmetic rounding, for example `0.1 + 0.2 == 0.3`. Use `System.DoubleExtensions.IsEqual(System.Double,System.Double,System.Int32)` when an exact decimal-precision comparison is needed.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`a`&nbsp;&nbsp;-&nbsp;&nbsp;The first value.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`b`&nbsp;&nbsp;-&nbsp;&nbsp;The second value.<br />
 >
-><b>Returns:</b> <see langword="true" /> if the two values are equals, <see langword="false" /> otherwise.
+><b>Returns:</b> <see langword="true" /> if the absolute difference between `a` and `b` is at most `System.DoubleExtensions.DoubleEpsilon`; otherwise, <see langword="false" />.
 #### IsEqual
 >```csharp
 >bool IsEqual(this double? a, double? b, int decimalPrecision)
 >```
-><b>Summary:</b> Compare two values. Return <see langword="true" /> if they are equals.
+><b>Summary:</b> Determines whether two double values are approximately equal within a tolerance of `System.DoubleExtensions.DoubleEpsilon` (1e-9). This handles common floating-point arithmetic rounding, for example `0.1 + 0.2 == 0.3`. Use `System.DoubleExtensions.IsEqual(System.Double,System.Double,System.Int32)` when an exact decimal-precision comparison is needed.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`a`&nbsp;&nbsp;-&nbsp;&nbsp;The first value.<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`b`&nbsp;&nbsp;-&nbsp;&nbsp;The second value.<br />
 >
-><b>Returns:</b> <see langword="true" /> if the two values are equals, <see langword="false" /> otherwise.
+><b>Returns:</b> <see langword="true" /> if the absolute difference between `a` and `b` is at most `System.DoubleExtensions.DoubleEpsilon`; otherwise, <see langword="false" />.
 #### IsZero
 >```csharp
 >bool IsZero(this double value)
 >```
-><b>Summary:</b> Determines whether the specified double value is approximately zero.
+><b>Summary:</b> Determines whether the specified double value is approximately zero within a tolerance of `System.DoubleExtensions.DoubleEpsilon` (1e-9).
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The value to check.<br />
 >
-><b>Returns:</b> <see langword="true" /> if the absolute value is less than epsilon; otherwise, <see langword="false" />.
+><b>Returns:</b> <see langword="true" /> if the absolute value is at most `System.DoubleExtensions.DoubleEpsilon`; otherwise, <see langword="false" />.
 #### RoundOff
 >```csharp
 >double RoundOff(this double value, int numberOfDecimals)
@@ -1688,13 +1728,13 @@ Extension methods for enumerations.
 >```csharp
 >bool IsSet(this Enum enumeration, Enum matchTo)
 >```
-><b>Summary:</b> Determines whether the specified enumeration match another enumeration.
+><b>Summary:</b> Determines whether all bits of `matchTo` are set in `enumeration`, equivalent to `enumeration.HasFlag(matchTo)`. Works for all underlying numeric types including <see langword="long" />-backed enumerations.
 >
 ><b>Parameters:</b><br>
->&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`enumeration`&nbsp;&nbsp;-&nbsp;&nbsp;The enumeration.<br />
->&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`matchTo`&nbsp;&nbsp;-&nbsp;&nbsp;The enumeration to match.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`enumeration`&nbsp;&nbsp;-&nbsp;&nbsp;The enumeration to check.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`matchTo`&nbsp;&nbsp;-&nbsp;&nbsp;The flags that must all be present in .<br />
 >
-><b>Returns:</b> true on match; otherwise false.
+><b>Returns:</b> <see langword="true" /> if every bit in `matchTo` is also set in `enumeration`; otherwise, <see langword="false" />.
 >
 ><b>Code usage:</b>
 >```csharp
@@ -1709,13 +1749,13 @@ Extension methods for enumerations.
 >```csharp
 >bool IsSet(this T enumeration, T flags)
 >```
-><b>Summary:</b> Determines whether the specified enumeration match another enumeration.
+><b>Summary:</b> Determines whether all bits of `matchTo` are set in `enumeration`, equivalent to `enumeration.HasFlag(matchTo)`. Works for all underlying numeric types including <see langword="long" />-backed enumerations.
 >
 ><b>Parameters:</b><br>
->&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`enumeration`&nbsp;&nbsp;-&nbsp;&nbsp;The enumeration.<br />
->&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`matchTo`&nbsp;&nbsp;-&nbsp;&nbsp;The enumeration to match.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`enumeration`&nbsp;&nbsp;-&nbsp;&nbsp;The enumeration to check.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`matchTo`&nbsp;&nbsp;-&nbsp;&nbsp;The flags that must all be present in .<br />
 >
-><b>Returns:</b> true on match; otherwise false.
+><b>Returns:</b> <see langword="true" /> if every bit in `matchTo` is also set in `enumeration`; otherwise, <see langword="false" />.
 >
 ><b>Code usage:</b>
 >```csharp
@@ -1753,6 +1793,19 @@ Extension methods for enumerations.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`enumeration`&nbsp;&nbsp;-&nbsp;&nbsp;The enum.<br />
+#### TryMapTo
+>```csharp
+>bool TryMapTo(this Enum source, out TTarget result)
+>```
+><b>Summary:</b> Tries to map the current enum value to a target enum type by matching the name (case-insensitive). Unlike `System.EnumExtensions.MapTo``1(System.Enum,System.Nullable{``0})`, this method never throws — it returns <see langword="false" /> when no match is found.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`source`&nbsp;&nbsp;-&nbsp;&nbsp;The source enum value.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`result`&nbsp;&nbsp;-&nbsp;&nbsp;
+            When this method returns , the matched target value; otherwise, the default value of .
+            <br />
+>
+><b>Returns:</b> <see langword="true" /> if a matching named value was found in `TTarget`; otherwise, <see langword="false" />.
 
 <br />
 
diff --git a/src/Atc/Extensions/BaseTypes/CharExtensions.cs b/src/Atc/Extensions/BaseTypes/CharExtensions.cs
index b047f0e0..925acfbf 100644
--- a/src/Atc/Extensions/BaseTypes/CharExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/CharExtensions.cs
@@ -13,4 +13,39 @@ public static class CharExtensions
     /// <returns><see langword="true"/> if the character value is less than or equal to 127 (ASCII range); otherwise, <see langword="false"/>.</returns>
     public static bool IsAscii(this char value)
         => value <= sbyte.MaxValue;
+
+    /// <summary>
+    /// Determines whether the specified character is an ASCII letter (A–Z or a–z).
+    /// </summary>
+    /// <param name="value">The character to check.</param>
+    /// <returns><see langword="true"/> if the character is an ASCII letter; otherwise, <see langword="false"/>.</returns>
+    public static bool IsAsciiLetter(this char value)
+        => (value >= 'A' && value <= 'Z') || (value >= 'a' && value <= 'z');
+
+    /// <summary>
+    /// Determines whether the specified character is an ASCII decimal digit (0–9).
+    /// </summary>
+    /// <param name="value">The character to check.</param>
+    /// <returns><see langword="true"/> if the character is a digit 0 through 9; otherwise, <see langword="false"/>.</returns>
+    public static bool IsAsciiDigit(this char value)
+        => value >= '0' && value <= '9';
+
+    /// <summary>
+    /// Determines whether the specified character is a hexadecimal digit (0–9, A–F, a–f).
+    /// </summary>
+    /// <param name="value">The character to check.</param>
+    /// <returns><see langword="true"/> if the character is a valid hexadecimal digit; otherwise, <see langword="false"/>.</returns>
+    public static bool IsHexDigit(this char value)
+        => (value >= '0' && value <= '9')
+        || (value >= 'A' && value <= 'F')
+        || (value >= 'a' && value <= 'f');
+
+    /// <summary>
+    /// Determines whether the specified character is an ASCII vowel (A, E, I, O, U — case-insensitive).
+    /// </summary>
+    /// <param name="value">The character to check.</param>
+    /// <returns><see langword="true"/> if the character is one of A, E, I, O, U (upper or lower case); otherwise, <see langword="false"/>.</returns>
+    public static bool IsVowel(this char value)
+        => value is 'A' or 'E' or 'I' or 'O' or 'U'
+               or 'a' or 'e' or 'i' or 'o' or 'u';
 }
\ No newline at end of file
diff --git a/src/Atc/Extensions/EnumExtensions.cs b/src/Atc/Extensions/EnumExtensions.cs
index ca3469dc..8ee3ca10 100644
--- a/src/Atc/Extensions/EnumExtensions.cs
+++ b/src/Atc/Extensions/EnumExtensions.cs
@@ -199,6 +199,33 @@ public static TTarget MapTo<TTarget>(
         return defaultValue ?? throw new InvalidOperationException($"Cannot map '{source}' from {source.GetType().Name} to {typeof(TTarget).Name}.");
     }
 
+    /// <summary>
+    /// Tries to map the current enum value to a target enum type by matching the name (case-insensitive).
+    /// Unlike <see cref="MapTo{TTarget}"/>, this method never throws — it returns <see langword="false"/> when no match is found.
+    /// </summary>
+    /// <typeparam name="TTarget">The target enum type.</typeparam>
+    /// <param name="source">The source enum value.</param>
+    /// <param name="result">
+    /// When this method returns <see langword="true"/>, the matched target value; otherwise, the default value of <typeparamref name="TTarget"/>.
+    /// </param>
+    /// <returns><see langword="true"/> if a matching named value was found in <typeparamref name="TTarget"/>; otherwise, <see langword="false"/>.</returns>
+    public static bool TryMapTo<TTarget>(
+        this Enum source,
+        out TTarget result)
+        where TTarget : struct, Enum
+    {
+        ArgumentNullException.ThrowIfNull(source);
+
+        if (Enum.TryParse<TTarget>(source.ToString(), ignoreCase: true, out result) &&
+            Enum.IsDefined(typeof(TTarget), result))
+        {
+            return true;
+        }
+
+        result = default;
+        return false;
+    }
+
     /// <summary>Gets the attribute value.</summary>
     /// <typeparam name="T">The type.</typeparam>
     /// <typeparam name="TExpected">The type of the expected.</typeparam>
diff --git a/test/Atc.Tests/Extensions/BaseTypes/CharExtensionsTests.cs b/test/Atc.Tests/Extensions/BaseTypes/CharExtensionsTests.cs
index aac4aa3c..0ba28281 100644
--- a/test/Atc.Tests/Extensions/BaseTypes/CharExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/BaseTypes/CharExtensionsTests.cs
@@ -14,4 +14,62 @@ public void IsAscii(
         // Assert
         Assert.Equal(expected, actual);
     }
+
+    [Theory]
+    [InlineData(true, 'A')]
+    [InlineData(true, 'Z')]
+    [InlineData(true, 'a')]
+    [InlineData(true, 'z')]
+    [InlineData(false, '0')]
+    [InlineData(false, '@')]
+    [InlineData(false, 'é')]
+    public void IsAsciiLetter(
+        bool expected,
+        char input)
+        => Assert.Equal(expected, input.IsAsciiLetter());
+
+    [Theory]
+    [InlineData(true, '0')]
+    [InlineData(true, '9')]
+    [InlineData(false, 'A')]
+    [InlineData(false, '/')]
+    [InlineData(false, ':')]
+    public void IsAsciiDigit(
+        bool expected,
+        char input)
+        => Assert.Equal(expected, input.IsAsciiDigit());
+
+    [Theory]
+    [InlineData(true, '0')]
+    [InlineData(true, '9')]
+    [InlineData(true, 'A')]
+    [InlineData(true, 'F')]
+    [InlineData(true, 'a')]
+    [InlineData(true, 'f')]
+    [InlineData(false, 'G')]
+    [InlineData(false, 'g')]
+    [InlineData(false, '@')]
+    public void IsHexDigit(
+        bool expected,
+        char input)
+        => Assert.Equal(expected, input.IsHexDigit());
+
+    [Theory]
+    [InlineData(true, 'A')]
+    [InlineData(true, 'E')]
+    [InlineData(true, 'I')]
+    [InlineData(true, 'O')]
+    [InlineData(true, 'U')]
+    [InlineData(true, 'a')]
+    [InlineData(true, 'e')]
+    [InlineData(true, 'i')]
+    [InlineData(true, 'o')]
+    [InlineData(true, 'u')]
+    [InlineData(false, 'B')]
+    [InlineData(false, 'z')]
+    [InlineData(false, '0')]
+    public void IsVowel(
+        bool expected,
+        char input)
+        => Assert.Equal(expected, input.IsVowel());
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Extensions/EnumExtensionsTests.cs b/test/Atc.Tests/Extensions/EnumExtensionsTests.cs
index 3cffa07b..7889bd58 100644
--- a/test/Atc.Tests/Extensions/EnumExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/EnumExtensionsTests.cs
@@ -113,6 +113,27 @@ public void MapTo_WithoutDefault(
     public void MapTo_WithoutDefault_Throws()
         => Assert.Throws<InvalidOperationException>(() => TestPetTypeB.Unknown.MapTo<TestPetTypeA>());
 
+    [Theory]
+    [InlineData(true, TestPetTypeA.Dog, TestPetTypeB.Dog)]
+    [InlineData(true, TestPetTypeA.Cat, TestPetTypeB.Cat)]
+    public void TryMapTo_MatchingName_ReturnsTrue(
+        bool expectedSuccess,
+        TestPetTypeA expectedResult,
+        TestPetTypeB source)
+    {
+        var success = source.TryMapTo<TestPetTypeA>(out var result);
+        Assert.Equal(expectedSuccess, success);
+        Assert.Equal(expectedResult, result);
+    }
+
+    [Fact]
+    public void TryMapTo_NoMatch_ReturnsFalse()
+    {
+        var success = TestPetTypeB.Unknown.TryMapTo<TestPetTypeA>(out var result);
+        Assert.False(success);
+        Assert.Equal(default(TestPetTypeA), result);
+    }
+
     [Theory]
     [InlineData("Display Red", TestColorType.Red)]
     [InlineData("Display Green", TestColorType.Green)]

From aa8f2c3d2622ce98fc46012977ded1f7a83f2e0f Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 11:41:30 +0200
Subject: [PATCH 061/100] feat(atc): add
 StartOfDay/EndOfDay/StartOfMonth/EndOfMonth/IsWeekend to DateTime and
 DateTimeOffset

---
 .../BaseTypes/DateTimeExtensions.cs           | 44 +++++++++++++++++
 .../BaseTypes/DateTimeOffsetExtensions.cs     | 49 +++++++++++++++++++
 .../BaseTypes/DateTimeExtensionsTests.cs      | 44 +++++++++++++++++
 .../DateTimeOffsetExtensionsTests.cs          | 48 ++++++++++++++++++
 4 files changed, 185 insertions(+)

diff --git a/src/Atc/Extensions/BaseTypes/DateTimeExtensions.cs b/src/Atc/Extensions/BaseTypes/DateTimeExtensions.cs
index ace88555..3a41a4a9 100644
--- a/src/Atc/Extensions/BaseTypes/DateTimeExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/DateTimeExtensions.cs
@@ -320,4 +320,48 @@ public static string ToShortTimeString(
             dateTimeFormatInfo.ShortTimePattern,
             dateTimeFormatInfo);
     }
+
+    /// <summary>
+    /// Returns a new <see cref="DateTime"/> set to the very start of the same day (00:00:00.000).
+    /// The <see cref="DateTime.Kind"/> of the result matches the input.
+    /// </summary>
+    /// <param name="dateTime">The date value.</param>
+    /// <returns>Midnight at the start of <paramref name="dateTime"/>'s date.</returns>
+    public static DateTime StartOfDay(this DateTime dateTime)
+        => dateTime.Date;
+
+    /// <summary>
+    /// Returns a new <see cref="DateTime"/> set to the very end of the same day (23:59:59.9999999).
+    /// The <see cref="DateTime.Kind"/> of the result matches the input.
+    /// </summary>
+    /// <param name="dateTime">The date value.</param>
+    /// <returns>The last representable tick of <paramref name="dateTime"/>'s date.</returns>
+    public static DateTime EndOfDay(this DateTime dateTime)
+        => dateTime.Date.AddDays(1).AddTicks(-1);
+
+    /// <summary>
+    /// Returns a new <see cref="DateTime"/> set to the first day of the same month at midnight (00:00:00.000).
+    /// </summary>
+    /// <param name="dateTime">The date value.</param>
+    /// <returns>The first day of the month containing <paramref name="dateTime"/>.</returns>
+    public static DateTime StartOfMonth(this DateTime dateTime)
+        => new(dateTime.Year, dateTime.Month, 1, 0, 0, 0, dateTime.Kind);
+
+    /// <summary>
+    /// Returns a new <see cref="DateTime"/> set to the last tick of the last day of the same month.
+    /// </summary>
+    /// <param name="dateTime">The date value.</param>
+    /// <returns>The last representable tick of the last day of the month containing <paramref name="dateTime"/>.</returns>
+    public static DateTime EndOfMonth(this DateTime dateTime)
+        => new DateTime(dateTime.Year, dateTime.Month, DateTime.DaysInMonth(dateTime.Year, dateTime.Month), 0, 0, 0, dateTime.Kind)
+            .AddDays(1)
+            .AddTicks(-1);
+
+    /// <summary>
+    /// Determines whether the specified date falls on a Saturday or Sunday.
+    /// </summary>
+    /// <param name="dateTime">The date to test.</param>
+    /// <returns><see langword="true"/> if the day of the week is <see cref="DayOfWeek.Saturday"/> or <see cref="DayOfWeek.Sunday"/>; otherwise, <see langword="false"/>.</returns>
+    public static bool IsWeekend(this DateTime dateTime)
+        => dateTime.DayOfWeek is DayOfWeek.Saturday or DayOfWeek.Sunday;
 }
\ No newline at end of file
diff --git a/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs b/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs
index 1baddf16..be6aa5c3 100644
--- a/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs
@@ -288,4 +288,53 @@ public static string ToShortTimeString(
             dateTimeFormatInfo.ShortTimePattern,
             dateTimeFormatInfo);
     }
+
+    /// <summary>
+    /// Returns a new <see cref="DateTimeOffset"/> set to the very start of the same day (00:00:00.000),
+    /// preserving the original <see cref="DateTimeOffset.Offset"/>.
+    /// </summary>
+    /// <param name="dateTimeOffset">The date-time value.</param>
+    /// <returns>Midnight at the start of the date, with the same UTC offset.</returns>
+    public static DateTimeOffset StartOfDay(this DateTimeOffset dateTimeOffset)
+        => new(dateTimeOffset.Year, dateTimeOffset.Month, dateTimeOffset.Day, 0, 0, 0, dateTimeOffset.Offset);
+
+    /// <summary>
+    /// Returns a new <see cref="DateTimeOffset"/> set to the very end of the same day (23:59:59.9999999),
+    /// preserving the original <see cref="DateTimeOffset.Offset"/>.
+    /// </summary>
+    /// <param name="dateTimeOffset">The date-time value.</param>
+    /// <returns>The last representable tick of the date, with the same UTC offset.</returns>
+    public static DateTimeOffset EndOfDay(this DateTimeOffset dateTimeOffset)
+        => new DateTimeOffset(dateTimeOffset.Year, dateTimeOffset.Month, dateTimeOffset.Day, 0, 0, 0, dateTimeOffset.Offset)
+            .AddDays(1)
+            .AddTicks(-1);
+
+    /// <summary>
+    /// Returns a new <see cref="DateTimeOffset"/> set to the first day of the same month at midnight,
+    /// preserving the original <see cref="DateTimeOffset.Offset"/>.
+    /// </summary>
+    /// <param name="dateTimeOffset">The date-time value.</param>
+    /// <returns>The first day of the month, with the same UTC offset.</returns>
+    public static DateTimeOffset StartOfMonth(
+        this DateTimeOffset dateTimeOffset)
+        => new(dateTimeOffset.Year, dateTimeOffset.Month, 1, 0, 0, 0, dateTimeOffset.Offset);
+
+    /// <summary>
+    /// Returns a new <see cref="DateTimeOffset"/> set to the last tick of the last day of the same month,
+    /// preserving the original <see cref="DateTimeOffset.Offset"/>.
+    /// </summary>
+    /// <param name="dateTimeOffset">The date-time value.</param>
+    /// <returns>The last representable tick of the month, with the same UTC offset.</returns>
+    public static DateTimeOffset EndOfMonth(this DateTimeOffset dateTimeOffset)
+        => new DateTimeOffset(dateTimeOffset.Year, dateTimeOffset.Month, DateTime.DaysInMonth(dateTimeOffset.Year, dateTimeOffset.Month), 0, 0, 0, dateTimeOffset.Offset)
+            .AddDays(1)
+            .AddTicks(-1);
+
+    /// <summary>
+    /// Determines whether the date falls on a Saturday or Sunday.
+    /// </summary>
+    /// <param name="dateTimeOffset">The date to test.</param>
+    /// <returns><see langword="true"/> if the day of week is <see cref="DayOfWeek.Saturday"/> or <see cref="DayOfWeek.Sunday"/>; otherwise, <see langword="false"/>.</returns>
+    public static bool IsWeekend(this DateTimeOffset dateTimeOffset)
+        => dateTimeOffset.DayOfWeek is DayOfWeek.Saturday or DayOfWeek.Sunday;
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Extensions/BaseTypes/DateTimeExtensionsTests.cs b/test/Atc.Tests/Extensions/BaseTypes/DateTimeExtensionsTests.cs
index 405ded1a..9f985502 100644
--- a/test/Atc.Tests/Extensions/BaseTypes/DateTimeExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/BaseTypes/DateTimeExtensionsTests.cs
@@ -417,4 +417,48 @@ public void ToShortTimeStringUsingSpecificCulture(
         // Assert
         Assert.Equal(expected, actual);
     }
+
+    [Fact]
+    public void StartOfDay_ReturnsMidnight()
+    {
+        var input = new DateTime(2024, 3, 15, 10, 30, 45, DateTimeKind.Utc);
+        var result = input.StartOfDay();
+        Assert.Equal(new DateTime(2024, 3, 15, 0, 0, 0, DateTimeKind.Utc), result);
+    }
+
+    [Fact]
+    public void EndOfDay_ReturnsLastTick()
+    {
+        var input = new DateTime(2024, 3, 15, 10, 30, 45, DateTimeKind.Utc);
+        var result = input.EndOfDay();
+        Assert.Equal(new DateTime(2024, 3, 15, 0, 0, 0, DateTimeKind.Utc).AddDays(1).AddTicks(-1), result);
+    }
+
+    [Fact]
+    public void StartOfMonth_ReturnsFirstDayMidnight()
+    {
+        var input = new DateTime(2024, 3, 15, 10, 30, 45, DateTimeKind.Utc);
+        var result = input.StartOfMonth();
+        Assert.Equal(new DateTime(2024, 3, 1, 0, 0, 0, DateTimeKind.Utc), result);
+    }
+
+    [Fact]
+    public void EndOfMonth_ReturnsLastTickOfLastDay()
+    {
+        var input = new DateTime(2024, 2, 10, 10, 30, 45, DateTimeKind.Utc);
+        var result = input.EndOfMonth();
+        Assert.Equal(new DateTime(2024, 2, 29, 0, 0, 0, DateTimeKind.Utc).AddDays(1).AddTicks(-1), result);
+    }
+
+    [Theory]
+    [InlineData(true, 2024, 3, 16)]
+    [InlineData(true, 2024, 3, 17)]
+    [InlineData(false, 2024, 3, 18)]
+    [InlineData(false, 2024, 3, 15)]
+    public void IsWeekend(
+        bool expected,
+        int year,
+        int month,
+        int day)
+        => Assert.Equal(expected, new DateTime(year, month, day).IsWeekend());
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Extensions/BaseTypes/DateTimeOffsetExtensionsTests.cs b/test/Atc.Tests/Extensions/BaseTypes/DateTimeOffsetExtensionsTests.cs
index aefaf75e..b70f4397 100644
--- a/test/Atc.Tests/Extensions/BaseTypes/DateTimeOffsetExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/BaseTypes/DateTimeOffsetExtensionsTests.cs
@@ -393,4 +393,52 @@ public void ToShortTimeString(
         // Assert
         Assert.Equal(expected, actual);
     }
+
+    [Fact]
+    public void StartOfDay_ReturnsMidnight_PreservesOffset()
+    {
+        var offset = TimeSpan.FromHours(2);
+        var input = new DateTimeOffset(2024, 3, 15, 10, 30, 45, offset);
+        var result = input.StartOfDay();
+        Assert.Equal(new DateTimeOffset(2024, 3, 15, 0, 0, 0, offset), result);
+    }
+
+    [Fact]
+    public void EndOfDay_ReturnsLastTick_PreservesOffset()
+    {
+        var offset = TimeSpan.FromHours(2);
+        var input = new DateTimeOffset(2024, 3, 15, 10, 30, 45, offset);
+        var result = input.EndOfDay();
+        Assert.Equal(new DateTimeOffset(2024, 3, 15, 0, 0, 0, offset).AddDays(1).AddTicks(-1), result);
+    }
+
+    [Fact]
+    public void StartOfMonth_ReturnsFirstDayMidnight_PreservesOffset()
+    {
+        var offset = TimeSpan.FromHours(-5);
+        var input = new DateTimeOffset(2024, 3, 15, 10, 30, 45, offset);
+        var result = input.StartOfMonth();
+        Assert.Equal(new DateTimeOffset(2024, 3, 1, 0, 0, 0, offset), result);
+    }
+
+    [Fact]
+    public void EndOfMonth_ReturnsLastTickOfLastDay_PreservesOffset()
+    {
+        var offset = TimeSpan.FromHours(-5);
+        var input = new DateTimeOffset(2024, 2, 10, 10, 30, 45, offset);
+        var result = input.EndOfMonth();
+        Assert.Equal(new DateTimeOffset(2024, 2, 29, 0, 0, 0, offset).AddDays(1).AddTicks(-1), result);
+    }
+
+    [Theory]
+    [InlineData(true, 2024, 3, 16)]
+    [InlineData(true, 2024, 3, 17)]
+    [InlineData(false, 2024, 3, 18)]
+    [InlineData(false, 2024, 3, 15)]
+    public void IsWeekend(
+        bool expected,
+        int year,
+        int month,
+        int day)
+        => Assert.Equal(expected, new DateTimeOffset(year, month, day, 0, 0, 0, TimeSpan.Zero).IsWeekend());
 }
\ No newline at end of file

From f71a3d635ece5d83bc44fe96a8624a6120eee3e6 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 11:45:23 +0200
Subject: [PATCH 062/100] feat(atc): add BeautifyName for
 ConstructorInfo/EventInfo and use Span in ByteExtensions.TakeBytes

---
 .../Extensions/BaseTypes/ByteExtensions.cs    |  5 +-
 .../Reflection/ConstructorInfoExtensions.cs   | 53 +++++++++++++++++++
 .../Reflection/EventInfoExtensions.cs         | 31 +++++++++++
 .../ConstructorInfoExtensionsTests.cs         | 34 ++++++++++++
 .../Reflection/EventInfoExtensionsTests.cs    | 25 +++++++++
 5 files changed, 144 insertions(+), 4 deletions(-)
 create mode 100644 src/Atc/Extensions/Reflection/ConstructorInfoExtensions.cs
 create mode 100644 src/Atc/Extensions/Reflection/EventInfoExtensions.cs
 create mode 100644 test/Atc.Tests/Extensions/Reflection/ConstructorInfoExtensionsTests.cs
 create mode 100644 test/Atc.Tests/Extensions/Reflection/EventInfoExtensionsTests.cs

diff --git a/src/Atc/Extensions/BaseTypes/ByteExtensions.cs b/src/Atc/Extensions/BaseTypes/ByteExtensions.cs
index 004e23da..840f9dee 100644
--- a/src/Atc/Extensions/BaseTypes/ByteExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/ByteExtensions.cs
@@ -29,10 +29,7 @@ public static byte[] TakeBytes(
             return Array.Empty<byte>();
         }
 
-        return value
-            .Skip(startPosition)
-            .Take(length)
-            .ToArray();
+        return new ReadOnlySpan<byte>(value, startPosition, length).ToArray();
     }
 
     /// <summary>
diff --git a/src/Atc/Extensions/Reflection/ConstructorInfoExtensions.cs b/src/Atc/Extensions/Reflection/ConstructorInfoExtensions.cs
new file mode 100644
index 00000000..10f0c1b3
--- /dev/null
+++ b/src/Atc/Extensions/Reflection/ConstructorInfoExtensions.cs
@@ -0,0 +1,53 @@
+// ReSharper disable once CheckNamespace
+namespace System.Reflection;
+
+/// <summary>
+/// Extensions for the <see cref="ConstructorInfo"/> class.
+/// </summary>
+public static class ConstructorInfoExtensions
+{
+    /// <summary>
+    /// Returns a human-readable representation of the constructor signature, optionally using full type names
+    /// and HTML formatting for the parameter types.
+    /// </summary>
+    /// <param name="constructorInfo">The constructor information.</param>
+    /// <param name="useFullName">If <see langword="true"/>, parameter types are rendered with their fully-qualified names.</param>
+    /// <param name="useHtmlFormat">If <see langword="true"/>, parameter type names are wrapped in HTML tags.</param>
+    /// <returns>A string of the form <c>.ctor(TypeA paramA, TypeB paramB)</c>.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="constructorInfo"/> is null.</exception>
+    public static string BeautifyName(
+        this ConstructorInfo constructorInfo,
+        bool useFullName = false,
+        bool useHtmlFormat = false)
+    {
+        ArgumentNullException.ThrowIfNull(constructorInfo);
+
+        var seq = constructorInfo
+            .GetParameters()
+            .Select(x =>
+            {
+                var typeName = x.ParameterType.BeautifyName(useFullName, useHtmlFormat);
+
+                // ReSharper disable once InvertIf
+                if (x.ParameterType.Name.EndsWith('&'))
+                {
+                    if (x.IsIn)
+                    {
+                        typeName = "in " + typeName.Replace("&", string.Empty, StringComparison.Ordinal);
+                    }
+                    else if (x.IsOut)
+                    {
+                        typeName = "out " + typeName.Replace("&", string.Empty, StringComparison.Ordinal);
+                    }
+                    else
+                    {
+                        typeName = "ref " + typeName.Replace("&", string.Empty, StringComparison.Ordinal);
+                    }
+                }
+
+                return typeName + " " + x.Name;
+            });
+
+        return $".ctor({string.Join(", ", seq)})";
+    }
+}
\ No newline at end of file
diff --git a/src/Atc/Extensions/Reflection/EventInfoExtensions.cs b/src/Atc/Extensions/Reflection/EventInfoExtensions.cs
new file mode 100644
index 00000000..93655ad5
--- /dev/null
+++ b/src/Atc/Extensions/Reflection/EventInfoExtensions.cs
@@ -0,0 +1,31 @@
+// ReSharper disable once CheckNamespace
+namespace System.Reflection;
+
+/// <summary>
+/// Extensions for the <see cref="EventInfo"/> class.
+/// </summary>
+public static class EventInfoExtensions
+{
+    /// <summary>
+    /// Returns a human-readable representation of the event, optionally including the event handler type
+    /// and using full type names or HTML formatting.
+    /// </summary>
+    /// <param name="eventInfo">The event information.</param>
+    /// <param name="useFullName">If <see langword="true"/>, the event-handler type is rendered with its fully-qualified name.</param>
+    /// <param name="useHtmlFormat">If <see langword="true"/>, the event-handler type name is wrapped in HTML tags.</param>
+    /// <param name="includeEventHandlerType">If <see langword="true"/>, the event-handler type is prepended to the name.</param>
+    /// <returns>A string such as <c>MyEvent</c> or <c>EventHandler MyEvent</c> when <paramref name="includeEventHandlerType"/> is <see langword="true"/>.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="eventInfo"/> is null.</exception>
+    public static string BeautifyName(
+        this EventInfo eventInfo,
+        bool useFullName = false,
+        bool useHtmlFormat = false,
+        bool includeEventHandlerType = false)
+    {
+        ArgumentNullException.ThrowIfNull(eventInfo);
+
+        return includeEventHandlerType && eventInfo.EventHandlerType is not null
+            ? $"{eventInfo.EventHandlerType.BeautifyName(useFullName, useHtmlFormat)} {eventInfo.Name}"
+            : eventInfo.Name;
+    }
+}
\ No newline at end of file
diff --git a/test/Atc.Tests/Extensions/Reflection/ConstructorInfoExtensionsTests.cs b/test/Atc.Tests/Extensions/Reflection/ConstructorInfoExtensionsTests.cs
new file mode 100644
index 00000000..9789da3c
--- /dev/null
+++ b/test/Atc.Tests/Extensions/Reflection/ConstructorInfoExtensionsTests.cs
@@ -0,0 +1,34 @@
+namespace Atc.Tests.Extensions.Reflection;
+
+public class ConstructorInfoExtensionsTests
+{
+    private sealed class SampleClass
+    {
+        // ReSharper disable once UnusedParameter.Local
+        public SampleClass(
+            int count,
+            string name)
+        {
+        }
+    }
+
+    [Fact]
+    public void BeautifyName_NoParams_ReturnsDotCtor()
+    {
+        var ctor = typeof(object).GetConstructor(Type.EmptyTypes)!;
+        Assert.Equal(".ctor()", ctor.BeautifyName());
+    }
+
+    [Fact]
+    public void BeautifyName_WithParams_IncludesParamTypes()
+    {
+        var ctor = typeof(SampleClass).GetConstructors().Single();
+        var result = ctor.BeautifyName();
+        Assert.Equal(".ctor(int count, string name)", result);
+    }
+
+    [Fact]
+    public void BeautifyName_Null_Throws()
+        => Assert.Throws<ArgumentNullException>(() =>
+            ((ConstructorInfo)null!).BeautifyName());
+}
\ No newline at end of file
diff --git a/test/Atc.Tests/Extensions/Reflection/EventInfoExtensionsTests.cs b/test/Atc.Tests/Extensions/Reflection/EventInfoExtensionsTests.cs
new file mode 100644
index 00000000..05c9c55b
--- /dev/null
+++ b/test/Atc.Tests/Extensions/Reflection/EventInfoExtensionsTests.cs
@@ -0,0 +1,25 @@
+namespace Atc.Tests.Extensions.Reflection;
+
+public class EventInfoExtensionsTests
+{
+    [Fact]
+    public void BeautifyName_ReturnsEventName()
+    {
+        var eventInfo = typeof(AppDomain).GetEvent(nameof(AppDomain.UnhandledException))!;
+        Assert.Equal("UnhandledException", eventInfo.BeautifyName());
+    }
+
+    [Fact]
+    public void BeautifyName_WithHandlerType_IncludesType()
+    {
+        var eventInfo = typeof(AppDomain).GetEvent(nameof(AppDomain.UnhandledException))!;
+        var result = eventInfo.BeautifyName(includeEventHandlerType: true);
+        Assert.Contains("UnhandledException", result, StringComparison.Ordinal);
+        Assert.Contains("UnhandledExceptionEventHandler", result, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void BeautifyName_Null_Throws()
+        => Assert.Throws<ArgumentNullException>(() =>
+            ((EventInfo)null!).BeautifyName());
+}
\ No newline at end of file

From 8c9eb30f9e9412429c463ee2f679551bf91f9bf7 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 13:10:19 +0200
Subject: [PATCH 063/100] feat(atc): extend exception API with non-enum
 overload and ThrowIf helpers

- SwitchCaseDefaultException: add object? ctor for non-enum switch values;
  add static Throw(Enum) and Throw(object?) [DoesNotReturn] helpers
- ConfigurationException: add structured ctor overload carrying inner
  exception; add ThrowIfMissing and ThrowIfInvalid static helpers
---
 src/Atc/Exceptions/ConfigurationException.cs  | 54 +++++++++++++-
 .../Exceptions/SwitchCaseDefaultException.cs  | 32 ++++++++
 test/Atc.Tests/Exceptions/ExceptionsTests.cs  | 73 +++++++++++++++++++
 3 files changed, 158 insertions(+), 1 deletion(-)

diff --git a/src/Atc/Exceptions/ConfigurationException.cs b/src/Atc/Exceptions/ConfigurationException.cs
index ae224eb5..9b4c1974 100644
--- a/src/Atc/Exceptions/ConfigurationException.cs
+++ b/src/Atc/Exceptions/ConfigurationException.cs
@@ -32,7 +32,7 @@ public ConfigurationException(string message)
     /// </summary>
     /// <param name="section">The configuration section name.</param>
     /// <param name="key">The configuration key name.</param>
-    /// <param name="isMissing">A value indicating whether the configuration is missing (true) or invalid (false).</param>
+    /// <param name="isMissing">A value indicating whether the configuration is missing (<see langword="true"/>) or invalid (<see langword="false"/>).</param>
     public ConfigurationException(
         string section,
         string key,
@@ -41,6 +41,24 @@ public ConfigurationException(
     {
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ConfigurationException"/> class with a configuration section, key, status, and inner exception.
+    /// </summary>
+    /// <param name="section">The configuration section name.</param>
+    /// <param name="key">The configuration key name.</param>
+    /// <param name="isMissing">A value indicating whether the configuration is missing (<see langword="true"/>) or invalid (<see langword="false"/>).</param>
+    /// <param name="innerException">The exception that is the cause of the current exception.</param>
+    public ConfigurationException(
+        string section,
+        string key,
+        bool isMissing,
+        Exception innerException)
+        : base(
+            $"Configuration with section '{section}' and key '{key}' is {GetTermForIsMissing(isMissing)}.",
+            innerException)
+    {
+    }
+
     /// <summary>
     /// Initializes a new instance of the <see cref="ConfigurationException"/> class.
     /// </summary>
@@ -53,6 +71,40 @@ public ConfigurationException(
     {
     }
 
+    /// <summary>
+    /// Throws a <see cref="ConfigurationException"/> if <paramref name="value"/> is <see langword="null"/> or empty.
+    /// </summary>
+    /// <param name="value">The configuration value to validate.</param>
+    /// <param name="section">The configuration section name.</param>
+    /// <param name="key">The configuration key name.</param>
+    public static void ThrowIfMissing(
+        [NotNull] string? value,
+        string section,
+        string key)
+    {
+        if (value is null || value.Length == 0)
+        {
+            throw new ConfigurationException(section, key, isMissing: true);
+        }
+    }
+
+    /// <summary>
+    /// Throws a <see cref="ConfigurationException"/> if <paramref name="condition"/> is <see langword="true"/>.
+    /// </summary>
+    /// <param name="condition">The condition that indicates the configuration value is invalid.</param>
+    /// <param name="section">The configuration section name.</param>
+    /// <param name="key">The configuration key name.</param>
+    public static void ThrowIfInvalid(
+        bool condition,
+        string section,
+        string key)
+    {
+        if (condition)
+        {
+            throw new ConfigurationException(section, key, isMissing: false);
+        }
+    }
+
     /// <summary>
     /// Initializes a new instance of the <see cref="ConfigurationException"/> class with serialized data.
     /// </summary>
diff --git a/src/Atc/Exceptions/SwitchCaseDefaultException.cs b/src/Atc/Exceptions/SwitchCaseDefaultException.cs
index a768f620..3bd630e6 100644
--- a/src/Atc/Exceptions/SwitchCaseDefaultException.cs
+++ b/src/Atc/Exceptions/SwitchCaseDefaultException.cs
@@ -54,6 +54,17 @@ public SwitchCaseDefaultException(
     {
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SwitchCaseDefaultException"/> class with any non-enum value.
+    /// </summary>
+    /// <param name="value">
+    /// The unexpected value that was encountered. Accepts any type, including <see langword="null"/>.
+    /// </param>
+    public SwitchCaseDefaultException(object? value)
+        : base(BuildMessageForObject(value))
+    {
+    }
+
     /// <summary>
     /// Initializes a new instance of the <see cref="SwitchCaseDefaultException"/> class.
     /// </summary>
@@ -66,6 +77,22 @@ public SwitchCaseDefaultException(
     {
     }
 
+    /// <summary>
+    /// Throws a <see cref="SwitchCaseDefaultException"/> for the given enum value.
+    /// </summary>
+    /// <param name="value">The unexpected enum value encountered in the switch default case.</param>
+    [DoesNotReturn]
+    public static void Throw(Enum value)
+        => throw new SwitchCaseDefaultException(value);
+
+    /// <summary>
+    /// Throws a <see cref="SwitchCaseDefaultException"/> for the given value.
+    /// </summary>
+    /// <param name="value">The unexpected value encountered in the switch default case.</param>
+    [DoesNotReturn]
+    public static void Throw(object? value)
+        => throw new SwitchCaseDefaultException(value);
+
     /// <summary>
     /// Initializes a new instance of the <see cref="SwitchCaseDefaultException"/> class with serialized data.
     /// </summary>
@@ -108,4 +135,9 @@ private static string BuildMessage(
 
         return $"{message}{Environment.NewLine}Enum name: {value.GetType().FullName}{Environment.NewLine}Enum value: {value}";
     }
+
+    private static string BuildMessageForObject(object? value)
+        => value is null
+            ? $"Unexpected value.{Environment.NewLine}Value: <null>"
+            : $"Unexpected value.{Environment.NewLine}Type: {value.GetType().FullName}{Environment.NewLine}Value: {value}";
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Exceptions/ExceptionsTests.cs b/test/Atc.Tests/Exceptions/ExceptionsTests.cs
index 0f22ee60..1905247f 100644
--- a/test/Atc.Tests/Exceptions/ExceptionsTests.cs
+++ b/test/Atc.Tests/Exceptions/ExceptionsTests.cs
@@ -430,6 +430,79 @@ public void SwitchCaseDefaultException_EnumValueAndMessage_ContainsAllParts()
         Assert.Contains("Friday", sut.Message, StringComparison.Ordinal);
     }
 
+    [Fact]
+    public void SwitchCaseDefaultException_ObjectValue_ContainsTypeAndValue()
+    {
+        var sut = new SwitchCaseDefaultException("unexpected");
+        Assert.Contains("String", sut.Message, StringComparison.Ordinal);
+        Assert.Contains("unexpected", sut.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void SwitchCaseDefaultException_NullObjectValue_ContainsNullIndicator()
+    {
+        var sut = new SwitchCaseDefaultException((object?)null);
+        Assert.Contains("<null>", sut.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void SwitchCaseDefaultException_ThrowEnum_ThrowsWithEnumDetails()
+    {
+        var ex = Assert.Throws<SwitchCaseDefaultException>(
+            () => SwitchCaseDefaultException.Throw(DayOfWeek.Wednesday));
+        Assert.Contains("Wednesday", ex.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void SwitchCaseDefaultException_ThrowObject_ThrowsWithDetails()
+    {
+        var ex = Assert.Throws<SwitchCaseDefaultException>(
+            () => SwitchCaseDefaultException.Throw((object)"bad"));
+        Assert.Contains("bad", ex.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ConfigurationException_StructuredCtorWithInner_CarriesInnerException()
+    {
+        var inner = new InvalidOperationException("root cause");
+        var sut = new ConfigurationException("MySection", "MyKey", isMissing: true, inner);
+        Assert.Contains("MySection", sut.Message, StringComparison.Ordinal);
+        Assert.Contains("MyKey", sut.Message, StringComparison.Ordinal);
+        Assert.Same(inner, sut.InnerException);
+    }
+
+    [Fact]
+    public void ConfigurationException_ThrowIfMissing_ThrowsWhenNullOrEmpty()
+    {
+        Assert.Throws<ConfigurationException>(
+            () => ConfigurationException.ThrowIfMissing(null, "Sec", "Key"));
+        Assert.Throws<ConfigurationException>(
+            () => ConfigurationException.ThrowIfMissing(string.Empty, "Sec", "Key"));
+    }
+
+    [Fact]
+    public void ConfigurationException_ThrowIfMissing_DoesNotThrowWhenValuePresent()
+    {
+        var exception = Record.Exception(
+            () => ConfigurationException.ThrowIfMissing("value", "Sec", "Key"));
+        Assert.Null(exception);
+    }
+
+    [Fact]
+    public void ConfigurationException_ThrowIfInvalid_ThrowsWhenConditionTrue()
+    {
+        Assert.Throws<ConfigurationException>(
+            () => ConfigurationException.ThrowIfInvalid(condition: true, "Sec", "Key"));
+    }
+
+    [Fact]
+    public void ConfigurationException_ThrowIfInvalid_DoesNotThrowWhenConditionFalse()
+    {
+        var exception = Record.Exception(
+            () => ConfigurationException.ThrowIfInvalid(condition: false, "Sec", "Key"));
+        Assert.Null(exception);
+    }
+
     [Fact]
     public void UnexpectedTypeException_Types_ContainsTypeNames()
     {

From 17bc77f3b6af5368615f3a51f4cd4c7c7ef60352 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 13:13:41 +0200
Subject: [PATCH 064/100] feat(atc): add UsingSpecificCulture overloads to
 DateTimeOffsetHelper

Mirror the DateTimeHelper pattern: refactor existing UsingCurrentUiCulture
methods to delegate to new UsingSpecificCulture variants. Adds:
TryParseUsingSpecificCulture, TryParseShortDateUsingSpecificCulture,
TryParseShortTimeUsingSpecificCulture, TryParseShortTimeUsingSpecificCultureUtc.
Also adds ToShortDateStringUsingSpecificCulture to DateTimeOffsetExtensions.
---
 .../BaseTypes/DateTimeOffsetExtensions.cs     |  15 ++
 src/Atc/Helpers/DateTimeOffsetHelper.cs       | 140 ++++++++++++++++--
 .../Helpers/DateTimeOffsetHelperTests.cs      |  94 ++++++++++++
 3 files changed, 239 insertions(+), 10 deletions(-)

diff --git a/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs b/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs
index be6aa5c3..cf8ec685 100644
--- a/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs
@@ -234,6 +234,21 @@ public static string ToShortDateStringUsingCurrentUiCulture(
         this DateTimeOffset dateTimeOffset)
         => dateTimeOffset.ToShortDateString(CultureInfo.CurrentUICulture.DateTimeFormat);
 
+    /// <summary>
+    /// Converts a <see cref="DateTimeOffset"/> to a string using the short date pattern of the specified culture.
+    /// </summary>
+    /// <param name="dateTimeOffset">The DateTimeOffset to format.</param>
+    /// <param name="cultureInfo">The culture whose short date pattern is used.</param>
+    /// <returns>A string representation of the date using the short date pattern of <paramref name="cultureInfo"/>.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="cultureInfo"/> is null.</exception>
+    public static string ToShortDateStringUsingSpecificCulture(
+        this DateTimeOffset dateTimeOffset,
+        CultureInfo cultureInfo)
+    {
+        ArgumentNullException.ThrowIfNull(cultureInfo);
+        return dateTimeOffset.ToShortDateString(cultureInfo.DateTimeFormat);
+    }
+
     /// <summary>
     /// Converts a DateTime to a string using the short date pattern of the provided DateTimeFormatInfo.
     /// </summary>
diff --git a/src/Atc/Helpers/DateTimeOffsetHelper.cs b/src/Atc/Helpers/DateTimeOffsetHelper.cs
index 94590fd7..a6cb6b49 100644
--- a/src/Atc/Helpers/DateTimeOffsetHelper.cs
+++ b/src/Atc/Helpers/DateTimeOffsetHelper.cs
@@ -25,6 +25,36 @@ public static bool TryParseUsingCurrentUiCulture(
         string value,
         out DateTimeOffset result)
     {
+        result = default;
+        if (!TryParseUsingSpecificCulture(value, CultureInfo.CurrentUICulture, out var res))
+        {
+            return false;
+        }
+
+        result = res;
+        return true;
+    }
+
+    /// <summary>
+    /// Tries to parse a string representation of a <c>DateTimeOffset</c> using a specific culture's date and time format.
+    /// </summary>
+    /// <param name="value">The string to parse.</param>
+    /// <param name="cultureInfo">The culture info to use for parsing.</param>
+    /// <param name="result">
+    /// When this method returns, contains the parsed <c>DateTimeOffset</c>,
+    /// if the parse operation was successful; otherwise, contains the default <c>DateTimeOffset</c>.
+    /// </param>
+    /// <returns>
+    ///   <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
+    /// </returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="cultureInfo"/> is null.</exception>
+    public static bool TryParseUsingSpecificCulture(
+        string value,
+        CultureInfo cultureInfo,
+        out DateTimeOffset result)
+    {
+        ArgumentNullException.ThrowIfNull(cultureInfo);
+
         result = default;
         if (string.IsNullOrWhiteSpace(value) ||
             value.Length < DateLength)
@@ -34,7 +64,7 @@ public static bool TryParseUsingCurrentUiCulture(
 
         if (!DateTimeOffset.TryParse(
                 value,
-                CultureInfo.CurrentUICulture.DateTimeFormat,
+                cultureInfo.DateTimeFormat,
                 DateTimeStyles.None,
                 out var res))
         {
@@ -61,6 +91,36 @@ public static bool TryParseShortDateUsingCurrentUiCulture(
         string value,
         out DateTimeOffset result)
     {
+        result = default;
+        if (!TryParseShortDateUsingSpecificCulture(value, CultureInfo.CurrentUICulture, out var res))
+        {
+            return false;
+        }
+
+        result = res;
+        return true;
+    }
+
+    /// <summary>
+    /// Tries to parse a string representation of a short date using a specific culture's date format.
+    /// </summary>
+    /// <param name="value">The string to parse.</param>
+    /// <param name="cultureInfo">The culture info to use for parsing.</param>
+    /// <param name="result">
+    /// When this method returns, contains the parsed <c>DateTimeOffset</c>,
+    /// if the parse operation was successful; otherwise, contains the default <c>DateTimeOffset</c>.
+    /// </param>
+    /// <returns>
+    ///   <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
+    /// </returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="cultureInfo"/> is null.</exception>
+    public static bool TryParseShortDateUsingSpecificCulture(
+        string value,
+        CultureInfo cultureInfo,
+        out DateTimeOffset result)
+    {
+        ArgumentNullException.ThrowIfNull(cultureInfo);
+
         result = default;
         if (string.IsNullOrWhiteSpace(value) ||
             value.Length > DateLength)
@@ -70,7 +130,7 @@ public static bool TryParseShortDateUsingCurrentUiCulture(
 
         if (!DateTimeOffset.TryParse(
                 value,
-                CultureInfo.CurrentUICulture.DateTimeFormat,
+                cultureInfo.DateTimeFormat,
                 DateTimeStyles.None,
                 out var res))
         {
@@ -97,10 +157,40 @@ public static bool TryParseShortTimeUsingCurrentUiCulture(
         string value,
         out DateTimeOffset result)
     {
+        result = default;
+        if (!TryParseShortTimeUsingSpecificCulture(value, CultureInfo.CurrentUICulture, out var res))
+        {
+            return false;
+        }
+
+        result = res;
+        return true;
+    }
+
+    /// <summary>
+    /// Tries to parse a string representation of a short time using a specific culture's time format (12-hour or 24-hour).
+    /// </summary>
+    /// <param name="value">The string to parse.</param>
+    /// <param name="cultureInfo">The culture info to use for parsing.</param>
+    /// <param name="result">
+    /// When this method returns, contains the parsed <c>DateTimeOffset</c>,
+    /// if the parse operation was successful; otherwise, contains the default <c>DateTimeOffset</c>.
+    /// </param>
+    /// <returns>
+    ///   <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
+    /// </returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="cultureInfo"/> is null.</exception>
+    public static bool TryParseShortTimeUsingSpecificCulture(
+        string value,
+        CultureInfo cultureInfo,
+        out DateTimeOffset result)
+    {
+        ArgumentNullException.ThrowIfNull(cultureInfo);
+
         result = default;
 
-        var use24Hours = !(CultureInfo.CurrentUICulture.DateTimeFormat.ShortTimePattern.StartsWith("h:", StringComparison.Ordinal) ||
-                           CultureInfo.CurrentUICulture.DateTimeFormat.ShortTimePattern.StartsWith("h.", StringComparison.Ordinal));
+        var use24Hours = !(cultureInfo.DateTimeFormat.ShortTimePattern.StartsWith("h:", StringComparison.Ordinal) ||
+                           cultureInfo.DateTimeFormat.ShortTimePattern.StartsWith("h.", StringComparison.Ordinal));
 
         var maxLength = use24Hours ? MaxTimeLengthFor24Hours : MaxTimeLengthFor12Hours;
 
@@ -110,10 +200,10 @@ public static bool TryParseShortTimeUsingCurrentUiCulture(
             return false;
         }
 
-        var dateTimeOffsetValue = $"{DateTimeOffset.Now.ToShortDateStringUsingCurrentUiCulture()} {value}";
+        var dateTimeOffsetValue = $"{DateTimeOffset.Now.ToShortDateStringUsingSpecificCulture(cultureInfo)} {value}";
         if (!DateTimeOffset.TryParse(
                 dateTimeOffsetValue,
-                CultureInfo.CurrentUICulture.DateTimeFormat,
+                cultureInfo.DateTimeFormat,
                 DateTimeStyles.None,
                 out var res))
         {
@@ -140,10 +230,40 @@ public static bool TryParseShortTimeUsingCurrentUiCultureUtc(
         string value,
         out DateTimeOffset result)
     {
+        result = default;
+        if (!TryParseShortTimeUsingSpecificCultureUtc(value, CultureInfo.CurrentUICulture, out var res))
+        {
+            return false;
+        }
+
+        result = res;
+        return true;
+    }
+
+    /// <summary>
+    /// Tries to parse a string representation of a short UTC time using a specific culture's time format (12-hour or 24-hour).
+    /// </summary>
+    /// <param name="value">The string to parse.</param>
+    /// <param name="cultureInfo">The culture info to use for parsing.</param>
+    /// <param name="result">
+    /// When this method returns, contains the parsed <c>DateTimeOffset</c> in UTC,
+    /// if the parse operation was successful; otherwise, contains the default <c>DateTimeOffset</c>.
+    /// </param>
+    /// <returns>
+    ///   <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
+    /// </returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="cultureInfo"/> is null.</exception>
+    public static bool TryParseShortTimeUsingSpecificCultureUtc(
+        string value,
+        CultureInfo cultureInfo,
+        out DateTimeOffset result)
+    {
+        ArgumentNullException.ThrowIfNull(cultureInfo);
+
         result = default;
 
-        var use24Hours = !(CultureInfo.CurrentUICulture.DateTimeFormat.ShortTimePattern.StartsWith("h:", StringComparison.Ordinal) ||
-                           CultureInfo.CurrentUICulture.DateTimeFormat.ShortTimePattern.StartsWith("h.", StringComparison.Ordinal));
+        var use24Hours = !(cultureInfo.DateTimeFormat.ShortTimePattern.StartsWith("h:", StringComparison.Ordinal) ||
+                           cultureInfo.DateTimeFormat.ShortTimePattern.StartsWith("h.", StringComparison.Ordinal));
 
         var maxLength = use24Hours ? MaxTimeLengthFor24Hours : MaxTimeLengthFor12Hours;
 
@@ -153,10 +273,10 @@ public static bool TryParseShortTimeUsingCurrentUiCultureUtc(
             return false;
         }
 
-        var dateTimeOffsetValue = $"{DateTimeOffset.UtcNow.ToShortDateStringUsingCurrentUiCulture()} {value}";
+        var dateTimeOffsetValue = $"{DateTimeOffset.UtcNow.ToShortDateStringUsingSpecificCulture(cultureInfo)} {value}";
         if (!DateTimeOffset.TryParse(
                 dateTimeOffsetValue,
-                CultureInfo.CurrentUICulture.DateTimeFormat,
+                cultureInfo.DateTimeFormat,
                 DateTimeStyles.None,
                 out var res))
         {
diff --git a/test/Atc.Tests/Helpers/DateTimeOffsetHelperTests.cs b/test/Atc.Tests/Helpers/DateTimeOffsetHelperTests.cs
index dc3a62dc..8b16e90d 100644
--- a/test/Atc.Tests/Helpers/DateTimeOffsetHelperTests.cs
+++ b/test/Atc.Tests/Helpers/DateTimeOffsetHelperTests.cs
@@ -130,4 +130,98 @@ public void TryParseShortTimeUsingCurrentUiCultureUtc(
         // Assert
         Assert.Equal(expected, actual);
     }
+
+    [Theory]
+    [InlineData(true, GlobalizationLcidConstants.UnitedStates, "10/15/2023")]
+    [InlineData(true, GlobalizationLcidConstants.UnitedStates, "10-15-2023")]
+    [InlineData(false, GlobalizationLcidConstants.UnitedStates, "20/15/2023")]
+    [InlineData(true, GlobalizationLcidConstants.GreatBritain, "15/10/2023")]
+    [InlineData(false, GlobalizationLcidConstants.GreatBritain, "15/20/2023")]
+    [InlineData(true, GlobalizationLcidConstants.Denmark, "15.10.2023")]
+    [InlineData(false, GlobalizationLcidConstants.Denmark, "15.20.2023")]
+    [InlineData(true, GlobalizationLcidConstants.Germany, "15.10.2023")]
+    [InlineData(false, GlobalizationLcidConstants.Germany, "15.20.2023")]
+    public void TryParseUsingSpecificCulture(
+        bool expected,
+        int lcid,
+        string value)
+    {
+        var actual = DateTimeOffsetHelper.TryParseUsingSpecificCulture(
+            value,
+            new CultureInfo(lcid),
+            out _);
+        Assert.Equal(expected, actual);
+    }
+
+    [Theory]
+    [InlineData(true, GlobalizationLcidConstants.UnitedStates, "10/15/2023")]
+    [InlineData(true, GlobalizationLcidConstants.UnitedStates, "10-15-2023")]
+    [InlineData(false, GlobalizationLcidConstants.UnitedStates, "20/15/2023")]
+    [InlineData(true, GlobalizationLcidConstants.GreatBritain, "15/10/2023")]
+    [InlineData(false, GlobalizationLcidConstants.GreatBritain, "15/20/2023")]
+    [InlineData(true, GlobalizationLcidConstants.Denmark, "15.10.2023")]
+    [InlineData(false, GlobalizationLcidConstants.Denmark, "15.20.2023")]
+    [InlineData(true, GlobalizationLcidConstants.Germany, "15.10.2023")]
+    [InlineData(false, GlobalizationLcidConstants.Germany, "15.20.2023")]
+    public void TryParseShortDateUsingSpecificCulture(
+        bool expected,
+        int lcid,
+        string value)
+    {
+        var actual = DateTimeOffsetHelper.TryParseShortDateUsingSpecificCulture(
+            value,
+            new CultureInfo(lcid),
+            out _);
+        Assert.Equal(expected, actual);
+    }
+
+    [Theory]
+    [InlineData(true, GlobalizationLcidConstants.UnitedStates, "3:30 AM")]
+    [InlineData(true, GlobalizationLcidConstants.UnitedStates, "3:30 PM")]
+    [InlineData(false, GlobalizationLcidConstants.UnitedStates, "3:30 X")]
+    [InlineData(true, GlobalizationLcidConstants.GreatBritain, "03:30")]
+    [InlineData(true, GlobalizationLcidConstants.GreatBritain, "15:30")]
+    [InlineData(false, GlobalizationLcidConstants.GreatBritain, "24:30")]
+    [InlineData(true, GlobalizationLcidConstants.Denmark, "03.30")]
+    [InlineData(true, GlobalizationLcidConstants.Denmark, "15.30")]
+    [InlineData(false, GlobalizationLcidConstants.Denmark, "24.30")]
+    [InlineData(true, GlobalizationLcidConstants.Germany, "03:30")]
+    [InlineData(true, GlobalizationLcidConstants.Germany, "15:30")]
+    [InlineData(false, GlobalizationLcidConstants.Germany, "24:30")]
+    public void TryParseShortTimeUsingSpecificCulture(
+        bool expected,
+        int lcid,
+        string value)
+    {
+        var actual = DateTimeOffsetHelper.TryParseShortTimeUsingSpecificCulture(
+            value,
+            new CultureInfo(lcid),
+            out _);
+        Assert.Equal(expected, actual);
+    }
+
+    [Theory]
+    [InlineData(true, GlobalizationLcidConstants.UnitedStates, "3:30 AM")]
+    [InlineData(true, GlobalizationLcidConstants.UnitedStates, "3:30 PM")]
+    [InlineData(false, GlobalizationLcidConstants.UnitedStates, "3:30 X")]
+    [InlineData(true, GlobalizationLcidConstants.GreatBritain, "03:30")]
+    [InlineData(true, GlobalizationLcidConstants.GreatBritain, "15:30")]
+    [InlineData(false, GlobalizationLcidConstants.GreatBritain, "24:30")]
+    [InlineData(true, GlobalizationLcidConstants.Denmark, "03.30")]
+    [InlineData(true, GlobalizationLcidConstants.Denmark, "15.30")]
+    [InlineData(false, GlobalizationLcidConstants.Denmark, "24.30")]
+    [InlineData(true, GlobalizationLcidConstants.Germany, "03:30")]
+    [InlineData(true, GlobalizationLcidConstants.Germany, "15:30")]
+    [InlineData(false, GlobalizationLcidConstants.Germany, "24:30")]
+    public void TryParseShortTimeUsingSpecificCultureUtc(
+        bool expected,
+        int lcid,
+        string value)
+    {
+        var actual = DateTimeOffsetHelper.TryParseShortTimeUsingSpecificCultureUtc(
+            value,
+            new CultureInfo(lcid),
+            out _);
+        Assert.Equal(expected, actual);
+    }
 }
\ No newline at end of file

From 692b37605e489368f2a24fe5c792dbd42d2b779b Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 13:19:38 +0200
Subject: [PATCH 065/100] feat(atc): implement IFormattable and
 IParsable/ISpanParsable on SemanticVersion

Add IFormattable.ToString(format, provider) adjacent to ToString() override.
Add IParsable<SemanticVersion> and ISpanParsable<SemanticVersion> behind
#if NET7_0_OR_GREATER as explicit interface implementations delegating to the
existing Parse/TryParse overloads; format and provider are ignored since
SemVer parsing is culture-invariant.
---
 src/Atc/Data/SemVer/SemanticVersion.cs        | 84 ++++++++++++++++++-
 .../Data/SemVer/SemanticVersionTests.cs       | 21 +++++
 2 files changed, 104 insertions(+), 1 deletion(-)

diff --git a/src/Atc/Data/SemVer/SemanticVersion.cs b/src/Atc/Data/SemVer/SemanticVersion.cs
index 9f0f8234..1dcfda48 100644
--- a/src/Atc/Data/SemVer/SemanticVersion.cs
+++ b/src/Atc/Data/SemVer/SemanticVersion.cs
@@ -9,7 +9,11 @@ namespace Atc.Data.SemVer;
 /// Represents a version object, compliant with the Semantic Version standard 2.0 (http://semver.org).
 /// </summary>
 [Serializable]
-public sealed class SemanticVersion : IComparable, IComparable<SemanticVersion>, IEquatable<SemanticVersion>
+#if NET7_0_OR_GREATER
+public sealed class SemanticVersion : IComparable, IComparable<SemanticVersion>, IEquatable<SemanticVersion>, IFormattable, ISpanParsable<SemanticVersion>
+#else
+public sealed class SemanticVersion : IComparable, IComparable<SemanticVersion>, IEquatable<SemanticVersion>, IFormattable
+#endif
 {
     private static readonly Regex StrictModeRegex = new(
         @"^
@@ -457,6 +461,18 @@ public override string ToString()
         return $"{Major}.{Minor}.{Patch}{preReleaseString}{buildString}";
     }
 
+    /// <summary>
+    /// Formats the value of the current instance using the specified format.
+    /// Both parameters are ignored; <see cref="SemanticVersion"/> uses a fixed, culture-invariant format.
+    /// </summary>
+    /// <param name="format">Format specifier — not used by this type.</param>
+    /// <param name="formatProvider">Culture provider — not used by this type.</param>
+    /// <returns>The string representation of the current instance.</returns>
+    public string ToString(
+        string? format,
+        IFormatProvider? formatProvider)
+        => ToString();
+
     /// <summary>
     /// Converts to <see cref="Version"/> based on Major, Minor and Patch.
     /// </summary>
@@ -475,6 +491,72 @@ public Version ToVersion()
         return new(Major, Minor, Patch);
     }
 
+#if NET7_0_OR_GREATER
+    /// <summary>
+    /// Parses a string into a <see cref="SemanticVersion"/>.
+    /// </summary>
+    /// <param name="s">The string to parse.</param>
+    /// <param name="provider">Ignored; parsing is culture-invariant.</param>
+    /// <returns>The parsed <see cref="SemanticVersion"/>.</returns>
+    /// <exception cref="ArgumentException">Thrown when <paramref name="s"/> is not a valid semantic version string.</exception>
+    static SemanticVersion IParsable<SemanticVersion>.Parse(
+        string s,
+        IFormatProvider? provider)
+        => Parse(s);
+
+    /// <summary>
+    /// Tries to parse a string into a <see cref="SemanticVersion"/>.
+    /// </summary>
+    /// <param name="s">The string to parse, or <see langword="null"/>.</param>
+    /// <param name="provider">Ignored; parsing is culture-invariant.</param>
+    /// <param name="result">
+    /// When this method returns, contains the parsed <see cref="SemanticVersion"/>,
+    /// or <see langword="null"/> if parsing fails.
+    /// </param>
+    /// <returns><see langword="true"/> if parsing succeeded; otherwise, <see langword="false"/>.</returns>
+    static bool IParsable<SemanticVersion>.TryParse(
+        string? s,
+        IFormatProvider? provider,
+        [NotNullWhen(true)] out SemanticVersion? result)
+    {
+        if (s is null)
+        {
+            result = null;
+            return false;
+        }
+
+        return TryParse(s, out result);
+    }
+
+    /// <summary>
+    /// Parses a character span into a <see cref="SemanticVersion"/>.
+    /// </summary>
+    /// <param name="s">The character span to parse.</param>
+    /// <param name="provider">Ignored; parsing is culture-invariant.</param>
+    /// <returns>The parsed <see cref="SemanticVersion"/>.</returns>
+    /// <exception cref="ArgumentException">Thrown when <paramref name="s"/> is not a valid semantic version string.</exception>
+    static SemanticVersion ISpanParsable<SemanticVersion>.Parse(
+        ReadOnlySpan<char> s,
+        IFormatProvider? provider)
+        => Parse(s.ToString());
+
+    /// <summary>
+    /// Tries to parse a character span into a <see cref="SemanticVersion"/>.
+    /// </summary>
+    /// <param name="s">The character span to parse.</param>
+    /// <param name="provider">Ignored; parsing is culture-invariant.</param>
+    /// <param name="result">
+    /// When this method returns, contains the parsed <see cref="SemanticVersion"/>,
+    /// or <see langword="null"/> if parsing fails.
+    /// </param>
+    /// <returns><see langword="true"/> if parsing succeeded; otherwise, <see langword="false"/>.</returns>
+    static bool ISpanParsable<SemanticVersion>.TryParse(
+        ReadOnlySpan<char> s,
+        IFormatProvider? provider,
+        [NotNullWhen(true)] out SemanticVersion? result)
+        => TryParse(s.ToString(), out result);
+#endif
+
     public static bool operator ==(
         SemanticVersion? a,
         SemanticVersion? b)
diff --git a/test/Atc.Tests/Data/SemVer/SemanticVersionTests.cs b/test/Atc.Tests/Data/SemVer/SemanticVersionTests.cs
index 815d3248..1dcfef8b 100644
--- a/test/Atc.Tests/Data/SemVer/SemanticVersionTests.cs
+++ b/test/Atc.Tests/Data/SemVer/SemanticVersionTests.cs
@@ -560,4 +560,25 @@ public void CompareTo_WithSignificantParts(
         // Assert
         Assert.Equal(expected, System.Math.Sign(actual));
     }
+
+    [Theory]
+    [InlineData("1.2.3", "1.2.3")]
+    [InlineData("1.2.3-beta.1", "1.2.3-beta.1")]
+    public void IFormattable_ToString_ReturnsStandardFormat(
+        string input,
+        string expected)
+    {
+        IFormattable sut = new SemanticVersion(input);
+        Assert.Equal(expected, sut.ToString(format: null, formatProvider: null));
+    }
+
+    [Fact]
+    public void IFormattable_ToString_IgnoresFormatAndProvider()
+    {
+        IFormattable sut = new SemanticVersion("2.0.0");
+        var result1 = sut.ToString("N", null);
+        var result2 = sut.ToString(null, CultureInfo.InvariantCulture);
+        Assert.Equal("2.0.0", result1);
+        Assert.Equal("2.0.0", result2);
+    }
 }
\ No newline at end of file

From 456147342193a422c4ee78079c6764eb8871d964 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 13:20:57 +0200
Subject: [PATCH 066/100] fix(atc): replace Concat(sentinel).Min/Max with
 DefaultIfEmpty in MathHelper

Eliminates per-call array allocation from Min/Max helpers. DefaultIfEmpty
preserves the existing empty-input sentinel contract without allocating
a temporary array.
---
 src/Atc/Helpers/MathHelper.cs | 32 ++++++++------------------------
 1 file changed, 8 insertions(+), 24 deletions(-)

diff --git a/src/Atc/Helpers/MathHelper.cs b/src/Atc/Helpers/MathHelper.cs
index 83953783..fc09cbeb 100644
--- a/src/Atc/Helpers/MathHelper.cs
+++ b/src/Atc/Helpers/MathHelper.cs
@@ -207,9 +207,7 @@ public static int Min(int[] values)
             throw new ArgumentNullException(nameof(values));
         }
 
-        return values
-            .Concat(new[] { int.MaxValue })
-            .Min();
+        return values.DefaultIfEmpty(int.MaxValue).Min();
     }
 
     /// <summary>
@@ -223,9 +221,7 @@ public static int Min(List<int> values)
             throw new ArgumentNullException(nameof(values));
         }
 
-        return values
-            .Concat(new[] { int.MaxValue })
-            .Min();
+        return values.DefaultIfEmpty(int.MaxValue).Min();
     }
 
     /// <summary>
@@ -239,9 +235,7 @@ public static double Min(double[] values)
             throw new ArgumentNullException(nameof(values));
         }
 
-        return values
-            .Concat(new[] { double.MaxValue })
-            .Min();
+        return values.DefaultIfEmpty(double.MaxValue).Min();
     }
 
     /// <summary>
@@ -255,9 +249,7 @@ public static double Min(List<double> values)
             throw new ArgumentNullException(nameof(values));
         }
 
-        return values
-            .Concat(new[] { double.MaxValue })
-            .Min();
+        return values.DefaultIfEmpty(double.MaxValue).Min();
     }
 
     /// <summary>
@@ -271,9 +263,7 @@ public static int Max(int[] values)
             throw new ArgumentNullException(nameof(values));
         }
 
-        return values
-            .Concat(new[] { int.MinValue })
-            .Max();
+        return values.DefaultIfEmpty(int.MinValue).Max();
     }
 
     /// <summary>
@@ -287,9 +277,7 @@ public static int Max(List<int> values)
             throw new ArgumentNullException(nameof(values));
         }
 
-        return values
-            .Concat(new[] { int.MinValue })
-            .Max();
+        return values.DefaultIfEmpty(int.MinValue).Max();
     }
 
     /// <summary>
@@ -303,9 +291,7 @@ public static double Max(double[] values)
             throw new ArgumentNullException(nameof(values));
         }
 
-        return values
-            .Concat(new[] { double.MinValue })
-            .Max();
+        return values.DefaultIfEmpty(double.MinValue).Max();
     }
 
     /// <summary>
@@ -319,9 +305,7 @@ public static double Max(List<double> values)
             throw new ArgumentNullException(nameof(values));
         }
 
-        return values
-            .Concat(new[] { double.MinValue })
-            .Max();
+        return values.DefaultIfEmpty(double.MinValue).Max();
     }
 
     /// <summary>

From 75afdab6309091a76c145ee865ec9ed4e41db813 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 14:29:15 +0200
Subject: [PATCH 067/100] feat(atc): extend ByteSize with IComparable,
 operators, Parse/TryParse, and IEC binary suffix

- ByteSize: implement IComparable<ByteSize> and IComparable with comparison operators and arithmetic operators (+ and -)
- ByteSize: add static Parse(string) and TryParse(string?, out ByteSize) methods
- ByteSizeSuffixType: add ShortBinary enum value for IEC 80000-13 notation (KiB, MiB, GiB, ...)
- ByteSizeCalculationData: add PrefixesShortBinary array
- ByteSizeFormatter: update prefix selection to a switch expression supporting ShortBinary
- Fix SwitchCaseDefaultException_ObjectValue test to force object? overload
- Add ConfigurationExceptionTests and SwitchCaseDefaultExceptionTests compliance test classes
---
 docs/CodeDoc/Atc/Atc.Data.SemVer.md           |   6 +-
 docs/CodeDoc/Atc/Atc.Helpers.md               |  60 +++++++
 .../Atc/Atc.Units.DigitalInformation.md       |  49 +++++-
 docs/CodeDoc/Atc/Index.md                     |   2 +
 docs/CodeDoc/Atc/IndexExtended.md             |  33 ++++
 docs/CodeDoc/Atc/System.Reflection.md         |  49 ++++++
 docs/CodeDoc/Atc/System.md                    | 151 +++++++++++++++++
 src/Atc/Units/DigitalInformation/ByteSize.cs  | 160 +++++++++++++++++-
 .../ByteSizeCalculationData.cs                |  15 ++
 .../DigitalInformation/ByteSizeFormatter.cs   |   9 +-
 .../Enums/ByteSizeSuffixType.cs               |   6 +
 .../Exceptions/ConfigurationExceptionTests.cs |  24 +++
 test/Atc.Tests/Exceptions/ExceptionsTests.cs  |   2 +-
 .../SwitchCaseDefaultExceptionTests.cs        |  38 +++++
 .../ByteSizeFormatterTests.cs                 |  28 ++-
 .../Units/DigitalInformation/ByteSizeTests.cs | 106 ++++++++++++
 16 files changed, 730 insertions(+), 8 deletions(-)
 create mode 100644 test/Atc.Tests/Exceptions/ConfigurationExceptionTests.cs
 create mode 100644 test/Atc.Tests/Exceptions/SwitchCaseDefaultExceptionTests.cs

diff --git a/docs/CodeDoc/Atc/Atc.Data.SemVer.md b/docs/CodeDoc/Atc/Atc.Data.SemVer.md
index 872b5ec4..596ebcfd 100644
--- a/docs/CodeDoc/Atc/Atc.Data.SemVer.md
+++ b/docs/CodeDoc/Atc/Atc.Data.SemVer.md
@@ -11,7 +11,7 @@
 Represents a version object, compliant with the Semantic Version standard 2.0 (http://semver.org).
 
 >```csharp
->public class SemanticVersion : IComparable, IComparable<SemanticVersion>, IEquatable<SemanticVersion>
+>public class SemanticVersion : IComparable, IComparable<SemanticVersion>, IEquatable<SemanticVersion>, IFormattable, ISpanParsable<SemanticVersion>, IParsable<SemanticVersion>
 >```
 
 ### Static Methods
@@ -181,6 +181,10 @@ Represents a version object, compliant with the Semantic Version standard 2.0 (h
 >```csharp
 >string ToString()
 >```
+#### ToString
+>```csharp
+>string ToString(string format, IFormatProvider formatProvider)
+>```
 #### ToVersion
 >```csharp
 >Version ToVersion()
diff --git a/docs/CodeDoc/Atc/Atc.Helpers.md b/docs/CodeDoc/Atc/Atc.Helpers.md
index e5dcf17c..3dcee6b5 100644
--- a/docs/CodeDoc/Atc/Atc.Helpers.md
+++ b/docs/CodeDoc/Atc/Atc.Helpers.md
@@ -938,6 +938,21 @@ DateTimeOffsetHelper.
             <br />
 >
 ><b>Returns:</b> <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
+#### TryParseShortDateUsingSpecificCulture
+>```csharp
+>bool TryParseShortDateUsingSpecificCulture(string value, CultureInfo cultureInfo, out DateTime result)
+>```
+><b>Summary:</b> Tries to parse a string representation of a short date using a specific culture's date format.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to parse.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cultureInfo`&nbsp;&nbsp;-&nbsp;&nbsp;The culture info to use for parsing.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`result`&nbsp;&nbsp;-&nbsp;&nbsp;
+            When this method returns, contains the parsed DateTimeOffset,
+            if the parse operation was successful; otherwise, contains the default DateTimeOffset.
+            <br />
+>
+><b>Returns:</b> <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
 #### TryParseShortTimeUsingCurrentUiCulture
 >```csharp
 >bool TryParseShortTimeUsingCurrentUiCulture(string value, out DateTime result)
@@ -966,6 +981,36 @@ DateTimeOffsetHelper.
             <br />
 >
 ><b>Returns:</b> <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
+#### TryParseShortTimeUsingSpecificCulture
+>```csharp
+>bool TryParseShortTimeUsingSpecificCulture(string value, CultureInfo cultureInfo, out DateTime result)
+>```
+><b>Summary:</b> Tries to parse a string representation of a short time using a specific culture's time format (12-hour or 24-hour).
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to parse.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cultureInfo`&nbsp;&nbsp;-&nbsp;&nbsp;The culture info to use for parsing.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`result`&nbsp;&nbsp;-&nbsp;&nbsp;
+            When this method returns, contains the parsed DateTimeOffset,
+            if the parse operation was successful; otherwise, contains the default DateTimeOffset.
+            <br />
+>
+><b>Returns:</b> <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
+#### TryParseShortTimeUsingSpecificCultureUtc
+>```csharp
+>bool TryParseShortTimeUsingSpecificCultureUtc(string value, CultureInfo cultureInfo, out DateTime result)
+>```
+><b>Summary:</b> Tries to parse a string representation of a short UTC time using a specific culture's time format (12-hour or 24-hour).
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to parse.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cultureInfo`&nbsp;&nbsp;-&nbsp;&nbsp;The culture info to use for parsing.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`result`&nbsp;&nbsp;-&nbsp;&nbsp;
+            When this method returns, contains the parsed DateTimeOffset in UTC,
+            if the parse operation was successful; otherwise, contains the default DateTimeOffset.
+            <br />
+>
+><b>Returns:</b> <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
 #### TryParseUsingCurrentUiCulture
 >```csharp
 >bool TryParseUsingCurrentUiCulture(string value, out DateTime result)
@@ -980,6 +1025,21 @@ DateTimeOffsetHelper.
             <br />
 >
 ><b>Returns:</b> <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
+#### TryParseUsingSpecificCulture
+>```csharp
+>bool TryParseUsingSpecificCulture(string value, CultureInfo cultureInfo, out DateTime result)
+>```
+><b>Summary:</b> Tries to parse a string representation of a `DateTimeOffset` using a specific culture's date and time format.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to parse.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cultureInfo`&nbsp;&nbsp;-&nbsp;&nbsp;The culture info to use for parsing.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`result`&nbsp;&nbsp;-&nbsp;&nbsp;
+            When this method returns, contains the parsed DateTimeOffset,
+            if the parse operation was successful; otherwise, contains the default DateTimeOffset.
+            <br />
+>
+><b>Returns:</b> <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
 
 <br />
 
diff --git a/docs/CodeDoc/Atc/Atc.Units.DigitalInformation.md b/docs/CodeDoc/Atc/Atc.Units.DigitalInformation.md
index 9f199bbe..3880a1e3 100644
--- a/docs/CodeDoc/Atc/Atc.Units.DigitalInformation.md
+++ b/docs/CodeDoc/Atc/Atc.Units.DigitalInformation.md
@@ -11,9 +11,35 @@
 Represents a size in bytes.
 
 >```csharp
->public struct ByteSize : IEquatable<ByteSize>
+>public struct ByteSize : IEquatable<ByteSize>, IComparable<ByteSize>, IComparable
 >```
 
+### Static Methods
+
+#### Parse
+>```csharp
+>ByteSize Parse(string value)
+>```
+><b>Summary:</b> Parses a string of digits into a `Atc.Units.DigitalInformation.ByteSize`.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to parse. Must represent a valid  value.<br />
+>
+><b>Returns:</b> A `Atc.Units.DigitalInformation.ByteSize` with the parsed byte count.
+#### TryParse
+>```csharp
+>bool TryParse(string value, out byte result)
+>```
+><b>Summary:</b> Tries to parse a string into a `Atc.Units.DigitalInformation.ByteSize`.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to parse, or .<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`result`&nbsp;&nbsp;-&nbsp;&nbsp;
+            When this method returns, contains the parsed 
+            if parsing succeeded; otherwise, .
+            <br />
+>
+><b>Returns:</b> <see langword="true" /> if parsing succeeded; otherwise, <see langword="false" />.
 ### Properties
 
 #### Value
@@ -23,6 +49,26 @@ Represents a size in bytes.
 ><b>Summary:</b> Gets the size in bytes.
 ### Methods
 
+#### CompareTo
+>```csharp
+>int CompareTo(ByteSize other)
+>```
+><b>Summary:</b> Compares this instance to another `Atc.Units.DigitalInformation.ByteSize` value.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`other`&nbsp;&nbsp;-&nbsp;&nbsp;The other value to compare to.<br />
+>
+><b>Returns:</b> A negative number if this instance is less than `other`; zero if they are equal; a positive number if this instance is greater.
+#### CompareTo
+>```csharp
+>int CompareTo(object obj)
+>```
+><b>Summary:</b> Compares this instance to another `Atc.Units.DigitalInformation.ByteSize` value.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`other`&nbsp;&nbsp;-&nbsp;&nbsp;The other value to compare to.<br />
+>
+><b>Returns:</b> A negative number if this instance is less than `other`; zero if they are equal; a positive number if this instance is greater.
 #### Equals
 >```csharp
 >bool Equals(ByteSize other)
@@ -174,6 +220,7 @@ Defines the suffix format for displaying byte sizes.
 | 0 | None | None | No suffix is appended to the numeric value. | 
 | 1 | Short | Short | Short suffix format (e.g., "B", "KB", "MB", "GB"). | 
 | 2 | Full | Full | Full suffix format (e.g., "byte", "Kilobyte", "Megabyte", "Gigabyte"). | 
+| 3 | ShortBinary | Short Binary | Short IEC binary suffix format (e.g., "B", "KiB", "MiB", "GiB"). Uses IEC 80000-13 notation to distinguish 1024-based units from SI decimal units. | 
 
 
 
diff --git a/docs/CodeDoc/Atc/Index.md b/docs/CodeDoc/Atc/Index.md
index 0dc6a121..15160ab4 100644
--- a/docs/CodeDoc/Atc/Index.md
+++ b/docs/CodeDoc/Atc/Index.md
@@ -267,6 +267,8 @@
 ## [System.Reflection](System.Reflection.md)
 
 - [AssemblyExtensions](System.Reflection.md#assemblyextensions)
+- [ConstructorInfoExtensions](System.Reflection.md#constructorinfoextensions)
+- [EventInfoExtensions](System.Reflection.md#eventinfoextensions)
 - [FieldInfoExtensions](System.Reflection.md#fieldinfoextensions)
 - [MemberInfoExtensions](System.Reflection.md#memberinfoextensions)
 - [MethodInfoExtensions](System.Reflection.md#methodinfoextensions)
diff --git a/docs/CodeDoc/Atc/IndexExtended.md b/docs/CodeDoc/Atc/IndexExtended.md
index 31bae2f1..320fd9b0 100644
--- a/docs/CodeDoc/Atc/IndexExtended.md
+++ b/docs/CodeDoc/Atc/IndexExtended.md
@@ -4394,6 +4394,7 @@
      - GreaterThanOrEqualTo(SemanticVersion otherVersion, int significantParts = 4, int startingPart = 1)
      - IsNewerThan(SemanticVersion otherVersion, bool withinMinorReleaseOnly = False, bool looseMode = False)
      - ToString()
+     - ToString(string format, IFormatProvider formatProvider)
      - ToVersion()
 
 ## [Atc.Factories](Atc.Factories.md)
@@ -4518,9 +4519,13 @@
 - [DateTimeOffsetHelper](Atc.Helpers.md#datetimeoffsethelper)
   -  Static Methods
      - TryParseShortDateUsingCurrentUiCulture(string value, out DateTime result)
+     - TryParseShortDateUsingSpecificCulture(string value, CultureInfo cultureInfo, out DateTime result)
      - TryParseShortTimeUsingCurrentUiCulture(string value, out DateTime result)
      - TryParseShortTimeUsingCurrentUiCultureUtc(string value, out DateTime result)
+     - TryParseShortTimeUsingSpecificCulture(string value, CultureInfo cultureInfo, out DateTime result)
+     - TryParseShortTimeUsingSpecificCultureUtc(string value, CultureInfo cultureInfo, out DateTime result)
      - TryParseUsingCurrentUiCulture(string value, out DateTime result)
+     - TryParseUsingSpecificCulture(string value, CultureInfo cultureInfo, out DateTime result)
 - [DayOfWeekHelper](Atc.Helpers.md#dayofweekhelper)
   -  Static Methods
      - GetDescription(DayOfWeek dayOfWeek, CultureInfo culture = null)
@@ -4983,9 +4988,14 @@
 ## [Atc.Units.DigitalInformation](Atc.Units.DigitalInformation.md)
 
 - [ByteSize](Atc.Units.DigitalInformation.md#bytesize)
+  -  Static Methods
+     - Parse(string value)
+     - TryParse(string value, out byte result)
   -  Properties
      - Value
   -  Methods
+     - CompareTo(ByteSize other)
+     - CompareTo(object obj)
      - Equals(ByteSize other)
      - Equals(object obj)
      - Format()
@@ -5084,13 +5094,21 @@
      - IsHexDigit(this char value)
      - IsVowel(this char value)
 - [ConfigurationException](System.md#configurationexception)
+  -  Static Methods
+     - ThrowIfInvalid(bool condition, string section, string key)
+     - ThrowIfMissing(string value, string section, string key)
 - [DateTimeExtensions](System.md#datetimeextensions)
   -  Static Methods
      - DateTimeDiff(this DateTime startDate, DateTime endDate, DateTimeDiffCompareType howToCompare)
+     - EndOfDay(this DateTime dateTime)
+     - EndOfMonth(this DateTime dateTime)
      - GetPrettyTimeDiff(this DateTime startDate, DateTime endDate, int decimalPrecision = 3)
      - GetPrettyTimeDiff(this DateTime startDate, int decimalPrecision = 3)
      - GetWeekNumber(this DateTime date)
      - IsBetween(this DateTime date, DateTime startDate, DateTime endDate)
+     - IsWeekend(this DateTime dateTime)
+     - StartOfDay(this DateTime dateTime)
+     - StartOfMonth(this DateTime dateTime)
      - ToIso8601Date(this DateTime dateTime)
      - ToIso8601UtcDate(this DateTime dateTime)
      - ToLongDateString(this DateTime dateTime, DateTimeFormatInfo dateTimeFormatInfo)
@@ -5108,12 +5126,17 @@
 - [DateTimeOffsetExtensions](System.md#datetimeoffsetextensions)
   -  Static Methods
      - DateTimeDiff(this DateTimeOffset startDate, DateTimeOffset endDate, DateTimeDiffCompareType howToCompare)
+     - EndOfDay(this DateTimeOffset dateTimeOffset)
+     - EndOfMonth(this DateTimeOffset dateTimeOffset)
      - GetPrettyTimeDiff(this DateTimeOffset startDate, DateTimeOffset endDate, int decimalPrecision = 3)
      - GetPrettyTimeDiff(this DateTimeOffset startDate, int decimalPrecision = 3)
      - GetWeekNumber(this DateTimeOffset date)
      - IsBetween(this DateTimeOffset dateTimeOffset, DateTimeOffset startDate, DateTimeOffset endDate)
+     - IsWeekend(this DateTimeOffset dateTimeOffset)
      - ResetToStartOfCurrentHour(this DateTimeOffset dateTimeOffset)
      - SetHourAndMinutes(this DateTimeOffset dateTimeOffset, int hour, int minutes)
+     - StartOfDay(this DateTimeOffset dateTimeOffset)
+     - StartOfMonth(this DateTimeOffset dateTimeOffset)
      - ToIso8601Date(this DateTimeOffset dateTimeOffset)
      - ToIso8601UtcDate(this DateTimeOffset dateTimeOffset)
      - ToLongDateString(this DateTimeOffset dateTimeOffset, DateTimeFormatInfo dateTimeFormatInfo)
@@ -5122,6 +5145,7 @@
      - ToLongTimeStringUsingCurrentUiCulture(this DateTimeOffset dateTimeOffset)
      - ToShortDateString(this DateTimeOffset dateTimeOffset, DateTimeFormatInfo dateTimeFormatInfo)
      - ToShortDateStringUsingCurrentUiCulture(this DateTimeOffset dateTimeOffset)
+     - ToShortDateStringUsingSpecificCulture(this DateTimeOffset dateTimeOffset, CultureInfo cultureInfo)
      - ToShortTimeString(this DateTimeOffset dateTimeOffset, DateTimeFormatInfo dateTimeFormatInfo)
      - ToShortTimeStringUsingCurrentUiCulture(this DateTimeOffset dateTimeOffset)
      - ToUnixTime(this DateTimeOffset dateTimeOffset)
@@ -5347,6 +5371,9 @@
      - IsWord(this string value)
 - [StringNullOrEmptyException](System.md#stringnulloremptyexception)
 - [SwitchCaseDefaultException](System.md#switchcasedefaultexception)
+  -  Static Methods
+     - Throw(Enum value)
+     - Throw(object value)
 - [TaskExtensions](System.md#taskextensions)
   -  Static Methods
      - Forget(this Task task)
@@ -5552,6 +5579,12 @@
      - GetResourceManagers(this Assembly assembly)
      - GetTypesInheritingFromType(this Assembly assembly, Type type)
      - IsDebugBuild(this Assembly assembly)
+- [ConstructorInfoExtensions](System.Reflection.md#constructorinfoextensions)
+  -  Static Methods
+     - BeautifyName(this ConstructorInfo constructorInfo, bool useFullName = False, bool useHtmlFormat = False)
+- [EventInfoExtensions](System.Reflection.md#eventinfoextensions)
+  -  Static Methods
+     - BeautifyName(this EventInfo eventInfo, bool useFullName = False, bool useHtmlFormat = False, bool includeEventHandlerType = False)
 - [FieldInfoExtensions](System.Reflection.md#fieldinfoextensions)
   -  Static Methods
      - BeautifyName(this FieldInfo fieldInfo, bool useFullName = False, bool useHtmlFormat = False, bool includeReturnType = False)
diff --git a/docs/CodeDoc/Atc/System.Reflection.md b/docs/CodeDoc/Atc/System.Reflection.md
index 7d673ccd..2bd2b487 100644
--- a/docs/CodeDoc/Atc/System.Reflection.md
+++ b/docs/CodeDoc/Atc/System.Reflection.md
@@ -81,6 +81,55 @@ Extensions for the `System.Reflection.Assembly` class.
 
 <br />
 
+## ConstructorInfoExtensions
+Extensions for the `System.Reflection.ConstructorInfo` class.
+
+>```csharp
+>public static class ConstructorInfoExtensions
+>```
+
+### Static Methods
+
+#### BeautifyName
+>```csharp
+>string BeautifyName(this ConstructorInfo constructorInfo, bool useFullName = False, bool useHtmlFormat = False)
+>```
+><b>Summary:</b> Returns a human-readable representation of the constructor signature, optionally using full type names and HTML formatting for the parameter types.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`constructorInfo`&nbsp;&nbsp;-&nbsp;&nbsp;The constructor information.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`useFullName`&nbsp;&nbsp;-&nbsp;&nbsp;If , parameter types are rendered with their fully-qualified names.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`useHtmlFormat`&nbsp;&nbsp;-&nbsp;&nbsp;If , parameter type names are wrapped in HTML tags.<br />
+>
+><b>Returns:</b> A string of the form `.ctor(TypeA paramA, TypeB paramB)`.
+
+<br />
+
+## EventInfoExtensions
+Extensions for the `System.Reflection.EventInfo` class.
+
+>```csharp
+>public static class EventInfoExtensions
+>```
+
+### Static Methods
+
+#### BeautifyName
+>```csharp
+>string BeautifyName(this EventInfo eventInfo, bool useFullName = False, bool useHtmlFormat = False, bool includeEventHandlerType = False)
+>```
+><b>Summary:</b> Returns a human-readable representation of the event, optionally including the event handler type and using full type names or HTML formatting.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`eventInfo`&nbsp;&nbsp;-&nbsp;&nbsp;The event information.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`useFullName`&nbsp;&nbsp;-&nbsp;&nbsp;If , the event-handler type is rendered with its fully-qualified name.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`useHtmlFormat`&nbsp;&nbsp;-&nbsp;&nbsp;If , the event-handler type name is wrapped in HTML tags.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`includeEventHandlerType`&nbsp;&nbsp;-&nbsp;&nbsp;If , the event-handler type is prepended to the name.<br />
+>
+><b>Returns:</b> A string such as `MyEvent` or `EventHandler MyEvent` when `includeEventHandlerType` is <see langword="true" />.
+
+<br />
+
 ## FieldInfoExtensions
 Extensions for the `System.Reflection.FieldInfo` class.
 
diff --git a/docs/CodeDoc/Atc/System.md b/docs/CodeDoc/Atc/System.md
index 69b028ba..abd5e7e4 100644
--- a/docs/CodeDoc/Atc/System.md
+++ b/docs/CodeDoc/Atc/System.md
@@ -608,6 +608,28 @@ The exception that is thrown when a configuration error occurs, such as missing
 >public class ConfigurationException : Exception, ISerializable
 >```
 
+### Static Methods
+
+#### ThrowIfInvalid
+>```csharp
+>void ThrowIfInvalid(bool condition, string section, string key)
+>```
+><b>Summary:</b> Throws a `System.ConfigurationException` if `condition` is <see langword="true" />.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`condition`&nbsp;&nbsp;-&nbsp;&nbsp;The condition that indicates the configuration value is invalid.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`section`&nbsp;&nbsp;-&nbsp;&nbsp;The configuration section name.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`key`&nbsp;&nbsp;-&nbsp;&nbsp;The configuration key name.<br />
+#### ThrowIfMissing
+>```csharp
+>void ThrowIfMissing(string value, string section, string key)
+>```
+><b>Summary:</b> Throws a `System.ConfigurationException` if `value` is <see langword="null" /> or empty.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The configuration value to validate.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`section`&nbsp;&nbsp;-&nbsp;&nbsp;The configuration section name.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`key`&nbsp;&nbsp;-&nbsp;&nbsp;The configuration key name.<br />
 
 <br />
 
@@ -632,6 +654,26 @@ Extensions for the `System.DateTime` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`howToCompare`&nbsp;&nbsp;-&nbsp;&nbsp;The how to compare.<br />
 >
 ><b>Returns:</b> The number between start date and end date, depend on the DiffCompareType.
+#### EndOfDay
+>```csharp
+>DateTime EndOfDay(this DateTime dateTime)
+>```
+><b>Summary:</b> Returns a new `System.DateTime` set to the very end of the same day (23:59:59.9999999). The `System.DateTime.Kind` of the result matches the input.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTime`&nbsp;&nbsp;-&nbsp;&nbsp;The date value.<br />
+>
+><b>Returns:</b> The last representable tick of `dateTime`'s date.
+#### EndOfMonth
+>```csharp
+>DateTime EndOfMonth(this DateTime dateTime)
+>```
+><b>Summary:</b> Returns a new `System.DateTime` set to the last tick of the last day of the same month.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTime`&nbsp;&nbsp;-&nbsp;&nbsp;The date value.<br />
+>
+><b>Returns:</b> The last representable tick of the last day of the month containing `dateTime`.
 #### GetPrettyTimeDiff
 >```csharp
 >string GetPrettyTimeDiff(this DateTime startDate, int decimalPrecision = 3)
@@ -672,6 +714,36 @@ Extensions for the `System.DateTime` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`endDate`&nbsp;&nbsp;-&nbsp;&nbsp;End date to check for.<br />
 >
 ><b>Returns:</b> boolean value indicating if the date is between or equal to one of the two values.
+#### IsWeekend
+>```csharp
+>bool IsWeekend(this DateTime dateTime)
+>```
+><b>Summary:</b> Determines whether the specified date falls on a Saturday or Sunday.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTime`&nbsp;&nbsp;-&nbsp;&nbsp;The date to test.<br />
+>
+><b>Returns:</b> <see langword="true" /> if the day of the week is `System.DayOfWeek.Saturday` or `System.DayOfWeek.Sunday`; otherwise, <see langword="false" />.
+#### StartOfDay
+>```csharp
+>DateTime StartOfDay(this DateTime dateTime)
+>```
+><b>Summary:</b> Returns a new `System.DateTime` set to the very start of the same day (00:00:00.000). The `System.DateTime.Kind` of the result matches the input.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTime`&nbsp;&nbsp;-&nbsp;&nbsp;The date value.<br />
+>
+><b>Returns:</b> Midnight at the start of `dateTime`'s date.
+#### StartOfMonth
+>```csharp
+>DateTime StartOfMonth(this DateTime dateTime)
+>```
+><b>Summary:</b> Returns a new `System.DateTime` set to the first day of the same month at midnight (00:00:00.000).
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTime`&nbsp;&nbsp;-&nbsp;&nbsp;The date value.<br />
+>
+><b>Returns:</b> The first day of the month containing `dateTime`.
 #### ToIso8601Date
 >```csharp
 >string ToIso8601Date(this DateTime dateTime)
@@ -845,6 +917,26 @@ Extensions for the `System.DateTimeOffset` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`howToCompare`&nbsp;&nbsp;-&nbsp;&nbsp;The how to compare.<br />
 >
 ><b>Returns:</b> The number between start date and end date, depend on the DiffCompareType.
+#### EndOfDay
+>```csharp
+>DateTimeOffset EndOfDay(this DateTimeOffset dateTimeOffset)
+>```
+><b>Summary:</b> Returns a new `System.DateTimeOffset` set to the very end of the same day (23:59:59.9999999), preserving the original `System.DateTimeOffset.Offset`.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeOffset`&nbsp;&nbsp;-&nbsp;&nbsp;The date-time value.<br />
+>
+><b>Returns:</b> The last representable tick of the date, with the same UTC offset.
+#### EndOfMonth
+>```csharp
+>DateTimeOffset EndOfMonth(this DateTimeOffset dateTimeOffset)
+>```
+><b>Summary:</b> Returns a new `System.DateTimeOffset` set to the last tick of the last day of the same month, preserving the original `System.DateTimeOffset.Offset`.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeOffset`&nbsp;&nbsp;-&nbsp;&nbsp;The date-time value.<br />
+>
+><b>Returns:</b> The last representable tick of the month, with the same UTC offset.
 #### GetPrettyTimeDiff
 >```csharp
 >string GetPrettyTimeDiff(this DateTimeOffset startDate, int decimalPrecision = 3)
@@ -885,6 +977,16 @@ Extensions for the `System.DateTimeOffset` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`endDate`&nbsp;&nbsp;-&nbsp;&nbsp;End date to check for.<br />
 >
 ><b>Returns:</b> boolean value indicating if the date is between or equal to one of the two values.
+#### IsWeekend
+>```csharp
+>bool IsWeekend(this DateTimeOffset dateTimeOffset)
+>```
+><b>Summary:</b> Determines whether the date falls on a Saturday or Sunday.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeOffset`&nbsp;&nbsp;-&nbsp;&nbsp;The date to test.<br />
+>
+><b>Returns:</b> <see langword="true" /> if the day of week is `System.DayOfWeek.Saturday` or `System.DayOfWeek.Sunday`; otherwise, <see langword="false" />.
 #### ResetToStartOfCurrentHour
 >```csharp
 >DateTimeOffset ResetToStartOfCurrentHour(this DateTimeOffset dateTimeOffset)
@@ -907,6 +1009,26 @@ Extensions for the `System.DateTimeOffset` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`minutes`&nbsp;&nbsp;-&nbsp;&nbsp;The minutes.<br />
 >
 ><b>Returns:</b> The dateTimeOffset with the specified hour and minutes.
+#### StartOfDay
+>```csharp
+>DateTimeOffset StartOfDay(this DateTimeOffset dateTimeOffset)
+>```
+><b>Summary:</b> Returns a new `System.DateTimeOffset` set to the very start of the same day (00:00:00.000), preserving the original `System.DateTimeOffset.Offset`.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeOffset`&nbsp;&nbsp;-&nbsp;&nbsp;The date-time value.<br />
+>
+><b>Returns:</b> Midnight at the start of the date, with the same UTC offset.
+#### StartOfMonth
+>```csharp
+>DateTimeOffset StartOfMonth(this DateTimeOffset dateTimeOffset)
+>```
+><b>Summary:</b> Returns a new `System.DateTimeOffset` set to the first day of the same month at midnight, preserving the original `System.DateTimeOffset.Offset`.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeOffset`&nbsp;&nbsp;-&nbsp;&nbsp;The date-time value.<br />
+>
+><b>Returns:</b> The first day of the month, with the same UTC offset.
 #### ToIso8601Date
 >```csharp
 >string ToIso8601Date(this DateTimeOffset dateTimeOffset)
@@ -986,6 +1108,17 @@ Extensions for the `System.DateTimeOffset` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeOffset`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTimeOffset to format.<br />
 >
 ><b>Returns:</b> A string representation of the DateTime using the short date pattern of the current UI culture.
+#### ToShortDateStringUsingSpecificCulture
+>```csharp
+>string ToShortDateStringUsingSpecificCulture(this DateTimeOffset dateTimeOffset, CultureInfo cultureInfo)
+>```
+><b>Summary:</b> Converts a `System.DateTimeOffset` to a string using the short date pattern of the specified culture.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeOffset`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTimeOffset to format.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cultureInfo`&nbsp;&nbsp;-&nbsp;&nbsp;The culture whose short date pattern is used.<br />
+>
+><b>Returns:</b> A string representation of the date using the short date pattern of `cultureInfo`.
 #### ToShortTimeString
 >```csharp
 >string ToShortTimeString(this DateTimeOffset dateTimeOffset, DateTimeFormatInfo dateTimeFormatInfo)
@@ -3275,6 +3408,24 @@ The exception that is thrown when an unexpected value is encountered in a switch
 >public class SwitchCaseDefaultException : Exception, ISerializable
 >```
 
+### Static Methods
+
+#### Throw
+>```csharp
+>void Throw(Enum value)
+>```
+><b>Summary:</b> Throws a `System.SwitchCaseDefaultException` for the given enum value.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The unexpected enum value encountered in the switch default case.<br />
+#### Throw
+>```csharp
+>void Throw(object value)
+>```
+><b>Summary:</b> Throws a `System.SwitchCaseDefaultException` for the given enum value.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The unexpected enum value encountered in the switch default case.<br />
 
 <br />
 
diff --git a/src/Atc/Units/DigitalInformation/ByteSize.cs b/src/Atc/Units/DigitalInformation/ByteSize.cs
index 1ea2dd7d..e098d187 100644
--- a/src/Atc/Units/DigitalInformation/ByteSize.cs
+++ b/src/Atc/Units/DigitalInformation/ByteSize.cs
@@ -5,7 +5,7 @@ namespace Atc.Units.DigitalInformation;
 /// </summary>
 [Serializable]
 [SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "OK.")]
-public struct ByteSize : IEquatable<ByteSize>
+public struct ByteSize : IEquatable<ByteSize>, IComparable<ByteSize>, IComparable
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="ByteSize"/> struct.
@@ -153,6 +153,127 @@ public ByteSize(long value)
     /// </returns>
     public static implicit operator ByteSize(ushort value) => new(value);
 
+    /// <summary>
+    /// Implements the less-than operator.
+    /// </summary>
+    /// <param name="a">Left operand.</param>
+    /// <param name="b">Right operand.</param>
+    /// <returns><see langword="true"/> if <paramref name="a"/> is less than <paramref name="b"/>.</returns>
+    public static bool operator <(
+        ByteSize a,
+        ByteSize b)
+        => a.Value < b.Value;
+
+    /// <summary>
+    /// Implements the less-than-or-equal operator.
+    /// </summary>
+    /// <param name="a">Left operand.</param>
+    /// <param name="b">Right operand.</param>
+    /// <returns><see langword="true"/> if <paramref name="a"/> is less than or equal to <paramref name="b"/>.</returns>
+    public static bool operator <=(
+        ByteSize a,
+        ByteSize b)
+        => a.Value <= b.Value;
+
+    /// <summary>
+    /// Implements the greater-than operator.
+    /// </summary>
+    /// <param name="a">Left operand.</param>
+    /// <param name="b">Right operand.</param>
+    /// <returns><see langword="true"/> if <paramref name="a"/> is greater than <paramref name="b"/>.</returns>
+    public static bool operator >(
+        ByteSize a,
+        ByteSize b)
+        => a.Value > b.Value;
+
+    /// <summary>
+    /// Implements the greater-than-or-equal operator.
+    /// </summary>
+    /// <param name="a">Left operand.</param>
+    /// <param name="b">Right operand.</param>
+    /// <returns><see langword="true"/> if <paramref name="a"/> is greater than or equal to <paramref name="b"/>.</returns>
+    public static bool operator >=(
+        ByteSize a,
+        ByteSize b)
+        => a.Value >= b.Value;
+
+    /// <summary>
+    /// Adds two <see cref="ByteSize"/> values.
+    /// </summary>
+    /// <param name="a">Left operand.</param>
+    /// <param name="b">Right operand.</param>
+    /// <returns>The sum of <paramref name="a"/> and <paramref name="b"/>.</returns>
+    public static ByteSize operator +(
+        ByteSize a,
+        ByteSize b)
+        => new(a.Value + b.Value);
+
+    /// <summary>
+    /// Subtracts one <see cref="ByteSize"/> value from another.
+    /// </summary>
+    /// <param name="a">Left operand.</param>
+    /// <param name="b">Right operand.</param>
+    /// <returns>The difference between <paramref name="a"/> and <paramref name="b"/>.</returns>
+    public static ByteSize operator -(
+        ByteSize a,
+        ByteSize b)
+        => new(a.Value - b.Value);
+
+    /// <summary>
+    /// Parses a string of digits into a <see cref="ByteSize"/>.
+    /// </summary>
+    /// <param name="value">The string to parse. Must represent a valid <see cref="long"/> value.</param>
+    /// <returns>A <see cref="ByteSize"/> with the parsed byte count.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="value"/> is null.</exception>
+    /// <exception cref="FormatException">Thrown when <paramref name="value"/> is not a valid integer.</exception>
+    public static ByteSize Parse(string value)
+    {
+        ArgumentNullException.ThrowIfNull(value);
+        if (long.TryParse(
+                value.Trim(),
+                NumberStyles.Integer,
+                CultureInfo.InvariantCulture,
+                out var longValue))
+        {
+            return new ByteSize(longValue);
+        }
+
+        throw new FormatException(
+            $"The value '{value}' is not a valid byte size.");
+    }
+
+    /// <summary>
+    /// Tries to parse a string into a <see cref="ByteSize"/>.
+    /// </summary>
+    /// <param name="value">The string to parse, or <see langword="null"/>.</param>
+    /// <param name="result">
+    /// When this method returns, contains the parsed <see cref="ByteSize"/>
+    /// if parsing succeeded; otherwise, <see langword="default"/>.
+    /// </param>
+    /// <returns><see langword="true"/> if parsing succeeded; otherwise, <see langword="false"/>.</returns>
+    public static bool TryParse(
+        string? value,
+        out ByteSize result)
+    {
+        result = default;
+        if (value is null)
+        {
+            return false;
+        }
+
+        if (long.TryParse(
+                value.Trim(),
+                NumberStyles.Integer,
+                CultureInfo.InvariantCulture,
+                out var longValue))
+        {
+            result = new ByteSize(longValue);
+            return true;
+        }
+
+        return false;
+    }
+
     /// <summary>
     /// Equals the specified other.
     /// </summary>
@@ -166,6 +287,43 @@ public override readonly bool Equals(object? obj)
     /// <inheritdoc />
     public override readonly int GetHashCode() => Value.GetHashCode();
 
+    /// <summary>
+    /// Compares this instance to another <see cref="ByteSize"/> value.
+    /// </summary>
+    /// <param name="other">The other value to compare to.</param>
+    /// <returns>
+    /// A negative number if this instance is less than <paramref name="other"/>;
+    /// zero if they are equal; a positive number if this instance is greater.
+    /// </returns>
+    public readonly int CompareTo(ByteSize other)
+        => Value.CompareTo(other.Value);
+
+    /// <summary>
+    /// Compares this instance to another object.
+    /// </summary>
+    /// <param name="obj">An object to compare to, or <see langword="null"/>.</param>
+    /// <returns>
+    /// A negative number if this instance is less than <paramref name="obj"/>;
+    /// zero if they are equal; a positive number if this instance is greater.
+    /// </returns>
+    /// <exception cref="ArgumentException">Thrown when <paramref name="obj"/> is not a <see cref="ByteSize"/>.</exception>
+    public readonly int CompareTo(object? obj)
+    {
+        if (obj is null)
+        {
+            return 1;
+        }
+
+        if (obj is ByteSize other)
+        {
+            return CompareTo(other);
+        }
+
+        throw new ArgumentException(
+            "Object must be of type ByteSize.",
+            nameof(obj));
+    }
+
     /// <summary>
     /// Returns a <see cref="string" /> that represents this instance.
     /// </summary>
diff --git a/src/Atc/Units/DigitalInformation/ByteSizeCalculationData.cs b/src/Atc/Units/DigitalInformation/ByteSizeCalculationData.cs
index df5f3100..966248b2 100644
--- a/src/Atc/Units/DigitalInformation/ByteSizeCalculationData.cs
+++ b/src/Atc/Units/DigitalInformation/ByteSizeCalculationData.cs
@@ -49,4 +49,19 @@ internal static class ByteSizeCalculationData
         "Peta",
         "Exa",
     };
+
+    /// <summary>
+    /// IEC binary prefix strings (empty, "Ki", "Mi", "Gi", "Ti", "Pi", "Ei").
+    /// Used with the "B" suffix to produce "KiB", "MiB", etc.
+    /// </summary>
+    internal static readonly string[] PrefixesShortBinary =
+    {
+        string.Empty,
+        "Ki",
+        "Mi",
+        "Gi",
+        "Ti",
+        "Pi",
+        "Ei",
+    };
 }
\ No newline at end of file
diff --git a/src/Atc/Units/DigitalInformation/ByteSizeFormatter.cs b/src/Atc/Units/DigitalInformation/ByteSizeFormatter.cs
index 57fa3f9f..a71f798d 100644
--- a/src/Atc/Units/DigitalInformation/ByteSizeFormatter.cs
+++ b/src/Atc/Units/DigitalInformation/ByteSizeFormatter.cs
@@ -114,9 +114,12 @@ public string Format(long size)
             return displaySizeStr;
         }
 
-        var prefixes = SuffixFormat == ByteSizeSuffixType.Full
-            ? ByteSizeCalculationData.PrefixesFull
-            : ByteSizeCalculationData.PrefixesShort;
+        var prefixes = SuffixFormat switch
+        {
+            ByteSizeSuffixType.Full => ByteSizeCalculationData.PrefixesFull,
+            ByteSizeSuffixType.ShortBinary => ByteSizeCalculationData.PrefixesShortBinary,
+            _ => ByteSizeCalculationData.PrefixesShort,
+        };
 
         var suffixLastPart = BuildSuffixLastPart(size, prefixIndex, displaySize);
 
diff --git a/src/Atc/Units/DigitalInformation/Enums/ByteSizeSuffixType.cs b/src/Atc/Units/DigitalInformation/Enums/ByteSizeSuffixType.cs
index f687df42..4a3d6a6e 100644
--- a/src/Atc/Units/DigitalInformation/Enums/ByteSizeSuffixType.cs
+++ b/src/Atc/Units/DigitalInformation/Enums/ByteSizeSuffixType.cs
@@ -21,4 +21,10 @@ public enum ByteSizeSuffixType
     /// Full suffix format (e.g., "byte", "Kilobyte", "Megabyte", "Gigabyte").
     /// </summary>
     Full,
+
+    /// <summary>
+    /// Short IEC binary suffix format (e.g., "B", "KiB", "MiB", "GiB").
+    /// Uses IEC 80000-13 notation to distinguish 1024-based units from SI decimal units.
+    /// </summary>
+    ShortBinary,
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Exceptions/ConfigurationExceptionTests.cs b/test/Atc.Tests/Exceptions/ConfigurationExceptionTests.cs
new file mode 100644
index 00000000..40b9acb6
--- /dev/null
+++ b/test/Atc.Tests/Exceptions/ConfigurationExceptionTests.cs
@@ -0,0 +1,24 @@
+namespace Atc.Tests.Exceptions;
+
+public class ConfigurationExceptionTests
+{
+    [Fact]
+    public void ThrowIfMissing_WithPresentValue_DoesNotThrow()
+    {
+        string value = "present-value";
+        string section = "MySection";
+        string key = "MyKey";
+        ConfigurationException.ThrowIfMissing(value, section, key);
+        Assert.NotEmpty(value);
+    }
+
+    [Fact]
+    public void ThrowIfInvalid_WhenConditionFalse_DoesNotThrow()
+    {
+        bool condition = false;
+        string section = "MySection";
+        string key = "MyKey";
+        ConfigurationException.ThrowIfInvalid(condition, section, key);
+        Assert.False(condition);
+    }
+}
\ No newline at end of file
diff --git a/test/Atc.Tests/Exceptions/ExceptionsTests.cs b/test/Atc.Tests/Exceptions/ExceptionsTests.cs
index 1905247f..67a40896 100644
--- a/test/Atc.Tests/Exceptions/ExceptionsTests.cs
+++ b/test/Atc.Tests/Exceptions/ExceptionsTests.cs
@@ -433,7 +433,7 @@ public void SwitchCaseDefaultException_EnumValueAndMessage_ContainsAllParts()
     [Fact]
     public void SwitchCaseDefaultException_ObjectValue_ContainsTypeAndValue()
     {
-        var sut = new SwitchCaseDefaultException("unexpected");
+        var sut = new SwitchCaseDefaultException((object?)"unexpected");
         Assert.Contains("String", sut.Message, StringComparison.Ordinal);
         Assert.Contains("unexpected", sut.Message, StringComparison.Ordinal);
     }
diff --git a/test/Atc.Tests/Exceptions/SwitchCaseDefaultExceptionTests.cs b/test/Atc.Tests/Exceptions/SwitchCaseDefaultExceptionTests.cs
new file mode 100644
index 00000000..37fdea71
--- /dev/null
+++ b/test/Atc.Tests/Exceptions/SwitchCaseDefaultExceptionTests.cs
@@ -0,0 +1,38 @@
+namespace Atc.Tests.Exceptions;
+
+public class SwitchCaseDefaultExceptionTests
+{
+    [Fact]
+    public void Throw_WithEnumValue_ThrowsWithEnumDetails()
+    {
+        Enum enumValue = DayOfWeek.Monday;
+        try
+        {
+            SwitchCaseDefaultException.Throw(enumValue);
+        }
+        catch (SwitchCaseDefaultException ex)
+        {
+            Assert.Contains("Monday", ex.Message, StringComparison.Ordinal);
+            return;
+        }
+
+        Assert.Fail("Expected SwitchCaseDefaultException to be thrown.");
+    }
+
+    [Fact]
+    public void Throw_WithObjectValue_ThrowsWithDetails()
+    {
+        object value = "unexpected-value";
+        try
+        {
+            SwitchCaseDefaultException.Throw(value);
+        }
+        catch (SwitchCaseDefaultException ex)
+        {
+            Assert.Contains("unexpected-value", ex.Message, StringComparison.Ordinal);
+            return;
+        }
+
+        Assert.Fail("Expected SwitchCaseDefaultException to be thrown.");
+    }
+}
\ No newline at end of file
diff --git a/test/Atc.Tests/Units/DigitalInformation/ByteSizeFormatterTests.cs b/test/Atc.Tests/Units/DigitalInformation/ByteSizeFormatterTests.cs
index e7590c50..b6e969e8 100644
--- a/test/Atc.Tests/Units/DigitalInformation/ByteSizeFormatterTests.cs
+++ b/test/Atc.Tests/Units/DigitalInformation/ByteSizeFormatterTests.cs
@@ -218,7 +218,7 @@ public void Format_Rounding_Down(
     [InlineData("1,536 B", 1024L + 512, 0, ByteSizeUnitType.Byte, ByteSizeUnitType.Byte, GlobalizationLcidConstants.UnitedStates)]
     [InlineData("2,048 B", 2 * 1024L, 0, ByteSizeUnitType.Byte, ByteSizeUnitType.Byte, GlobalizationLcidConstants.UnitedStates)]
     [InlineData("378,630,729,272 B", 378630729272, 0, ByteSizeUnitType.Byte, ByteSizeUnitType.Byte, GlobalizationLcidConstants.UnitedStates)]
-    public void Format_MinMax(
+    public void Format_MinMax_Units(
         string expected,
         long size,
         int numberOfDecimals,
@@ -241,4 +241,30 @@ public void Format_MinMax(
         // Assert
         Assert.Equal(expected, actual);
     }
+
+    [Theory]
+    [InlineData("1 B", 1)]
+    [InlineData("1 KiB", 1024L)]
+    [InlineData("2 KiB", 2 * 1024L)]
+    [InlineData("1 MiB", 1024L * 1024L)]
+    [InlineData("1 GiB", 1024L * 1024L * 1024L)]
+    [InlineData("1 TiB", 1024L * 1024L * 1024L * 1024L)]
+    [InlineData("1 PiB", 1024L * 1024L * 1024L * 1024L * 1024L)]
+    [InlineData("1 EiB", 1024L * 1024L * 1024L * 1024L * 1024L * 1024L)]
+    public void Format_Suffix_ShortBinary(
+        string expected,
+        long size)
+    {
+        // Arrange
+        var formatter = new ByteSizeFormatter
+        {
+            SuffixFormat = ByteSizeSuffixType.ShortBinary,
+        };
+
+        // Atc
+        var actual = formatter.Format(size);
+
+        // Assert
+        Assert.Equal(expected, actual);
+    }
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Units/DigitalInformation/ByteSizeTests.cs b/test/Atc.Tests/Units/DigitalInformation/ByteSizeTests.cs
index 05bd4405..ebc08194 100644
--- a/test/Atc.Tests/Units/DigitalInformation/ByteSizeTests.cs
+++ b/test/Atc.Tests/Units/DigitalInformation/ByteSizeTests.cs
@@ -77,4 +77,110 @@ public void GetHashCode_AllowsReliableUseAsHashSetKey()
         Assert.Contains(new ByteSize(2048), set);
         Assert.DoesNotContain(new ByteSize(4096), set);
     }
+
+    [Theory]
+    [InlineData(-1, 1024, 2048)]
+    [InlineData(1, 2048, 1024)]
+    [InlineData(0, 512, 512)]
+    public void CompareTo_OrdersCorrectly(
+        int expectedSign,
+        long a,
+        long b)
+    {
+        // Arrange
+        var left = new ByteSize(a);
+        var right = new ByteSize(b);
+
+        // Atc
+        var actual = System.Math.Sign(left.CompareTo(right));
+
+        // Assert
+        Assert.Equal(expectedSign, actual);
+    }
+
+    [Fact]
+    public void CompareTo_WithObject_OrdersCorrectly()
+    {
+        // Arrange
+        var small = new ByteSize(512);
+        var large = new ByteSize(2048);
+        object boxedSmall = small;
+        object boxedLarge = large;
+
+        // Atc & Assert
+        Assert.True(small.CompareTo(boxedSmall) == 0);
+        Assert.True(small.CompareTo(boxedLarge) < 0);
+        Assert.True(large.CompareTo(boxedSmall) > 0);
+        Assert.Throws<ArgumentException>(() => small.CompareTo("not a ByteSize"));
+    }
+
+    [Fact]
+    public void ComparisonOperators_WorkCorrectly()
+    {
+        var small = new ByteSize(100);
+        var large = new ByteSize(200);
+        Assert.True(small < large);
+        Assert.True(small <= large);
+        Assert.True(large > small);
+        Assert.True(large >= small);
+        Assert.False(small > large);
+    }
+
+    [Fact]
+    public void ArithmeticOperators_AddAndSubtract()
+    {
+        var a = new ByteSize(1024);
+        var b = new ByteSize(512);
+        Assert.Equal(1536L, (a + b).Value);
+        Assert.Equal(512L, (a - b).Value);
+    }
+
+    [Fact]
+    public void TryParse_WithValidInput_ReturnsTrueAndValue()
+    {
+        // Arrange
+        string value = "4096";
+
+        // Atc
+        var ok = ByteSize.TryParse(value, out var result);
+
+        // Assert
+        Assert.True(ok);
+        Assert.Equal(4096L, result.Value);
+    }
+
+    [Theory]
+    [InlineData(true, "1024", 1024)]
+    [InlineData(true, "-512", -512)]
+    [InlineData(true, "  0  ", 0)]
+    [InlineData(false, "1.5", 0)]
+    [InlineData(false, "abc", 0)]
+    [InlineData(false, null, 0)]
+    public void TryParse(
+        bool expectedResult,
+        string? input,
+        long expectedValue)
+    {
+        var ok = ByteSize.TryParse(input, out var result);
+        Assert.Equal(expectedResult, ok);
+        if (ok)
+        {
+            Assert.Equal(expectedValue, result.Value);
+        }
+    }
+
+    [Fact]
+    public void Parse_ValidString_ReturnsByteSize()
+    {
+        var result = ByteSize.Parse("4096");
+        Assert.Equal(4096L, result.Value);
+    }
+
+    [Fact]
+    public void Parse_InvalidString_ThrowsFormatException()
+        => Assert.Throws<FormatException>(() => ByteSize.Parse("not-a-number"));
+
+    [Fact]
+    public void Parse_NullString_ThrowsArgumentNullException()
+        => Assert.Throws<ArgumentNullException>(() => ByteSize.Parse(null!));
 }
\ No newline at end of file

From f56c11c1431939522e99ecc196a36ab17809f1ae Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 14:40:40 +0200
Subject: [PATCH 068/100] feat(atc): add netstandard2.0 fallbacks for
 DictionaryExtensions GetOrAdd and TryUpdate

Consumers targeting netstandard2.0 previously got an empty class because
all four methods (GetOrAdd/value, GetOrAdd/factory, TryUpdate/value,
TryUpdate/factory) were gated behind #if NET9_0_OR_GREATER to use the
CollectionsMarshal fast paths.

The #else block provides TryGetValue/ContainsKey-based fallbacks that are
fully compatible with netstandard2.0 and semantically identical.
---
 src/Atc/Extensions/DictionaryExtensions.cs | 127 +++++++++++++++++++++
 1 file changed, 127 insertions(+)

diff --git a/src/Atc/Extensions/DictionaryExtensions.cs b/src/Atc/Extensions/DictionaryExtensions.cs
index 2f414813..4e1e5ede 100644
--- a/src/Atc/Extensions/DictionaryExtensions.cs
+++ b/src/Atc/Extensions/DictionaryExtensions.cs
@@ -112,5 +112,132 @@ public static bool TryUpdate<TKey, TValue>(
         dictionaryValue = valueFactory(key, dictionaryValue);
         return true;
     }
+#else
+    /// <summary>
+    /// Retrieves the value associated with the specified key or adds a new value if the key does not exist.
+    /// </summary>
+    /// <typeparam name="TKey">The type of the dictionary keys.</typeparam>
+    /// <typeparam name="TValue">The type of the dictionary values.</typeparam>
+    /// <param name="dict">The dictionary instance.</param>
+    /// <param name="key">The key whose value to get or add.</param>
+    /// <param name="value">The value to add if the key does not exist.</param>
+    /// <returns>The existing or newly added value.</returns>
+    public static TValue GetOrAdd<TKey, TValue>(
+        this Dictionary<TKey, TValue> dict,
+        TKey key,
+        TValue value)
+        where TKey : notnull
+    {
+        if (dict is null)
+        {
+            throw new ArgumentNullException(nameof(dict));
+        }
+
+        if (dict.TryGetValue(key, out var existing))
+        {
+            return existing;
+        }
+
+        dict.Add(key, value);
+        return value;
+    }
+
+    /// <summary>
+    /// Retrieves the value associated with the specified key or adds a new value generated by the provided factory function if the key does not exist.
+    /// </summary>
+    /// <typeparam name="TKey">The type of the dictionary keys.</typeparam>
+    /// <typeparam name="TValue">The type of the dictionary values.</typeparam>
+    /// <param name="dict">The dictionary instance.</param>
+    /// <param name="key">The key whose value to get or add.</param>
+    /// <param name="valueFactory">A function to generate the value if the key does not exist.</param>
+    /// <returns>The existing or newly added value.</returns>
+    public static TValue GetOrAdd<TKey, TValue>(
+        this Dictionary<TKey, TValue> dict,
+        TKey key,
+        Func<TKey, TValue> valueFactory)
+        where TKey : notnull
+    {
+        if (dict is null)
+        {
+            throw new ArgumentNullException(nameof(dict));
+        }
+
+        if (valueFactory is null)
+        {
+            throw new ArgumentNullException(nameof(valueFactory));
+        }
+
+        if (dict.TryGetValue(key, out var existing))
+        {
+            return existing;
+        }
+
+        var newValue = valueFactory(key);
+        dict.Add(key, newValue);
+        return newValue;
+    }
+
+    /// <summary>
+    /// Attempts to update the value of an existing key in the dictionary.
+    /// </summary>
+    /// <typeparam name="TKey">The type of the dictionary keys.</typeparam>
+    /// <typeparam name="TValue">The type of the dictionary values.</typeparam>
+    /// <param name="dict">The dictionary instance.</param>
+    /// <param name="key">The key whose value should be updated.</param>
+    /// <param name="value">The new value to assign.</param>
+    /// <returns><c>true</c> if the key exists and the value was updated; otherwise, <c>false</c>.</returns>
+    public static bool TryUpdate<TKey, TValue>(
+        this Dictionary<TKey, TValue> dict,
+        TKey key,
+        TValue value)
+        where TKey : notnull
+    {
+        if (dict is null)
+        {
+            throw new ArgumentNullException(nameof(dict));
+        }
+
+        if (!dict.ContainsKey(key))
+        {
+            return false;
+        }
+
+        dict[key] = value;
+        return true;
+    }
+
+    /// <summary>
+    /// Attempts to update the value of an existing key in the dictionary using a factory function.
+    /// </summary>
+    /// <typeparam name="TKey">The type of the dictionary keys.</typeparam>
+    /// <typeparam name="TValue">The type of the dictionary values.</typeparam>
+    /// <param name="dict">The dictionary instance.</param>
+    /// <param name="key">The key whose value should be updated.</param>
+    /// <param name="valueFactory">A function to generate the new value based on the existing value.</param>
+    /// <returns><c>true</c> if the key exists and the value was updated; otherwise, <c>false</c>.</returns>
+    public static bool TryUpdate<TKey, TValue>(
+        this Dictionary<TKey, TValue> dict,
+        TKey key,
+        Func<TKey, TValue, TValue> valueFactory)
+        where TKey : notnull
+    {
+        if (dict is null)
+        {
+            throw new ArgumentNullException(nameof(dict));
+        }
+
+        if (valueFactory is null)
+        {
+            throw new ArgumentNullException(nameof(valueFactory));
+        }
+
+        if (!dict.TryGetValue(key, out var existing))
+        {
+            return false;
+        }
+
+        dict[key] = valueFactory(key, existing);
+        return true;
+    }
 #endif
 }
\ No newline at end of file

From 361de745f4a2b964cbb6177eedf256df18d8b3d9 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 14:43:48 +0200
Subject: [PATCH 069/100] fix(atc): use Convert.ToInt64 in EnumHelper flag-skip
 logic; add long.IsBinarySequence

ShouldEnumValueBeSkipped used Convert.ToInt32 to read boxed enum values,
throwing OverflowException for [Flags] enums whose backing type is long
and whose values exceed int.MaxValue.

Changed all three ToInt32 calls in that private helper to ToInt64 and
changed the local variable type from int to long. Added IsBinarySequence
as a long extension to support the flag-bit check on the wider type.
---
 src/Atc/Extensions/BaseTypes/LongExtensions.cs  |  8 ++++++++
 src/Atc/Helpers/Enums/EnumHelper.cs             |  6 +++---
 .../Extensions/BaseTypes/LongExtensionsTests.cs | 17 +++++++++++++++++
 3 files changed, 28 insertions(+), 3 deletions(-)

diff --git a/src/Atc/Extensions/BaseTypes/LongExtensions.cs b/src/Atc/Extensions/BaseTypes/LongExtensions.cs
index 584dd0ac..3e6eac95 100644
--- a/src/Atc/Extensions/BaseTypes/LongExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/LongExtensions.cs
@@ -27,4 +27,12 @@ public static DateTimeOffset FromUnixTime(this long valueInSeconds)
     /// ]]></example>
     public static DateTimeOffset FromUnixTimeMs(this long valueInMs)
         => DateTimeOffset.FromUnixTimeMilliseconds(valueInMs);
+
+    /// <summary>
+    /// Determines whether the value is a binary sequence (a power of two), meaning exactly one bit is set.
+    /// </summary>
+    /// <param name="number">The number to evaluate.</param>
+    /// <returns><see langword="true" /> if <paramref name="number"/> is a positive power of two; otherwise, <see langword="false" />.</returns>
+    public static bool IsBinarySequence(this long number)
+        => number > 0 && (number & (number - 1)) == 0;
 }
\ No newline at end of file
diff --git a/src/Atc/Helpers/Enums/EnumHelper.cs b/src/Atc/Helpers/Enums/EnumHelper.cs
index 1e98d642..dc727ae7 100644
--- a/src/Atc/Helpers/Enums/EnumHelper.cs
+++ b/src/Atc/Helpers/Enums/EnumHelper.cs
@@ -636,7 +636,7 @@ private static bool ShouldEnumValueBeSkipped(
         bool byFlagIncludeBase,
         bool byFlagIncludeCombined)
     {
-        if (!includeDefault && Convert.ToInt32(objEnumValue, CultureInfo.InvariantCulture) == 0)
+        if (!includeDefault && Convert.ToInt64(objEnumValue, CultureInfo.InvariantCulture) == 0L)
         {
             return true;
         }
@@ -646,7 +646,7 @@ private static bool ShouldEnumValueBeSkipped(
             return false;
         }
 
-        var n = Convert.ToInt32(objEnumValue, CultureInfo.InvariantCulture);
+        var n = Convert.ToInt64(objEnumValue, CultureInfo.InvariantCulture);
         if (!byFlagIncludeBase && n.IsBinarySequence())
         {
             return true;
@@ -662,6 +662,6 @@ private static bool ShouldEnumValueBeSkipped(
             return false;
         }
 
-        return !includeDefault || Convert.ToInt32(objEnumValue, CultureInfo.InvariantCulture) != 0;
+        return !includeDefault || Convert.ToInt64(objEnumValue, CultureInfo.InvariantCulture) != 0L;
     }
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Extensions/BaseTypes/LongExtensionsTests.cs b/test/Atc.Tests/Extensions/BaseTypes/LongExtensionsTests.cs
index 860433b9..50824953 100644
--- a/test/Atc.Tests/Extensions/BaseTypes/LongExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/BaseTypes/LongExtensionsTests.cs
@@ -44,6 +44,23 @@ public void FromUnixTimeMs(
         Assert.Equal(expectedDateTimeOffset, actual);
     }
 
+    [Theory]
+    [InlineData(true, 1L)]
+    [InlineData(true, 2L)]
+    [InlineData(true, 4L)]
+    [InlineData(true, 1L << 32)]
+    [InlineData(true, 1L << 62)]
+    [InlineData(false, 0L)]
+    [InlineData(false, 3L)]
+    [InlineData(false, 6L)]
+    [InlineData(false, -1L)]
+    public void IsBinarySequence(
+        bool expected,
+        long input)
+    {
+        Assert.Equal(expected, input.IsBinarySequence());
+    }
+
     [Theory]
     [InlineData(500, 1970, 1, 1, 0, 0, 0, 500)]
     [InlineData(1500, 1970, 1, 1, 0, 0, 1, 500)]

From 35078612fc655bf3d68df406757d6caac7bd1670 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 14:48:12 +0200
Subject: [PATCH 070/100] perf(atc): replace Math.Pow(x,2) with repeated
 multiplication in math helpers

Math.Pow uses logarithms internally, introducing a small but unnecessary
floating-point error and extra overhead for exact integer exponents.

Replace Math.Pow(x,2) with x*x in CircleHelper, TriangleHelper, and
CartesianHelper. In the UTM converter also replace Pow(x,3..6) by building
each power from the previous one, and replace hard-coded 0.9996/500000.0
literals with the existing UTM_FAKTOR/UTM_FALSE_EASTING constants.
---
 .../UniversalTransverseMercatorConverter.cs   | 26 ++++++++---------
 src/Atc/Math/Geometry/CircleHelper.cs         |  2 +-
 .../CoordinateSystem/CartesianHelper.cs       | 28 ++++++-------------
 src/Atc/Math/Geometry/TriangleHelper.cs       | 12 ++++++--
 4 files changed, 32 insertions(+), 36 deletions(-)

diff --git a/src/Atc/Math/GeoSpatial/UniversalTransverseMercatorConverter.cs b/src/Atc/Math/GeoSpatial/UniversalTransverseMercatorConverter.cs
index f858b6ed..9e2e839a 100644
--- a/src/Atc/Math/GeoSpatial/UniversalTransverseMercatorConverter.cs
+++ b/src/Atc/Math/GeoSpatial/UniversalTransverseMercatorConverter.cs
@@ -125,11 +125,11 @@ public UniversalTransverseMercatorResult ToUtm(
             + (15 * eccSquared * eccSquared / 256 + 45 * eccSquared * eccSquared * eccSquared / 1024) *
             System.Math.Sin(4 * latitudeRadian) - 35 * eccSquared * eccSquared * eccSquared / 3072 * System.Math.Sin(6 * latitudeRadian));
 
-        var utmEasting = 0.9996 * N * (A + (1 - T + C) * A * A * A / 6
+        var utmEasting = UTM_FAKTOR * N * (A + (1 - T + C) * A * A * A / 6
                                          + (5 - 18 * T + T * T + 72 * C - 58 * eccPrimeSquared) * A * A * A * A * A / 120)
-                         + 500000.0;
+                         + UTM_FALSE_EASTING;
 
-        var utmNorthing = 0.9996 * (M + N * System.Math.Tan(latitudeRadian) * (A * A / 2 + (5 - T + 9 * C + 4 * C * C) * A * A * A * A / 24
+        var utmNorthing = UTM_FAKTOR * (M + N * System.Math.Tan(latitudeRadian) * (A * A / 2 + (5 - T + 9 * C + 4 * C * C) * A * A * A * A / 24
             + (61 - 58 * T + T * T + 600 * C - 330 * eccPrimeSquared) * A * A * A * A * A * A / 720));
 
         if (latitude < 0)
@@ -200,20 +200,20 @@ public CartesianCoordinate ToWgs84(
 
         // Transverse curvature
         var qkhm1 = WGS84_POL / System.Math.Sqrt(1 + eta);
-        var qkhm2 = System.Math.Pow(qkhm1, 2);
-        var qkhm3 = System.Math.Pow(qkhm1, 3);
-        var qkhm4 = System.Math.Pow(qkhm1, 4);
-        var qkhm5 = System.Math.Pow(qkhm1, 5);
-        var qkhm6 = System.Math.Pow(qkhm1, 6);
+        var qkhm2 = qkhm1 * qkhm1;
+        var qkhm3 = qkhm2 * qkhm1;
+        var qkhm4 = qkhm2 * qkhm2;
+        var qkhm5 = qkhm4 * qkhm1;
+        var qkhm6 = qkhm3 * qkhm3;
 
         // Difference to the reference meridian
         var merid = (utmZoneNumber - 30) * 6 - 3;
         var dlongitude1 = (utmEasting - UTM_FALSE_EASTING) / UTM_FAKTOR;
-        var dlongitude2 = System.Math.Pow(dlongitude1, 2);
-        var dlongitude3 = System.Math.Pow(dlongitude1, 3);
-        var dlongitude4 = System.Math.Pow(dlongitude1, 4);
-        var dlongitude5 = System.Math.Pow(dlongitude1, 5);
-        var dlongitude6 = System.Math.Pow(dlongitude1, 6);
+        var dlongitude2 = dlongitude1 * dlongitude1;
+        var dlongitude3 = dlongitude2 * dlongitude1;
+        var dlongitude4 = dlongitude2 * dlongitude2;
+        var dlongitude5 = dlongitude4 * dlongitude1;
+        var dlongitude6 = dlongitude3 * dlongitude3;
 
         // Factors for latitude calculation
         var bfakt2 = -tangens1 * (1 + eta) / (2 * qkhm2);
diff --git a/src/Atc/Math/Geometry/CircleHelper.cs b/src/Atc/Math/Geometry/CircleHelper.cs
index 80564b96..7a567ace 100644
--- a/src/Atc/Math/Geometry/CircleHelper.cs
+++ b/src/Atc/Math/Geometry/CircleHelper.cs
@@ -11,7 +11,7 @@ public static class CircleHelper
     /// <param name="radius">The radius of the circle.</param>
     /// <returns>The area of the circle (π * r²).</returns>
     public static double Area(double radius)
-        => System.Math.PI * System.Math.Pow(radius, 2);
+        => System.Math.PI * radius * radius;
 
     /// <summary>
     /// Calculates the circumference of a circle given its radius.
diff --git a/src/Atc/Math/Geometry/CoordinateSystem/CartesianHelper.cs b/src/Atc/Math/Geometry/CoordinateSystem/CartesianHelper.cs
index a9863e6a..affe255b 100644
--- a/src/Atc/Math/Geometry/CoordinateSystem/CartesianHelper.cs
+++ b/src/Atc/Math/Geometry/CoordinateSystem/CartesianHelper.cs
@@ -74,17 +74,9 @@ public static double DistanceBetweenTwoPoints(
         double x2,
         double y2)
     {
-        // Take x2-x1, then square it
-        var part1 = System.Math.Pow(x2 - x1, 2);
-
-        // Take y2-y1, then square it
-        var part2 = System.Math.Pow(y2 - y1, 2);
-
-        // Add both of the parts together
-        var underRadical = part1 + part2;
-
-        // Get the square root of the parts
-        return System.Math.Sqrt(underRadical);
+        var dx = x2 - x1;
+        var dy = y2 - y1;
+        return System.Math.Sqrt((dx * dx) + (dy * dy));
     }
 
     /// <summary>
@@ -106,14 +98,12 @@ public static double DistanceBetweenTwoPoints(
         double y2,
         double z2)
     {
-        // Take x2-x1, then square it
-        var part1 = System.Math.Pow(x2 - x1, 2);
-
-        // Take y2-y1, then square it
-        var part2 = System.Math.Pow(y2 - y1, 2);
-
-        // Take z2-z1, then square it
-        var part3 = System.Math.Pow(z2 - z1, 2);
+        var dx = x2 - x1;
+        var dy = y2 - y1;
+        var dz = z2 - z1;
+        var part1 = dx * dx;
+        var part2 = dy * dy;
+        var part3 = dz * dz;
 
         // Add both of the parts together
         var underRadical = part1 + part2 + part3;
diff --git a/src/Atc/Math/Geometry/TriangleHelper.cs b/src/Atc/Math/Geometry/TriangleHelper.cs
index e211a49f..424fbc5d 100644
--- a/src/Atc/Math/Geometry/TriangleHelper.cs
+++ b/src/Atc/Math/Geometry/TriangleHelper.cs
@@ -73,7 +73,9 @@ public static double Pythagorean(
         if (sideA is null && sideB is not null && sideC is not null)
         {
             // Calc sideA
-            var radicand = System.Math.Pow((double)sideC, 2) - System.Math.Pow((double)sideB, 2);
+            var c = (double)sideC;
+            var b = (double)sideB;
+            var radicand = (c * c) - (b * b);
             if (radicand < 0)
             {
                 throw new ArithmeticException("The given side lengths do not form a valid right triangle.");
@@ -85,7 +87,9 @@ public static double Pythagorean(
         if (sideA is not null && sideB is null && sideC is not null)
         {
             // Calc sideB
-            var radicand = System.Math.Pow((double)sideC, 2) - System.Math.Pow((double)sideA, 2);
+            var c = (double)sideC;
+            var a = (double)sideA;
+            var radicand = (c * c) - (a * a);
             if (radicand < 0)
             {
                 throw new ArithmeticException("The given side lengths do not form a valid right triangle.");
@@ -97,7 +101,9 @@ public static double Pythagorean(
         if (sideA is not null && sideB is not null && sideC is null)
         {
             // Calc sideC
-            return System.Math.Sqrt(System.Math.Pow((double)sideA, 2) + System.Math.Pow((double)sideB, 2));
+            var a = (double)sideA;
+            var b = (double)sideB;
+            return System.Math.Sqrt((a * a) + (b * b));
         }
 
         throw new ArithmeticException("Expected early return - Bad implementation.");

From 338ceb23f34ff56fcb5fae8821b26648b4f53bfb Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 14:52:48 +0200
Subject: [PATCH 071/100] feat(atc): add JsonSerializerOptionsFactory.Default
 cached preset

Callers that use the default settings and never mutate the options can
reference the shared lazy-initialized instance instead of calling Create()
on every request, avoiding repeated option construction and STJ metadata
re-discovery on hot paths (FileHelper, JsonSerializerHelper, DynamicJson).

Create() is unchanged; Default is an explicit opt-in so no existing
behavior is silently changed.
---
 src/Atc/Serialization/JsonSerializerOptionsFactory.cs | 11 +++++++++++
 .../JsonSerializerOptionsFactoryTests.cs              | 10 ++++++++++
 2 files changed, 21 insertions(+)

diff --git a/src/Atc/Serialization/JsonSerializerOptionsFactory.cs b/src/Atc/Serialization/JsonSerializerOptionsFactory.cs
index 8a658b99..132646d8 100644
--- a/src/Atc/Serialization/JsonSerializerOptionsFactory.cs
+++ b/src/Atc/Serialization/JsonSerializerOptionsFactory.cs
@@ -10,6 +10,17 @@ namespace Atc.Serialization;
 /// </remarks>
 public static class JsonSerializerOptionsFactory
 {
+    private static readonly Lazy<JsonSerializerOptions> LazyDefault =
+        new(() => Create(), LazyThreadSafetyMode.ExecutionAndPublication);
+
+    /// <summary>
+    /// Gets a cached, shared <see cref="JsonSerializerOptions"/> instance using the default settings
+    /// (camelCase, null-values ignored, case-insensitive names, indented output).
+    /// The instance is created once and reused; after the first serialization call it becomes read-only.
+    /// Use <see cref="Create(bool,bool,bool,bool)"/> when you need a mutable copy.
+    /// </summary>
+    public static JsonSerializerOptions Default => LazyDefault.Value;
+
     /// <summary>
     /// Creates a new <see cref="JsonSerializerOptions"/> instance with the specified parameters.
     /// </summary>
diff --git a/test/Atc.Tests/Serialization/JsonSerializerOptionsFactoryTests.cs b/test/Atc.Tests/Serialization/JsonSerializerOptionsFactoryTests.cs
index 32e73852..0e4a9b52 100644
--- a/test/Atc.Tests/Serialization/JsonSerializerOptionsFactoryTests.cs
+++ b/test/Atc.Tests/Serialization/JsonSerializerOptionsFactoryTests.cs
@@ -67,4 +67,14 @@ public void Create_WithNullSettings_ThrowsArgumentNullException()
         // Act & Assert
         Assert.Throws<ArgumentNullException>(() => JsonSerializerOptionsFactory.Create(null!));
     }
+
+    [Fact]
+    public void Default_ReturnsSameInstance()
+    {
+        var first = JsonSerializerOptionsFactory.Default;
+        var second = JsonSerializerOptionsFactory.Default;
+        Assert.Same(first, second);
+        Assert.Equal(JsonNamingPolicy.CamelCase, first.PropertyNamingPolicy);
+        Assert.True(first.WriteIndented);
+    }
 }
\ No newline at end of file

From 9d2d67c9d6f5e5d68d867ff128920d46f607950a Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 14:55:41 +0200
Subject: [PATCH 072/100] perf(atc-console-spectre): pre-escape categoryName
 once in ConsoleLogger ctor

Markup.Escape(categoryName) was called inside GetCategoryNameWithMarkup()
on every log write. Since categoryName is immutable after construction,
store the escaped form in a readonly field and reference it directly.
---
 src/Atc.Console.Spectre/Logging/ConsoleLogger.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs b/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs
index 03b7469a..a856ed5b 100644
--- a/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs
+++ b/src/Atc.Console.Spectre/Logging/ConsoleLogger.cs
@@ -12,6 +12,7 @@ namespace Atc.Console.Spectre.Logging;
 public class ConsoleLogger : ILogger
 {
     private readonly string categoryName;
+    private readonly string escapedCategoryName;
     private readonly ConsoleLoggerConfiguration config;
     private readonly IAnsiConsole console;
 
@@ -30,6 +31,7 @@ public ConsoleLogger(
         IAnsiConsole console)
     {
         this.categoryName = categoryName;
+        this.escapedCategoryName = Markup.Escape(categoryName ?? string.Empty);
         this.config = config ?? throw new ArgumentNullException(nameof(config));
         this.console = console ?? throw new ArgumentNullException(nameof(console));
     }
@@ -334,7 +336,7 @@ private string GetTimeStampWithMarkup()
         => $"[white]{GetTimeStamp()}[/]";
 
     private string GetCategoryNameWithMarkup()
-        => $"[grey]{Markup.Escape(categoryName)}[/]";
+        => $"[grey]{escapedCategoryName}[/]";
 
     private string GetTimeStampAndCategoryNameWithMarkup()
         => $"{GetTimeStampWithMarkup()} {GetCategoryNameWithMarkup()}";

From f255b1e30b6800789b7107ab1ab0a0379e5a20d5 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 14:57:08 +0200
Subject: [PATCH 073/100] fix(atc-xunit): remove debug-breakpoint throws from
 AnalyzerHelper
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The else-if blocks that threw Exception("Whoops..") and Exception("Ups..")
were placeholder breakpoint hooks in debugLimitData paths. These would
abort the entire compliance run in Debug builds and were never meaningful
in Release (the condition is rare; the exception non-specific).

Removed both blocks — developers can set explicit breakpoints in the
caller when debugging with debugLimitData.
---
 src/Atc.XUnit/Internal/AbstractSyntaxTree/AnalyzerHelper.cs | 5 -----
 src/Atc.XUnit/Internal/MonoReflection/AnalyzerHelper.cs     | 5 -----
 2 files changed, 10 deletions(-)

diff --git a/src/Atc.XUnit/Internal/AbstractSyntaxTree/AnalyzerHelper.cs b/src/Atc.XUnit/Internal/AbstractSyntaxTree/AnalyzerHelper.cs
index fbac386b..46616e3d 100644
--- a/src/Atc.XUnit/Internal/AbstractSyntaxTree/AnalyzerHelper.cs
+++ b/src/Atc.XUnit/Internal/AbstractSyntaxTree/AnalyzerHelper.cs
@@ -42,11 +42,6 @@ internal static MethodInfo[] GetSourceMethodsWithMissingTest(
                         {
                             methodsWithTest.Add(method);
                         }
-                        else if (debugLimitData is not null)
-                        {
-                            // Dummy for breakpoint
-                            throw new Exception("Whoops..");
-                        }
                     }
                 }
             }
diff --git a/src/Atc.XUnit/Internal/MonoReflection/AnalyzerHelper.cs b/src/Atc.XUnit/Internal/MonoReflection/AnalyzerHelper.cs
index e5c7faaa..17de035f 100644
--- a/src/Atc.XUnit/Internal/MonoReflection/AnalyzerHelper.cs
+++ b/src/Atc.XUnit/Internal/MonoReflection/AnalyzerHelper.cs
@@ -40,11 +40,6 @@ public static MethodInfo[] GetSourceMethodsWithMissingTest(
                         {
                             methodsWithTest.Add(method);
                         }
-                        else if (debugLimitData is not null)
-                        {
-                            // Dummy for breakpoint
-                            throw new Exception("Ups..");
-                        }
                     }
                 }
             }

From 2d43f71009213d525c3f442c30aba24c7586ef6d Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 14:58:47 +0200
Subject: [PATCH 074/100] fix(atc-rest-extended): guard against
 ReflectionTypeLoadException in SwaggerEnumDescriptionsDocumentFilter

GetEnumTypeByName called Assembly.GetTypes() which throws
ReflectionTypeLoadException when an assembly fails to load some types.
This crashed Swagger document generation entirely.

Extracted GetEnumTypesFromAssembly helper that uses GetExportedTypes()
(public types only; smaller surface than GetTypes()) and handles both
ReflectionTypeLoadException (returns partial set) and any other exception
(returns empty) so Swagger generation continues even with problematic assemblies.
---
 .../SwaggerEnumDescriptionsDocumentFilter.cs  | 21 ++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/src/Atc.Rest.Extended/Filters/SwaggerEnumDescriptionsDocumentFilter.cs b/src/Atc.Rest.Extended/Filters/SwaggerEnumDescriptionsDocumentFilter.cs
index 9c5bcd21..5abf97f9 100644
--- a/src/Atc.Rest.Extended/Filters/SwaggerEnumDescriptionsDocumentFilter.cs
+++ b/src/Atc.Rest.Extended/Filters/SwaggerEnumDescriptionsDocumentFilter.cs
@@ -115,9 +115,7 @@ private static string DescribeEnum(
     private static Type? GetEnumTypeByName(string enumTypeName)
         => AppDomain.CurrentDomain
                 .GetAssemblies()
-                .SelectMany(x => x
-                    .GetTypes()
-                    .Where(t => t.IsEnum))
+                .SelectMany(GetEnumTypesFromAssembly)
                 .Where(x => string.Equals(x.Name, enumTypeName, StringComparison.Ordinal))
                 .ToArray()
             switch
@@ -125,4 +123,21 @@ private static string DescribeEnum(
                 { Length: 1 } a => a[0],
                 _ => null,
             };
+
+    [SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "Assembly.GetExportedTypes can fail for many reasons; fall back to empty on any error.")]
+    private static IEnumerable<Type> GetEnumTypesFromAssembly(Assembly assembly)
+    {
+        try
+        {
+            return assembly.GetExportedTypes().Where(t => t.IsEnum);
+        }
+        catch (ReflectionTypeLoadException ex)
+        {
+            return ex.Types.Where(t => t?.IsEnum == true).Select(t => t!);
+        }
+        catch
+        {
+            return [];
+        }
+    }
 }
\ No newline at end of file

From 3e8ea556bc3c670dcde62a248aebaee8346aa5c4 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 15:03:39 +0200
Subject: [PATCH 075/100] feat(atc-rest-fluentassertions): add WithEmptyContent
 and BeOkResultWithContent convenience methods

OkResultAssertions.WithEmptyContent() asserts that the OK result carries
no body (Value is null), for endpoints that return 200 with no payload.

ResultAssertions.BeOkResultWithContent<T>(expectedContent) is a one-call
shorthand for BeOkResult().WithContent(expectedContent), removing the
common two-step pattern from caller test code.
---
 .../Assertions/OkResultAssertions.cs           | 17 +++++++++++++++++
 .../Assertions/ResultAssertions.cs             | 18 ++++++++++++++++++
 2 files changed, 35 insertions(+)

diff --git a/src/Atc.Rest.FluentAssertions/Assertions/OkResultAssertions.cs b/src/Atc.Rest.FluentAssertions/Assertions/OkResultAssertions.cs
index 0d372682..44789350 100644
--- a/src/Atc.Rest.FluentAssertions/Assertions/OkResultAssertions.cs
+++ b/src/Atc.Rest.FluentAssertions/Assertions/OkResultAssertions.cs
@@ -35,6 +35,23 @@ public AndWhichConstraint<ObjectAssertions, T> WithContentOfType<T>(
         }
     }
 
+    /// <summary>
+    /// Asserts that the OK result has no body content (the result value is <see langword="null"/>).
+    /// </summary>
+    /// <param name="because">Optional explanation of why the assertion is needed.</param>
+    /// <param name="becauseArgs">Optional formatting arguments for the <paramref name="because"/> parameter.</param>
+    /// <returns>An <see cref="AndConstraint{OkResultAssertions}"/> for chaining further assertions.</returns>
+    public AndConstraint<OkResultAssertions> WithEmptyContent(
+        string because = "",
+        params object[] becauseArgs)
+    {
+        Execute.Assertion
+            .BecauseOf(because, becauseArgs)
+            .ForCondition(Subject.Value is null)
+            .FailWith("Expected content of {0} to be empty{{reason}}, but found {1}.", Identifier, Subject.Value);
+        return new AndConstraint<OkResultAssertions>(this);
+    }
+
     /// <summary>
     /// Asserts that the OK result contains content equivalent to the specified expected content.
     /// </summary>
diff --git a/src/Atc.Rest.FluentAssertions/Assertions/ResultAssertions.cs b/src/Atc.Rest.FluentAssertions/Assertions/ResultAssertions.cs
index 8c0dfa01..44f680cb 100644
--- a/src/Atc.Rest.FluentAssertions/Assertions/ResultAssertions.cs
+++ b/src/Atc.Rest.FluentAssertions/Assertions/ResultAssertions.cs
@@ -47,6 +47,24 @@ public OkResultAssertions BeOkResult(
         return new OkResultAssertions(okSubject);
     }
 
+    /// <summary>
+    /// Asserts that the action result is a 200 OK result whose content is equivalent to <paramref name="expectedContent"/>.
+    /// This is a convenience shorthand for <c>BeOkResult().WithContent(expectedContent)</c>.
+    /// </summary>
+    /// <typeparam name="T">The type of the expected content.</typeparam>
+    /// <param name="expectedContent">The expected content value to compare against.</param>
+    /// <param name="because">Optional explanation of why the assertion is needed.</param>
+    /// <param name="becauseArgs">Optional formatting arguments for the <paramref name="because"/> parameter.</param>
+    /// <returns>An <see cref="AndWhichConstraint{OkResultAssertions, OkObjectResult}"/> for further assertions.</returns>
+    public AndWhichConstraint<OkResultAssertions, OkObjectResult> BeOkResultWithContent<T>(
+        T expectedContent,
+        string because = "",
+        params object[] becauseArgs)
+    {
+        var okAssertions = BeOkResult(because, becauseArgs);
+        return okAssertions.WithContent(expectedContent, because, becauseArgs);
+    }
+
     /// <summary>
     /// Asserts that the action result is a <see cref="ContentResult"/> with HTTP status code 201 (Created).
     /// </summary>

From 8e2b21895a33da9c4f000551ae101bee0febb852 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 15:16:59 +0200
Subject: [PATCH 076/100] feat(atc-codeanalysis-csharp): extend syntax
 factories and declaration extensions

- SyntaxLiteralExpressionFactory: add Create(long), Create(double), Create(bool), Create(char), CreateNull() overloads
- InterfaceDeclarationSyntaxExtensions: add AddSuppressMessageAttribute (mirrors class extension)
- RecordDeclarationSyntaxExtensions: new file with AddSuppressMessageAttribute and AddGeneratedCodeAttribute
---
 .../InterfaceDeclarationSyntaxExtensions.cs   | 45 +++++++++
 .../RecordDeclarationSyntaxExtensions.cs      | 91 +++++++++++++++++++
 .../SyntaxLiteralExpressionFactory.cs         | 40 ++++++++
 3 files changed, 176 insertions(+)
 create mode 100644 src/Atc.CodeAnalysis.CSharp/Extensions/RecordDeclarationSyntaxExtensions.cs

diff --git a/src/Atc.CodeAnalysis.CSharp/Extensions/InterfaceDeclarationSyntaxExtensions.cs b/src/Atc.CodeAnalysis.CSharp/Extensions/InterfaceDeclarationSyntaxExtensions.cs
index a8c1ea51..8ad033c6 100644
--- a/src/Atc.CodeAnalysis.CSharp/Extensions/InterfaceDeclarationSyntaxExtensions.cs
+++ b/src/Atc.CodeAnalysis.CSharp/Extensions/InterfaceDeclarationSyntaxExtensions.cs
@@ -6,6 +6,51 @@ namespace Microsoft.CodeAnalysis.CSharp.Syntax;
 /// </summary>
 public static class InterfaceDeclarationSyntaxExtensions
 {
+    /// <summary>
+    /// Adds a <see cref="SuppressMessageAttribute"/> to the interface declaration.
+    /// </summary>
+    /// <param name="interfaceDeclaration">The interface declaration to modify.</param>
+    /// <param name="suppressMessage">The suppress message attribute to add.</param>
+    /// <returns>A new <see cref="InterfaceDeclarationSyntax"/> with the attribute added.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="interfaceDeclaration"/> or <paramref name="suppressMessage"/> is null.</exception>
+    /// <exception cref="ArgumentException">Thrown when the justification in <paramref name="suppressMessage"/> is invalid.</exception>
+    public static InterfaceDeclarationSyntax AddSuppressMessageAttribute(
+        this InterfaceDeclarationSyntax interfaceDeclaration,
+        SuppressMessageAttribute suppressMessage)
+    {
+        if (interfaceDeclaration is null)
+        {
+            throw new ArgumentNullException(nameof(interfaceDeclaration));
+        }
+
+        if (suppressMessage is null)
+        {
+            throw new ArgumentNullException(nameof(suppressMessage));
+        }
+
+        if (string.IsNullOrEmpty(suppressMessage.Justification))
+        {
+            throw new ArgumentException("Justification is invalid.", nameof(suppressMessage));
+        }
+
+        var attributeArgumentList = SyntaxFactory.AttributeArgumentList(
+            SyntaxFactory.SeparatedList<AttributeArgumentSyntax>(
+                SyntaxFactory.NodeOrTokenList(
+                    SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.Category)),
+                    SyntaxTokenFactory.Comma(),
+                    SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.CheckId)),
+                    SyntaxTokenFactory.Comma(),
+                    SyntaxFactory
+                        .AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.Justification!))
+                        .WithNameEquals(
+                        SyntaxNameEqualsFactory
+                            .Create(nameof(SuppressMessageAttribute.Justification))
+                            .WithEqualsToken(SyntaxTokenFactory.Equals())))));
+
+        return interfaceDeclaration
+            .AddAttributeLists(SyntaxAttributeListFactory.Create(nameof(SuppressMessageAttribute), attributeArgumentList));
+    }
+
     /// <summary>
     /// Adds a <see cref="GeneratedCodeAttribute"/> to the interface declaration.
     /// </summary>
diff --git a/src/Atc.CodeAnalysis.CSharp/Extensions/RecordDeclarationSyntaxExtensions.cs b/src/Atc.CodeAnalysis.CSharp/Extensions/RecordDeclarationSyntaxExtensions.cs
new file mode 100644
index 00000000..caeec03e
--- /dev/null
+++ b/src/Atc.CodeAnalysis.CSharp/Extensions/RecordDeclarationSyntaxExtensions.cs
@@ -0,0 +1,91 @@
+// ReSharper disable once CheckNamespace
+namespace Microsoft.CodeAnalysis.CSharp.Syntax;
+
+/// <summary>
+/// Extension methods for <see cref="RecordDeclarationSyntax"/>.
+/// </summary>
+public static class RecordDeclarationSyntaxExtensions
+{
+    /// <summary>
+    /// Adds a <see cref="SuppressMessageAttribute"/> to the record declaration.
+    /// </summary>
+    /// <param name="recordDeclaration">The record declaration to modify.</param>
+    /// <param name="suppressMessage">The suppress message attribute to add.</param>
+    /// <returns>A new <see cref="RecordDeclarationSyntax"/> with the attribute added.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="recordDeclaration"/> or <paramref name="suppressMessage"/> is null.</exception>
+    /// <exception cref="ArgumentException">Thrown when the justification in <paramref name="suppressMessage"/> is invalid.</exception>
+    public static RecordDeclarationSyntax AddSuppressMessageAttribute(
+        this RecordDeclarationSyntax recordDeclaration,
+        SuppressMessageAttribute suppressMessage)
+    {
+        if (recordDeclaration is null)
+        {
+            throw new ArgumentNullException(nameof(recordDeclaration));
+        }
+
+        if (suppressMessage is null)
+        {
+            throw new ArgumentNullException(nameof(suppressMessage));
+        }
+
+        if (string.IsNullOrEmpty(suppressMessage.Justification))
+        {
+            throw new ArgumentException("Justification is invalid.", nameof(suppressMessage));
+        }
+
+        var attributeArgumentList = SyntaxFactory.AttributeArgumentList(
+            SyntaxFactory.SeparatedList<AttributeArgumentSyntax>(
+                SyntaxFactory.NodeOrTokenList(
+                    SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.Category)),
+                    SyntaxTokenFactory.Comma(),
+                    SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.CheckId)),
+                    SyntaxTokenFactory.Comma(),
+                    SyntaxFactory
+                        .AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.Justification!))
+                        .WithNameEquals(
+                        SyntaxNameEqualsFactory
+                            .Create(nameof(SuppressMessageAttribute.Justification))
+                            .WithEqualsToken(SyntaxTokenFactory.Equals())))));
+
+        return recordDeclaration
+            .AddAttributeLists(SyntaxAttributeListFactory.Create(nameof(SuppressMessageAttribute), attributeArgumentList));
+    }
+
+    /// <summary>
+    /// Adds a <see cref="GeneratedCodeAttribute"/> to the record declaration.
+    /// </summary>
+    /// <param name="recordDeclaration">The record declaration to modify.</param>
+    /// <param name="toolName">The name of the code generation tool.</param>
+    /// <param name="version">The version of the code generation tool.</param>
+    /// <returns>A new <see cref="RecordDeclarationSyntax"/> with the attribute added.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="recordDeclaration"/>, <paramref name="toolName"/>, or <paramref name="version"/> is null.</exception>
+    public static RecordDeclarationSyntax AddGeneratedCodeAttribute(
+        this RecordDeclarationSyntax recordDeclaration,
+        string toolName,
+        string version)
+    {
+        if (recordDeclaration is null)
+        {
+            throw new ArgumentNullException(nameof(recordDeclaration));
+        }
+
+        if (toolName is null)
+        {
+            throw new ArgumentNullException(nameof(toolName));
+        }
+
+        if (version is null)
+        {
+            throw new ArgumentNullException(nameof(version));
+        }
+
+        var attributeArgumentList = SyntaxFactory.AttributeArgumentList(
+            SyntaxFactory.SeparatedList<AttributeArgumentSyntax>(SyntaxFactory.NodeOrTokenList(
+                SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(toolName)),
+                SyntaxTokenFactory.Comma(),
+                SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(version)))));
+
+        return recordDeclaration
+            .AddAttributeLists(SyntaxAttributeListFactory.Create(nameof(GeneratedCodeAttribute), attributeArgumentList));
+    }
+}
\ No newline at end of file
diff --git a/src/Atc.CodeAnalysis.CSharp/SyntaxFactories/SyntaxLiteralExpressionFactory.cs b/src/Atc.CodeAnalysis.CSharp/SyntaxFactories/SyntaxLiteralExpressionFactory.cs
index 93080795..f893e276 100644
--- a/src/Atc.CodeAnalysis.CSharp/SyntaxFactories/SyntaxLiteralExpressionFactory.cs
+++ b/src/Atc.CodeAnalysis.CSharp/SyntaxFactories/SyntaxLiteralExpressionFactory.cs
@@ -53,4 +53,44 @@ public static LiteralExpressionSyntax Create(
     /// <returns>A <see cref="LiteralExpressionSyntax"/> node representing the integer.</returns>
     public static LiteralExpressionSyntax Create(int value)
         => SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(value));
+
+    /// <summary>
+    /// Creates a numeric literal expression from a long value.
+    /// </summary>
+    /// <param name="value">The long value for the literal expression.</param>
+    /// <returns>A <see cref="LiteralExpressionSyntax"/> node representing the long.</returns>
+    public static LiteralExpressionSyntax Create(long value)
+        => SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(value));
+
+    /// <summary>
+    /// Creates a numeric literal expression from a double value.
+    /// </summary>
+    /// <param name="value">The double value for the literal expression.</param>
+    /// <returns>A <see cref="LiteralExpressionSyntax"/> node representing the double.</returns>
+    public static LiteralExpressionSyntax Create(double value)
+        => SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(value));
+
+    /// <summary>
+    /// Creates a boolean literal expression.
+    /// </summary>
+    /// <param name="value">The boolean value.</param>
+    /// <returns>A <see cref="LiteralExpressionSyntax"/> node representing <see langword="true"/> or <see langword="false"/>.</returns>
+    public static LiteralExpressionSyntax Create(bool value)
+        => SyntaxFactory.LiteralExpression(
+            value ? SyntaxKind.TrueLiteralExpression : SyntaxKind.FalseLiteralExpression);
+
+    /// <summary>
+    /// Creates a character literal expression.
+    /// </summary>
+    /// <param name="value">The character value.</param>
+    /// <returns>A <see cref="LiteralExpressionSyntax"/> node representing the character literal.</returns>
+    public static LiteralExpressionSyntax Create(char value)
+        => SyntaxFactory.LiteralExpression(SyntaxKind.CharacterLiteralExpression, SyntaxFactory.Literal(value));
+
+    /// <summary>
+    /// Creates a <see langword="null"/> literal expression.
+    /// </summary>
+    /// <returns>A <see cref="LiteralExpressionSyntax"/> node representing <see langword="null"/>.</returns>
+    public static LiteralExpressionSyntax CreateNull()
+        => SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
 }
\ No newline at end of file

From 2fedb015486976d1b258da95a04c259ad59a7414 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 15:18:41 +0200
Subject: [PATCH 077/100] feat(atc-codeanalysis-csharp): add argument-list and
 generic overloads to SyntaxObjectCreationExpressionFactory

Add Create(name, ArgumentListSyntax), Create(ns, name, ArgumentListSyntax),
CreateGeneric(name, TypeArgumentListSyntax), CreateGeneric(name, typeName),
CreateGeneric(name, TypeArgumentListSyntax, ArgumentListSyntax), and
CreateGeneric(name, typeName, ArgumentListSyntax) overloads.
---
 .../SyntaxObjectCreationExpressionFactory.cs  | 177 ++++++++++++++++++
 1 file changed, 177 insertions(+)

diff --git a/src/Atc.CodeAnalysis.CSharp/SyntaxFactories/SyntaxObjectCreationExpressionFactory.cs b/src/Atc.CodeAnalysis.CSharp/SyntaxFactories/SyntaxObjectCreationExpressionFactory.cs
index 40c7e3d2..95f7b487 100644
--- a/src/Atc.CodeAnalysis.CSharp/SyntaxFactories/SyntaxObjectCreationExpressionFactory.cs
+++ b/src/Atc.CodeAnalysis.CSharp/SyntaxFactories/SyntaxObjectCreationExpressionFactory.cs
@@ -47,4 +47,181 @@ public static ObjectCreationExpressionSyntax Create(
                 SyntaxFactory.IdentifierName(namespaceName),
                 SyntaxFactory.IdentifierName(identifierName)));
     }
+
+    /// <summary>
+    /// Creates an object creation expression for a type with an explicit argument list.
+    /// </summary>
+    /// <param name="identifierName">The name of the type to instantiate.</param>
+    /// <param name="argumentList">The argument list to pass to the constructor.</param>
+    /// <returns>An <see cref="ObjectCreationExpressionSyntax"/> node with the given arguments.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="identifierName"/> or <paramref name="argumentList"/> is null.</exception>
+    public static ObjectCreationExpressionSyntax Create(
+        string identifierName,
+        ArgumentListSyntax argumentList)
+    {
+        if (identifierName is null)
+        {
+            throw new ArgumentNullException(nameof(identifierName));
+        }
+
+        if (argumentList is null)
+        {
+            throw new ArgumentNullException(nameof(argumentList));
+        }
+
+        return SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName(identifierName))
+            .WithArgumentList(argumentList);
+    }
+
+    /// <summary>
+    /// Creates an object creation expression for a qualified type name with an explicit argument list.
+    /// </summary>
+    /// <param name="namespaceName">The namespace containing the type.</param>
+    /// <param name="identifierName">The name of the type to instantiate.</param>
+    /// <param name="argumentList">The argument list to pass to the constructor.</param>
+    /// <returns>An <see cref="ObjectCreationExpressionSyntax"/> node with the given arguments.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when any parameter is null.</exception>
+    public static ObjectCreationExpressionSyntax Create(
+        string namespaceName,
+        string identifierName,
+        ArgumentListSyntax argumentList)
+    {
+        if (namespaceName is null)
+        {
+            throw new ArgumentNullException(nameof(namespaceName));
+        }
+
+        if (identifierName is null)
+        {
+            throw new ArgumentNullException(nameof(identifierName));
+        }
+
+        if (argumentList is null)
+        {
+            throw new ArgumentNullException(nameof(argumentList));
+        }
+
+        return SyntaxFactory.ObjectCreationExpression(
+            SyntaxFactory.QualifiedName(
+                SyntaxFactory.IdentifierName(namespaceName),
+                SyntaxFactory.IdentifierName(identifierName)))
+            .WithArgumentList(argumentList);
+    }
+
+    /// <summary>
+    /// Creates a generic object creation expression (e.g. <c>new List&lt;T&gt;()</c>).
+    /// </summary>
+    /// <param name="identifierName">The name of the generic type to instantiate.</param>
+    /// <param name="typeArgumentList">The type argument list (e.g. <c>&lt;T&gt;</c>).</param>
+    /// <returns>An <see cref="ObjectCreationExpressionSyntax"/> node for the generic type.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="identifierName"/> or <paramref name="typeArgumentList"/> is null.</exception>
+    public static ObjectCreationExpressionSyntax CreateGeneric(
+        string identifierName,
+        TypeArgumentListSyntax typeArgumentList)
+    {
+        if (identifierName is null)
+        {
+            throw new ArgumentNullException(nameof(identifierName));
+        }
+
+        if (typeArgumentList is null)
+        {
+            throw new ArgumentNullException(nameof(typeArgumentList));
+        }
+
+        return SyntaxFactory.ObjectCreationExpression(
+            SyntaxFactory.GenericName(
+                SyntaxFactory.Identifier(identifierName))
+            .WithTypeArgumentList(typeArgumentList));
+    }
+
+    /// <summary>
+    /// Creates a generic object creation expression with a single named type argument (e.g. <c>new List&lt;MyType&gt;()</c>).
+    /// </summary>
+    /// <param name="identifierName">The name of the generic type to instantiate.</param>
+    /// <param name="typeArgumentName">The name of the single type argument.</param>
+    /// <returns>An <see cref="ObjectCreationExpressionSyntax"/> node for the generic type.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when any parameter is null.</exception>
+    public static ObjectCreationExpressionSyntax CreateGeneric(
+        string identifierName,
+        string typeArgumentName)
+    {
+        if (identifierName is null)
+        {
+            throw new ArgumentNullException(nameof(identifierName));
+        }
+
+        if (typeArgumentName is null)
+        {
+            throw new ArgumentNullException(nameof(typeArgumentName));
+        }
+
+        return CreateGeneric(identifierName, SyntaxTypeArgumentListFactory.CreateWithOneItem(typeArgumentName));
+    }
+
+    /// <summary>
+    /// Creates a generic object creation expression with an explicit argument list (e.g. <c>new Dictionary&lt;K,V&gt;(capacity)</c>).
+    /// </summary>
+    /// <param name="identifierName">The name of the generic type to instantiate.</param>
+    /// <param name="typeArgumentList">The type argument list.</param>
+    /// <param name="argumentList">The argument list to pass to the constructor.</param>
+    /// <returns>An <see cref="ObjectCreationExpressionSyntax"/> node for the generic type with arguments.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when any parameter is null.</exception>
+    public static ObjectCreationExpressionSyntax CreateGeneric(
+        string identifierName,
+        TypeArgumentListSyntax typeArgumentList,
+        ArgumentListSyntax argumentList)
+    {
+        if (identifierName is null)
+        {
+            throw new ArgumentNullException(nameof(identifierName));
+        }
+
+        if (typeArgumentList is null)
+        {
+            throw new ArgumentNullException(nameof(typeArgumentList));
+        }
+
+        if (argumentList is null)
+        {
+            throw new ArgumentNullException(nameof(argumentList));
+        }
+
+        return SyntaxFactory.ObjectCreationExpression(
+            SyntaxFactory.GenericName(
+                SyntaxFactory.Identifier(identifierName))
+            .WithTypeArgumentList(typeArgumentList))
+            .WithArgumentList(argumentList);
+    }
+
+    /// <summary>
+    /// Creates a generic object creation expression with a single named type argument and an argument list.
+    /// </summary>
+    /// <param name="identifierName">The name of the generic type to instantiate.</param>
+    /// <param name="typeArgumentName">The name of the single type argument.</param>
+    /// <param name="argumentList">The argument list to pass to the constructor.</param>
+    /// <returns>An <see cref="ObjectCreationExpressionSyntax"/> node for the generic type with arguments.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when any parameter is null.</exception>
+    public static ObjectCreationExpressionSyntax CreateGeneric(
+        string identifierName,
+        string typeArgumentName,
+        ArgumentListSyntax argumentList)
+    {
+        if (identifierName is null)
+        {
+            throw new ArgumentNullException(nameof(identifierName));
+        }
+
+        if (typeArgumentName is null)
+        {
+            throw new ArgumentNullException(nameof(typeArgumentName));
+        }
+
+        if (argumentList is null)
+        {
+            throw new ArgumentNullException(nameof(argumentList));
+        }
+
+        return CreateGeneric(identifierName, SyntaxTypeArgumentListFactory.CreateWithOneItem(typeArgumentName), argumentList);
+    }
 }
\ No newline at end of file

From 0cb821a7ce4a1747a1b82e5488d2d41d804ebd6e Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 15:26:53 +0200
Subject: [PATCH 078/100] feat(atc-codedoc+atc-xunit): add explicit xmlDocPath
 overloads to documentation helpers

AssemblyCommentHelper, DocumentationHelper, and CodeComplianceDocumentationHelper
all gain FileInfo xmlDocPath overloads so callers can specify the XML doc file
explicitly instead of relying on AppDomain base-dir auto-resolution.
Renamed private core methods to *Core to avoid S4136/S1144 analyzer violations.
---
 .../AssemblyCommentHelper.cs                  | 95 +++++++++++++++++--
 .../DocumentationHelper.cs                    | 29 ++++++
 .../CodeComplianceDocumentationHelper.cs      | 47 +++++++++
 3 files changed, 165 insertions(+), 6 deletions(-)

diff --git a/src/Atc.CodeDocumentation/AssemblyCommentHelper.cs b/src/Atc.CodeDocumentation/AssemblyCommentHelper.cs
index 9ca587fa..48026743 100644
--- a/src/Atc.CodeDocumentation/AssemblyCommentHelper.cs
+++ b/src/Atc.CodeDocumentation/AssemblyCommentHelper.cs
@@ -18,7 +18,32 @@ internal static class AssemblyCommentHelper
         }
 
         var xmlFile = GetXmlFileForAssembly(type.Assembly);
-        return CollectExportedTypesWithComments(type.Assembly, xmlFile, namespaceMatch: null, excludeSourceTypes: null)
+        return CollectExportedTypesWithCommentsCore(type.Assembly, xmlFile, namespaceMatch: null, excludeSourceTypes: null)
+            .FirstOrDefault(x => string.Equals(x.FullName, type.FullName, StringComparison.Ordinal));
+    }
+
+    /// <summary>
+    /// Collects XML documentation comments for a specific type using an explicit XML documentation file.
+    /// </summary>
+    /// <param name="type">The type to collect documentation for.</param>
+    /// <param name="xmlDocPath">The explicit path to the XML documentation file.</param>
+    /// <returns>The type comments, or <see langword="null"/> if the type was not found.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="type"/> or <paramref name="xmlDocPath"/> is null.</exception>
+    public static TypeComments? CollectExportedTypeWithComments(
+        Type type,
+        FileInfo xmlDocPath)
+    {
+        if (type is null)
+        {
+            throw new ArgumentNullException(nameof(type));
+        }
+
+        if (xmlDocPath is null)
+        {
+            throw new ArgumentNullException(nameof(xmlDocPath));
+        }
+
+        return CollectExportedTypesWithCommentsCore(type.Assembly, xmlDocPath, namespaceMatch: null, excludeSourceTypes: null)
             .FirstOrDefault(x => string.Equals(x.FullName, type.FullName, StringComparison.Ordinal));
     }
 
@@ -40,7 +65,36 @@ public static TypeComments[] CollectExportedTypesWithMissingComments(
         }
 
         var xmlFile = GetXmlFileForAssembly(assembly);
-        return CollectExportedTypesWithMissingComments(assembly, xmlFile, namespaceMatch, excludeSourceTypes);
+        return CollectExportedTypesWithMissingCommentsCore(assembly, xmlFile, namespaceMatch, excludeSourceTypes);
+    }
+
+    /// <summary>
+    /// Collects all public types from an assembly that are missing XML documentation comments,
+    /// using an explicit XML documentation file path.
+    /// </summary>
+    /// <param name="assembly">The assembly to scan for types.</param>
+    /// <param name="xmlDocPath">The explicit path to the XML documentation file.</param>
+    /// <param name="namespaceMatch">Optional regex pattern to filter types by namespace.</param>
+    /// <param name="excludeSourceTypes">Optional list of types to exclude from the results.</param>
+    /// <returns>An array of type comments for types missing documentation.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="assembly"/> or <paramref name="xmlDocPath"/> is null.</exception>
+    public static TypeComments[] CollectExportedTypesWithMissingComments(
+        Assembly assembly,
+        FileInfo xmlDocPath,
+        string? namespaceMatch = null,
+        List<Type>? excludeSourceTypes = null)
+    {
+        if (assembly is null)
+        {
+            throw new ArgumentNullException(nameof(assembly));
+        }
+
+        if (xmlDocPath is null)
+        {
+            throw new ArgumentNullException(nameof(xmlDocPath));
+        }
+
+        return CollectExportedTypesWithMissingCommentsCore(assembly, xmlDocPath, namespaceMatch, excludeSourceTypes);
     }
 
     /// <summary>
@@ -61,7 +115,36 @@ public static TypeComments[] CollectExportedTypesWithComments(
         }
 
         var xmlFile = GetXmlFileForAssembly(assembly);
-        return CollectExportedTypesWithComments(assembly, xmlFile, namespaceMatch, excludeSourceTypes);
+        return CollectExportedTypesWithCommentsCore(assembly, xmlFile, namespaceMatch, excludeSourceTypes);
+    }
+
+    /// <summary>
+    /// Collects all public types from an assembly along with their XML documentation comments,
+    /// using an explicit XML documentation file path.
+    /// </summary>
+    /// <param name="assembly">The assembly to scan for types.</param>
+    /// <param name="xmlDocPath">The explicit path to the XML documentation file.</param>
+    /// <param name="namespaceMatch">Optional regex pattern to filter types by namespace.</param>
+    /// <param name="excludeSourceTypes">Optional list of types to exclude from the results.</param>
+    /// <returns>An array of type comments for all matching types.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="assembly"/> or <paramref name="xmlDocPath"/> is null.</exception>
+    public static TypeComments[] CollectExportedTypesWithComments(
+        Assembly assembly,
+        FileInfo xmlDocPath,
+        string? namespaceMatch = null,
+        List<Type>? excludeSourceTypes = null)
+    {
+        if (assembly is null)
+        {
+            throw new ArgumentNullException(nameof(assembly));
+        }
+
+        if (xmlDocPath is null)
+        {
+            throw new ArgumentNullException(nameof(xmlDocPath));
+        }
+
+        return CollectExportedTypesWithCommentsCore(assembly, xmlDocPath, namespaceMatch, excludeSourceTypes);
     }
 
     /// <summary>
@@ -110,7 +193,7 @@ private static bool IsRequiredNamespace(
         => regex is null ||
            regex.IsMatch(type.Namespace ?? string.Empty);
 
-    private static TypeComments[] CollectExportedTypesWithMissingComments(
+    private static TypeComments[] CollectExportedTypesWithMissingCommentsCore(
         Assembly assembly,
         FileSystemInfo xmlPath,
         string? namespaceMatch,
@@ -131,7 +214,7 @@ private static TypeComments[] CollectExportedTypesWithMissingComments(
             throw new IOException($"File don't exist: {xmlPath.FullName}");
         }
 
-        var collectExportedTypesWithComments = CollectExportedTypesWithComments(assembly, xmlPath, namespaceMatch, excludeSourceTypes);
+        var collectExportedTypesWithComments = CollectExportedTypesWithCommentsCore(assembly, xmlPath, namespaceMatch, excludeSourceTypes);
 
         var collectExportedTypesWithMissingComments = collectExportedTypesWithComments
             .Where(x => !x.HasComments)
@@ -141,7 +224,7 @@ private static TypeComments[] CollectExportedTypesWithMissingComments(
         return collectExportedTypesWithMissingComments;
     }
 
-    private static TypeComments[] CollectExportedTypesWithComments(
+    private static TypeComments[] CollectExportedTypesWithCommentsCore(
         Assembly assembly,
         FileSystemInfo xmlPath,
         string? namespaceMatch,
diff --git a/src/Atc.CodeDocumentation/DocumentationHelper.cs b/src/Atc.CodeDocumentation/DocumentationHelper.cs
index e24ea397..059a5abe 100644
--- a/src/Atc.CodeDocumentation/DocumentationHelper.cs
+++ b/src/Atc.CodeDocumentation/DocumentationHelper.cs
@@ -14,6 +14,17 @@ public static class DocumentationHelper
         Type type)
         => AssemblyCommentHelper.CollectExportedTypeWithComments(type);
 
+    /// <summary>
+    /// Collects XML documentation comments for a specific type using an explicit XML documentation file.
+    /// </summary>
+    /// <param name="type">The type to collect documentation for.</param>
+    /// <param name="xmlDocPath">The explicit path to the XML documentation file.</param>
+    /// <returns>The type comments, or <see langword="null"/> if the type was not found.</returns>
+    public static TypeComments? CollectExportedTypeWithCommentsFromType(
+        Type type,
+        FileInfo xmlDocPath)
+        => AssemblyCommentHelper.CollectExportedTypeWithComments(type, xmlDocPath);
+
     /// <summary>
     /// Collects all public types from an assembly that are missing XML documentation comments.
     /// </summary>
@@ -28,6 +39,24 @@ public static TypeComments[] CollectExportedTypesWithMissingCommentsFromAssembly
             namespaceMatch: null,
             excludeTypes);
 
+    /// <summary>
+    /// Collects all public types from an assembly that are missing XML documentation comments,
+    /// using an explicit XML documentation file path.
+    /// </summary>
+    /// <param name="assembly">The assembly to scan for types.</param>
+    /// <param name="xmlDocPath">The explicit path to the XML documentation file.</param>
+    /// <param name="excludeTypes">Optional list of types to exclude from the results.</param>
+    /// <returns>An array of type comments for types missing documentation.</returns>
+    public static TypeComments[] CollectExportedTypesWithMissingCommentsFromAssembly(
+        Assembly assembly,
+        FileInfo xmlDocPath,
+        List<Type>? excludeTypes = null)
+        => AssemblyCommentHelper.CollectExportedTypesWithMissingComments(
+            assembly,
+            xmlDocPath,
+            namespaceMatch: null,
+            excludeTypes);
+
     /// <summary>
     /// Collects all public types from an assembly that are missing XML documentation and generates a formatted text report.
     /// </summary>
diff --git a/src/Atc.XUnit/CodeComplianceDocumentationHelper.cs b/src/Atc.XUnit/CodeComplianceDocumentationHelper.cs
index ac731a30..ff38a1ba 100644
--- a/src/Atc.XUnit/CodeComplianceDocumentationHelper.cs
+++ b/src/Atc.XUnit/CodeComplianceDocumentationHelper.cs
@@ -23,6 +23,53 @@ public static void AssertExportedTypeWithMissingComments(Type type)
         TestResultHelper.AssertOnTestResults(testResults);
     }
 
+    /// <summary>
+    /// Asserts that all exported types in an assembly have XML documentation comments,
+    /// using an explicit XML documentation file path instead of relying on automatic path resolution.
+    /// Use this overload when the XML documentation file is not located next to the assembly or in
+    /// <see cref="AppDomain.CurrentDomain"/> base directory.
+    /// </summary>
+    /// <param name="assembly">The assembly to validate.</param>
+    /// <param name="xmlDocPath">The explicit path to the XML documentation file for <paramref name="assembly"/>.</param>
+    /// <param name="excludeTypes">Optional list of types to exclude from validation.</param>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="assembly"/> or <paramref name="xmlDocPath"/> is null.</exception>
+    public static void AssertExportedTypesWithMissingComments(
+        Assembly assembly,
+        FileInfo xmlDocPath,
+        List<Type>? excludeTypes = null)
+    {
+        if (assembly is null)
+        {
+            throw new ArgumentNullException(nameof(assembly));
+        }
+
+        if (xmlDocPath is null)
+        {
+            throw new ArgumentNullException(nameof(xmlDocPath));
+        }
+
+        // Due to some build issue with GenerateDocumentationFile=true and xml-file location, this hack is made for now.
+        if (!OperatingSystem.IsWindows())
+        {
+            return;
+        }
+
+        var typesWithMissingCommentsGroups = DocumentationHelper
+            .CollectExportedTypesWithMissingCommentsFromAssembly(assembly, xmlDocPath, excludeTypes)
+            .OrderBy(x => x.Type.FullName, StringComparer.Ordinal)
+            .GroupBy(x => x.Type.BeautifyName(useFullName: true), StringComparer.Ordinal)
+            .ToArray();
+
+        var testResults = new List<TestResult>
+        {
+            new($"Assembly: {assembly.GetName()}"),
+        };
+
+        testResults.AddRange(typesWithMissingCommentsGroups.Select(item => new TestResult(isError: false, 1, $"Type: {item.Key}")));
+
+        TestResultHelper.AssertOnTestResults(testResults);
+    }
+
     /// <summary>
     /// Asserts that all exported types in an assembly have XML documentation comments.
     /// Fails the test if any types are missing documentation.

From 12779ff2cbfa4b64c61e3dee5dee4eeb73daff19 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 15:32:14 +0200
Subject: [PATCH 079/100] fix(atc-rest+atc-rest-healthchecks): harden
 ExceptionTelemetryMiddleware and HealthReportEntry data sanitization

- ExceptionTelemetryMiddleware: check RequestAborted before writing response,
  and write application/problem+json (ProblemDetails) instead of plain text
- HealthReportEntryExtensions.SanitizeData: convert non-string/non-Exception
  data values to their string representation to prevent verbatim serialization
  of potentially sensitive objects to unauthenticated /health endpoints
---
 .../Extensions/HealthReportEntryExtensions.cs        | 10 +++++++---
 .../Middleware/ExceptionTelemetryMiddleware.cs       | 12 ++++++++----
 2 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/src/Atc.Rest.HealthChecks/Extensions/HealthReportEntryExtensions.cs b/src/Atc.Rest.HealthChecks/Extensions/HealthReportEntryExtensions.cs
index 681d933a..2ae15308 100644
--- a/src/Atc.Rest.HealthChecks/Extensions/HealthReportEntryExtensions.cs
+++ b/src/Atc.Rest.HealthChecks/Extensions/HealthReportEntryExtensions.cs
@@ -60,8 +60,12 @@ private static IReadOnlyDictionary<string, object> SanitizeData(
         IReadOnlyDictionary<string, object> data)
         => data.ToDictionary(
             kvp => kvp.Key,
-            kvp => kvp.Value is Exception ex
-                ? ex.Message
-                : kvp.Value,
+            kvp => kvp.Value switch
+            {
+                null => (object)string.Empty,
+                Exception ex => ex.Message,
+                string s => s,
+                _ => kvp.Value.ToString() ?? string.Empty,
+            },
             StringComparer.Ordinal);
 }
\ No newline at end of file
diff --git a/src/Atc.Rest/Middleware/ExceptionTelemetryMiddleware.cs b/src/Atc.Rest/Middleware/ExceptionTelemetryMiddleware.cs
index 6f295e89..1bf24e2d 100644
--- a/src/Atc.Rest/Middleware/ExceptionTelemetryMiddleware.cs
+++ b/src/Atc.Rest/Middleware/ExceptionTelemetryMiddleware.cs
@@ -53,12 +53,16 @@ private async Task InternalInvokeAsync(HttpContext context)
             requestFailed = true;
         }
 
-        if (requestFailed)
+        if (requestFailed && !context.RequestAborted.IsCancellationRequested)
         {
             context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
-            await context
-                .Response
-                .WriteAsync($"Something is broken. Please contact the development team with the value of the returned header named '{WellKnownHttpHeaders.CorrelationId}'");
+            var problem = new ProblemDetails
+            {
+                Status = (int)HttpStatusCode.InternalServerError,
+                Title = "An unexpected error occurred.",
+                Detail = $"Contact the development team with the value of the '{WellKnownHttpHeaders.CorrelationId}' response header.",
+            };
+            await context.Response.WriteAsJsonAsync(problem, context.RequestAborted);
         }
     }
 }
\ No newline at end of file

From d9bec4439bce5b275de037e06f6c3f2c7848b62d Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 15:35:48 +0200
Subject: [PATCH 080/100] feat(atc): extend GeoSpatial helpers with bearing,
 Earth-radius param, and ToWgs84 convenience overload
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- GeoSpatialHelper.Distance: add optional earthRadiusKm parameter (default 6371.0 km)
- GeoSpatialHelper.Bearing: new method calculates initial bearing (0-360°) between two points
- UniversalTransverseMercatorConverter.ToWgs84: convenience overload accepting UniversalTransverseMercatorResult directly
---
 src/Atc/Math/GeoSpatial/GeoSpatialHelper.cs   | 48 +++++++++++++++++--
 .../UniversalTransverseMercatorConverter.cs   | 21 ++++++++
 2 files changed, 65 insertions(+), 4 deletions(-)

diff --git a/src/Atc/Math/GeoSpatial/GeoSpatialHelper.cs b/src/Atc/Math/GeoSpatial/GeoSpatialHelper.cs
index 6dd1de49..1bb85f8a 100644
--- a/src/Atc/Math/GeoSpatial/GeoSpatialHelper.cs
+++ b/src/Atc/Math/GeoSpatial/GeoSpatialHelper.cs
@@ -26,6 +26,7 @@ public static double Distance(
     /// <param name="longitude2">The longitude of the second point in degrees.</param>
     /// <param name="latitude2">The latitude of the second point in degrees.</param>
     /// <param name="measurement">The unit of measurement for the result. Default is kilometers.</param>
+    /// <param name="earthRadiusKm">The Earth radius in kilometers used for the calculation. Defaults to the mean Earth radius of 6371 km.</param>
     /// <returns>The great-circle distance between the two points in the specified measurement unit.</returns>
     /// <remarks>
     /// This method assumes a spherical Earth and uses the Haversine formula for calculation.
@@ -36,10 +37,9 @@ public static double Distance(
         double latitude1,
         double longitude2,
         double latitude2,
-        DistanceMeasurementType measurement = DistanceMeasurementType.Kilometers)
+        DistanceMeasurementType measurement = DistanceMeasurementType.Kilometers,
+        double earthRadiusKm = 6371.0)
     {
-        const double EarthRadiusKm = 6371.0;
-
         var lat1Rad = MathHelper.DegreesToRadians(latitude1);
         var lat2Rad = MathHelper.DegreesToRadians(latitude2);
         var dLat = MathHelper.DegreesToRadians(latitude2 - latitude1);
@@ -50,7 +50,7 @@ public static double Distance(
                  System.Math.Sin(dLon / 2) * System.Math.Sin(dLon / 2));
 
         var c = 2 * System.Math.Atan2(System.Math.Sqrt(a), System.Math.Sqrt(1 - a));
-        var distanceKm = EarthRadiusKm * c;
+        var distanceKm = earthRadiusKm * c;
 
         return measurement switch
         {
@@ -62,4 +62,44 @@ public static double Distance(
             _ => throw new SwitchCaseDefaultException(measurement),
         };
     }
+
+    /// <summary>
+    /// Calculates the initial bearing (forward azimuth) from one geographic coordinate to another.
+    /// The bearing is the angle measured clockwise from true north (0°) to the direction of travel.
+    /// </summary>
+    /// <param name="coordinate1">The starting coordinate.</param>
+    /// <param name="coordinate2">The destination coordinate.</param>
+    /// <returns>The initial bearing in degrees (0–360), where 0° is north, 90° east, 180° south, 270° west.</returns>
+    public static double Bearing(
+        CartesianCoordinate coordinate1,
+        CartesianCoordinate coordinate2)
+        => Bearing(coordinate1.Longitude, coordinate1.Latitude, coordinate2.Longitude, coordinate2.Latitude);
+
+    /// <summary>
+    /// Calculates the initial bearing (forward azimuth) from one geographic point to another.
+    /// The bearing is the angle measured clockwise from true north (0°) to the direction of travel.
+    /// </summary>
+    /// <param name="longitude1">The longitude of the starting point in degrees.</param>
+    /// <param name="latitude1">The latitude of the starting point in degrees.</param>
+    /// <param name="longitude2">The longitude of the destination point in degrees.</param>
+    /// <param name="latitude2">The latitude of the destination point in degrees.</param>
+    /// <returns>The initial bearing in degrees (0–360), where 0° is north, 90° east, 180° south, 270° west.</returns>
+    public static double Bearing(
+        double longitude1,
+        double latitude1,
+        double longitude2,
+        double latitude2)
+    {
+        var lat1Rad = MathHelper.DegreesToRadians(latitude1);
+        var lat2Rad = MathHelper.DegreesToRadians(latitude2);
+        var dLonRad = MathHelper.DegreesToRadians(longitude2 - longitude1);
+
+        var y = System.Math.Sin(dLonRad) * System.Math.Cos(lat2Rad);
+        var x = (System.Math.Cos(lat1Rad) * System.Math.Sin(lat2Rad)) -
+                (System.Math.Sin(lat1Rad) * System.Math.Cos(lat2Rad) * System.Math.Cos(dLonRad));
+
+        var bearingRad = System.Math.Atan2(y, x);
+        var bearingDeg = MathHelper.RadiansToDegrees(bearingRad) + 360.0;
+        return bearingDeg % 360.0;
+    }
 }
\ No newline at end of file
diff --git a/src/Atc/Math/GeoSpatial/UniversalTransverseMercatorConverter.cs b/src/Atc/Math/GeoSpatial/UniversalTransverseMercatorConverter.cs
index 9e2e839a..c09a74b4 100644
--- a/src/Atc/Math/GeoSpatial/UniversalTransverseMercatorConverter.cs
+++ b/src/Atc/Math/GeoSpatial/UniversalTransverseMercatorConverter.cs
@@ -140,6 +140,27 @@ public UniversalTransverseMercatorResult ToUtm(
         return new UniversalTransverseMercatorResult(zoneNumber, utmZone, utmEasting, utmNorthing);
     }
 
+    /// <summary>
+    /// Converts a <see cref="UniversalTransverseMercatorResult"/> back to a WGS84 geographic coordinate.
+    /// This is a convenience overload that unpacks the fields from the result returned by <see cref="ToUtm(CartesianCoordinate)"/> or <see cref="ToUtm(double,double)"/>.
+    /// </summary>
+    /// <param name="utmResult">The UTM result to convert.</param>
+    /// <param name="maxDecimalPrecision">The maximum number of decimal places in the returned latitude/longitude values.</param>
+    /// <returns>A <see cref="CartesianCoordinate"/> containing the WGS84 latitude and longitude.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="utmResult"/> is null.</exception>
+    [SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "OK.")]
+    public CartesianCoordinate ToWgs84(
+        UniversalTransverseMercatorResult utmResult,
+        int maxDecimalPrecision = 8)
+    {
+        if (utmResult is null)
+        {
+            throw new ArgumentNullException(nameof(utmResult));
+        }
+
+        return ToWgs84(utmResult.ZoneNumber, utmResult.ZoneLetter, utmResult.UtmEasting, utmResult.UtmNorthing, maxDecimalPrecision);
+    }
+
     /// <summary>
     /// To WGS84.
     /// </summary>

From e75fa40551e189f25354411653a052f234845649 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 15:38:39 +0200
Subject: [PATCH 081/100] =?UTF-8?q?perf(atc-rest):=20optimize=20ServiceCol?=
 =?UTF-8?q?lectionExtensions=20auto-registration=20from=20O(n=C2=B2)=20to?=
 =?UTF-8?q?=20O(n)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

AutoRegistrateServices: build a lookup keyed by interface FullName so each interface
maps to its implementations in O(1) instead of rescanning all types per interface.
ValidateServiceRegistrations: build a HashSet of registered service types for O(1)
contains-check instead of O(services) per interface.
---
 .../ServiceCollectionExtensions.cs            | 31 ++++++++++---------
 1 file changed, 16 insertions(+), 15 deletions(-)

diff --git a/src/Atc.Rest/Extensions/ServiceCollection/ServiceCollectionExtensions.cs b/src/Atc.Rest/Extensions/ServiceCollection/ServiceCollectionExtensions.cs
index 53d73439..999f4a6e 100644
--- a/src/Atc.Rest/Extensions/ServiceCollection/ServiceCollectionExtensions.cs
+++ b/src/Atc.Rest/Extensions/ServiceCollection/ServiceCollectionExtensions.cs
@@ -34,23 +34,23 @@ public static void AutoRegistrateServices(
             .DefinedTypes
             .ToArray();
 
+        // Build a lookup keyed by interface FullName to avoid an O(interfaces × types) double loop.
+        var implementationLookup = implementationTypes
+            .SelectMany(t => t.GetInterfaces(), (t, i) => (InterfaceName: i.FullName, Type: t))
+            .Where(x => x.InterfaceName is not null)
+            .ToLookup(x => x.InterfaceName!, x => x.Type, StringComparer.Ordinal);
+
         foreach (var implementationInterface in implementationInterfaces)
         {
-            foreach (var implementationType in implementationTypes)
+            var matchingType = implementationLookup[implementationInterface.FullName ?? string.Empty].FirstOrDefault();
+            if (matchingType is null)
             {
-                if (implementationType
-                        .GetInterfaces()
-                        .FirstOrDefault(x => string.Equals(x.FullName, implementationInterface.FullName, StringComparison.Ordinal)) is null)
-                {
-                    continue;
-                }
-
-                if (!IsImplementationTypeRegistered(services, implementationType))
-                {
-                    services.AddTransient(implementationInterface, implementationType);
-                }
+                continue;
+            }
 
-                break;
+            if (!IsImplementationTypeRegistered(services, matchingType))
+            {
+                services.AddTransient(implementationInterface, matchingType);
             }
         }
     }
@@ -68,11 +68,12 @@ public static void ValidateServiceRegistrations(
         ArgumentNullException.ThrowIfNull(services);
         ArgumentNullException.ThrowIfNull(apiAssembly);
 
+        var registeredServiceTypes = new HashSet<Type>(services.Select(x => x.ServiceType));
+
         var notRegistered = apiAssembly
             .DefinedTypes
             .Where(x => x.IsInterface)
-            .Where(typeInfo => services
-                .All(x => x.ServiceType != typeInfo))
+            .Where(typeInfo => !registeredServiceTypes.Contains(typeInfo))
             .ToList();
 
         if (notRegistered.Count <= 0)

From d7b7653dbb5180e948bfeb18e40a51cef8a2dfe5 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 15:40:21 +0200
Subject: [PATCH 082/100] fix(atc-rest): avoid PII/cost in App Insights
 BadRequest trace from ConfigureApiBehaviorOptions

Previously serialized the full ValidationProblemDetails (including user-submitted
field values) into every 400 telemetry trace. Now logs only the invalid field names
and the correlation traceId, which is sufficient for diagnostics without capturing PII.
---
 src/Atc.Rest/Options/ConfigureApiBehaviorOptions.cs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/Atc.Rest/Options/ConfigureApiBehaviorOptions.cs b/src/Atc.Rest/Options/ConfigureApiBehaviorOptions.cs
index 464f6cf9..63dd9e99 100644
--- a/src/Atc.Rest/Options/ConfigureApiBehaviorOptions.cs
+++ b/src/Atc.Rest/Options/ConfigureApiBehaviorOptions.cs
@@ -51,11 +51,14 @@ public void Configure(ApiBehaviorOptions options)
                 },
             };
 
+            // Log only the field names (not values) to avoid capturing PII or user-submitted data in telemetry.
+            var invalidFields = string.Join(", ", error.Errors.Keys);
             telemetry?.TrackTrace(
                 "BadRequest",
                 new Dictionary<string, string>(StringComparer.Ordinal)
                 {
-                    { "Response.Body", JsonSerializer.Serialize(error) },
+                    { "InvalidFields", invalidFields },
+                    { "TraceId", error.Extensions.TryGetValue("traceId", out var traceId) ? traceId?.ToString() ?? string.Empty : string.Empty },
                 });
 
             return new BadRequestObjectResult(error);

From 1fa7ceeb73b60c0f6c4bd823f2ef7b28164bd847 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 15:46:18 +0200
Subject: [PATCH 083/100] feat(atc): add ExecuteWithSeparateOutput to
 ProcessHelper
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Expose stdout and stderr as distinct fields by changing InvokeExecuteWithProcessId
return type to (IsSuccessful, StdOut, StdErr, ProcessId), adding the new
InvokeExecuteWithTimeoutSeparate private helper, and surfacing two public
ExecuteWithSeparateOutput overloads (FileInfo and DirectoryInfo+FileInfo).
Existing Execute overloads are unaffected — they still combine stdout/stderr.
---
 src/Atc/Helpers/ProcessHelper.cs | 176 +++++++++++++++++++++++++++++--
 1 file changed, 165 insertions(+), 11 deletions(-)

diff --git a/src/Atc/Helpers/ProcessHelper.cs b/src/Atc/Helpers/ProcessHelper.cs
index 0753b193..6a694969 100644
--- a/src/Atc/Helpers/ProcessHelper.cs
+++ b/src/Atc/Helpers/ProcessHelper.cs
@@ -111,6 +111,103 @@ public static class ProcessHelper
             cancellationToken);
     }
 
+    /// <summary>
+    /// Executes a process with the specified file and arguments, returning standard output and standard error separately.
+    /// </summary>
+    /// <param name="fileInfo">The executable file to run.</param>
+    /// <param name="arguments">The command-line arguments to pass to the executable.</param>
+    /// <param name="runAsAdministrator">If <see langword="true"/>, attempts to run the process with elevated privileges.</param>
+    /// <param name="timeoutInSec">The maximum time in seconds to wait for the process to complete. Default is 30 seconds.</param>
+    /// <param name="cancellationToken">A token to cancel the operation.</param>
+    /// <returns>A task that returns a tuple containing success status, standard output, and standard error streams separately.</returns>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="fileInfo"/> or <paramref name="arguments"/> is <see langword="null"/>.</exception>
+    /// <exception cref="FileNotFoundException">Thrown if the specified file does not exist.</exception>
+    public static Task<(
+        bool IsSuccessful,
+        string StdOut,
+        string StdErr)> ExecuteWithSeparateOutput(
+        FileInfo fileInfo,
+        string arguments,
+        bool runAsAdministrator = false,
+        ushort timeoutInSec = DefaultTimeoutInSec,
+        CancellationToken cancellationToken = default)
+    {
+        if (fileInfo is null)
+        {
+            throw new ArgumentNullException(nameof(fileInfo));
+        }
+
+        if (arguments is null)
+        {
+            throw new ArgumentNullException(nameof(arguments));
+        }
+
+        if (!File.Exists(fileInfo.FullName))
+        {
+            throw new FileNotFoundException(nameof(fileInfo));
+        }
+
+        return InvokeExecuteWithTimeoutSeparate(
+            workingDirectory: null,
+            fileInfo,
+            arguments,
+            runAsAdministrator,
+            timeoutInSec,
+            cancellationToken);
+    }
+
+    /// <summary>
+    /// Executes a process with the specified working directory, file, and arguments, returning standard output and standard error separately.
+    /// </summary>
+    /// <param name="workingDirectory">The working directory for the process.</param>
+    /// <param name="fileInfo">The executable file to run.</param>
+    /// <param name="arguments">The command-line arguments to pass to the executable.</param>
+    /// <param name="runAsAdministrator">If <see langword="true"/>, attempts to run the process with elevated privileges.</param>
+    /// <param name="timeoutInSec">The maximum time in seconds to wait for the process to complete. Default is 30 seconds.</param>
+    /// <param name="cancellationToken">A token to cancel the operation.</param>
+    /// <returns>A task that returns a tuple containing success status, standard output, and standard error streams separately.</returns>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="workingDirectory"/>, <paramref name="fileInfo"/>, or <paramref name="arguments"/> is <see langword="null"/>.</exception>
+    /// <exception cref="FileNotFoundException">Thrown if the specified file does not exist.</exception>
+    public static Task<(
+        bool IsSuccessful,
+        string StdOut,
+        string StdErr)> ExecuteWithSeparateOutput(
+        DirectoryInfo workingDirectory,
+        FileInfo fileInfo,
+        string arguments,
+        bool runAsAdministrator = false,
+        ushort timeoutInSec = DefaultTimeoutInSec,
+        CancellationToken cancellationToken = default)
+    {
+        if (workingDirectory is null)
+        {
+            throw new ArgumentNullException(nameof(workingDirectory));
+        }
+
+        if (fileInfo is null)
+        {
+            throw new ArgumentNullException(nameof(fileInfo));
+        }
+
+        if (arguments is null)
+        {
+            throw new ArgumentNullException(nameof(arguments));
+        }
+
+        if (!File.Exists(fileInfo.FullName))
+        {
+            throw new FileNotFoundException(nameof(fileInfo));
+        }
+
+        return InvokeExecuteWithTimeoutSeparate(
+            workingDirectory,
+            fileInfo,
+            arguments,
+            runAsAdministrator,
+            timeoutInSec,
+            cancellationToken);
+    }
+
     /// <summary>
     /// Executes a process without capturing its output, returning only success status.
     /// </summary>
@@ -650,13 +747,27 @@ public static (bool IsSuccessful, string Output) KillByName(
 
         try
         {
-            var (isSuccessful, output, _) = await TaskHelper
+            var (isSuccessful, stdOut, stdErr, _) = await TaskHelper
                 .Execute(
                     _ => InvokeExecuteWithProcessId(workingDirectory, fileInfo, arguments, runAsAdministrator, id => Volatile.Write(ref processIdHolder[0], id)),
                     TimeSpan.FromSeconds(timeoutInSec),
                     cancellationToken)
                 .ConfigureAwait(false);
 
+            string output;
+            if (string.IsNullOrEmpty(stdErr))
+            {
+                output = stdOut;
+            }
+            else if (string.IsNullOrEmpty(stdOut))
+            {
+                output = stdErr;
+            }
+            else
+            {
+                output = $"{stdOut}{Environment.NewLine}{stdErr}";
+            }
+
             resultOutput = output;
 
             return (IsSuccessful: isSuccessful, Output: output);
@@ -691,6 +802,53 @@ public static (bool IsSuccessful, string Output) KillByName(
         }
     }
 
+    private static async Task<(
+        bool IsSuccessful,
+        string StdOut,
+        string StdErr)> InvokeExecuteWithTimeoutSeparate(
+        DirectoryInfo? workingDirectory,
+        FileInfo fileInfo,
+        string arguments,
+        bool runAsAdministrator,
+        ushort timeoutInSec,
+        CancellationToken cancellationToken)
+    {
+        var processIdHolder = new[] { -1 };
+
+        try
+        {
+            var (isSuccessful, stdOut, stdErr, _) = await TaskHelper
+                .Execute(
+                    _ => InvokeExecuteWithProcessId(workingDirectory, fileInfo, arguments, runAsAdministrator, id => Volatile.Write(ref processIdHolder[0], id)),
+                    TimeSpan.FromSeconds(timeoutInSec),
+                    cancellationToken)
+                .ConfigureAwait(false);
+
+            return (IsSuccessful: isSuccessful, StdOut: stdOut, StdErr: stdErr);
+        }
+        catch (TimeoutException)
+        {
+            var processId = Volatile.Read(ref processIdHolder[0]);
+            string stdErr;
+            if (processId > 0)
+            {
+                var (killIsSuccessful, _) = KillById(processId);
+                stdErr = killIsSuccessful
+                    ? $"Process has been running for {timeoutInSec} seconds. before terminated."
+                    : $"Process has been running for {timeoutInSec} seconds.";
+            }
+            else
+            {
+                stdErr = $"Process has been running for {timeoutInSec} seconds.";
+            }
+
+            return (
+                IsSuccessful: false,
+                StdOut: string.Empty,
+                StdErr: stdErr);
+        }
+    }
+
     private static async Task<bool> InvokeExecuteWithTimeoutAndIgnoreOutput(
         DirectoryInfo? workingDirectory,
         FileInfo fileInfo,
@@ -809,11 +967,11 @@ await process
         }
     }
 
-    [SuppressMessage("Major Code Smell", "S3358:Ternary operators should not be nested", Justification = "OK.")]
     [SuppressMessage("Microsoft.Design", "CA1031:Do not catch general exception types", Justification = "OK.")]
     private static async Task<(
         bool IsSuccessful,
-        string Output,
+        string StdOut,
+        string StdErr,
         int ProcessId)> InvokeExecuteWithProcessId(
         DirectoryInfo? workingDirectory,
         FileInfo fileInfo,
@@ -848,24 +1006,20 @@ await process
             var standardOutput = await standardOutputTask.ConfigureAwait(false);
             var standardError = await standardErrorTask.ConfigureAwait(false);
 
-            var message = string.IsNullOrEmpty(standardError)
-                ? standardOutput
-                : string.IsNullOrEmpty(standardOutput)
-                    ? standardError
-                    : $"{standardOutput}{Environment.NewLine}{standardError}";
-
             return (
                 IsSuccessful: process.ExitCode == ConsoleExitStatusCodes.Success,
-                Output: message,
+                StdOut: standardOutput,
+                StdErr: standardError,
                 ProcessId: processId);
         }
         catch (Exception ex)
         {
             return (
                 IsSuccessful: false,
-                Output: ex.GetMessage(
+                StdOut: ex.GetMessage(
                     includeInnerMessage: true,
                     includeExceptionName: true),
+                StdErr: string.Empty,
                 ProcessId: processId);
         }
     }

From c0b4e4cc2ea236a01c8b2383082a76a998d1d593 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 15:55:02 +0200
Subject: [PATCH 084/100] feat(atc-codeanalysis-csharp,atc-rest): add struct
 extensions and ObjectResult factory overloads

- StructDeclarationSyntaxExtensions: AddSuppressMessageAttribute and AddGeneratedCodeAttribute,
  mirroring the existing Class/Interface/Record extension pattern.
- ResultFactory: add CreateObjectResultWithProblemDetails and CreateObjectResultWithValidationProblemDetails
  overloads that return ObjectResult so ASP.NET Core output formatters apply app-configured
  JsonSerializerOptions instead of bypassing them.
- ErrorHandlingExceptionFilterAttribute: use ObjectResult for the ProblemDetails path,
  removing the manual JsonSerializer.Serialize call.
- docs/CodeDoc: regenerated entries for JsonSerializerOptionsFactory.Default and IsBinarySequence
  (documentation for APIs added in prior commits).
---
 docs/CodeDoc/Atc/Atc.Serialization.md         |  7 ++
 docs/CodeDoc/Atc/IndexExtended.md             |  3 +
 docs/CodeDoc/Atc/System.md                    | 10 ++
 .../StructDeclarationSyntaxExtensions.cs      | 91 +++++++++++++++++++
 .../ErrorHandlingExceptionFilterAttribute.cs  | 24 +++--
 src/Atc.Rest/Results/ResultFactory.cs         | 63 ++++++++++++-
 6 files changed, 186 insertions(+), 12 deletions(-)
 create mode 100644 src/Atc.CodeAnalysis.CSharp/Extensions/StructDeclarationSyntaxExtensions.cs

diff --git a/docs/CodeDoc/Atc/Atc.Serialization.md b/docs/CodeDoc/Atc/Atc.Serialization.md
index a2c13387..6ffa82ac 100644
--- a/docs/CodeDoc/Atc/Atc.Serialization.md
+++ b/docs/CodeDoc/Atc/Atc.Serialization.md
@@ -219,6 +219,13 @@ Factory class for creating preconfigured `System.Text.Json.JsonSerializerOptions
 >public static class JsonSerializerOptionsFactory
 >```
 
+### Static Properties
+
+#### Default
+>```csharp
+>Default
+>```
+><b>Summary:</b> Gets a cached, shared `System.Text.Json.JsonSerializerOptions` instance using the default settings (camelCase, null-values ignored, case-insensitive names, indented output). The instance is created once and reused; after the first serialization call it becomes read-only. Use `Atc.Serialization.JsonSerializerOptionsFactory.Create(System.Boolean,System.Boolean,System.Boolean,System.Boolean)` when you need a mutable copy.
 ### Static Methods
 
 #### Create
diff --git a/docs/CodeDoc/Atc/IndexExtended.md b/docs/CodeDoc/Atc/IndexExtended.md
index 320fd9b0..a793dd34 100644
--- a/docs/CodeDoc/Atc/IndexExtended.md
+++ b/docs/CodeDoc/Atc/IndexExtended.md
@@ -4903,6 +4903,8 @@
      - SerializeToStreamAsync(T value, Stream stream, CancellationToken cancellationToken = null)
      - SerializeToStreamAsync(T value, Stream stream, JsonSerializerOptions options, CancellationToken cancellationToken = null)
 - [JsonSerializerOptionsFactory](Atc.Serialization.md#jsonserializeroptionsfactory)
+  -  Static Properties
+     - Default
   -  Static Methods
      - Create(JsonSerializerFactorySettings settings)
      - Create(bool useCamelCase = True, bool ignoreNullValues = True, bool propertyNameCaseInsensitive = True, bool writeIndented = True)
@@ -5251,6 +5253,7 @@
   -  Static Methods
      - FromUnixTime(this long valueInSeconds)
      - FromUnixTimeMs(this long valueInMs)
+     - IsBinarySequence(this long number)
 - [NullException](System.md#nullexception)
 - [ObjectExtensions](System.md#objectextensions)
   -  Static Methods
diff --git a/docs/CodeDoc/Atc/System.md b/docs/CodeDoc/Atc/System.md
index abd5e7e4..3d0ecad3 100644
--- a/docs/CodeDoc/Atc/System.md
+++ b/docs/CodeDoc/Atc/System.md
@@ -2209,6 +2209,16 @@ Extensions for the `System.Int64` class.
 >long unixTime = 0; // Equivalent to 1-1-1970
 >DateTimeOffset dateTimeOffset = unixTime.FromUnixTimeMs();
 >```
+#### IsBinarySequence
+>```csharp
+>bool IsBinarySequence(this long number)
+>```
+><b>Summary:</b> Determines whether the value is a binary sequence (a power of two), meaning exactly one bit is set.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`number`&nbsp;&nbsp;-&nbsp;&nbsp;The number to evaluate.<br />
+>
+><b>Returns:</b> <see langword="true" /> if `number` is a positive power of two; otherwise, <see langword="false" />.
 
 <br />
 
diff --git a/src/Atc.CodeAnalysis.CSharp/Extensions/StructDeclarationSyntaxExtensions.cs b/src/Atc.CodeAnalysis.CSharp/Extensions/StructDeclarationSyntaxExtensions.cs
new file mode 100644
index 00000000..82c186b4
--- /dev/null
+++ b/src/Atc.CodeAnalysis.CSharp/Extensions/StructDeclarationSyntaxExtensions.cs
@@ -0,0 +1,91 @@
+// ReSharper disable once CheckNamespace
+namespace Microsoft.CodeAnalysis.CSharp.Syntax;
+
+/// <summary>
+/// Extension methods for <see cref="StructDeclarationSyntax"/>.
+/// </summary>
+public static class StructDeclarationSyntaxExtensions
+{
+    /// <summary>
+    /// Adds a <see cref="SuppressMessageAttribute"/> to the struct declaration.
+    /// </summary>
+    /// <param name="structDeclaration">The struct declaration to modify.</param>
+    /// <param name="suppressMessage">The suppress message attribute to add.</param>
+    /// <returns>A new <see cref="StructDeclarationSyntax"/> with the attribute added.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="structDeclaration"/> or <paramref name="suppressMessage"/> is null.</exception>
+    /// <exception cref="ArgumentException">Thrown when the justification in <paramref name="suppressMessage"/> is invalid.</exception>
+    public static StructDeclarationSyntax AddSuppressMessageAttribute(
+        this StructDeclarationSyntax structDeclaration,
+        SuppressMessageAttribute suppressMessage)
+    {
+        if (structDeclaration is null)
+        {
+            throw new ArgumentNullException(nameof(structDeclaration));
+        }
+
+        if (suppressMessage is null)
+        {
+            throw new ArgumentNullException(nameof(suppressMessage));
+        }
+
+        if (string.IsNullOrEmpty(suppressMessage.Justification))
+        {
+            throw new ArgumentException("Justification is invalid.", nameof(suppressMessage));
+        }
+
+        var attributeArgumentList = SyntaxFactory.AttributeArgumentList(
+            SyntaxFactory.SeparatedList<AttributeArgumentSyntax>(
+                SyntaxFactory.NodeOrTokenList(
+                    SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.Category)),
+                    SyntaxTokenFactory.Comma(),
+                    SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.CheckId)),
+                    SyntaxTokenFactory.Comma(),
+                    SyntaxFactory
+                        .AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.Justification!))
+                        .WithNameEquals(
+                        SyntaxNameEqualsFactory
+                            .Create(nameof(SuppressMessageAttribute.Justification))
+                            .WithEqualsToken(SyntaxTokenFactory.Equals())))));
+
+        return structDeclaration
+            .AddAttributeLists(SyntaxAttributeListFactory.Create(nameof(SuppressMessageAttribute), attributeArgumentList));
+    }
+
+    /// <summary>
+    /// Adds a <see cref="GeneratedCodeAttribute"/> to the struct declaration.
+    /// </summary>
+    /// <param name="structDeclaration">The struct declaration to modify.</param>
+    /// <param name="toolName">The name of the code generation tool.</param>
+    /// <param name="version">The version of the code generation tool.</param>
+    /// <returns>A new <see cref="StructDeclarationSyntax"/> with the attribute added.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="structDeclaration"/>, <paramref name="toolName"/>, or <paramref name="version"/> is null.</exception>
+    public static StructDeclarationSyntax AddGeneratedCodeAttribute(
+        this StructDeclarationSyntax structDeclaration,
+        string toolName,
+        string version)
+    {
+        if (structDeclaration is null)
+        {
+            throw new ArgumentNullException(nameof(structDeclaration));
+        }
+
+        if (toolName is null)
+        {
+            throw new ArgumentNullException(nameof(toolName));
+        }
+
+        if (version is null)
+        {
+            throw new ArgumentNullException(nameof(version));
+        }
+
+        var attributeArgumentList = SyntaxFactory.AttributeArgumentList(
+            SyntaxFactory.SeparatedList<AttributeArgumentSyntax>(SyntaxFactory.NodeOrTokenList(
+                SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(toolName)),
+                SyntaxTokenFactory.Comma(),
+                SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(version)))));
+
+        return structDeclaration
+            .AddAttributeLists(SyntaxAttributeListFactory.Create(nameof(GeneratedCodeAttribute), attributeArgumentList));
+    }
+}
\ No newline at end of file
diff --git a/src/Atc.Rest/Filters/ErrorHandlingExceptionFilterAttribute.cs b/src/Atc.Rest/Filters/ErrorHandlingExceptionFilterAttribute.cs
index 1e5ff54e..120e37d8 100644
--- a/src/Atc.Rest/Filters/ErrorHandlingExceptionFilterAttribute.cs
+++ b/src/Atc.Rest/Filters/ErrorHandlingExceptionFilterAttribute.cs
@@ -101,14 +101,24 @@ private static HttpStatusCode GetHttpStatusCodeByExceptionType(
 
     private void HandleException(ExceptionContext context)
     {
-        context.Result = new ContentResult
+        var statusCode = (int)GetHttpStatusCodeByExceptionType(context);
+
+        if (useProblemDetailsAsResponseBody)
+        {
+            context.Result = new ObjectResult(CreateProblemDetails(context))
+            {
+                StatusCode = statusCode,
+            };
+        }
+        else
         {
-            ContentType = MediaTypeNames.Application.Json,
-            StatusCode = (int)GetHttpStatusCodeByExceptionType(context),
-            Content = useProblemDetailsAsResponseBody
-                ? JsonSerializer.Serialize(CreateProblemDetails(context))
-                : CreateMessage(context),
-        };
+            context.Result = new ContentResult
+            {
+                ContentType = MediaTypeNames.Application.Json,
+                StatusCode = statusCode,
+                Content = CreateMessage(context),
+            };
+        }
     }
 
     [SuppressMessage("Globalization", "CA1305:Specify IFormatProvider", Justification = "OK.")]
diff --git a/src/Atc.Rest/Results/ResultFactory.cs b/src/Atc.Rest/Results/ResultFactory.cs
index 0838ded9..d073b13a 100644
--- a/src/Atc.Rest/Results/ResultFactory.cs
+++ b/src/Atc.Rest/Results/ResultFactory.cs
@@ -61,7 +61,7 @@ public static ContentResult CreateContentResultWithProblemDetails(
         {
             ContentType = contentType,
             StatusCode = (int)statusCode,
-            Content = JsonSerializer.Serialize(CreateProblemDetails(statusCode, message)),
+            Content = JsonSerializer.Serialize(CreateProblemDetails(statusCode, message), JsonSerializerOptionsFactory.Default),
         };
 
     /// <summary>
@@ -93,11 +93,11 @@ public static ContentResult CreateContentResultWithProblemDetails(
 
         var message = SimpleTypeHelper.IsSimpleType(beautifyTypeName)
             ? value.ToString()
-            : JsonSerializer.Serialize(value);
+            : JsonSerializer.Serialize(value, JsonSerializerOptionsFactory.Default);
 
         var problemDetails = CreateProblemDetails(statusCode, message);
 
-        result.Content = JsonSerializer.Serialize(problemDetails);
+        result.Content = JsonSerializer.Serialize(problemDetails, JsonSerializerOptionsFactory.Default);
 
         return result;
     }
@@ -117,7 +117,7 @@ public static ContentResult CreateContentResultWithValidationProblemDetails(
         {
             ContentType = contentType,
             StatusCode = (int)statusCode,
-            Content = JsonSerializer.Serialize(CreateValidationProblemDetails(statusCode, new Dictionary<string, string[]>(StringComparer.Ordinal), message)),
+            Content = JsonSerializer.Serialize(CreateValidationProblemDetails(statusCode, new Dictionary<string, string[]>(StringComparer.Ordinal), message), JsonSerializerOptionsFactory.Default),
         };
 
     /// <summary>
@@ -137,7 +137,60 @@ public static ContentResult CreateContentResultWithValidationProblemDetails(
         {
             ContentType = contentType,
             StatusCode = (int)statusCode,
-            Content = JsonSerializer.Serialize(CreateValidationProblemDetails(statusCode, errors, message)),
+            Content = JsonSerializer.Serialize(CreateValidationProblemDetails(statusCode, errors, message), JsonSerializerOptionsFactory.Default),
+        };
+
+    /// <summary>
+    /// Creates an <see cref="ObjectResult"/> containing ProblemDetails, allowing ASP.NET Core's
+    /// output formatters to serialize it using the app-configured <see cref="JsonSerializerOptions"/>.
+    /// Prefer this over <see cref="CreateContentResultWithProblemDetails(HttpStatusCode, string?, string)"/>
+    /// when consistent casing with the rest of the API is required.
+    /// </summary>
+    /// <param name="statusCode">The HTTP status code.</param>
+    /// <param name="message">The detail message describing the problem.</param>
+    /// <returns>An <see cref="ObjectResult"/> wrapping a <see cref="ProblemDetails"/> instance.</returns>
+    public static ObjectResult CreateObjectResultWithProblemDetails(
+        HttpStatusCode statusCode,
+        string? message)
+        => new(CreateProblemDetails(statusCode, message))
+        {
+            StatusCode = (int)statusCode,
+        };
+
+    /// <summary>
+    /// Creates an <see cref="ObjectResult"/> containing ValidationProblemDetails without field-specific errors,
+    /// allowing ASP.NET Core's output formatters to serialize it using the app-configured <see cref="JsonSerializerOptions"/>.
+    /// Prefer this over <see cref="CreateContentResultWithValidationProblemDetails(HttpStatusCode, string?, string)"/>
+    /// when consistent casing with the rest of the API is required.
+    /// </summary>
+    /// <param name="statusCode">The HTTP status code.</param>
+    /// <param name="message">The detail message describing the validation failure.</param>
+    /// <returns>An <see cref="ObjectResult"/> wrapping a <see cref="ValidationProblemDetails"/> instance.</returns>
+    public static ObjectResult CreateObjectResultWithValidationProblemDetails(
+        HttpStatusCode statusCode,
+        string? message)
+        => new(CreateValidationProblemDetails(statusCode, new Dictionary<string, string[]>(StringComparer.Ordinal), message))
+        {
+            StatusCode = (int)statusCode,
+        };
+
+    /// <summary>
+    /// Creates an <see cref="ObjectResult"/> containing ValidationProblemDetails with field-specific errors,
+    /// allowing ASP.NET Core's output formatters to serialize it using the app-configured <see cref="JsonSerializerOptions"/>.
+    /// Prefer this over <see cref="CreateContentResultWithValidationProblemDetails(HttpStatusCode, Dictionary{string, string[]}, string?, string)"/>
+    /// when consistent casing with the rest of the API is required.
+    /// </summary>
+    /// <param name="statusCode">The HTTP status code.</param>
+    /// <param name="errors">A dictionary of field names and their associated validation errors.</param>
+    /// <param name="message">The detail message describing the validation failure.</param>
+    /// <returns>An <see cref="ObjectResult"/> wrapping a <see cref="ValidationProblemDetails"/> instance.</returns>
+    public static ObjectResult CreateObjectResultWithValidationProblemDetails(
+        HttpStatusCode statusCode,
+        Dictionary<string, string[]> errors,
+        string? message)
+        => new(CreateValidationProblemDetails(statusCode, errors, message))
+        {
+            StatusCode = (int)statusCode,
         };
 
     /// <summary>

From 995e97881b620204a6655babb6d5d2a24bdf8cba Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 16:00:42 +0200
Subject: [PATCH 085/100] fix(atc): use CurrentCulture (not CurrentUICulture)
 in CurrencyRounding

CurrencyRoundingAsInteger/CurrencyRounding on decimal and double used
Thread.CurrentThread.CurrentUICulture.NumberFormat.CurrencyDecimalDigits.
The UI culture controls resource language, not regional number format;
currency rounding should follow CultureInfo.CurrentCulture.
---
 src/Atc/Extensions/BaseTypes/DecimalExtensions.cs | 4 ++--
 src/Atc/Extensions/BaseTypes/DoubleExtensions.cs  | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/Atc/Extensions/BaseTypes/DecimalExtensions.cs b/src/Atc/Extensions/BaseTypes/DecimalExtensions.cs
index 61741dfe..d570a3bf 100644
--- a/src/Atc/Extensions/BaseTypes/DecimalExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/DecimalExtensions.cs
@@ -122,12 +122,12 @@ public static int CurrencyRoundingAsInteger(this decimal value)
         => (int)CurrencyRounding(value, 0);
 
     /// <summary>
-    /// Rounds a decimal value using the currency decimal digits of the current UI culture.
+    /// Rounds a decimal value using the currency decimal digits of the current culture.
     /// </summary>
     /// <param name="value">The decimal value to round.</param>
     /// <returns>The rounded decimal value.</returns>
     public static decimal CurrencyRounding(this decimal value)
-        => CurrencyRounding(value, Thread.CurrentThread.CurrentUICulture.NumberFormat.CurrencyDecimalDigits);
+        => CurrencyRounding(value, CultureInfo.CurrentCulture.NumberFormat.CurrencyDecimalDigits);
 
     /// <summary>
     /// Rounds a decimal value to a specified number of decimal digits using midpoint rounding away from zero.
diff --git a/src/Atc/Extensions/BaseTypes/DoubleExtensions.cs b/src/Atc/Extensions/BaseTypes/DoubleExtensions.cs
index db19993e..a1cb0588 100644
--- a/src/Atc/Extensions/BaseTypes/DoubleExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/DoubleExtensions.cs
@@ -129,12 +129,12 @@ public static int CurrencyRoundingAsInteger(this double value)
         => (int)CurrencyRounding(value, 0);
 
     /// <summary>
-    /// Rounds a double value using the currency decimal digits of the current UI culture.
+    /// Rounds a double value using the currency decimal digits of the current culture.
     /// </summary>
     /// <param name="value">The double value to round.</param>
     /// <returns>The rounded double value.</returns>
     public static double CurrencyRounding(this double value)
-        => CurrencyRounding(value, Thread.CurrentThread.CurrentUICulture.NumberFormat.CurrencyDecimalDigits);
+        => CurrencyRounding(value, CultureInfo.CurrentCulture.NumberFormat.CurrencyDecimalDigits);
 
     /// <summary>
     /// Rounds a double value to a specified number of decimal digits using midpoint rounding away from zero.

From 1457696d528d7a008c2824490aa17a350633fafc Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 16:04:40 +0200
Subject: [PATCH 086/100] fix(atc): fix GetFileVersion for single-file
 published assemblies

When Assembly.Location is empty (single-file publish), FileVersionInfo returns null.
Now falls back to AssemblyFileVersionAttribute so callers get the correct version
string instead of the 1.0.0.0 sentinel.
---
 .../Reflection/AssemblyExtensions.cs          | 22 ++++++++++++++-----
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/src/Atc/Extensions/Reflection/AssemblyExtensions.cs b/src/Atc/Extensions/Reflection/AssemblyExtensions.cs
index 57be036a..6a858135 100644
--- a/src/Atc/Extensions/Reflection/AssemblyExtensions.cs
+++ b/src/Atc/Extensions/Reflection/AssemblyExtensions.cs
@@ -9,6 +9,8 @@ public static class AssemblyExtensions
 {
     /// <summary>
     /// Gets the file version of the assembly.
+    /// Falls back to <see cref="AssemblyFileVersionAttribute"/> when the assembly location is
+    /// unavailable (e.g., single-file published apps where <see cref="Assembly.Location"/> is empty).
     /// </summary>
     /// <param name="assembly">The assembly to query.</param>
     /// <returns>The file version, or 1.0.0.0 if the version cannot be determined.</returns>
@@ -20,15 +22,23 @@ public static Version GetFileVersion(this Assembly assembly)
             throw new ArgumentNullException(nameof(assembly));
         }
 
-        var fileVersion = FileVersionInfo.GetVersionInfo(assembly.Location).FileVersion;
-        if (fileVersion is null)
+        var location = assembly.Location;
+        if (!string.IsNullOrEmpty(location))
         {
-            return new Version(1, 0, 0, 0);
+            var fileVersion = FileVersionInfo.GetVersionInfo(location).FileVersion;
+            if (fileVersion is not null && Version.TryParse(fileVersion, out var fvVersion))
+            {
+                return fvVersion;
+            }
+        }
+
+        var attr = assembly.GetCustomAttribute<AssemblyFileVersionAttribute>();
+        if (attr is not null && Version.TryParse(attr.Version, out var attrVersion))
+        {
+            return attrVersion;
         }
 
-        return Version.TryParse(fileVersion, out var version)
-            ? version
-            : new Version(1, 0, 0, 0);
+        return new Version(1, 0, 0, 0);
     }
 
     /// <summary>

From a37ef6eaaada80c29b660ec8ccd55436e4365e99 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 16:07:17 +0200
Subject: [PATCH 087/100] perf(atc-rest-healthchecks): stream JSON directly to
 response body, use cached options

HealthCheckOptionsFactory.CreateJson previously serialized the health-check
response to an intermediate string with a freshly-allocated JsonSerializerOptions
per request. Now:
- Uses JsonSerializer.SerializeAsync to write directly to HttpResponse.Body,
  eliminating the intermediate string allocation.
- Falls back to JsonSerializerOptionsFactory.Default (shared cached instance)
  instead of JsonSerializerOptionsFactory.Create() (new object per call).
- Remove redundant Microsoft.AspNetCore.Http global using (already available
  via the Microsoft.AspNetCore.App framework reference).
---
 .../Factories/HealthCheckOptionsFactory.cs                | 8 ++++----
 src/Atc.Rest.HealthChecks/GlobalUsings.cs                 | 1 -
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/Atc.Rest.HealthChecks/Factories/HealthCheckOptionsFactory.cs b/src/Atc.Rest.HealthChecks/Factories/HealthCheckOptionsFactory.cs
index 65e8ba2a..be8ef80f 100644
--- a/src/Atc.Rest.HealthChecks/Factories/HealthCheckOptionsFactory.cs
+++ b/src/Atc.Rest.HealthChecks/Factories/HealthCheckOptionsFactory.cs
@@ -33,10 +33,10 @@ public static HealthCheckOptions CreateJson(
                     r.Status,
                     r.TotalDuration);
 
-                await c.Response.WriteAsync(
-                    JsonSerializer.Serialize(
-                        response,
-                        jsonSerializerOptions ?? JsonSerializerOptionsFactory.Create()),
+                await JsonSerializer.SerializeAsync(
+                    c.Response.Body,
+                    response,
+                    jsonSerializerOptions ?? JsonSerializerOptionsFactory.Default,
                     c.RequestAborted);
             },
         };
diff --git a/src/Atc.Rest.HealthChecks/GlobalUsings.cs b/src/Atc.Rest.HealthChecks/GlobalUsings.cs
index f42fecc3..4affb6a3 100644
--- a/src/Atc.Rest.HealthChecks/GlobalUsings.cs
+++ b/src/Atc.Rest.HealthChecks/GlobalUsings.cs
@@ -4,5 +4,4 @@
 global using Atc.Rest.HealthChecks.Models;
 global using Atc.Serialization;
 global using Microsoft.AspNetCore.Diagnostics.HealthChecks;
-global using Microsoft.AspNetCore.Http;
 global using Microsoft.Extensions.Diagnostics.HealthChecks;
\ No newline at end of file

From 21eba0caaddb73cd65e638a7028b405592a5b8e1 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 16:11:26 +0200
Subject: [PATCH 088/100] fix(atc-rest-extended): remove blocking Task.Run+Wait
 from ConfigureAuthorizationOptions startup
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Removed the eager OIDC signing-key pre-fetch (Task.Run+Wait with a 30 s
timeout) from ConfigureAuthorizationOptions.PostConfigure. JwtBearer's
built-in ConfigurationManager already fetches and caches the OIDC
discovery document (including signing keys) on the first authentication
request via options.Authority — the manual pre-fetch was redundant and
blocked application startup for up to 30 s on slow or unreachable IdPs.

Removed the two GetIssuerSigningKeysAsync private methods and the unused
WellKnownOpenidConfiguration / SigningKeyFetchTimeout constants. Removed
the now-unused Microsoft.IdentityModel.Protocols global usings.
---
 src/Atc.Rest.Extended/GlobalUsings.cs         |  2 -
 .../Options/ConfigureAuthorizationOptions.cs  | 89 +++----------------
 2 files changed, 10 insertions(+), 81 deletions(-)

diff --git a/src/Atc.Rest.Extended/GlobalUsings.cs b/src/Atc.Rest.Extended/GlobalUsings.cs
index 34825d2d..f2a28811 100644
--- a/src/Atc.Rest.Extended/GlobalUsings.cs
+++ b/src/Atc.Rest.Extended/GlobalUsings.cs
@@ -31,8 +31,6 @@
 global using Microsoft.Extensions.Logging;
 global using Microsoft.Extensions.Options;
 global using Microsoft.IdentityModel.Logging;
-global using Microsoft.IdentityModel.Protocols;
-global using Microsoft.IdentityModel.Protocols.OpenIdConnect;
 global using Microsoft.IdentityModel.Tokens;
 global using Microsoft.OpenApi;
 
diff --git a/src/Atc.Rest.Extended/Options/ConfigureAuthorizationOptions.cs b/src/Atc.Rest.Extended/Options/ConfigureAuthorizationOptions.cs
index d1adad17..4f512a38 100644
--- a/src/Atc.Rest.Extended/Options/ConfigureAuthorizationOptions.cs
+++ b/src/Atc.Rest.Extended/Options/ConfigureAuthorizationOptions.cs
@@ -5,14 +5,13 @@ namespace Atc.Rest.Extended.Options;
 
 /// <summary>
 /// Post-configures JWT Bearer authentication and authorization options based on <see cref="RestApiExtendedOptions"/>.
-/// Handles issuer signing key retrieval from OpenID Connect configuration and token validation setup.
+/// Signing-key discovery is delegated to JwtBearer's built-in <see cref="Microsoft.IdentityModel.Protocols.ConfigurationManager{T}"/>,
+/// which fetches and caches the OIDC discovery document on the first authentication request using the <see cref="JwtBearerOptions.Authority"/> set here.
 /// </summary>
 public class ConfigureAuthorizationOptions :
     IPostConfigureOptions<JwtBearerOptions>,
     IPostConfigureOptions<AuthenticationOptions>
 {
-    private const string WellKnownOpenidConfiguration = ".well-known/openid-configuration";
-    private static readonly TimeSpan SigningKeyFetchTimeout = TimeSpan.FromSeconds(30);
     private readonly IWebHostEnvironment? environment;
     private readonly RestApiExtendedOptions apiOptions;
     private readonly ILogger<ConfigureAuthorizationOptions>? logger;
@@ -34,7 +33,9 @@ public ConfigureAuthorizationOptions(
     }
 
     /// <summary>
-    /// Post-configures JWT Bearer options with token validation parameters and issuer signing keys.
+    /// Post-configures JWT Bearer options with token validation parameters.
+    /// Signing keys are not pre-fetched; JwtBearer's built-in <see cref="Microsoft.IdentityModel.Protocols.ConfigurationManager{T}"/>
+    /// discovers and caches them from the OIDC discovery endpoint on the first authentication request.
     /// </summary>
     /// <param name="name">The name of the options instance being configured.</param>
     /// <param name="options">The <see cref="JwtBearerOptions"/> to configure.</param>
@@ -113,19 +114,11 @@ public void PostConfigure(
         options.TokenValidationParameters.ValidIssuer = apiOptions.Authorization.Issuer;
         options.TokenValidationParameters.ValidIssuers = apiOptions.Authorization.ValidIssuers ?? new List<string>();
 
-        // Run the async fetch on a thread-pool thread with a hard timeout so we cannot deadlock
-        // on a captured sync-context and cannot hang application startup indefinitely if an
-        // identity provider is unreachable.
-        var fetchTask = Task.Run(() => GetIssuerSigningKeysAsync(options));
-        if (!fetchTask.Wait(SigningKeyFetchTimeout))
-        {
-            logger?.LogWarning(
-                "Timed out fetching issuer signing keys after {TimeoutSeconds}s. Signature validation stays enabled and relies on the JwtBearer Authority metadata; tokens that cannot be signature-verified are rejected.",
-                SigningKeyFetchTimeout.TotalSeconds);
-            return;
-        }
-
-        options.TokenValidationParameters.IssuerSigningKeys = fetchTask.Result;
+        // Signing keys are discovered lazily by JwtBearer's built-in ConfigurationManager via options.Authority.
+        // Pre-fetching here blocked application startup for up to 30 s and duplicated JwtBearer's own mechanism.
+        logger?.LogInformation(
+            "JWT signing-key discovery deferred: keys will be fetched from {Authority} on the first authentication request.",
+            options.Authority);
     }
 
     /// <summary>
@@ -142,68 +135,6 @@ public void PostConfigure(
         options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
     }
 
-    /// <summary>
-    /// Retrieves issuer signing keys from the OpenID Connect configuration endpoint.
-    /// </summary>
-    /// <param name="issuer">The issuer URL.</param>
-    /// <returns>
-    /// A collection of security keys for token validation, or an empty array if retrieval failed
-    /// (the failure is logged via the configured <see cref="ILogger"/>; callers should treat an
-    /// empty result as "signing keys unavailable").
-    /// </returns>
-    [SuppressMessage("Microsoft.Design", "CA1031:Do not catch general exception types", Justification = "Failure to fetch keys must not abort startup; we log and return empty so the caller decides.")]
-    private async Task<IEnumerable<SecurityKey>> GetIssuerSigningKeysAsync(
-        string issuer)
-    {
-        try
-        {
-            var configurationManager = new ConfigurationManager<OpenIdConnectConfiguration>(
-                $"{issuer}/{WellKnownOpenidConfiguration}",
-                new OpenIdConnectConfigurationRetriever());
-
-            var configuration = await configurationManager.GetConfigurationAsync();
-            return configuration.SigningKeys;
-        }
-        catch (Exception e)
-        {
-            logger?.LogWarning(
-                e,
-                "Failed to retrieve OpenID Connect signing keys from {Issuer}. Token validation will fall back to an empty key set for this issuer.",
-                issuer);
-            return Array.Empty<SecurityKey>();
-        }
-    }
-
-    private async Task<IEnumerable<SecurityKey>> GetIssuerSigningKeysAsync(
-        JwtBearerOptions options)
-    {
-        var issuerSigningKeys = new List<SecurityKey>();
-
-        if (!string.IsNullOrEmpty(options.Authority))
-        {
-            issuerSigningKeys.AddRange(
-                await GetIssuerSigningKeysAsync(
-                    options.Authority));
-        }
-
-        if (apiOptions.Authorization is not null &&
-            !string.IsNullOrWhiteSpace(apiOptions.Authorization.Issuer))
-        {
-            issuerSigningKeys.AddRange(
-                await GetIssuerSigningKeysAsync(
-                    apiOptions.Authorization.Issuer));
-        }
-
-        foreach (var issuer in options.TokenValidationParameters.ValidIssuers)
-        {
-            issuerSigningKeys.AddRange(
-                await GetIssuerSigningKeysAsync(
-                    issuer));
-        }
-
-        return issuerSigningKeys;
-    }
-
     private void SanityCheck(JwtBearerOptions options)
     {
         ArgumentNullException.ThrowIfNull(options);

From 1bc0b74eaa7d2a9abc4c07024d4799b339f88010 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 16:12:33 +0200
Subject: [PATCH 089/100] fix(atc-codeanalysis-csharp-tests): disambiguate null
 overload in SyntaxObjectCreationExpression test

After adding Create(string, ArgumentListSyntax) alongside Create(string, string),
passing null! was ambiguous. Cast to (string)null! to select the correct overload.
---
 .../SyntaxObjectCreationExpressionFactoryTests.cs               | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/Atc.CodeAnalysis.CSharp.Tests/SyntaxFactories/SyntaxObjectCreationExpressionFactoryTests.cs b/test/Atc.CodeAnalysis.CSharp.Tests/SyntaxFactories/SyntaxObjectCreationExpressionFactoryTests.cs
index 14db3d99..ef48d48c 100644
--- a/test/Atc.CodeAnalysis.CSharp.Tests/SyntaxFactories/SyntaxObjectCreationExpressionFactoryTests.cs
+++ b/test/Atc.CodeAnalysis.CSharp.Tests/SyntaxFactories/SyntaxObjectCreationExpressionFactoryTests.cs
@@ -37,7 +37,7 @@ public void Create_With_Namespace_Should_Throw_When_IdentifierName_Is_Null()
     {
         // Act & Assert
         Assert.Throws<ArgumentNullException>(() =>
-            SyntaxObjectCreationExpressionFactory.Create("System", null!));
+            SyntaxObjectCreationExpressionFactory.Create("System", (string)null!));
     }
 
     [Fact]

From b5deec0037c2dbb9758b6beee6d86c440b7561da Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 16:18:50 +0200
Subject: [PATCH 090/100] fix(atc): use CurrentCulture instead of
 CurrentUICulture in TimeSpanExtensions.GetPrettyTime
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Number formatting ("N{n}" format specifier) and string case conversion in
GetPrettyTime used Thread.CurrentThread.CurrentUICulture. The UI culture
controls resource language, not number/date regional format; using it for
number formatting produces wrong decimal separators when UI language ≠
regional format (e.g. da-DK region with en-US UI language).

Changed both usages to CultureInfo.CurrentCulture to match the regional
number format convention used throughout the rest of the codebase.
---
 .../BaseTypes/TimeSpanExtensions.cs           | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/Atc/Extensions/BaseTypes/TimeSpanExtensions.cs b/src/Atc/Extensions/BaseTypes/TimeSpanExtensions.cs
index 33f58fbf..31d21770 100644
--- a/src/Atc/Extensions/BaseTypes/TimeSpanExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/TimeSpanExtensions.cs
@@ -61,30 +61,30 @@ public static string GetPrettyTime(
     {
         if ((int)timeSpan.TotalDays > 0)
         {
-            return $"{timeSpan.TotalDays.ToString("N" + decimalPrecision, Thread.CurrentThread.CurrentUICulture)} " +
-                   $"{DateAndTime.Days.ToLower(Thread.CurrentThread.CurrentUICulture)}";
+            return $"{timeSpan.TotalDays.ToString("N" + decimalPrecision, CultureInfo.CurrentCulture)} " +
+                   $"{DateAndTime.Days.ToLower(CultureInfo.CurrentCulture)}";
         }
 
         if ((int)timeSpan.TotalHours > 0)
         {
-            return $"{timeSpan.TotalHours.ToString("N" + decimalPrecision, Thread.CurrentThread.CurrentUICulture)} " +
-                   $"{DateAndTime.Hours.ToLower(Thread.CurrentThread.CurrentUICulture)}";
+            return $"{timeSpan.TotalHours.ToString("N" + decimalPrecision, CultureInfo.CurrentCulture)} " +
+                   $"{DateAndTime.Hours.ToLower(CultureInfo.CurrentCulture)}";
         }
 
         if ((int)timeSpan.TotalMinutes > 0)
         {
-            return $"{timeSpan.TotalMinutes.ToString("N" + decimalPrecision, Thread.CurrentThread.CurrentUICulture)} " +
-                   $"{DateAndTime.MinuteAsAbbreviation.ToLower(Thread.CurrentThread.CurrentUICulture)}";
+            return $"{timeSpan.TotalMinutes.ToString("N" + decimalPrecision, CultureInfo.CurrentCulture)} " +
+                   $"{DateAndTime.MinuteAsAbbreviation.ToLower(CultureInfo.CurrentCulture)}";
         }
 
         // ReSharper disable once ConvertIfStatementToReturnStatement
         if ((int)timeSpan.TotalSeconds > 0)
         {
-            return $"{timeSpan.TotalSeconds.ToString("N" + decimalPrecision, Thread.CurrentThread.CurrentUICulture)} " +
-                   $"{DateAndTime.SecondAsAbbreviation.ToLower(Thread.CurrentThread.CurrentUICulture)}";
+            return $"{timeSpan.TotalSeconds.ToString("N" + decimalPrecision, CultureInfo.CurrentCulture)} " +
+                   $"{DateAndTime.SecondAsAbbreviation.ToLower(CultureInfo.CurrentCulture)}";
         }
 
-        return $"{timeSpan.TotalMilliseconds.ToString("N" + decimalPrecision, Thread.CurrentThread.CurrentUICulture)} " +
-               $"{DateAndTime.MillisecondAsAbbreviation1.ToLower(Thread.CurrentThread.CurrentUICulture)}";
+        return $"{timeSpan.TotalMilliseconds.ToString("N" + decimalPrecision, CultureInfo.CurrentCulture)} " +
+               $"{DateAndTime.MillisecondAsAbbreviation1.ToLower(CultureInfo.CurrentCulture)}";
     }
 }
\ No newline at end of file

From ae70a0b66d11765bc5234b00010845ecafd7bca6 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Mon, 22 Jun 2026 16:23:07 +0200
Subject: [PATCH 091/100] feat(atc-rest): add RoleClaimType and NameClaimType
 to AuthorizationOptions

Azure AD access tokens use short-form role/name claims ("roles", "name",
"preferred_username") rather than the long-URI ClaimTypes.Role / ClaimTypes.Name
that TokenValidationParameters defaults to. Without setting RoleClaimType,
[Authorize(Roles="admin")] silently never matches Azure AD role claims.

Added optional RoleClaimType and NameClaimType to AuthorizationOptions.
ConfigureAuthorizationOptions.PostConfigure now applies them when configured,
leaving the framework defaults intact when left null/empty.
---
 .../Options/ConfigureAuthorizationOptions.cs   | 14 +++++++++++++-
 src/Atc.Rest/Options/AuthorizationOptions.cs   | 18 ++++++++++++++++++
 2 files changed, 31 insertions(+), 1 deletion(-)

diff --git a/src/Atc.Rest.Extended/Options/ConfigureAuthorizationOptions.cs b/src/Atc.Rest.Extended/Options/ConfigureAuthorizationOptions.cs
index 4f512a38..7d51ac0d 100644
--- a/src/Atc.Rest.Extended/Options/ConfigureAuthorizationOptions.cs
+++ b/src/Atc.Rest.Extended/Options/ConfigureAuthorizationOptions.cs
@@ -93,7 +93,7 @@ public void PostConfigure(
             options.Authority = $"{apiOptions.Authorization.Instance}/{apiOptions.Authorization.TenantId}/";
         }
 
-        options.TokenValidationParameters = new TokenValidationParameters
+        var tvp = new TokenValidationParameters
         {
             ValidateAudience = true,
             ValidAudience = apiOptions.Authorization.Audience,
@@ -106,6 +106,18 @@ public void PostConfigure(
             ValidateIssuerSigningKey = true,
         };
 
+        if (!string.IsNullOrEmpty(apiOptions.Authorization.RoleClaimType))
+        {
+            tvp.RoleClaimType = apiOptions.Authorization.RoleClaimType;
+        }
+
+        if (!string.IsNullOrEmpty(apiOptions.Authorization.NameClaimType))
+        {
+            tvp.NameClaimType = apiOptions.Authorization.NameClaimType;
+        }
+
+        options.TokenValidationParameters = tvp;
+
         if (!options.TokenValidationParameters.ValidateIssuer)
         {
             return;
diff --git a/src/Atc.Rest/Options/AuthorizationOptions.cs b/src/Atc.Rest/Options/AuthorizationOptions.cs
index 349853b0..3b5490dd 100644
--- a/src/Atc.Rest/Options/AuthorizationOptions.cs
+++ b/src/Atc.Rest/Options/AuthorizationOptions.cs
@@ -72,6 +72,24 @@ public class AuthorizationOptions
     /// </summary>
     public List<string> ValidIssuers { get; set; } = new();
 
+    /// <summary>
+    /// Gets or sets the JWT claim type used to populate ASP.NET Core roles for
+    /// <c>[Authorize(Roles=…)]</c>. For Azure AD access tokens the claim is <c>"roles"</c>;
+    /// for client-credentials tokens the scope claim is <c>"scp"</c>.
+    /// When <see langword="null"/> or empty, the framework default
+    /// (<c>ClaimTypes.Role</c> = the long URI form) is used, which does not match
+    /// the short-form claims issued by Azure AD.
+    /// </summary>
+    public string? RoleClaimType { get; set; }
+
+    /// <summary>
+    /// Gets or sets the JWT claim type used to populate the user's identity name (<see cref="System.Security.Claims.ClaimsIdentity.Name"/>).
+    /// For Azure AD access tokens the claim is typically <c>"name"</c> or <c>"preferred_username"</c>.
+    /// When <see langword="null"/> or empty, the framework default
+    /// (<c>ClaimTypes.Name</c> = the long URI form) is used.
+    /// </summary>
+    public string? NameClaimType { get; set; }
+
     /// <summary>
     /// Determines whether any security settings are configured.
     /// </summary>

From 9c9a04780abdc8d2701d46506ce5fa25882d2f5f Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Tue, 23 Jun 2026 01:15:22 +0200
Subject: [PATCH 092/100] test(atc): add missing tests for Bearing and
 ToWgs84(UtmResult) to fix compliance checks

Adds GeoSpatialHelper.Bearing (CartesianCoordinate and double overloads)
and UniversalTransverseMercatorConverter.ToWgs84(UniversalTransverseMercatorResult)
tests, resolving AssertExportedMethodsWithMissingTests failures for both
AbstractSyntaxTree and MonoReflection decompiler modes. Also includes
updated auto-generated CodeDoc for APIs added in prior sessions.
---
 docs/CodeDoc/Atc/Atc.Helpers.md               | 28 +++++++++++
 docs/CodeDoc/Atc/Atc.Math.GeoSpatial.md       | 46 ++++++++++++++---
 docs/CodeDoc/Atc/IndexExtended.md             |  7 ++-
 docs/CodeDoc/Atc/System.Reflection.md         |  2 +-
 docs/CodeDoc/Atc/System.md                    |  8 +--
 .../Math/GeoSpatial/GeoSpatialHelperTests.cs  | 49 +++++++++++++++++++
 ...iversalTransverseMercatorConverterTests.cs | 20 ++++++++
 7 files changed, 147 insertions(+), 13 deletions(-)

diff --git a/docs/CodeDoc/Atc/Atc.Helpers.md b/docs/CodeDoc/Atc/Atc.Helpers.md
index 3dcee6b5..244c6727 100644
--- a/docs/CodeDoc/Atc/Atc.Helpers.md
+++ b/docs/CodeDoc/Atc/Atc.Helpers.md
@@ -2846,6 +2846,34 @@ Provides utility methods for executing external processes, managing process life
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the operation.<br />
 >
 ><b>Returns:</b> A task that returns a tuple containing success status and output/error messages.
+#### ExecuteWithSeparateOutput
+>```csharp
+>Task<ValueTuple<bool, string, string>> ExecuteWithSeparateOutput(FileInfo fileInfo, string arguments, bool runAsAdministrator = False, ushort timeoutInSec = 30, CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Executes a process with the specified file and arguments, returning standard output and standard error separately.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`fileInfo`&nbsp;&nbsp;-&nbsp;&nbsp;The executable file to run.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`arguments`&nbsp;&nbsp;-&nbsp;&nbsp;The command-line arguments to pass to the executable.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`runAsAdministrator`&nbsp;&nbsp;-&nbsp;&nbsp;If , attempts to run the process with elevated privileges.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`timeoutInSec`&nbsp;&nbsp;-&nbsp;&nbsp;The maximum time in seconds to wait for the process to complete. Default is 30 seconds.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the operation.<br />
+>
+><b>Returns:</b> A task that returns a tuple containing success status, standard output, and standard error streams separately.
+#### ExecuteWithSeparateOutput
+>```csharp
+>Task<ValueTuple<bool, string, string>> ExecuteWithSeparateOutput(DirectoryInfo workingDirectory, FileInfo fileInfo, string arguments, bool runAsAdministrator = False, ushort timeoutInSec = 30, CancellationToken cancellationToken = null)
+>```
+><b>Summary:</b> Executes a process with the specified file and arguments, returning standard output and standard error separately.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`fileInfo`&nbsp;&nbsp;-&nbsp;&nbsp;The executable file to run.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`arguments`&nbsp;&nbsp;-&nbsp;&nbsp;The command-line arguments to pass to the executable.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`runAsAdministrator`&nbsp;&nbsp;-&nbsp;&nbsp;If , attempts to run the process with elevated privileges.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`timeoutInSec`&nbsp;&nbsp;-&nbsp;&nbsp;The maximum time in seconds to wait for the process to complete. Default is 30 seconds.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`cancellationToken`&nbsp;&nbsp;-&nbsp;&nbsp;A token to cancel the operation.<br />
+>
+><b>Returns:</b> A task that returns a tuple containing success status, standard output, and standard error streams separately.
 #### KillById
 >```csharp
 >ValueTuple<bool, string> KillById(int processId, int timeoutInSec = 30)
diff --git a/docs/CodeDoc/Atc/Atc.Math.GeoSpatial.md b/docs/CodeDoc/Atc/Atc.Math.GeoSpatial.md
index 3a4ea2e5..59c364f0 100644
--- a/docs/CodeDoc/Atc/Atc.Math.GeoSpatial.md
+++ b/docs/CodeDoc/Atc/Atc.Math.GeoSpatial.md
@@ -36,6 +36,28 @@ Provides utility methods for geospatial calculations including distance measurem
 
 ### Static Methods
 
+#### Bearing
+>```csharp
+>double Bearing(CartesianCoordinate coordinate1, CartesianCoordinate coordinate2)
+>```
+><b>Summary:</b> Calculates the initial bearing (forward azimuth) from one geographic coordinate to another. The bearing is the angle measured clockwise from true north (0°) to the direction of travel.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`coordinate1`&nbsp;&nbsp;-&nbsp;&nbsp;The starting coordinate.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`coordinate2`&nbsp;&nbsp;-&nbsp;&nbsp;The destination coordinate.<br />
+>
+><b>Returns:</b> The initial bearing in degrees (0–360), where 0° is north, 90° east, 180° south, 270° west.
+#### Bearing
+>```csharp
+>double Bearing(double longitude1, double latitude1, double longitude2, double latitude2)
+>```
+><b>Summary:</b> Calculates the initial bearing (forward azimuth) from one geographic coordinate to another. The bearing is the angle measured clockwise from true north (0°) to the direction of travel.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`coordinate1`&nbsp;&nbsp;-&nbsp;&nbsp;The starting coordinate.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`coordinate2`&nbsp;&nbsp;-&nbsp;&nbsp;The destination coordinate.<br />
+>
+><b>Returns:</b> The initial bearing in degrees (0–360), where 0° is north, 90° east, 180° south, 270° west.
 #### Distance
 >```csharp
 >double Distance(CartesianCoordinate coordinate1, CartesianCoordinate coordinate2, DistanceMeasurementType measurement)
@@ -50,7 +72,7 @@ Provides utility methods for geospatial calculations including distance measurem
 ><b>Returns:</b> The distance between the two coordinates in the specified measurement unit.
 #### Distance
 >```csharp
->double Distance(double longitude1, double latitude1, double longitude2, double latitude2, DistanceMeasurementType measurement = Kilometers)
+>double Distance(double longitude1, double latitude1, double longitude2, double latitude2, DistanceMeasurementType measurement = Kilometers, double earthRadiusKm = 6371)
 >```
 ><b>Summary:</b> Calculates the great-circle distance between two geographic coordinates.
 >
@@ -131,16 +153,26 @@ UniversalTransverseMercatorConverter
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`coordinate`&nbsp;&nbsp;-&nbsp;&nbsp;The coordinate.<br />
 #### ToWgs84
 >```csharp
+>CartesianCoordinate ToWgs84(UniversalTransverseMercatorResult utmResult, int maxDecimalPrecision = 8)
+>```
+><b>Summary:</b> Converts a `Atc.Math.GeoSpatial.UniversalTransverseMercatorResult` back to a WGS84 geographic coordinate. This is a convenience overload that unpacks the fields from the result returned by `Atc.Math.GeoSpatial.UniversalTransverseMercatorConverter.ToUtm(Atc.Structs.CartesianCoordinate)` or `Atc.Math.GeoSpatial.UniversalTransverseMercatorConverter.ToUtm(System.Double,System.Double)`.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`utmResult`&nbsp;&nbsp;-&nbsp;&nbsp;The UTM result to convert.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`maxDecimalPrecision`&nbsp;&nbsp;-&nbsp;&nbsp;The maximum number of decimal places in the returned latitude/longitude values.<br />
+>
+><b>Returns:</b> A `Atc.Structs.CartesianCoordinate` containing the WGS84 latitude and longitude.
+#### ToWgs84
+>```csharp
 >CartesianCoordinate ToWgs84(int utmZoneNumber, string utmZoneLetter, double utmEasting, double utmNorthing, int maxDecimalPrecision = 8)
 >```
-><b>Summary:</b> To WGS84.
+><b>Summary:</b> Converts a `Atc.Math.GeoSpatial.UniversalTransverseMercatorResult` back to a WGS84 geographic coordinate. This is a convenience overload that unpacks the fields from the result returned by `Atc.Math.GeoSpatial.UniversalTransverseMercatorConverter.ToUtm(Atc.Structs.CartesianCoordinate)` or `Atc.Math.GeoSpatial.UniversalTransverseMercatorConverter.ToUtm(System.Double,System.Double)`.
 >
 ><b>Parameters:</b><br>
->&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`utmZoneNumber`&nbsp;&nbsp;-&nbsp;&nbsp;The utm zone number.<br />
->&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`utmZoneLetter`&nbsp;&nbsp;-&nbsp;&nbsp;The utm zone letter.<br />
->&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`utmEasting`&nbsp;&nbsp;-&nbsp;&nbsp;The utm easting.<br />
->&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`utmNorthing`&nbsp;&nbsp;-&nbsp;&nbsp;The utm northing.<br />
->&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`maxDecimalPrecision`&nbsp;&nbsp;-&nbsp;&nbsp;The maximum decimal precision.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`utmResult`&nbsp;&nbsp;-&nbsp;&nbsp;The UTM result to convert.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`maxDecimalPrecision`&nbsp;&nbsp;-&nbsp;&nbsp;The maximum number of decimal places in the returned latitude/longitude values.<br />
+>
+><b>Returns:</b> A `Atc.Structs.CartesianCoordinate` containing the WGS84 latitude and longitude.
 
 <br />
 
diff --git a/docs/CodeDoc/Atc/IndexExtended.md b/docs/CodeDoc/Atc/IndexExtended.md
index a793dd34..475cdb72 100644
--- a/docs/CodeDoc/Atc/IndexExtended.md
+++ b/docs/CodeDoc/Atc/IndexExtended.md
@@ -4728,6 +4728,8 @@
      - ExecuteAsync(FileInfo fileInfo, string arguments, bool runAsAdministrator = False, ushort timeoutInSec = 30, CancellationToken cancellationToken = null)
      - ExecuteAsync(ProcessStartInfo startInfo, ushort timeoutInSec = 30, CancellationToken cancellationToken = null)
      - ExecutePrompt(DirectoryInfo workingDirectory, FileInfo fileInfo, string arguments, string[] inputLines, bool runAsAdministrator = False, ushort timeoutInSec = 1, CancellationToken cancellationToken = null)
+     - ExecuteWithSeparateOutput(DirectoryInfo workingDirectory, FileInfo fileInfo, string arguments, bool runAsAdministrator = False, ushort timeoutInSec = 30, CancellationToken cancellationToken = null)
+     - ExecuteWithSeparateOutput(FileInfo fileInfo, string arguments, bool runAsAdministrator = False, ushort timeoutInSec = 30, CancellationToken cancellationToken = null)
      - KillById(int processId, int timeoutInSec = 30)
      - KillByName(string processName, bool allowMultiKill = True, int timeoutInSec = 30)
      - KillEntryCaller(int timeoutInSec = 30)
@@ -4812,13 +4814,16 @@
 - [DistanceMeasurementType](Atc.Math.GeoSpatial.md#distancemeasurementtype)
 - [GeoSpatialHelper](Atc.Math.GeoSpatial.md#geospatialhelper)
   -  Static Methods
+     - Bearing(CartesianCoordinate coordinate1, CartesianCoordinate coordinate2)
+     - Bearing(double longitude1, double latitude1, double longitude2, double latitude2)
      - Distance(CartesianCoordinate coordinate1, CartesianCoordinate coordinate2, DistanceMeasurementType measurement)
-     - Distance(double longitude1, double latitude1, double longitude2, double latitude2, DistanceMeasurementType measurement = Kilometers)
+     - Distance(double longitude1, double latitude1, double longitude2, double latitude2, DistanceMeasurementType measurement = Kilometers, double earthRadiusKm = 6371)
 - [ReferenceEllipsoidType](Atc.Math.GeoSpatial.md#referenceellipsoidtype)
 - [UniversalTransverseMercatorConverter](Atc.Math.GeoSpatial.md#universaltransversemercatorconverter)
   -  Methods
      - ToUtm(CartesianCoordinate coordinate)
      - ToUtm(double latitude, double longitude)
+     - ToWgs84(UniversalTransverseMercatorResult utmResult, int maxDecimalPrecision = 8)
      - ToWgs84(int utmZoneNumber, string utmZoneLetter, double utmEasting, double utmNorthing, int maxDecimalPrecision = 8)
 - [UniversalTransverseMercatorResult](Atc.Math.GeoSpatial.md#universaltransversemercatorresult)
   -  Properties
diff --git a/docs/CodeDoc/Atc/System.Reflection.md b/docs/CodeDoc/Atc/System.Reflection.md
index 2bd2b487..b46595e2 100644
--- a/docs/CodeDoc/Atc/System.Reflection.md
+++ b/docs/CodeDoc/Atc/System.Reflection.md
@@ -41,7 +41,7 @@ Extensions for the `System.Reflection.Assembly` class.
 >```csharp
 >Version GetFileVersion(this Assembly assembly)
 >```
-><b>Summary:</b> Gets the file version of the assembly.
+><b>Summary:</b> Gets the file version of the assembly. Falls back to `System.Reflection.AssemblyFileVersionAttribute` when the assembly location is unavailable (e.g., single-file published apps where `System.Reflection.Assembly.Location` is empty).
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`assembly`&nbsp;&nbsp;-&nbsp;&nbsp;The assembly to query.<br />
diff --git a/docs/CodeDoc/Atc/System.md b/docs/CodeDoc/Atc/System.md
index 3d0ecad3..fd24d4a0 100644
--- a/docs/CodeDoc/Atc/System.md
+++ b/docs/CodeDoc/Atc/System.md
@@ -1177,7 +1177,7 @@ Extensions for the `System.Decimal` class.
 >```csharp
 >decimal CurrencyRounding(this decimal value)
 >```
-><b>Summary:</b> Rounds a decimal value using the currency decimal digits of the current UI culture.
+><b>Summary:</b> Rounds a decimal value using the currency decimal digits of the current culture.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The decimal value to round.<br />
@@ -1187,7 +1187,7 @@ Extensions for the `System.Decimal` class.
 >```csharp
 >decimal CurrencyRounding(this decimal value, int digits)
 >```
-><b>Summary:</b> Rounds a decimal value using the currency decimal digits of the current UI culture.
+><b>Summary:</b> Rounds a decimal value using the currency decimal digits of the current culture.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The decimal value to round.<br />
@@ -1343,7 +1343,7 @@ Extensions for the `System.Double` class.
 >```csharp
 >double CurrencyRounding(this double value)
 >```
-><b>Summary:</b> Rounds a double value using the currency decimal digits of the current UI culture.
+><b>Summary:</b> Rounds a double value using the currency decimal digits of the current culture.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The double value to round.<br />
@@ -1353,7 +1353,7 @@ Extensions for the `System.Double` class.
 >```csharp
 >double CurrencyRounding(this double value, int digits)
 >```
-><b>Summary:</b> Rounds a double value using the currency decimal digits of the current UI culture.
+><b>Summary:</b> Rounds a double value using the currency decimal digits of the current culture.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The double value to round.<br />
diff --git a/test/Atc.Tests/Math/GeoSpatial/GeoSpatialHelperTests.cs b/test/Atc.Tests/Math/GeoSpatial/GeoSpatialHelperTests.cs
index ac389073..131dcc9d 100644
--- a/test/Atc.Tests/Math/GeoSpatial/GeoSpatialHelperTests.cs
+++ b/test/Atc.Tests/Math/GeoSpatial/GeoSpatialHelperTests.cs
@@ -55,4 +55,53 @@ public void Distance_LondonToParis_IsApproximately341Km()
 
         Assert.InRange(km, 338, 344);
     }
+
+    [Theory]
+    [InlineData(0.0, 0.0, 0.0, 0.0, 0.0)]
+    public void Bearing_CartesianCoordinate(
+        double expected,
+        double latitude1,
+        double longitude1,
+        double latitude2,
+        double longitude2)
+    {
+        // Arrange
+        var coordinate1 = new CartesianCoordinate(latitude1, longitude1);
+        var coordinate2 = new CartesianCoordinate(latitude2, longitude2);
+
+        // Act
+        var actual = GeoSpatialHelper.Bearing(coordinate1, coordinate2);
+
+        // Assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Theory]
+    [InlineData(0.0, 0.0, 0.0, 0.0, 0.0)]
+    public void Bearing(
+        double expected,
+        double longitude1,
+        double latitude1,
+        double longitude2,
+        double latitude2)
+    {
+        // Act
+        var actual = GeoSpatialHelper.Bearing(longitude1, latitude1, longitude2, latitude2);
+
+        // Assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void Bearing_LondonToParis_IsApproximately148Degrees()
+    {
+        const double londonLat = 51.5074;
+        const double londonLon = -0.1278;
+        const double parisLat = 48.8566;
+        const double parisLon = 2.3522;
+
+        var actual = GeoSpatialHelper.Bearing(londonLon, londonLat, parisLon, parisLat);
+
+        Assert.InRange(actual, 145, 152);
+    }
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Math/GeoSpatial/UniversalTransverseMercatorConverterTests.cs b/test/Atc.Tests/Math/GeoSpatial/UniversalTransverseMercatorConverterTests.cs
index 25c9cc18..f858094c 100644
--- a/test/Atc.Tests/Math/GeoSpatial/UniversalTransverseMercatorConverterTests.cs
+++ b/test/Atc.Tests/Math/GeoSpatial/UniversalTransverseMercatorConverterTests.cs
@@ -74,4 +74,24 @@ public void ToWgs84(
         actual.Latitude.Should().Be(expected.Latitude, $"Latitude on ({description})");
         actual.Longitude.Should().Be(expected.Longitude, $"Longitude on ({description})");
     }
+
+    [Theory]
+    [ClassData(typeof(TestClassDataForGeoSpatialToWgs84))]
+    public void ToWgs84_UtmResult(
+        string description,
+        UniversalTransverseMercatorResult input,
+        int maxDecimalPrecision,
+        CartesianCoordinate expected)
+    {
+        // Arrange
+        var converter = new UniversalTransverseMercatorConverter();
+
+        // Act
+        var actual = converter.ToWgs84(input, maxDecimalPrecision);
+
+        // Assert
+        actual.Should().NotBeNull(description);
+        actual.Latitude.Should().Be(expected.Latitude, $"Latitude on ({description})");
+        actual.Longitude.Should().Be(expected.Longitude, $"Longitude on ({description})");
+    }
 }
\ No newline at end of file

From e728b1882913e504c9dd2c3eca26e84442408749 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Tue, 23 Jun 2026 02:47:17 +0200
Subject: [PATCH 093/100] chore: nuget updates

---
 Directory.Build.props                          | 2 +-
 src/Atc.Rest.Extended/Atc.Rest.Extended.csproj | 2 +-
 src/Atc/Atc.csproj                             | 2 +-
 src/Directory.Build.props                      | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Directory.Build.props b/Directory.Build.props
index 05349a70..dabb3d74 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -42,7 +42,7 @@
   <ItemGroup Label="Code Analyzers">
     <PackageReference Include="Atc.Analyzer" Version="0.1.23" PrivateAssets="All" />
     <PackageReference Include="AsyncFixer" Version="2.1.0" PrivateAssets="All" />
-    <PackageReference Include="Meziantou.Analyzer" Version="3.0.104" PrivateAssets="All" />
+    <PackageReference Include="Meziantou.Analyzer" Version="3.0.109" PrivateAssets="All" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.435" PrivateAssets="All" />
     <PackageReference Include="SonarAnalyzer.CSharp" Version="10.27.0.140913" PrivateAssets="All" />
   </ItemGroup>
diff --git a/src/Atc.Rest.Extended/Atc.Rest.Extended.csproj b/src/Atc.Rest.Extended/Atc.Rest.Extended.csproj
index ef2d9b0b..894d3b5a 100644
--- a/src/Atc.Rest.Extended/Atc.Rest.Extended.csproj
+++ b/src/Atc.Rest.Extended/Atc.Rest.Extended.csproj
@@ -12,7 +12,7 @@
     <PackageReference Include="FluentValidation.AspNetCore" Version="11.3.1" />
     <PackageReference Include="Microsoft.ApplicationInsights.AspNetCore" Version="2.23.0" />
     <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="9.0.10" />
-    <PackageReference Include="Swashbuckle.AspNetCore" Version="10.2.1" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="10.2.3" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/Atc/Atc.csproj b/src/Atc/Atc.csproj
index c0284035..f599855c 100644
--- a/src/Atc/Atc.csproj
+++ b/src/Atc/Atc.csproj
@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Meziantou.Polyfill" Version="1.0.152">
+    <PackageReference Include="Meziantou.Polyfill" Version="1.0.153">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
diff --git a/src/Directory.Build.props b/src/Directory.Build.props
index fd98e5b4..c29e7f62 100644
--- a/src/Directory.Build.props
+++ b/src/Directory.Build.props
@@ -54,7 +54,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="10.0.300" PrivateAssets="All" />
-    <PackageReference Include="Nerdbank.GitVersioning" Version="3.9.50" PrivateAssets="All" />
+    <PackageReference Include="Nerdbank.GitVersioning" Version="3.10.85" PrivateAssets="All" />
   </ItemGroup>
 
 </Project>
\ No newline at end of file

From 90cb11a2cf650b7704b36701f6895f708809f1da Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Wed, 24 Jun 2026 02:53:16 +0200
Subject: [PATCH 094/100] fix(atc): replace Single() with
 typeof(CultureHelper).Assembly in GetResourceManagerForResource

AppDomain.GetAssemblies().Single() threw InvalidOperationException when both the net10.0
and netstandard2.0 builds of Atc were loaded in the same AppDomain during test runs.
typeof(CultureHelper).Assembly always resolves to the correct assembly unambiguously.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/Atc/Helpers/CultureHelper.cs | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/Atc/Helpers/CultureHelper.cs b/src/Atc/Helpers/CultureHelper.cs
index c92e9d27..9d47a464 100644
--- a/src/Atc/Helpers/CultureHelper.cs
+++ b/src/Atc/Helpers/CultureHelper.cs
@@ -32,7 +32,8 @@ public static List<Culture> GetCultures()
 
             allCultures ??= new Dictionary<int, List<Culture>>();
 
-            allCultures[Thread.CurrentThread.CurrentUICulture.LCID] = new List<Culture>();
+            var lcid = Thread.CurrentThread.CurrentUICulture.LCID;
+            var result = new List<Culture>();
             var culturesFromPlatform = GetCultureInfoFromPlatform();
             foreach (var cultureInfo in culturesFromPlatform)
             {
@@ -57,13 +58,14 @@ public static List<Culture> GetCultures()
                 culture.CountryDisplayName = TryTranslateCountryEnglishName(culture.CountryEnglishName);
                 culture.LanguageDisplayName = TryTranslateLanguageEnglishName(culture.LanguageEnglishName);
 
-                if (!allCultures[Thread.CurrentThread.CurrentUICulture.LCID].Contains(culture))
+                if (!result.Contains(culture))
                 {
-                    allCultures[Thread.CurrentThread.CurrentUICulture.LCID].Add(culture);
+                    result.Add(culture);
                 }
             }
 
-            return allCultures[Thread.CurrentThread.CurrentUICulture.LCID];
+            allCultures[lcid] = result;
+            return result;
         }
     }
 
@@ -1026,9 +1028,7 @@ private static string TryTranslateLanguageEnglishName(
     private static ResourceManager GetResourceManagerForResource(
         string resource)
     {
-        var assembly = AppDomain.CurrentDomain
-            .GetAssemblies()
-            .Single(x => x.FullName!.StartsWith(ResourceBaseName + ", Version", StringComparison.Ordinal));
+        var assembly = typeof(CultureHelper).Assembly;
         return new ResourceManager($"{ResourceBaseName}.Resources.{resource}", assembly);
     }
 }
\ No newline at end of file

From a51d876331a095c528a6a6ad659650de68aee6f6 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Wed, 24 Jun 2026 02:53:20 +0200
Subject: [PATCH 095/100] fix(atc-rest): use compact JSON in
 CreateContentResult factory methods

Switched from JsonSerializerOptionsFactory.Default (WriteIndented=true) to
JsonSerializerOptionsFactory.Create(writeIndented: false) so HTTP response bodies
are compact rather than pretty-printed.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/Atc.Rest/Results/ResultFactory.cs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/Atc.Rest/Results/ResultFactory.cs b/src/Atc.Rest/Results/ResultFactory.cs
index d073b13a..d5c1568a 100644
--- a/src/Atc.Rest/Results/ResultFactory.cs
+++ b/src/Atc.Rest/Results/ResultFactory.cs
@@ -61,7 +61,7 @@ public static ContentResult CreateContentResultWithProblemDetails(
         {
             ContentType = contentType,
             StatusCode = (int)statusCode,
-            Content = JsonSerializer.Serialize(CreateProblemDetails(statusCode, message), JsonSerializerOptionsFactory.Default),
+            Content = JsonSerializer.Serialize(CreateProblemDetails(statusCode, message), JsonSerializerOptionsFactory.Create(writeIndented: false)),
         };
 
     /// <summary>
@@ -93,11 +93,11 @@ public static ContentResult CreateContentResultWithProblemDetails(
 
         var message = SimpleTypeHelper.IsSimpleType(beautifyTypeName)
             ? value.ToString()
-            : JsonSerializer.Serialize(value, JsonSerializerOptionsFactory.Default);
+            : JsonSerializer.Serialize(value, JsonSerializerOptionsFactory.Create(writeIndented: false));
 
         var problemDetails = CreateProblemDetails(statusCode, message);
 
-        result.Content = JsonSerializer.Serialize(problemDetails, JsonSerializerOptionsFactory.Default);
+        result.Content = JsonSerializer.Serialize(problemDetails, JsonSerializerOptionsFactory.Create(writeIndented: false));
 
         return result;
     }
@@ -117,7 +117,7 @@ public static ContentResult CreateContentResultWithValidationProblemDetails(
         {
             ContentType = contentType,
             StatusCode = (int)statusCode,
-            Content = JsonSerializer.Serialize(CreateValidationProblemDetails(statusCode, new Dictionary<string, string[]>(StringComparer.Ordinal), message), JsonSerializerOptionsFactory.Default),
+            Content = JsonSerializer.Serialize(CreateValidationProblemDetails(statusCode, new Dictionary<string, string[]>(StringComparer.Ordinal), message), JsonSerializerOptionsFactory.Create(writeIndented: false)),
         };
 
     /// <summary>
@@ -137,7 +137,7 @@ public static ContentResult CreateContentResultWithValidationProblemDetails(
         {
             ContentType = contentType,
             StatusCode = (int)statusCode,
-            Content = JsonSerializer.Serialize(CreateValidationProblemDetails(statusCode, errors, message), JsonSerializerOptionsFactory.Default),
+            Content = JsonSerializer.Serialize(CreateValidationProblemDetails(statusCode, errors, message), JsonSerializerOptionsFactory.Create(writeIndented: false)),
         };
 
     /// <summary>

From d68cfc28912e0c0b799e22aaf0bc3087e8a0e19d Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Wed, 24 Jun 2026 02:53:28 +0200
Subject: [PATCH 096/100] test(atc-rest,atc-rest-healthchecks): update tests
 for ObjectResult and string-sanitized health data

- ErrorHandlingExceptionFilterAttributeTests: expect ObjectResult instead of ContentResult
  now that HandleException returns ObjectResult when useProblemDetailsAsResponseBody=true
- HealthReportEntryExtensionsTests: expect string values after SanitizeData converts all
  non-exception entries via .ToString() (bool true -> "True", int 3 -> "3", etc.)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../HealthReportEntryExtensionsTests.cs          | 16 ++++++++--------
 ...ErrorHandlingExceptionFilterAttributeTests.cs |  4 ++--
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/test/Atc.Rest.HealthChecks.Tests/Extensions/HealthReportEntryExtensionsTests.cs b/test/Atc.Rest.HealthChecks.Tests/Extensions/HealthReportEntryExtensionsTests.cs
index a5e0a32b..8f5163b4 100644
--- a/test/Atc.Rest.HealthChecks.Tests/Extensions/HealthReportEntryExtensionsTests.cs
+++ b/test/Atc.Rest.HealthChecks.Tests/Extensions/HealthReportEntryExtensionsTests.cs
@@ -71,8 +71,8 @@ public void ToHealthCheck_With_Data()
             .And.ContainKey("isRunning")
             .And.ContainKey("duration");
 
-        actual.Data!["isRunning"].Should().Be(true);
-        actual.Data!["duration"].Should().Be(duration);
+        actual.Data!["isRunning"].Should().Be("True");
+        actual.Data!["duration"].Should().Be(duration.ToString());
     }
 
     [Fact]
@@ -189,7 +189,7 @@ public void ToHealthCheck_Sanitizes_Exception_In_Data()
         // Assert
         actual.Data.Should().NotBeNull().And.HaveCount(2);
         actual.Data!["error"].Should().Be("Cache connection failed");
-        actual.Data!["retries"].Should().Be(3);
+        actual.Data!["retries"].Should().Be("3");
     }
 
     [Fact]
@@ -223,9 +223,9 @@ public void ToHealthCheck_Preserves_NonException_Objects_In_Data()
         // Assert
         actual.Data.Should().NotBeNull().And.HaveCount(4);
         actual.Data!["label"].Should().Be("healthy");
-        actual.Data!["flag"].Should().Be(true);
-        actual.Data!["count"].Should().Be(42);
-        actual.Data!["duration"].Should().Be(TimeSpan.FromMilliseconds(500));
+        actual.Data!["flag"].Should().Be("True");
+        actual.Data!["count"].Should().Be("42");
+        actual.Data!["duration"].Should().Be(TimeSpan.FromMilliseconds(500).ToString());
     }
 
     [Fact]
@@ -256,7 +256,7 @@ public void ToHealthCheck_Preserves_ResourceHealthCheck_In_Data()
 
         // Assert
         actual.Data.Should().NotBeNull().And.HaveCount(1);
-        actual.Data!["redis"].Should().Be(resource);
+        actual.Data!["redis"].Should().Be(resource.ToString());
     }
 
     [Fact]
@@ -323,6 +323,6 @@ public void ToHealthChecks_With_Data()
         dataBag
             .Should().NotBeNull()
             .And.HaveCount(1);
-        dataBag!["failures"].Should().Be(3);
+        dataBag!["failures"].Should().Be("3");
     }
 }
\ No newline at end of file
diff --git a/test/Atc.Rest.Tests/Filters/ErrorHandlingExceptionFilterAttributeTests.cs b/test/Atc.Rest.Tests/Filters/ErrorHandlingExceptionFilterAttributeTests.cs
index 9e0bdcbb..4924185b 100644
--- a/test/Atc.Rest.Tests/Filters/ErrorHandlingExceptionFilterAttributeTests.cs
+++ b/test/Atc.Rest.Tests/Filters/ErrorHandlingExceptionFilterAttributeTests.cs
@@ -63,7 +63,7 @@ public void OnException_LiveRequest_ComposesResponseBody()
         // Assert
         Assert.True(exceptionContext.ExceptionHandled);
         Assert.NotNull(exceptionContext.Result);
-        var content = Assert.IsType<ContentResult>(exceptionContext.Result);
-        Assert.Equal((int)HttpStatusCode.InternalServerError, content.StatusCode);
+        var objectResult = Assert.IsType<ObjectResult>(exceptionContext.Result);
+        Assert.Equal((int)HttpStatusCode.InternalServerError, objectResult.StatusCode);
     }
 }
\ No newline at end of file

From 270e2ddee4c4bc06ca7f6c1a970471626c54d327 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Wed, 24 Jun 2026 02:53:38 +0200
Subject: [PATCH 097/100] test(atc-codeanalysis-csharp): add missing compliance
 tests for syntax factories and declaration extensions

- SyntaxLiteralExpressionFactory: add CreateNull test
- SyntaxObjectCreationExpressionFactory: add tests for ArgumentList, namespace+ArgumentList,
  and all CreateGeneric overloads; simplify Create+ArgumentList test to avoid nested Create
  call that confused the compliance checker's AST overload resolution
- InterfaceDeclarationSyntaxExtensions: add AddSuppressMessageAttribute and
  AddGeneratedCodeAttribute tests; fix assertion to expect "SuppressMessage" (Roslyn
  strips the Attribute suffix via RemoveSuffix)
- RecordDeclarationSyntaxExtensionsTests: new file covering AddSuppressMessageAttribute
  and AddGeneratedCodeAttribute on record declarations
- StructDeclarationSyntaxExtensionsTests: new file covering the same on struct declarations

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 ...terfaceDeclarationSyntaxExtensionsTests.cs |  52 +++++++
 .../RecordDeclarationSyntaxExtensionsTests.cs | 110 +++++++++++++++
 .../StructDeclarationSyntaxExtensionsTests.cs | 110 +++++++++++++++
 .../SyntaxLiteralExpressionFactoryTests.cs    |  11 ++
 ...taxObjectCreationExpressionFactoryTests.cs | 130 ++++++++++++++++++
 5 files changed, 413 insertions(+)
 create mode 100644 test/Atc.CodeAnalysis.CSharp.Tests/Extensions/RecordDeclarationSyntaxExtensionsTests.cs
 create mode 100644 test/Atc.CodeAnalysis.CSharp.Tests/Extensions/StructDeclarationSyntaxExtensionsTests.cs

diff --git a/test/Atc.CodeAnalysis.CSharp.Tests/Extensions/InterfaceDeclarationSyntaxExtensionsTests.cs b/test/Atc.CodeAnalysis.CSharp.Tests/Extensions/InterfaceDeclarationSyntaxExtensionsTests.cs
index d9cf158e..3f34611d 100644
--- a/test/Atc.CodeAnalysis.CSharp.Tests/Extensions/InterfaceDeclarationSyntaxExtensionsTests.cs
+++ b/test/Atc.CodeAnalysis.CSharp.Tests/Extensions/InterfaceDeclarationSyntaxExtensionsTests.cs
@@ -2,6 +2,58 @@ namespace Atc.CodeAnalysis.CSharp.Tests.Extensions;
 
 public class InterfaceDeclarationSyntaxExtensionsTests
 {
+    [Fact]
+    public void AddSuppressMessageAttribute_Should_Throw_When_InterfaceDeclaration_Is_Null()
+    {
+        // Arrange
+        InterfaceDeclarationSyntax interfaceDeclaration = null!;
+        var suppressMessage = new SuppressMessageAttribute("category", "checkId") { Justification = "OK." };
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() =>
+            interfaceDeclaration.AddSuppressMessageAttribute(suppressMessage));
+    }
+
+    [Fact]
+    public void AddSuppressMessageAttribute_Should_Throw_When_SuppressMessage_Is_Null()
+    {
+        // Arrange
+        var interfaceDeclaration = SyntaxFactory.InterfaceDeclaration("ITestInterface");
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() =>
+            interfaceDeclaration.AddSuppressMessageAttribute(null!));
+    }
+
+    [Fact]
+    public void AddSuppressMessageAttribute_Should_Throw_When_Justification_Is_Empty()
+    {
+        // Arrange
+        var interfaceDeclaration = SyntaxFactory.InterfaceDeclaration("ITestInterface");
+        var suppressMessage = new SuppressMessageAttribute("category", "checkId");
+
+        // Act & Assert
+        Assert.Throws<ArgumentException>(() =>
+            interfaceDeclaration.AddSuppressMessageAttribute(suppressMessage));
+    }
+
+    [Fact]
+    public void AddSuppressMessageAttribute_Should_Add_Attribute()
+    {
+        // Arrange
+        var interfaceDeclaration = SyntaxFactory.InterfaceDeclaration("ITestInterface");
+        var suppressMessage = new SuppressMessageAttribute("Design", "CA1002") { Justification = "OK." };
+
+        // Act
+        var result = interfaceDeclaration.AddSuppressMessageAttribute(suppressMessage);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Single(result.AttributeLists);
+        var attribute = result.AttributeLists[0].Attributes[0];
+        Assert.Equal("SuppressMessage", attribute.Name.ToString(), StringComparer.Ordinal);
+    }
+
     [Fact]
     public void AddGeneratedCodeAttribute_Should_Throw_When_InterfaceDeclaration_Is_Null()
     {
diff --git a/test/Atc.CodeAnalysis.CSharp.Tests/Extensions/RecordDeclarationSyntaxExtensionsTests.cs b/test/Atc.CodeAnalysis.CSharp.Tests/Extensions/RecordDeclarationSyntaxExtensionsTests.cs
new file mode 100644
index 00000000..bfa72442
--- /dev/null
+++ b/test/Atc.CodeAnalysis.CSharp.Tests/Extensions/RecordDeclarationSyntaxExtensionsTests.cs
@@ -0,0 +1,110 @@
+namespace Atc.CodeAnalysis.CSharp.Tests.Extensions;
+
+public class RecordDeclarationSyntaxExtensionsTests
+{
+    [Fact]
+    public void AddSuppressMessageAttribute_Should_Throw_When_RecordDeclaration_Is_Null()
+    {
+        // Arrange
+        RecordDeclarationSyntax recordDeclaration = null!;
+        var suppressMessage = new SuppressMessageAttribute("category", "checkId") { Justification = "OK." };
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() =>
+            recordDeclaration.AddSuppressMessageAttribute(suppressMessage));
+    }
+
+    [Fact]
+    public void AddSuppressMessageAttribute_Should_Throw_When_SuppressMessage_Is_Null()
+    {
+        // Arrange
+        var recordDeclaration = SyntaxFactory.RecordDeclaration(SyntaxFactory.Token(SyntaxKind.RecordKeyword), "TestRecord");
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() =>
+            recordDeclaration.AddSuppressMessageAttribute(null!));
+    }
+
+    [Fact]
+    public void AddSuppressMessageAttribute_Should_Throw_When_Justification_Is_Empty()
+    {
+        // Arrange
+        var recordDeclaration = SyntaxFactory.RecordDeclaration(SyntaxFactory.Token(SyntaxKind.RecordKeyword), "TestRecord");
+        var suppressMessage = new SuppressMessageAttribute("category", "checkId");
+
+        // Act & Assert
+        Assert.Throws<ArgumentException>(() =>
+            recordDeclaration.AddSuppressMessageAttribute(suppressMessage));
+    }
+
+    [Fact]
+    public void AddSuppressMessageAttribute_Should_Add_Attribute()
+    {
+        // Arrange
+        var recordDeclaration = SyntaxFactory.RecordDeclaration(SyntaxFactory.Token(SyntaxKind.RecordKeyword), "TestRecord");
+        var suppressMessage = new SuppressMessageAttribute("Design", "CA1002") { Justification = "OK." };
+
+        // Act
+        var result = recordDeclaration.AddSuppressMessageAttribute(suppressMessage);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Single(result.AttributeLists);
+        var attribute = result.AttributeLists[0].Attributes[0];
+        Assert.Equal("SuppressMessage", attribute.Name.ToString(), StringComparer.Ordinal);
+    }
+
+    [Fact]
+    public void AddGeneratedCodeAttribute_Should_Throw_When_RecordDeclaration_Is_Null()
+    {
+        // Arrange
+        RecordDeclarationSyntax recordDeclaration = null!;
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() =>
+            recordDeclaration.AddGeneratedCodeAttribute("Tool", "1.0"));
+    }
+
+    [Fact]
+    public void AddGeneratedCodeAttribute_Should_Throw_When_ToolName_Is_Null()
+    {
+        // Arrange
+        var recordDeclaration = SyntaxFactory.RecordDeclaration(SyntaxFactory.Token(SyntaxKind.RecordKeyword), "TestRecord");
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() =>
+            recordDeclaration.AddGeneratedCodeAttribute(null!, "1.0"));
+    }
+
+    [Fact]
+    public void AddGeneratedCodeAttribute_Should_Throw_When_Version_Is_Null()
+    {
+        // Arrange
+        var recordDeclaration = SyntaxFactory.RecordDeclaration(SyntaxFactory.Token(SyntaxKind.RecordKeyword), "TestRecord");
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() =>
+            recordDeclaration.AddGeneratedCodeAttribute("Tool", null!));
+    }
+
+    [Fact]
+    public void AddGeneratedCodeAttribute_Should_Add_Attribute_With_ToolName_And_Version()
+    {
+        // Arrange
+        var recordDeclaration = SyntaxFactory.RecordDeclaration(SyntaxFactory.Token(SyntaxKind.RecordKeyword), "TestRecord");
+        const string toolName = "MyCodeGenerator";
+        const string version = "1.2.3";
+
+        // Act
+        var result = recordDeclaration.AddGeneratedCodeAttribute(toolName, version);
+
+        // Assert
+        Assert.NotNull(result);
+        var attributeLists = result.AttributeLists;
+        Assert.Single(attributeLists);
+        var attribute = attributeLists[0].Attributes[0];
+        Assert.Equal("GeneratedCode", attribute.Name.ToString(), StringComparer.Ordinal);
+        Assert.NotNull(attribute.ArgumentList);
+        Assert.Equal(2, attribute.ArgumentList.Arguments.Count);
+    }
+}
\ No newline at end of file
diff --git a/test/Atc.CodeAnalysis.CSharp.Tests/Extensions/StructDeclarationSyntaxExtensionsTests.cs b/test/Atc.CodeAnalysis.CSharp.Tests/Extensions/StructDeclarationSyntaxExtensionsTests.cs
new file mode 100644
index 00000000..ba3cbfdd
--- /dev/null
+++ b/test/Atc.CodeAnalysis.CSharp.Tests/Extensions/StructDeclarationSyntaxExtensionsTests.cs
@@ -0,0 +1,110 @@
+namespace Atc.CodeAnalysis.CSharp.Tests.Extensions;
+
+public class StructDeclarationSyntaxExtensionsTests
+{
+    [Fact]
+    public void AddSuppressMessageAttribute_Should_Throw_When_StructDeclaration_Is_Null()
+    {
+        // Arrange
+        StructDeclarationSyntax structDeclaration = null!;
+        var suppressMessage = new SuppressMessageAttribute("category", "checkId") { Justification = "OK." };
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() =>
+            structDeclaration.AddSuppressMessageAttribute(suppressMessage));
+    }
+
+    [Fact]
+    public void AddSuppressMessageAttribute_Should_Throw_When_SuppressMessage_Is_Null()
+    {
+        // Arrange
+        var structDeclaration = SyntaxFactory.StructDeclaration("TestStruct");
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() =>
+            structDeclaration.AddSuppressMessageAttribute(null!));
+    }
+
+    [Fact]
+    public void AddSuppressMessageAttribute_Should_Throw_When_Justification_Is_Empty()
+    {
+        // Arrange
+        var structDeclaration = SyntaxFactory.StructDeclaration("TestStruct");
+        var suppressMessage = new SuppressMessageAttribute("category", "checkId");
+
+        // Act & Assert
+        Assert.Throws<ArgumentException>(() =>
+            structDeclaration.AddSuppressMessageAttribute(suppressMessage));
+    }
+
+    [Fact]
+    public void AddSuppressMessageAttribute_Should_Add_Attribute()
+    {
+        // Arrange
+        var structDeclaration = SyntaxFactory.StructDeclaration("TestStruct");
+        var suppressMessage = new SuppressMessageAttribute("Design", "CA1002") { Justification = "OK." };
+
+        // Act
+        var result = structDeclaration.AddSuppressMessageAttribute(suppressMessage);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Single(result.AttributeLists);
+        var attribute = result.AttributeLists[0].Attributes[0];
+        Assert.Equal("SuppressMessage", attribute.Name.ToString(), StringComparer.Ordinal);
+    }
+
+    [Fact]
+    public void AddGeneratedCodeAttribute_Should_Throw_When_StructDeclaration_Is_Null()
+    {
+        // Arrange
+        StructDeclarationSyntax structDeclaration = null!;
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() =>
+            structDeclaration.AddGeneratedCodeAttribute("Tool", "1.0"));
+    }
+
+    [Fact]
+    public void AddGeneratedCodeAttribute_Should_Throw_When_ToolName_Is_Null()
+    {
+        // Arrange
+        var structDeclaration = SyntaxFactory.StructDeclaration("TestStruct");
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() =>
+            structDeclaration.AddGeneratedCodeAttribute(null!, "1.0"));
+    }
+
+    [Fact]
+    public void AddGeneratedCodeAttribute_Should_Throw_When_Version_Is_Null()
+    {
+        // Arrange
+        var structDeclaration = SyntaxFactory.StructDeclaration("TestStruct");
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() =>
+            structDeclaration.AddGeneratedCodeAttribute("Tool", null!));
+    }
+
+    [Fact]
+    public void AddGeneratedCodeAttribute_Should_Add_Attribute_With_ToolName_And_Version()
+    {
+        // Arrange
+        var structDeclaration = SyntaxFactory.StructDeclaration("TestStruct");
+        const string toolName = "MyCodeGenerator";
+        const string version = "1.2.3";
+
+        // Act
+        var result = structDeclaration.AddGeneratedCodeAttribute(toolName, version);
+
+        // Assert
+        Assert.NotNull(result);
+        var attributeLists = result.AttributeLists;
+        Assert.Single(attributeLists);
+        var attribute = attributeLists[0].Attributes[0];
+        Assert.Equal("GeneratedCode", attribute.Name.ToString(), StringComparer.Ordinal);
+        Assert.NotNull(attribute.ArgumentList);
+        Assert.Equal(2, attribute.ArgumentList.Arguments.Count);
+    }
+}
\ No newline at end of file
diff --git a/test/Atc.CodeAnalysis.CSharp.Tests/SyntaxFactories/SyntaxLiteralExpressionFactoryTests.cs b/test/Atc.CodeAnalysis.CSharp.Tests/SyntaxFactories/SyntaxLiteralExpressionFactoryTests.cs
index c25d2cac..ec5d70d0 100644
--- a/test/Atc.CodeAnalysis.CSharp.Tests/SyntaxFactories/SyntaxLiteralExpressionFactoryTests.cs
+++ b/test/Atc.CodeAnalysis.CSharp.Tests/SyntaxFactories/SyntaxLiteralExpressionFactoryTests.cs
@@ -42,6 +42,17 @@ public void ShouldParseInvalidNumberAsString(string value)
         Assert.Equal($"\"{value}\"", result.ToString());
     }
 
+    [Fact]
+    public void CreateNull_Returns_NullLiteralExpression()
+    {
+        // Act
+        var result = SyntaxLiteralExpressionFactory.CreateNull();
+
+        // Assert
+        Assert.Equal(SyntaxKind.NullLiteralExpression, result.Kind());
+        Assert.Equal("null", result.ToString());
+    }
+
     [Theory]
     [InlineData(0)]
     [InlineData(42)]
diff --git a/test/Atc.CodeAnalysis.CSharp.Tests/SyntaxFactories/SyntaxObjectCreationExpressionFactoryTests.cs b/test/Atc.CodeAnalysis.CSharp.Tests/SyntaxFactories/SyntaxObjectCreationExpressionFactoryTests.cs
index ef48d48c..6a98feaf 100644
--- a/test/Atc.CodeAnalysis.CSharp.Tests/SyntaxFactories/SyntaxObjectCreationExpressionFactoryTests.cs
+++ b/test/Atc.CodeAnalysis.CSharp.Tests/SyntaxFactories/SyntaxObjectCreationExpressionFactoryTests.cs
@@ -56,4 +56,134 @@ public void Create_With_Namespace_Should_Create_Object_Creation_Expression_With_
         Assert.Contains(namespaceName, typeName, StringComparison.Ordinal);
         Assert.Contains(identifierName, typeName, StringComparison.Ordinal);
     }
+
+    [Fact]
+    public void Create_With_ArgumentList_Should_Throw_When_IdentifierName_Is_Null()
+    {
+        // Arrange
+        var argumentList = SyntaxFactory.ArgumentList();
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() =>
+            SyntaxObjectCreationExpressionFactory.Create((string)null!, argumentList));
+    }
+
+    [Fact]
+    public void Create_With_ArgumentList_Should_Throw_When_ArgumentList_Is_Null()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() =>
+            SyntaxObjectCreationExpressionFactory.Create("TestClass", (ArgumentListSyntax)null!));
+    }
+
+    [Fact]
+    public void Create_With_ArgumentList_Should_Create_Object_Creation_Expression_With_Arguments()
+    {
+        // Arrange
+        const string identifierName = "TestClass";
+        var argumentList = SyntaxFactory.ArgumentList();
+
+        // Act
+        var result = SyntaxObjectCreationExpressionFactory.Create(identifierName, argumentList);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Equal(identifierName, result.Type.ToString(), StringComparer.Ordinal);
+        Assert.NotNull(result.ArgumentList);
+    }
+
+    [Fact]
+    public void Create_With_Namespace_And_ArgumentList_Should_Create_Expression_With_Arguments()
+    {
+        // Arrange
+        const string namespaceName = "System";
+        const string identifierName = "Exception";
+        var argumentList = SyntaxFactory.ArgumentList();
+
+        // Act
+        var result = SyntaxObjectCreationExpressionFactory.Create(namespaceName, identifierName, argumentList);
+
+        // Assert
+        Assert.NotNull(result);
+        var typeName = result.Type.ToString();
+        Assert.Contains(namespaceName, typeName, StringComparison.Ordinal);
+        Assert.Contains(identifierName, typeName, StringComparison.Ordinal);
+        Assert.NotNull(result.ArgumentList);
+    }
+
+    [Fact]
+    public void CreateGeneric_With_TypeArgumentList_Should_Create_Generic_Expression()
+    {
+        // Arrange
+        const string identifierName = "List";
+        var typeArgumentList = SyntaxFactory.TypeArgumentList(
+            SyntaxFactory.SeparatedList<TypeSyntax>(new[]
+            {
+                SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)),
+            }));
+
+        // Act
+        var result = SyntaxObjectCreationExpressionFactory.CreateGeneric(identifierName, typeArgumentList);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Contains("List", result.Type.ToString(), StringComparison.Ordinal);
+        Assert.Contains("string", result.Type.ToString(), StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void CreateGeneric_With_TypeArgumentName_Should_Create_Generic_Expression()
+    {
+        // Arrange
+        const string identifierName = "List";
+        const string typeArgumentName = "MyType";
+
+        // Act
+        var result = SyntaxObjectCreationExpressionFactory.CreateGeneric(identifierName, typeArgumentName);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Contains(identifierName, result.Type.ToString(), StringComparison.Ordinal);
+        Assert.Contains(typeArgumentName, result.Type.ToString(), StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void CreateGeneric_With_TypeArgumentList_And_ArgumentList_Should_Create_Generic_Expression_With_Arguments()
+    {
+        // Arrange
+        const string identifierName = "Dictionary";
+        var typeArgumentList = SyntaxFactory.TypeArgumentList(
+            SyntaxFactory.SeparatedList<TypeSyntax>(new[]
+            {
+                SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)),
+                SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)),
+            }));
+        var argumentList = SyntaxFactory.ArgumentList();
+
+        // Act
+        var result = SyntaxObjectCreationExpressionFactory.CreateGeneric(identifierName, typeArgumentList, argumentList);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Contains(identifierName, result.Type.ToString(), StringComparison.Ordinal);
+        Assert.NotNull(result.ArgumentList);
+    }
+
+    [Fact]
+    public void CreateGeneric_With_TypeArgumentName_And_ArgumentList_Should_Create_Generic_Expression_With_Arguments()
+    {
+        // Arrange
+        const string identifierName = "List";
+        const string typeArgumentName = "MyType";
+        var argumentList = SyntaxFactory.ArgumentList();
+
+        // Act
+        var result = SyntaxObjectCreationExpressionFactory.CreateGeneric(identifierName, typeArgumentName, argumentList);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Contains(identifierName, result.Type.ToString(), StringComparison.Ordinal);
+        Assert.Contains(typeArgumentName, result.Type.ToString(), StringComparison.Ordinal);
+        Assert.NotNull(result.ArgumentList);
+    }
 }
\ No newline at end of file

From 7a930a94938030bf52be94ce2a92699693f4b273 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Wed, 24 Jun 2026 02:53:48 +0200
Subject: [PATCH 098/100] feat(atc): add *Ui extension methods using
 CurrentUICulture; rename UsingCurrentUiCulture suffix to Ui

New methods using CultureInfo.CurrentUICulture for frontend/UI rendering scenarios:
- TimeSpanExtensions.GetPrettyTimeUi
- DecimalExtensions.CurrencyRoundingUi
- DoubleExtensions.CurrencyRoundingUi
- DateTimeExtensions.GetWeekNumberUi
- DateTimeOffsetExtensions.GetWeekNumberUi
- IntegerExtensions.GetNumberOfWeeksByYearUi
- IntegerExtensions.GetFirstDayOfWeekNumberByYearUi
- IntegerExtensions.GetLastDayOfWeekNumberByYearUi

Breaking renames (old names removed):
- To*StringUsingCurrentUiCulture -> To*StringUi on DateTime and DateTimeOffset extensions
- TryParse*UsingCurrentUiCulture -> TryParse*Ui on DateTimeHelper and DateTimeOffsetHelper
- IntegerExtensions.GetMonthNameByMonthNumber -> GetMonthNameByMonthNumberUi

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../BaseTypes/DateTimeExtensions.cs           | 49 ++++++++---------
 .../BaseTypes/DateTimeOffsetExtensions.cs     | 49 ++++++++---------
 .../Extensions/BaseTypes/DecimalExtensions.cs |  9 ++++
 .../Extensions/BaseTypes/DoubleExtensions.cs  |  9 ++++
 .../Extensions/BaseTypes/IntegerExtensions.cs | 54 ++++++++++++++++++-
 .../BaseTypes/TimeSpanExtensions.cs           | 42 +++++++++++++++
 src/Atc/Helpers/DateTimeHelper.cs             | 24 ++++-----
 src/Atc/Helpers/DateTimeOffsetHelper.cs       | 24 ++++-----
 8 files changed, 186 insertions(+), 74 deletions(-)

diff --git a/src/Atc/Extensions/BaseTypes/DateTimeExtensions.cs b/src/Atc/Extensions/BaseTypes/DateTimeExtensions.cs
index 3a41a4a9..15e0489d 100644
--- a/src/Atc/Extensions/BaseTypes/DateTimeExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/DateTimeExtensions.cs
@@ -55,6 +55,15 @@ public static string GetPrettyTimeDiff(
     public static int GetWeekNumber(this DateTime date)
         => CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(date, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
 
+    /// <summary>
+    /// Gets the week number from a given date using the current UI culture's calendar.
+    /// Use this variant when rendering the week number for display in a user interface.
+    /// </summary>
+    /// <param name="date">The date.</param>
+    /// <returns>The week number from the given date.</returns>
+    public static int GetWeekNumberUi(this DateTime date)
+        => CultureInfo.CurrentUICulture.Calendar.GetWeekOfYear(date, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
+
     /// <summary>
     /// Find the diff between to DateTimes.
     /// </summary>
@@ -113,14 +122,12 @@ public static string ToIso8601UtcDate(this DateTime dateTime)
             .ToString(GlobalizationConstants.DateTimeIso8601, GlobalizationConstants.EnglishCultureInfo);
 
     /// <summary>
-    /// Converts a DateTime to a string using the long date pattern
-    /// of the current UI culture.
+    /// Converts a DateTime to a string using the long date pattern of the current UI culture.
+    /// Use this variant when rendering output for display in a user interface.
     /// </summary>
     /// <param name="dateTime">The DateTime to format.</param>
-    /// <returns>A string representation of the DateTime using the
-    /// long date pattern of the current UI culture.</returns>
-    public static string ToLongDateStringUsingCurrentUiCulture(
-        this DateTime dateTime)
+    /// <returns>A string representation of the DateTime using the long date pattern of the current UI culture.</returns>
+    public static string ToLongDateStringUi(this DateTime dateTime)
         => dateTime.ToLongDateString(CultureInfo.CurrentUICulture.DateTimeFormat);
 
     /// <summary>
@@ -166,14 +173,12 @@ public static string ToLongDateString(
     }
 
     /// <summary>
-    /// Converts a DateTime to a string using the long time pattern
-    /// of the current UI culture.
+    /// Converts a DateTime to a string using the long time pattern of the current UI culture.
+    /// Use this variant when rendering output for display in a user interface.
     /// </summary>
     /// <param name="dateTime">The DateTime to format.</param>
-    /// <returns>A string representation of the DateTime using the
-    /// long time pattern of the current UI culture.</returns>
-    public static string ToLongTimeStringUsingCurrentUiCulture(
-        this DateTime dateTime)
+    /// <returns>A string representation of the DateTime using the long time pattern of the current UI culture.</returns>
+    public static string ToLongTimeStringUi(this DateTime dateTime)
         => dateTime.ToLongTimeString(CultureInfo.CurrentUICulture.DateTimeFormat);
 
     /// <summary>
@@ -218,14 +223,12 @@ public static string ToLongTimeString(
     }
 
     /// <summary>
-    /// Converts a DateTime to a string using the short date pattern
-    /// of the current UI culture.
+    /// Converts a DateTime to a string using the short date pattern of the current UI culture.
+    /// Use this variant when rendering output for display in a user interface.
     /// </summary>
     /// <param name="dateTime">The DateTime to format.</param>
-    /// <returns>A string representation of the DateTime using the
-    /// short date pattern of the current UI culture.</returns>
-    public static string ToShortDateStringUsingCurrentUiCulture(
-        this DateTime dateTime)
+    /// <returns>A string representation of the DateTime using the short date pattern of the current UI culture.</returns>
+    public static string ToShortDateStringUi(this DateTime dateTime)
         => dateTime.ToShortDateString(CultureInfo.CurrentUICulture.DateTimeFormat);
 
     /// <summary>
@@ -270,14 +273,12 @@ public static string ToShortDateString(
     }
 
     /// <summary>
-    /// Converts a DateTime to a string using the short time pattern
-    /// of the current UI culture.
+    /// Converts a DateTime to a string using the short time pattern of the current UI culture.
+    /// Use this variant when rendering output for display in a user interface.
     /// </summary>
     /// <param name="dateTime">The DateTime to format.</param>
-    /// <returns>A string representation of the DateTime using the
-    /// short time pattern of the current UI culture.</returns>
-    public static string ToShortTimeStringUsingCurrentUiCulture(
-        this DateTime dateTime)
+    /// <returns>A string representation of the DateTime using the short time pattern of the current UI culture.</returns>
+    public static string ToShortTimeStringUi(this DateTime dateTime)
         => dateTime.ToShortTimeString(CultureInfo.CurrentUICulture.DateTimeFormat);
 
     /// <summary>
diff --git a/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs b/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs
index cf8ec685..828e09e8 100644
--- a/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/DateTimeOffsetExtensions.cs
@@ -55,6 +55,15 @@ public static string GetPrettyTimeDiff(
     public static int GetWeekNumber(this DateTimeOffset date)
         => CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(date.DateTime, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
 
+    /// <summary>
+    /// Gets the week number from a given date using the current UI culture's calendar.
+    /// Use this variant when rendering the week number for display in a user interface.
+    /// </summary>
+    /// <param name="date">The date.</param>
+    /// <returns>The week number from the given date.</returns>
+    public static int GetWeekNumberUi(this DateTimeOffset date)
+        => CultureInfo.CurrentUICulture.Calendar.GetWeekOfYear(date.DateTime, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
+
     /// <summary>
     /// Find the diff between to DateTimes.
     /// </summary>
@@ -157,14 +166,12 @@ public static string ToIso8601UtcDate(this DateTimeOffset dateTimeOffset)
             .ToString(GlobalizationConstants.DateTimeIso8601, GlobalizationConstants.EnglishCultureInfo);
 
     /// <summary>
-    /// Converts a DateTime to a string using the long date pattern
-    /// of the current UI culture.
+    /// Converts a DateTimeOffset to a string using the long date pattern of the current UI culture.
+    /// Use this variant when rendering output for display in a user interface.
     /// </summary>
     /// <param name="dateTimeOffset">The DateTimeOffset to format.</param>
-    /// <returns>A string representation of the DateTime using the
-    /// long date pattern of the current UI culture.</returns>
-    public static string ToLongDateStringUsingCurrentUiCulture(
-        this DateTimeOffset dateTimeOffset)
+    /// <returns>A string representation of the DateTimeOffset using the long date pattern of the current UI culture.</returns>
+    public static string ToLongDateStringUi(this DateTimeOffset dateTimeOffset)
         => dateTimeOffset.ToLongDateString(CultureInfo.CurrentUICulture.DateTimeFormat);
 
     /// <summary>
@@ -191,14 +198,12 @@ public static string ToLongDateString(
     }
 
     /// <summary>
-    /// Converts a DateTime to a string using the long time pattern
-    /// of the current UI culture.
+    /// Converts a DateTimeOffset to a string using the long time pattern of the current UI culture.
+    /// Use this variant when rendering output for display in a user interface.
     /// </summary>
     /// <param name="dateTimeOffset">The DateTimeOffset to format.</param>
-    /// <returns>A string representation of the DateTime using the
-    /// long time pattern of the current UI culture.</returns>
-    public static string ToLongTimeStringUsingCurrentUiCulture(
-        this DateTimeOffset dateTimeOffset)
+    /// <returns>A string representation of the DateTimeOffset using the long time pattern of the current UI culture.</returns>
+    public static string ToLongTimeStringUi(this DateTimeOffset dateTimeOffset)
         => dateTimeOffset.ToLongTimeString(CultureInfo.CurrentUICulture.DateTimeFormat);
 
     /// <summary>
@@ -224,14 +229,12 @@ public static string ToLongTimeString(
     }
 
     /// <summary>
-    /// Converts a DateTime to a string using the short date pattern
-    /// of the current UI culture.
+    /// Converts a DateTimeOffset to a string using the short date pattern of the current UI culture.
+    /// Use this variant when rendering output for display in a user interface.
     /// </summary>
     /// <param name="dateTimeOffset">The DateTimeOffset to format.</param>
-    /// <returns>A string representation of the DateTime using the
-    /// short date pattern of the current UI culture.</returns>
-    public static string ToShortDateStringUsingCurrentUiCulture(
-        this DateTimeOffset dateTimeOffset)
+    /// <returns>A string representation of the DateTimeOffset using the short date pattern of the current UI culture.</returns>
+    public static string ToShortDateStringUi(this DateTimeOffset dateTimeOffset)
         => dateTimeOffset.ToShortDateString(CultureInfo.CurrentUICulture.DateTimeFormat);
 
     /// <summary>
@@ -272,14 +275,12 @@ public static string ToShortDateString(
     }
 
     /// <summary>
-    /// Converts a DateTime to a string using the short time pattern
-    /// of the current UI culture.
+    /// Converts a DateTimeOffset to a string using the short time pattern of the current UI culture.
+    /// Use this variant when rendering output for display in a user interface.
     /// </summary>
     /// <param name="dateTimeOffset">The DateTimeOffset to format.</param>
-    /// <returns>A string representation of the DateTime using the
-    /// short time pattern of the current UI culture.</returns>
-    public static string ToShortTimeStringUsingCurrentUiCulture(
-        this DateTimeOffset dateTimeOffset)
+    /// <returns>A string representation of the DateTimeOffset using the short time pattern of the current UI culture.</returns>
+    public static string ToShortTimeStringUi(this DateTimeOffset dateTimeOffset)
         => dateTimeOffset.ToShortTimeString(CultureInfo.CurrentUICulture.DateTimeFormat);
 
     /// <summary>
diff --git a/src/Atc/Extensions/BaseTypes/DecimalExtensions.cs b/src/Atc/Extensions/BaseTypes/DecimalExtensions.cs
index d570a3bf..43482bf3 100644
--- a/src/Atc/Extensions/BaseTypes/DecimalExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/DecimalExtensions.cs
@@ -147,6 +147,15 @@ public static decimal CurrencyRounding(
         return Math.Round(value, digits, MidpointRounding.AwayFromZero);
     }
 
+    /// <summary>
+    /// Rounds a decimal value using the currency decimal digits of the current UI culture.
+    /// Use this variant when rounding for display in a user interface.
+    /// </summary>
+    /// <param name="value">The decimal value to round.</param>
+    /// <returns>The rounded decimal value.</returns>
+    public static decimal CurrencyRoundingUi(this decimal value)
+        => CurrencyRounding(value, CultureInfo.CurrentUICulture.NumberFormat.CurrencyDecimalDigits);
+
     /// <summary>
     /// Rounds a decimal value to 2 decimal places.
     /// </summary>
diff --git a/src/Atc/Extensions/BaseTypes/DoubleExtensions.cs b/src/Atc/Extensions/BaseTypes/DoubleExtensions.cs
index a1cb0588..33ac8a8b 100644
--- a/src/Atc/Extensions/BaseTypes/DoubleExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/DoubleExtensions.cs
@@ -154,6 +154,15 @@ public static double CurrencyRounding(
         return Math.Round(value, digits, MidpointRounding.AwayFromZero);
     }
 
+    /// <summary>
+    /// Rounds a double value using the currency decimal digits of the current UI culture.
+    /// Use this variant when rounding for display in a user interface.
+    /// </summary>
+    /// <param name="value">The double value to round.</param>
+    /// <returns>The rounded double value.</returns>
+    public static double CurrencyRoundingUi(this double value)
+        => CurrencyRounding(value, CultureInfo.CurrentUICulture.NumberFormat.CurrencyDecimalDigits);
+
     /// <summary>
     /// Rounds a double value to 2 decimal places.
     /// </summary>
diff --git a/src/Atc/Extensions/BaseTypes/IntegerExtensions.cs b/src/Atc/Extensions/BaseTypes/IntegerExtensions.cs
index 43997542..ab613f85 100644
--- a/src/Atc/Extensions/BaseTypes/IntegerExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/IntegerExtensions.cs
@@ -92,13 +92,14 @@ public static bool IsBinarySequence(this int number)
         => number > 0 && (number & (number - 1)) == 0;
 
     /// <summary>
-    /// Gets the month name by month number.
+    /// Gets the month name by month number using the current UI culture.
+    /// Use this variant when rendering output for display in a user interface.
     /// </summary>
     /// <param name="month">The month.</param>
     /// <param name="pascalCased">if set to <see langword="true" /> [pascal cased].</param>
     /// <returns>The name of the month.</returns>
     [SuppressMessage("Microsoft.Globalization", "CA1305:SpecifyIFormatProvider", Justification = "OK.")]
-    public static string GetMonthNameByMonthNumber(
+    public static string GetMonthNameByMonthNumberUi(
         this int month,
         bool pascalCased = false)
     {
@@ -130,6 +131,15 @@ public static string GetMonthNameByMonthNumber(
     public static int GetNumberOfWeeksByYear(this int year)
         => CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(new DateTime(year, 12, 28), CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
 
+    /// <summary>
+    /// Returns the number of ISO weeks in the given year using the current UI culture's calendar.
+    /// Use this variant when rendering the value for display in a user interface.
+    /// </summary>
+    /// <param name="year">The four-digit year.</param>
+    /// <returns>52 or 53 depending on the year and calendar.</returns>
+    public static int GetNumberOfWeeksByYearUi(this int year)
+        => CultureInfo.CurrentUICulture.Calendar.GetWeekOfYear(new DateTime(year, 12, 28), CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
+
     /// <summary>
     /// Get the date of the first day in the given year and week number.
     /// </summary>
@@ -157,6 +167,34 @@ public static DateTime GetFirstDayOfWeekNumberByYear(
         return result.AddDays(-3);
     }
 
+    /// <summary>
+    /// Gets the date of the first day of a given week in a given year using the current UI culture's calendar.
+    /// Use this variant when rendering dates for display in a user interface.
+    /// </summary>
+    /// <param name="year">The four-digit year.</param>
+    /// <param name="weekNumber">The ISO week number (1–53).</param>
+    /// <returns>The <see cref="DateTime"/> of the Monday that starts the requested week.</returns>
+    public static DateTime GetFirstDayOfWeekNumberByYearUi(
+        this int year,
+        int weekNumber)
+    {
+        var calendar = CultureInfo.CurrentUICulture.Calendar;
+        var firstOfYear = new DateTime(year, 1, 1, calendar);
+        var daysOffset = DayOfWeek.Thursday - firstOfYear.DayOfWeek;
+
+        var firstThursday = firstOfYear.AddDays(daysOffset);
+        var firstWeek = CultureInfo.CurrentUICulture.Calendar.GetWeekOfYear(firstThursday, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
+
+        var weekNum = weekNumber;
+        if (firstWeek <= 1)
+        {
+            weekNum -= 1;
+        }
+
+        var result = firstThursday.AddDays(weekNum * 7);
+        return result.AddDays(-3);
+    }
+
     /// <summary>
     /// Get the date of the last day in the given year and week number.
     /// </summary>
@@ -167,4 +205,16 @@ public static DateTime GetLastDayOfWeekNumberByYear(
         this int year,
         int weekNumber)
         => GetFirstDayOfWeekNumberByYear(year, weekNumber).AddDays(6);
+
+    /// <summary>
+    /// Gets the date of the last day of a given week in a given year using the current UI culture's calendar.
+    /// Use this variant when rendering dates for display in a user interface.
+    /// </summary>
+    /// <param name="year">The four-digit year.</param>
+    /// <param name="weekNumber">The ISO week number (1–53).</param>
+    /// <returns>The <see cref="DateTime"/> of the Sunday that ends the requested week.</returns>
+    public static DateTime GetLastDayOfWeekNumberByYearUi(
+        this int year,
+        int weekNumber)
+        => GetFirstDayOfWeekNumberByYearUi(year, weekNumber).AddDays(6);
 }
\ No newline at end of file
diff --git a/src/Atc/Extensions/BaseTypes/TimeSpanExtensions.cs b/src/Atc/Extensions/BaseTypes/TimeSpanExtensions.cs
index 31d21770..a12689ce 100644
--- a/src/Atc/Extensions/BaseTypes/TimeSpanExtensions.cs
+++ b/src/Atc/Extensions/BaseTypes/TimeSpanExtensions.cs
@@ -87,4 +87,46 @@ public static string GetPrettyTime(
         return $"{timeSpan.TotalMilliseconds.ToString("N" + decimalPrecision, CultureInfo.CurrentCulture)} " +
                $"{DateAndTime.MillisecondAsAbbreviation1.ToLower(CultureInfo.CurrentCulture)}";
     }
+
+    /// <summary>
+    /// Converts a TimeSpan to a human-readable string representation with appropriate time units,
+    /// using the current UI culture for number formatting and unit label casing.
+    /// Use this variant when rendering output for display in a user interface.
+    /// </summary>
+    /// <param name="timeSpan">The TimeSpan to format.</param>
+    /// <param name="decimalPrecision">The number of decimal places to display (default is 3).</param>
+    /// <returns>A formatted string representing the time in the most appropriate unit (days, hours, minutes, seconds, or milliseconds).</returns>
+    [SuppressMessage("Globalization", "CA1305:Specify IFormatProvider", Justification = "OK.")]
+    public static string GetPrettyTimeUi(
+        this TimeSpan timeSpan,
+        int decimalPrecision = 3)
+    {
+        if ((int)timeSpan.TotalDays > 0)
+        {
+            return $"{timeSpan.TotalDays.ToString("N" + decimalPrecision, CultureInfo.CurrentUICulture)} " +
+                   $"{DateAndTime.Days.ToLower(CultureInfo.CurrentUICulture)}";
+        }
+
+        if ((int)timeSpan.TotalHours > 0)
+        {
+            return $"{timeSpan.TotalHours.ToString("N" + decimalPrecision, CultureInfo.CurrentUICulture)} " +
+                   $"{DateAndTime.Hours.ToLower(CultureInfo.CurrentUICulture)}";
+        }
+
+        if ((int)timeSpan.TotalMinutes > 0)
+        {
+            return $"{timeSpan.TotalMinutes.ToString("N" + decimalPrecision, CultureInfo.CurrentUICulture)} " +
+                   $"{DateAndTime.MinuteAsAbbreviation.ToLower(CultureInfo.CurrentUICulture)}";
+        }
+
+        // ReSharper disable once ConvertIfStatementToReturnStatement
+        if ((int)timeSpan.TotalSeconds > 0)
+        {
+            return $"{timeSpan.TotalSeconds.ToString("N" + decimalPrecision, CultureInfo.CurrentUICulture)} " +
+                   $"{DateAndTime.SecondAsAbbreviation.ToLower(CultureInfo.CurrentUICulture)}";
+        }
+
+        return $"{timeSpan.TotalMilliseconds.ToString("N" + decimalPrecision, CultureInfo.CurrentUICulture)} " +
+               $"{DateAndTime.MillisecondAsAbbreviation1.ToLower(CultureInfo.CurrentUICulture)}";
+    }
 }
\ No newline at end of file
diff --git a/src/Atc/Helpers/DateTimeHelper.cs b/src/Atc/Helpers/DateTimeHelper.cs
index d181d228..fd76f94d 100644
--- a/src/Atc/Helpers/DateTimeHelper.cs
+++ b/src/Atc/Helpers/DateTimeHelper.cs
@@ -10,8 +10,8 @@ public static class DateTimeHelper
     private const int MaxTimeLengthFor12Hours = 8;
 
     /// <summary>
-    /// Tries to parse a string representation of a <c>DateTime</c> using
-    /// the current UI culture's date and time format.
+    /// Tries to parse a string representation of a <c>DateTime</c> using the current UI culture's date and time format.
+    /// Use this variant when parsing input from a user interface.
     /// </summary>
     /// <param name="value">The string to parse.</param>
     /// <param name="result">
@@ -21,7 +21,7 @@ public static class DateTimeHelper
     /// <returns>
     ///   <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
     /// </returns>
-    public static bool TryParseUsingCurrentUiCulture(
+    public static bool TryParseUi(
         string value,
         out DateTime result)
     {
@@ -78,8 +78,8 @@ public static bool TryParseUsingSpecificCulture(
     }
 
     /// <summary>
-    /// Tries to parse a string representation of a short date using
-    /// the current UI culture's date format.
+    /// Tries to parse a string representation of a short date using the current UI culture's date format.
+    /// Use this variant when parsing input from a user interface.
     /// </summary>
     /// <param name="value">The string to parse.</param>
     /// <param name="result">
@@ -89,7 +89,7 @@ public static bool TryParseUsingSpecificCulture(
     /// <returns>
     ///   <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
     /// </returns>
-    public static bool TryParseShortDateUsingCurrentUiCulture(
+    public static bool TryParseShortDateUi(
         string value,
         out DateTime result)
     {
@@ -146,8 +146,8 @@ public static bool TryParseShortDateUsingSpecificCulture(
     }
 
     /// <summary>
-    /// Tries to parse a string representation of a short time using the
-    /// current UI culture's time format (12-hour or 24-hour).
+    /// Tries to parse a string representation of a short time using the current UI culture's time format (12-hour or 24-hour).
+    /// Use this variant when parsing input from a user interface.
     /// </summary>
     /// <param name="value">The string to parse.</param>
     /// <param name="result">
@@ -157,7 +157,7 @@ public static bool TryParseShortDateUsingSpecificCulture(
     /// <returns>
     ///   <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
     /// </returns>
-    public static bool TryParseShortTimeUsingCurrentUiCulture(
+    public static bool TryParseShortTimeUi(
         string value,
         out DateTime result)
     {
@@ -221,8 +221,8 @@ public static bool TryParseShortTimeUsingSpecificCulture(
     }
 
     /// <summary>
-    /// Tries to parse a string representation of a short UTC time using the
-    /// current UI culture's time format (12-hour or 24-hour).
+    /// Tries to parse a string representation of a short UTC time using the current UI culture's time format (12-hour or 24-hour).
+    /// Use this variant when parsing input from a user interface.
     /// </summary>
     /// <param name="value">The string to parse.</param>
     /// <param name="result">
@@ -232,7 +232,7 @@ public static bool TryParseShortTimeUsingSpecificCulture(
     /// <returns>
     ///   <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
     /// </returns>
-    public static bool TryParseShortTimeUsingCurrentUiCultureUtc(
+    public static bool TryParseShortTimeUiUtc(
         string value,
         out DateTime result)
     {
diff --git a/src/Atc/Helpers/DateTimeOffsetHelper.cs b/src/Atc/Helpers/DateTimeOffsetHelper.cs
index a6cb6b49..d4d15fb8 100644
--- a/src/Atc/Helpers/DateTimeOffsetHelper.cs
+++ b/src/Atc/Helpers/DateTimeOffsetHelper.cs
@@ -10,8 +10,8 @@ public static class DateTimeOffsetHelper
     private const int MaxTimeLengthFor12Hours = 8;
 
     /// <summary>
-    /// Tries to parse a string representation of a <c>DateTimeOffset</c> using
-    /// the current UI culture's date and time format.
+    /// Tries to parse a string representation of a <c>DateTimeOffset</c> using the current UI culture's date and time format.
+    /// Use this variant when parsing input from a user interface.
     /// </summary>
     /// <param name="value">The string to parse.</param>
     /// <param name="result">
@@ -21,7 +21,7 @@ public static class DateTimeOffsetHelper
     /// <returns>
     ///   <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
     /// </returns>
-    public static bool TryParseUsingCurrentUiCulture(
+    public static bool TryParseUi(
         string value,
         out DateTimeOffset result)
     {
@@ -76,8 +76,8 @@ public static bool TryParseUsingSpecificCulture(
     }
 
     /// <summary>
-    /// Tries to parse a string representation of a short date using
-    /// the current UI culture's date format.
+    /// Tries to parse a string representation of a short date using the current UI culture's date format.
+    /// Use this variant when parsing input from a user interface.
     /// </summary>
     /// <param name="value">The string to parse.</param>
     /// <param name="result">
@@ -87,7 +87,7 @@ public static bool TryParseUsingSpecificCulture(
     /// <returns>
     ///   <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
     /// </returns>
-    public static bool TryParseShortDateUsingCurrentUiCulture(
+    public static bool TryParseShortDateUi(
         string value,
         out DateTimeOffset result)
     {
@@ -142,8 +142,8 @@ public static bool TryParseShortDateUsingSpecificCulture(
     }
 
     /// <summary>
-    /// Tries to parse a string representation of a short time using the
-    /// current UI culture's time format (12-hour or 24-hour).
+    /// Tries to parse a string representation of a short time using the current UI culture's time format (12-hour or 24-hour).
+    /// Use this variant when parsing input from a user interface.
     /// </summary>
     /// <param name="value">The string to parse.</param>
     /// <param name="result">
@@ -153,7 +153,7 @@ public static bool TryParseShortDateUsingSpecificCulture(
     /// <returns>
     ///   <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
     /// </returns>
-    public static bool TryParseShortTimeUsingCurrentUiCulture(
+    public static bool TryParseShortTimeUi(
         string value,
         out DateTimeOffset result)
     {
@@ -215,8 +215,8 @@ public static bool TryParseShortTimeUsingSpecificCulture(
     }
 
     /// <summary>
-    /// Tries to parse a string representation of a short UTC time using the
-    /// current UI culture's time format (12-hour or 24-hour).
+    /// Tries to parse a string representation of a short UTC time using the current UI culture's time format (12-hour or 24-hour).
+    /// Use this variant when parsing input from a user interface.
     /// </summary>
     /// <param name="value">The string to parse.</param>
     /// <param name="result">
@@ -226,7 +226,7 @@ public static bool TryParseShortTimeUsingSpecificCulture(
     /// <returns>
     ///   <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
     /// </returns>
-    public static bool TryParseShortTimeUsingCurrentUiCultureUtc(
+    public static bool TryParseShortTimeUiUtc(
         string value,
         out DateTimeOffset result)
     {

From a35e97e32898255fb8dfa909314f6ed4c2f72e84 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Wed, 24 Jun 2026 02:53:56 +0200
Subject: [PATCH 099/100] test(atc): add tests for *Ui extension methods and
 update renamed method calls

- Add theory tests for all new *Ui methods verifying CurrentUICulture is used
  (tests set CurrentUICulture independently from CurrentCulture to confirm the
  correct property is read)
- Rename test method calls from *UsingCurrentUiCulture to *Ui to match source renames
- Fix GetMonthNameByMonthNumber -> GetMonthNameByMonthNumberUi call sites
- Fix TestMemberDataForTimeSpanExtensions: correct expected values for GetPrettyTimeUi

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../BaseTypes/DateTimeExtensionsTests.cs      | 37 +++++++---
 .../DateTimeOffsetExtensionsTests.cs          | 37 +++++++---
 .../BaseTypes/DecimalExtensionsTests.cs       | 18 +++++
 .../BaseTypes/DoubleExtensionsTests.cs        | 18 +++++
 .../BaseTypes/IntegerExtensionsTests.cs       | 69 ++++++++++++++++++-
 .../BaseTypes/TimeSpanExtensionsTests.cs      | 19 +++++
 test/Atc.Tests/Helpers/DateTimeHelperTests.cs | 16 ++---
 .../Helpers/DateTimeOffsetHelperTests.cs      | 16 ++---
 .../TestMemberDataForTimeSpanExtensions.cs    | 15 ++++
 9 files changed, 211 insertions(+), 34 deletions(-)

diff --git a/test/Atc.Tests/Extensions/BaseTypes/DateTimeExtensionsTests.cs b/test/Atc.Tests/Extensions/BaseTypes/DateTimeExtensionsTests.cs
index 9f985502..e243529c 100644
--- a/test/Atc.Tests/Extensions/BaseTypes/DateTimeExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/BaseTypes/DateTimeExtensionsTests.cs
@@ -76,6 +76,7 @@ public void GetPrettyTimeDiff_EndNow(
         int arrangeUiLcid)
     {
         // Arrange
+        Thread.CurrentThread.CurrentCulture = new CultureInfo(arrangeUiLcid);
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
@@ -95,6 +96,7 @@ public void GetPrettyTimeDiff_EndNow_DecimalPrecision(
         int arrangeUiLcid)
     {
         // Arrange
+        Thread.CurrentThread.CurrentCulture = new CultureInfo(arrangeUiLcid);
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
@@ -122,6 +124,25 @@ public void GetWeekNumber(
         Assert.Equal(expected, actual);
     }
 
+    [Theory]
+    [InlineData(1, 1970, 1)]
+    [InlineData(48, 2019, 12)]
+    public void GetWeekNumberUi(
+        int expected,
+        int year,
+        int month)
+    {
+        // Arrange
+        Thread.CurrentThread.CurrentUICulture = new CultureInfo(GlobalizationLcidConstants.UnitedStates);
+        var input = new DateTime(year, month, 1, 0, 0, 0);
+
+        // Act
+        var actual = input.GetWeekNumberUi();
+
+        // Assert
+        Assert.Equal(expected, actual);
+    }
+
     [Theory]
     [InlineData(10000, 10, DateTimeDiffCompareType.Milliseconds)]
     [InlineData(42000, 42, DateTimeDiffCompareType.Milliseconds)]
@@ -183,7 +204,7 @@ public void ToIso8601Utc(
     [InlineData("Sunday, 15 October 2023", GlobalizationLcidConstants.GreatBritain)]
     [InlineData("søndag den 15. oktober 2023", GlobalizationLcidConstants.Denmark)]
     [InlineData("Sonntag, 15. Oktober 2023", GlobalizationLcidConstants.Germany)]
-    public void ToLongDateStringUsingCurrentUiCulture(
+    public void ToLongDateStringUi(
         string expected,
         int arrangeUiLcid)
     {
@@ -192,7 +213,7 @@ public void ToLongDateStringUsingCurrentUiCulture(
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
-        var actual = dateTime.ToLongDateStringUsingCurrentUiCulture();
+        var actual = dateTime.ToLongDateStringUi();
 
         // Assert
         Assert.Equal(expected, actual);
@@ -223,7 +244,7 @@ public void ToLongDateString(
     [InlineData("15:30:45", GlobalizationLcidConstants.GreatBritain)]
     [InlineData("15.30.45", GlobalizationLcidConstants.Denmark)]
     [InlineData("15:30:45", GlobalizationLcidConstants.Germany)]
-    public void ToLongTimeStringUsingCurrentUiCulture(
+    public void ToLongTimeStringUi(
         string expected,
         int arrangeUiLcid)
     {
@@ -232,7 +253,7 @@ public void ToLongTimeStringUsingCurrentUiCulture(
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
-        var actual = dateTime.ToLongTimeStringUsingCurrentUiCulture();
+        var actual = dateTime.ToLongTimeStringUi();
 
         // Assert
         Assert.Equal(expected, actual);
@@ -263,7 +284,7 @@ public void ToLongTimeString(
     [InlineData("15/10/2023", GlobalizationLcidConstants.GreatBritain)]
     [InlineData("15.10.2023", GlobalizationLcidConstants.Denmark)]
     [InlineData("15.10.2023", GlobalizationLcidConstants.Germany)]
-    public void ToShortDateStringUsingCurrentUiCulture(
+    public void ToShortDateStringUi(
         string expected,
         int arrangeUiLcid)
     {
@@ -272,7 +293,7 @@ public void ToShortDateStringUsingCurrentUiCulture(
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
-        var actual = dateTime.ToShortDateStringUsingCurrentUiCulture();
+        var actual = dateTime.ToShortDateStringUi();
 
         // Assert
         Assert.Equal(expected, actual);
@@ -303,7 +324,7 @@ public void ToShortDateString(
     [InlineData("15:30", GlobalizationLcidConstants.GreatBritain)]
     [InlineData("15.30", GlobalizationLcidConstants.Denmark)]
     [InlineData("15:30", GlobalizationLcidConstants.Germany)]
-    public void ToShortTimeStringUsingCurrentUiCulture(
+    public void ToShortTimeStringUi(
         string expected,
         int arrangeUiLcid)
     {
@@ -312,7 +333,7 @@ public void ToShortTimeStringUsingCurrentUiCulture(
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
-        var actual = dateTime.ToShortTimeStringUsingCurrentUiCulture();
+        var actual = dateTime.ToShortTimeStringUi();
 
         // Assert
         Assert.Equal(expected, actual);
diff --git a/test/Atc.Tests/Extensions/BaseTypes/DateTimeOffsetExtensionsTests.cs b/test/Atc.Tests/Extensions/BaseTypes/DateTimeOffsetExtensionsTests.cs
index b70f4397..9dc781d7 100644
--- a/test/Atc.Tests/Extensions/BaseTypes/DateTimeOffsetExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/BaseTypes/DateTimeOffsetExtensionsTests.cs
@@ -71,6 +71,7 @@ public void GetPrettyTimeDiff_EndNow(
         int arrangeUiLcid)
     {
         // Arrange
+        Thread.CurrentThread.CurrentCulture = new CultureInfo(arrangeUiLcid);
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
@@ -90,6 +91,7 @@ public void GetPrettyTimeDiff_EndNow_DecimalPrecision(
         int arrangeUiLcid)
     {
         // Arrange
+        Thread.CurrentThread.CurrentCulture = new CultureInfo(arrangeUiLcid);
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
@@ -117,6 +119,25 @@ public void GetWeekNumber(
         Assert.Equal(expected, actual);
     }
 
+    [Theory]
+    [InlineData(1, 1970, 1)]
+    [InlineData(48, 2019, 12)]
+    public void GetWeekNumberUi(
+        int expected,
+        int year,
+        int month)
+    {
+        // Arrange
+        Thread.CurrentThread.CurrentUICulture = new CultureInfo(GlobalizationLcidConstants.UnitedStates);
+        var input = new DateTimeOffset(year, month, 1, 0, 0, 0, TimeSpan.Zero);
+
+        // Act
+        var actual = input.GetWeekNumberUi();
+
+        // Assert
+        Assert.Equal(expected, actual);
+    }
+
     [Theory]
     [InlineData(true, 2019, 10, 5, 15)]
     [InlineData(true, 2019, 10, 10, 15)]
@@ -239,7 +260,7 @@ public void ToIso8601Utc(
     [InlineData("Sunday, 15 October 2023", GlobalizationLcidConstants.GreatBritain)]
     [InlineData("søndag den 15. oktober 2023", GlobalizationLcidConstants.Denmark)]
     [InlineData("Sonntag, 15. Oktober 2023", GlobalizationLcidConstants.Germany)]
-    public void ToLongDateStringUsingCurrentUiCulture(
+    public void ToLongDateStringUi(
         string expected,
         int arrangeUiLcid)
     {
@@ -248,7 +269,7 @@ public void ToLongDateStringUsingCurrentUiCulture(
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
-        var actual = dateTimeOffset.ToLongDateStringUsingCurrentUiCulture();
+        var actual = dateTimeOffset.ToLongDateStringUi();
 
         // Assert
         Assert.Equal(expected, actual);
@@ -279,7 +300,7 @@ public void ToLongDateString(
     [InlineData("15:30:45", GlobalizationLcidConstants.GreatBritain)]
     [InlineData("15.30.45", GlobalizationLcidConstants.Denmark)]
     [InlineData("15:30:45", GlobalizationLcidConstants.Germany)]
-    public void ToLongTimeStringUsingCurrentUiCulture(
+    public void ToLongTimeStringUi(
         string expected,
         int arrangeUiLcid)
     {
@@ -288,7 +309,7 @@ public void ToLongTimeStringUsingCurrentUiCulture(
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
-        var actual = dateTimeOffset.ToLongTimeStringUsingCurrentUiCulture();
+        var actual = dateTimeOffset.ToLongTimeStringUi();
 
         // Assert
         Assert.Equal(expected, actual);
@@ -319,7 +340,7 @@ public void ToLongTimeString(
     [InlineData("15/10/2023", GlobalizationLcidConstants.GreatBritain)]
     [InlineData("15.10.2023", GlobalizationLcidConstants.Denmark)]
     [InlineData("15.10.2023", GlobalizationLcidConstants.Germany)]
-    public void ToShortDateStringUsingCurrentUiCulture(
+    public void ToShortDateStringUi(
         string expected,
         int arrangeUiLcid)
     {
@@ -328,7 +349,7 @@ public void ToShortDateStringUsingCurrentUiCulture(
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
-        var actual = dateTimeOffset.ToShortDateStringUsingCurrentUiCulture();
+        var actual = dateTimeOffset.ToShortDateStringUi();
 
         // Assert
         Assert.Equal(expected, actual);
@@ -359,7 +380,7 @@ public void ToShortDateString(
     [InlineData("15:30", GlobalizationLcidConstants.GreatBritain)]
     [InlineData("15.30", GlobalizationLcidConstants.Denmark)]
     [InlineData("15:30", GlobalizationLcidConstants.Germany)]
-    public void ToShortTimeStringUsingCurrentUiCulture(
+    public void ToShortTimeStringUi(
         string expected,
         int arrangeUiLcid)
     {
@@ -368,7 +389,7 @@ public void ToShortTimeStringUsingCurrentUiCulture(
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
-        var actual = dateTimeOffset.ToShortTimeStringUsingCurrentUiCulture();
+        var actual = dateTimeOffset.ToShortTimeStringUi();
 
         // Assert
         Assert.Equal(expected, actual);
diff --git a/test/Atc.Tests/Extensions/BaseTypes/DecimalExtensionsTests.cs b/test/Atc.Tests/Extensions/BaseTypes/DecimalExtensionsTests.cs
index b348b7a4..1f50a06c 100644
--- a/test/Atc.Tests/Extensions/BaseTypes/DecimalExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/BaseTypes/DecimalExtensionsTests.cs
@@ -106,6 +106,24 @@ public void CurrencyRounding(
         Assert.Equal(expected, actual);
     }
 
+    [Theory]
+    [InlineData(12.45, 12.449)]
+    [InlineData(12.45, 12.450)]
+    [InlineData(12.45, 12.451)]
+    public void CurrencyRoundingUi(
+        decimal expected,
+        decimal input)
+    {
+        // Arrange
+        Thread.CurrentThread.CurrentUICulture = new CultureInfo(GlobalizationLcidConstants.UnitedStates);
+
+        // Act
+        var actual = input.CurrencyRoundingUi();
+
+        // Assert
+        Assert.Equal(expected, actual);
+    }
+
     [Theory]
     [InlineData(0.0, 0, 0)]
     [InlineData(10.0, 10, 0)]
diff --git a/test/Atc.Tests/Extensions/BaseTypes/DoubleExtensionsTests.cs b/test/Atc.Tests/Extensions/BaseTypes/DoubleExtensionsTests.cs
index 4d04afe5..4ba96802 100644
--- a/test/Atc.Tests/Extensions/BaseTypes/DoubleExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/BaseTypes/DoubleExtensionsTests.cs
@@ -164,6 +164,24 @@ public void CurrencyRounding(
         Assert.Equal(expected, actual);
     }
 
+    [Theory]
+    [InlineData(12.45, 12.449)]
+    [InlineData(12.45, 12.450)]
+    [InlineData(12.45, 12.451)]
+    public void CurrencyRoundingUi(
+        double expected,
+        double input)
+    {
+        // Arrange
+        Thread.CurrentThread.CurrentUICulture = new CultureInfo(GlobalizationLcidConstants.UnitedStates);
+
+        // Act
+        var actual = input.CurrencyRoundingUi();
+
+        // Assert
+        Assert.Equal(expected, actual);
+    }
+
     [Theory]
     [InlineData(0.0, 0, 0)]
     [InlineData(10.0, 10, 0)]
diff --git a/test/Atc.Tests/Extensions/BaseTypes/IntegerExtensionsTests.cs b/test/Atc.Tests/Extensions/BaseTypes/IntegerExtensionsTests.cs
index a4b94589..4441d3f7 100644
--- a/test/Atc.Tests/Extensions/BaseTypes/IntegerExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/BaseTypes/IntegerExtensionsTests.cs
@@ -113,7 +113,7 @@ public void IsBinarySequence(
 
     [Theory]
     [MemberData(nameof(TestMemberDataForExtensionsInteger.MonthNameData), MemberType = typeof(TestMemberDataForExtensionsInteger))]
-    public void GetMonthNameByMonthNumber(
+    public void GetMonthNameByMonthNumberUi(
         int arrangeUiLcid,
         string expected,
         int input,
@@ -123,7 +123,7 @@ public void GetMonthNameByMonthNumber(
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
-        var actual = input.GetMonthNameByMonthNumber(pascalCased);
+        var actual = input.GetMonthNameByMonthNumberUi(pascalCased);
 
         // Assert
         Assert.Equal(expected, actual);
@@ -145,6 +145,25 @@ public void GetNumberOfWeeksByYear(
         Assert.Equal(expected, actual);
     }
 
+    [Theory]
+    [InlineData(52, 2019)]
+    [InlineData(53, 2020)]
+    [InlineData(52, 2021)]
+    [InlineData(52, 2022)]
+    public void GetNumberOfWeeksByYearUi(
+        int expected,
+        int input)
+    {
+        // Arrange
+        Thread.CurrentThread.CurrentUICulture = new CultureInfo(GlobalizationLcidConstants.UnitedStates);
+
+        // Act
+        var actual = input.GetNumberOfWeeksByYearUi();
+
+        // Assert
+        Assert.Equal(expected, actual);
+    }
+
     [Theory]
     [InlineData(2018, 12, 31, 2019, 1)]
     [InlineData(2019, 12, 30, 2020, 1)]
@@ -167,6 +186,29 @@ public void GetFirstDayOfWeekNumberByYear(
         Assert.Equal(expectedDateTime, actual);
     }
 
+    [Theory]
+    [InlineData(2018, 12, 31, 2019, 1)]
+    [InlineData(2019, 12, 30, 2020, 1)]
+    [InlineData(2021, 1, 4, 2021, 1)]
+    [InlineData(2022, 1, 3, 2022, 1)]
+    public void GetFirstDayOfWeekNumberByYearUi(
+        int expectedYear,
+        int expectedMonth,
+        int expectedDay,
+        int input,
+        int weekNumber)
+    {
+        // Arrange
+        Thread.CurrentThread.CurrentUICulture = new CultureInfo(GlobalizationLcidConstants.UnitedStates);
+        var expectedDateTime = new DateTime(expectedYear, expectedMonth, expectedDay);
+
+        // Act
+        var actual = input.GetFirstDayOfWeekNumberByYearUi(weekNumber);
+
+        // Assert
+        Assert.Equal(expectedDateTime, actual);
+    }
+
     [Theory]
     [InlineData(2019, 1, 6, 2019, 1)]
     [InlineData(2020, 1, 5, 2020, 1)]
@@ -188,4 +230,27 @@ public void GetLastDayOfWeekNumberByYear(
         // Assert
         Assert.Equal(expectedDateTime, actual);
     }
+
+    [Theory]
+    [InlineData(2019, 1, 6, 2019, 1)]
+    [InlineData(2020, 1, 5, 2020, 1)]
+    [InlineData(2021, 1, 10, 2021, 1)]
+    [InlineData(2022, 1, 9, 2022, 1)]
+    public void GetLastDayOfWeekNumberByYearUi(
+        int expectedYear,
+        int expectedMonth,
+        int expectedDay,
+        int input,
+        int weekNumber)
+    {
+        // Arrange
+        Thread.CurrentThread.CurrentUICulture = new CultureInfo(GlobalizationLcidConstants.UnitedStates);
+        var expectedDateTime = new DateTime(expectedYear, expectedMonth, expectedDay);
+
+        // Act
+        var actual = input.GetLastDayOfWeekNumberByYearUi(weekNumber);
+
+        // Assert
+        Assert.Equal(expectedDateTime, actual);
+    }
 }
\ No newline at end of file
diff --git a/test/Atc.Tests/Extensions/BaseTypes/TimeSpanExtensionsTests.cs b/test/Atc.Tests/Extensions/BaseTypes/TimeSpanExtensionsTests.cs
index bcecebbb..465868ca 100644
--- a/test/Atc.Tests/Extensions/BaseTypes/TimeSpanExtensionsTests.cs
+++ b/test/Atc.Tests/Extensions/BaseTypes/TimeSpanExtensionsTests.cs
@@ -91,6 +91,25 @@ public void GetPrettyTimeDiff(
         Assert.NotNull(actual);
     }
 
+    [Theory]
+    [MemberData(nameof(TestMemberDataForTimeSpanExtensions.GetPrettyTimeUi), MemberType = typeof(TestMemberDataForTimeSpanExtensions))]
+    public void GetPrettyTimeUi(
+        string expected,
+        TimeSpan timeSpan,
+        int arrangeUiLcid,
+        int arrangeLcid)
+    {
+        // Arrange
+        Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
+        Thread.CurrentThread.CurrentCulture = new CultureInfo(arrangeLcid);
+
+        // Act
+        var actual = timeSpan.GetPrettyTimeUi();
+
+        // Assert
+        Assert.Equal(expected, actual);
+    }
+
     [Theory]
     [MemberData(nameof(TestMemberDataForTimeSpanExtensions.GetPrettyTimeWithDecimalPrecision), MemberType = typeof(TestMemberDataForTimeSpanExtensions))]
     public void GetPrettyTimeDiff_DecimalPrecision(
diff --git a/test/Atc.Tests/Helpers/DateTimeHelperTests.cs b/test/Atc.Tests/Helpers/DateTimeHelperTests.cs
index f5696e26..3c1f77af 100644
--- a/test/Atc.Tests/Helpers/DateTimeHelperTests.cs
+++ b/test/Atc.Tests/Helpers/DateTimeHelperTests.cs
@@ -20,7 +20,7 @@ public class DateTimeHelperTests
     [InlineData(true, GlobalizationLcidConstants.Germany, "15-10-2023")]
     [InlineData(true, GlobalizationLcidConstants.Germany, "15/10/2023")]
     [InlineData(false, GlobalizationLcidConstants.Germany, "15.20.2023")]
-    public void TryParseUsingCurrentUiCulture(
+    public void TryParseUi(
         bool expected,
         int arrangeUiLcid,
         string value)
@@ -29,7 +29,7 @@ public void TryParseUsingCurrentUiCulture(
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
-        var actual = DateTimeHelper.TryParseUsingCurrentUiCulture(value, out _);
+        var actual = DateTimeHelper.TryParseUi(value, out _);
 
         // Assert
         Assert.Equal(expected, actual);
@@ -72,7 +72,7 @@ public void TryParseUsingSpecificCulture(
     [InlineData(true, GlobalizationLcidConstants.Germany, "15-10-2023")]
     [InlineData(true, GlobalizationLcidConstants.Germany, "15/10/2023")]
     [InlineData(false, GlobalizationLcidConstants.Germany, "15.20.2023")]
-    public void TryParseShortDateUsingCurrentUiCulture(
+    public void TryParseShortDateUi(
         bool expected,
         int arrangeUiLcid,
         string value)
@@ -81,7 +81,7 @@ public void TryParseShortDateUsingCurrentUiCulture(
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
-        var actual = DateTimeHelper.TryParseShortDateUsingCurrentUiCulture(value, out _);
+        var actual = DateTimeHelper.TryParseShortDateUi(value, out _);
 
         // Assert
         Assert.Equal(expected, actual);
@@ -124,7 +124,7 @@ public void TryParseShortDateUsingSpecificCulture(
     [InlineData(true, GlobalizationLcidConstants.Germany, "15:30")]
     [InlineData(false, GlobalizationLcidConstants.Germany, "24:30")]
     [InlineData(false, GlobalizationLcidConstants.Germany, "15.30")]
-    public void TryParseShortTimeUsingCurrentUiCulture(
+    public void TryParseShortTimeUi(
         bool expected,
         int arrangeUiLcid,
         string value)
@@ -133,7 +133,7 @@ public void TryParseShortTimeUsingCurrentUiCulture(
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
-        var actual = DateTimeHelper.TryParseShortTimeUsingCurrentUiCulture(value, out _);
+        var actual = DateTimeHelper.TryParseShortTimeUi(value, out _);
 
         // Assert
         Assert.Equal(expected, actual);
@@ -176,7 +176,7 @@ public void TryParseShortTimeUsingSpecificCulture(
     [InlineData(true, GlobalizationLcidConstants.Germany, "15:30")]
     [InlineData(false, GlobalizationLcidConstants.Germany, "24:30")]
     [InlineData(false, GlobalizationLcidConstants.Germany, "15.30")]
-    public void TryParseShortTimeUsingCurrentUiCultureUtc(
+    public void TryParseShortTimeUiUtc(
         bool expected,
         int arrangeUiLcid,
         string value)
@@ -185,7 +185,7 @@ public void TryParseShortTimeUsingCurrentUiCultureUtc(
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
-        var actual = DateTimeHelper.TryParseShortTimeUsingCurrentUiCultureUtc(value, out _);
+        var actual = DateTimeHelper.TryParseShortTimeUiUtc(value, out _);
 
         // Assert
         Assert.Equal(expected, actual);
diff --git a/test/Atc.Tests/Helpers/DateTimeOffsetHelperTests.cs b/test/Atc.Tests/Helpers/DateTimeOffsetHelperTests.cs
index 8b16e90d..d5f5ac06 100644
--- a/test/Atc.Tests/Helpers/DateTimeOffsetHelperTests.cs
+++ b/test/Atc.Tests/Helpers/DateTimeOffsetHelperTests.cs
@@ -20,7 +20,7 @@ public class DateTimeOffsetHelperTests
     [InlineData(true, GlobalizationLcidConstants.Germany, "15-10-2023")]
     [InlineData(true, GlobalizationLcidConstants.Germany, "15/10/2023")]
     [InlineData(false, GlobalizationLcidConstants.Germany, "15.20.2023")]
-    public void TryParseUsingCurrentUiCulture(
+    public void TryParseUi(
         bool expected,
         int arrangeUiLcid,
         string value)
@@ -29,7 +29,7 @@ public void TryParseUsingCurrentUiCulture(
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
-        var actual = DateTimeOffsetHelper.TryParseUsingCurrentUiCulture(value, out _);
+        var actual = DateTimeOffsetHelper.TryParseUi(value, out _);
 
         // Assert
         Assert.Equal(expected, actual);
@@ -52,7 +52,7 @@ public void TryParseUsingCurrentUiCulture(
     [InlineData(true, GlobalizationLcidConstants.Germany, "15-10-2023")]
     [InlineData(true, GlobalizationLcidConstants.Germany, "15/10/2023")]
     [InlineData(false, GlobalizationLcidConstants.Germany, "15.20.2023")]
-    public void TryParseShortDateUsingCurrentUiCulture(
+    public void TryParseShortDateUi(
         bool expected,
         int arrangeUiLcid,
         string value)
@@ -61,7 +61,7 @@ public void TryParseShortDateUsingCurrentUiCulture(
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
-        var actual = DateTimeOffsetHelper.TryParseShortDateUsingCurrentUiCulture(value, out _);
+        var actual = DateTimeOffsetHelper.TryParseShortDateUi(value, out _);
 
         // Assert
         Assert.Equal(expected, actual);
@@ -84,7 +84,7 @@ public void TryParseShortDateUsingCurrentUiCulture(
     [InlineData(true, GlobalizationLcidConstants.Germany, "15:30")]
     [InlineData(false, GlobalizationLcidConstants.Germany, "24:30")]
     [InlineData(false, GlobalizationLcidConstants.Germany, "15.30")]
-    public void TryParseShortTimeUsingCurrentUiCulture(
+    public void TryParseShortTimeUi(
         bool expected,
         int arrangeUiLcid,
         string value)
@@ -93,7 +93,7 @@ public void TryParseShortTimeUsingCurrentUiCulture(
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
-        var actual = DateTimeOffsetHelper.TryParseShortTimeUsingCurrentUiCulture(value, out _);
+        var actual = DateTimeOffsetHelper.TryParseShortTimeUi(value, out _);
 
         // Assert
         Assert.Equal(expected, actual);
@@ -116,7 +116,7 @@ public void TryParseShortTimeUsingCurrentUiCulture(
     [InlineData(true, GlobalizationLcidConstants.Germany, "15:30")]
     [InlineData(false, GlobalizationLcidConstants.Germany, "24:30")]
     [InlineData(false, GlobalizationLcidConstants.Germany, "15.30")]
-    public void TryParseShortTimeUsingCurrentUiCultureUtc(
+    public void TryParseShortTimeUiUtc(
         bool expected,
         int arrangeUiLcid,
         string value)
@@ -125,7 +125,7 @@ public void TryParseShortTimeUsingCurrentUiCultureUtc(
         Thread.CurrentThread.CurrentUICulture = new CultureInfo(arrangeUiLcid);
 
         // Act
-        var actual = DateTimeOffsetHelper.TryParseShortTimeUsingCurrentUiCultureUtc(value, out _);
+        var actual = DateTimeOffsetHelper.TryParseShortTimeUiUtc(value, out _);
 
         // Assert
         Assert.Equal(expected, actual);
diff --git a/test/Atc.Tests/XUnitTestData/TestMemberDataForTimeSpanExtensions.cs b/test/Atc.Tests/XUnitTestData/TestMemberDataForTimeSpanExtensions.cs
index 811c0878..d568e2af 100644
--- a/test/Atc.Tests/XUnitTestData/TestMemberDataForTimeSpanExtensions.cs
+++ b/test/Atc.Tests/XUnitTestData/TestMemberDataForTimeSpanExtensions.cs
@@ -28,6 +28,21 @@ public static TheoryData<string, TimeSpan, int> GetPrettyTime()
             { "15,000 ms", new TimeSpan(0, 0, 0, 0, 15), GlobalizationLcidConstants.Germany },
         };
 
+    public static TheoryData<string, TimeSpan, int, int> GetPrettyTimeUi()
+        => new()
+        {
+            { "11,509 dage", new TimeSpan(11, 12, 13, 14, 15), GlobalizationLcidConstants.Denmark, GlobalizationLcidConstants.UnitedStates },
+            { "12,221 timer", new TimeSpan(0, 12, 13, 14, 15), GlobalizationLcidConstants.Denmark, GlobalizationLcidConstants.UnitedStates },
+            { "13,234 min", new TimeSpan(0, 0, 13, 14, 15), GlobalizationLcidConstants.Denmark, GlobalizationLcidConstants.UnitedStates },
+            { "14,015 sek", new TimeSpan(0, 0, 0, 14, 15), GlobalizationLcidConstants.Denmark, GlobalizationLcidConstants.UnitedStates },
+            { "15,000 ms", new TimeSpan(0, 0, 0, 0, 15), GlobalizationLcidConstants.Denmark, GlobalizationLcidConstants.UnitedStates },
+            { "11.509 days", new TimeSpan(11, 12, 13, 14, 15), GlobalizationLcidConstants.UnitedStates, GlobalizationLcidConstants.Denmark },
+            { "12.221 hours", new TimeSpan(0, 12, 13, 14, 15), GlobalizationLcidConstants.UnitedStates, GlobalizationLcidConstants.Denmark },
+            { "13.234 min", new TimeSpan(0, 0, 13, 14, 15), GlobalizationLcidConstants.UnitedStates, GlobalizationLcidConstants.Denmark },
+            { "14.015 sec", new TimeSpan(0, 0, 0, 14, 15), GlobalizationLcidConstants.UnitedStates, GlobalizationLcidConstants.Denmark },
+            { "15.000 ms", new TimeSpan(0, 0, 0, 0, 15), GlobalizationLcidConstants.UnitedStates, GlobalizationLcidConstants.Denmark },
+        };
+
     public static TheoryData<string, TimeSpan, int, int> GetPrettyTimeWithDecimalPrecision()
         => new()
         {

From fe51944b6d649e8f015af7027580b37fceaf5859 Mon Sep 17 00:00:00 2001
From: David Kallesen <david@lmdk.dk>
Date: Wed, 24 Jun 2026 02:54:01 +0200
Subject: [PATCH 100/100] docs: regenerate CodeDoc for all packages affected by
 this branch

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 ...Atc.CodeAnalysis.CSharp.SyntaxFactories.md | 115 ++++++++++++++
 docs/CodeDoc/Atc.CodeAnalysis.CSharp/Index.md |   2 +
 .../Atc.CodeAnalysis.CSharp/IndexExtended.md  |  20 +++
 .../Microsoft.CodeAnalysis.CSharp.Syntax.md   |  81 ++++++++++
 .../Atc.CodeDocumentation.md                  |  21 +++
 .../Atc.CodeDocumentation/IndexExtended.md    |   2 +
 .../Atc.Rest.Extended.Options.md              |   6 +-
 .../Atc.Rest.FluentAssertions.md              |  23 +++
 .../IndexExtended.md                          |   2 +
 docs/CodeDoc/Atc.Rest/Atc.Rest.Options.md     |  10 ++
 docs/CodeDoc/Atc.Rest/Atc.Rest.Results.md     |  33 ++++
 docs/CodeDoc/Atc.Rest/IndexExtended.md        |   5 +
 docs/CodeDoc/Atc.XUnit/Atc.XUnit.md           |  13 +-
 docs/CodeDoc/Atc.XUnit/IndexExtended.md       |   1 +
 docs/CodeDoc/Atc/Atc.Helpers.md               |  48 +++---
 docs/CodeDoc/Atc/IndexExtended.md             |  42 +++--
 docs/CodeDoc/Atc/System.md                    | 145 ++++++++++++++----
 17 files changed, 493 insertions(+), 76 deletions(-)

diff --git a/docs/CodeDoc/Atc.CodeAnalysis.CSharp/Atc.CodeAnalysis.CSharp.SyntaxFactories.md b/docs/CodeDoc/Atc.CodeAnalysis.CSharp/Atc.CodeAnalysis.CSharp.SyntaxFactories.md
index cdf843bb..3f0fb224 100644
--- a/docs/CodeDoc/Atc.CodeAnalysis.CSharp/Atc.CodeAnalysis.CSharp.SyntaxFactories.md
+++ b/docs/CodeDoc/Atc.CodeAnalysis.CSharp/Atc.CodeAnalysis.CSharp.SyntaxFactories.md
@@ -736,6 +736,57 @@ Factory for creating `Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSynt
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`syntaxKind`&nbsp;&nbsp;-&nbsp;&nbsp;The syntax kind for the literal (string or numeric).<br />
 >
 ><b>Returns:</b> A `Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax` node.
+#### Create
+>```csharp
+>LiteralExpressionSyntax Create(long value)
+>```
+><b>Summary:</b> Creates a literal expression from a string value with the specified syntax kind.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The value for the literal expression.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`syntaxKind`&nbsp;&nbsp;-&nbsp;&nbsp;The syntax kind for the literal (string or numeric).<br />
+>
+><b>Returns:</b> A `Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax` node.
+#### Create
+>```csharp
+>LiteralExpressionSyntax Create(double value)
+>```
+><b>Summary:</b> Creates a literal expression from a string value with the specified syntax kind.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The value for the literal expression.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`syntaxKind`&nbsp;&nbsp;-&nbsp;&nbsp;The syntax kind for the literal (string or numeric).<br />
+>
+><b>Returns:</b> A `Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax` node.
+#### Create
+>```csharp
+>LiteralExpressionSyntax Create(bool value)
+>```
+><b>Summary:</b> Creates a literal expression from a string value with the specified syntax kind.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The value for the literal expression.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`syntaxKind`&nbsp;&nbsp;-&nbsp;&nbsp;The syntax kind for the literal (string or numeric).<br />
+>
+><b>Returns:</b> A `Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax` node.
+#### Create
+>```csharp
+>LiteralExpressionSyntax Create(char value)
+>```
+><b>Summary:</b> Creates a literal expression from a string value with the specified syntax kind.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The value for the literal expression.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`syntaxKind`&nbsp;&nbsp;-&nbsp;&nbsp;The syntax kind for the literal (string or numeric).<br />
+>
+><b>Returns:</b> A `Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax` node.
+#### CreateNull
+>```csharp
+>LiteralExpressionSyntax CreateNull()
+>```
+><b>Summary:</b> Creates a <see langword="null" /> literal expression.
+>
+><b>Returns:</b> A `Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax` node representing <see langword="null" />.
 
 <br />
 
@@ -813,6 +864,70 @@ Factory for creating `Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpress
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`identifierName`&nbsp;&nbsp;-&nbsp;&nbsp;The name of the type to instantiate.<br />
 >
 ><b>Returns:</b> An `Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax` node.
+#### Create
+>```csharp
+>ObjectCreationExpressionSyntax Create(string identifierName, ArgumentListSyntax argumentList)
+>```
+><b>Summary:</b> Creates an object creation expression for a type.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`identifierName`&nbsp;&nbsp;-&nbsp;&nbsp;The name of the type to instantiate.<br />
+>
+><b>Returns:</b> An `Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax` node.
+#### Create
+>```csharp
+>ObjectCreationExpressionSyntax Create(string namespaceName, string identifierName, ArgumentListSyntax argumentList)
+>```
+><b>Summary:</b> Creates an object creation expression for a type.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`identifierName`&nbsp;&nbsp;-&nbsp;&nbsp;The name of the type to instantiate.<br />
+>
+><b>Returns:</b> An `Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax` node.
+#### CreateGeneric
+>```csharp
+>ObjectCreationExpressionSyntax CreateGeneric(string identifierName, TypeArgumentListSyntax typeArgumentList)
+>```
+><b>Summary:</b> Creates a generic object creation expression (e.g. `new List&lt;T&gt;()`).
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`identifierName`&nbsp;&nbsp;-&nbsp;&nbsp;The name of the generic type to instantiate.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`typeArgumentList`&nbsp;&nbsp;-&nbsp;&nbsp;The type argument list (e.g. <T>).<br />
+>
+><b>Returns:</b> An `Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax` node for the generic type.
+#### CreateGeneric
+>```csharp
+>ObjectCreationExpressionSyntax CreateGeneric(string identifierName, string typeArgumentName)
+>```
+><b>Summary:</b> Creates a generic object creation expression (e.g. `new List&lt;T&gt;()`).
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`identifierName`&nbsp;&nbsp;-&nbsp;&nbsp;The name of the generic type to instantiate.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`typeArgumentList`&nbsp;&nbsp;-&nbsp;&nbsp;The type argument list (e.g. <T>).<br />
+>
+><b>Returns:</b> An `Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax` node for the generic type.
+#### CreateGeneric
+>```csharp
+>ObjectCreationExpressionSyntax CreateGeneric(string identifierName, TypeArgumentListSyntax typeArgumentList, ArgumentListSyntax argumentList)
+>```
+><b>Summary:</b> Creates a generic object creation expression (e.g. `new List&lt;T&gt;()`).
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`identifierName`&nbsp;&nbsp;-&nbsp;&nbsp;The name of the generic type to instantiate.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`typeArgumentList`&nbsp;&nbsp;-&nbsp;&nbsp;The type argument list (e.g. <T>).<br />
+>
+><b>Returns:</b> An `Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax` node for the generic type.
+#### CreateGeneric
+>```csharp
+>ObjectCreationExpressionSyntax CreateGeneric(string identifierName, string typeArgumentName, ArgumentListSyntax argumentList)
+>```
+><b>Summary:</b> Creates a generic object creation expression (e.g. `new List&lt;T&gt;()`).
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`identifierName`&nbsp;&nbsp;-&nbsp;&nbsp;The name of the generic type to instantiate.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`typeArgumentList`&nbsp;&nbsp;-&nbsp;&nbsp;The type argument list (e.g. <T>).<br />
+>
+><b>Returns:</b> An `Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax` node for the generic type.
 
 <br />
 
diff --git a/docs/CodeDoc/Atc.CodeAnalysis.CSharp/Index.md b/docs/CodeDoc/Atc.CodeAnalysis.CSharp/Index.md
index 320371d7..c0ca27b3 100644
--- a/docs/CodeDoc/Atc.CodeAnalysis.CSharp/Index.md
+++ b/docs/CodeDoc/Atc.CodeAnalysis.CSharp/Index.md
@@ -47,6 +47,8 @@
 - [EnumDeclarationSyntaxExtensions](Microsoft.CodeAnalysis.CSharp.Syntax.md#enumdeclarationsyntaxextensions)
 - [InterfaceDeclarationSyntaxExtensions](Microsoft.CodeAnalysis.CSharp.Syntax.md#interfacedeclarationsyntaxextensions)
 - [MethodDeclarationSyntaxExtensions](Microsoft.CodeAnalysis.CSharp.Syntax.md#methoddeclarationsyntaxextensions)
+- [RecordDeclarationSyntaxExtensions](Microsoft.CodeAnalysis.CSharp.Syntax.md#recorddeclarationsyntaxextensions)
+- [StructDeclarationSyntaxExtensions](Microsoft.CodeAnalysis.CSharp.Syntax.md#structdeclarationsyntaxextensions)
 - [SyntaxNodeExtensions](Microsoft.CodeAnalysis.CSharp.Syntax.md#syntaxnodeextensions)
 - [UsingDirectiveSyntaxExtensions](Microsoft.CodeAnalysis.CSharp.Syntax.md#usingdirectivesyntaxextensions)
 
diff --git a/docs/CodeDoc/Atc.CodeAnalysis.CSharp/IndexExtended.md b/docs/CodeDoc/Atc.CodeAnalysis.CSharp/IndexExtended.md
index a1b7ebaf..0a67e253 100644
--- a/docs/CodeDoc/Atc.CodeAnalysis.CSharp/IndexExtended.md
+++ b/docs/CodeDoc/Atc.CodeAnalysis.CSharp/IndexExtended.md
@@ -97,8 +97,13 @@
      - StringTextParenthesesEnd()
 - [SyntaxLiteralExpressionFactory](Atc.CodeAnalysis.CSharp.SyntaxFactories.md#syntaxliteralexpressionfactory)
   -  Static Methods
+     - Create(bool value)
+     - Create(char value)
+     - Create(double value)
      - Create(int value)
+     - Create(long value)
      - Create(string value, SyntaxKind syntaxKind = StringLiteralExpression)
+     - CreateNull()
 - [SyntaxMemberAccessExpressionFactory](Atc.CodeAnalysis.CSharp.SyntaxFactories.md#syntaxmemberaccessexpressionfactory)
   -  Static Methods
      - Create(string memberTypeName, string memberName)
@@ -108,7 +113,13 @@
 - [SyntaxObjectCreationExpressionFactory](Atc.CodeAnalysis.CSharp.SyntaxFactories.md#syntaxobjectcreationexpressionfactory)
   -  Static Methods
      - Create(string identifierName)
+     - Create(string identifierName, ArgumentListSyntax argumentList)
      - Create(string namespaceName, string identifierName)
+     - Create(string namespaceName, string identifierName, ArgumentListSyntax argumentList)
+     - CreateGeneric(string identifierName, TypeArgumentListSyntax typeArgumentList)
+     - CreateGeneric(string identifierName, TypeArgumentListSyntax typeArgumentList, ArgumentListSyntax argumentList)
+     - CreateGeneric(string identifierName, string typeArgumentName)
+     - CreateGeneric(string identifierName, string typeArgumentName, ArgumentListSyntax argumentList)
 - [SyntaxParameterFactory](Atc.CodeAnalysis.CSharp.SyntaxFactories.md#syntaxparameterfactory)
   -  Static Methods
      - Create(string parameterTypeName, string parameterName, string genericListTypeName = null)
@@ -194,9 +205,18 @@
 - [InterfaceDeclarationSyntaxExtensions](Microsoft.CodeAnalysis.CSharp.Syntax.md#interfacedeclarationsyntaxextensions)
   -  Static Methods
      - AddGeneratedCodeAttribute(this InterfaceDeclarationSyntax interfaceDeclaration, string toolName, string version)
+     - AddSuppressMessageAttribute(this InterfaceDeclarationSyntax interfaceDeclaration, SuppressMessageAttribute suppressMessage)
 - [MethodDeclarationSyntaxExtensions](Microsoft.CodeAnalysis.CSharp.Syntax.md#methoddeclarationsyntaxextensions)
   -  Static Methods
      - AddSuppressMessageAttribute(this MethodDeclarationSyntax methodDeclaration, SuppressMessageAttribute suppressMessage)
+- [RecordDeclarationSyntaxExtensions](Microsoft.CodeAnalysis.CSharp.Syntax.md#recorddeclarationsyntaxextensions)
+  -  Static Methods
+     - AddGeneratedCodeAttribute(this RecordDeclarationSyntax recordDeclaration, string toolName, string version)
+     - AddSuppressMessageAttribute(this RecordDeclarationSyntax recordDeclaration, SuppressMessageAttribute suppressMessage)
+- [StructDeclarationSyntaxExtensions](Microsoft.CodeAnalysis.CSharp.Syntax.md#structdeclarationsyntaxextensions)
+  -  Static Methods
+     - AddGeneratedCodeAttribute(this StructDeclarationSyntax structDeclaration, string toolName, string version)
+     - AddSuppressMessageAttribute(this StructDeclarationSyntax structDeclaration, SuppressMessageAttribute suppressMessage)
 - [SyntaxNodeExtensions](Microsoft.CodeAnalysis.CSharp.Syntax.md#syntaxnodeextensions)
   -  Static Methods
      - GetUsedUsingStatements(this SyntaxNode syntaxNode)
diff --git a/docs/CodeDoc/Atc.CodeAnalysis.CSharp/Microsoft.CodeAnalysis.CSharp.Syntax.md b/docs/CodeDoc/Atc.CodeAnalysis.CSharp/Microsoft.CodeAnalysis.CSharp.Syntax.md
index 0bd2f3c3..ce6aa0a1 100644
--- a/docs/CodeDoc/Atc.CodeAnalysis.CSharp/Microsoft.CodeAnalysis.CSharp.Syntax.md
+++ b/docs/CodeDoc/Atc.CodeAnalysis.CSharp/Microsoft.CodeAnalysis.CSharp.Syntax.md
@@ -130,6 +130,17 @@ Extension methods for `Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclaration
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`version`&nbsp;&nbsp;-&nbsp;&nbsp;The version of the code generation tool.<br />
 >
 ><b>Returns:</b> A new `Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax` with the attribute added.
+#### AddSuppressMessageAttribute
+>```csharp
+>InterfaceDeclarationSyntax AddSuppressMessageAttribute(this InterfaceDeclarationSyntax interfaceDeclaration, SuppressMessageAttribute suppressMessage)
+>```
+><b>Summary:</b> Adds a `System.Diagnostics.CodeAnalysis.SuppressMessageAttribute` to the interface declaration.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`interfaceDeclaration`&nbsp;&nbsp;-&nbsp;&nbsp;The interface declaration to modify.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`suppressMessage`&nbsp;&nbsp;-&nbsp;&nbsp;The suppress message attribute to add.<br />
+>
+><b>Returns:</b> A new `Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax` with the attribute added.
 
 <br />
 
@@ -156,6 +167,76 @@ Extension methods for `Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyn
 
 <br />
 
+## RecordDeclarationSyntaxExtensions
+Extension methods for `Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax`.
+
+>```csharp
+>public static class RecordDeclarationSyntaxExtensions
+>```
+
+### Static Methods
+
+#### AddGeneratedCodeAttribute
+>```csharp
+>RecordDeclarationSyntax AddGeneratedCodeAttribute(this RecordDeclarationSyntax recordDeclaration, string toolName, string version)
+>```
+><b>Summary:</b> Adds a `System.CodeDom.Compiler.GeneratedCodeAttribute` to the record declaration.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`recordDeclaration`&nbsp;&nbsp;-&nbsp;&nbsp;The record declaration to modify.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`toolName`&nbsp;&nbsp;-&nbsp;&nbsp;The name of the code generation tool.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`version`&nbsp;&nbsp;-&nbsp;&nbsp;The version of the code generation tool.<br />
+>
+><b>Returns:</b> A new `Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax` with the attribute added.
+#### AddSuppressMessageAttribute
+>```csharp
+>RecordDeclarationSyntax AddSuppressMessageAttribute(this RecordDeclarationSyntax recordDeclaration, SuppressMessageAttribute suppressMessage)
+>```
+><b>Summary:</b> Adds a `System.Diagnostics.CodeAnalysis.SuppressMessageAttribute` to the record declaration.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`recordDeclaration`&nbsp;&nbsp;-&nbsp;&nbsp;The record declaration to modify.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`suppressMessage`&nbsp;&nbsp;-&nbsp;&nbsp;The suppress message attribute to add.<br />
+>
+><b>Returns:</b> A new `Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax` with the attribute added.
+
+<br />
+
+## StructDeclarationSyntaxExtensions
+Extension methods for `Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax`.
+
+>```csharp
+>public static class StructDeclarationSyntaxExtensions
+>```
+
+### Static Methods
+
+#### AddGeneratedCodeAttribute
+>```csharp
+>StructDeclarationSyntax AddGeneratedCodeAttribute(this StructDeclarationSyntax structDeclaration, string toolName, string version)
+>```
+><b>Summary:</b> Adds a `System.CodeDom.Compiler.GeneratedCodeAttribute` to the struct declaration.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`structDeclaration`&nbsp;&nbsp;-&nbsp;&nbsp;The struct declaration to modify.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`toolName`&nbsp;&nbsp;-&nbsp;&nbsp;The name of the code generation tool.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`version`&nbsp;&nbsp;-&nbsp;&nbsp;The version of the code generation tool.<br />
+>
+><b>Returns:</b> A new `Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax` with the attribute added.
+#### AddSuppressMessageAttribute
+>```csharp
+>StructDeclarationSyntax AddSuppressMessageAttribute(this StructDeclarationSyntax structDeclaration, SuppressMessageAttribute suppressMessage)
+>```
+><b>Summary:</b> Adds a `System.Diagnostics.CodeAnalysis.SuppressMessageAttribute` to the struct declaration.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`structDeclaration`&nbsp;&nbsp;-&nbsp;&nbsp;The struct declaration to modify.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`suppressMessage`&nbsp;&nbsp;-&nbsp;&nbsp;The suppress message attribute to add.<br />
+>
+><b>Returns:</b> A new `Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax` with the attribute added.
+
+<br />
+
 ## SyntaxNodeExtensions
 Extension methods for `Microsoft.CodeAnalysis.SyntaxNode`.
 
diff --git a/docs/CodeDoc/Atc.CodeDocumentation/Atc.CodeDocumentation.md b/docs/CodeDoc/Atc.CodeDocumentation/Atc.CodeDocumentation.md
index 9b01b233..e3423ae6 100644
--- a/docs/CodeDoc/Atc.CodeDocumentation/Atc.CodeDocumentation.md
+++ b/docs/CodeDoc/Atc.CodeDocumentation/Atc.CodeDocumentation.md
@@ -52,6 +52,16 @@ Provides public API methods for collecting and analyzing XML documentation comme
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`type`&nbsp;&nbsp;-&nbsp;&nbsp;The type to collect documentation for.<br />
 >
 ><b>Returns:</b> The type comments, or <see langword="null" /> if the type was not found.
+#### CollectExportedTypeWithCommentsFromType
+>```csharp
+>TypeComments CollectExportedTypeWithCommentsFromType(Type type, FileInfo xmlDocPath)
+>```
+><b>Summary:</b> Collects XML documentation comments for a specific type from its assembly.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`type`&nbsp;&nbsp;-&nbsp;&nbsp;The type to collect documentation for.<br />
+>
+><b>Returns:</b> The type comments, or <see langword="null" /> if the type was not found.
 #### CollectExportedTypesWithMissingCommentsFromAssembly
 >```csharp
 >TypeComments[] CollectExportedTypesWithMissingCommentsFromAssembly(Assembly assembly, List<Type> excludeTypes = null)
@@ -63,6 +73,17 @@ Provides public API methods for collecting and analyzing XML documentation comme
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`excludeTypes`&nbsp;&nbsp;-&nbsp;&nbsp;Optional list of types to exclude from the results.<br />
 >
 ><b>Returns:</b> An array of type comments for types missing documentation.
+#### CollectExportedTypesWithMissingCommentsFromAssembly
+>```csharp
+>TypeComments[] CollectExportedTypesWithMissingCommentsFromAssembly(Assembly assembly, FileInfo xmlDocPath, List<Type> excludeTypes = null)
+>```
+><b>Summary:</b> Collects all public types from an assembly that are missing XML documentation comments.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`assembly`&nbsp;&nbsp;-&nbsp;&nbsp;The assembly to scan for types.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`excludeTypes`&nbsp;&nbsp;-&nbsp;&nbsp;Optional list of types to exclude from the results.<br />
+>
+><b>Returns:</b> An array of type comments for types missing documentation.
 #### CollectExportedTypesWithMissingCommentsFromAssemblyAndGenerateText
 >```csharp
 >string CollectExportedTypesWithMissingCommentsFromAssemblyAndGenerateText(Assembly assembly, List<Type> excludeTypes = null, bool useFullName = False)
diff --git a/docs/CodeDoc/Atc.CodeDocumentation/IndexExtended.md b/docs/CodeDoc/Atc.CodeDocumentation/IndexExtended.md
index 5fa060dc..fe5d53ce 100644
--- a/docs/CodeDoc/Atc.CodeDocumentation/IndexExtended.md
+++ b/docs/CodeDoc/Atc.CodeDocumentation/IndexExtended.md
@@ -13,6 +13,8 @@
 - [DocumentationHelper](Atc.CodeDocumentation.md#documentationhelper)
   -  Static Methods
      - CollectExportedTypeWithCommentsFromType(Type type)
+     - CollectExportedTypeWithCommentsFromType(Type type, FileInfo xmlDocPath)
+     - CollectExportedTypesWithMissingCommentsFromAssembly(Assembly assembly, FileInfo xmlDocPath, List&lt;Type&gt; excludeTypes = null)
      - CollectExportedTypesWithMissingCommentsFromAssembly(Assembly assembly, List&lt;Type&gt; excludeTypes = null)
      - CollectExportedTypesWithMissingCommentsFromAssemblyAndGenerateText(Assembly assembly, List&lt;Type&gt; excludeTypes = null, bool useFullName = False)
      - CollectExportedTypesWithMissingCommentsFromAssemblyAndGenerateTextLines(Assembly assembly, List&lt;Type&gt; excludeTypes = null, bool useFullName = False)
diff --git a/docs/CodeDoc/Atc.Rest.Extended/Atc.Rest.Extended.Options.md b/docs/CodeDoc/Atc.Rest.Extended/Atc.Rest.Extended.Options.md
index a708886d..ab3f8802 100644
--- a/docs/CodeDoc/Atc.Rest.Extended/Atc.Rest.Extended.Options.md
+++ b/docs/CodeDoc/Atc.Rest.Extended/Atc.Rest.Extended.Options.md
@@ -28,7 +28,7 @@ Configures API versioning options for ASP.NET Core API versioning. Sets up versi
 <br />
 
 ## ConfigureAuthorizationOptions
-Post-configures JWT Bearer authentication and authorization options based on `Atc.Rest.Extended.Options.RestApiExtendedOptions`. Handles issuer signing key retrieval from OpenID Connect configuration and token validation setup.
+Post-configures JWT Bearer authentication and authorization options based on `Atc.Rest.Extended.Options.RestApiExtendedOptions`. Signing-key discovery is delegated to JwtBearer's built-in `Microsoft.IdentityModel.Protocols.ConfigurationManager`1`, which fetches and caches the OIDC discovery document on the first authentication request using the `Microsoft.AspNetCore.Authentication.JwtBearer.JwtBearerOptions.Authority` set here.
 
 >```csharp
 >public class ConfigureAuthorizationOptions : IPostConfigureOptions<JwtBearerOptions>, IPostConfigureOptions<AuthenticationOptions>
@@ -40,7 +40,7 @@ Post-configures JWT Bearer authentication and authorization options based on `At
 >```csharp
 >void PostConfigure(string name, JwtBearerOptions options)
 >```
-><b>Summary:</b> Post-configures JWT Bearer options with token validation parameters and issuer signing keys.
+><b>Summary:</b> Post-configures JWT Bearer options with token validation parameters. Signing keys are not pre-fetched; JwtBearer's built-in `Microsoft.IdentityModel.Protocols.ConfigurationManager`1` discovers and caches them from the OIDC discovery endpoint on the first authentication request.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`name`&nbsp;&nbsp;-&nbsp;&nbsp;The name of the options instance being configured.<br />
@@ -49,7 +49,7 @@ Post-configures JWT Bearer authentication and authorization options based on `At
 >```csharp
 >void PostConfigure(string name, AuthenticationOptions options)
 >```
-><b>Summary:</b> Post-configures JWT Bearer options with token validation parameters and issuer signing keys.
+><b>Summary:</b> Post-configures JWT Bearer options with token validation parameters. Signing keys are not pre-fetched; JwtBearer's built-in `Microsoft.IdentityModel.Protocols.ConfigurationManager`1` discovers and caches them from the OIDC discovery endpoint on the first authentication request.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`name`&nbsp;&nbsp;-&nbsp;&nbsp;The name of the options instance being configured.<br />
diff --git a/docs/CodeDoc/Atc.Rest.FluentAssertions/Atc.Rest.FluentAssertions.md b/docs/CodeDoc/Atc.Rest.FluentAssertions/Atc.Rest.FluentAssertions.md
index 80978303..159ec404 100644
--- a/docs/CodeDoc/Atc.Rest.FluentAssertions/Atc.Rest.FluentAssertions.md
+++ b/docs/CodeDoc/Atc.Rest.FluentAssertions/Atc.Rest.FluentAssertions.md
@@ -213,6 +213,17 @@ Provides FluentAssertions-style assertions for `Microsoft.AspNetCore.Mvc.OkObjec
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`becauseArgs`&nbsp;&nbsp;-&nbsp;&nbsp;Optional formatting arguments for the  parameter.<br />
 >
 ><b>Returns:</b> An `FluentAssertions.AndWhichConstraint`2` for further assertions on the typed content.
+#### WithEmptyContent
+>```csharp
+>AndConstraint<OkResultAssertions> WithEmptyContent(string because = , object[] becauseArgs)
+>```
+><b>Summary:</b> Asserts that the OK result has no body content (the result value is <see langword="null" />).
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`because`&nbsp;&nbsp;-&nbsp;&nbsp;Optional explanation of why the assertion is needed.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`becauseArgs`&nbsp;&nbsp;-&nbsp;&nbsp;Optional formatting arguments for the  parameter.<br />
+>
+><b>Returns:</b> An `FluentAssertions.AndConstraint`1` for chaining further assertions.
 
 <br />
 
@@ -324,6 +335,18 @@ Provides FluentAssertions-style assertions for `Microsoft.AspNetCore.Mvc.ActionR
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`becauseArgs`&nbsp;&nbsp;-&nbsp;&nbsp;Optional formatting arguments for the  parameter.<br />
 >
 ><b>Returns:</b> An `Atc.Rest.FluentAssertions.OkResultAssertions` instance for further assertions.
+#### BeOkResultWithContent
+>```csharp
+>AndWhichConstraint<OkResultAssertions, OkObjectResult> BeOkResultWithContent(T expectedContent, string because = , object[] becauseArgs)
+>```
+><b>Summary:</b> Asserts that the action result is a 200 OK result whose content is equivalent to `expectedContent`. This is a convenience shorthand for `BeOkResult().WithContent(expectedContent)`.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`expectedContent`&nbsp;&nbsp;-&nbsp;&nbsp;The expected content value to compare against.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`because`&nbsp;&nbsp;-&nbsp;&nbsp;Optional explanation of why the assertion is needed.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`becauseArgs`&nbsp;&nbsp;-&nbsp;&nbsp;Optional formatting arguments for the  parameter.<br />
+>
+><b>Returns:</b> An `FluentAssertions.AndWhichConstraint`2` for further assertions.
 
 <br />
 
diff --git a/docs/CodeDoc/Atc.Rest.FluentAssertions/IndexExtended.md b/docs/CodeDoc/Atc.Rest.FluentAssertions/IndexExtended.md
index 230a4bda..262a1370 100644
--- a/docs/CodeDoc/Atc.Rest.FluentAssertions/IndexExtended.md
+++ b/docs/CodeDoc/Atc.Rest.FluentAssertions/IndexExtended.md
@@ -29,6 +29,7 @@
   -  Methods
      - WithContent(T expectedContent, string because = , object[] becauseArgs)
      - WithContentOfType(string because = , object[] becauseArgs)
+     - WithEmptyContent(string because = , object[] becauseArgs)
 - [ResultAssertions](Atc.Rest.FluentAssertions.md#resultassertions)
   -  Methods
      - BeAcceptedResult(string because = , object[] becauseArgs)
@@ -40,6 +41,7 @@
      - BeNoContentResult(string because = , object[] becauseArgs)
      - BeNotFoundResult(string because = , object[] becauseArgs)
      - BeOkResult(string because = , object[] becauseArgs)
+     - BeOkResultWithContent(T expectedContent, string because = , object[] becauseArgs)
 - [ResultBaseExtensions](Atc.Rest.FluentAssertions.md#resultbaseextensions)
   -  Static Methods
      - Should(this ResultBase subject)
diff --git a/docs/CodeDoc/Atc.Rest/Atc.Rest.Options.md b/docs/CodeDoc/Atc.Rest/Atc.Rest.Options.md
index 34efb2ad..4fa82669 100644
--- a/docs/CodeDoc/Atc.Rest/Atc.Rest.Options.md
+++ b/docs/CodeDoc/Atc.Rest/Atc.Rest.Options.md
@@ -100,6 +100,16 @@ Copy and fill out the AzureAd section into the project User Secrets.
 >Issuer
 >```
 ><b>Summary:</b> Gets or sets the expected token issuer for validation.
+#### NameClaimType
+>```csharp
+>NameClaimType
+>```
+><b>Summary:</b> Gets or sets the JWT claim type used to populate the user's identity name (`System.Security.Claims.ClaimsIdentity.Name`). For Azure AD access tokens the claim is typically `"name"` or `"preferred_username"`. When <see langword="null" /> or empty, the framework default (`ClaimTypes.Name` = the long URI form) is used.
+#### RoleClaimType
+>```csharp
+>RoleClaimType
+>```
+><b>Summary:</b> Gets or sets the JWT claim type used to populate ASP.NET Core roles for `[Authorize(Roles=…)]`. For Azure AD access tokens the claim is `"roles"`; for client-credentials tokens the scope claim is `"scp"`. When <see langword="null" /> or empty, the framework default (`ClaimTypes.Role` = the long URI form) is used, which does not match the short-form claims issued by Azure AD.
 #### TenantId
 >```csharp
 >TenantId
diff --git a/docs/CodeDoc/Atc.Rest/Atc.Rest.Results.md b/docs/CodeDoc/Atc.Rest/Atc.Rest.Results.md
index 90262410..36c09f26 100644
--- a/docs/CodeDoc/Atc.Rest/Atc.Rest.Results.md
+++ b/docs/CodeDoc/Atc.Rest/Atc.Rest.Results.md
@@ -159,6 +159,39 @@ Factory methods for creating standardized HTTP response results.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`contentType`&nbsp;&nbsp;-&nbsp;&nbsp;The content type. Defaults to application/octet-stream.<br />
 >
 ><b>Returns:</b> A `Microsoft.AspNetCore.Mvc.FileResult` configured for file download.
+#### CreateObjectResultWithProblemDetails
+>```csharp
+>ObjectResult CreateObjectResultWithProblemDetails(HttpStatusCode statusCode, string message)
+>```
+><b>Summary:</b> Creates an `Microsoft.AspNetCore.Mvc.ObjectResult` containing ProblemDetails, allowing ASP.NET Core's output formatters to serialize it using the app-configured `System.Text.Json.JsonSerializerOptions`. Prefer this over `Atc.Rest.Results.ResultFactory.CreateContentResultWithProblemDetails(System.Net.HttpStatusCode,System.String,System.String)` when consistent casing with the rest of the API is required.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`statusCode`&nbsp;&nbsp;-&nbsp;&nbsp;The HTTP status code.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`message`&nbsp;&nbsp;-&nbsp;&nbsp;The detail message describing the problem.<br />
+>
+><b>Returns:</b> An `Microsoft.AspNetCore.Mvc.ObjectResult` wrapping a `Microsoft.AspNetCore.Mvc.ProblemDetails` instance.
+#### CreateObjectResultWithValidationProblemDetails
+>```csharp
+>ObjectResult CreateObjectResultWithValidationProblemDetails(HttpStatusCode statusCode, string message)
+>```
+><b>Summary:</b> Creates an `Microsoft.AspNetCore.Mvc.ObjectResult` containing ValidationProblemDetails without field-specific errors, allowing ASP.NET Core's output formatters to serialize it using the app-configured `System.Text.Json.JsonSerializerOptions`. Prefer this over `Atc.Rest.Results.ResultFactory.CreateContentResultWithValidationProblemDetails(System.Net.HttpStatusCode,System.String,System.String)` when consistent casing with the rest of the API is required.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`statusCode`&nbsp;&nbsp;-&nbsp;&nbsp;The HTTP status code.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`message`&nbsp;&nbsp;-&nbsp;&nbsp;The detail message describing the validation failure.<br />
+>
+><b>Returns:</b> An `Microsoft.AspNetCore.Mvc.ObjectResult` wrapping a `Microsoft.AspNetCore.Mvc.ValidationProblemDetails` instance.
+#### CreateObjectResultWithValidationProblemDetails
+>```csharp
+>ObjectResult CreateObjectResultWithValidationProblemDetails(HttpStatusCode statusCode, Dictionary<string, string[]> errors, string message)
+>```
+><b>Summary:</b> Creates an `Microsoft.AspNetCore.Mvc.ObjectResult` containing ValidationProblemDetails without field-specific errors, allowing ASP.NET Core's output formatters to serialize it using the app-configured `System.Text.Json.JsonSerializerOptions`. Prefer this over `Atc.Rest.Results.ResultFactory.CreateContentResultWithValidationProblemDetails(System.Net.HttpStatusCode,System.String,System.String)` when consistent casing with the rest of the API is required.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`statusCode`&nbsp;&nbsp;-&nbsp;&nbsp;The HTTP status code.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`message`&nbsp;&nbsp;-&nbsp;&nbsp;The detail message describing the validation failure.<br />
+>
+><b>Returns:</b> An `Microsoft.AspNetCore.Mvc.ObjectResult` wrapping a `Microsoft.AspNetCore.Mvc.ValidationProblemDetails` instance.
 #### CreateProblemDetails
 >```csharp
 >ProblemDetails CreateProblemDetails(HttpStatusCode statusCode, string message)
diff --git a/docs/CodeDoc/Atc.Rest/IndexExtended.md b/docs/CodeDoc/Atc.Rest/IndexExtended.md
index 9ef3499e..d6b87927 100644
--- a/docs/CodeDoc/Atc.Rest/IndexExtended.md
+++ b/docs/CodeDoc/Atc.Rest/IndexExtended.md
@@ -108,6 +108,8 @@
      - ClientId
      - Instance
      - Issuer
+     - NameClaimType
+     - RoleClaimType
      - TenantId
      - ValidAudiences
      - ValidIssuers
@@ -176,6 +178,9 @@
      - CreateContentResultWithValidationProblemDetails(HttpStatusCode statusCode, Dictionary&lt;string, string[]&gt; errors, string message, string contentType = application/json)
      - CreateContentResultWithValidationProblemDetails(HttpStatusCode statusCode, string message, string contentType = application/json)
      - CreateFileContentResult(byte[] bytes, string fileName, string contentType = application/octet-stream)
+     - CreateObjectResultWithProblemDetails(HttpStatusCode statusCode, string message)
+     - CreateObjectResultWithValidationProblemDetails(HttpStatusCode statusCode, Dictionary&lt;string, string[]&gt; errors, string message)
+     - CreateObjectResultWithValidationProblemDetails(HttpStatusCode statusCode, string message)
      - CreateProblemDetails(HttpStatusCode statusCode, string message)
      - CreateValidationProblemDetails(HttpStatusCode statusCode, Dictionary&lt;string, string[]&gt; errors, string message)
 
diff --git a/docs/CodeDoc/Atc.XUnit/Atc.XUnit.md b/docs/CodeDoc/Atc.XUnit/Atc.XUnit.md
index 42701e5b..a7747054 100644
--- a/docs/CodeDoc/Atc.XUnit/Atc.XUnit.md
+++ b/docs/CodeDoc/Atc.XUnit/Atc.XUnit.md
@@ -82,12 +82,23 @@ Provides helper methods for asserting code compliance related to XML documentati
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`type`&nbsp;&nbsp;-&nbsp;&nbsp;The type to validate for XML documentation.<br />
 #### AssertExportedTypesWithMissingComments
 >```csharp
+>void AssertExportedTypesWithMissingComments(Assembly assembly, FileInfo xmlDocPath, List<Type> excludeTypes = null)
+>```
+><b>Summary:</b> Asserts that all exported types in an assembly have XML documentation comments, using an explicit XML documentation file path instead of relying on automatic path resolution. Use this overload when the XML documentation file is not located next to the assembly or in `System.AppDomain.CurrentDomain` base directory.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`assembly`&nbsp;&nbsp;-&nbsp;&nbsp;The assembly to validate.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`xmlDocPath`&nbsp;&nbsp;-&nbsp;&nbsp;The explicit path to the XML documentation file for .<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`excludeTypes`&nbsp;&nbsp;-&nbsp;&nbsp;Optional list of types to exclude from validation.<br />
+#### AssertExportedTypesWithMissingComments
+>```csharp
 >void AssertExportedTypesWithMissingComments(Assembly assembly, List<Type> excludeTypes = null)
 >```
-><b>Summary:</b> Asserts that all exported types in an assembly have XML documentation comments. Fails the test if any types are missing documentation.
+><b>Summary:</b> Asserts that all exported types in an assembly have XML documentation comments, using an explicit XML documentation file path instead of relying on automatic path resolution. Use this overload when the XML documentation file is not located next to the assembly or in `System.AppDomain.CurrentDomain` base directory.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`assembly`&nbsp;&nbsp;-&nbsp;&nbsp;The assembly to validate.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`xmlDocPath`&nbsp;&nbsp;-&nbsp;&nbsp;The explicit path to the XML documentation file for .<br />
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`excludeTypes`&nbsp;&nbsp;-&nbsp;&nbsp;Optional list of types to exclude from validation.<br />
 
 <br />
diff --git a/docs/CodeDoc/Atc.XUnit/IndexExtended.md b/docs/CodeDoc/Atc.XUnit/IndexExtended.md
index e219fcdc..0d83c1b9 100644
--- a/docs/CodeDoc/Atc.XUnit/IndexExtended.md
+++ b/docs/CodeDoc/Atc.XUnit/IndexExtended.md
@@ -15,6 +15,7 @@
 - [CodeComplianceDocumentationHelper](Atc.XUnit.md#codecompliancedocumentationhelper)
   -  Static Methods
      - AssertExportedTypeWithMissingComments(Type type)
+     - AssertExportedTypesWithMissingComments(Assembly assembly, FileInfo xmlDocPath, List&lt;Type&gt; excludeTypes = null)
      - AssertExportedTypesWithMissingComments(Assembly assembly, List&lt;Type&gt; excludeTypes = null)
 - [CodeComplianceHelper](Atc.XUnit.md#codecompliancehelper)
   -  Static Methods
diff --git a/docs/CodeDoc/Atc/Atc.Helpers.md b/docs/CodeDoc/Atc/Atc.Helpers.md
index 244c6727..160a8382 100644
--- a/docs/CodeDoc/Atc/Atc.Helpers.md
+++ b/docs/CodeDoc/Atc/Atc.Helpers.md
@@ -796,11 +796,11 @@ DateTimeHelper.
 
 ### Static Methods
 
-#### TryParseShortDateUsingCurrentUiCulture
+#### TryParseShortDateUi
 >```csharp
->bool TryParseShortDateUsingCurrentUiCulture(string value, out DateTime result)
+>bool TryParseShortDateUi(string value, out DateTime result)
 >```
-><b>Summary:</b> Tries to parse a string representation of a short date using the current UI culture's date format.
+><b>Summary:</b> Tries to parse a string representation of a short date using the current UI culture's date format. Use this variant when parsing input from a user interface.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to parse.<br />
@@ -825,11 +825,11 @@ DateTimeHelper.
             <br />
 >
 ><b>Returns:</b> <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
-#### TryParseShortTimeUsingCurrentUiCulture
+#### TryParseShortTimeUi
 >```csharp
->bool TryParseShortTimeUsingCurrentUiCulture(string value, out DateTime result)
+>bool TryParseShortTimeUi(string value, out DateTime result)
 >```
-><b>Summary:</b> Tries to parse a string representation of a short time using the current UI culture's time format (12-hour or 24-hour).
+><b>Summary:</b> Tries to parse a string representation of a short time using the current UI culture's time format (12-hour or 24-hour). Use this variant when parsing input from a user interface.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to parse.<br />
@@ -839,11 +839,11 @@ DateTimeHelper.
             <br />
 >
 ><b>Returns:</b> <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
-#### TryParseShortTimeUsingCurrentUiCultureUtc
+#### TryParseShortTimeUiUtc
 >```csharp
->bool TryParseShortTimeUsingCurrentUiCultureUtc(string value, out DateTime result)
+>bool TryParseShortTimeUiUtc(string value, out DateTime result)
 >```
-><b>Summary:</b> Tries to parse a string representation of a short UTC time using the current UI culture's time format (12-hour or 24-hour).
+><b>Summary:</b> Tries to parse a string representation of a short UTC time using the current UI culture's time format (12-hour or 24-hour). Use this variant when parsing input from a user interface.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to parse.<br />
@@ -883,11 +883,11 @@ DateTimeHelper.
             <br />
 >
 ><b>Returns:</b> <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
-#### TryParseUsingCurrentUiCulture
+#### TryParseUi
 >```csharp
->bool TryParseUsingCurrentUiCulture(string value, out DateTime result)
+>bool TryParseUi(string value, out DateTime result)
 >```
-><b>Summary:</b> Tries to parse a string representation of a `DateTime` using the current UI culture's date and time format.
+><b>Summary:</b> Tries to parse a string representation of a `DateTime` using the current UI culture's date and time format. Use this variant when parsing input from a user interface.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to parse.<br />
@@ -924,11 +924,11 @@ DateTimeOffsetHelper.
 
 ### Static Methods
 
-#### TryParseShortDateUsingCurrentUiCulture
+#### TryParseShortDateUi
 >```csharp
->bool TryParseShortDateUsingCurrentUiCulture(string value, out DateTime result)
+>bool TryParseShortDateUi(string value, out DateTime result)
 >```
-><b>Summary:</b> Tries to parse a string representation of a short date using the current UI culture's date format.
+><b>Summary:</b> Tries to parse a string representation of a short date using the current UI culture's date format. Use this variant when parsing input from a user interface.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to parse.<br />
@@ -953,11 +953,11 @@ DateTimeOffsetHelper.
             <br />
 >
 ><b>Returns:</b> <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
-#### TryParseShortTimeUsingCurrentUiCulture
+#### TryParseShortTimeUi
 >```csharp
->bool TryParseShortTimeUsingCurrentUiCulture(string value, out DateTime result)
+>bool TryParseShortTimeUi(string value, out DateTime result)
 >```
-><b>Summary:</b> Tries to parse a string representation of a short time using the current UI culture's time format (12-hour or 24-hour).
+><b>Summary:</b> Tries to parse a string representation of a short time using the current UI culture's time format (12-hour or 24-hour). Use this variant when parsing input from a user interface.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to parse.<br />
@@ -967,11 +967,11 @@ DateTimeOffsetHelper.
             <br />
 >
 ><b>Returns:</b> <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
-#### TryParseShortTimeUsingCurrentUiCultureUtc
+#### TryParseShortTimeUiUtc
 >```csharp
->bool TryParseShortTimeUsingCurrentUiCultureUtc(string value, out DateTime result)
+>bool TryParseShortTimeUiUtc(string value, out DateTime result)
 >```
-><b>Summary:</b> Tries to parse a string representation of a short UTC time using the current UI culture's time format (12-hour or 24-hour).
+><b>Summary:</b> Tries to parse a string representation of a short UTC time using the current UI culture's time format (12-hour or 24-hour). Use this variant when parsing input from a user interface.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to parse.<br />
@@ -1011,11 +1011,11 @@ DateTimeOffsetHelper.
             <br />
 >
 ><b>Returns:</b> <see langword="true" /> if the parsing was successful; otherwise, <see langword="false" />.
-#### TryParseUsingCurrentUiCulture
+#### TryParseUi
 >```csharp
->bool TryParseUsingCurrentUiCulture(string value, out DateTime result)
+>bool TryParseUi(string value, out DateTime result)
 >```
-><b>Summary:</b> Tries to parse a string representation of a `DateTimeOffset` using the current UI culture's date and time format.
+><b>Summary:</b> Tries to parse a string representation of a `DateTimeOffset` using the current UI culture's date and time format. Use this variant when parsing input from a user interface.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The string to parse.<br />
diff --git a/docs/CodeDoc/Atc/IndexExtended.md b/docs/CodeDoc/Atc/IndexExtended.md
index 475cdb72..6ec4ace8 100644
--- a/docs/CodeDoc/Atc/IndexExtended.md
+++ b/docs/CodeDoc/Atc/IndexExtended.md
@@ -4508,23 +4508,23 @@
      - TryValidateOutToValidationException(T data, out ValidationException validationException, bool validateAllProperties = True)
 - [DateTimeHelper](Atc.Helpers.md#datetimehelper)
   -  Static Methods
-     - TryParseShortDateUsingCurrentUiCulture(string value, out DateTime result)
+     - TryParseShortDateUi(string value, out DateTime result)
      - TryParseShortDateUsingSpecificCulture(string value, CultureInfo cultureInfo, out DateTime result)
-     - TryParseShortTimeUsingCurrentUiCulture(string value, out DateTime result)
-     - TryParseShortTimeUsingCurrentUiCultureUtc(string value, out DateTime result)
+     - TryParseShortTimeUi(string value, out DateTime result)
+     - TryParseShortTimeUiUtc(string value, out DateTime result)
      - TryParseShortTimeUsingSpecificCulture(string value, CultureInfo cultureInfo, out DateTime result)
      - TryParseShortTimeUsingSpecificCultureUtc(string value, CultureInfo cultureInfo, out DateTime result)
-     - TryParseUsingCurrentUiCulture(string value, out DateTime result)
+     - TryParseUi(string value, out DateTime result)
      - TryParseUsingSpecificCulture(string value, CultureInfo cultureInfo, out DateTime result)
 - [DateTimeOffsetHelper](Atc.Helpers.md#datetimeoffsethelper)
   -  Static Methods
-     - TryParseShortDateUsingCurrentUiCulture(string value, out DateTime result)
+     - TryParseShortDateUi(string value, out DateTime result)
      - TryParseShortDateUsingSpecificCulture(string value, CultureInfo cultureInfo, out DateTime result)
-     - TryParseShortTimeUsingCurrentUiCulture(string value, out DateTime result)
-     - TryParseShortTimeUsingCurrentUiCultureUtc(string value, out DateTime result)
+     - TryParseShortTimeUi(string value, out DateTime result)
+     - TryParseShortTimeUiUtc(string value, out DateTime result)
      - TryParseShortTimeUsingSpecificCulture(string value, CultureInfo cultureInfo, out DateTime result)
      - TryParseShortTimeUsingSpecificCultureUtc(string value, CultureInfo cultureInfo, out DateTime result)
-     - TryParseUsingCurrentUiCulture(string value, out DateTime result)
+     - TryParseUi(string value, out DateTime result)
      - TryParseUsingSpecificCulture(string value, CultureInfo cultureInfo, out DateTime result)
 - [DayOfWeekHelper](Atc.Helpers.md#dayofweekhelper)
   -  Static Methods
@@ -5112,6 +5112,7 @@
      - GetPrettyTimeDiff(this DateTime startDate, DateTime endDate, int decimalPrecision = 3)
      - GetPrettyTimeDiff(this DateTime startDate, int decimalPrecision = 3)
      - GetWeekNumber(this DateTime date)
+     - GetWeekNumberUi(this DateTime date)
      - IsBetween(this DateTime date, DateTime startDate, DateTime endDate)
      - IsWeekend(this DateTime dateTime)
      - StartOfDay(this DateTime dateTime)
@@ -5119,16 +5120,16 @@
      - ToIso8601Date(this DateTime dateTime)
      - ToIso8601UtcDate(this DateTime dateTime)
      - ToLongDateString(this DateTime dateTime, DateTimeFormatInfo dateTimeFormatInfo)
-     - ToLongDateStringUsingCurrentUiCulture(this DateTime dateTime)
+     - ToLongDateStringUi(this DateTime dateTime)
      - ToLongDateStringUsingSpecificCulture(this DateTime dateTime, CultureInfo cultureInfo)
      - ToLongTimeString(this DateTime dateTime, DateTimeFormatInfo dateTimeFormatInfo)
-     - ToLongTimeStringUsingCurrentUiCulture(this DateTime dateTime)
+     - ToLongTimeStringUi(this DateTime dateTime)
      - ToLongTimeStringUsingSpecificCulture(this DateTime dateTime, CultureInfo cultureInfo)
      - ToShortDateString(this DateTime dateTime, DateTimeFormatInfo dateTimeFormatInfo)
-     - ToShortDateStringUsingCurrentUiCulture(this DateTime dateTime)
+     - ToShortDateStringUi(this DateTime dateTime)
      - ToShortDateStringUsingSpecificCulture(this DateTime dateTime, CultureInfo cultureInfo)
      - ToShortTimeString(this DateTime dateTime, DateTimeFormatInfo dateTimeFormatInfo)
-     - ToShortTimeStringUsingCurrentUiCulture(this DateTime dateTime)
+     - ToShortTimeStringUi(this DateTime dateTime)
      - ToShortTimeStringUsingSpecificCulture(this DateTime dateTime, CultureInfo cultureInfo)
 - [DateTimeOffsetExtensions](System.md#datetimeoffsetextensions)
   -  Static Methods
@@ -5138,6 +5139,7 @@
      - GetPrettyTimeDiff(this DateTimeOffset startDate, DateTimeOffset endDate, int decimalPrecision = 3)
      - GetPrettyTimeDiff(this DateTimeOffset startDate, int decimalPrecision = 3)
      - GetWeekNumber(this DateTimeOffset date)
+     - GetWeekNumberUi(this DateTimeOffset date)
      - IsBetween(this DateTimeOffset dateTimeOffset, DateTimeOffset startDate, DateTimeOffset endDate)
      - IsWeekend(this DateTimeOffset dateTimeOffset)
      - ResetToStartOfCurrentHour(this DateTimeOffset dateTimeOffset)
@@ -5147,20 +5149,21 @@
      - ToIso8601Date(this DateTimeOffset dateTimeOffset)
      - ToIso8601UtcDate(this DateTimeOffset dateTimeOffset)
      - ToLongDateString(this DateTimeOffset dateTimeOffset, DateTimeFormatInfo dateTimeFormatInfo)
-     - ToLongDateStringUsingCurrentUiCulture(this DateTimeOffset dateTimeOffset)
+     - ToLongDateStringUi(this DateTimeOffset dateTimeOffset)
      - ToLongTimeString(this DateTimeOffset dateTimeOffset, DateTimeFormatInfo dateTimeFormatInfo)
-     - ToLongTimeStringUsingCurrentUiCulture(this DateTimeOffset dateTimeOffset)
+     - ToLongTimeStringUi(this DateTimeOffset dateTimeOffset)
      - ToShortDateString(this DateTimeOffset dateTimeOffset, DateTimeFormatInfo dateTimeFormatInfo)
-     - ToShortDateStringUsingCurrentUiCulture(this DateTimeOffset dateTimeOffset)
+     - ToShortDateStringUi(this DateTimeOffset dateTimeOffset)
      - ToShortDateStringUsingSpecificCulture(this DateTimeOffset dateTimeOffset, CultureInfo cultureInfo)
      - ToShortTimeString(this DateTimeOffset dateTimeOffset, DateTimeFormatInfo dateTimeFormatInfo)
-     - ToShortTimeStringUsingCurrentUiCulture(this DateTimeOffset dateTimeOffset)
+     - ToShortTimeStringUi(this DateTimeOffset dateTimeOffset)
      - ToUnixTime(this DateTimeOffset dateTimeOffset)
 - [DecimalExtensions](System.md#decimalextensions)
   -  Static Methods
      - CurrencyRounding(this decimal value)
      - CurrencyRounding(this decimal value, int digits)
      - CurrencyRoundingAsInteger(this decimal value)
+     - CurrencyRoundingUi(this decimal value)
      - IsEqual(this decimal a, decimal b)
      - IsEqual(this decimal a, decimal b, int decimalPrecision)
      - IsEqual(this decimal? a, decimal? b)
@@ -5179,6 +5182,7 @@
      - CurrencyRounding(this double value)
      - CurrencyRounding(this double value, int digits)
      - CurrencyRoundingAsInteger(this double value)
+     - CurrencyRoundingUi(this double value)
      - GreaterThanOrClose(this double value1, double value2)
      - IsEqual(this double a, double b)
      - IsEqual(this double a, double b, int decimalPrecision)
@@ -5245,9 +5249,12 @@
 - [IntegerExtensions](System.md#integerextensions)
   -  Static Methods
      - GetFirstDayOfWeekNumberByYear(this int year, int weekNumber)
+     - GetFirstDayOfWeekNumberByYearUi(this int year, int weekNumber)
      - GetLastDayOfWeekNumberByYear(this int year, int weekNumber)
-     - GetMonthNameByMonthNumber(this int month, bool pascalCased = False)
+     - GetLastDayOfWeekNumberByYearUi(this int year, int weekNumber)
+     - GetMonthNameByMonthNumberUi(this int month, bool pascalCased = False)
      - GetNumberOfWeeksByYear(this int year)
+     - GetNumberOfWeeksByYearUi(this int year)
      - IsBinarySequence(this int number)
      - IsEqual(this int? a, int? b)
      - IsEven(this int number)
@@ -5391,6 +5398,7 @@
 - [TimeSpanExtensions](System.md#timespanextensions)
   -  Static Methods
      - GetPrettyTime(this TimeSpan timeSpan, int decimalPrecision = 3)
+     - GetPrettyTimeUi(this TimeSpan timeSpan, int decimalPrecision = 3)
      - Max(this TimeSpan t1, TimeSpan t2)
      - Min(this TimeSpan t1, TimeSpan t2)
      - RemoveMilliseconds(this TimeSpan timeSpan)
diff --git a/docs/CodeDoc/Atc/System.md b/docs/CodeDoc/Atc/System.md
index fd24d4a0..a90f9390 100644
--- a/docs/CodeDoc/Atc/System.md
+++ b/docs/CodeDoc/Atc/System.md
@@ -702,6 +702,16 @@ Extensions for the `System.DateTime` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`date`&nbsp;&nbsp;-&nbsp;&nbsp;The date.<br />
 >
 ><b>Returns:</b> The week number from the given date.
+#### GetWeekNumberUi
+>```csharp
+>int GetWeekNumberUi(this DateTime date)
+>```
+><b>Summary:</b> Gets the week number from a given date using the current UI culture's calendar. Use this variant when rendering the week number for display in a user interface.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`date`&nbsp;&nbsp;-&nbsp;&nbsp;The date.<br />
+>
+><b>Returns:</b> The week number from the given date.
 #### IsBetween
 >```csharp
 >bool IsBetween(this DateTime date, DateTime startDate, DateTime endDate)
@@ -776,11 +786,11 @@ Extensions for the `System.DateTime` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeFormatInfo`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTimeFormatInfo specifying the format to use.<br />
 >
 ><b>Returns:</b> A string representation of the DateTime using the long date pattern of the provided DateTimeFormatInfo.
-#### ToLongDateStringUsingCurrentUiCulture
+#### ToLongDateStringUi
 >```csharp
->string ToLongDateStringUsingCurrentUiCulture(this DateTime dateTime)
+>string ToLongDateStringUi(this DateTime dateTime)
 >```
-><b>Summary:</b> Converts a DateTime to a string using the long date pattern of the current UI culture.
+><b>Summary:</b> Converts a DateTime to a string using the long date pattern of the current UI culture. Use this variant when rendering output for display in a user interface.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTime`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTime to format.<br />
@@ -808,11 +818,11 @@ Extensions for the `System.DateTime` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeFormatInfo`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTimeFormatInfo specifying the format to use.<br />
 >
 ><b>Returns:</b> A string representation of the DateTime using the long time pattern of the provided DateTimeFormatInfo.
-#### ToLongTimeStringUsingCurrentUiCulture
+#### ToLongTimeStringUi
 >```csharp
->string ToLongTimeStringUsingCurrentUiCulture(this DateTime dateTime)
+>string ToLongTimeStringUi(this DateTime dateTime)
 >```
-><b>Summary:</b> Converts a DateTime to a string using the long time pattern of the current UI culture.
+><b>Summary:</b> Converts a DateTime to a string using the long time pattern of the current UI culture. Use this variant when rendering output for display in a user interface.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTime`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTime to format.<br />
@@ -840,11 +850,11 @@ Extensions for the `System.DateTime` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeFormatInfo`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTimeFormatInfo specifying the format to use.<br />
 >
 ><b>Returns:</b> A string representation of the DateTime using the short date pattern of the provided DateTimeFormatInfo.
-#### ToShortDateStringUsingCurrentUiCulture
+#### ToShortDateStringUi
 >```csharp
->string ToShortDateStringUsingCurrentUiCulture(this DateTime dateTime)
+>string ToShortDateStringUi(this DateTime dateTime)
 >```
-><b>Summary:</b> Converts a DateTime to a string using the short date pattern of the current UI culture.
+><b>Summary:</b> Converts a DateTime to a string using the short date pattern of the current UI culture. Use this variant when rendering output for display in a user interface.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTime`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTime to format.<br />
@@ -872,11 +882,11 @@ Extensions for the `System.DateTime` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeFormatInfo`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTimeFormatInfo specifying the format to use.<br />
 >
 ><b>Returns:</b> A string representation of the DateTime using the short time pattern of the provided DateTimeFormatInfo.
-#### ToShortTimeStringUsingCurrentUiCulture
+#### ToShortTimeStringUi
 >```csharp
->string ToShortTimeStringUsingCurrentUiCulture(this DateTime dateTime)
+>string ToShortTimeStringUi(this DateTime dateTime)
 >```
-><b>Summary:</b> Converts a DateTime to a string using the short time pattern of the current UI culture.
+><b>Summary:</b> Converts a DateTime to a string using the short time pattern of the current UI culture. Use this variant when rendering output for display in a user interface.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTime`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTime to format.<br />
@@ -965,6 +975,16 @@ Extensions for the `System.DateTimeOffset` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`date`&nbsp;&nbsp;-&nbsp;&nbsp;The date.<br />
 >
 ><b>Returns:</b> The week number from the given date.
+#### GetWeekNumberUi
+>```csharp
+>int GetWeekNumberUi(this DateTimeOffset date)
+>```
+><b>Summary:</b> Gets the week number from a given date using the current UI culture's calendar. Use this variant when rendering the week number for display in a user interface.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`date`&nbsp;&nbsp;-&nbsp;&nbsp;The date.<br />
+>
+><b>Returns:</b> The week number from the given date.
 #### IsBetween
 >```csharp
 >bool IsBetween(this DateTimeOffset dateTimeOffset, DateTimeOffset startDate, DateTimeOffset endDate)
@@ -1056,16 +1076,16 @@ Extensions for the `System.DateTimeOffset` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeFormatInfo`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTimeFormatInfo specifying the format to use.<br />
 >
 ><b>Returns:</b> A string representation of the DateTime using the long date pattern of the provided DateTimeFormatInfo.
-#### ToLongDateStringUsingCurrentUiCulture
+#### ToLongDateStringUi
 >```csharp
->string ToLongDateStringUsingCurrentUiCulture(this DateTimeOffset dateTimeOffset)
+>string ToLongDateStringUi(this DateTimeOffset dateTimeOffset)
 >```
-><b>Summary:</b> Converts a DateTime to a string using the long date pattern of the current UI culture.
+><b>Summary:</b> Converts a DateTimeOffset to a string using the long date pattern of the current UI culture. Use this variant when rendering output for display in a user interface.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeOffset`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTimeOffset to format.<br />
 >
-><b>Returns:</b> A string representation of the DateTime using the long date pattern of the current UI culture.
+><b>Returns:</b> A string representation of the DateTimeOffset using the long date pattern of the current UI culture.
 #### ToLongTimeString
 >```csharp
 >string ToLongTimeString(this DateTimeOffset dateTimeOffset, DateTimeFormatInfo dateTimeFormatInfo)
@@ -1077,16 +1097,16 @@ Extensions for the `System.DateTimeOffset` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeFormatInfo`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTimeFormatInfo specifying the format to use.<br />
 >
 ><b>Returns:</b> A string representation of the DateTime using the long time pattern of the provided DateTimeFormatInfo.
-#### ToLongTimeStringUsingCurrentUiCulture
+#### ToLongTimeStringUi
 >```csharp
->string ToLongTimeStringUsingCurrentUiCulture(this DateTimeOffset dateTimeOffset)
+>string ToLongTimeStringUi(this DateTimeOffset dateTimeOffset)
 >```
-><b>Summary:</b> Converts a DateTime to a string using the long time pattern of the current UI culture.
+><b>Summary:</b> Converts a DateTimeOffset to a string using the long time pattern of the current UI culture. Use this variant when rendering output for display in a user interface.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeOffset`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTimeOffset to format.<br />
 >
-><b>Returns:</b> A string representation of the DateTime using the long time pattern of the current UI culture.
+><b>Returns:</b> A string representation of the DateTimeOffset using the long time pattern of the current UI culture.
 #### ToShortDateString
 >```csharp
 >string ToShortDateString(this DateTimeOffset dateTimeOffset, DateTimeFormatInfo dateTimeFormatInfo)
@@ -1098,16 +1118,16 @@ Extensions for the `System.DateTimeOffset` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeFormatInfo`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTimeFormatInfo specifying the format to use.<br />
 >
 ><b>Returns:</b> A string representation of the DateTime using the short date pattern of the provided DateTimeFormatInfo.
-#### ToShortDateStringUsingCurrentUiCulture
+#### ToShortDateStringUi
 >```csharp
->string ToShortDateStringUsingCurrentUiCulture(this DateTimeOffset dateTimeOffset)
+>string ToShortDateStringUi(this DateTimeOffset dateTimeOffset)
 >```
-><b>Summary:</b> Converts a DateTime to a string using the short date pattern of the current UI culture.
+><b>Summary:</b> Converts a DateTimeOffset to a string using the short date pattern of the current UI culture. Use this variant when rendering output for display in a user interface.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeOffset`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTimeOffset to format.<br />
 >
-><b>Returns:</b> A string representation of the DateTime using the short date pattern of the current UI culture.
+><b>Returns:</b> A string representation of the DateTimeOffset using the short date pattern of the current UI culture.
 #### ToShortDateStringUsingSpecificCulture
 >```csharp
 >string ToShortDateStringUsingSpecificCulture(this DateTimeOffset dateTimeOffset, CultureInfo cultureInfo)
@@ -1130,16 +1150,16 @@ Extensions for the `System.DateTimeOffset` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeFormatInfo`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTimeFormatInfo specifying the format to use.<br />
 >
 ><b>Returns:</b> A string representation of the DateTime using the short time pattern of the provided DateTimeFormatInfo.
-#### ToShortTimeStringUsingCurrentUiCulture
+#### ToShortTimeStringUi
 >```csharp
->string ToShortTimeStringUsingCurrentUiCulture(this DateTimeOffset dateTimeOffset)
+>string ToShortTimeStringUi(this DateTimeOffset dateTimeOffset)
 >```
-><b>Summary:</b> Converts a DateTime to a string using the short time pattern of the current UI culture.
+><b>Summary:</b> Converts a DateTimeOffset to a string using the short time pattern of the current UI culture. Use this variant when rendering output for display in a user interface.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`dateTimeOffset`&nbsp;&nbsp;-&nbsp;&nbsp;The DateTimeOffset to format.<br />
 >
-><b>Returns:</b> A string representation of the DateTime using the short time pattern of the current UI culture.
+><b>Returns:</b> A string representation of the DateTimeOffset using the short time pattern of the current UI culture.
 #### ToUnixTime
 >```csharp
 >long ToUnixTime(this DateTimeOffset dateTimeOffset)
@@ -1203,6 +1223,16 @@ Extensions for the `System.Decimal` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The decimal value to round.<br />
 >
 ><b>Returns:</b> The rounded value as an integer.
+#### CurrencyRoundingUi
+>```csharp
+>decimal CurrencyRoundingUi(this decimal value)
+>```
+><b>Summary:</b> Rounds a decimal value using the currency decimal digits of the current UI culture. Use this variant when rounding for display in a user interface.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The decimal value to round.<br />
+>
+><b>Returns:</b> The rounded decimal value.
 #### IsEqual
 >```csharp
 >bool IsEqual(this decimal a, decimal b)
@@ -1369,6 +1399,16 @@ Extensions for the `System.Double` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The double value to round.<br />
 >
 ><b>Returns:</b> The rounded value as an integer.
+#### CurrencyRoundingUi
+>```csharp
+>double CurrencyRoundingUi(this double value)
+>```
+><b>Summary:</b> Rounds a double value using the currency decimal digits of the current UI culture. Use this variant when rounding for display in a user interface.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`value`&nbsp;&nbsp;-&nbsp;&nbsp;The double value to round.<br />
+>
+><b>Returns:</b> The rounded double value.
 #### GreaterThanOrClose
 >```csharp
 >bool GreaterThanOrClose(this double value1, double value2)
@@ -2051,6 +2091,17 @@ Extensions for the `System.Int32` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`weekNumber`&nbsp;&nbsp;-&nbsp;&nbsp;The week number.<br />
 >
 ><b>Returns:</b> The date of the first day in the given year and week number.
+#### GetFirstDayOfWeekNumberByYearUi
+>```csharp
+>DateTime GetFirstDayOfWeekNumberByYearUi(this int year, int weekNumber)
+>```
+><b>Summary:</b> Gets the date of the first day of a given week in a given year using the current UI culture's calendar. Use this variant when rendering dates for display in a user interface.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`year`&nbsp;&nbsp;-&nbsp;&nbsp;The four-digit year.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`weekNumber`&nbsp;&nbsp;-&nbsp;&nbsp;The ISO week number (1–53).<br />
+>
+><b>Returns:</b> The `System.DateTime` of the Monday that starts the requested week.
 #### GetLastDayOfWeekNumberByYear
 >```csharp
 >DateTime GetLastDayOfWeekNumberByYear(this int year, int weekNumber)
@@ -2062,11 +2113,22 @@ Extensions for the `System.Int32` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`weekNumber`&nbsp;&nbsp;-&nbsp;&nbsp;The week number.<br />
 >
 ><b>Returns:</b> The date of the last day in the given year and week number.
-#### GetMonthNameByMonthNumber
+#### GetLastDayOfWeekNumberByYearUi
+>```csharp
+>DateTime GetLastDayOfWeekNumberByYearUi(this int year, int weekNumber)
+>```
+><b>Summary:</b> Gets the date of the last day of a given week in a given year using the current UI culture's calendar. Use this variant when rendering dates for display in a user interface.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`year`&nbsp;&nbsp;-&nbsp;&nbsp;The four-digit year.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`weekNumber`&nbsp;&nbsp;-&nbsp;&nbsp;The ISO week number (1–53).<br />
+>
+><b>Returns:</b> The `System.DateTime` of the Sunday that ends the requested week.
+#### GetMonthNameByMonthNumberUi
 >```csharp
->string GetMonthNameByMonthNumber(this int month, bool pascalCased = False)
+>string GetMonthNameByMonthNumberUi(this int month, bool pascalCased = False)
 >```
-><b>Summary:</b> Gets the month name by month number.
+><b>Summary:</b> Gets the month name by month number using the current UI culture. Use this variant when rendering output for display in a user interface.
 >
 ><b>Parameters:</b><br>
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`month`&nbsp;&nbsp;-&nbsp;&nbsp;The month.<br />
@@ -2083,6 +2145,16 @@ Extensions for the `System.Int32` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`year`&nbsp;&nbsp;-&nbsp;&nbsp;The year.<br />
 >
 ><b>Returns:</b> The get number of weeks.
+#### GetNumberOfWeeksByYearUi
+>```csharp
+>int GetNumberOfWeeksByYearUi(this int year)
+>```
+><b>Summary:</b> Returns the number of ISO weeks in the given year using the current UI culture's calendar. Use this variant when rendering the value for display in a user interface.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`year`&nbsp;&nbsp;-&nbsp;&nbsp;The four-digit year.<br />
+>
+><b>Returns:</b> 52 or 53 depending on the year and calendar.
 #### IsBinarySequence
 >```csharp
 >bool IsBinarySequence(this int number)
@@ -3509,6 +3581,17 @@ Extensions for the `System.TimeSpan` class.
 >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`decimalPrecision`&nbsp;&nbsp;-&nbsp;&nbsp;The number of decimal places to display (default is 3).<br />
 >
 ><b>Returns:</b> A formatted string representing the time in the most appropriate unit (days, hours, minutes, seconds, or milliseconds).
+#### GetPrettyTimeUi
+>```csharp
+>string GetPrettyTimeUi(this TimeSpan timeSpan, int decimalPrecision = 3)
+>```
+><b>Summary:</b> Converts a TimeSpan to a human-readable string representation with appropriate time units, using the current UI culture for number formatting and unit label casing. Use this variant when rendering output for display in a user interface.
+>
+><b>Parameters:</b><br>
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`timeSpan`&nbsp;&nbsp;-&nbsp;&nbsp;The TimeSpan to format.<br />
+>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`decimalPrecision`&nbsp;&nbsp;-&nbsp;&nbsp;The number of decimal places to display (default is 3).<br />
+>
+><b>Returns:</b> A formatted string representing the time in the most appropriate unit (days, hours, minutes, seconds, or milliseconds).
 #### Max
 >```csharp
 >TimeSpan Max(this TimeSpan t1, TimeSpan t2)