From d95d3f9687d4e28fa767d15576a20bad4d3ab2e0 Mon Sep 17 00:00:00 2001
From: Jason Barden <jason.barden@outlook.com>
Date: Sat, 2 Aug 2025 01:00:21 +0100
Subject: [PATCH 1/4] Remove unused controllers and refactor records

---
 .../MultiProjectResultsController.cs          | 33 -------------------
 .../Controllers/TestResultsController.cs      | 26 ---------------
 .../Models/TestResult.cs                      | 22 ++++++-------
 .../Program.cs                                | 25 --------------
 .../Shared/Dtos/TestResultDto.cs              | 14 ++++----
 .../TestCoverage/TestResultsEndpoint.cs       |  1 -
 .../TrxParser.cs                              | 22 +++++++------
 .../Components/Pages/Dashboard.razor.cs       |  4 +--
 .../Components/ThemeToggle.razor              |  2 +-
 .../Models/TestResult.cs                      | 22 ++++++-------
 src/AStar.Dev.Testing.Dashboard/Program.cs    |  1 -
 .../Services/TestResultsService.cs            |  6 ++--
 12 files changed, 45 insertions(+), 133 deletions(-)
 delete mode 100644 src/AStar.Dev.Testing.Dashboard.Server/Controllers/MultiProjectResultsController.cs
 delete mode 100644 src/AStar.Dev.Testing.Dashboard.Server/Controllers/TestResultsController.cs
 rename src/AStar.Dev.Testing.Dashboard.Server/{Controllers => TestCoverage}/TrxParser.cs (54%)

diff --git a/src/AStar.Dev.Testing.Dashboard.Server/Controllers/MultiProjectResultsController.cs b/src/AStar.Dev.Testing.Dashboard.Server/Controllers/MultiProjectResultsController.cs
deleted file mode 100644
index bed572e..0000000
--- a/src/AStar.Dev.Testing.Dashboard.Server/Controllers/MultiProjectResultsController.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-using AStar.Dev.Testing.Dashboard.Server.Models;
-using Microsoft.AspNetCore.Mvc;
-
-namespace AStar.Dev.Testing.Dashboard.Server.Controllers;
-
-[ApiController]
-[Route("api/[controller]")]
-public class MultiProjectResultsController : ControllerBase
-{
-    [HttpGet]
-    public ActionResult<IEnumerable<TestResult>> GetTrxResults()
-    {
-        var rootPath   = Path.Combine(Directory.GetCurrentDirectory(), "../../test");
-        var allResults = new List<TestResult>();
-
-        var directories = Directory.GetDirectories(rootPath);
-
-        foreach (var dir in directories)
-        {
-            var filePath = Path.Combine(dir, "TestResults", "results.trx");
-
-            if (!System.IO.File.Exists(filePath))
-            {
-                continue;
-            }
-
-            var results = TrxParser.ParseTrx(filePath);
-            allResults.AddRange(results);
-        }
-
-        return Ok(allResults);
-    }
-}
diff --git a/src/AStar.Dev.Testing.Dashboard.Server/Controllers/TestResultsController.cs b/src/AStar.Dev.Testing.Dashboard.Server/Controllers/TestResultsController.cs
deleted file mode 100644
index 9aed15d..0000000
--- a/src/AStar.Dev.Testing.Dashboard.Server/Controllers/TestResultsController.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-using System.Text.Json;
-using AStar.Dev.Testing.Dashboard.Server.Models;
-using Microsoft.AspNetCore.Mvc;
-
-namespace AStar.Dev.Testing.Dashboard.Server.Controllers;
-
-[ApiController]
-[Route("api/[controller]")]
-public class TestResultsController : ControllerBase
-{
-    [HttpGet]
-    public async Task<ActionResult<IEnumerable<TestResult>>> GetAsync()
-    {
-        var filePath = Path.Combine("Data", "test-results.json");
-
-        if (!System.IO.File.Exists(filePath))
-        {
-            return NotFound("Test result file not found.");
-        }
-
-        var json    = await System.IO.File.ReadAllTextAsync(filePath);
-        var results = JsonSerializer.Deserialize<List<TestResult>>(json, new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
-
-        return Ok(results);
-    }
-}
diff --git a/src/AStar.Dev.Testing.Dashboard.Server/Models/TestResult.cs b/src/AStar.Dev.Testing.Dashboard.Server/Models/TestResult.cs
index 4463ffc..800a44b 100644
--- a/src/AStar.Dev.Testing.Dashboard.Server/Models/TestResult.cs
+++ b/src/AStar.Dev.Testing.Dashboard.Server/Models/TestResult.cs
@@ -1,14 +1,12 @@
 namespace AStar.Dev.Testing.Dashboard.Server.Models;
 
-public class TestResult
-{
-    public string   Name         { get;  set; }
-    public string   Outcome      { get;  set; } // Passed, Failed, Skipped
-    public string   Duration     { get;  set; }
-    public string   Category     { get;  set; }
-    public string   ErrorMessage { get;  set; }
-    public DateTime Timestamp    { get;  set; }
-    public string?  StartTime    { get ; set ; }
-    public string?  EndTime      { get ; set ; }
-    public string   ProjectName  { get ; set ; }
-}
+public record TestResult(
+    string  Name         ,
+    string  Outcome      ,
+    string  Duration     ,
+    string? Category     ,
+    string? ErrorMessage ,
+    string? StartTime    ,
+    string? EndTime      ,
+    string  ProjectName
+);
diff --git a/src/AStar.Dev.Testing.Dashboard.Server/Program.cs b/src/AStar.Dev.Testing.Dashboard.Server/Program.cs
index 1c75626..d04f942 100644
--- a/src/AStar.Dev.Testing.Dashboard.Server/Program.cs
+++ b/src/AStar.Dev.Testing.Dashboard.Server/Program.cs
@@ -1,4 +1,3 @@
-using AStar.Dev.Testing.Dashboard.Server;
 using AStar.Dev.Testing.Dashboard.Server.TestCoverage;
 
 var builder = WebApplication.CreateBuilder(args);
@@ -31,32 +30,8 @@
 app.MapControllers();
 app.UseHttpsRedirection();
 
-var summaries = new[] { "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching" };
-
-app.MapGet("/weatherforecast", () =>
-                               {
-                                   var forecast =  Enumerable.Range(1, 5).Select(index => new WeatherForecast
-                                                                                     (
-                                                                                      DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
-                                                                                      Random.Shared.Next(-20, 55),
-                                                                                      summaries[Random.Shared.Next(summaries.Length)]
-                                                                                     ))
-                                                             .ToArray();
-
-                                   return forecast;
-                               })
-   .WithName("GetWeatherForecast");
-
 app.MapCodeCoverageEndpoints()
    .MapTestResultsEndpoint()
    .UseCors();
 
 await app.RunAsync();
-
-namespace AStar.Dev.Testing.Dashboard.Server
-{
-    internal record WeatherForecast(DateOnly Date, int TemperatureC, string? Summary)
-    {
-        public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
-    }
-}
diff --git a/src/AStar.Dev.Testing.Dashboard.Server/Shared/Dtos/TestResultDto.cs b/src/AStar.Dev.Testing.Dashboard.Server/Shared/Dtos/TestResultDto.cs
index d634cd0..e7f5cf6 100644
--- a/src/AStar.Dev.Testing.Dashboard.Server/Shared/Dtos/TestResultDto.cs
+++ b/src/AStar.Dev.Testing.Dashboard.Server/Shared/Dtos/TestResultDto.cs
@@ -1,8 +1,8 @@
 namespace AStar.Dev.Testing.Dashboard.Server.Shared.Dtos;
 
-public class TestResultDto
+public record TestResultDto
 {
-    public string Name { get; set; }
+    public required string Name { get; set; }
 
     public string StatusIcon => Outcome switch
                                 {
@@ -12,9 +12,9 @@ public class TestResultDto
                                     _         => "help"
                                 };
 
-    public string   Outcome    { get; set; }
-    public double   DurationMs { get; set; }
-    public string   Category   { get; set; }
-    public string   Message    { get; set; }
-    public DateTime Timestamp  { get; set; }
+    public required string   Outcome    { get; set; }
+    public          double   DurationMs { get; set; }
+    public required string   Category   { get; set; }
+    public required string   Message    { get; set; }
+    public          DateTime Timestamp  { get; set; }
 }
diff --git a/src/AStar.Dev.Testing.Dashboard.Server/TestCoverage/TestResultsEndpoint.cs b/src/AStar.Dev.Testing.Dashboard.Server/TestCoverage/TestResultsEndpoint.cs
index 9d80219..80ef1af 100644
--- a/src/AStar.Dev.Testing.Dashboard.Server/TestCoverage/TestResultsEndpoint.cs
+++ b/src/AStar.Dev.Testing.Dashboard.Server/TestCoverage/TestResultsEndpoint.cs
@@ -1,4 +1,3 @@
-using AStar.Dev.Testing.Dashboard.Server.Controllers;
 using AStar.Dev.Testing.Dashboard.Server.Models;
 
 namespace AStar.Dev.Testing.Dashboard.Server.TestCoverage;
diff --git a/src/AStar.Dev.Testing.Dashboard.Server/Controllers/TrxParser.cs b/src/AStar.Dev.Testing.Dashboard.Server/TestCoverage/TrxParser.cs
similarity index 54%
rename from src/AStar.Dev.Testing.Dashboard.Server/Controllers/TrxParser.cs
rename to src/AStar.Dev.Testing.Dashboard.Server/TestCoverage/TrxParser.cs
index e768e3e..24e5fda 100644
--- a/src/AStar.Dev.Testing.Dashboard.Server/Controllers/TrxParser.cs
+++ b/src/AStar.Dev.Testing.Dashboard.Server/TestCoverage/TrxParser.cs
@@ -1,7 +1,7 @@
 using System.Xml.Linq;
 using AStar.Dev.Testing.Dashboard.Server.Models;
 
-namespace AStar.Dev.Testing.Dashboard.Server.Controllers;
+namespace AStar.Dev.Testing.Dashboard.Server.TestCoverage;
 
 public static class TrxParser
 {
@@ -14,18 +14,20 @@ public static List<TestResult> ParseTrx(string filePath)
         const string secondSearchString  = ".Tests.Unit/TestResults/results.trx";
         var          index               = filePath.LastIndexOf(initialSearchString, StringComparison.Ordinal) + initialSearchString.Length;
         var          index2              = filePath.LastIndexOf(secondSearchString,  StringComparison.Ordinal) - index;
-        var          root                = filePath.Substring(index, index2);
+        var          projectName         = filePath.Substring(index, index2);
 
         var results = doc.Descendants(ns + "UnitTestResult")
                          .Select(x => new TestResult
-                                      {
-                                          ProjectName = root,
-                                          Name        = x.Attribute("testName")?.Value,
-                                          Outcome     = x.Attribute("outcome")?.Value,
-                                          Duration    = x.Attribute("duration")?.Value,
-                                          StartTime   = x.Attribute("startTime")?.Value,
-                                          EndTime     = x.Attribute("endTime")?.Value
-                                      })
+                                     (
+                                      x.Attribute("testName")?.Value!,
+                                      x.Attribute("outcome")?.Value!,
+                                      x.Attribute("duration")?.Value!,
+                                      x.Attribute("startTime")?.Value,
+                                      x.Attribute("endTime")?.Value,
+                                      x.Attribute("errorMessage")?.Value,
+                                      x.Attribute("testType")?.Value,
+                                      projectName
+                                     ))
                          .ToList();
 
         return results;
diff --git a/src/AStar.Dev.Testing.Dashboard/Components/Pages/Dashboard.razor.cs b/src/AStar.Dev.Testing.Dashboard/Components/Pages/Dashboard.razor.cs
index 056d61e..f57ffaa 100644
--- a/src/AStar.Dev.Testing.Dashboard/Components/Pages/Dashboard.razor.cs
+++ b/src/AStar.Dev.Testing.Dashboard/Components/Pages/Dashboard.razor.cs
@@ -1,5 +1,5 @@
-using AStar.Dev.Test.Dashboard.Ui.Models;
-using AStar.Dev.Test.Dashboard.Ui.Services;
+using AStar.Dev.Testing.Dashboard.Models;
+using AStar.Dev.Testing.Dashboard.Services;
 using Microsoft.AspNetCore.Components;
 
 namespace AStar.Dev.Testing.Dashboard.Components.Pages;
diff --git a/src/AStar.Dev.Testing.Dashboard/Components/ThemeToggle.razor b/src/AStar.Dev.Testing.Dashboard/Components/ThemeToggle.razor
index 4fb2361..10578b5 100644
--- a/src/AStar.Dev.Testing.Dashboard/Components/ThemeToggle.razor
+++ b/src/AStar.Dev.Testing.Dashboard/Components/ThemeToggle.razor
@@ -1,7 +1,7 @@
 @using AStar.Dev.Testing.Dashboard.Services
 @namespace AStar.Dev.Testing.Dashboard.Components
 @inject ThemeService ThemeService
-@inject IJSRuntime            JsRuntime
+@inject IJSRuntime   JsRuntime
 
 <div class="theme-toggle">
     <button class="btn btn-link" @onclick="ToggleTheme">
diff --git a/src/AStar.Dev.Testing.Dashboard/Models/TestResult.cs b/src/AStar.Dev.Testing.Dashboard/Models/TestResult.cs
index e6119a6..e810db7 100644
--- a/src/AStar.Dev.Testing.Dashboard/Models/TestResult.cs
+++ b/src/AStar.Dev.Testing.Dashboard/Models/TestResult.cs
@@ -1,13 +1,11 @@
-namespace AStar.Dev.Test.Dashboard.Ui.Models;
+namespace AStar.Dev.Testing.Dashboard.Models;
 
-public class TestResult
-{
-    public string   Name         { get; set; }
-    public string   Outcome      { get; set; } // Passed, Failed, Skipped
-    public TimeSpan Duration     { get; set; }
-    public string   Category     { get; set; }
-    public string   ErrorMessage { get; set; }
-    public DateTime Timestamp    { get; set; }
-    public string   StartTime    { get; set; }
-    public string   EndTime      { get; set; }
-}
+public record TestResult(
+    string   Name         ,
+    string   Outcome      ,
+    TimeSpan Duration     ,
+    string   Category     ,
+    string   ErrorMessage ,
+    DateTime Timestamp    ,
+    string   StartTime    ,
+    string   EndTime     );
diff --git a/src/AStar.Dev.Testing.Dashboard/Program.cs b/src/AStar.Dev.Testing.Dashboard/Program.cs
index 2b2f02a..08a3946 100644
--- a/src/AStar.Dev.Testing.Dashboard/Program.cs
+++ b/src/AStar.Dev.Testing.Dashboard/Program.cs
@@ -1,4 +1,3 @@
-using AStar.Dev.Test.Dashboard.Ui.Services;
 using AStar.Dev.Testing.Dashboard.Components;
 using AStar.Dev.Testing.Dashboard.Services;
 
diff --git a/src/AStar.Dev.Testing.Dashboard/Services/TestResultsService.cs b/src/AStar.Dev.Testing.Dashboard/Services/TestResultsService.cs
index 4f004ed..64d9c01 100644
--- a/src/AStar.Dev.Testing.Dashboard/Services/TestResultsService.cs
+++ b/src/AStar.Dev.Testing.Dashboard/Services/TestResultsService.cs
@@ -1,7 +1,7 @@
 using System.Text.Json;
-using AStar.Dev.Test.Dashboard.Ui.Models;
+using AStar.Dev.Testing.Dashboard.Models;
 
-namespace AStar.Dev.Test.Dashboard.Ui.Services;
+namespace AStar.Dev.Testing.Dashboard.Services;
 
 public class TestResultsService(IHttpClientFactory factory)
 {
@@ -10,7 +10,7 @@ public class TestResultsService(IHttpClientFactory factory)
 
     public async Task<List<TestResult>> GetAllResultsAsync()
     {
-        var response = await httpClient.GetAsync("/api/multiprojectresults");
+        var response = await httpClient.GetAsync("/api/test-results");
         response.EnsureSuccessStatusCode();
 
         var json = await response.Content.ReadAsStringAsync();

From 08cc5ecec7050c707abd2ad8b318cbebeca0b72a Mon Sep 17 00:00:00 2001
From: Jason Barden <jason.barden@outlook.com>
Date: Sat, 2 Aug 2025 01:01:46 +0100
Subject: [PATCH 2/4] Separate the endpoints

---
 .../Program.cs                                |  1 +
 .../TestCoverage/TestResultsEndpoint.cs       | 36 -------------------
 .../TestCoverage/TrxParser.cs                 | 35 ------------------
 3 files changed, 1 insertion(+), 71 deletions(-)
 delete mode 100644 src/AStar.Dev.Testing.Dashboard.Server/TestCoverage/TestResultsEndpoint.cs
 delete mode 100644 src/AStar.Dev.Testing.Dashboard.Server/TestCoverage/TrxParser.cs

diff --git a/src/AStar.Dev.Testing.Dashboard.Server/Program.cs b/src/AStar.Dev.Testing.Dashboard.Server/Program.cs
index d04f942..61f3260 100644
--- a/src/AStar.Dev.Testing.Dashboard.Server/Program.cs
+++ b/src/AStar.Dev.Testing.Dashboard.Server/Program.cs
@@ -1,4 +1,5 @@
 using AStar.Dev.Testing.Dashboard.Server.TestCoverage;
+using AStar.Dev.Testing.Dashboard.Server.TestResultsEndpoint;
 
 var builder = WebApplication.CreateBuilder(args);
 
diff --git a/src/AStar.Dev.Testing.Dashboard.Server/TestCoverage/TestResultsEndpoint.cs b/src/AStar.Dev.Testing.Dashboard.Server/TestCoverage/TestResultsEndpoint.cs
deleted file mode 100644
index 80ef1af..0000000
--- a/src/AStar.Dev.Testing.Dashboard.Server/TestCoverage/TestResultsEndpoint.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-using AStar.Dev.Testing.Dashboard.Server.Models;
-
-namespace AStar.Dev.Testing.Dashboard.Server.TestCoverage;
-
-public static class TestResultsEndpoint
-{
-    public static WebApplication MapTestResultsEndpoint(this WebApplication app)
-    {
-        app.MapGet("/api/test-results", () =>
-                                        {
-                                            var rootPath   = Path.Combine(Directory.GetCurrentDirectory(), "../../test");
-                                            var allResults = new List<TestResult>();
-
-                                            var directories = Directory.GetDirectories(rootPath);
-
-                                            foreach (var dir in directories)
-                                            {
-                                                var filePath = Path.Combine(dir, "TestResults", "results.trx");
-
-                                                if (!File.Exists(filePath))
-                                                {
-                                                    continue;
-                                                }
-
-                                                var results = TrxParser.ParseTrx(filePath);
-                                                allResults.AddRange(results);
-                                            }
-
-                                            return Results.Ok(allResults);
-                                        })
-           .WithName("GetTestResults")
-           .WithOpenApi();
-
-        return app;
-    }
-}
diff --git a/src/AStar.Dev.Testing.Dashboard.Server/TestCoverage/TrxParser.cs b/src/AStar.Dev.Testing.Dashboard.Server/TestCoverage/TrxParser.cs
deleted file mode 100644
index 24e5fda..0000000
--- a/src/AStar.Dev.Testing.Dashboard.Server/TestCoverage/TrxParser.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-using System.Xml.Linq;
-using AStar.Dev.Testing.Dashboard.Server.Models;
-
-namespace AStar.Dev.Testing.Dashboard.Server.TestCoverage;
-
-public static class TrxParser
-{
-    public static List<TestResult> ParseTrx(string filePath)
-    {
-        var        doc = XDocument.Load(filePath);
-        XNamespace ns  = "http://microsoft.com/schemas/VisualStudio/TeamTest/2010";
-
-        const string initialSearchString = "../../test/";
-        const string secondSearchString  = ".Tests.Unit/TestResults/results.trx";
-        var          index               = filePath.LastIndexOf(initialSearchString, StringComparison.Ordinal) + initialSearchString.Length;
-        var          index2              = filePath.LastIndexOf(secondSearchString,  StringComparison.Ordinal) - index;
-        var          projectName         = filePath.Substring(index, index2);
-
-        var results = doc.Descendants(ns + "UnitTestResult")
-                         .Select(x => new TestResult
-                                     (
-                                      x.Attribute("testName")?.Value!,
-                                      x.Attribute("outcome")?.Value!,
-                                      x.Attribute("duration")?.Value!,
-                                      x.Attribute("startTime")?.Value,
-                                      x.Attribute("endTime")?.Value,
-                                      x.Attribute("errorMessage")?.Value,
-                                      x.Attribute("testType")?.Value,
-                                      projectName
-                                     ))
-                         .ToList();
-
-        return results;
-    }
-}

From a76fbe8c499f6851f9fbc52ca280c70305a91cfa Mon Sep 17 00:00:00 2001
From: Jason Barden <jason.barden@outlook.com>
Date: Sat, 2 Aug 2025 01:12:59 +0100
Subject: [PATCH 3/4] Add the functional project with tests from another
 solution

---
 AStar.Dev.Testing.Dashboard.sln               |  14 ++
 .../AStar.Dev.Functional.Extensions.csproj    |  41 +++++
 .../EnumerableExtensions.cs                   |  24 +++
 src/AStar.Dev.Functional.Extensions/Option.cs |  17 ++
 .../OptionAsyncExtensions.cs                  |  66 ++++++++
 .../OptionExtensions.cs                       | 115 +++++++++++++
 .../OptionLinqExtensions.cs                   |  38 +++++
 .../Option{T}.cs                              |  90 ++++++++++
 .../Pattern.cs                                |  51 ++++++
 .../Readme-option.md                          | 103 ++++++++++++
 .../Readme-result.md                          |  96 +++++++++++
 src/AStar.Dev.Functional.Extensions/Readme.md |  29 ++++
 src/AStar.Dev.Functional.Extensions/Result.cs |  66 ++++++++
 .../ResultAsyncExtensions.cs                  |  84 ++++++++++
 .../ResultAsyncLinqExtensions.cs              |  49 ++++++
 .../ResultExtensions.cs                       |  72 ++++++++
 .../ResultLinqExtensions.cs                   |  67 ++++++++
 src/AStar.Dev.Functional.Extensions/Try.cs    |  80 +++++++++
 ...ev.Functional.Extensions.Tests.Unit.csproj |  39 +++++
 .../EnumerableExtensionsShould.cs             |  47 ++++++
 .../OptionAsyncExtensionsShould.cs            |  58 +++++++
 .../OptionShould.cs                           |  13 ++
 .../OptionToResultTests.cs                    |  20 +++
 .../PatternTests.cs                           |  43 +++++
 .../ResultAsyncLinqExtensionsTests.cs         |  53 ++++++
 .../ResultLinqExtensionsTests.cs              | 108 ++++++++++++
 .../ResultShould.cs                           | 157 ++++++++++++++++++
 .../TryTests.cs                               |  41 +++++
 28 files changed, 1681 insertions(+)
 create mode 100644 src/AStar.Dev.Functional.Extensions/AStar.Dev.Functional.Extensions.csproj
 create mode 100644 src/AStar.Dev.Functional.Extensions/EnumerableExtensions.cs
 create mode 100644 src/AStar.Dev.Functional.Extensions/Option.cs
 create mode 100644 src/AStar.Dev.Functional.Extensions/OptionAsyncExtensions.cs
 create mode 100644 src/AStar.Dev.Functional.Extensions/OptionExtensions.cs
 create mode 100644 src/AStar.Dev.Functional.Extensions/OptionLinqExtensions.cs
 create mode 100644 src/AStar.Dev.Functional.Extensions/Option{T}.cs
 create mode 100644 src/AStar.Dev.Functional.Extensions/Pattern.cs
 create mode 100644 src/AStar.Dev.Functional.Extensions/Readme-option.md
 create mode 100644 src/AStar.Dev.Functional.Extensions/Readme-result.md
 create mode 100644 src/AStar.Dev.Functional.Extensions/Readme.md
 create mode 100644 src/AStar.Dev.Functional.Extensions/Result.cs
 create mode 100644 src/AStar.Dev.Functional.Extensions/ResultAsyncExtensions.cs
 create mode 100644 src/AStar.Dev.Functional.Extensions/ResultAsyncLinqExtensions.cs
 create mode 100644 src/AStar.Dev.Functional.Extensions/ResultExtensions.cs
 create mode 100644 src/AStar.Dev.Functional.Extensions/ResultLinqExtensions.cs
 create mode 100644 src/AStar.Dev.Functional.Extensions/Try.cs
 create mode 100644 test/AStar.Dev.Functional.Extensions.Tests.Unit/AStar.Dev.Functional.Extensions.Tests.Unit.csproj
 create mode 100644 test/AStar.Dev.Functional.Extensions.Tests.Unit/EnumerableExtensionsShould.cs
 create mode 100644 test/AStar.Dev.Functional.Extensions.Tests.Unit/OptionAsyncExtensionsShould.cs
 create mode 100644 test/AStar.Dev.Functional.Extensions.Tests.Unit/OptionShould.cs
 create mode 100644 test/AStar.Dev.Functional.Extensions.Tests.Unit/OptionToResultTests.cs
 create mode 100644 test/AStar.Dev.Functional.Extensions.Tests.Unit/PatternTests.cs
 create mode 100644 test/AStar.Dev.Functional.Extensions.Tests.Unit/ResultAsyncLinqExtensionsTests.cs
 create mode 100644 test/AStar.Dev.Functional.Extensions.Tests.Unit/ResultLinqExtensionsTests.cs
 create mode 100644 test/AStar.Dev.Functional.Extensions.Tests.Unit/ResultShould.cs
 create mode 100644 test/AStar.Dev.Functional.Extensions.Tests.Unit/TryTests.cs

diff --git a/AStar.Dev.Testing.Dashboard.sln b/AStar.Dev.Testing.Dashboard.sln
index 0ebbb15..b617dfe 100644
--- a/AStar.Dev.Testing.Dashboard.sln
+++ b/AStar.Dev.Testing.Dashboard.sln
@@ -21,6 +21,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AStar.Dev.Testing.Dashboard
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AStar.Dev.Testing.Dashboard.Server.Tests.Unit", "test\AStar.Dev.Testing.Dashboard.Server.Tests.Unit\AStar.Dev.Testing.Dashboard.Server.Tests.Unit.csproj", "{6060F8F6-FDAC-4379-81D3-8A3CA0627F47}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AStar.Dev.Functional.Extensions", "src\AStar.Dev.Functional.Extensions\AStar.Dev.Functional.Extensions.csproj", "{F83287F8-9CB1-4B20-A469-2D58DADAC9DC}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AStar.Dev.Functional.Extensions.Tests.Unit", "test\AStar.Dev.Functional.Extensions.Tests.Unit\AStar.Dev.Functional.Extensions.Tests.Unit.csproj", "{4DB946D7-421E-4602-9D75-3DD5CA64F1F1}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -43,6 +47,14 @@ Global
 		{6060F8F6-FDAC-4379-81D3-8A3CA0627F47}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{6060F8F6-FDAC-4379-81D3-8A3CA0627F47}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{6060F8F6-FDAC-4379-81D3-8A3CA0627F47}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F83287F8-9CB1-4B20-A469-2D58DADAC9DC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F83287F8-9CB1-4B20-A469-2D58DADAC9DC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F83287F8-9CB1-4B20-A469-2D58DADAC9DC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F83287F8-9CB1-4B20-A469-2D58DADAC9DC}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4DB946D7-421E-4602-9D75-3DD5CA64F1F1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4DB946D7-421E-4602-9D75-3DD5CA64F1F1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4DB946D7-421E-4602-9D75-3DD5CA64F1F1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4DB946D7-421E-4602-9D75-3DD5CA64F1F1}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{FC3B1F57-9BAD-4928-B155-74A76E687852} = {06382787-BE50-4C3B-A709-57FA0B6EAADE}
@@ -51,5 +63,7 @@ Global
 		{FCC70445-C25B-4DCF-8407-03593B3DE15F} = {06382787-BE50-4C3B-A709-57FA0B6EAADE}
 		{BBE3B9B2-B4B8-43FE-9A96-3B6C943E98C0} = {F33B86B1-5AC4-403B-A30D-E65848BA0FE6}
 		{6060F8F6-FDAC-4379-81D3-8A3CA0627F47} = {F33B86B1-5AC4-403B-A30D-E65848BA0FE6}
+		{F83287F8-9CB1-4B20-A469-2D58DADAC9DC} = {06382787-BE50-4C3B-A709-57FA0B6EAADE}
+		{4DB946D7-421E-4602-9D75-3DD5CA64F1F1} = {F33B86B1-5AC4-403B-A30D-E65848BA0FE6}
 	EndGlobalSection
 EndGlobal
diff --git a/src/AStar.Dev.Functional.Extensions/AStar.Dev.Functional.Extensions.csproj b/src/AStar.Dev.Functional.Extensions/AStar.Dev.Functional.Extensions.csproj
new file mode 100644
index 0000000..8b92d90
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/AStar.Dev.Functional.Extensions.csproj
@@ -0,0 +1,41 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netstandard2.1</TargetFramework>
+        <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+        <PublishRepositoryUrl>true</PublishRepositoryUrl>
+        <EmbedUntrackedSources>true</EmbedUntrackedSources>
+        <IncludeSymbols>true</IncludeSymbols>
+        <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+        <PackageId>AStar.Dev.Functional.Extensions</PackageId>
+        <Version>0.2.2-alpha</Version>
+        <PackageReadmeFile>Readme.md</PackageReadmeFile>
+        <Authors>Jason</Authors>
+        <Company>AStar Development</Company>
+        <Description>F#-inspired Result type with functional combinators, async support, and LINQ integration.</Description>
+        <PackageTags>result functional monad async linq</PackageTags>
+        <RepositoryUrl>https://github.com/astar-development/astar-dev-functional-extensions.git</RepositoryUrl>
+        <RepositoryType>git</RepositoryType>
+        <PackageLicenseExpression>MIT</PackageLicenseExpression>
+        <PackageProjectUrl>https://github.com/astar-development/astar-dev-functional-extensions</PackageProjectUrl>
+        <RootNamespace>AStar.Dev.Functional.Extensions</RootNamespace>
+        <LangVersion>latest</LangVersion>
+        <Nullable>enable</Nullable>
+        <IsPackable>true</IsPackable>
+        <Title>AStar.Dev.Functional.Extensions</Title>
+        <Copyright>AStar Development 2025</Copyright>
+        <PackageReleaseNotes>No changes in this version, just extending the documentation</PackageReleaseNotes>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" PrivateAssets="All"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <None Include="Readme.md" Pack="true" PackagePath="\"/>
+        <None Include="Readme-result.md" Pack="true" PackagePath="\"/>
+        <None Include="Readme-option.md" Pack="true" PackagePath="\"/>
+    </ItemGroup>
+
+</Project>
diff --git a/src/AStar.Dev.Functional.Extensions/EnumerableExtensions.cs b/src/AStar.Dev.Functional.Extensions/EnumerableExtensions.cs
new file mode 100644
index 0000000..6f4977b
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/EnumerableExtensions.cs
@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace AStar.Dev.Functional.Extensions;
+
+/// <summary>
+///     Contains extensions for <see cref="IEnumerable{T}" />.
+/// </summary>
+public static class EnumerableExtensions
+{
+    /// <summary>
+    ///     An extension method that, rather than returning null if no object matches the predicate, it will return a suitable instance of <see cref="Option{T}.None" />.
+    /// </summary>
+    /// <typeparam name="T">The type of the parameter.</typeparam>
+    /// <param name="sequence">The sequence of objects to search.</param>
+    /// <param name="predicate">The predicate to apply.</param>
+    /// <returns>The option, containing the item or a suitable instance of <see cref="Option{T}.None" />.</returns>
+    public static Option<T> FirstOrNone<T>(this IEnumerable<T> sequence, Func<T, bool> predicate) =>
+        sequence.Where(predicate)
+                .Select<T, Option<T>>(x => x)
+                .DefaultIfEmpty(Option.None<T>())
+                .First();
+}
diff --git a/src/AStar.Dev.Functional.Extensions/Option.cs b/src/AStar.Dev.Functional.Extensions/Option.cs
new file mode 100644
index 0000000..b7c54d9
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/Option.cs
@@ -0,0 +1,17 @@
+namespace AStar.Dev.Functional.Extensions;
+
+/// <summary>
+///     Factory methods for creating instances of <see cref="Option{T}" />.
+/// </summary>
+public static class Option
+{
+    /// <summary>
+    ///     Creates a <c>Some</c> instance containing the specified non-null value.
+    /// </summary>
+    public static Option<T> Some<T>(T value) => new Option<T>.Some(value);
+
+    /// <summary>
+    ///     Returns a <c>None</c> instance representing an absent value.
+    /// </summary>
+    public static Option<T> None<T>() => Option<T>.None.Instance;
+}
diff --git a/src/AStar.Dev.Functional.Extensions/OptionAsyncExtensions.cs b/src/AStar.Dev.Functional.Extensions/OptionAsyncExtensions.cs
new file mode 100644
index 0000000..8e1d8b3
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/OptionAsyncExtensions.cs
@@ -0,0 +1,66 @@
+using System;
+using System.Threading.Tasks;
+
+namespace AStar.Dev.Functional.Extensions;
+
+/// <summary>
+///     Functional async extensions for working with <see cref="Task{Option}" />.
+/// </summary>
+public static class OptionAsyncExtensions
+{
+    /// <summary>
+    ///     Asynchronously transforms the value inside an <see cref="Option{T}" /> if it exists.
+    /// </summary>
+    /// <typeparam name="T">The type of the wrapped value.</typeparam>
+    /// <typeparam name="TResult">The type of the transformed value.</typeparam>
+    /// <param name="task">The asynchronous <see cref="Option{T}" /> to await and transform.</param>
+    /// <param name="func">A mapping function to apply if a value is present.</param>
+    /// <returns>
+    ///     A <see cref="Task{TResult}" /> wrapping an <see cref="Option{TResult}" /> containing the transformed value, or <c>None</c>.
+    /// </returns>
+    public static async Task<Option<TResult>> MapAsync<T, TResult>(
+        this Task<Option<T>> task,
+        Func<T, TResult>     func)
+    {
+        var option = await task;
+
+        return option is Option<T>.Some some
+                   ? new Option<TResult>.Some(func(some.Value))
+                   : Option.None<TResult>();
+    }
+
+    /// <summary>
+    ///     Asynchronously pattern-matches on an <see cref="Option{T}" />.
+    /// </summary>
+    /// <typeparam name="T">The type of the wrapped value.</typeparam>
+    /// <typeparam name="TResult">The return type of the match operation.</typeparam>
+    /// <param name="task">The asynchronous <see cref="Option{T}" /> to await.</param>
+    /// <param name="onSome">A function to invoke if a value is present.</param>
+    /// <param name="onNone">A function to invoke if no value is present.</param>
+    /// <returns>
+    ///     A <see cref="Task{TResult}" /> containing the result of the match operation.
+    /// </returns>
+    public static async Task<TResult> MatchAsync<T, TResult>(
+        this Task<Option<T>>   task,
+        Func<T, Task<TResult>> onSome,
+        Func<Task<TResult>>    onNone)
+    {
+        var option = await task;
+
+        return option is Option<T>.Some some
+                   ? await onSome(some.Value)
+                   : await onNone();
+    }
+
+    /// <summary>
+    ///     Asynchronously binds the value to another <see cref="Task{Option}" /> if present.
+    /// </summary>
+    public static async Task<Option<TResult>> BindAsync<T, TResult>(
+        this Task<Option<T>>           task,
+        Func<T, Task<Option<TResult>>> func)
+    {
+        var option = await task;
+
+        return option is Option<T>.Some some ? await func(some.Value) : Option.None<TResult>();
+    }
+}
diff --git a/src/AStar.Dev.Functional.Extensions/OptionExtensions.cs b/src/AStar.Dev.Functional.Extensions/OptionExtensions.cs
new file mode 100644
index 0000000..d9b3ecd
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/OptionExtensions.cs
@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Generic;
+
+namespace AStar.Dev.Functional.Extensions;
+
+/// <summary>
+///     Functional helpers and utilities for working with <see cref="Option{T}" />.
+/// </summary>
+public static class OptionExtensions
+{
+    /// <summary>
+    ///     Attempts to extract the value from an <see cref="Option{T}" />.
+    /// </summary>
+    public static bool TryGetValue<T>(this Option<T> option, out T value)
+    {
+        if (option is Option<T>.Some some)
+        {
+            value = some.Value;
+
+            return true;
+        }
+
+        value = default!;
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Converts a value to an <see cref="Option{T}" />, treating default/null as <c>None</c>.
+    /// </summary>
+    public static Option<T> ToOption<T>(this T value) =>
+        EqualityComparer<T>.Default.Equals(value, default!)
+            ? Option.None<T>()
+            : new Option<T>.Some(value);
+
+    /// <summary>
+    ///     Converts a value to an <see cref="Option{T}" /> if it satisfies the predicate.
+    /// </summary>
+    public static Option<T> ToOption<T>(this T value, Func<T, bool> predicate) =>
+        predicate(value)
+            ? new Option<T>.Some(value)
+            : Option.None<T>();
+
+    /// <summary>
+    ///     Converts a nullable value type to an <see cref="Option{T}" />.
+    /// </summary>
+    public static Option<T> ToOption<T>(this T? nullable) where T : struct =>
+        nullable.HasValue
+            ? new Option<T>.Some(nullable.Value)
+            : Option.None<T>();
+
+    /// <summary>
+    ///     Transforms the value inside an <see cref="Option{T}" /> if present.
+    /// </summary>
+    public static Option<TResult> Map<T, TResult>(this Option<T> option, Func<T, TResult> map) =>
+        option.Match(
+                     some => new Option<TResult>.Some(map(some)),
+                     Option.None<TResult>);
+
+    /// <summary>
+    ///     Chains another <see cref="Option{T}" />-producing function.
+    /// </summary>
+    public static Option<TResult> Bind<T, TResult>(this Option<T> option, Func<T, Option<TResult>> bind) => option.Match(bind, Option.None<TResult>);
+
+    /// <summary>
+    ///     Converts an <see cref="Option{T}" /> to a <see cref="Result{T, TError}" />.
+    /// </summary>
+    public static Result<T, TError> ToResult<T, TError>(this Option<T> option, Func<TError> errorFactory) =>
+        option.Match<Result<T, TError>>(
+                                        some => new Result<T, TError>.Ok(some),
+                                        () => new Result<T, TError>.Error(errorFactory()));
+
+    /// <summary>
+    ///     Determines whether the option contains a value.
+    /// </summary>
+    public static bool IsSome<T>(this Option<T> option) => option is Option<T>.Some;
+
+    /// <summary>
+    ///     Determines whether the option is empty.
+    /// </summary>
+    public static bool IsNone<T>(this Option<T> option) => option is Option<T>.None;
+
+    /// <summary>
+    ///     Converts an <see cref="Option{T}" /> to a nullable type.
+    /// </summary>
+    public static T? ToNullable<T>(this Option<T> option) where T : struct => option is Option<T>.Some some ? some.Value : null;
+
+    /// <summary>
+    ///     Converts an <see cref="Option{T}" /> to a single-element enumerable or an empty sequence.
+    /// </summary>
+    public static IEnumerable<T> ToEnumerable<T>(this Option<T> option) => option is Option<T>.Some some ? [ some.Value ] : [];
+
+    /// <summary>
+    ///     Gets the value of the option or returns a fallback value.
+    /// </summary>
+    public static T OrElse<T>(this Option<T> option, T fallback) => option is Option<T>.Some some ? some.Value : fallback;
+
+    /// <summary>
+    ///     Gets the value of the option or throws an exception if absent.
+    /// </summary>
+    public static T OrThrow<T>(this Option<T> option, Exception? ex = null) => option is Option<T>.Some some ? some.Value : throw ex ?? new InvalidOperationException("No value present");
+
+    /// <summary>
+    ///     Enables deconstruction of an option into a boolean and value pair.
+    /// </summary>
+    /// <param name="option"></param>
+    /// <param name="isSome"></param>
+    /// <param name="value"></param>
+    /// <typeparam name="T"></typeparam>
+    public static void Deconstruct<T>(this Option<T> option, out bool isSome, out T? value)
+    {
+        isSome = option is Option<T>.Some;
+        value  = isSome ? ((Option<T>.Some)option).Value : default;
+    }
+}
diff --git a/src/AStar.Dev.Functional.Extensions/OptionLinqExtensions.cs b/src/AStar.Dev.Functional.Extensions/OptionLinqExtensions.cs
new file mode 100644
index 0000000..02fe022
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/OptionLinqExtensions.cs
@@ -0,0 +1,38 @@
+using System;
+using System.Threading.Tasks;
+
+namespace AStar.Dev.Functional.Extensions;
+
+/// <summary>
+///     LINQ-style query support for <see cref="Option{T}" />.
+/// </summary>
+public static class OptionLinqExtensions
+{
+    /// <summary>
+    ///     Projects the value of a <see cref="Option{T}" /> using the specified function.
+    /// </summary>
+    public static Option<TResult> Select<T, TResult>(this Option<T> option, Func<T, TResult> selector) => option.Map(selector);
+
+    /// <summary>
+    ///     Projects and flattens nested <see cref="Option{T}" /> structures using a LINQ-style binding function.
+    /// </summary>
+    public static Option<TResult> SelectMany<T, TIntermediate, TResult>(
+        this Option<T>                  option,
+        Func<T, Option<TIntermediate>>  bind,
+        Func<T, TIntermediate, TResult> project) =>
+        option.Bind(x => bind(x).Map(y => project(x, y)));
+
+    /// <summary>
+    ///     Asynchronously projects the value of a <see cref="Task{Option}" /> using the specified function.
+    /// </summary>
+    public static async Task<Option<TResult>> SelectAwait<T, TResult>(
+        this Task<Option<T>>   task,
+        Func<T, Task<TResult>> selector)
+    {
+        var option = await task;
+
+        return option is Option<T>.Some some
+                   ? new Option<TResult>.Some(await selector(some.Value))
+                   : Option.None<TResult>();
+    }
+}
diff --git a/src/AStar.Dev.Functional.Extensions/Option{T}.cs b/src/AStar.Dev.Functional.Extensions/Option{T}.cs
new file mode 100644
index 0000000..74d0053
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/Option{T}.cs
@@ -0,0 +1,90 @@
+using System;
+
+namespace AStar.Dev.Functional.Extensions;
+
+/// <summary>
+///     Represents an optional value that may be present (<see cref="Some" />) or absent (<see cref="None" />).
+/// </summary>
+/// <typeparam name="T">The type of the optional value.</typeparam>
+public abstract class Option<T>
+{
+    private Option()
+    {
+    }
+
+    /// <summary>
+    ///     Implicitly converts a value to an <see cref="Option{T}" />.
+    /// </summary>
+    /// <param name="value">The value to wrap. Null becomes <see cref="None" />.</param>
+    public static implicit operator Option<T>(T value) =>
+        value != null
+            ? new Some(value)
+            : None.Instance;
+
+    /// <summary>
+    ///     Pattern matches on the option.
+    /// </summary>
+    /// <typeparam name="TResult">The return type.</typeparam>
+    /// <param name="onSome">Function to run when the value is present.</param>
+    /// <param name="onNone">Function to run when the value is absent.</param>
+    public TResult Match<TResult>(Func<T, TResult> onSome, Func<TResult> onNone) =>
+        this switch
+        {
+            Some some => onSome(some.Value),
+            None x    => onNone(),
+            _         => throw new InvalidOperationException("It should not be possible to reach this point.")
+        };
+
+    /// <summary>
+    ///     Represents the presence of a value.
+    /// </summary>
+    public sealed class Some : Option<T>
+    {
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="Option{T}.Some" /> class.
+        /// </summary>
+        /// <param name="value">A non-null value.</param>
+        /// <exception cref="ArgumentNullException" />
+        public Some(T value)
+        {
+            if (value is null)
+            {
+                throw new ArgumentNullException(nameof(value));
+            }
+
+            Value = value;
+        }
+
+        /// <summary>
+        ///     The wrapped value.
+        /// </summary>
+        public T Value { get; }
+
+        /// <summary>
+        ///     Overrides the ToString method to return both the type and the value.
+        /// </summary>
+        /// <returns>The overridden ToString</returns>
+        public override string ToString() => $"Some({Value})";
+    }
+
+    /// <summary>
+    ///     Represents the absence of a value.
+    /// </summary>
+    public sealed class None : Option<T>
+    {
+        /// <summary>
+        ///     A helper method to create an instance of <see cref="Option{T}.None" />
+        /// </summary>
+        public static readonly None Instance = new ();
+
+        private None()
+        {
+        }
+
+        /// <summary>
+        ///     Overrides the ToString method to return the type as a simple string.
+        /// </summary>
+        /// <returns>The overridden ToString</returns>
+        public override string ToString() => "None";
+    }
+}
diff --git a/src/AStar.Dev.Functional.Extensions/Pattern.cs b/src/AStar.Dev.Functional.Extensions/Pattern.cs
new file mode 100644
index 0000000..954c3da
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/Pattern.cs
@@ -0,0 +1,51 @@
+namespace AStar.Dev.Functional.Extensions;
+
+/// <summary>
+///     Provides pattern-style checks across Option, Result, and Try.
+/// </summary>
+public static class Pattern
+{
+    /// <summary>
+    /// </summary>
+    /// <param name="option"></param>
+    /// <typeparam name="T"></typeparam>
+    /// <returns></returns>
+    public static bool IsSome<T>(Option<T> option) => option is Option<T>.Some;
+
+    /// <summary>
+    /// </summary>
+    /// <param name="option"></param>
+    /// <typeparam name="T"></typeparam>
+    /// <returns></returns>
+    public static bool IsNone<T>(Option<T> option) => option is Option<T>.None;
+
+    /// <summary>
+    /// </summary>
+    /// <param name="result"></param>
+    /// <typeparam name="T"></typeparam>
+    /// <typeparam name="TE"></typeparam>
+    /// <returns></returns>
+    public static bool IsOk<T, TE>(Result<T, TE>    result) => result is Result<T, TE>.Ok;
+
+    /// <summary>
+    /// </summary>
+    /// <param name="result"></param>
+    /// <typeparam name="T"></typeparam>
+    /// <typeparam name="TE"></typeparam>
+    /// <returns></returns>
+    public static bool IsError<T, TE>(Result<T, TE> result) => result is Result<T, TE>.Error;
+
+    /// <summary>
+    /// </summary>
+    /// <param name="result"></param>
+    /// <typeparam name="T"></typeparam>
+    /// <returns></returns>
+    public static bool IsSuccess<T>(Try<T> result) => result is Try<T>.Success;
+
+    /// <summary>
+    /// </summary>
+    /// <param name="result"></param>
+    /// <typeparam name="T"></typeparam>
+    /// <returns></returns>
+    public static bool IsFailure<T>(Try<T> result) => result is Try<T>.Failure;
+}
diff --git a/src/AStar.Dev.Functional.Extensions/Readme-option.md b/src/AStar.Dev.Functional.Extensions/Readme-option.md
new file mode 100644
index 0000000..7c2b434
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/Readme-option.md
@@ -0,0 +1,103 @@
+# 🎯 Option<T> Functional Cheat Sheet
+
+## 🧩 Option Overview
+
+Represents a value that might exist (`Some`) or not (`None`), avoiding nulls and enabling functional composition.
+
+```csharp
+Option<int> maybeNumber = Option.Some(42);
+Option<string> emptyName = Option.None<string>();
+```
+
+---
+
+## 🏗 Construction
+
+| Syntax                      | Description                             |
+|-----------------------------|-----------------------------------------|
+| `Option.Some(value)`        | Wraps a non-null value as `Some`        |
+| `Option.None<T>()`          | Creates a `None` of type `T`            |
+| `value.ToOption()`          | Converts value or default to Option     |
+| `value.ToOption(predicate)` | Converts only if predicate returns true |
+| `nullable.ToOption()`       | Converts nullable struct to Option      |
+
+---
+
+## 🧪 Pattern Matching
+
+```csharp
+option.Match(
+    some => $"Value: {some}",
+    ()   => "No value"
+);
+```
+
+Or via deconstruction:
+
+```csharp
+var (isSome, value) = option;
+```
+
+Or with TryGet:
+
+```csharp
+if (option.TryGetValue(out var value)) { /* use value */ }
+```
+
+---
+
+## 🔧 Transformation
+
+| Method              | Description                                 |
+|---------------------|---------------------------------------------|
+| `Map(func)`         | Transforms value inside Some                |
+| `Bind(func)`        | Chains function that returns another Option |
+| `ToResult(errorFn)` | Converts Option to `Result<T, TError>`      |
+| `ToNullable()`      | Converts to nullable (structs only)         |
+| `ToEnumerable()`    | Converts to `IEnumerable<T>`                |
+
+---
+
+## 🪄 LINQ Support
+
+```csharp
+var result =
+    from name in Option.Some("Jason")
+    from greeting in Option.Some($"Hello, {name}")
+    select greeting;
+```
+
+Via `Select`, `SelectMany`, or `SelectAwait` (async LINQ)
+
+---
+
+## 🔁 Async Support
+
+| Method                       | Description                                   |
+|------------------------------|-----------------------------------------------|
+| `MapAsync(func)`             | Awaits and maps value                         |
+| `BindAsync(func)`            | Awaits and chains async Option-returning func |
+| `MatchAsync(onSome, onNone)` | Async pattern match                           |
+| `SelectAwait(func)`          | LINQ-friendly async projection                |
+
+---
+
+## 🧯 Fallbacks and Conversions
+
+```csharp
+option.OrElse("fallback");      // returns value or fallback
+option.OrThrow();               // throws if None
+option.IsSome();                // true if Some
+option.IsNone();                // true if None
+```
+
+---
+
+## 🐛 Debugging & Output
+
+```csharp
+option.ToString(); // Outputs "Some(value)" or "None"
+```
+
+---
+
diff --git a/src/AStar.Dev.Functional.Extensions/Readme-result.md b/src/AStar.Dev.Functional.Extensions/Readme-result.md
new file mode 100644
index 0000000..5c211ca
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/Readme-result.md
@@ -0,0 +1,96 @@
+# 🧭 Result<T, TError> Cheat Sheet
+
+## 🧱 Core Concept
+
+Result<T, TError> encapsulates either:
+
+✅ Ok(T) — a success value
+
+❌ Error(TError) — an error reason
+
+```csharp
+Result<string, string> nameResult = new Result<string, string>.Ok("Jason");
+Result<int, string> errorResult = new Result<int, string>.Error("Invalid input");
+```
+
+## 🏗 Construction Helpers
+
+| Expression                     | Outcome                     |
+|--------------------------------|-----------------------------|
+| new Result<T, E>.Ok(value)     | Constructs a success result |
+| new Result<T, E>.Error(reason) | Constructs an error result  |
+
+## 🔧 Transformation
+
+| Method      | Description                                      |
+|-------------|--------------------------------------------------|
+| Map(fn)     | Transforms the success value                     |
+| Bind(fn)    | Chains to another result-returning function      |
+| Tap(action) | Invokes side effect on success, returns original |
+
+```csharp
+result.Map(value => value.ToUpper());
+result.Bind(value => Validate(value));
+result.Tap(Console.WriteLine);
+```
+
+## 🧪 Pattern Matching
+
+```csharp
+result.Match(
+onSuccess: value => $"✅ {value}",
+onError: reason => $"❌ {reason}"
+);
+```
+
+## 🧞 LINQ Composition
+
+```csharp
+var final =
+from input in GetInput()
+from valid in Validate(input)
+select $"Welcome, {valid}";
+```
+
+## LINQ Methods
+
+| Method               | Description                                 |
+|----------------------|---------------------------------------------|
+| Select(fn)           | Maps over success value                     |
+| SelectMany(fn)       | Binds to next result                        |
+| SelectMany(..., ...) | Binds and projects from intermediate result |
+
+## ⚡ Async Support
+
+```csharp
+var asyncResult = await resultTask.MapAsync(val => val.Length);
+var finalValue = await resultTask.MatchAsync(...);
+```
+
+## Async LINQ
+
+```csharp
+var result =
+await GetAsync()
+.SelectMany(asyncValue => ValidateAsync(asyncValue), (a, b) => $"{a}-{b}");
+```
+
+## 🧯 Error Handling
+
+```csharp
+if (result is Result<T, TError>.Error err)
+Log(err.Reason);
+```
+
+Or selectively tap into errors:
+
+```csharp
+public static Result<T, TError> TapError<T, TError>(
+this Result<T, TError> result,
+Action<TError> handler)
+{
+if (result is Result<T, TError>.Error error)
+handler(error.Reason);
+return result;
+}
+```
diff --git a/src/AStar.Dev.Functional.Extensions/Readme.md b/src/AStar.Dev.Functional.Extensions/Readme.md
new file mode 100644
index 0000000..dbf2f9d
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/Readme.md
@@ -0,0 +1,29 @@
+# AStar Dev Functional Extensions
+
+## Overview
+
+This project contains a bunch of classes and extension methods to facilitate a more functional approach to handling errors and optional objects.
+
+## Cheat Sheets
+
+### Result&lt;T&gt; and associated extensions
+
+Cheat sheet is [here](Readme-result.md)
+
+### Option&lt;T&gt; and associated extensions
+
+Cheat sheet is [here](Readme-option.md)
+
+## Build and analysis
+
+### GitHub build
+
+[![SonarQube](https://github.com/astar-development/astar-dev-functional-extensions/actions/workflows/dotnet.yml/badge.svg)](https://github.com/astar-development/astar-dev-functional-extensions/actions/workflows/dotnet.yml)
+
+### SonarQube details
+
+|                                                                                                                                                                                                                                                            |                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                    |
+|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=astar-development_astar-dev-functional-extensions&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=astar-development_astar-dev-functional-extensions)      | [![Bugs](https://sonarcloud.io/api/project_badges/measure?project=astar-development_astar-dev-functional-extensions&metric=bugs)](https://sonarcloud.io/summary/new_code?id=astar-development_astar-dev-functional-extensions)                       | [![Code Smells](https://sonarcloud.io/api/project_badges/measure?project=astar-development_astar-dev-functional-extensions&metric=code_smells)](https://sonarcloud.io/summary/new_code?id=astar-development_astar-dev-functional-extensions)    | [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=astar-development_astar-dev-functional-extensions&metric=coverage)](https://sonarcloud.io/summary/new_code?id=astar-development_astar-dev-functional-extensions)                   | [![Duplicated Lines (%)](https://sonarcloud.io/api/project_badges/measure?project=astar-development_astar-dev-functional-extensions&metric=duplicated_lines_density)](https://sonarcloud.io/summary/new_code?id=astar-development_astar-dev-functional-extensions) |
+| [![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=astar-development_astar-dev-functional-extensions&metric=reliability_rating)](https://sonarcloud.io/summary/new_code?id=astar-development_astar-dev-functional-extensions) | [![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=astar-development_astar-dev-functional-extensions&metric=security_rating)](https://sonarcloud.io/summary/new_code?id=astar-development_astar-dev-functional-extensions) | [![Technical Debt](https://sonarcloud.io/api/project_badges/measure?project=astar-development_astar-dev-functional-extensions&metric=sqale_index)](https://sonarcloud.io/summary/new_code?id=astar-development_astar-dev-functional-extensions) | [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=astar-development_astar-dev-functional-extensions&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=astar-development_astar-dev-functional-extensions) | [![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=astar-development_astar-dev-functional-extensions&metric=vulnerabilities)](https://sonarcloud.io/summary/new_code?id=astar-development_astar-dev-functional-extensions)               |
+
diff --git a/src/AStar.Dev.Functional.Extensions/Result.cs b/src/AStar.Dev.Functional.Extensions/Result.cs
new file mode 100644
index 0000000..c221120
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/Result.cs
@@ -0,0 +1,66 @@
+using System;
+
+namespace AStar.Dev.Functional.Extensions;
+
+/// <summary>
+///     Represents a discriminated union of success or failure.
+/// </summary>
+/// <typeparam name="TSuccess">The type of the success value.</typeparam>
+/// <typeparam name="TError">The type of the error reason.</typeparam>
+public abstract class Result<TSuccess, TError>
+{
+    private Result()
+    {
+    }
+
+    /// <summary>
+    /// </summary>
+    /// <param name="onSuccess"></param>
+    /// <param name="onError"></param>
+    /// <typeparam name="TResult"></typeparam>
+    /// <returns></returns>
+    /// <exception cref="InvalidOperationException"></exception>
+    public TResult Match<TResult>(
+        Func<TSuccess, TResult> onSuccess,
+        Func<TError, TResult>   onError) =>
+        this switch
+        {
+            Ok ok     => onSuccess(ok.Value),
+            Error err => onError(err.Reason),
+            _         => throw new InvalidOperationException("Unrecognized result type")
+        };
+
+    /// <summary>
+    ///     Represents a successful outcome.
+    /// </summary>
+    public sealed class Ok : Result<TSuccess, TError>
+    {
+        /// <summary>
+        ///     Creates a successful result.
+        /// </summary>
+        /// <param name="value">The result value.</param>
+        public Ok(TSuccess value) => Value = value;
+
+        /// <summary>
+        ///     The successful value.
+        /// </summary>
+        public TSuccess Value { get; }
+    }
+
+    /// <summary>
+    ///     Represents an error outcome.
+    /// </summary>
+    public sealed class Error : Result<TSuccess, TError>
+    {
+        /// <summary>
+        ///     Creates an error result.
+        /// </summary>
+        /// <param name="reason">The failure reason.</param>
+        public Error(TError reason) => Reason = reason;
+
+        /// <summary>
+        ///     The error reason.
+        /// </summary>
+        public TError Reason { get; }
+    }
+}
diff --git a/src/AStar.Dev.Functional.Extensions/ResultAsyncExtensions.cs b/src/AStar.Dev.Functional.Extensions/ResultAsyncExtensions.cs
new file mode 100644
index 0000000..7737eb5
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/ResultAsyncExtensions.cs
@@ -0,0 +1,84 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace AStar.Dev.Functional.Extensions;
+
+/// <summary>
+///     Provides asynchronous functional operations for <see cref="Result{T, TError}" /> wrapped in <see cref="ValueTask" />.
+/// </summary>
+public static class ResultAsyncExtensions
+{
+    /// <summary>
+    ///     Asynchronously transforms the success value of a <see cref="Result{T, TError}" /> if present.
+    /// </summary>
+    /// <typeparam name="T">The type of the original success value.</typeparam>
+    /// <typeparam name="TError">The type of the error value.</typeparam>
+    /// <typeparam name="TNew">The type of the transformed success value.</typeparam>
+    /// <param name="task">A <see cref="ValueTask{Result}" /> that wraps the result to transform.</param>
+    /// <param name="map">A mapping function applied to the success value.</param>
+    /// <param name="cancellationToken">An optional cancellation token to cancel the operation.</param>
+    /// <returns>
+    ///     A <see cref="ValueTask{Result}" /> containing either a transformed <c>Ok</c> result or the original <c>Error</c>.
+    /// </returns>
+    public static async ValueTask<Result<TNew, TError>> MapAsync<T, TError, TNew>(
+        this ValueTask<Result<T, TError>> task,
+        Func<T, TNew>                     map,
+        CancellationToken                 cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        var result = await task;
+
+        return result.Map(map);
+    }
+
+    /// <summary>
+    ///     Asynchronously chains a function that returns another <see cref="Result{T, TError}" /> if the current result is successful.
+    /// </summary>
+    /// <typeparam name="T">The type of the original success value.</typeparam>
+    /// <typeparam name="TError">The type of the error value.</typeparam>
+    /// <typeparam name="TNew">The type of the success value returned by the binding function.</typeparam>
+    /// <param name="task">A <see cref="ValueTask{Result}" /> containing the result to bind.</param>
+    /// <param name="bind">A function that returns a new asynchronous result.</param>
+    /// <param name="cancellationToken">An optional cancellation token to cancel the operation.</param>
+    /// <returns>
+    ///     A <see cref="ValueTask{Result}" /> containing the bound result if successful, or the original <c>Error</c>.
+    /// </returns>
+    public static async ValueTask<Result<TNew, TError>> BindAsync<T, TError, TNew>(
+        this ValueTask<Result<T, TError>>        task,
+        Func<T, ValueTask<Result<TNew, TError>>> bind,
+        CancellationToken                        cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        var result = await task;
+
+        return result is Result<T, TError>.Ok ok
+                   ? await bind(ok.Value)
+                   : new Result<TNew, TError>.Error(((Result<T, TError>.Error)result).Reason);
+    }
+
+    /// <summary>
+    ///     Asynchronously matches on a <see cref="Result{T, TError}" />, executing the appropriate function depending on success or error.
+    /// </summary>
+    /// <typeparam name="T">The type of the success value.</typeparam>
+    /// <typeparam name="TError">The type of the error value.</typeparam>
+    /// <typeparam name="TResult">The return type of the match operation.</typeparam>
+    /// <param name="task">A <see cref="ValueTask{Result}" /> to evaluate.</param>
+    /// <param name="onSuccess">A function invoked if the result is <c>Ok</c>.</param>
+    /// <param name="onError">A function invoked if the result is <c>Error</c>.</param>
+    /// <param name="cancellationToken">An optional cancellation token to cancel the operation.</param>
+    /// <returns>
+    ///     A <see cref="ValueTask{TResult}" /> containing the return value of the appropriate match function.
+    /// </returns>
+    public static async ValueTask<TResult> MatchAsync<T, TError, TResult>(
+        this ValueTask<Result<T, TError>> task,
+        Func<T, TResult>                  onSuccess,
+        Func<TError, TResult>             onError,
+        CancellationToken                 cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        var result = await task;
+
+        return result.Match(onSuccess, onError);
+    }
+}
diff --git a/src/AStar.Dev.Functional.Extensions/ResultAsyncLinqExtensions.cs b/src/AStar.Dev.Functional.Extensions/ResultAsyncLinqExtensions.cs
new file mode 100644
index 0000000..eb18ea0
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/ResultAsyncLinqExtensions.cs
@@ -0,0 +1,49 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace AStar.Dev.Functional.Extensions;
+
+/// <summary>
+///     Provides LINQ-style asynchronous binding for <see cref="Result{T, TError}" /> wrapped in <see cref="ValueTask" />.
+/// </summary>
+public static class ResultAsyncLinqExtensions
+{
+    /// <summary>
+    ///     Asynchronously binds and projects over a <see cref="Result{T, TError}" /> using LINQ-style composition.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the original success value.</typeparam>
+    /// <typeparam name="TError">The type of the error value.</typeparam>
+    /// <typeparam name="TCollection">The type of the intermediate value returned by the binding function.</typeparam>
+    /// <typeparam name="TResult">The final projected result type.</typeparam>
+    /// <param name="source">
+    ///     An asynchronous <see cref="Result{TSource, TError}" /> to be bound and projected.
+    /// </param>
+    /// <param name="bind">
+    ///     A function that returns an asynchronous <see cref="Result{TCollection, TError}" /> from the source value.
+    /// </param>
+    /// <param name="project">
+    ///     A projection function that combines the source and collection values into a final result.
+    /// </param>
+    /// <param name="cancellationToken">
+    ///     A token used to cancel the operation before completion.
+    /// </param>
+    /// <returns>
+    ///     A <see cref="ValueTask{Result}" /> containing either a projected <c>Ok</c> value or an <c>Error</c> from any failure.
+    /// </returns>
+    public static async ValueTask<Result<TResult, TError>> SelectMany<TSource, TError, TCollection, TResult>(
+        this ValueTask<Result<TSource, TError>>               source,
+        Func<TSource, ValueTask<Result<TCollection, TError>>> bind,
+        Func<TSource, TCollection, TResult>                   project,
+        CancellationToken                                     cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        var result = await source;
+
+        return result is Result<TSource, TError>.Ok ok
+                   ? await bind(ok.Value).MapAsync(
+                                                   inner => project(ok.Value, inner),
+                                                   cancellationToken)
+                   : new Result<TResult, TError>.Error(((Result<TSource, TError>.Error)result).Reason);
+    }
+}
diff --git a/src/AStar.Dev.Functional.Extensions/ResultExtensions.cs b/src/AStar.Dev.Functional.Extensions/ResultExtensions.cs
new file mode 100644
index 0000000..cc37fbd
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/ResultExtensions.cs
@@ -0,0 +1,72 @@
+using System;
+
+namespace AStar.Dev.Functional.Extensions;
+
+/// <summary>
+///     Provides functional operations for transforming and composing <see cref="Result{T, TError}" />.
+/// </summary>
+public static class ResultExtensions
+{
+    /// <summary>
+    ///     Transforms the success value of a <see cref="Result{T, TError}" /> using the specified mapping function.
+    /// </summary>
+    /// <typeparam name="T">The original type of the success value.</typeparam>
+    /// <typeparam name="TError">The type of the error value.</typeparam>
+    /// <typeparam name="TNew">The type of the transformed success value.</typeparam>
+    /// <param name="result">The result to transform.</param>
+    /// <param name="map">A function that maps the original value to a new value.</param>
+    /// <returns>
+    ///     A new <see cref="Result{TNew, TError}" /> containing the mapped success value if present,
+    ///     or the original error if unsuccessful.
+    /// </returns>
+    public static Result<TNew, TError> Map<T, TError, TNew>(
+        this Result<T, TError> result,
+        Func<T, TNew>          map) =>
+        result.Match<Result<TNew, TError>>(
+                                           ok => new Result<TNew, TError>.Ok(map(ok)),
+                                           err => new Result<TNew, TError>.Error(err)
+                                          );
+
+    /// <summary>
+    ///     Chains the current result to another <see cref="Result{TNew, TError}" />-producing function,
+    ///     allowing for functional composition across result types.
+    /// </summary>
+    /// <typeparam name="T">The original type of the success value.</typeparam>
+    /// <typeparam name="TError">The type of the error value.</typeparam>
+    /// <typeparam name="TNew">The type of the new result's success value.</typeparam>
+    /// <param name="result">The result to bind.</param>
+    /// <param name="bind">A function that returns a new <see cref="Result{TNew, TError}" />.</param>
+    /// <returns>
+    ///     The result of the binding function if the original was successful; otherwise, the original error.
+    /// </returns>
+    public static Result<TNew, TError> Bind<T, TError, TNew>(
+        this Result<T, TError>        result,
+        Func<T, Result<TNew, TError>> bind) =>
+        result.Match(
+                     bind,
+                     err => new Result<TNew, TError>.Error(err)
+                    );
+
+    /// <summary>
+    ///     Executes a side-effect action on the success value of a <see cref="Result{T, TError}" />,
+    ///     returning the original result unchanged.
+    /// </summary>
+    /// <typeparam name="T">The type of the success value.</typeparam>
+    /// <typeparam name="TError">The type of the error value.</typeparam>
+    /// <param name="result">The result to inspect.</param>
+    /// <param name="action">An action to invoke if the result is successful.</param>
+    /// <returns>
+    ///     The original <see cref="Result{T, TError}" /> instance, unchanged.
+    /// </returns>
+    public static Result<T, TError> Tap<T, TError>(
+        this Result<T, TError> result,
+        Action<T>              action)
+    {
+        if (result is Result<T, TError>.Ok ok)
+        {
+            action(ok.Value);
+        }
+
+        return result;
+    }
+}
diff --git a/src/AStar.Dev.Functional.Extensions/ResultLinqExtensions.cs b/src/AStar.Dev.Functional.Extensions/ResultLinqExtensions.cs
new file mode 100644
index 0000000..af88306
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/ResultLinqExtensions.cs
@@ -0,0 +1,67 @@
+using System;
+
+namespace AStar.Dev.Functional.Extensions;
+
+/// <summary>
+///     Enables LINQ-style composition for <see cref="Result{T, TError}" /> types using <c>Select</c> and <c>SelectMany</c>.
+/// </summary>
+public static class ResultLinqExtensions
+{
+    /// <summary>
+    ///     Binds and projects over a <see cref="Result{TSource, TError}" /> using LINQ-style composition.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the original success value.</typeparam>
+    /// <typeparam name="TError">The type of the error value.</typeparam>
+    /// <typeparam name="TCollection">The intermediate value returned by the binding function.</typeparam>
+    /// <typeparam name="TResult">The final projected result value.</typeparam>
+    /// <param name="source">The initial result to bind.</param>
+    /// <param name="bind">A function that returns a result from the source value.</param>
+    /// <param name="project">A projection that combines the source and bound values.</param>
+    /// <returns>
+    ///     A <see cref="Result{TResult, TError}" /> containing the projected success value,
+    ///     or the first encountered error.
+    /// </returns>
+    public static Result<TResult, TError> SelectMany<TSource, TError, TCollection, TResult>(
+        this Result<TSource, TError>               source,
+        Func<TSource, Result<TCollection, TError>> bind,
+        Func<TSource, TCollection, TResult>        project) =>
+        source.Match(
+                     ok => bind(ok).Match<Result<TResult, TError>>(
+                                                                   inner => new Result<TResult, TError>.Ok(project(ok, inner)),
+                                                                   err => new Result<TResult, TError>.Error(err)
+                                                                  ),
+                     err => new Result<TResult, TError>.Error(err)
+                    );
+
+    /// <summary>
+    ///     Binds a result-producing function to a <see cref="Result{T, TError}" />, enabling LINQ-style monadic chaining.
+    /// </summary>
+    /// <typeparam name="T">The original type of the success value.</typeparam>
+    /// <typeparam name="TError">The type of the error value.</typeparam>
+    /// <typeparam name="TNew">The type of the bound result’s success value.</typeparam>
+    /// <param name="result">The original result to bind.</param>
+    /// <param name="binder">A function returning a new result from the success value.</param>
+    /// <returns>
+    ///     The bound result if successful, or the original error.
+    /// </returns>
+    public static Result<TNew, TError> SelectMany<T, TError, TNew>(
+        this Result<T, TError>        result,
+        Func<T, Result<TNew, TError>> binder) =>
+        result.Bind(binder);
+
+    /// <summary>
+    ///     Transforms the success value of a <see cref="Result{T, TError}" /> using a mapping function.
+    /// </summary>
+    /// <typeparam name="T">The original type of the success value.</typeparam>
+    /// <typeparam name="TError">The type of the error value.</typeparam>
+    /// <typeparam name="TNew">The type of the transformed value.</typeparam>
+    /// <param name="result">The result to map.</param>
+    /// <param name="selector">A function that transforms the success value.</param>
+    /// <returns>
+    ///     A result containing the mapped value if successful, or the original error.
+    /// </returns>
+    public static Result<TNew, TError> Select<T, TError, TNew>(
+        this Result<T, TError> result,
+        Func<T, TNew>          selector) =>
+        result.Map(selector);
+}
diff --git a/src/AStar.Dev.Functional.Extensions/Try.cs b/src/AStar.Dev.Functional.Extensions/Try.cs
new file mode 100644
index 0000000..13925dc
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/Try.cs
@@ -0,0 +1,80 @@
+using System;
+
+namespace AStar.Dev.Functional.Extensions;
+
+/// <summary>
+///     Represents a computation that may succeed or throw an exception.
+/// </summary>
+public abstract class Try<T>
+{
+    private Try()
+    {
+    }
+
+    /// <summary>
+    ///     Runs a function and returns a Try containing success or captured exception.
+    /// </summary>
+    /// <param name="func">The computation to execute.</param>
+    /// <returns>A <see cref="Try{T}" /> result.</returns>
+    public static Try<T> Run(Func<T> func)
+    {
+        try
+        {
+            return new Success(func());
+        }
+        catch (Exception ex)
+        {
+            return new Failure(ex);
+        }
+    }
+
+    /// <summary>
+    ///     Pattern matches on success or failure.
+    /// </summary>
+    /// <typeparam name="TResult">Result type.</typeparam>
+    /// <param name="onSuccess">Called when successful.</param>
+    /// <param name="onFailure">Called when an exception occurred.</param>
+    public TResult Match<TResult>(
+        Func<T, TResult>         onSuccess,
+        Func<Exception, TResult> onFailure) =>
+        this switch
+        {
+            Success success => onSuccess(success.Value),
+            Failure failure => onFailure(failure.Exception),
+            _               => throw new InvalidOperationException()
+        };
+
+    /// <summary>
+    ///     A successful result.
+    /// </summary>
+    public sealed class Success : Try<T>
+    {
+        /// <summary>
+        ///     Creates a success.
+        /// </summary>
+        /// <param name="value">The result.</param>
+        public Success(T value) => Value = value;
+
+        /// <summary>
+        ///     The successful value.
+        /// </summary>
+        public T Value { get; }
+    }
+
+    /// <summary>
+    ///     A failed result due to exception.
+    /// </summary>
+    public sealed class Failure : Try<T>
+    {
+        /// <summary>
+        ///     Creates a failure.
+        /// </summary>
+        /// <param name="ex">The exception.</param>
+        public Failure(Exception ex) => Exception = ex;
+
+        /// <summary>
+        ///     The exception thrown.
+        /// </summary>
+        public Exception Exception { get; }
+    }
+}
diff --git a/test/AStar.Dev.Functional.Extensions.Tests.Unit/AStar.Dev.Functional.Extensions.Tests.Unit.csproj b/test/AStar.Dev.Functional.Extensions.Tests.Unit/AStar.Dev.Functional.Extensions.Tests.Unit.csproj
new file mode 100644
index 0000000..03023d1
--- /dev/null
+++ b/test/AStar.Dev.Functional.Extensions.Tests.Unit/AStar.Dev.Functional.Extensions.Tests.Unit.csproj
@@ -0,0 +1,39 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net9.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <IsPackable>false</IsPackable>
+        <LangVersion>latest</LangVersion>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="coverlet.collector" Version="6.0.4">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="JetBrains.Annotations" Version="2025.1.0-eap1"/>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1"/>
+        <PackageReference Include="Shouldly" Version="4.3.0"/>
+        <PackageReference Include="xunit" Version="2.9.3"/>
+        <PackageReference Include="xunit.runner.visualstudio" Version="3.1.1">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+    </ItemGroup>
+
+    <ItemGroup>
+        <AssemblyAttribute Include="System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <Using Include="Xunit"/>
+        <Using Include="Shouldly"/>
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\..\src\AStar.Dev.Functional.Extensions\AStar.Dev.Functional.Extensions.csproj" />
+    </ItemGroup>
+
+</Project>
diff --git a/test/AStar.Dev.Functional.Extensions.Tests.Unit/EnumerableExtensionsShould.cs b/test/AStar.Dev.Functional.Extensions.Tests.Unit/EnumerableExtensionsShould.cs
new file mode 100644
index 0000000..7fc800f
--- /dev/null
+++ b/test/AStar.Dev.Functional.Extensions.Tests.Unit/EnumerableExtensionsShould.cs
@@ -0,0 +1,47 @@
+namespace AStar.Dev.Functional.Extensions.Tests.Unit;
+
+public class EnumerableExtensionsShould
+{
+    [Fact]
+    public void FirstOrNone_ShouldReturnSome_WhenPredicateMatches()
+    {
+        var list = new List<string> { "apple", "banana", "cherry" };
+
+        var result = list.FirstOrNone(s => s.StartsWith('b'));
+
+        result.ShouldBeOfType<Option<string>.Some>();
+        var some = result as Option<string>.Some;
+        some!.Value.ShouldBe("banana");
+    }
+
+    [Fact]
+    public void FirstOrNone_ShouldReturnNone_WhenNoPredicateMatches()
+    {
+        var list = new List<int> { 1, 2, 3 };
+
+        var result = list.FirstOrNone(n => n > 10);
+
+        result.ShouldBeOfType<Option<int>.None>();
+    }
+
+    [Fact]
+    public void FirstOrNone_ShouldReturnNone_ForEmptySequence()
+    {
+        var list = new List<int>();
+
+        var result = list.FirstOrNone(n => n == 0);
+
+        result.ShouldBeOfType<Option<int>.None>();
+    }
+
+    [Fact]
+    public void FirstOrNone_ShouldReturnFirstMatchingItem()
+    {
+        var list = new List<int> { 2, 4, 6 };
+
+        var result = list.FirstOrNone(n => n % 2 == 0);
+
+        var some = result.ShouldBeOfType<Option<int>.Some>();
+        some.Value.ShouldBe(2);
+    }
+}
diff --git a/test/AStar.Dev.Functional.Extensions.Tests.Unit/OptionAsyncExtensionsShould.cs b/test/AStar.Dev.Functional.Extensions.Tests.Unit/OptionAsyncExtensionsShould.cs
new file mode 100644
index 0000000..7f2c306
--- /dev/null
+++ b/test/AStar.Dev.Functional.Extensions.Tests.Unit/OptionAsyncExtensionsShould.cs
@@ -0,0 +1,58 @@
+namespace AStar.Dev.Functional.Extensions.Tests.Unit;
+
+public class OptionAsyncExtensionsShould
+{
+    private static Task<Option<string>> GetUserAsync(bool found) => Task.FromResult(found ? new Option<string>.Some("Alice") :  Option.None<string>());
+
+    [Fact]
+    public async Task MapAsync_ShouldTransformValue_WhenSome()
+    {
+        var result = await GetUserAsync(true).MapAsync(name => name.ToUpper());
+        var some   = result.ShouldBeOfType<Option<string>.Some>();
+        some.Value.ShouldBe("ALICE");
+    }
+
+    [Fact]
+    public async Task MapAsync_ShouldPreserveNone()
+    {
+        var result = await GetUserAsync(false).MapAsync(name => name.ToUpper());
+        result.ShouldBeOfType<Option<string>.None>();
+    }
+
+    [Fact]
+    public async Task BindAsync_ShouldChainTasks_WhenSome()
+    {
+        Task<Option<string>> ValidateAsync(string name)
+        {
+            return Task.FromResult<Option<string>>(name == "Alice"
+                                                       ? new Option<string>.Some("Valid")
+                                                       :  Option.None<string>());
+        }
+
+        var result = await GetUserAsync(true).BindAsync(ValidateAsync);
+        var some   = result.ShouldBeOfType<Option<string>.Some>();
+        some.Value.ShouldBe("Valid");
+    }
+
+    [Fact]
+    public async Task MatchAsync_ShouldHandleSome()
+    {
+        var result = await GetUserAsync(true).MatchAsync(
+                                                         name => Task.FromResult($"Hello {name}"),
+                                                         () => Task.FromResult("User not found")
+                                                        );
+
+        result.ShouldBe("Hello Alice");
+    }
+
+    [Fact]
+    public async Task MatchAsync_ShouldHandleNone()
+    {
+        var result = await GetUserAsync(false).MatchAsync(
+                                                          name => Task.FromResult($"Hello {name}"),
+                                                          () => Task.FromResult("User not found")
+                                                         );
+
+        result.ShouldBe("User not found");
+    }
+}
diff --git a/test/AStar.Dev.Functional.Extensions.Tests.Unit/OptionShould.cs b/test/AStar.Dev.Functional.Extensions.Tests.Unit/OptionShould.cs
new file mode 100644
index 0000000..6bbe5d5
--- /dev/null
+++ b/test/AStar.Dev.Functional.Extensions.Tests.Unit/OptionShould.cs
@@ -0,0 +1,13 @@
+using JetBrains.Annotations;
+
+namespace AStar.Dev.Functional.Extensions.Tests.Unit;
+
+[TestSubject(typeof(Option<>))]
+public class OptionShould
+{
+    [Fact]
+    public void OverrideToStringForSome() => Option.Some("Test Text").ToString().ShouldBe("Some(Test Text)");
+
+    [Fact]
+    public void OverrideToStringForNone() => Option.None<string>().ToString().ShouldBe("None");
+}
diff --git a/test/AStar.Dev.Functional.Extensions.Tests.Unit/OptionToResultTests.cs b/test/AStar.Dev.Functional.Extensions.Tests.Unit/OptionToResultTests.cs
new file mode 100644
index 0000000..7c3f492
--- /dev/null
+++ b/test/AStar.Dev.Functional.Extensions.Tests.Unit/OptionToResultTests.cs
@@ -0,0 +1,20 @@
+namespace AStar.Dev.Functional.Extensions.Tests.Unit;
+
+public class OptionToResultTests
+{
+    [Fact]
+    public void ToResult_FromSome_ReturnsOk()
+    {
+        var opt    = new Option<int>.Some(42);
+        var result = opt.ToResult(() => "missing");
+        Assert.True(result is Result<int, string>.Ok ok && ok.Value == 42);
+    }
+
+    [Fact]
+    public void ToResult_FromNone_ReturnsError()
+    {
+        var opt    =  Option.None<int>();
+        var result = opt.ToResult(() => "missing");
+        Assert.True(result is Result<int, string>.Error err && err.Reason == "missing");
+    }
+}
diff --git a/test/AStar.Dev.Functional.Extensions.Tests.Unit/PatternTests.cs b/test/AStar.Dev.Functional.Extensions.Tests.Unit/PatternTests.cs
new file mode 100644
index 0000000..c18b66a
--- /dev/null
+++ b/test/AStar.Dev.Functional.Extensions.Tests.Unit/PatternTests.cs
@@ -0,0 +1,43 @@
+namespace AStar.Dev.Functional.Extensions.Tests.Unit;
+
+public class PatternTests
+{
+    [Fact]
+    public void IsSome_And_IsNone_WorkCorrectly()
+    {
+        Option<string> some = new Option<string>.Some("value");
+        var            none =  Option.None<string>();
+
+        Assert.True(Pattern.IsSome(some));
+        Assert.False(Pattern.IsNone(some));
+
+        Assert.True(Pattern.IsNone(none));
+        Assert.False(Pattern.IsSome(none));
+    }
+
+    [Fact]
+    public void IsOk_And_IsError_WorkCorrectly()
+    {
+        Result<int, string> ok  = new Result<int, string>.Ok(1);
+        Result<int, string> err = new Result<int, string>.Error("fail");
+
+        Assert.True(Pattern.IsOk(ok));
+        Assert.False(Pattern.IsError(ok));
+
+        Assert.True(Pattern.IsError(err));
+        Assert.False(Pattern.IsOk(err));
+    }
+
+    [Fact]
+    public void IsSuccess_And_IsFailure_WorkCorrectly()
+    {
+        var success = Try<int>.Run(() => 1);
+        var failure = Try<int>.Run(() => throw new ArgumentNullException("fail"));
+
+        Assert.True(Pattern.IsSuccess(success));
+        Assert.False(Pattern.IsFailure(success));
+
+        Assert.True(Pattern.IsFailure(failure));
+        Assert.False(Pattern.IsSuccess(failure));
+    }
+}
diff --git a/test/AStar.Dev.Functional.Extensions.Tests.Unit/ResultAsyncLinqExtensionsTests.cs b/test/AStar.Dev.Functional.Extensions.Tests.Unit/ResultAsyncLinqExtensionsTests.cs
new file mode 100644
index 0000000..d932513
--- /dev/null
+++ b/test/AStar.Dev.Functional.Extensions.Tests.Unit/ResultAsyncLinqExtensionsTests.cs
@@ -0,0 +1,53 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace AStar.Dev.Functional.Extensions.Tests.Unit;
+
+[SuppressMessage("Reliability", "CA2012:Use ValueTasks correctly")]
+public class ResultAsyncLinqExtensionsTests
+{
+    private static Result<int, string>.Ok Ok(int        value) => new(value);
+
+    private static Result<int, string>.Error Err(string error) => new(error);
+
+    [Fact]
+    public async Task AsyncLinq_ComposesCorrectly()
+    {
+        var result = from a in new ValueTask<Result<int, string>>(Ok(2))
+                     from b in new ValueTask<Result<int, string>>(Ok(3))
+                     select a + b;
+
+        var output = await result.MatchAsync(
+                                             success => success,
+                                             error => -1);
+
+        Assert.Equal(5, output);
+    }
+
+    [Fact]
+    public async Task AsyncLinq_PropagatesOuterError()
+    {
+        var result = from a in new ValueTask<Result<int, string>>(Err("outer"))
+                     from b in new ValueTask<Result<int, string>>(Ok(3))
+                     select a + b;
+
+        var output = await result.MatchAsync(
+                                             success => success,
+                                             error => -1);
+
+        Assert.Equal(-1, output);
+    }
+
+    [Fact]
+    public async Task AsyncLinq_PropagatesInnerError()
+    {
+        var result = from a in new ValueTask<Result<int, string>>(Ok(2))
+                     from b in new ValueTask<Result<int, string>>(Err("inner"))
+                     select a + b;
+
+        var output = await result.MatchAsync(
+                                             success => success,
+                                             error => -1);
+
+        Assert.Equal(-1, output);
+    }
+}
diff --git a/test/AStar.Dev.Functional.Extensions.Tests.Unit/ResultLinqExtensionsTests.cs b/test/AStar.Dev.Functional.Extensions.Tests.Unit/ResultLinqExtensionsTests.cs
new file mode 100644
index 0000000..3ef512a
--- /dev/null
+++ b/test/AStar.Dev.Functional.Extensions.Tests.Unit/ResultLinqExtensionsTests.cs
@@ -0,0 +1,108 @@
+namespace AStar.Dev.Functional.Extensions.Tests.Unit;
+
+public class ResultLinqExtensionsTests
+{
+    private static Result<int, string>.Ok Ok(int        value) => new(value);
+
+    private static Result<int, string>.Error Err(string error) => new(error);
+
+    [Fact]
+    public void Select_MapsSuccess()
+    {
+        var result = Ok(10).Select(x => x + 5);
+
+        var output = result.Match(
+                                  success => success,
+                                  error => -1);
+
+        Assert.Equal(15, output);
+    }
+
+    [Fact]
+    public void Select_PreservesError()
+    {
+        var result = Err("fail").Select(x => x + 5);
+
+        var output = result.Match(
+                                  success => success,
+                                  error => -1);
+
+        Assert.Equal(-1, output);
+    }
+
+    [Fact]
+    public void SelectMany_BindsSuccess()
+    {
+        Result<int, string> Double(int x)
+        {
+            return Ok(x * 2);
+        }
+
+        var result = Ok(3).SelectMany(Double);
+
+        var output = result.Match(
+                                  success => success,
+                                  error => -1);
+
+        Assert.Equal(6, output);
+    }
+
+    [Fact]
+    public void SelectMany_ShortCircuitsOnError()
+    {
+        Result<int, string> Double(int x)
+        {
+            return Ok(x * 2);
+        }
+
+        var result = Err("fail").SelectMany(Double);
+
+        var output = result.Match(
+                                  success => success,
+                                  error => -1);
+
+        Assert.Equal(-1, output);
+    }
+
+    [Fact]
+    public void SelectMany_WithProjection_ComposesCorrectly()
+    {
+        var result = Ok(2).SelectMany(
+                                      a => Ok(3),
+                                      (a, b) => a + b);
+
+        var output = result.Match(
+                                  success => success,
+                                  error => -1);
+
+        Assert.Equal(5, output);
+    }
+
+    [Fact]
+    public void SelectMany_WithProjection_PropagatesOuterError()
+    {
+        var result = Err("outer").SelectMany(
+                                             a => Ok(3),
+                                             (a, b) => a + b);
+
+        var output = result.Match(
+                                  success => success,
+                                  error => -1);
+
+        Assert.Equal(-1, output);
+    }
+
+    [Fact]
+    public void SelectMany_WithProjection_PropagatesInnerError()
+    {
+        var result = Ok(2).SelectMany(
+                                      a => Err("inner"),
+                                      (a, b) => a + b);
+
+        var output = result.Match(
+                                  success => success,
+                                  error => -1);
+
+        Assert.Equal(-1, output);
+    }
+}
diff --git a/test/AStar.Dev.Functional.Extensions.Tests.Unit/ResultShould.cs b/test/AStar.Dev.Functional.Extensions.Tests.Unit/ResultShould.cs
new file mode 100644
index 0000000..2248007
--- /dev/null
+++ b/test/AStar.Dev.Functional.Extensions.Tests.Unit/ResultShould.cs
@@ -0,0 +1,157 @@
+namespace AStar.Dev.Functional.Extensions.Tests.Unit;
+
+public class ResultShould
+{
+    private static Result<int, string>.Ok Ok(int value) => new(value);
+
+    private static Result<int, string>.Error Err(string error) => new(error);
+
+    [Fact]
+    public void Match_ReturnsCorrectBranch()
+    {
+        var ok  = Ok(42);
+        var err = Err("fail");
+
+        var okResult = ok.Match(
+                                success => $"Success: {success}",
+                                error => $"Error: {error}");
+
+        var errResult = err.Match(
+                                  success => $"Success: {success}",
+                                  error => $"Error: {error}");
+
+        Assert.Equal("Success: 42", okResult);
+        Assert.Equal("Error: fail", errResult);
+    }
+
+    [Fact]
+    public void Map_TransformsSuccess()
+    {
+        var result = Ok(10).Map(x => x * 2);
+
+        var output = result.Match(
+                                  success => success,
+                                  error => -1);
+
+        Assert.Equal(20, output);
+    }
+
+    [Fact]
+    public void Map_PreservesError()
+    {
+        var result = Err("oops").Map(x => x * 2);
+
+        var output = result.Match(
+                                  success => success,
+                                  error => -1);
+
+        Assert.Equal(-1, output);
+    }
+
+    [Fact]
+    public void Bind_ChainsSuccess()
+    {
+        Result<int, string> DoubleIfEven(int x)
+        {
+            return x % 2 == 0 ? Ok(x * 2) : Err("odd");
+        }
+
+        var result = Ok(4).Bind(DoubleIfEven);
+
+        var output = result.Match(
+                                  success => success,
+                                  error => -1);
+
+        Assert.Equal(8, output);
+    }
+
+    [Fact]
+    public void Bind_ShortCircuitsOnError()
+    {
+        var result = Err("fail").Bind(x => Ok(x * 2));
+
+        var output = result.Match(
+                                  success => success,
+                                  error => -1);
+
+        Assert.Equal(-1, output);
+    }
+
+    [Fact]
+    public void Tap_InvokesSideEffectOnSuccess()
+    {
+        var tapped = 0;
+        var result = Ok(5).Tap(x => tapped = x);
+        Assert.Equal(5, tapped);
+    }
+
+    [Fact]
+    public void Tap_DoesNotInvokeOnError()
+    {
+        var tapped = 0;
+        var result = Err("fail").Tap(x => tapped = x);
+        Assert.Equal(0, tapped);
+    }
+
+    [Fact]
+    public void Linq_Query_ComposesCorrectly()
+    {
+        var result = from a in Ok(2)
+                     from b in Ok(3)
+                     select a + b;
+
+        var output = result.Match(
+                                  success => success,
+                                  error => -1);
+
+        Assert.Equal(5, output);
+    }
+
+    [Fact]
+    public async Task MapAsync_TransformsSuccess()
+    {
+        var result = await new ValueTask<Result<int, string>>(Ok(3))
+                         .MapAsync(x => x + 1);
+
+        var output = result.Match(
+                                  success => success,
+                                  error => -1);
+
+        Assert.Equal(4, output);
+    }
+
+    [Fact]
+    public async Task BindAsync_ChainsAsyncResults()
+    {
+        ValueTask<Result<int, string>> DoubleAsync(int x)
+        {
+            return new(new Result<int, string>.Ok(x * 2));
+        }
+
+        var result = await new ValueTask<Result<int, string>>(Ok(5))
+                         .BindAsync(DoubleAsync);
+
+        var output = result.Match(
+                                  success => success,
+                                  error => -1);
+
+        Assert.Equal(10, output);
+    }
+
+    [Fact]
+    public async Task MatchAsync_HandlesBothBranches()
+    {
+        var ok = await new ValueTask<Result<int, string>>(Ok(7))
+                     .MatchAsync(
+                                 success => $"Yay: {success}",
+                                 error => $"Oops: {error}");
+
+        var err = await new ValueTask<Result<int, string>>(Err("bad"))
+                      .MatchAsync(
+                                  success => $"Yay: {success}",
+                                  error => $"Oops: {error}");
+
+        Assert.Equal("Yay: 7",    ok);
+        Assert.Equal("Oops: bad", err);
+    }
+}
diff --git a/test/AStar.Dev.Functional.Extensions.Tests.Unit/TryTests.cs b/test/AStar.Dev.Functional.Extensions.Tests.Unit/TryTests.cs
new file mode 100644
index 0000000..3ec2123
--- /dev/null
+++ b/test/AStar.Dev.Functional.Extensions.Tests.Unit/TryTests.cs
@@ -0,0 +1,41 @@
+namespace AStar.Dev.Functional.Extensions.Tests.Unit;
+
+public class TryTests
+{
+    [Fact]
+    public void Try_Run_CapturesSuccess()
+    {
+        var result = Try<int>.Run(() => 42);
+
+        var output = result.Match(
+                                  ok => ok,
+                                  ex => -1);
+
+        Assert.Equal(42, output);
+    }
+
+    [Fact]
+    public void Try_Run_CapturesException()
+    {
+        var result = Try<int>.Run(() => throw new InvalidOperationException("fail"));
+
+        var output = result.Match(
+                                  ok => ok,
+                                  ex => -1);
+
+        Assert.Equal(-1, output);
+    }
+
+    [Fact]
+    public void Try_Match_ReturnsCorrectBranch()
+    {
+        var success = Try<string>.Run(() => "done");
+        var failure = Try<string>.Run(() => throw new InvalidOperationException("fail"));
+
+        var a = success.Match(x => $"OK: {x}", ex => $"ERR: {ex.Message}");
+        var b = failure.Match(x => $"OK: {x}", ex => $"ERR: {ex.Message}");
+
+        Assert.Equal("OK: done",                              a);
+        Assert.Equal("ERR: fail", b);
+    }
+}

From 1ad11cb79f41e980e43070c5401b13b71a352dbf Mon Sep 17 00:00:00 2001
From: Jason Barden <jason.barden@outlook.com>
Date: Sat, 2 Aug 2025 01:31:43 +0100
Subject: [PATCH 4/4] Add the utilities and associated tests from the main
 solution

---
 AStar.Dev.Testing.Dashboard.sln               |  14 +
 .../ErrorResponse.cs                          |  13 +
 .../AStar.Dev.Testing.Dashboard.Server.csproj |   4 +
 .../AStar.Dev.Utilities.csproj                |  54 +++
 .../AStar.Dev.Utilities.xml                   | 335 ++++++++++++++++++
 src/AStar.Dev.Utilities/Constants.cs          |  15 +
 .../EncryptionExtensions.cs                   |  77 ++++
 src/AStar.Dev.Utilities/EnumExtensions.cs     |  16 +
 src/AStar.Dev.Utilities/LICENSE               |  21 ++
 src/AStar.Dev.Utilities/ObjectExtensions.cs   |  21 ++
 src/AStar.Dev.Utilities/Readme.md             |   1 +
 src/AStar.Dev.Utilities/RegexExtensions.cs    |  48 +++
 src/AStar.Dev.Utilities/StringExtensions.cs   |  92 +++++
 src/AStar.Dev.Utilities/astar.ico             | Bin 0 -> 16958 bytes
 src/AStar.Dev.Utilities/astar.png             | Bin 0 -> 15984 bytes
 .../AStar.Dev.Utilities.Tests.Unit.csproj     |  49 +++
 .../AnyClass.cs                               |   8 +
 .../AStar.Dev.Utilities.Tests.Unit/AnyEnum.cs |   7 +
 ...eserialisationSettingsSetting.approved.txt |  31 ++
 .../ConstantsShould.cs                        |  10 +
 .../EnumExtensionsShould.cs                   |  16 +
 ...WhichReturnsTheExpectedString.approved.txt |   4 +
 .../ObjectExtensionsShould.cs                 |  10 +
 .../StringExtensionsShould.cs                 |  33 ++
 24 files changed, 879 insertions(+)
 create mode 100644 src/AStar.Dev.Functional.Extensions/ErrorResponse.cs
 create mode 100644 src/AStar.Dev.Utilities/AStar.Dev.Utilities.csproj
 create mode 100644 src/AStar.Dev.Utilities/AStar.Dev.Utilities.xml
 create mode 100644 src/AStar.Dev.Utilities/Constants.cs
 create mode 100644 src/AStar.Dev.Utilities/EncryptionExtensions.cs
 create mode 100644 src/AStar.Dev.Utilities/EnumExtensions.cs
 create mode 100644 src/AStar.Dev.Utilities/LICENSE
 create mode 100644 src/AStar.Dev.Utilities/ObjectExtensions.cs
 create mode 100644 src/AStar.Dev.Utilities/Readme.md
 create mode 100644 src/AStar.Dev.Utilities/RegexExtensions.cs
 create mode 100644 src/AStar.Dev.Utilities/StringExtensions.cs
 create mode 100644 src/AStar.Dev.Utilities/astar.ico
 create mode 100644 src/AStar.Dev.Utilities/astar.png
 create mode 100644 test/AStar.Dev.Utilities.Tests.Unit/AStar.Dev.Utilities.Tests.Unit.csproj
 create mode 100644 test/AStar.Dev.Utilities.Tests.Unit/AnyClass.cs
 create mode 100644 test/AStar.Dev.Utilities.Tests.Unit/AnyEnum.cs
 create mode 100644 test/AStar.Dev.Utilities.Tests.Unit/ConstantsShould.ContainTheExpectedWebDeserialisationSettingsSetting.approved.txt
 create mode 100644 test/AStar.Dev.Utilities.Tests.Unit/ConstantsShould.cs
 create mode 100644 test/AStar.Dev.Utilities.Tests.Unit/EnumExtensionsShould.cs
 create mode 100644 test/AStar.Dev.Utilities.Tests.Unit/ObjectExtensionsShould.ContainTheToJsonMethodWhichReturnsTheExpectedString.approved.txt
 create mode 100644 test/AStar.Dev.Utilities.Tests.Unit/ObjectExtensionsShould.cs
 create mode 100644 test/AStar.Dev.Utilities.Tests.Unit/StringExtensionsShould.cs

diff --git a/AStar.Dev.Testing.Dashboard.sln b/AStar.Dev.Testing.Dashboard.sln
index b617dfe..7337163 100644
--- a/AStar.Dev.Testing.Dashboard.sln
+++ b/AStar.Dev.Testing.Dashboard.sln
@@ -25,6 +25,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AStar.Dev.Functional.Extens
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AStar.Dev.Functional.Extensions.Tests.Unit", "test\AStar.Dev.Functional.Extensions.Tests.Unit\AStar.Dev.Functional.Extensions.Tests.Unit.csproj", "{4DB946D7-421E-4602-9D75-3DD5CA64F1F1}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AStar.Dev.Utilities.Tests.Unit", "test\AStar.Dev.Utilities.Tests.Unit\AStar.Dev.Utilities.Tests.Unit.csproj", "{3E3708D2-28A5-4B08-8750-E0FC995FF9A8}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AStar.Dev.Utilities", "src\AStar.Dev.Utilities\AStar.Dev.Utilities.csproj", "{1E48615F-F35C-4932-A4D8-456510B6172E}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -55,6 +59,14 @@ Global
 		{4DB946D7-421E-4602-9D75-3DD5CA64F1F1}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{4DB946D7-421E-4602-9D75-3DD5CA64F1F1}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{4DB946D7-421E-4602-9D75-3DD5CA64F1F1}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3E3708D2-28A5-4B08-8750-E0FC995FF9A8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3E3708D2-28A5-4B08-8750-E0FC995FF9A8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3E3708D2-28A5-4B08-8750-E0FC995FF9A8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3E3708D2-28A5-4B08-8750-E0FC995FF9A8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{1E48615F-F35C-4932-A4D8-456510B6172E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1E48615F-F35C-4932-A4D8-456510B6172E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1E48615F-F35C-4932-A4D8-456510B6172E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1E48615F-F35C-4932-A4D8-456510B6172E}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{FC3B1F57-9BAD-4928-B155-74A76E687852} = {06382787-BE50-4C3B-A709-57FA0B6EAADE}
@@ -65,5 +77,7 @@ Global
 		{6060F8F6-FDAC-4379-81D3-8A3CA0627F47} = {F33B86B1-5AC4-403B-A30D-E65848BA0FE6}
 		{F83287F8-9CB1-4B20-A469-2D58DADAC9DC} = {06382787-BE50-4C3B-A709-57FA0B6EAADE}
 		{4DB946D7-421E-4602-9D75-3DD5CA64F1F1} = {F33B86B1-5AC4-403B-A30D-E65848BA0FE6}
+		{3E3708D2-28A5-4B08-8750-E0FC995FF9A8} = {F33B86B1-5AC4-403B-A30D-E65848BA0FE6}
+		{1E48615F-F35C-4932-A4D8-456510B6172E} = {06382787-BE50-4C3B-A709-57FA0B6EAADE}
 	EndGlobalSection
 EndGlobal
diff --git a/src/AStar.Dev.Functional.Extensions/ErrorResponse.cs b/src/AStar.Dev.Functional.Extensions/ErrorResponse.cs
new file mode 100644
index 0000000..689f113
--- /dev/null
+++ b/src/AStar.Dev.Functional.Extensions/ErrorResponse.cs
@@ -0,0 +1,13 @@
+namespace AStar.Dev.Functional.Extensions;
+
+/// <summary>
+///
+/// </summary>
+/// <param name="Message"></param>
+public class ErrorResponse
+{
+    /// <summary>
+    /// Represents the message associated with an error response.
+    /// </summary>
+    public string Message { get; set; } = string.Empty;
+}
diff --git a/src/AStar.Dev.Testing.Dashboard.Server/AStar.Dev.Testing.Dashboard.Server.csproj b/src/AStar.Dev.Testing.Dashboard.Server/AStar.Dev.Testing.Dashboard.Server.csproj
index f1befcf..6c79a25 100644
--- a/src/AStar.Dev.Testing.Dashboard.Server/AStar.Dev.Testing.Dashboard.Server.csproj
+++ b/src/AStar.Dev.Testing.Dashboard.Server/AStar.Dev.Testing.Dashboard.Server.csproj
@@ -12,4 +12,8 @@
         <PackageReference Include="Swashbuckle.AspNetCore.SwaggerUI" Version="9.0.3"/>
     </ItemGroup>
 
+    <ItemGroup>
+      <ProjectReference Include="..\AStar.Dev.Functional.Extensions\AStar.Dev.Functional.Extensions.csproj" />
+    </ItemGroup>
+
 </Project>
diff --git a/src/AStar.Dev.Utilities/AStar.Dev.Utilities.csproj b/src/AStar.Dev.Utilities/AStar.Dev.Utilities.csproj
new file mode 100644
index 0000000..3fbc290
--- /dev/null
+++ b/src/AStar.Dev.Utilities/AStar.Dev.Utilities.csproj
@@ -0,0 +1,54 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net9.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <Title>AStar Dev Utilities</Title>
+        <Company>AStar Development</Company>
+        <Copyright>AStar Development, 2024</Copyright>
+        <PackageReadmeFile>Readme.md</PackageReadmeFile>
+        <IncludeSymbols>True</IncludeSymbols>
+        <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+        <GenerateDocumentationFile>True</GenerateDocumentationFile>
+        <RepositoryUrl>https://github.com/astar-development/astar-dev-utilities.git</RepositoryUrl>
+        <RepositoryType>git</RepositoryType>
+        <PackageProjectUrl>https://github.com/astar-development/astar-dev-utilities</PackageProjectUrl>
+        <Description>A collection of useful utilities that do not fit within any of the other, more targeted, AStar NuGet packages.</Description>
+        <Version>1.6.0</Version>
+        <Authors>AStar Development, Jason Barden</Authors>
+        <RepositoryType>git</RepositoryType>
+        <IncludeSymbols>True</IncludeSymbols>
+        <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+        <PackageReadmeFile>Readme.md</PackageReadmeFile>
+        <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
+        <PackageLicenseFile>LICENSE</PackageLicenseFile>
+        <DocumentationFile>$(AssemblyName).xml</DocumentationFile>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <None Include="LICENSE" Pack="true" PackagePath=""/>
+        <None Include="Readme.md" Pack="true" PackagePath=""/>
+    </ItemGroup>
+
+    <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+        <TreatWarningsAsErrors>True</TreatWarningsAsErrors>
+        <NoWarn>1701;1702;</NoWarn>
+    </PropertyGroup>
+
+    <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+        <TreatWarningsAsErrors>True</TreatWarningsAsErrors>
+        <NoWarn>1701;1702;</NoWarn>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <None Update="AStar.png">
+            <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+        </None>
+    </ItemGroup>
+
+    <ItemGroup>
+
+    </ItemGroup>
+
+</Project>
diff --git a/src/AStar.Dev.Utilities/AStar.Dev.Utilities.xml b/src/AStar.Dev.Utilities/AStar.Dev.Utilities.xml
new file mode 100644
index 0000000..cb71429
--- /dev/null
+++ b/src/AStar.Dev.Utilities/AStar.Dev.Utilities.xml
@@ -0,0 +1,335 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>AStar.Dev.Utilities</name>
+    </assembly>
+    <members>
+        <member name="T:AStar.Dev.Utilities.Constants">
+            <summary>
+                The <see href="Constants"></see>see> class contains static / constant properties to simplify and centralise various
+                settings
+            </summary>
+        </member>
+        <member name="P:AStar.Dev.Utilities.Constants.WebDeserialisationSettings">
+            <summary>
+                Returns an instance of <see href="JsonSerializerOptions"></see> configured with the Web defaults
+            </summary>
+        </member>
+        <member name="T:AStar.Dev.Utilities.EncryptionExtensions">
+            <summary>
+                The <see cref="T:AStar.Dev.Utilities.EncryptionExtensions" /> class contains extension methods to encrypt / decrypt the specified string
+            </summary>
+        </member>
+        <member name="M:AStar.Dev.Utilities.EncryptionExtensions.Encrypt(System.String,System.String,System.String)">
+            <summary>
+                The Encrypt extension method will encrypt the specified string (using AES encryption)
+            </summary>
+            <param name="plainText">The string to encrypt</param>
+            <param name="key">
+                The optional key to use for the encryption. If supplied, it must be 16, 24, or 32 bytes long. If not
+                specified, an internal default (32 bytes) will be used
+            </param>
+            <param name="iv">
+                The optional iv (initialisation vector) to use for the decryption. If supplied, it must be 16 bytes
+                long. If not specified, an internal default will be used
+            </param>
+            <returns>The original string encrypted appropriately</returns>
+        </member>
+        <member name="M:AStar.Dev.Utilities.EncryptionExtensions.Decrypt(System.String,System.String,System.String)">
+            <summary>
+                The Decrypt extension method will encrypt the specified string (using AES encryption)
+            </summary>
+            <param name="encryptedText">The string to decrypt</param>
+            <param name="key">
+                The optional key to use for the encryption. If supplied, it must be 16, 24, or 32 bytes long. If not
+                specified, an internal default (32 bytes) will be used
+            </param>
+            <param name="iv">
+                The optional iv (initialisation vector) to use for the decryption. If supplied, it must be 16 bytes
+                long. If not specified, an internal default will be used
+            </param>
+            <returns>The decrypted string</returns>
+        </member>
+        <member name="T:AStar.Dev.Utilities.EnumExtensions">
+            <summary>
+            </summary>
+        </member>
+        <member name="M:AStar.Dev.Utilities.EnumExtensions.ParseEnum``1(System.String)">
+            <summary>
+                The ParseEnum method will parse the supplied string and return the matching enum value
+            </summary>
+            <typeparam name="T">The typeof of the expected enum</typeparam>
+            <param name="value">The value to parse to the enum</param>
+            <returns>The parsed value as the matching enum value</returns>
+            <exception cref="T:System.ArgumentException">Thrown when the string is not a valid enum value</exception>
+        </member>
+        <member name="T:AStar.Dev.Utilities.ObjectExtensions">
+            <summary>
+                The <see cref="T:AStar.Dev.Utilities.ObjectExtensions" /> class contains some useful methods to enable various tasks
+                to be performed in a more fluid, English sentence, style
+            </summary>
+        </member>
+        <member name="M:AStar.Dev.Utilities.ObjectExtensions.ToJson``1(``0)">
+            <summary>
+                The ToJson method, as you might expect, converts the supplied object to its JSON equivalent (using the
+                JsonSerializerDefaults.Web defaults with WriteIndented set to true)
+            </summary>
+            <param name="object">The object to convert to JSON</param>
+            <returns>The JSON string of the object supplied</returns>
+        </member>
+        <member name="T:AStar.Dev.Utilities.RegexExtensions">
+            <summary>
+            </summary>
+        </member>
+        <member name="M:AStar.Dev.Utilities.RegexExtensions.ContainsAtLeastOneLowercaseLetter(System.String)">
+            <summary>
+            </summary>
+            <param name="value"></param>
+            <returns></returns>
+        </member>
+        <member name="M:AStar.Dev.Utilities.RegexExtensions.ContainsAtLeastOneUppercaseLetter(System.String)">
+            <summary>
+            </summary>
+            <param name="value"></param>
+            <returns></returns>
+        </member>
+        <member name="M:AStar.Dev.Utilities.RegexExtensions.ContainsAtLeastOneDigit(System.String)">
+            <summary>
+            </summary>
+            <param name="value"></param>
+            <returns></returns>
+        </member>
+        <member name="M:AStar.Dev.Utilities.RegexExtensions.ContainsAtLeastOneSpecialCharacter(System.String)">
+            <summary>
+            </summary>
+            <param name="value"></param>
+            <returns></returns>
+        </member>
+        <member name="M:AStar.Dev.Utilities.RegexExtensions.LowercaseLettersRegex">
+            <remarks>
+            Pattern:<br/>
+            <code>^[a-z]+$</code><br/>
+            Options:<br/>
+            <code>RegexOptions.CultureInvariant</code><br/>
+            Explanation:<br/>
+            <code>
+            ○ Match if at the beginning of the string.<br/>
+            ○ Match a character in the set [a-z] atomically at least once.<br/>
+            ○ Match if at the end of the string or if before an ending newline.<br/>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:AStar.Dev.Utilities.RegexExtensions.UppercaseLettersRegex">
+            <remarks>
+            Pattern:<br/>
+            <code>^[A-Z]+$</code><br/>
+            Options:<br/>
+            <code>RegexOptions.CultureInvariant</code><br/>
+            Explanation:<br/>
+            <code>
+            ○ Match if at the beginning of the string.<br/>
+            ○ Match a character in the set [A-Z] atomically at least once.<br/>
+            ○ Match if at the end of the string or if before an ending newline.<br/>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:AStar.Dev.Utilities.RegexExtensions.DigitRegex">
+            <remarks>
+            Pattern:<br/>
+            <code>^[A-Z]+$</code><br/>
+            Options:<br/>
+            <code>RegexOptions.CultureInvariant</code><br/>
+            Explanation:<br/>
+            <code>
+            ○ Match if at the beginning of the string.<br/>
+            ○ Match a character in the set [A-Z] atomically at least once.<br/>
+            ○ Match if at the end of the string or if before an ending newline.<br/>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:AStar.Dev.Utilities.RegexExtensions.SpecialCharacterRegex">
+            <remarks>
+            Pattern:<br/>
+            <code>[!-\\/:-@[-`{-~]</code><br/>
+            Options:<br/>
+            <code>RegexOptions.CultureInvariant</code><br/>
+            Explanation:<br/>
+            <code>
+            ○ Match a character in the set [!-/:-@[-`{-~].<br/>
+            </code>
+            </remarks>
+        </member>
+        <member name="T:AStar.Dev.Utilities.StringExtensions">
+            <summary>
+                The <see cref="T:AStar.Dev.Utilities.StringExtensions" /> class contains some useful methods to enable checks to be
+                performed in a more fluid, English sentence, style
+            </summary>
+        </member>
+        <member name="M:AStar.Dev.Utilities.StringExtensions.IsNull(System.String)">
+            <summary>
+                The IsNull method, as you might expect, checks whether the string is, in fact, null
+            </summary>
+            <param name="value">The string to check for being null</param>
+            <returns>True if the string is null, False otherwise</returns>
+        </member>
+        <member name="M:AStar.Dev.Utilities.StringExtensions.IsNotNull(System.String)">
+            <summary>
+                The IsNotNull method, as you might expect, checks whether the string is not null
+            </summary>
+            <param name="value">The string to check for being not null</param>
+            <returns>True if the string is not null, False otherwise</returns>
+        </member>
+        <member name="M:AStar.Dev.Utilities.StringExtensions.IsNullOrWhiteSpace(System.String)">
+            <summary>
+                The IsNullOrWhiteSpace method, as you might expect, checks whether the string is, in fact, null, empty or
+                whitespace
+            </summary>
+            <param name="value">The string to check for being null, empty or whitespace</param>
+            <returns>True if the string is null, empty or whitespace, False otherwise</returns>
+        </member>
+        <member name="M:AStar.Dev.Utilities.StringExtensions.IsNotNullOrWhiteSpace(System.String)">
+            <summary>
+                The IsNotNullOrWhiteSpace method, as you might expect, checks whether the string is not null, empty or whitespace
+            </summary>
+            <param name="value">The string to check for being not null, empty or whitespace</param>
+            <returns>True if the string is not null, empty or whitespace, False otherwise</returns>
+        </member>
+        <member name="M:AStar.Dev.Utilities.StringExtensions.FromJson``1(System.String)">
+            <summary>
+                The FromJson method, as you might expect, converts the supplied JSON to the specified object
+            </summary>
+            <typeparam name="T">The required type of the object to deserialise to</typeparam>
+            <param name="json">The JSON representation of the object</param>
+            <returns>A deserialised object based on the original JSON</returns>
+        </member>
+        <member name="M:AStar.Dev.Utilities.StringExtensions.FromJson``1(System.String,System.Text.Json.JsonSerializerOptions)">
+            <summary>
+                The FromJson method, as you might expect, converts the supplied JSON to the specified object
+            </summary>
+            <typeparam name="T">The required type of the object to deserialise to</typeparam>
+            <param name="json">The JSON representation of the object</param>
+            <param name="options">
+                Allows the specific <see href="JsonSerializerOptions">options</see> to be set to control
+                deserialisation
+            </param>
+            <returns>A deserialised object based on the original JSON</returns>
+        </member>
+        <member name="M:AStar.Dev.Utilities.StringExtensions.IsImage(System.String)">
+            <summary>
+            </summary>
+            <param name="fileName"></param>
+            <returns></returns>
+        </member>
+        <member name="M:AStar.Dev.Utilities.StringExtensions.IsNumberOnly(System.String)">
+            <summary>
+            </summary>
+            <param name="fileName"></param>
+            <returns></returns>
+        </member>
+        <member name="M:AStar.Dev.Utilities.StringExtensions.TruncateIfRequired(System.String,System.Int32)">
+            <summary>
+                The TruncateIfRequired method will, as the name suggests, truncate the string if the length exceeds the specified length
+            </summary>
+            <param name="value">The raw string to potentially truncate</param>
+            <param name="truncateLenght">The maximum length the string should be truncated to if required</param>
+            <returns>The specified string or the truncated version</returns>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.LowercaseLettersRegex_0">
+            <summary>Custom <see cref="T:System.Text.RegularExpressions.Regex"/>-derived type for the LowercaseLettersRegex method.</summary>
+        </member>
+        <member name="F:System.Text.RegularExpressions.Generated.LowercaseLettersRegex_0.Instance">
+            <summary>Cached, thread-safe singleton instance.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.LowercaseLettersRegex_0.#ctor">
+            <summary>Initializes the instance.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.LowercaseLettersRegex_0.RunnerFactory">
+            <summary>Provides a factory for creating <see cref="T:System.Text.RegularExpressions.RegexRunner"/> instances to be used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.LowercaseLettersRegex_0.RunnerFactory.CreateInstance">
+            <summary>Creates an instance of a <see cref="T:System.Text.RegularExpressions.RegexRunner"/> used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.LowercaseLettersRegex_0.RunnerFactory.Runner">
+            <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.LowercaseLettersRegex_0.RunnerFactory.Runner.Scan(System.ReadOnlySpan{System.Char})">
+            <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.LowercaseLettersRegex_0.RunnerFactory.Runner.TryFindNextPossibleStartingPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if a possible match was found; false if no more matches are possible.</returns>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.LowercaseLettersRegex_0.RunnerFactory.Runner.TryMatchAtCurrentPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.UppercaseLettersRegex_1">
+            <summary>Custom <see cref="T:System.Text.RegularExpressions.Regex"/>-derived type for the UppercaseLettersRegex method.</summary>
+        </member>
+        <member name="F:System.Text.RegularExpressions.Generated.UppercaseLettersRegex_1.Instance">
+            <summary>Cached, thread-safe singleton instance.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.UppercaseLettersRegex_1.#ctor">
+            <summary>Initializes the instance.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.UppercaseLettersRegex_1.RunnerFactory">
+            <summary>Provides a factory for creating <see cref="T:System.Text.RegularExpressions.RegexRunner"/> instances to be used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.UppercaseLettersRegex_1.RunnerFactory.CreateInstance">
+            <summary>Creates an instance of a <see cref="T:System.Text.RegularExpressions.RegexRunner"/> used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.UppercaseLettersRegex_1.RunnerFactory.Runner">
+            <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.UppercaseLettersRegex_1.RunnerFactory.Runner.Scan(System.ReadOnlySpan{System.Char})">
+            <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.UppercaseLettersRegex_1.RunnerFactory.Runner.TryFindNextPossibleStartingPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if a possible match was found; false if no more matches are possible.</returns>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.UppercaseLettersRegex_1.RunnerFactory.Runner.TryMatchAtCurrentPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.SpecialCharacterRegex_2">
+            <summary>Custom <see cref="T:System.Text.RegularExpressions.Regex"/>-derived type for the SpecialCharacterRegex method.</summary>
+        </member>
+        <member name="F:System.Text.RegularExpressions.Generated.SpecialCharacterRegex_2.Instance">
+            <summary>Cached, thread-safe singleton instance.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.SpecialCharacterRegex_2.#ctor">
+            <summary>Initializes the instance.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.SpecialCharacterRegex_2.RunnerFactory">
+            <summary>Provides a factory for creating <see cref="T:System.Text.RegularExpressions.RegexRunner"/> instances to be used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.SpecialCharacterRegex_2.RunnerFactory.CreateInstance">
+            <summary>Creates an instance of a <see cref="T:System.Text.RegularExpressions.RegexRunner"/> used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.SpecialCharacterRegex_2.RunnerFactory.Runner">
+            <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.SpecialCharacterRegex_2.RunnerFactory.Runner.Scan(System.ReadOnlySpan{System.Char})">
+            <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.SpecialCharacterRegex_2.RunnerFactory.Runner.TryFindNextPossibleStartingPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if a possible match was found; false if no more matches are possible.</returns>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.Utilities">
+            <summary>Helper methods used by generated <see cref="T:System.Text.RegularExpressions.Regex"/>-derived implementations.</summary>
+        </member>
+        <member name="F:System.Text.RegularExpressions.Generated.Utilities.s_ascii_FEFF00FC010000F801000078">
+            <summary>Supports searching for characters in or not in "!\"#$%&amp;'()*+,-./:;&lt;=&gt;?@[\\]^_`{|}~".</summary>
+        </member>
+    </members>
+</doc>
diff --git a/src/AStar.Dev.Utilities/Constants.cs b/src/AStar.Dev.Utilities/Constants.cs
new file mode 100644
index 0000000..2ca4609
--- /dev/null
+++ b/src/AStar.Dev.Utilities/Constants.cs
@@ -0,0 +1,15 @@
+using System.Text.Json;
+
+namespace AStar.Dev.Utilities;
+
+/// <summary>
+///     The <see href="Constants"></see>see> class contains static / constant properties to simplify and centralise various
+///     settings
+/// </summary>
+public static class Constants
+{
+    /// <summary>
+    ///     Returns an instance of <see href="JsonSerializerOptions"></see> configured with the Web defaults
+    /// </summary>
+    public static JsonSerializerOptions WebDeserialisationSettings => new(JsonSerializerDefaults.Web);
+}
diff --git a/src/AStar.Dev.Utilities/EncryptionExtensions.cs b/src/AStar.Dev.Utilities/EncryptionExtensions.cs
new file mode 100644
index 0000000..ad27b7f
--- /dev/null
+++ b/src/AStar.Dev.Utilities/EncryptionExtensions.cs
@@ -0,0 +1,77 @@
+using System.Security.Cryptography;
+using System.Text;
+
+namespace AStar.Dev.Utilities;
+
+/// <summary>
+///     The <see cref="EncryptionExtensions" /> class contains extension methods to encrypt / decrypt the specified string
+/// </summary>
+public static class EncryptionExtensions
+{
+    private const string Key = "oe3QnEe&@NnJ$$^L$1N@4WVKFayaAAOb";
+    private const string Iv  = "sBA&3z*4cQf%$!ww";
+
+    /// <summary>
+    ///     The Encrypt extension method will encrypt the specified string (using AES encryption)
+    /// </summary>
+    /// <param name="plainText">The string to encrypt</param>
+    /// <param name="key">
+    ///     The optional key to use for the encryption. If supplied, it must be 16, 24, or 32 bytes long. If not
+    ///     specified, an internal default (32 bytes) will be used
+    /// </param>
+    /// <param name="iv">
+    ///     The optional iv (initialisation vector) to use for the decryption. If supplied, it must be 16 bytes
+    ///     long. If not specified, an internal default will be used
+    /// </param>
+    /// <returns>The original string encrypted appropriately</returns>
+    public static string Encrypt(this string plainText, string? key = null, string? iv = null)
+    {
+        using var aesAlg = Aes.Create();
+
+        aesAlg.Key = Encoding.UTF8.GetBytes(key ?? Key);
+        aesAlg.IV  = Encoding.UTF8.GetBytes(iv  ?? Iv);
+
+        var encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
+
+        using var msEncrypt = new MemoryStream();
+        using var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write);
+
+        using (var swEncrypt = new StreamWriter(csEncrypt))
+        {
+            swEncrypt.Write(plainText);
+        }
+
+        return Convert.ToBase64String(msEncrypt.ToArray());
+    }
+
+    /// <summary>
+    ///     The Decrypt extension method will encrypt the specified string (using AES encryption)
+    /// </summary>
+    /// <param name="encryptedText">The string to decrypt</param>
+    /// <param name="key">
+    ///     The optional key to use for the encryption. If supplied, it must be 16, 24, or 32 bytes long. If not
+    ///     specified, an internal default (32 bytes) will be used
+    /// </param>
+    /// <param name="iv">
+    ///     The optional iv (initialisation vector) to use for the decryption. If supplied, it must be 16 bytes
+    ///     long. If not specified, an internal default will be used
+    /// </param>
+    /// <returns>The decrypted string</returns>
+    public static string Decrypt(this string encryptedText, string? key = null, string? iv = null)
+    {
+        using var aesAlg = Aes.Create();
+
+        aesAlg.Key = Encoding.UTF8.GetBytes(key ?? Key);
+        aesAlg.IV  = Encoding.UTF8.GetBytes(iv  ?? Iv);
+
+        var decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
+
+        using var msDecrypt = new MemoryStream(Convert.FromBase64String(encryptedText));
+
+        using var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read);
+
+        using var srDecrypt = new StreamReader(csDecrypt);
+
+        return srDecrypt.ReadToEnd();
+    }
+}
diff --git a/src/AStar.Dev.Utilities/EnumExtensions.cs b/src/AStar.Dev.Utilities/EnumExtensions.cs
new file mode 100644
index 0000000..d49d839
--- /dev/null
+++ b/src/AStar.Dev.Utilities/EnumExtensions.cs
@@ -0,0 +1,16 @@
+namespace AStar.Dev.Utilities;
+
+/// <summary>
+/// </summary>
+public static class EnumExtensions
+{
+    /// <summary>
+    ///     The ParseEnum method will parse the supplied string and return the matching enum value
+    /// </summary>
+    /// <typeparam name="T">The typeof of the expected enum</typeparam>
+    /// <param name="value">The value to parse to the enum</param>
+    /// <returns>The parsed value as the matching enum value</returns>
+    /// <exception cref="ArgumentException">Thrown when the string is not a valid enum value</exception>
+    public static T ParseEnum<T>(this string value) =>
+        (T)Enum.Parse(typeof(T), value, true);
+}
diff --git a/src/AStar.Dev.Utilities/LICENSE b/src/AStar.Dev.Utilities/LICENSE
new file mode 100644
index 0000000..0b1b024
--- /dev/null
+++ b/src/AStar.Dev.Utilities/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 AStar Development, Jason Barden
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/src/AStar.Dev.Utilities/ObjectExtensions.cs b/src/AStar.Dev.Utilities/ObjectExtensions.cs
new file mode 100644
index 0000000..20ef5d1
--- /dev/null
+++ b/src/AStar.Dev.Utilities/ObjectExtensions.cs
@@ -0,0 +1,21 @@
+using System.Text.Json;
+
+namespace AStar.Dev.Utilities;
+
+/// <summary>
+///     The <see cref="ObjectExtensions" /> class contains some useful methods to enable various tasks
+///     to be performed in a more fluid, English sentence, style
+/// </summary>
+public static class ObjectExtensions
+{
+    private static readonly JsonSerializerOptions Options = new(JsonSerializerDefaults.Web) { WriteIndented = true };
+
+    /// <summary>
+    ///     The ToJson method, as you might expect, converts the supplied object to its JSON equivalent (using the
+    ///     JsonSerializerDefaults.Web defaults with WriteIndented set to true)
+    /// </summary>
+    /// <param name="object">The object to convert to JSON</param>
+    /// <returns>The JSON string of the object supplied</returns>
+    public static string ToJson<T>(this T @object) =>
+        JsonSerializer.Serialize(@object, Options);
+}
diff --git a/src/AStar.Dev.Utilities/Readme.md b/src/AStar.Dev.Utilities/Readme.md
new file mode 100644
index 0000000..16dacd1
--- /dev/null
+++ b/src/AStar.Dev.Utilities/Readme.md
@@ -0,0 +1 @@
+Update
\ No newline at end of file
diff --git a/src/AStar.Dev.Utilities/RegexExtensions.cs b/src/AStar.Dev.Utilities/RegexExtensions.cs
new file mode 100644
index 0000000..9b61eb8
--- /dev/null
+++ b/src/AStar.Dev.Utilities/RegexExtensions.cs
@@ -0,0 +1,48 @@
+using System.Text.RegularExpressions;
+
+namespace AStar.Dev.Utilities;
+
+/// <summary>
+/// </summary>
+public static partial class RegexExtensions
+{
+    /// <summary>
+    /// </summary>
+    /// <param name="value"></param>
+    /// <returns></returns>
+    public static bool ContainsAtLeastOneLowercaseLetter(this string value) =>
+        LowercaseLettersRegex().IsMatch(value);
+
+    /// <summary>
+    /// </summary>
+    /// <param name="value"></param>
+    /// <returns></returns>
+    public static bool ContainsAtLeastOneUppercaseLetter(this string value) =>
+        UppercaseLettersRegex().IsMatch(value);
+
+    /// <summary>
+    /// </summary>
+    /// <param name="value"></param>
+    /// <returns></returns>
+    public static bool ContainsAtLeastOneDigit(this string value) =>
+        DigitRegex().IsMatch(value);
+
+    /// <summary>
+    /// </summary>
+    /// <param name="value"></param>
+    /// <returns></returns>
+    public static bool ContainsAtLeastOneSpecialCharacter(this string value) =>
+        SpecialCharacterRegex().IsMatch(value);
+
+    [GeneratedRegex("^[a-z]+$", RegexOptions.CultureInvariant, 1_000)]
+    private static partial Regex LowercaseLettersRegex();
+
+    [GeneratedRegex("^[A-Z]+$", RegexOptions.CultureInvariant, 1_000)]
+    private static partial Regex UppercaseLettersRegex();
+
+    [GeneratedRegex("^[A-Z]+$", RegexOptions.CultureInvariant, 1_000)]
+    private static partial Regex DigitRegex();
+
+    [GeneratedRegex(@"[!-\/:-@[-`{-~]", RegexOptions.CultureInvariant, 1_000)]
+    private static partial Regex SpecialCharacterRegex();
+}
diff --git a/src/AStar.Dev.Utilities/StringExtensions.cs b/src/AStar.Dev.Utilities/StringExtensions.cs
new file mode 100644
index 0000000..f800ff3
--- /dev/null
+++ b/src/AStar.Dev.Utilities/StringExtensions.cs
@@ -0,0 +1,92 @@
+using System.Text.Json;
+
+namespace AStar.Dev.Utilities;
+
+/// <summary>
+///     The <see cref="StringExtensions" /> class contains some useful methods to enable checks to be
+///     performed in a more fluid, English sentence, style
+/// </summary>
+public static class StringExtensions
+{
+    /// <summary>
+    ///     The IsNull method, as you might expect, checks whether the string is, in fact, null
+    /// </summary>
+    /// <param name="value">The string to check for being null</param>
+    /// <returns>True if the string is null, False otherwise</returns>
+    public static bool IsNull(this string? value) =>
+        value is null;
+
+    /// <summary>
+    ///     The IsNotNull method, as you might expect, checks whether the string is not null
+    /// </summary>
+    /// <param name="value">The string to check for being not null</param>
+    /// <returns>True if the string is not null, False otherwise</returns>
+    public static bool IsNotNull(this string? value) =>
+        !value.IsNull();
+
+    /// <summary>
+    ///     The IsNullOrWhiteSpace method, as you might expect, checks whether the string is, in fact, null, empty or
+    ///     whitespace
+    /// </summary>
+    /// <param name="value">The string to check for being null, empty or whitespace</param>
+    /// <returns>True if the string is null, empty or whitespace, False otherwise</returns>
+    public static bool IsNullOrWhiteSpace(this string? value) =>
+        string.IsNullOrWhiteSpace(value);
+
+    /// <summary>
+    ///     The IsNotNullOrWhiteSpace method, as you might expect, checks whether the string is not null, empty or whitespace
+    /// </summary>
+    /// <param name="value">The string to check for being not null, empty or whitespace</param>
+    /// <returns>True if the string is not null, empty or whitespace, False otherwise</returns>
+    public static bool IsNotNullOrWhiteSpace(this string? value) =>
+        !value.IsNullOrWhiteSpace();
+
+    /// <summary>
+    ///     The FromJson method, as you might expect, converts the supplied JSON to the specified object
+    /// </summary>
+    /// <typeparam name="T">The required type of the object to deserialise to</typeparam>
+    /// <param name="json">The JSON representation of the object</param>
+    /// <returns>A deserialised object based on the original JSON</returns>
+    public static T FromJson<T>(this string json) =>
+        JsonSerializer.Deserialize<T>(json)!;
+
+    /// <summary>
+    ///     The FromJson method, as you might expect, converts the supplied JSON to the specified object
+    /// </summary>
+    /// <typeparam name="T">The required type of the object to deserialise to</typeparam>
+    /// <param name="json">The JSON representation of the object</param>
+    /// <param name="options">
+    ///     Allows the specific <see href="JsonSerializerOptions">options</see> to be set to control
+    ///     deserialisation
+    /// </param>
+    /// <returns>A deserialised object based on the original JSON</returns>
+    public static T FromJson<T>(this string json, JsonSerializerOptions options) =>
+        JsonSerializer.Deserialize<T>(json, options)!;
+
+    /// <summary>
+    /// </summary>
+    /// <param name="fileName"></param>
+    /// <returns></returns>
+    public static bool IsImage(this string fileName) =>
+        fileName.EndsWith(".jpg",     StringComparison.OrdinalIgnoreCase)
+        || fileName.EndsWith(".jpeg", StringComparison.OrdinalIgnoreCase)
+        || fileName.EndsWith(".png",  StringComparison.OrdinalIgnoreCase)
+        || fileName.EndsWith(".bmp",  StringComparison.OrdinalIgnoreCase)
+        || fileName.EndsWith(".gif",  StringComparison.OrdinalIgnoreCase);
+
+    /// <summary>
+    /// </summary>
+    /// <param name="fileName"></param>
+    /// <returns></returns>
+    public static bool IsNumberOnly(this string fileName) =>
+        fileName.All(c => char.IsDigit(c) || c == '_' || c == '.');
+
+    /// <summary>
+    ///     The TruncateIfRequired method will, as the name suggests, truncate the string if the length exceeds the specified length
+    /// </summary>
+    /// <param name="value">The raw string to potentially truncate</param>
+    /// <param name="truncateLenght">The maximum length the string should be truncated to if required</param>
+    /// <returns>The specified string or the truncated version</returns>
+    public static string TruncateIfRequired(this string value, int truncateLenght) =>
+        value.Length > truncateLenght ? value[..350] : value;
+}
diff --git a/src/AStar.Dev.Utilities/astar.ico b/src/AStar.Dev.Utilities/astar.ico
new file mode 100644
index 0000000000000000000000000000000000000000..38b6709a751659db6d84ef77d794c46015e49f91
GIT binary patch
literal 16958
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
X&NDAFOJCS+^Z#D}|KI<=mx2EQlDulw

literal 0
HcmV?d00001

diff --git a/src/AStar.Dev.Utilities/astar.png b/src/AStar.Dev.Utilities/astar.png
new file mode 100644
index 0000000000000000000000000000000000000000..74b197eaae17c8a9d66b29d6259ce99af25741e6
GIT binary patch
literal 15984
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

literal 0
HcmV?d00001

diff --git a/test/AStar.Dev.Utilities.Tests.Unit/AStar.Dev.Utilities.Tests.Unit.csproj b/test/AStar.Dev.Utilities.Tests.Unit/AStar.Dev.Utilities.Tests.Unit.csproj
new file mode 100644
index 0000000..35c9d60
--- /dev/null
+++ b/test/AStar.Dev.Utilities.Tests.Unit/AStar.Dev.Utilities.Tests.Unit.csproj
@@ -0,0 +1,49 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net9.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <IsPackable>false</IsPackable>
+        <RootNamespace>AStar.Dev.Utilities</RootNamespace>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <AssemblyAttribute Include="System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage"/>
+    </ItemGroup>
+
+    <ItemGroup>
+
+        <PackageReference Include="coverlet.collector" Version="6.0.4">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1"/>
+        <PackageReference Include="Shouldly" Version="4.3.0"/>
+        <PackageReference Include="xunit" Version="2.9.3"/>
+        <PackageReference Include="xunit.runner.visualstudio" Version="3.1.3">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+    </ItemGroup>
+
+    <ItemGroup>
+        <Using Include="Xunit"/>
+        <Using Include="Shouldly"/>
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\..\src\AStar.Dev.Utilities\AStar.Dev.Utilities.csproj" />
+    </ItemGroup>
+
+    <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+        <TreatWarningsAsErrors>True</TreatWarningsAsErrors>
+        <NoWarn>1701;1702;IDE0058;</NoWarn>
+    </PropertyGroup>
+
+    <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+        <TreatWarningsAsErrors>True</TreatWarningsAsErrors>
+        <NoWarn>1701;1702;IDE0058;</NoWarn>
+    </PropertyGroup>
+
+</Project>
diff --git a/test/AStar.Dev.Utilities.Tests.Unit/AnyClass.cs b/test/AStar.Dev.Utilities.Tests.Unit/AnyClass.cs
new file mode 100644
index 0000000..372688c
--- /dev/null
+++ b/test/AStar.Dev.Utilities.Tests.Unit/AnyClass.cs
@@ -0,0 +1,8 @@
+namespace AStar.Dev.Utilities;
+
+internal sealed class AnyClass
+{
+    public int AnyInt { get; set; }
+
+    public string AnyString { get; set; } = string.Empty;
+}
diff --git a/test/AStar.Dev.Utilities.Tests.Unit/AnyEnum.cs b/test/AStar.Dev.Utilities.Tests.Unit/AnyEnum.cs
new file mode 100644
index 0000000..ac0e95e
--- /dev/null
+++ b/test/AStar.Dev.Utilities.Tests.Unit/AnyEnum.cs
@@ -0,0 +1,7 @@
+namespace AStar.Dev.Utilities;
+
+internal enum AnyEnum
+{
+    NotDefined,
+    Defined
+}
diff --git a/test/AStar.Dev.Utilities.Tests.Unit/ConstantsShould.ContainTheExpectedWebDeserialisationSettingsSetting.approved.txt b/test/AStar.Dev.Utilities.Tests.Unit/ConstantsShould.ContainTheExpectedWebDeserialisationSettingsSetting.approved.txt
new file mode 100644
index 0000000..c91a12f
--- /dev/null
+++ b/test/AStar.Dev.Utilities.Tests.Unit/ConstantsShould.ContainTheExpectedWebDeserialisationSettingsSetting.approved.txt
@@ -0,0 +1,31 @@
+{
+  "converters": [],
+  "typeInfoResolver": null,
+  "typeInfoResolverChain": [],
+  "allowOutOfOrderMetadataProperties": false,
+  "allowTrailingCommas": false,
+  "defaultBufferSize": 16384,
+  "encoder": null,
+  "dictionaryKeyPolicy": null,
+  "ignoreNullValues": false,
+  "defaultIgnoreCondition": 0,
+  "numberHandling": 1,
+  "preferredObjectCreationHandling": 0,
+  "ignoreReadOnlyProperties": false,
+  "ignoreReadOnlyFields": false,
+  "includeFields": false,
+  "maxDepth": 0,
+  "propertyNamingPolicy": {},
+  "propertyNameCaseInsensitive": true,
+  "readCommentHandling": 0,
+  "unknownTypeHandling": 0,
+  "unmappedMemberHandling": 0,
+  "writeIndented": false,
+  "indentCharacter": " ",
+  "indentSize": 2,
+  "referenceHandler": null,
+  "newLine": "\n",
+  "respectNullableAnnotations": false,
+  "respectRequiredConstructorParameters": false,
+  "isReadOnly": false
+}
\ No newline at end of file
diff --git a/test/AStar.Dev.Utilities.Tests.Unit/ConstantsShould.cs b/test/AStar.Dev.Utilities.Tests.Unit/ConstantsShould.cs
new file mode 100644
index 0000000..1b35a30
--- /dev/null
+++ b/test/AStar.Dev.Utilities.Tests.Unit/ConstantsShould.cs
@@ -0,0 +1,10 @@
+namespace AStar.Dev.Utilities;
+
+public sealed class ConstantsShould
+{
+    [Fact]
+    public void ContainTheExpectedWebDeserialisationSettingsSetting() =>
+        Constants.WebDeserialisationSettings
+                 .ToJson()
+                 .ShouldMatchApproved();
+}
diff --git a/test/AStar.Dev.Utilities.Tests.Unit/EnumExtensionsShould.cs b/test/AStar.Dev.Utilities.Tests.Unit/EnumExtensionsShould.cs
new file mode 100644
index 0000000..fafdde4
--- /dev/null
+++ b/test/AStar.Dev.Utilities.Tests.Unit/EnumExtensionsShould.cs
@@ -0,0 +1,16 @@
+namespace AStar.Dev.Utilities;
+
+public sealed class EnumExtensionsShould
+{
+    [Fact]
+    public void ContainTheParseMethodReturningTheExpectedValue() =>
+        "Defined".ParseEnum<AnyEnum>().ShouldBe(AnyEnum.Defined);
+
+    [Fact]
+    public void ContainTheParseMethodWhichThrowsArgumentExceptionWhenTheValueIsNotFound()
+    {
+        Action parseStringAction = () => "ThisDoesntExitst".ParseEnum<AnyEnum>();
+
+        _ = parseStringAction.ShouldThrow<ArgumentException>();
+    }
+}
diff --git a/test/AStar.Dev.Utilities.Tests.Unit/ObjectExtensionsShould.ContainTheToJsonMethodWhichReturnsTheExpectedString.approved.txt b/test/AStar.Dev.Utilities.Tests.Unit/ObjectExtensionsShould.ContainTheToJsonMethodWhichReturnsTheExpectedString.approved.txt
new file mode 100644
index 0000000..3eb293f
--- /dev/null
+++ b/test/AStar.Dev.Utilities.Tests.Unit/ObjectExtensionsShould.ContainTheToJsonMethodWhichReturnsTheExpectedString.approved.txt
@@ -0,0 +1,4 @@
+{
+  "anyInt": 0,
+  "anyString": ""
+}
\ No newline at end of file
diff --git a/test/AStar.Dev.Utilities.Tests.Unit/ObjectExtensionsShould.cs b/test/AStar.Dev.Utilities.Tests.Unit/ObjectExtensionsShould.cs
new file mode 100644
index 0000000..ce87f65
--- /dev/null
+++ b/test/AStar.Dev.Utilities.Tests.Unit/ObjectExtensionsShould.cs
@@ -0,0 +1,10 @@
+namespace AStar.Dev.Utilities;
+
+public sealed class ObjectExtensionsShould
+{
+    [Fact]
+    public void ContainTheToJsonMethodWhichReturnsTheExpectedString() =>
+        new AnyClass()
+            .ToJson()
+            .ShouldMatchApproved();
+}
diff --git a/test/AStar.Dev.Utilities.Tests.Unit/StringExtensionsShould.cs b/test/AStar.Dev.Utilities.Tests.Unit/StringExtensionsShould.cs
new file mode 100644
index 0000000..eb81531
--- /dev/null
+++ b/test/AStar.Dev.Utilities.Tests.Unit/StringExtensionsShould.cs
@@ -0,0 +1,33 @@
+namespace AStar.Dev.Utilities;
+
+public sealed class StringExtensionsShould
+{
+    private readonly string  anyJson          = "{\"AnyInt\":0,\"AnyString\":\"\"}";
+    private readonly string  notNullString    = "value does not matter";
+    private readonly string? nullString       = null!;
+    private readonly string  whitespaceString = " ";
+
+    [Fact]
+    public void ContainTheIsNullMethodWhichReturnsTheResult() =>
+        nullString.IsNull().ShouldBeTrue();
+
+    [Fact]
+    public void ContainTheIsNotNullMethodWhichReturnsTheResult() =>
+        notNullString.IsNotNull().ShouldBeTrue();
+
+    [Fact]
+    public void ContainTheIsNullOrWhiteSpaceMethodWhichReturnsTheResult() =>
+        whitespaceString.IsNullOrWhiteSpace().ShouldBeTrue();
+
+    [Fact]
+    public void ContainTheIsNotNullOrWhiteSpaceMethodWhichReturnsTheResult() =>
+        notNullString.IsNotNullOrWhiteSpace().ShouldBeTrue();
+
+    [Fact]
+    public void ContainTheFromJsonMethodWhichReturnsTheResult() =>
+        anyJson.FromJson<AnyClass>().ShouldBeEquivalentTo(new AnyClass());
+
+    [Fact]
+    public void ContainTheFromJsonTakingJsonSerializerOptionsMethodWhichReturnsTheResult() =>
+        anyJson.FromJson<AnyClass>(new()).ShouldBeEquivalentTo(new AnyClass());
+}