Replace owned null returns with explicit outcomes

Use ManagedCode.Communication results at null-producing owners and update bound callers, awaited calls and delegates throughout the solution. Preserve successful JSON null scalars in an explicit payload and transfer cache reservations through annotated Try/out ownership.

Reconcile the complete 3290-case compiled unit census, including existing omitted cases and current display identities. Confine coverage selectors using TUnit's case-insensitive matching and verify their exact compiled selections in CI. Keep all existing classifications, assertions and numeric coverage thresholds.

Check the original ANN capture budget under the generation gate before acquiring its owner after seed capture, so admitted shutdown work observes cancellation before a disposed owner.

Validation: complete Debug solution build with -warnaserror; formatter verification; governance, source closure and shard partition checks; exact full census and five coverage selectors; 503 analyzer tests; 215 real process recovery tests; 631 U1 cases; focused SDK/HTTPS model cases; real three-node HTTPS HTTP/2 request identity case; five independent ANN shutdown/no-effects/healthy follow-up executions. Remaining unit shards and full Aspire shards are still running; no complete Linux or coverage qualification is claimed.

Author: KSemenenko

.github/workflows/build-and-tests.yml

@@ -30,6 +30,20 @@ jobs:
         run: node scripts/Features/TestInfrastructure/ci-test-shards.mjs verify
       - name: Build
         run: dotnet build KeyLoad.slnx -warnaserror
+      - name: Check compiled unit inventory and coverage selectors
+        shell: pwsh
+        run: |
+          $evidence = Join-Path $PWD 'tests/KeyLoad.UnitTests/bin/Debug/net10.0/ci-inventory'
+          New-Item -ItemType Directory -Path $evidence -ErrorAction Stop | Out-Null
+          & ./scripts/Features/CodeQuality/functional-coverage.workflow-discovery.ps1 -Repository $PWD -EvidenceRoot $evidence
+      - name: Save compiled discovery evidence
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v7
+        with:
+          name: compiled-unit-discovery
+          path: tests/KeyLoad.UnitTests/bin/Debug/net10.0/ci-inventory
+          if-no-files-found: warn
+          retention-days: 30
 
   shards:
     name: Plan test shards

benchmarks/KeyLoad.BenchmarkScenarios/Fixtures/Embedded/EmbeddedBenchmarkDatabase.cs

@@ -106,7 +106,7 @@ private static void Require(Result<object> result)
     {
         if (result.IsFailed)
         {
-            throw Errors.Fail(Errors.Code(result.Problem)!.Value, result.Problem.Detail!);
+            throw Errors.Fail(Errors.Code(result.Problem).Value!.Value, result.Problem.Detail!);
         }
     }
 }

benchmarks/KeyLoad.ComparisonHost/DatabaseAdapters/Cases/AdditionalDatabaseTests.cs

@@ -28,7 +28,7 @@ private static async Task VerifyAsync(IComparisonTarget target, CancellationToke
         await using var session = await documents.OpenDocumentSessionAsync(token);
         await using var independent = await documents.OpenDocumentSessionAsync(token);
         await Assert.That(session.ClientIdentity).IsNotEqualTo(independent.ClientIdentity);
-        await Assert.That(await session.ReadAsync(corpus.CreateDocument(First), token)).IsNull();
+        await Assert.That((await session.ReadAsync(corpus.CreateDocument(First), token)).Value).IsNull();
         for (var index = First; index < InitialCount; index++)
         {
             await session.ExecuteAsync(Scenario.DocumentWrite, corpus.CreateDocument(index), token);
@@ -50,14 +50,14 @@ private static async Task VerifyAsync(IComparisonTarget target, CancellationToke
         {
             await queries.BuildSessionIndexesAsync(token);
             await session.ExecuteAsync(Scenario.DocumentDelete, corpus.CreateDocument(Deleted), token);
-            await Assert.That(await independent.ReadAsync(corpus.CreateDocument(Deleted), token)).IsNull();
+            await Assert.That((await independent.ReadAsync(corpus.CreateDocument(Deleted), token)).Value).IsNull();
         }
         await queries.QuerySessionAsync(First, Stable, Single, token);
         await VerifyReadbackAsync(session, corpus, target.Supports(Scenario.DocumentDelete), token);
     }
 
     private static async Task AssertDocumentAsync(IDocumentComparisonSession session, BenchmarkDocument expected, CancellationToken token)
-        => await Assert.That(BenchmarkDataset.SameDocument(await session.ReadAsync(expected, token), expected)).IsTrue();
+        => await Assert.That(BenchmarkDataset.SameDocument((await session.ReadAsync(expected, token)).Value, expected)).IsTrue();
 
     private static async Task VerifyReadbackAsync(IDocumentComparisonSession session, DocumentComparisonCorpus corpus,
         bool deleted, CancellationToken token)

benchmarks/KeyLoad.ComparisonHost/Orchestration/Contracts/IsolatedTeardownFailures.cs

@@ -44,7 +44,7 @@ internal void ThrowIfAny()
             return;
         }
 
-        var fatal = FindFatal(failures);
+        var fatal = (FindFatal(failures)).Value;
         if (fatal is not null)
         {
             var prioritized = new List<Exception> { fatal };
@@ -66,17 +66,17 @@ private List<Exception> OrderedFailures()
         return ordered;
     }
 
-    private static Exception? FindFatal(IEnumerable<Exception> failures)
+    private static global::ManagedCode.Communication.Result<Exception?> FindFatal(IEnumerable<Exception> failures)
     {
         foreach (var failure in failures)
         {
             var fatal = CqrsRuntimeFailures.FindFatal(failure);
             if (fatal is not null)
             {
-                return fatal;
+                return global::ManagedCode.Communication.Result<Exception?>.Succeed(((Exception?)(fatal)));
             }
         }
-        return null;
+        return global::ManagedCode.Communication.Result<Exception?>.FailNotFound(nameof(FindFatal));
     }
 
     private static void AddDistinct(List<Exception> target, IEnumerable<Exception> additions)

benchmarks/KeyLoad.ComparisonHost/Orchestration/Fixtures/BenchmarkSessionAspireFixture.cs

@@ -80,8 +80,8 @@ await IsolatedReportAssertions.VerifyModelAsync(
             {
                 await work.StartSettlement();
             }
-            var qualificationFailure = await BenchmarkSessionQualifications.RunAsync(application, selection,
-                selected, evidence, exit, token);
+            var qualificationFailure = (await BenchmarkSessionQualifications.RunAsync(application, selection,
+                selected, evidence, exit, token)).Value;
             using var retention = new CancellationTokenSource(execution.Value.TeardownReceiptTimeout, TimeProvider.System);
             await BenchmarkSessionManifest.WriteAsync(evidence, selected, exit, qualificationFailure is not null, retention.Token);
             if (qualificationFailure is not null)

benchmarks/KeyLoad.ComparisonHost/Orchestration/Fixtures/IsolatedOwnedWork.cs

@@ -91,9 +91,9 @@ private async Task DisposeAndJoinAsync(Task registered)
         await registered;
         try
         {
-            var runnerFailure = await RuntimeComparisonFailure.ObserveAsync(StopRunnerAsync());
-            var captureFailure = await RuntimeComparisonFailure.ObserveAsync(DisposeCaptureCoreAsync());
-            var combined = RuntimeComparisonFailure.Combine(runnerFailure, captureFailure is null ? [] : [captureFailure]);
+            var runnerFailure = (await RuntimeComparisonFailure.ObserveAsync(StopRunnerAsync())).Value;
+            var captureFailure = (await RuntimeComparisonFailure.ObserveAsync(DisposeCaptureCoreAsync())).Value;
+            var combined = (RuntimeComparisonFailure.Combine(runnerFailure, captureFailure is null ? [] : [captureFailure])).Value;
             if (combined is not null)
             {
                 ExceptionDispatchInfo.Capture(combined).Throw();

benchmarks/KeyLoad.ComparisonHost/Orchestration/Reporting/BenchmarkSessionQualifications.cs

@@ -27,7 +27,7 @@ internal static class BenchmarkSessionQualifications
     private const string Correctness = "execution-correctness";
     private static readonly JsonSerializerOptions Json = new(JsonSerializerDefaults.Web);
 
-    internal static async Task<Exception?> RunAsync(DistributedApplication application,
+    internal static async Task<global::ManagedCode.Communication.Result<Exception?>> RunAsync(DistributedApplication application,
         BenchmarkSessionSelection selection, BenchmarkSessionCallerOptions selected, string evidence,
         int runtimeExit, CancellationToken token)
     {
@@ -51,9 +51,9 @@ await InvokeAsync(Correctness, applicable: true,
         await WriteAsync(evidence, report);
         return failures.Count switch
         {
-            EmptyCount => null,
-            SingleItemCount => failures[EmptyCount],
-            _ => new AggregateException(failures)
+            EmptyCount => global::ManagedCode.Communication.Result<Exception?>.FailNotFound(nameof(RunAsync)),
+            SingleItemCount => global::ManagedCode.Communication.Result<Exception?>.Succeed(((Exception?)(failures[EmptyCount]))),
+            _ => global::ManagedCode.Communication.Result<Exception?>.Succeed((Exception?)(new AggregateException(failures)))
         };
     }
 

benchmarks/KeyLoad.ComparisonHost/Orchestration/Scenarios/IsolatedTeardown.cs

@@ -85,14 +85,14 @@ await IsolatedOriginalTaskSettlement.RunAsync(
 
     internal static async Task SettleOwnerDisposalAsync(Task original, Task disposal)
     {
-        var primary = await RuntimeComparisonFailure.ObserveAsync(original);
-        var cleanup = await RuntimeComparisonFailure.ObserveAsync(disposal);
+        var primary = (await RuntimeComparisonFailure.ObserveAsync(original)).Value;
+        var cleanup = (await RuntimeComparisonFailure.ObserveAsync(disposal)).Value;
         if (cleanup is null || ContainsAllFailures(primary, cleanup))
         {
             // A repeated await of the same execution completion must not replace its already retained teardown failure.
             return;
         }
-        var combined = RuntimeComparisonFailure.Combine(primary, [cleanup]);
+        var combined = (RuntimeComparisonFailure.Combine(primary, [cleanup])).Value;
         ExceptionDispatchInfo.Capture(combined!).Throw();
     }
 

benchmarks/KeyLoad.ComparisonHost/Orchestration/Scenarios/IsolatedTeardownSupport.cs

@@ -12,14 +12,14 @@ internal static class IsolatedTeardownSupport
     internal static async Task CollectFailureAsync(Func<Task> operation, List<Exception> failures)
     {
         var initiation = StartAsync(operation);
-        var failure = await RuntimeComparisonFailure.ObserveAsync(initiation);
+        var failure = (await RuntimeComparisonFailure.ObserveAsync(initiation)).Value;
         if (failure is not null)
         {
             AddOriginalFailures(initiation, failure, failures);
             return;
         }
         var original = await initiation;
-        failure = await RuntimeComparisonFailure.ObserveAsync(original);
+        failure = (await RuntimeComparisonFailure.ObserveAsync(original)).Value;
         if (failure is not null)
         {
             AddOriginalFailures(original, failure, failures);

benchmarks/KeyLoad.ComparisonHost/Session/Lifecycle/BenchmarkSessionFixtureDisposal.cs

@@ -10,17 +10,17 @@ internal static class BenchmarkSessionFixtureDisposal
     internal static async ValueTask CompleteAsync(Task original, IAsyncDisposable? runtimeOwner, IDisposable? configuration)
     {
         ArgumentNullException.ThrowIfNull(original);
-        var primary = await RuntimeComparisonFailure.ObserveAsync(original);
+        var primary = (await RuntimeComparisonFailure.ObserveAsync(original)).Value;
         var cleanup = ImmutableArray.CreateBuilder<Exception>();
-        if (await RuntimeComparisonFailure.ObserveAsync(RuntimeDisposeAsync(runtimeOwner)) is { } runtimeFailure)
+        if ((await RuntimeComparisonFailure.ObserveAsync(RuntimeDisposeAsync(runtimeOwner))).Value is { } runtimeFailure)
         {
             cleanup.Add(runtimeFailure);
         }
-        if (await RuntimeComparisonFailure.ObserveAsync(DisposeConfigurationAsync(configuration)) is { } configurationFailure)
+        if ((await RuntimeComparisonFailure.ObserveAsync(DisposeConfigurationAsync(configuration))).Value is { } configurationFailure)
         {
             cleanup.Add(configurationFailure);
         }
-        if (RuntimeComparisonFailure.Combine(primary, cleanup.ToImmutable()) is { } combined)
+        if ((RuntimeComparisonFailure.Combine(primary, cleanup.ToImmutable())).Value is { } combined)
         {
             ExceptionDispatchInfo.Capture(combined).Throw();
         }
@@ -30,9 +30,9 @@ internal static async Task RetainFailureAsync(Exception original, Task retention
     {
         ArgumentNullException.ThrowIfNull(original);
         ArgumentNullException.ThrowIfNull(retention);
-        var retentionFailure = await RuntimeComparisonFailure.ObserveAsync(retention);
-        var combined = RuntimeComparisonFailure.Combine(original,
-            retentionFailure is null ? [] : [retentionFailure]);
+        var retentionFailure = (await RuntimeComparisonFailure.ObserveAsync(retention)).Value;
+        var combined = (RuntimeComparisonFailure.Combine(original,
+            retentionFailure is null ? [] : [retentionFailure])).Value;
         ExceptionDispatchInfo.Capture(combined!).Throw();
     }