SQLite pool activation can lend the same connection to two live owners

<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup><OutputType>Exe</OutputType><TargetFramework>net10.0</TargetFramework><ImplicitUsings>enable</ImplicitUsings></PropertyGroup>
<ItemGroup><PackageReference Include="Microsoft.Data.Sqlite" Version="10.0.11" /><PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" Version="3.0.5" /></ItemGroup>
</Project>

using System.Collections.Concurrent;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Text.Json;
using Microsoft.Data.Sqlite;

// Public APIs only. All owners remain strongly held and open until each wave
// has finished. A duplicate is then checked with two independent read-only transactions.
// No writes, provider internals or forced GC.
var rounds = int.Parse(args[1]);
const int workers = 16;
ThreadPool.SetMinThreads(workers + 2, workers + 2);
var errors = new ConcurrentQueue<string>();
var duplicates = new List<object>();
var transactionErrors = new List<string>();
var file = Path.Combine(Path.GetDirectoryName(Path.GetFullPath(args[0]))!, "pool-public-probe.db");
var connectionString = new SqliteConnectionStringBuilder { DataSource = file, Pooling = true }.ToString();
using var control = new SqliteConnection(connectionString);
control.Open();
control.Close();
var stopwatch = Stopwatch.StartNew();
var completed = 0;
for (int round = 0; round < rounds; round++)
{
    // Clear this probe's pool only, with all preceding owners already closed.
    SqliteConnection.ClearPool(control);
    using var ready = new Barrier(workers);
    var connections = Enumerable.Range(0, workers).Select(_ => new SqliteConnection(connectionString)).ToArray();
    try
    {
        await Task.WhenAll(connections.Select(connection => Task.Run(() =>
        {
            ready.SignalAndWait();
            try { connection.Open(); }
            catch (Exception exception) { errors.Enqueue(exception.ToString()); }
        })));
        var handles = connections.Select((connection, owner) => new {
            Owner = owner, State = connection.State, Handle = connection.Handle?.DangerousGetHandle().ToInt64()
        }).ToArray();
        foreach (var owner in handles.Where(x => x.State != System.Data.ConnectionState.Open || !x.Handle.HasValue || x.Handle.Value == 0))
            errors.Enqueue($"Round {round}, owner {owner.Owner}: expected an open live connection; got {owner.State}, handle {owner.Handle}.");
        foreach (var group in handles.Where(x => x.Handle.HasValue).GroupBy(x => x.Handle).Where(g => g.Count() > 1))
        {
            var owners = group.Select(x => x.Owner).ToArray();
            duplicates.Add(new { Round = round, Handle = group.Key, Owners = owners });
            using var firstTransaction = connections[owners[0]].BeginTransaction(System.Data.IsolationLevel.Serializable, deferred: true);
            try
            {
                using var secondTransaction = connections[owners[1]].BeginTransaction(System.Data.IsolationLevel.Serializable, deferred: true);
                secondTransaction.Rollback();
            }
            catch (Microsoft.Data.Sqlite.SqliteException exception)
            {
                transactionErrors.Add(exception.Message);
            }
            firstTransaction.Rollback();
        }
        completed++;
    }
    finally
    {
        foreach (var connection in connections)
            try { connection.Dispose(); }
            catch (Exception exception) { errors.Enqueue(exception.ToString()); }
    }
    if (duplicates.Count != 0 || !errors.IsEmpty)
        break;
    if (completed % 100 == 0)
        Console.WriteLine($"Completed {completed}/{rounds} waves ({workers} concurrent opens each).");
}
SqliteConnection.ClearPool(control);
var assembly = typeof(SqliteConnection).Assembly;
var report = new {
    Kind = "Published Microsoft.Data.Sqlite pool and transaction reproduction",
    Runtime = RuntimeInformation.FrameworkDescription,
    Assembly = assembly.FullName,
    AssemblySha256 = Convert.ToHexStringLower(SHA256.HashData(File.ReadAllBytes(assembly.Location))),
    RequestedRounds = rounds, CompletedRounds = completed, WorkersPerRound = workers,
    DurationSeconds = stopwatch.Elapsed.TotalSeconds,
    DuplicateLiveNativeHandles = duplicates, SecondBeginErrors = transactionErrors, Errors = errors.ToArray(),
    Limitation = "Public opens and deferred transaction begins only. A passing stress run cannot exclude rare interleavings."
};
var json = JsonSerializer.Serialize(report, new JsonSerializerOptions { WriteIndented = true });
File.WriteAllText(args[0], json);
Console.WriteLine(json);
return duplicates.Count == 0 && errors.IsEmpty ? 0 : 1;