From e03c12b63978b269e012591f22ba19e6628041f8 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 6 Jul 2026 21:17:27 +0000
Subject: [PATCH] refactor: extract shared transience computation into
 TransienceCalculator

Both PrimaryPortInnerErrors and SecondaryPortInnerErrors carried a
byte-for-byte identical ComputeTransience implementation. Extract that
logic into an internal TransienceCalculator helper and have both classes
delegate to it, so the transience resolution rules live in a single
authoritative place. Behaviour is unchanged; existing coverage in
PortInnerErrorsTests exercises all branches through the public API.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011eKgk4tXrcECvpepJwGshF
---
 FirstClassErrors/PrimaryPortInnerErrors.cs   | 15 +----
 FirstClassErrors/SecondaryPortInnerErrors.cs | 15 +----
 FirstClassErrors/TransienceCalculator.cs     | 59 ++++++++++++++++++++
 3 files changed, 61 insertions(+), 28 deletions(-)
 create mode 100644 FirstClassErrors/TransienceCalculator.cs

diff --git a/FirstClassErrors/PrimaryPortInnerErrors.cs b/FirstClassErrors/PrimaryPortInnerErrors.cs
index 70efb70..7451181 100644
--- a/FirstClassErrors/PrimaryPortInnerErrors.cs
+++ b/FirstClassErrors/PrimaryPortInnerErrors.cs
@@ -89,20 +89,7 @@ public PrimaryPortInnerErrors Add(PrimaryPortError error) {
     ///     It determines the transience based on the <see cref="InfrastructureError.Transience" /> property.
     /// </remarks>
     public Transience ComputeTransience() {
-        IEnumerable<InfrastructureError> infraErrors = _errors.OfType<InfrastructureError>();
-
-        bool hasTransient = false;
-
-        foreach (InfrastructureError? error in infraErrors) {
-            switch (error.Transience) {
-                case Transience.NonTransient: return Transience.NonTransient;
-                case Transience.Transient:    hasTransient = true; break;
-            }
-        }
-
-        return hasTransient
-            ? Transience.Transient
-            : Transience.Unknown;
+        return TransienceCalculator.Compute(_errors);
     }
 
     internal IReadOnlyList<Error> ToList() {
diff --git a/FirstClassErrors/SecondaryPortInnerErrors.cs b/FirstClassErrors/SecondaryPortInnerErrors.cs
index 5f40087..37e5885 100644
--- a/FirstClassErrors/SecondaryPortInnerErrors.cs
+++ b/FirstClassErrors/SecondaryPortInnerErrors.cs
@@ -106,20 +106,7 @@ internal IReadOnlyList<Error> ToList() {
     ///     <see cref="InfrastructureError.Transience" /> property of each error.
     /// </remarks>
     public Transience ComputeTransience() {
-        IEnumerable<InfrastructureError> infraErrors = _errors.OfType<InfrastructureError>();
-
-        bool hasTransient = false;
-
-        foreach (InfrastructureError? error in infraErrors) {
-            switch (error.Transience) {
-                case Transience.NonTransient: return Transience.NonTransient;
-                case Transience.Transient:    hasTransient = true; break;
-            }
-        }
-
-        return hasTransient
-            ? Transience.Transient
-            : Transience.Unknown;
+        return TransienceCalculator.Compute(_errors);
     }
 
     /// <inheritdoc />
diff --git a/FirstClassErrors/TransienceCalculator.cs b/FirstClassErrors/TransienceCalculator.cs
new file mode 100644
index 0000000..f2204d4
--- /dev/null
+++ b/FirstClassErrors/TransienceCalculator.cs
@@ -0,0 +1,59 @@
+namespace FirstClassErrors;
+
+/// <summary>
+///     Computes the overall <see cref="Transience" /> of a collection of errors.
+/// </summary>
+/// <remarks>
+///     This helper centralizes the transience resolution rules so that the various inner-error collections
+///     (for instance <see cref="PrimaryPortInnerErrors" /> and <see cref="SecondaryPortInnerErrors" />) share a
+///     single, authoritative implementation rather than duplicating the logic.
+/// </remarks>
+internal static class TransienceCalculator {
+
+    #region Statics members declarations
+
+    /// <summary>
+    ///     Computes the overall transience of the specified errors.
+    /// </summary>
+    /// <param name="errors">The errors to evaluate.</param>
+    /// <returns>
+    ///     A <see cref="Transience" /> value indicating the overall transience of the errors:
+    ///     <list type="bullet">
+    ///         <item>
+    ///             <description><see cref="Transience.NonTransient" /> if any error is explicitly non-transient.</description>
+    ///         </item>
+    ///         <item>
+    ///             <description>
+    ///                 <see cref="Transience.Transient" /> if at least one error is transient and none are
+    ///                 non-transient.
+    ///             </description>
+    ///         </item>
+    ///         <item>
+    ///             <description><see cref="Transience.Unknown" /> if no errors are classified as transient or non-transient.</description>
+    ///         </item>
+    ///     </list>
+    /// </returns>
+    /// <remarks>
+    ///     Only errors of type <see cref="InfrastructureError" /> are taken into account; the transience is determined
+    ///     based on their <see cref="InfrastructureError.Transience" /> property.
+    /// </remarks>
+    public static Transience Compute(IEnumerable<Error> errors) {
+        IEnumerable<InfrastructureError> infraErrors = errors.OfType<InfrastructureError>();
+
+        bool hasTransient = false;
+
+        foreach (InfrastructureError error in infraErrors) {
+            switch (error.Transience) {
+                case Transience.NonTransient: return Transience.NonTransient;
+                case Transience.Transient:    hasTransient = true; break;
+            }
+        }
+
+        return hasTransient
+            ? Transience.Transient
+            : Transience.Unknown;
+    }
+
+    #endregion
+
+}