From d5dd86f19c9c5cfecf16c7ef9cc9427e6a4d4ca2 Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 10:06:07 +0200
Subject: [PATCH 01/18] Add second impl for netstandard2

---
 src/Verifast/IValidator.cs                    | 60 +++++++++++++++++-
 src/Verifast/ValidationResult.cs              | 11 +++-
 src/Verifast/Validator.cs                     | 62 +++++++++++++++++++
 src/Verifast/Verifast.csproj                  |  9 ++-
 .../Verifast.Tests.Unit.csproj                |  2 +-
 5 files changed, 137 insertions(+), 7 deletions(-)

diff --git a/src/Verifast/IValidator.cs b/src/Verifast/IValidator.cs
index f837c4b..e2ed935 100644
--- a/src/Verifast/IValidator.cs
+++ b/src/Verifast/IValidator.cs
@@ -1,5 +1,6 @@
 namespace Verifast;
 
+#if NET9_0_OR_GREATER
 /// <summary>
 /// Interface for implementing a synchronous validator for <typeparamref name="T"/> with message type <typeparamref name="TMessage"/>
 /// </summary>
@@ -54,4 +55,61 @@ public interface IAsyncValidator<T> {
     /// <param name="ct"></param>
     /// <returns></returns>
     ValueTask<ValidationResult<string>> ValidateAsync(T instance, CancellationToken ct = default);
-}
\ No newline at end of file
+}
+#else
+/// <summary>
+/// Interface for implementing a synchronous validator for <typeparamref name="T"/> with message type <typeparamref name="TMessage"/>
+/// </summary>
+/// <typeparam name="T"></typeparam>
+/// <typeparam name="TMessage"></typeparam>
+public interface IValidator<T, TMessage> {
+    /// <summary>
+    /// Validate method
+    /// </summary>
+    /// <param name="instance"></param>
+    /// <param name="result"></param>
+    void Validate(in T instance, ref ValidationResult<TMessage> result);
+}
+
+/// <summary>
+/// Interface for implementing a synchronous validator for <typeparamref name="T"/>
+/// </summary>
+/// <typeparam name="T"></typeparam>
+public interface IValidator<T> {
+    /// <summary>
+	/// Validate method
+	/// </summary>
+	/// <param name="instance"></param>
+	/// <param name="result"></param>
+    void Validate(in T instance, ref ValidationResult<string> result);
+}
+
+/// <summary>
+/// Interface for implementing an asynchronous validator for <typeparamref name="T"/> with message type <typeparamref name="TMessage"/>
+/// </summary>
+/// <typeparam name="T"></typeparam>
+/// <typeparam name="TMessage"></typeparam>
+public interface IAsyncValidator<T, TMessage> {
+    /// <summary>
+    /// ValidateAsync method
+    /// </summary>
+    /// <param name="instance"></param>
+    /// <param name="ct"></param>
+    /// <returns></returns>
+    Task<ValidationResult<TMessage>> ValidateAsync(T instance, CancellationToken ct = default);
+}
+
+/// <summary>
+/// Interface for implementing an asynchronous validator for <typeparamref name="T"/>
+/// </summary>
+/// <typeparam name="T"></typeparam>
+public interface IAsyncValidator<T> {
+    /// <summary>
+    /// ValidateAsync method
+    /// </summary>
+    /// <param name="instance"></param>
+    /// <param name="ct"></param>
+    /// <returns></returns>
+    Task<ValidationResult<string>> ValidateAsync(T instance, CancellationToken ct = default);
+}
+#endif
\ No newline at end of file
diff --git a/src/Verifast/ValidationResult.cs b/src/Verifast/ValidationResult.cs
index 56cbca5..3486abd 100644
--- a/src/Verifast/ValidationResult.cs
+++ b/src/Verifast/ValidationResult.cs
@@ -9,6 +9,13 @@ public struct ValidationResult<TMessage> {
     private List<TMessage>? _errors;
     private List<TMessage>? _warnings;
 
+    private static readonly ReadOnlyCollection<TMessage> Empty =
+#if NET
+        ReadOnlyCollection<TMessage>.Empty;
+#else
+        new(Array.Empty<TMessage>());
+#endif
+
     /// <summary>
     /// The result is valid if no errors were found.
     /// </summary>
@@ -20,7 +27,7 @@ public struct ValidationResult<TMessage> {
     public readonly ReadOnlyCollection<TMessage> Errors
         => _errors is not null
         ? new ReadOnlyCollection<TMessage>(_errors)
-        : ReadOnlyCollection<TMessage>.Empty;
+        : Empty;
 
     /// <summary>
     /// A <see cref="ReadOnlyCollection{TMessage}"/> of the <see cref="Warnings"/>
@@ -28,7 +35,7 @@ public readonly ReadOnlyCollection<TMessage> Errors
     public readonly ReadOnlyCollection<TMessage> Warnings
         => _warnings is not null
         ? new ReadOnlyCollection<TMessage>(_warnings)
-        : ReadOnlyCollection<TMessage>.Empty;
+        : Empty;
 
     /// <summary>
     /// Adds an error to the validation result
diff --git a/src/Verifast/Validator.cs b/src/Verifast/Validator.cs
index 4127f4a..1039b80 100644
--- a/src/Verifast/Validator.cs
+++ b/src/Verifast/Validator.cs
@@ -4,6 +4,7 @@
 /// A static class providing the main APIs for validation
 /// </summary>
 public static class Validator {
+#if NET9_0_OR_GREATER
     /// <summary>
     /// Validate
     /// </summary>
@@ -71,4 +72,65 @@ public static bool TryValidate<TValidator, T>(this TValidator validator, in T in
         validator.Validate(in instance, ref result);
         return result.IsValid;
     }
+#else
+    /// <summary>
+    /// Validate
+    /// </summary>
+    /// <typeparam name="TValidator"></typeparam>
+    /// <typeparam name="T"></typeparam>
+    /// <typeparam name="TMessage"></typeparam>
+    /// <param name="validator"></param>
+    /// <param name="instance"></param>
+    /// <returns></returns>
+    public static ValidationResult<TMessage> Validate<TValidator, T, TMessage>(this TValidator validator, in T instance) {
+        ValidationResult<TMessage> result = default;
+        validator.Validate(in instance, ref result);
+        return result;
+    }
+
+    /// <summary>
+	/// Validate
+	/// </summary>
+	/// <typeparam name="TValidator"></typeparam>
+	/// <typeparam name="T"></typeparam>
+	/// <param name="validator"></param>
+	/// <param name="instance"></param>
+	/// <returns></returns>
+	public static ValidationResult<string> Validate<TValidator, T>(this TValidator validator, in T instance) {
+        ValidationResult<string> result = default;
+        validator.Validate(in instance, ref result);
+        return result;
+    }
+
+    /// <summary>
+    /// Try Validate
+    /// </summary>
+    /// <typeparam name="TValidator"></typeparam>
+    /// <typeparam name="T"></typeparam>
+    /// <typeparam name="TMessage"></typeparam>
+    /// <param name="validator"></param>
+    /// <param name="instance"></param>
+    /// <param name="result"></param>
+    /// <returns>True if <paramref name="instance"/> is valid.</returns>
+    public static bool TryValidate<TValidator, T, TMessage>(this TValidator validator, in T instance, out ValidationResult<TMessage> result) {
+        result = default;
+        validator.Validate(in instance, ref result);
+        return result.IsValid;
+    }
+
+    /// <summary>
+	/// Try Validate
+	/// </summary>
+	/// <typeparam name="TValidator"></typeparam>
+	/// <typeparam name="T"></typeparam>
+	/// <param name="validator"></param>
+	/// <param name="instance"></param>
+	/// <param name="result"></param>
+	/// <returns>True if <paramref name="instance"/> is valid.</returns>
+	public static bool TryValidate<TValidator, T>(this TValidator validator, in T instance, out ValidationResult<string> result) {
+        result = default;
+        validator.Validate(in instance, ref result);
+        return result.IsValid;
+    }
+#endif
 }
\ No newline at end of file
diff --git a/src/Verifast/Verifast.csproj b/src/Verifast/Verifast.csproj
index f8df1d7..8fa2306 100644
--- a/src/Verifast/Verifast.csproj
+++ b/src/Verifast/Verifast.csproj
@@ -3,16 +3,19 @@
   <PropertyGroup>
     <Version>0.1.0.0</Version>
 
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFrameworks>net9.0;netstandard2.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <LangVersion>latest</LangVersion>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <Deterministic>true</Deterministic>
     <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
     <EnableNETAnalyzers>true</EnableNETAnalyzers>
     <AnalysisLevel>latest-recommended</AnalysisLevel>
-    <IsAotCompatible>true</IsAotCompatible>
-    <IsTrimmable>true</IsTrimmable>
+    <IsAotCompatible
+      Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net9.0'))">true</IsAotCompatible>
+    <IsTrimmable
+      Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net9.0'))">true</IsTrimmable>
 
     <Authors>David Shnayder</Authors>
     <Copyright>David Shnayder</Copyright>
diff --git a/tests/Verifast.Tests.Unit/Verifast.Tests.Unit.csproj b/tests/Verifast.Tests.Unit/Verifast.Tests.Unit.csproj
index 1c67b6b..01951d2 100644
--- a/tests/Verifast.Tests.Unit/Verifast.Tests.Unit.csproj
+++ b/tests/Verifast.Tests.Unit/Verifast.Tests.Unit.csproj
@@ -5,7 +5,7 @@
     <Nullable>enable</Nullable>
     <OutputType>Exe</OutputType>
     <RootNamespace>Verifast.Tests.Unit</RootNamespace>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFrameworks>net9.0;netstandard2.0</TargetFrameworks>
     <!--
     To enable the Microsoft Testing Platform 'dotnet test' experience, add property:
       <TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>

From 06628b1c727c90f1edee951fd094d9c818df7885 Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 10:17:31 +0200
Subject: [PATCH 02/18] Fix constraints

---
 src/Verifast/IValidator.cs       |  4 ++--
 src/Verifast/ValidationResult.cs |  4 ++--
 src/Verifast/Validator.cs        | 12 ++++++++----
 3 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/src/Verifast/IValidator.cs b/src/Verifast/IValidator.cs
index e2ed935..73656d4 100644
--- a/src/Verifast/IValidator.cs
+++ b/src/Verifast/IValidator.cs
@@ -89,7 +89,7 @@ public interface IValidator<T> {
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <typeparam name="TMessage"></typeparam>
-public interface IAsyncValidator<T, TMessage> {
+public interface IAsyncValidator<in T, TMessage> {
     /// <summary>
     /// ValidateAsync method
     /// </summary>
@@ -103,7 +103,7 @@ public interface IAsyncValidator<T, TMessage> {
 /// Interface for implementing an asynchronous validator for <typeparamref name="T"/>
 /// </summary>
 /// <typeparam name="T"></typeparam>
-public interface IAsyncValidator<T> {
+public interface IAsyncValidator<in T> {
     /// <summary>
     /// ValidateAsync method
     /// </summary>
diff --git a/src/Verifast/ValidationResult.cs b/src/Verifast/ValidationResult.cs
index 3486abd..1a5efdd 100644
--- a/src/Verifast/ValidationResult.cs
+++ b/src/Verifast/ValidationResult.cs
@@ -42,7 +42,7 @@ public readonly ReadOnlyCollection<TMessage> Warnings
     /// </summary>
     /// <param name="message"></param>
     public void AddError(TMessage message) {
-        _errors ??= new List<TMessage>();
+        _errors ??= [];
         _errors.Add(message);
     }
 
@@ -51,7 +51,7 @@ public void AddError(TMessage message) {
     /// </summary>
     /// <param name="message"></param>
     public void AddWarning(TMessage message) {
-        _warnings ??= new List<TMessage>();
+        _warnings ??= [];
         _warnings.Add(message);
     }
 }
\ No newline at end of file
diff --git a/src/Verifast/Validator.cs b/src/Verifast/Validator.cs
index 1039b80..882fe0a 100644
--- a/src/Verifast/Validator.cs
+++ b/src/Verifast/Validator.cs
@@ -82,7 +82,8 @@ public static bool TryValidate<TValidator, T>(this TValidator validator, in T in
     /// <param name="validator"></param>
     /// <param name="instance"></param>
     /// <returns></returns>
-    public static ValidationResult<TMessage> Validate<TValidator, T, TMessage>(this TValidator validator, in T instance) {
+    public static ValidationResult<TMessage> Validate<TValidator, T, TMessage>(this TValidator validator, in T instance)
+        where TValidator : IValidator<T, TMessage> {
         ValidationResult<TMessage> result = default;
         validator.Validate(in instance, ref result);
         return result;
@@ -96,7 +97,8 @@ public static ValidationResult<TMessage> Validate<TValidator, T, TMessage>(this
 	/// <param name="validator"></param>
 	/// <param name="instance"></param>
 	/// <returns></returns>
-	public static ValidationResult<string> Validate<TValidator, T>(this TValidator validator, in T instance) {
+	public static ValidationResult<string> Validate<TValidator, T>(this TValidator validator, in T instance) 
+        where TValidator : IValidator<T> {
         ValidationResult<string> result = default;
         validator.Validate(in instance, ref result);
         return result;
@@ -112,7 +114,8 @@ public static ValidationResult<string> Validate<TValidator, T>(this TValidator v
     /// <param name="instance"></param>
     /// <param name="result"></param>
     /// <returns>True if <paramref name="instance"/> is valid.</returns>
-    public static bool TryValidate<TValidator, T, TMessage>(this TValidator validator, in T instance, out ValidationResult<TMessage> result) {
+    public static bool TryValidate<TValidator, T, TMessage>(this TValidator validator, in T instance, out ValidationResult<TMessage> result)
+        where TValidator : IValidator<T, TMessage> {
         result = default;
         validator.Validate(in instance, ref result);
         return result.IsValid;
@@ -127,7 +130,8 @@ public static bool TryValidate<TValidator, T, TMessage>(this TValidator validato
 	/// <param name="instance"></param>
 	/// <param name="result"></param>
 	/// <returns>True if <paramref name="instance"/> is valid.</returns>
-	public static bool TryValidate<TValidator, T>(this TValidator validator, in T instance, out ValidationResult<string> result) {
+	public static bool TryValidate<TValidator, T>(this TValidator validator, in T instance, out ValidationResult<string> result)
+        where TValidator : IValidator<T> {
         result = default;
         validator.Validate(in instance, ref result);
         return result.IsValid;

From 8231ca8a436c1b167ff2e3103a0d8fda2d3101fe Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 10:17:49 +0200
Subject: [PATCH 03/18] Remove standard to implement secondary test project for
 them

---
 tests/Verifast.Tests.Unit/Verifast.Tests.Unit.csproj | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/Verifast.Tests.Unit/Verifast.Tests.Unit.csproj b/tests/Verifast.Tests.Unit/Verifast.Tests.Unit.csproj
index 01951d2..53f0a66 100644
--- a/tests/Verifast.Tests.Unit/Verifast.Tests.Unit.csproj
+++ b/tests/Verifast.Tests.Unit/Verifast.Tests.Unit.csproj
@@ -4,8 +4,8 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <OutputType>Exe</OutputType>
-    <RootNamespace>Verifast.Tests.Unit</RootNamespace>
-    <TargetFrameworks>net9.0;netstandard2.0</TargetFrameworks>
+    <LangVersion>Verifast.Tests.Unit</LangVersion>
+    <TargetFramework>net9.0</TargetFramework>
     <!--
     To enable the Microsoft Testing Platform 'dotnet test' experience, add property:
       <TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>

From 660c0af4f2757424d0809ecabdd1c3a596995d67 Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 10:22:32 +0200
Subject: [PATCH 04/18] Update agents.md

---
 .gitignore |  2 --
 AGENTS.md  | 73 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 73 insertions(+), 2 deletions(-)
 create mode 100644 AGENTS.md

diff --git a/.gitignore b/.gitignore
index d71bbee..bc78471 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,8 +15,6 @@
 
 # User-specific files (MonoDevelop/Xamarin Studio)
 *.userprefs
-*WARP.md
-*AGENTS.md
 
 # Mono auto generated files
 mono_crash.*
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..0ab563e
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,73 @@
+# AGENTS.md
+
+This file provides guidance to agents when working with code in this repository.
+
+## Project Overview
+- Tech: Multi‑targeted .NET library (`src/Verifast`) targeting `net9.0` and `netstandard2.0`, focused on fast, allocation‑aware validation. Unit tests live in `tests/Verifast.Tests.Unit` (net9.0) using xUnit v3 with the Microsoft Testing Platform. A minimal benchmarks project exists under `benchmarks/Verifast.Benchmarks` (net9.0).
+- Design: The library centers on simple, interface‑driven validators and a lightweight result type that captures errors and warnings only when needed.
+
+## Big‑Picture Architecture
+- Validation contracts:
+  - `IValidator<T, TMessage>` and `IValidator<T>`: synchronous validators. On `net9.0`, both use `where T : allows ref struct` so validators can be used with stack‑only types without forcing `ref struct` everywhere. On `netstandard2.0`, the constraint is omitted.
+  - `IAsyncValidator<T, TMessage>` and `IAsyncValidator<T>`: asynchronous validators. On `net9.0` they return `ValueTask<ValidationResult<...>>`; on `netstandard2.0` they return `Task<ValidationResult<...>>` and are declared with `in T` variance.
+- Orchestrator APIs:
+  - Static `Validator` class: extension methods for synchronous validation and `TryValidate` overloads. Only sync helpers exist (no async orchestrator today). On `net9.0` the extensions include `allows ref struct` constraints.
+- Result type:
+  - `ValidationResult<TMessage>`: a struct that tracks `IsValid`, `Errors`, and `Warnings`. Message lists are allocated on‑demand when the first message is added; `Errors`/`Warnings` return `ReadOnlyCollection<TMessage>` wrappers.
+
+## Usage Model
+- Implement `IValidator<T>` (or `IAsyncValidator<T>`) on the type being validated or in a separate validator type.
+- Sync validators populate results via `Validate(in T instance, ref ValidationResult<...> result)`.
+- Execute via `validator.Validate(instance)` / `validator.TryValidate(instance, out var result)` or `validator.ValidateAsync(instance, ct)`.
+- Choose `string` messages for simplicity or a custom `TMessage` type for structured metadata.
+
+## Repository Layout
+- `src/Verifast`: Library code (`IValidator`, `IAsyncValidator`, `Validator`, `ValidationResult`).
+- `tests/Verifast.Tests.Unit`: xUnit v3 tests referencing the library. Configured as `OutputType Exe` to support Microsoft Testing Platform.
+- `benchmarks/Verifast.Benchmarks`: BenchmarkDotNet project (scaffolded).
+- `Verifast.slnx`: Solution file exists, but project‑scoped commands are preferred.
+
+## Commands You’ll Commonly Use
+Note: Favor project‑scoped commands (operate on `src/Verifast` or `tests/Verifast.Tests.Unit` explicitly). Avoid explicit `dotnet build` before running tests; `dotnet run` builds implicitly.
+
+- Build the library (project‑scoped):
+  - `dotnet build src/Verifast/Verifast.csproj`
+
+- Format/lint (EditorConfig conventions assumed):
+  - Analyze only: `dotnet format analyze --severity info`
+  - Apply style/whitespace fixes: `dotnet format`
+  - If `dotnet format` isn’t installed: `dotnet tool update -g dotnet-format`
+
+- Run all tests (Microsoft Testing Platform via dotnet run):
+  - From repo root: `dotnet run --project tests/Verifast.Tests.Unit`
+
+- List tests (Microsoft Testing Platform semantics):
+  - `dotnet run --project tests/Verifast.Tests.Unit -- --list-tests`
+
+- Run a single test (recommended: filter by fully qualified name):
+  - By method: `dotnet run --project tests/Verifast.Tests.Unit --filter-method="*TestMethodPattern*"`
+  - By class: `dotnet run --project tests/Verifast.Tests.Unit --filter-class="*TestClassPattern*"`
+  - Alternative (traditional): `dotnet test tests/Verifast.Tests.Unit --filter "FullyQualifiedName~Pattern"`
+
+- Run benchmarks (Release, no debugger):
+  - `dotnet run --project benchmarks/Verifast.Benchmarks -c Release`
+
+## Style and Conventions
+- C# 10+ idioms; file‑scoped namespaces.
+- Braces required around blocks.
+- Private fields: `_camelCase`; private static fields: `s_camelCase`.
+- Interfaces start with `I`; type parameters start with `T`.
+- Prefer explicit, straightforward logic (no heavy reflection or expression trees). Keep hot paths allocation‑aware.
+
+## Test Stack Specifics
+- xUnit v3 with `Microsoft.NET.Test.Sdk`. The test project sets `OutputType Exe` and includes `xunit.runner.json`.
+- Filters and test listing use Microsoft Testing Platform semantics when using `dotnet run`.
+- You can also use `dotnet test` with similar filter semantics if preferred.
+
+## AOT/Trimming Notes
+- `IsAotCompatible` and `IsTrimmable` are enabled for the `net9.0` target. Avoid patterns that rely on runtime code generation or deep reflection without proper annotations.
+
+## Notes for Future Agents
+- The `allows ref struct` constraints are intentional to enable stack‑only scenarios. Avoid introducing APIs that disallow `ref struct` usage unless necessary.
+- Keep the API surface minimal and allocation‑friendly. `ValidationResult<TMessage>` should remain a lightweight struct that only allocates when messages are added.
+- Prefer project‑scoped commands; the solution file exists but isn’t required for everyday operations.

From 38be6041f2af6d6648e19b6fef707eac43c35c20 Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 10:35:26 +0200
Subject: [PATCH 05/18] Add test project for standard2.0

---
 AGENTS.md                                     |   6 +-
 Verifast.slnx                                 |   1 +
 .../Verifast.Tests.Unit.Standard/AsyncUser.cs | 112 ++++++++++++++++++
 .../AsyncUserValidatorTests.cs                |  93 +++++++++++++++
 tests/Verifast.Tests.Unit.Standard/User.cs    | 104 ++++++++++++++++
 .../UserTryValidateTests.cs                   |  99 ++++++++++++++++
 .../UserValidatorTests.cs                     |  94 +++++++++++++++
 .../Verifast.Tests.Unit.Standard.csproj       |  31 +++++
 .../xunit.runner.json                         |   3 +
 .../Verifast.Tests.Unit.csproj                |  20 +---
 10 files changed, 548 insertions(+), 15 deletions(-)
 create mode 100644 tests/Verifast.Tests.Unit.Standard/AsyncUser.cs
 create mode 100644 tests/Verifast.Tests.Unit.Standard/AsyncUserValidatorTests.cs
 create mode 100644 tests/Verifast.Tests.Unit.Standard/User.cs
 create mode 100644 tests/Verifast.Tests.Unit.Standard/UserTryValidateTests.cs
 create mode 100644 tests/Verifast.Tests.Unit.Standard/UserValidatorTests.cs
 create mode 100644 tests/Verifast.Tests.Unit.Standard/Verifast.Tests.Unit.Standard.csproj
 create mode 100644 tests/Verifast.Tests.Unit.Standard/xunit.runner.json

diff --git a/AGENTS.md b/AGENTS.md
index 0ab563e..728cab9 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -3,7 +3,7 @@
 This file provides guidance to agents when working with code in this repository.
 
 ## Project Overview
-- Tech: Multi‑targeted .NET library (`src/Verifast`) targeting `net9.0` and `netstandard2.0`, focused on fast, allocation‑aware validation. Unit tests live in `tests/Verifast.Tests.Unit` (net9.0) using xUnit v3 with the Microsoft Testing Platform. A minimal benchmarks project exists under `benchmarks/Verifast.Benchmarks` (net9.0).
+- Tech: Multi‑targeted .NET library (`src/Verifast`) targeting `net9.0` and `netstandard2.0`, focused on fast, allocation‑aware validation. Unit tests live in `tests/Verifast.Tests.Unit` (net9.0) using xUnit v3 with the Microsoft Testing Platform, and `tests/Verifast.Tests.Unit.Standard` (net8.0) using xUnit v2 to exercise the `netstandard2.0` target. A minimal benchmarks project exists under `benchmarks/Verifast.Benchmarks` (net9.0).
 - Design: The library centers on simple, interface‑driven validators and a lightweight result type that captures errors and warnings only when needed.
 
 ## Big‑Picture Architecture
@@ -24,6 +24,7 @@ This file provides guidance to agents when working with code in this repository.
 ## Repository Layout
 - `src/Verifast`: Library code (`IValidator`, `IAsyncValidator`, `Validator`, `ValidationResult`).
 - `tests/Verifast.Tests.Unit`: xUnit v3 tests referencing the library. Configured as `OutputType Exe` to support Microsoft Testing Platform.
+- `tests/Verifast.Tests.Unit.Standard`: xUnit v2 tests targeting `net8.0` so the library resolves to its `netstandard2.0` target.
 - `benchmarks/Verifast.Benchmarks`: BenchmarkDotNet project (scaffolded).
 - `Verifast.slnx`: Solution file exists, but project‑scoped commands are preferred.
 
@@ -41,6 +42,9 @@ Note: Favor project‑scoped commands (operate on `src/Verifast` or `tests/Verif
 - Run all tests (Microsoft Testing Platform via dotnet run):
   - From repo root: `dotnet run --project tests/Verifast.Tests.Unit`
 
+- Run netstandard2.0 coverage tests (xUnit v2 via dotnet test):
+  - `dotnet test tests/Verifast.Tests.Unit.Standard`
+
 - List tests (Microsoft Testing Platform semantics):
   - `dotnet run --project tests/Verifast.Tests.Unit -- --list-tests`
 
diff --git a/Verifast.slnx b/Verifast.slnx
index 69c0933..98a72e7 100644
--- a/Verifast.slnx
+++ b/Verifast.slnx
@@ -6,6 +6,7 @@
     <Project Path="src/Verifast/Verifast.csproj" />
   </Folder>
   <Folder Name="/tests/">
+    <Project Path="tests/Verifast.Tests.Unit.Standard/Verifast.Tests.Unit.Standard.csproj" />
     <Project Path="tests/Verifast.Tests.Unit/Verifast.Tests.Unit.csproj" />
   </Folder>
 </Solution>
diff --git a/tests/Verifast.Tests.Unit.Standard/AsyncUser.cs b/tests/Verifast.Tests.Unit.Standard/AsyncUser.cs
new file mode 100644
index 0000000..6ccf64a
--- /dev/null
+++ b/tests/Verifast.Tests.Unit.Standard/AsyncUser.cs
@@ -0,0 +1,112 @@
+namespace Verifast.Tests.Unit.Standard;
+
+public class AsyncUserDto : IAsyncValidator<AsyncUserDto> {
+    public string? Name { get; set; }
+    public int Age { get; set; }
+    public string? Email { get; set; }
+    public string? Password { get; set; }
+    public string? Phone { get; set; }
+
+    public async Task<ValidationResult<string>> ValidateAsync(AsyncUserDto instance, CancellationToken ct = default) {
+        // Emulate asynchronous work so tests exercise the async path
+        await Task.Yield();
+        ct.ThrowIfCancellationRequested();
+
+        var result = new ValidationResult<string>();
+
+        // Name: required, length 1..100
+        if (string.IsNullOrWhiteSpace(instance.Name)) {
+            result.AddError($"'{nameof(Name)}' must be non-empty");
+        } else if (instance.Name!.Length > 100) {
+            result.AddError($"'{nameof(Name)}' must be at most 100 characters");
+        }
+
+        // Age: 18..120 inclusive
+        if (instance.Age is < 18 or > 120) {
+            result.AddError($"'{nameof(Age)}' must be between 18 and 120");
+        }
+
+        // Email: very lightweight format check (no regex)
+        if (!string.IsNullOrWhiteSpace(instance.Email)) {
+            if (!IsLikelyEmail(instance.Email!)) {
+                result.AddError($"'{nameof(Email)}' must be a valid email");
+            }
+        }
+
+        // Password: required, min 8, has upper, lower, digit
+        if (string.IsNullOrEmpty(instance.Password)) {
+            result.AddError($"'{nameof(Password)}' must be non-empty");
+        } else {
+            var pwd = instance.Password!;
+            if (pwd.Length < 8) {
+                result.AddError($"'{nameof(Password)}' must be at least 8 characters");
+            }
+
+            bool hasUpper = false, hasLower = false, hasDigit = false;
+            for (int i = 0; i < pwd.Length; i++) {
+                char c = pwd[i];
+                if (!hasUpper && char.IsUpper(c)) {
+                    hasUpper = true;
+                } else if (!hasLower && char.IsLower(c)) {
+                    hasLower = true;
+                } else if (!hasDigit && char.IsDigit(c)) {
+                    hasDigit = true;
+                }
+
+                if (hasUpper && hasLower && hasDigit) {
+                    break;
+                }
+            }
+
+            if (!hasUpper) {
+                result.AddError($"'{nameof(Password)}' must contain an uppercase letter");
+            }
+
+            if (!hasLower) {
+                result.AddError($"'{nameof(Password)}' must contain a lowercase letter");
+            }
+
+            if (!hasDigit) {
+                result.AddError($"'{nameof(Password)}' must contain a digit");
+            }
+        }
+
+        // Phone: optional; if provided, basic E.164-ish (+?[0-9]{10,15})
+        if (!string.IsNullOrWhiteSpace(instance.Phone)) {
+            if (!IsLikelyPhone(instance.Phone!)) {
+                result.AddWarning($"'{nameof(Phone)}' format looks invalid");
+            }
+        }
+
+        return result;
+
+        static bool IsLikelyEmail(string s) {
+            // Minimal: exactly one '@', non-empty local/domain, domain has a '.' after '@'
+            int at = s.IndexOf('@');
+            if (at <= 0 || at >= s.Length - 1) return false;
+            int dot = s.IndexOf('.', at + 1);
+            if (dot <= at + 1 || dot >= s.Length - 1) return false;
+            return true;
+        }
+
+        static bool IsLikelyPhone(string s) {
+            int i = 0;
+            int digits = 0;
+            if (s.Length > 0 && s[0] == '+') {
+                i = 1;
+            }
+
+            for (; i < s.Length; i++) {
+                char c = s[i];
+                if (char.IsDigit(c)) {
+                    digits++;
+                    continue;
+                }
+
+                return false;
+            }
+
+            return digits >= 10 && digits <= 15;
+        }
+    }
+}
diff --git a/tests/Verifast.Tests.Unit.Standard/AsyncUserValidatorTests.cs b/tests/Verifast.Tests.Unit.Standard/AsyncUserValidatorTests.cs
new file mode 100644
index 0000000..285c9c6
--- /dev/null
+++ b/tests/Verifast.Tests.Unit.Standard/AsyncUserValidatorTests.cs
@@ -0,0 +1,93 @@
+namespace Verifast.Tests.Unit.Standard;
+
+public class AsyncUserValidatorTests {
+    [Fact]
+    public async Task Valid_User_Has_No_Errors_Async() {
+        var user = new AsyncUserDto {
+            Name = "Alice",
+            Age = 30,
+            Email = "alice@example.com",
+            Password = "Secret123",
+            Phone = "+14155552671"
+        };
+
+        var result = await user.ValidateAsync(user, CancellationToken.None);
+        Assert.True(result.IsValid);
+        Assert.Empty(result.Errors);
+        Assert.Empty(result.Warnings);
+    }
+
+    [Fact]
+    public async Task Missing_Name_Is_Error_Async() {
+        var user = new AsyncUserDto {
+            Name = "",
+            Age = 25,
+            Email = "bob@example.com",
+            Password = "Abcdef12"
+        };
+
+        var result = await user.ValidateAsync(user, CancellationToken.None);
+        Assert.False(result.IsValid);
+        Assert.Contains(result.Errors, e => e.Contains("Name"));
+    }
+
+    [Fact]
+    public async Task Age_Out_Of_Range_Is_Error_Async() {
+        var user = new AsyncUserDto {
+            Name = "Bob",
+            Age = 10,
+            Email = "bob@example.com",
+            Password = "Abcdef12"
+        };
+
+        var result = await user.ValidateAsync(user, CancellationToken.None);
+        Assert.False(result.IsValid);
+        Assert.Contains(result.Errors, e => e.Contains("Age"));
+    }
+
+    [Fact]
+    public async Task Invalid_Email_Is_Error_Async() {
+        var user = new AsyncUserDto {
+            Name = "Carol",
+            Age = 40,
+            Email = "invalid-email",
+            Password = "Abcdef12"
+        };
+
+        var result = await user.ValidateAsync(user, CancellationToken.None);
+        Assert.False(result.IsValid);
+        Assert.Contains(result.Errors, e => e.Contains("Email"));
+    }
+
+    [Fact]
+    public async Task Password_Rules_Are_Validated_Async() {
+        var user = new AsyncUserDto {
+            Name = "Dan",
+            Age = 22,
+            Email = "dan@example.com",
+            Password = "short"
+        };
+
+        var result = await user.ValidateAsync(user, CancellationToken.None);
+        Assert.False(result.IsValid);
+        Assert.Contains(result.Errors, e => e.Contains("at least 8"));
+        Assert.True(result.Errors.Count >= 2);
+    }
+
+    [Fact]
+    public async Task Invalid_Phone_Is_Warning_Not_Error_Async() {
+        var user = new AsyncUserDto {
+            Name = "Erin",
+            Age = 28,
+            Email = "erin@example.com",
+            Password = "Abcdef12",
+            Phone = "123-456" // too few digits
+        };
+
+        var result = await user.ValidateAsync(user, CancellationToken.None);
+        Assert.True(result.IsValid);
+        Assert.Empty(result.Errors);
+        Assert.NotEmpty(result.Warnings);
+        Assert.Contains(result.Warnings, w => w.Contains("Phone"));
+    }
+}
diff --git a/tests/Verifast.Tests.Unit.Standard/User.cs b/tests/Verifast.Tests.Unit.Standard/User.cs
new file mode 100644
index 0000000..c3e6dff
--- /dev/null
+++ b/tests/Verifast.Tests.Unit.Standard/User.cs
@@ -0,0 +1,104 @@
+namespace Verifast.Tests.Unit.Standard;
+
+public class UserDto : IValidator<UserDto> {
+    public string? Name { get; set; }
+    public int Age { get; set; }
+    public string? Email { get; set; }
+    public string? Password { get; set; }
+    public string? Phone { get; set; }
+
+    public void Validate(in UserDto instance, ref ValidationResult<string> result) {
+        // Name: required, length 1..100
+        if (string.IsNullOrWhiteSpace(instance.Name)) {
+            result.AddError($"'{nameof(Name)}' must be non-empty");
+        } else if (instance.Name!.Length > 100) {
+            result.AddError($"'{nameof(Name)}' must be at most 100 characters");
+        }
+
+        // Age: 18..120 inclusive
+        if (instance.Age is < 18 or > 120) {
+            result.AddError($"'{nameof(Age)}' must be between 18 and 120");
+        }
+
+        // Email: very lightweight format check (no regex)
+        if (!string.IsNullOrWhiteSpace(instance.Email)) {
+            if (!IsLikelyEmail(instance.Email!)) {
+                result.AddError($"'{nameof(Email)}' must be a valid email");
+            }
+        }
+
+        // Password: required, min 8, has upper, lower, digit
+        if (string.IsNullOrEmpty(instance.Password)) {
+            result.AddError($"'{nameof(Password)}' must be non-empty");
+        } else {
+            var pwd = instance.Password!;
+            if (pwd.Length < 8) {
+                result.AddError($"'{nameof(Password)}' must be at least 8 characters");
+            }
+
+            bool hasUpper = false, hasLower = false, hasDigit = false;
+            for (int i = 0; i < pwd.Length; i++) {
+                char c = pwd[i];
+                if (!hasUpper && char.IsUpper(c)) {
+                    hasUpper = true;
+                } else if (!hasLower && char.IsLower(c)) {
+                    hasLower = true;
+                } else if (!hasDigit && char.IsDigit(c)) {
+                    hasDigit = true;
+                }
+
+                if (hasUpper && hasLower && hasDigit) {
+                    break;
+                }
+            }
+
+            if (!hasUpper) {
+                result.AddError($"'{nameof(Password)}' must contain an uppercase letter");
+            }
+
+            if (!hasLower) {
+                result.AddError($"'{nameof(Password)}' must contain a lowercase letter");
+            }
+
+            if (!hasDigit) {
+                result.AddError($"'{nameof(Password)}' must contain a digit");
+            }
+        }
+
+        // Phone: optional; if provided, basic E.164-ish (+?[0-9]{10,15})
+        if (!string.IsNullOrWhiteSpace(instance.Phone)) {
+            if (!IsLikelyPhone(instance.Phone!)) {
+                result.AddWarning($"'{nameof(Phone)}' format looks invalid");
+            }
+        }
+
+        static bool IsLikelyEmail(string s) {
+            // Minimal: exactly one '@', non-empty local/domain, domain has a '.' after '@'
+            int at = s.IndexOf('@');
+            if (at <= 0 || at >= s.Length - 1) return false;
+            int dot = s.IndexOf('.', at + 1);
+            if (dot <= at + 1 || dot >= s.Length - 1) return false;
+            return true;
+        }
+
+        static bool IsLikelyPhone(string s) {
+            int i = 0;
+            int digits = 0;
+            if (s[0] == '+') {
+                i = 1;
+            }
+
+            for (; i < s.Length; i++) {
+                char c = s[i];
+                if (char.IsDigit(c)) {
+                    digits++;
+                    continue;
+                }
+
+                return false;
+            }
+
+            return digits >= 10 && digits <= 15;
+        }
+    }
+}
diff --git a/tests/Verifast.Tests.Unit.Standard/UserTryValidateTests.cs b/tests/Verifast.Tests.Unit.Standard/UserTryValidateTests.cs
new file mode 100644
index 0000000..2116fc6
--- /dev/null
+++ b/tests/Verifast.Tests.Unit.Standard/UserTryValidateTests.cs
@@ -0,0 +1,99 @@
+namespace Verifast.Tests.Unit.Standard;
+
+public class UserTryValidateTests {
+    [Fact]
+    public void TryValidate_Valid_User_Has_No_Errors() {
+        var user = new UserDto {
+            Name = "Alice",
+            Age = 30,
+            Email = "alice@example.com",
+            Password = "Secret123",
+            Phone = "+14155552671"
+        };
+
+        var ok = user.TryValidate(user, out var result);
+        Assert.True(ok);
+        Assert.True(result.IsValid);
+        Assert.Empty(result.Errors);
+        Assert.Empty(result.Warnings);
+    }
+
+    [Fact]
+    public void TryValidate_Missing_Name_Is_Error() {
+        var user = new UserDto {
+            Name = "",
+            Age = 25,
+            Email = "bob@example.com",
+            Password = "Abcdef12"
+        };
+
+        var ok = user.TryValidate(user, out var result);
+        Assert.False(ok);
+        Assert.False(result.IsValid);
+        Assert.Contains(result.Errors, e => e.Contains("Name"));
+    }
+
+    [Fact]
+    public void TryValidate_Age_Out_Of_Range_Is_Error() {
+        var user = new UserDto {
+            Name = "Bob",
+            Age = 10,
+            Email = "bob@example.com",
+            Password = "Abcdef12"
+        };
+
+        var ok = user.TryValidate(user, out var result);
+        Assert.False(ok);
+        Assert.False(result.IsValid);
+        Assert.Contains(result.Errors, e => e.Contains("Age"));
+    }
+
+    [Fact]
+    public void TryValidate_Invalid_Email_Is_Error() {
+        var user = new UserDto {
+            Name = "Carol",
+            Age = 40,
+            Email = "invalid-email",
+            Password = "Abcdef12"
+        };
+
+        var ok = user.TryValidate(user, out var result);
+        Assert.False(ok);
+        Assert.False(result.IsValid);
+        Assert.Contains(result.Errors, e => e.Contains("Email"));
+    }
+
+    [Fact]
+    public void TryValidate_Password_Rules_Are_Validated() {
+        var user = new UserDto {
+            Name = "Dan",
+            Age = 22,
+            Email = "dan@example.com",
+            Password = "short"
+        };
+
+        var ok = user.TryValidate(user, out var result);
+        Assert.False(ok);
+        Assert.False(result.IsValid);
+        Assert.Contains(result.Errors, e => e.Contains("at least 8"));
+        Assert.True(result.Errors.Count >= 2);
+    }
+
+    [Fact]
+    public void TryValidate_Invalid_Phone_Is_Warning_Not_Error() {
+        var user = new UserDto {
+            Name = "Erin",
+            Age = 28,
+            Email = "erin@example.com",
+            Password = "Abcdef12",
+            Phone = "123-456" // too few digits
+        };
+
+        var ok = user.TryValidate(user, out var result);
+        Assert.True(ok);
+        Assert.True(result.IsValid);
+        Assert.Empty(result.Errors);
+        Assert.NotEmpty(result.Warnings);
+        Assert.Contains(result.Warnings, w => w.Contains("Phone"));
+    }
+}
diff --git a/tests/Verifast.Tests.Unit.Standard/UserValidatorTests.cs b/tests/Verifast.Tests.Unit.Standard/UserValidatorTests.cs
new file mode 100644
index 0000000..74fa35e
--- /dev/null
+++ b/tests/Verifast.Tests.Unit.Standard/UserValidatorTests.cs
@@ -0,0 +1,94 @@
+namespace Verifast.Tests.Unit.Standard;
+
+public class UserValidatorTests {
+    [Fact]
+    public void Valid_User_Has_No_Errors() {
+        var user = new UserDto {
+            Name = "Alice",
+            Age = 30,
+            Email = "alice@example.com",
+            Password = "Secret123",
+            Phone = "+14155552671"
+        };
+
+        var result = user.Validate(user);
+        Assert.True(result.IsValid);
+        Assert.Empty(result.Errors);
+        Assert.Empty(result.Warnings);
+    }
+
+    [Fact]
+    public void Missing_Name_Is_Error() {
+        var user = new UserDto {
+            Name = "",
+            Age = 5,
+            Email = "bob@example.com",
+            Password = "Abcdef12"
+        };
+
+        var result = user.Validate(user);
+        Assert.False(result.IsValid);
+        Assert.Contains(result.Errors, e => e.Contains("Name"));
+    }
+
+    [Fact]
+    public void Age_Out_Of_Range_Is_Error() {
+        var user = new UserDto {
+            Name = "Bob",
+            Age = 10,
+            Email = "bob@example.com",
+            Password = "Abcdef12"
+        };
+
+        var result = user.Validate(user);
+        Assert.False(result.IsValid);
+        Assert.Contains(result.Errors, e => e.Contains("Age"));
+    }
+
+    [Fact]
+    public void Invalid_Email_Is_Error() {
+        var user = new UserDto {
+            Name = "Carol",
+            Age = 40,
+            Email = "invalid-email",
+            Password = "Abcdef12"
+        };
+
+        var result = user.Validate(user);
+        Assert.False(result.IsValid);
+        Assert.Contains(result.Errors, e => e.Contains("Email"));
+    }
+
+    [Fact]
+    public void Password_Rules_Are_Validated() {
+        var user = new UserDto {
+            Name = "Dan",
+            Age = 22,
+            Email = "dan@example.com",
+            Password = "short"
+        };
+
+        var result = user.Validate(user);
+        Assert.False(result.IsValid);
+        Assert.Contains(result.Errors, e => e.Contains("at least 8"));
+        // Missing upper/lower/digit should trigger multiple errors
+        Assert.True(result.Errors.Count >= 2);
+    }
+
+    [Fact]
+    public void Invalid_Phone_Is_Warning_Not_Error() {
+        var user = new UserDto {
+            Name = "Erin",
+            Age = 28,
+            Email = "erin@example.com",
+            Password = "Abcdef12",
+            Phone = "123-456" // too few digits
+        };
+
+        var result = user.Validate(user);
+        Assert.True(result.IsValid);
+        Assert.Empty(result.Errors);
+        Assert.NotEmpty(result.Warnings);
+        Assert.Contains(result.Warnings, w => w.Contains("Phone"));
+    }
+}
diff --git a/tests/Verifast.Tests.Unit.Standard/Verifast.Tests.Unit.Standard.csproj b/tests/Verifast.Tests.Unit.Standard/Verifast.Tests.Unit.Standard.csproj
new file mode 100644
index 0000000..eb7e254
--- /dev/null
+++ b/tests/Verifast.Tests.Unit.Standard/Verifast.Tests.Unit.Standard.csproj
@@ -0,0 +1,31 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+    <TargetFramework>net8.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Content Include="xunit.runner.json" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../../src/Verifast/Verifast.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/Verifast.Tests.Unit.Standard/xunit.runner.json b/tests/Verifast.Tests.Unit.Standard/xunit.runner.json
new file mode 100644
index 0000000..86c7ea0
--- /dev/null
+++ b/tests/Verifast.Tests.Unit.Standard/xunit.runner.json
@@ -0,0 +1,3 @@
+{
+    "$schema": "https://xunit.net/schema/current/xunit.runner.schema.json"
+}
diff --git a/tests/Verifast.Tests.Unit/Verifast.Tests.Unit.csproj b/tests/Verifast.Tests.Unit/Verifast.Tests.Unit.csproj
index 53f0a66..557bbfc 100644
--- a/tests/Verifast.Tests.Unit/Verifast.Tests.Unit.csproj
+++ b/tests/Verifast.Tests.Unit/Verifast.Tests.Unit.csproj
@@ -4,18 +4,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <OutputType>Exe</OutputType>
-    <LangVersion>Verifast.Tests.Unit</LangVersion>
     <TargetFramework>net9.0</TargetFramework>
-    <!--
-    To enable the Microsoft Testing Platform 'dotnet test' experience, add property:
-      <TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>
-
-    To enable the Microsoft Testing Platform native command line experience, add property:
-      <UseMicrosoftTestingPlatformRunner>true</UseMicrosoftTestingPlatformRunner>
-
-    For more information on Microsoft Testing Platform support in xUnit.net, please visit:
-      https://xunit.net/docs/getting-started/v3/microsoft-testing-platform
-    -->
   </PropertyGroup>
 
   <ItemGroup>
@@ -27,9 +16,12 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
-    <PackageReference Include="xunit.v3" Version="3.0.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.4" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
+    <PackageReference Include="xunit.v3" Version="3.2.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
   </ItemGroup>
 
   <ItemGroup>

From c14619669ce6514653eb89c5f6d3aaa60414e80b Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 10:57:41 +0200
Subject: [PATCH 06/18] Use ValueTask by conditionally add dependency

---
 AGENTS.md                                     |  2 +-
 src/Verifast/IAsyncValidator.cs               | 30 ++++++++++
 src/Verifast/IValidator.cs                    | 58 -------------------
 src/Verifast/Verifast.csproj                  |  8 ++-
 .../Verifast.Tests.Unit.Standard/AsyncUser.cs |  2 +-
 5 files changed, 38 insertions(+), 62 deletions(-)
 create mode 100644 src/Verifast/IAsyncValidator.cs

diff --git a/AGENTS.md b/AGENTS.md
index 728cab9..a3b05df 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -9,7 +9,7 @@ This file provides guidance to agents when working with code in this repository.
 ## Big‑Picture Architecture
 - Validation contracts:
   - `IValidator<T, TMessage>` and `IValidator<T>`: synchronous validators. On `net9.0`, both use `where T : allows ref struct` so validators can be used with stack‑only types without forcing `ref struct` everywhere. On `netstandard2.0`, the constraint is omitted.
-  - `IAsyncValidator<T, TMessage>` and `IAsyncValidator<T>`: asynchronous validators. On `net9.0` they return `ValueTask<ValidationResult<...>>`; on `netstandard2.0` they return `Task<ValidationResult<...>>` and are declared with `in T` variance.
+  - `IAsyncValidator<T, TMessage>` and `IAsyncValidator<T>`: asynchronous validators returning `ValueTask<ValidationResult<...>>` across targets. The `netstandard2.0` forms are declared with `in T` variance.
 - Orchestrator APIs:
   - Static `Validator` class: extension methods for synchronous validation and `TryValidate` overloads. Only sync helpers exist (no async orchestrator today). On `net9.0` the extensions include `allows ref struct` constraints.
 - Result type:
diff --git a/src/Verifast/IAsyncValidator.cs b/src/Verifast/IAsyncValidator.cs
new file mode 100644
index 0000000..7c97afa
--- /dev/null
+++ b/src/Verifast/IAsyncValidator.cs
@@ -0,0 +1,30 @@
+namespace Verifast;
+
+/// <summary>
+/// Interface for implementing an asynchronous validator for <typeparamref name="T"/> with message type <typeparamref name="TMessage"/>
+/// </summary>
+/// <typeparam name="T"></typeparam>
+/// <typeparam name="TMessage"></typeparam>
+public interface IAsyncValidator<T, TMessage> {
+    /// <summary>
+    /// ValidateAsync method
+    /// </summary>
+    /// <param name="instance"></param>
+    /// <param name="ct"></param>
+    /// <returns></returns>
+    ValueTask<ValidationResult<TMessage>> ValidateAsync(T instance, CancellationToken ct = default);
+}
+
+/// <summary>
+/// Interface for implementing an asynchronous validator for <typeparamref name="T"/>
+/// </summary>
+/// <typeparam name="T"></typeparam>
+public interface IAsyncValidator<T> {
+    /// <summary>
+    /// ValidateAsync method
+    /// </summary>
+    /// <param name="instance"></param>
+    /// <param name="ct"></param>
+    /// <returns></returns>
+    ValueTask<ValidationResult<string>> ValidateAsync(T instance, CancellationToken ct = default);
+}
\ No newline at end of file
diff --git a/src/Verifast/IValidator.cs b/src/Verifast/IValidator.cs
index 73656d4..6c8959a 100644
--- a/src/Verifast/IValidator.cs
+++ b/src/Verifast/IValidator.cs
@@ -27,35 +27,6 @@ public interface IValidator<T> where T : allows ref struct {
 	/// <param name="result"></param>
     void Validate(in T instance, ref ValidationResult<string> result);
 }
-
-/// <summary>
-/// Interface for implementing an asynchronous validator for <typeparamref name="T"/> with message type <typeparamref name="TMessage"/>
-/// </summary>
-/// <typeparam name="T"></typeparam>
-/// <typeparam name="TMessage"></typeparam>
-public interface IAsyncValidator<T, TMessage> {
-    /// <summary>
-    /// ValidateAsync method
-    /// </summary>
-    /// <param name="instance"></param>
-    /// <param name="ct"></param>
-    /// <returns></returns>
-    ValueTask<ValidationResult<TMessage>> ValidateAsync(T instance, CancellationToken ct = default);
-}
-
-/// <summary>
-/// Interface for implementing an asynchronous validator for <typeparamref name="T"/>
-/// </summary>
-/// <typeparam name="T"></typeparam>
-public interface IAsyncValidator<T> {
-    /// <summary>
-    /// ValidateAsync method
-    /// </summary>
-    /// <param name="instance"></param>
-    /// <param name="ct"></param>
-    /// <returns></returns>
-    ValueTask<ValidationResult<string>> ValidateAsync(T instance, CancellationToken ct = default);
-}
 #else
 /// <summary>
 /// Interface for implementing a synchronous validator for <typeparamref name="T"/> with message type <typeparamref name="TMessage"/>
@@ -83,33 +54,4 @@ public interface IValidator<T> {
 	/// <param name="result"></param>
     void Validate(in T instance, ref ValidationResult<string> result);
 }
-
-/// <summary>
-/// Interface for implementing an asynchronous validator for <typeparamref name="T"/> with message type <typeparamref name="TMessage"/>
-/// </summary>
-/// <typeparam name="T"></typeparam>
-/// <typeparam name="TMessage"></typeparam>
-public interface IAsyncValidator<in T, TMessage> {
-    /// <summary>
-    /// ValidateAsync method
-    /// </summary>
-    /// <param name="instance"></param>
-    /// <param name="ct"></param>
-    /// <returns></returns>
-    Task<ValidationResult<TMessage>> ValidateAsync(T instance, CancellationToken ct = default);
-}
-
-/// <summary>
-/// Interface for implementing an asynchronous validator for <typeparamref name="T"/>
-/// </summary>
-/// <typeparam name="T"></typeparam>
-public interface IAsyncValidator<in T> {
-    /// <summary>
-    /// ValidateAsync method
-    /// </summary>
-    /// <param name="instance"></param>
-    /// <param name="ct"></param>
-    /// <returns></returns>
-    Task<ValidationResult<string>> ValidateAsync(T instance, CancellationToken ct = default);
-}
 #endif
\ No newline at end of file
diff --git a/src/Verifast/Verifast.csproj b/src/Verifast/Verifast.csproj
index 8fa2306..0c6634b 100644
--- a/src/Verifast/Verifast.csproj
+++ b/src/Verifast/Verifast.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <Version>0.1.0.0</Version>
+    <Version>1.0.0.0</Version>
 
     <TargetFrameworks>net9.0;netstandard2.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
@@ -37,6 +37,10 @@
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" PrivateAssets="All" />
   </ItemGroup>
 
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.6.3" />
+  </ItemGroup>
+
   <PropertyGroup>
     <DebugType>portable</DebugType>
     <EmbedUntrackedSources>true</EmbedUntrackedSources>
@@ -54,4 +58,4 @@
     </PackageReleaseNotes>
   </PropertyGroup>
 
-</Project>
\ No newline at end of file
+</Project>
diff --git a/tests/Verifast.Tests.Unit.Standard/AsyncUser.cs b/tests/Verifast.Tests.Unit.Standard/AsyncUser.cs
index 6ccf64a..d46cb36 100644
--- a/tests/Verifast.Tests.Unit.Standard/AsyncUser.cs
+++ b/tests/Verifast.Tests.Unit.Standard/AsyncUser.cs
@@ -7,7 +7,7 @@ public class AsyncUserDto : IAsyncValidator<AsyncUserDto> {
     public string? Password { get; set; }
     public string? Phone { get; set; }
 
-    public async Task<ValidationResult<string>> ValidateAsync(AsyncUserDto instance, CancellationToken ct = default) {
+    public async ValueTask<ValidationResult<string>> ValidateAsync(AsyncUserDto instance, CancellationToken ct = default) {
         // Emulate asynchronous work so tests exercise the async path
         await Task.Yield();
         ct.ThrowIfCancellationRequested();

From a039a077919cd95c488878fa63936ae8db2c9fe3 Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 11:02:09 +0200
Subject: [PATCH 07/18] Make T contravarient

---
 src/Verifast/IAsyncValidator.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Verifast/IAsyncValidator.cs b/src/Verifast/IAsyncValidator.cs
index 7c97afa..aad2e0a 100644
--- a/src/Verifast/IAsyncValidator.cs
+++ b/src/Verifast/IAsyncValidator.cs
@@ -5,7 +5,7 @@
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <typeparam name="TMessage"></typeparam>
-public interface IAsyncValidator<T, TMessage> {
+public interface IAsyncValidator<in T, TMessage> {
     /// <summary>
     /// ValidateAsync method
     /// </summary>
@@ -19,7 +19,7 @@ public interface IAsyncValidator<T, TMessage> {
 /// Interface for implementing an asynchronous validator for <typeparamref name="T"/>
 /// </summary>
 /// <typeparam name="T"></typeparam>
-public interface IAsyncValidator<T> {
+public interface IAsyncValidator<in T> {
     /// <summary>
     /// ValidateAsync method
     /// </summary>

From d8a1b009b96ec32700174df6c640bf3a660973f0 Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 11:11:18 +0200
Subject: [PATCH 08/18] Adjust dependencies for netcore

---
 AGENTS.md                                                     | 4 ++--
 src/Verifast/Verifast.csproj                                  | 2 +-
 .../Verifast.Tests.Unit.Standard.csproj                       | 3 ++-
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index a3b05df..fb74b74 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -3,12 +3,12 @@
 This file provides guidance to agents when working with code in this repository.
 
 ## Project Overview
-- Tech: Multi‑targeted .NET library (`src/Verifast`) targeting `net9.0` and `netstandard2.0`, focused on fast, allocation‑aware validation. Unit tests live in `tests/Verifast.Tests.Unit` (net9.0) using xUnit v3 with the Microsoft Testing Platform, and `tests/Verifast.Tests.Unit.Standard` (net8.0) using xUnit v2 to exercise the `netstandard2.0` target. A minimal benchmarks project exists under `benchmarks/Verifast.Benchmarks` (net9.0).
+- Tech: Multi‑targeted .NET library (`src/Verifast`) targeting `net9.0`, `netstandard2.1`, and `netstandard2.0`, focused on fast, allocation‑aware validation. Unit tests live in `tests/Verifast.Tests.Unit` (net9.0) using xUnit v3 with the Microsoft Testing Platform, and `tests/Verifast.Tests.Unit.Standard` (net8.0) using xUnit v2 to exercise the `netstandard2.0` target. A minimal benchmarks project exists under `benchmarks/Verifast.Benchmarks` (net9.0).
 - Design: The library centers on simple, interface‑driven validators and a lightweight result type that captures errors and warnings only when needed.
 
 ## Big‑Picture Architecture
 - Validation contracts:
-  - `IValidator<T, TMessage>` and `IValidator<T>`: synchronous validators. On `net9.0`, both use `where T : allows ref struct` so validators can be used with stack‑only types without forcing `ref struct` everywhere. On `netstandard2.0`, the constraint is omitted.
+  - `IValidator<T, TMessage>` and `IValidator<T>`: synchronous validators. On `net9.0`, both use `where T : allows ref struct` so validators can be used with stack‑only types without forcing `ref struct` everywhere. On `netstandard2.1`/`netstandard2.0`, the constraint is omitted.
   - `IAsyncValidator<T, TMessage>` and `IAsyncValidator<T>`: asynchronous validators returning `ValueTask<ValidationResult<...>>` across targets. The `netstandard2.0` forms are declared with `in T` variance.
 - Orchestrator APIs:
   - Static `Validator` class: extension methods for synchronous validation and `TryValidate` overloads. Only sync helpers exist (no async orchestrator today). On `net9.0` the extensions include `allows ref struct` constraints.
diff --git a/src/Verifast/Verifast.csproj b/src/Verifast/Verifast.csproj
index 0c6634b..edc6e57 100644
--- a/src/Verifast/Verifast.csproj
+++ b/src/Verifast/Verifast.csproj
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Version>1.0.0.0</Version>
 
-    <TargetFrameworks>net9.0;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>net9.0;netstandard2.1;netstandard2.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <LangVersion>latest</LangVersion>
diff --git a/tests/Verifast.Tests.Unit.Standard/Verifast.Tests.Unit.Standard.csproj b/tests/Verifast.Tests.Unit.Standard/Verifast.Tests.Unit.Standard.csproj
index eb7e254..4853328 100644
--- a/tests/Verifast.Tests.Unit.Standard/Verifast.Tests.Unit.Standard.csproj
+++ b/tests/Verifast.Tests.Unit.Standard/Verifast.Tests.Unit.Standard.csproj
@@ -25,7 +25,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="../../src/Verifast/Verifast.csproj" />
+    <ProjectReference Include="../../src/Verifast/Verifast.csproj"
+                      AdditionalProperties="TargetFramework=netstandard2.0" />
   </ItemGroup>
 
 </Project>

From 072930cb728dddc56d05691aaaee234aa96143d0 Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 11:13:00 +0200
Subject: [PATCH 09/18] Update dependencies

---
 benchmarks/Verifast.Benchmarks/Verifast.Benchmarks.csproj | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/benchmarks/Verifast.Benchmarks/Verifast.Benchmarks.csproj b/benchmarks/Verifast.Benchmarks/Verifast.Benchmarks.csproj
index cc0fe65..e41379e 100644
--- a/benchmarks/Verifast.Benchmarks/Verifast.Benchmarks.csproj
+++ b/benchmarks/Verifast.Benchmarks/Verifast.Benchmarks.csproj
@@ -8,9 +8,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.15.2" />
-    <PackageReference Include="Bogus" Version="35.6.3" />
-    <PackageReference Include="FluentValidation" Version="12.0.0" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.15.8" />
+    <PackageReference Include="Bogus" Version="35.6.5" />
+    <PackageReference Include="FluentValidation" Version="12.1.1" />
   </ItemGroup>
 
   <ItemGroup>

From c609c60896891f9bbdaf4e44b176d709cd2ef954 Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 11:19:18 +0200
Subject: [PATCH 10/18] Lower trimming compatibility

---
 src/Verifast/Verifast.csproj | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Verifast/Verifast.csproj b/src/Verifast/Verifast.csproj
index edc6e57..419e632 100644
--- a/src/Verifast/Verifast.csproj
+++ b/src/Verifast/Verifast.csproj
@@ -13,9 +13,9 @@
     <EnableNETAnalyzers>true</EnableNETAnalyzers>
     <AnalysisLevel>latest-recommended</AnalysisLevel>
     <IsAotCompatible
-      Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net9.0'))">true</IsAotCompatible>
+      Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net8.0'))">true</IsAotCompatible>
     <IsTrimmable
-      Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net9.0'))">true</IsTrimmable>
+      Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net8.0'))">true</IsTrimmable>
 
     <Authors>David Shnayder</Authors>
     <Copyright>David Shnayder</Copyright>

From 4cdc707e8bc3cd1008e49e4c260e2a85bbbb6602 Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 11:21:57 +0200
Subject: [PATCH 11/18] Add standard2.0 tests to actions

---
 .github/workflows/unit-tests.yaml | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/unit-tests.yaml b/.github/workflows/unit-tests.yaml
index 9bc8a46..123d9f7 100644
--- a/.github/workflows/unit-tests.yaml
+++ b/.github/workflows/unit-tests.yaml
@@ -14,4 +14,14 @@ jobs:
     with:
       platform: ${{ matrix.platform }}
       dotnet-version: 9.0.x
-      test-project-path: tests/Verifast.Tests.Unit/Verifast.Tests.Unit.csproj
\ No newline at end of file
+      test-project-path: tests/Verifast.Tests.Unit/Verifast.Tests.Unit.csproj
+  unit-tests-standard:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-latest, windows-latest, macos-latest]
+    uses: dusrdev/actions/.github/workflows/reusable-dotnet-test.yaml@main
+    with:
+      platform: ${{ matrix.platform }}
+      dotnet-version: 8.0.x
+      test-project-path: tests/Verifast.Tests.Unit.Standard/Verifast.Tests.Unit.Standard.csproj
\ No newline at end of file

From c90a17f8bf1f75584df20d384d1c5e6acbc607de Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 11:40:06 +0200
Subject: [PATCH 12/18] Update docs

---
 README.md                    | 12 ++++--------
 src/Verifast/Verifast.csproj |  3 +--
 2 files changed, 5 insertions(+), 10 deletions(-)

diff --git a/README.md b/README.md
index 88cc841..24fbc9a 100644
--- a/README.md
+++ b/README.md
@@ -3,9 +3,9 @@
 [![NuGet](https://img.shields.io/nuget/v/Verifast.svg?style=flat-square)](https://www.nuget.org/packages/Verifast)
 [![NuGet Downloads](https://img.shields.io/nuget/dt/Verifast?style=flat&label=Downloads)](https://www.nuget.org/packages/Verifast)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)](LICENSE)
-[![.NET](https://img.shields.io/badge/.NET-9.0-512BD4?style=flat-square)](#)
+[![.NET](https://img.shields.io/badge/.NET-net9.0%20%7C%20netstandard2.1%20%7C%20netstandard2.0-512BD4?style=flat-square)](#)
 
-High‑performance, allocation‑friendly validation for .NET 9 and above. No complicated APIs, no expression trees - just plain C#. Implement a tiny interface, add errors or warnings, and you’re done.
+High‑performance, allocation‑friendly validation for .NET 9 and netstandard (2.1/2.0). No complicated APIs, no expression trees - just plain C#. Implement a tiny interface, add errors or warnings, and you’re done.
 
 ## Why Verifast
 
@@ -21,10 +21,6 @@ High‑performance, allocation‑friendly validation for .NET 9 and above. No co
 dotnet add package Verifast
 ```
 
-## Versioning
-
-While the version is below `1.0.0.0` minor versions can change the public API without warning (SemVer will not be followed until `1.0.0.0` is reached).
-
 ## Quick Start
 
 Define your model and implement its validator. Then call the extension helpers.
@@ -34,7 +30,7 @@ using Verifast;
 
 public readonly record struct User(string? Name, int Age);
 
-public readonly ref struct UserValidator : IValidator<User> {
+public readonly struct UserValidator : IValidator<User> {
     public void Validate(in User instance, ref ValidationResult<string> result) {
         if (string.IsNullOrWhiteSpace(instance.Name))
             result.AddError("'Name' must be non-empty");
@@ -95,7 +91,7 @@ using Verifast;
 
 public readonly record struct Msg(string Code, string Text);
 
-public readonly ref struct EvenValidator : IValidator<int, Msg> {
+public readonly struct EvenValidator : IValidator<int, Msg> {
     public void Validate(in int value, ref ValidationResult<Msg> result) {
         if ((value & 1) != 0)
             result.AddError(new Msg("NotEven", "Value must be even"));
diff --git a/src/Verifast/Verifast.csproj b/src/Verifast/Verifast.csproj
index 419e632..4202034 100644
--- a/src/Verifast/Verifast.csproj
+++ b/src/Verifast/Verifast.csproj
@@ -54,8 +54,7 @@
   </ItemGroup>
 
   <PropertyGroup>
-    <PackageReleaseNotes>
-    </PackageReleaseNotes>
+    <PackageReleaseNotes>Added support for netstandard2.0 and netstandard2.1.</PackageReleaseNotes>
   </PropertyGroup>
 
 </Project>

From d64a1cc7a6bac1e3883ed85948bdfa1c0e09ae03 Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 11:53:00 +0200
Subject: [PATCH 13/18] Use net10 for benchmarks

---
 benchmarks/Verifast.Benchmarks/Verifast.Benchmarks.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/benchmarks/Verifast.Benchmarks/Verifast.Benchmarks.csproj b/benchmarks/Verifast.Benchmarks/Verifast.Benchmarks.csproj
index e41379e..e8c5c9c 100644
--- a/benchmarks/Verifast.Benchmarks/Verifast.Benchmarks.csproj
+++ b/benchmarks/Verifast.Benchmarks/Verifast.Benchmarks.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>

From 187a1d0025b64f6dbd859e072cee0f62a92d6ec1 Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 12:09:20 +0200
Subject: [PATCH 14/18] Add benchmark results

---
 .../BenchmarkRun-joined.md                    | 23 +++++++++++++++++++
 .../Benchmarks/AsyncValidation.cs             |  8 +++----
 .../Benchmarks/SyncValidation.cs              |  8 +++----
 .../Models/BenchmarkConfig.cs                 |  7 ++++--
 4 files changed, 36 insertions(+), 10 deletions(-)
 create mode 100644 benchmarks/Verifast.Benchmarks/BenchmarkRun-joined.md

diff --git a/benchmarks/Verifast.Benchmarks/BenchmarkRun-joined.md b/benchmarks/Verifast.Benchmarks/BenchmarkRun-joined.md
new file mode 100644
index 0000000..a04e927
--- /dev/null
+++ b/benchmarks/Verifast.Benchmarks/BenchmarkRun-joined.md
@@ -0,0 +1,23 @@
+```
+
+BenchmarkDotNet v0.15.8, macOS Tahoe 26.1 (25B78) [Darwin 25.1.0]
+Apple M2 Pro, 1 CPU, 10 logical and 10 physical cores
+.NET SDK 10.0.101
+  [Host]    : .NET 10.0.1 (10.0.1, 10.0.125.57005), Arm64 RyuJIT armv8.0-a
+  MediumRun : .NET 10.0.1 (10.0.1, 10.0.125.57005), Arm64 RyuJIT armv8.0-a
+
+Job=MediumRun  OutlierMode=RemoveAll  IterationCount=15  
+IterationTime=100ms  LaunchCount=2  WarmupCount=10  
+
+```
+| Type            | Method           | ValidDto | Mean        | Ratio           | Rank | Allocated | Alloc Ratio   |
+|---------------- |----------------- |--------- |------------:|----------------:|-----:|----------:|--------------:|
+| AsyncValidation | FluentValidation | False    | 10,935.2 ns |        baseline |    4 |   14104 B |               |
+| AsyncValidation | Verifast         | False    |  2,203.2 ns |    4.96x faster |    2 |    1096 B |   12.87x less |
+| AsyncValidation | FluentValidation | True     |  8,470.8 ns |        baseline |    3 |    9808 B |               |
+| AsyncValidation | Verifast         | True     |  2,101.9 ns |    5.20x faster |    1 |    1016 B |   13.88x less |
+|                 |                  |          |             |                 |      |           |               |
+| SyncValidation  | FluentValidation | False    | 35,687.7 ns |        baseline |    4 |   63112 B |               |
+| SyncValidation  | Verifast         | False    |    141.4 ns | 252.377x faster |    2 |     328 B | 192.415x less |
+| SyncValidation  | FluentValidation | True     | 26,091.2 ns |        baseline |    3 |   50063 B |               |
+| SyncValidation  | Verifast         | True     |    112.3 ns | 320.264x faster |    1 |         - |            NA |
diff --git a/benchmarks/Verifast.Benchmarks/Benchmarks/AsyncValidation.cs b/benchmarks/Verifast.Benchmarks/Benchmarks/AsyncValidation.cs
index 3b48622..5af8321 100644
--- a/benchmarks/Verifast.Benchmarks/Benchmarks/AsyncValidation.cs
+++ b/benchmarks/Verifast.Benchmarks/Benchmarks/AsyncValidation.cs
@@ -6,7 +6,7 @@ namespace Verifast.Benchmarks.Benchmarks;
 
 public class AsyncValidation {
     [Params(true, false)]
-    public bool DtoValid { get; set; }
+    public bool ValidDto { get; set; }
 
     private UserProfile? _dto;
     private FakeUserRepository _repo = null!;
@@ -18,19 +18,19 @@ public async Task Setup() {
         // Simulate seeding work
         await _repo.AddAsync("taken@spam.com");
 
-        _dto = DtoValid
+        _dto = ValidDto
             ? UserProfileFactory.CreateValid("valid@example.com")
             : UserProfileFactory.CreateInvalid("taken@spam.com");
     }
 
-    [Benchmark(Baseline = true)]
+    [Benchmark(Baseline = true, Description = "FluentValidation")]
     public async Task<int> FluentValidation_Async() {
         var validator = new UserProfileFluentAsyncValidator(_repo);
         var result = await validator.ValidateAsync(_dto!);
         return result.Errors.Count;
     }
 
-    [Benchmark]
+    [Benchmark(Description = "Verifast")]
     public async Task<int> Verifast_Async() {
         var validator = new AsyncUserProfileVerifastValidator(_repo);
         var result = await validator.ValidateAsync(_dto!);
diff --git a/benchmarks/Verifast.Benchmarks/Benchmarks/SyncValidation.cs b/benchmarks/Verifast.Benchmarks/Benchmarks/SyncValidation.cs
index dc9951a..0529dd5 100644
--- a/benchmarks/Verifast.Benchmarks/Benchmarks/SyncValidation.cs
+++ b/benchmarks/Verifast.Benchmarks/Benchmarks/SyncValidation.cs
@@ -7,25 +7,25 @@ namespace Verifast.Benchmarks.Benchmarks;
 [ReturnValueValidator]
 public class SyncValidation {
     [Params(true, false)]
-    public bool DtoValid { get; set; }
+    public bool ValidDto { get; set; }
 
     private UserProfile? _dto;
 
     [GlobalSetup]
     public void Setup() {
-        _dto = DtoValid
+        _dto = ValidDto
             ? UserProfileFactory.CreateValid()
             : UserProfileFactory.CreateInvalid();
     }
 
-    [Benchmark(Baseline = true)]
+    [Benchmark(Baseline = true, Description = "FluentValidation")]
     public int FluentValidation() {
         var validator = new UserProfileFluentValidator();
         var result = validator.Validate(_dto!);
         return result.Errors.Count;
     }
 
-    [Benchmark]
+    [Benchmark(Description = "Verifast")]
     public int Verifast() {
         var validator = new UserProfileVerifastValidator();
         var result = validator.Validate(_dto!);
diff --git a/benchmarks/Verifast.Benchmarks/Models/BenchmarkConfig.cs b/benchmarks/Verifast.Benchmarks/Models/BenchmarkConfig.cs
index 56006ab..6694d2b 100644
--- a/benchmarks/Verifast.Benchmarks/Models/BenchmarkConfig.cs
+++ b/benchmarks/Verifast.Benchmarks/Models/BenchmarkConfig.cs
@@ -3,12 +3,14 @@
 using BenchmarkDotNet.Columns;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Diagnosers;
+using BenchmarkDotNet.Exporters;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Loggers;
 using BenchmarkDotNet.Order;
 using BenchmarkDotNet.Reports;
 using BenchmarkDotNet.Running;
 
+using Perfolizer.Horology;
 using Perfolizer.Mathematics.OutlierDetection;
 
 namespace Verifast.Benchmarks.Models;
@@ -17,14 +19,15 @@ public class BenchmarkConfig : ManualConfig {
     public BenchmarkConfig() {
         SummaryStyle = SummaryStyle.Default.WithRatioStyle(RatioStyle.Trend);
         AddDiagnoser(MemoryDiagnoser.Default);
-        AddJob(Job.MediumRun.WithOutlierMode(OutlierMode.RemoveAll));
+        AddJob(Job.MediumRun.WithOutlierMode(OutlierMode.RemoveAll).WithIterationTime(TimeInterval.FromMilliseconds(100)));
         AddColumnProvider(DefaultColumnProviders.Instance);
         AddColumn(RankColumn.Arabic);
-        HideColumns(Column.Error, Column.StdDev, Column.Median, Column.RatioSD);
+        HideColumns(Column.Error, Column.StdDev, Column.Median, Column.RatioSD, Column.Gen0, Column.Gen1, Column.Gen2);
         WithOrderer(new GroupByTypeOrderer());
         WithOptions(ConfigOptions.JoinSummary);
         WithOptions(ConfigOptions.StopOnFirstError);
         WithOptions(ConfigOptions.DisableLogFile);
+        AddExporter(MarkdownExporter.GitHub);
         AddLogger(ConsoleLogger.Default);
     }
 }

From 2e110c5b3e868bee7facec8a41dc1375f8087aaf Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 12:21:45 +0200
Subject: [PATCH 15/18] Show benchmarks in readme

---
 README.md | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/README.md b/README.md
index 24fbc9a..f613b2b 100644
--- a/README.md
+++ b/README.md
@@ -15,6 +15,22 @@ High‑performance, allocation‑friendly validation for .NET 9 and netstandard
 - Plays well with `ref struct`: APIs are designed to enable stack‑only scenarios.
 - Your messages, your way: use `string` or a custom `TMessage` for richer metadata.
 
+## Benchmarks
+
+[BenchmarkDotNet](https://benchmarkdotnet.org/) results comparing `Verifast` to [FluentValidation](https://github.com/FluentValidation/FluentValidation) (baseline, industry standard). Full report: [BenchmarkRun-joined.md](benchmarks/Verifast.Benchmarks/BenchmarkRun-joined.md).
+
+| Type            | Method           | ValidDto | Mean        | Ratio           | Rank | Allocated | Alloc Ratio   |
+|---------------- |----------------- |--------- |------------:|----------------:|-----:|----------:|--------------:|
+| AsyncValidation | FluentValidation | False    | 10,935.2 ns |        baseline |    4 |   14104 B |               |
+| AsyncValidation | Verifast         | False    |  2,203.2 ns |    4.96x faster |    2 |    1096 B |   12.87x less |
+| AsyncValidation | FluentValidation | True     |  8,470.8 ns |        baseline |    3 |    9808 B |               |
+| AsyncValidation | Verifast         | True     |  2,101.9 ns |    5.20x faster |    1 |    1016 B |   13.88x less |
+|                 |                  |          |             |                 |      |           |               |
+| SyncValidation  | FluentValidation | False    | 35,687.7 ns |        baseline |    4 |   63112 B |               |
+| SyncValidation  | Verifast         | False    |    141.4 ns | 252.377x faster |    2 |     328 B | 192.415x less |
+| SyncValidation  | FluentValidation | True     | 26,091.2 ns |        baseline |    3 |   50063 B |               |
+| SyncValidation  | Verifast         | True     |    112.3 ns | 320.264x faster |    1 |         - |            NA |
+
 ## Install
 
 ```bash

From 9c0f27e8f5f0023ae0ca43c79776266364d51231 Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 12:24:08 +0200
Subject: [PATCH 16/18] Remove rank from results

---
 README.md                                     | 22 +++++++++----------
 .../BenchmarkRun-joined.md                    | 22 +++++++++----------
 .../Models/BenchmarkConfig.cs                 |  2 +-
 3 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/README.md b/README.md
index f613b2b..ca3c92d 100644
--- a/README.md
+++ b/README.md
@@ -19,17 +19,17 @@ High‑performance, allocation‑friendly validation for .NET 9 and netstandard
 
 [BenchmarkDotNet](https://benchmarkdotnet.org/) results comparing `Verifast` to [FluentValidation](https://github.com/FluentValidation/FluentValidation) (baseline, industry standard). Full report: [BenchmarkRun-joined.md](benchmarks/Verifast.Benchmarks/BenchmarkRun-joined.md).
 
-| Type            | Method           | ValidDto | Mean        | Ratio           | Rank | Allocated | Alloc Ratio   |
-|---------------- |----------------- |--------- |------------:|----------------:|-----:|----------:|--------------:|
-| AsyncValidation | FluentValidation | False    | 10,935.2 ns |        baseline |    4 |   14104 B |               |
-| AsyncValidation | Verifast         | False    |  2,203.2 ns |    4.96x faster |    2 |    1096 B |   12.87x less |
-| AsyncValidation | FluentValidation | True     |  8,470.8 ns |        baseline |    3 |    9808 B |               |
-| AsyncValidation | Verifast         | True     |  2,101.9 ns |    5.20x faster |    1 |    1016 B |   13.88x less |
-|                 |                  |          |             |                 |      |           |               |
-| SyncValidation  | FluentValidation | False    | 35,687.7 ns |        baseline |    4 |   63112 B |               |
-| SyncValidation  | Verifast         | False    |    141.4 ns | 252.377x faster |    2 |     328 B | 192.415x less |
-| SyncValidation  | FluentValidation | True     | 26,091.2 ns |        baseline |    3 |   50063 B |               |
-| SyncValidation  | Verifast         | True     |    112.3 ns | 320.264x faster |    1 |         - |            NA |
+| Type            | Method           | ValidDto | Mean        | Ratio           | Allocated | Alloc Ratio   |
+|---------------- |----------------- |--------- |------------:|----------------:|----------:|--------------:|
+| AsyncValidation | FluentValidation | False    | 10,935.2 ns |        baseline |   14104 B |               |
+| AsyncValidation | Verifast         | False    |  2,203.2 ns |    4.96x faster |    1096 B |   12.87x less |
+| AsyncValidation | FluentValidation | True     |  8,470.8 ns |        baseline |    9808 B |               |
+| AsyncValidation | Verifast         | True     |  2,101.9 ns |    5.20x faster |    1016 B |   13.88x less |
+|                 |                  |          |             |                 |           |               |
+| SyncValidation  | FluentValidation | False    | 35,687.7 ns |        baseline |   63112 B |               |
+| SyncValidation  | Verifast         | False    |    141.4 ns | 252.377x faster |     328 B | 192.415x less |
+| SyncValidation  | FluentValidation | True     | 26,091.2 ns |        baseline |   50063 B |               |
+| SyncValidation  | Verifast         | True     |    112.3 ns | 320.264x faster |         - |            NA |
 
 ## Install
 
diff --git a/benchmarks/Verifast.Benchmarks/BenchmarkRun-joined.md b/benchmarks/Verifast.Benchmarks/BenchmarkRun-joined.md
index a04e927..2dd69fa 100644
--- a/benchmarks/Verifast.Benchmarks/BenchmarkRun-joined.md
+++ b/benchmarks/Verifast.Benchmarks/BenchmarkRun-joined.md
@@ -10,14 +10,14 @@ Job=MediumRun  OutlierMode=RemoveAll  IterationCount=15
 IterationTime=100ms  LaunchCount=2  WarmupCount=10  
 
 ```
-| Type            | Method           | ValidDto | Mean        | Ratio           | Rank | Allocated | Alloc Ratio   |
-|---------------- |----------------- |--------- |------------:|----------------:|-----:|----------:|--------------:|
-| AsyncValidation | FluentValidation | False    | 10,935.2 ns |        baseline |    4 |   14104 B |               |
-| AsyncValidation | Verifast         | False    |  2,203.2 ns |    4.96x faster |    2 |    1096 B |   12.87x less |
-| AsyncValidation | FluentValidation | True     |  8,470.8 ns |        baseline |    3 |    9808 B |               |
-| AsyncValidation | Verifast         | True     |  2,101.9 ns |    5.20x faster |    1 |    1016 B |   13.88x less |
-|                 |                  |          |             |                 |      |           |               |
-| SyncValidation  | FluentValidation | False    | 35,687.7 ns |        baseline |    4 |   63112 B |               |
-| SyncValidation  | Verifast         | False    |    141.4 ns | 252.377x faster |    2 |     328 B | 192.415x less |
-| SyncValidation  | FluentValidation | True     | 26,091.2 ns |        baseline |    3 |   50063 B |               |
-| SyncValidation  | Verifast         | True     |    112.3 ns | 320.264x faster |    1 |         - |            NA |
+| Type            | Method           | ValidDto | Mean        | Ratio           | Allocated | Alloc Ratio   |
+|---------------- |----------------- |--------- |------------:|----------------:|----------:|--------------:|
+| AsyncValidation | FluentValidation | False    | 10,935.2 ns |        baseline |   14104 B |               |
+| AsyncValidation | Verifast         | False    |  2,203.2 ns |    4.96x faster |    1096 B |   12.87x less |
+| AsyncValidation | FluentValidation | True     |  8,470.8 ns |        baseline |    9808 B |               |
+| AsyncValidation | Verifast         | True     |  2,101.9 ns |    5.20x faster |    1016 B |   13.88x less |
+|                 |                  |          |             |                 |           |               |
+| SyncValidation  | FluentValidation | False    | 35,687.7 ns |        baseline |   63112 B |               |
+| SyncValidation  | Verifast         | False    |    141.4 ns | 252.377x faster |     328 B | 192.415x less |
+| SyncValidation  | FluentValidation | True     | 26,091.2 ns |        baseline |   50063 B |               |
+| SyncValidation  | Verifast         | True     |    112.3 ns | 320.264x faster |         - |            NA |
diff --git a/benchmarks/Verifast.Benchmarks/Models/BenchmarkConfig.cs b/benchmarks/Verifast.Benchmarks/Models/BenchmarkConfig.cs
index 6694d2b..5d767ff 100644
--- a/benchmarks/Verifast.Benchmarks/Models/BenchmarkConfig.cs
+++ b/benchmarks/Verifast.Benchmarks/Models/BenchmarkConfig.cs
@@ -22,7 +22,7 @@ public BenchmarkConfig() {
         AddJob(Job.MediumRun.WithOutlierMode(OutlierMode.RemoveAll).WithIterationTime(TimeInterval.FromMilliseconds(100)));
         AddColumnProvider(DefaultColumnProviders.Instance);
         AddColumn(RankColumn.Arabic);
-        HideColumns(Column.Error, Column.StdDev, Column.Median, Column.RatioSD, Column.Gen0, Column.Gen1, Column.Gen2);
+        HideColumns(Column.Error, Column.StdDev, Column.Median, Column.RatioSD, Column.Gen0, Column.Gen1, Column.Gen2, Column.Rank);
         WithOrderer(new GroupByTypeOrderer());
         WithOptions(ConfigOptions.JoinSummary);
         WithOptions(ConfigOptions.StopOnFirstError);

From 0889a39af970a7a07149c215a69d93c74478138a Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 12:32:05 +0200
Subject: [PATCH 17/18] Include debug symbols in nuget package

---
 src/Verifast/Verifast.csproj | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Verifast/Verifast.csproj b/src/Verifast/Verifast.csproj
index 4202034..7d3f1db 100644
--- a/src/Verifast/Verifast.csproj
+++ b/src/Verifast/Verifast.csproj
@@ -44,6 +44,8 @@
   <PropertyGroup>
     <DebugType>portable</DebugType>
     <EmbedUntrackedSources>true</EmbedUntrackedSources>
+    <IncludeSymbols>true</IncludeSymbols>
+    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
     <AllowedOutputExtensionsInPackageBuildOutputFolder>
       $(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb
     </AllowedOutputExtensionsInPackageBuildOutputFolder>

From 855128a0b2b99ede448b0e15a380445edefb155c Mon Sep 17 00:00:00 2001
From: David Shnayder <dusrdev@gmail.com>
Date: Tue, 30 Dec 2025 12:33:37 +0200
Subject: [PATCH 18/18] Update CI

---
 .github/workflows/benchmarks.yaml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/.github/workflows/benchmarks.yaml b/.github/workflows/benchmarks.yaml
index 09b18c6..52e1929 100644
--- a/.github/workflows/benchmarks.yaml
+++ b/.github/workflows/benchmarks.yaml
@@ -1,7 +1,6 @@
 name: Benchmarks
 
 on:
-  pull_request:
   workflow_dispatch:
 
 jobs:
@@ -18,7 +17,7 @@ jobs:
       - name: Setup .NET
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 9.0.x
+          dotnet-version: 10.0.x
 
       - name: Run Benchmarks
         run: dotnet run --project ${{ env.PROJECT }} --configuration Release -- --filter '*'