save checkpoint: save features

src/BinaryIndex/StellaOps.BinaryIndex.WebService/Controllers/ResolutionController.cs

@@ -88,6 +88,11 @@ public sealed class ResolutionController : ControllerBase
             var result = await _resolutionService.ResolveAsync(request, options, ct);
             return Ok(result);
         }
+        catch (ArgumentException ex)
+        {
+            _logger.LogWarning(ex, "Invalid vulnerability resolution request for package {Package}", request.Package);
+            return BadRequest(CreateProblem(ex.Message, "InvalidRequest", StatusCodes.Status400BadRequest));
+        }
         catch (Exception ex)
         {
             _logger.LogError(ex, "Failed to resolve vulnerability for package {Package}", request.Package);
@@ -153,6 +158,11 @@ public sealed class ResolutionController : ControllerBase
             var result = await _resolutionService.ResolveBatchAsync(request, options, ct);
             return Ok(result);
         }
+        catch (ArgumentException ex)
+        {
+            _logger.LogWarning(ex, "Invalid batch vulnerability resolution request");
+            return BadRequest(CreateProblem(ex.Message, "InvalidRequest", StatusCodes.Status400BadRequest));
+        }
         catch (Exception ex)
         {
             _logger.LogError(ex, "Failed to process batch resolution");

src/BinaryIndex/StellaOps.BinaryIndex.WebService/Program.cs

@@ -5,6 +5,9 @@ using Microsoft.Extensions.Options;
 using StackExchange.Redis;
 using StellaOps.BinaryIndex.Cache;
 using StellaOps.BinaryIndex.Core.Resolution;
+using StellaOps.BinaryIndex.Core.Services;
+using StellaOps.BinaryIndex.GoldenSet;
+using StellaOps.BinaryIndex.Persistence.Repositories;
 using StellaOps.BinaryIndex.VexBridge;
 using StellaOps.BinaryIndex.WebService.Middleware;
 using StellaOps.BinaryIndex.WebService.Services;
@@ -26,15 +29,17 @@ builder.Services.AddOptions<ResolutionCacheOptions>()
     .Bind(builder.Configuration.GetSection(ResolutionCacheOptions.SectionName))
     .ValidateOnStart();
 
-// Add Redis/Valkey connection
+// Add Redis/Valkey connection (optional with deterministic in-memory fallback)
 var redisConnectionString = builder.Configuration.GetConnectionString("Redis") ?? "localhost:6379";
-builder.Services.AddSingleton<IConnectionMultiplexer>(_ =>
-    ConnectionMultiplexer.Connect(redisConnectionString));
 
 // Add services
 builder.Services.TryAddSingleton(TimeProvider.System);
 builder.Services.TryAddSingleton<IRandomSource, SystemRandomSource>();
-builder.Services.AddSingleton<IResolutionCacheService, ResolutionCacheService>();
+builder.Services.AddGoldenSetServices(builder.Configuration);
+builder.Services.TryAddSingleton<IGoldenSetStore, InMemoryGoldenSetStore>();
+builder.Services.TryAddSingleton<IBinaryVulnerabilityService, InMemoryBinaryVulnerabilityService>();
+builder.Services.TryAddSingleton<IDeltaSignatureRepository, InMemoryDeltaSignatureRepository>();
+builder.Services.AddSingleton<IResolutionCacheService>(sp => CreateResolutionCacheService(sp, redisConnectionString));
 builder.Services.AddScoped<ResolutionService>();
 builder.Services.AddScoped<IResolutionService>(sp =>
     new CachedResolutionService(
@@ -73,10 +78,58 @@ if (app.Environment.IsDevelopment())
 }
 
 app.UseStellaOpsCors();
-app.UseHttpsRedirection();
+var hasHttpsBinding = app.Urls.Any(url => url.StartsWith("https://", StringComparison.OrdinalIgnoreCase));
+if (hasHttpsBinding)
+{
+    app.UseHttpsRedirection();
+}
+else
+{
+    app.Logger.LogInformation("Skipping HTTPS redirection because no HTTPS binding is configured.");
+}
 app.UseResolutionRateLimiting();
 app.UseAuthorization();
 app.MapControllers();
 app.MapHealthChecks("/health");
 
 app.Run();
+
+static IResolutionCacheService CreateResolutionCacheService(IServiceProvider services, string redisConnectionString)
+{
+    var startupLogger = services
+        .GetRequiredService<ILoggerFactory>()
+        .CreateLogger("BinaryIndex.WebService.Startup");
+
+    var cacheOptions = services.GetRequiredService<IOptions<ResolutionCacheOptions>>();
+    var random = services.GetRequiredService<IRandomSource>();
+
+    try
+    {
+        var redisOptions = ConfigurationOptions.Parse(redisConnectionString);
+        redisOptions.AbortOnConnectFail = true;
+        redisOptions.ConnectRetry = 0;
+        redisOptions.ConnectTimeout = 500;
+        redisOptions.SyncTimeout = 500;
+        redisOptions.AsyncTimeout = 500;
+
+        var multiplexer = ConnectionMultiplexer.Connect(redisOptions);
+        _ = multiplexer.GetDatabase().Ping();
+
+        startupLogger.LogInformation("Using Redis-backed resolution cache.");
+        return new ResolutionCacheService(
+            multiplexer,
+            cacheOptions,
+            services.GetRequiredService<ILogger<ResolutionCacheService>>(),
+            random);
+    }
+    catch (Exception ex)
+    {
+        startupLogger.LogWarning(
+            ex,
+            "Redis is unavailable. Falling back to deterministic in-memory resolution cache.");
+        return new InMemoryResolutionCacheService(
+            cacheOptions,
+            services.GetRequiredService<TimeProvider>(),
+            services.GetRequiredService<ILogger<InMemoryResolutionCacheService>>());
+    }
+}

src/BinaryIndex/StellaOps.BinaryIndex.WebService/Services/InMemoryBinaryVulnerabilityService.cs

@@ -0,0 +1,77 @@
+using StellaOps.BinaryIndex.Core.Models;
+using StellaOps.BinaryIndex.Core.Services;
+using System.Collections.Immutable;
+
+namespace StellaOps.BinaryIndex.WebService.Services;
+
+/// <summary>
+/// Deterministic fallback vulnerability service used when persistence-backed
+/// BinaryIndex services are not configured in local/dev WebService startup.
+/// </summary>
+public sealed class InMemoryBinaryVulnerabilityService : IBinaryVulnerabilityService
+{
+    public Task<ImmutableArray<BinaryVulnMatch>> LookupByIdentityAsync(
+        BinaryIdentity identity,
+        LookupOptions? options = null,
+        CancellationToken ct = default) =>
+        Task.FromResult(ImmutableArray<BinaryVulnMatch>.Empty);
+
+    public Task<ImmutableDictionary<string, ImmutableArray<BinaryVulnMatch>>> LookupBatchAsync(
+        IEnumerable<BinaryIdentity> identities,
+        LookupOptions? options = null,
+        CancellationToken ct = default) =>
+        Task.FromResult(ImmutableDictionary<string, ImmutableArray<BinaryVulnMatch>>.Empty);
+
+    public Task<FixStatusResult?> GetFixStatusAsync(
+        string distro,
+        string release,
+        string sourcePkg,
+        string cveId,
+        CancellationToken ct = default) =>
+        Task.FromResult<FixStatusResult?>(null);
+
+    public Task<ImmutableDictionary<string, FixStatusResult>> GetFixStatusBatchAsync(
+        string distro,
+        string release,
+        string sourcePkg,
+        IEnumerable<string> cveIds,
+        CancellationToken ct = default) =>
+        Task.FromResult(ImmutableDictionary<string, FixStatusResult>.Empty);
+
+    public Task<ImmutableArray<BinaryVulnMatch>> LookupByFingerprintAsync(
+        byte[] fingerprint,
+        FingerprintLookupOptions? options = null,
+        CancellationToken ct = default) =>
+        Task.FromResult(ImmutableArray<BinaryVulnMatch>.Empty);
+
+    public Task<ImmutableDictionary<string, ImmutableArray<BinaryVulnMatch>>> LookupByFingerprintBatchAsync(
+        IEnumerable<(string Key, byte[] Fingerprint)> fingerprints,
+        FingerprintLookupOptions? options = null,
+        CancellationToken ct = default) =>
+        Task.FromResult(ImmutableDictionary<string, ImmutableArray<BinaryVulnMatch>>.Empty);
+
+    public Task<ImmutableArray<BinaryVulnMatch>> LookupByDeltaSignatureAsync(
+        Stream binaryStream,
+        DeltaSigLookupOptions? options = null,
+        CancellationToken ct = default) =>
+        Task.FromResult(ImmutableArray<BinaryVulnMatch>.Empty);
+
+    public Task<ImmutableArray<BinaryVulnMatch>> LookupBySymbolHashAsync(
+        string symbolHash,
+        string symbolName,
+        DeltaSigLookupOptions? options = null,
+        CancellationToken ct = default) =>
+        Task.FromResult(ImmutableArray<BinaryVulnMatch>.Empty);
+
+    public Task<ImmutableArray<CorpusFunctionMatch>> IdentifyFunctionFromCorpusAsync(
+        FunctionFingerprintSet fingerprints,
+        CorpusLookupOptions? options = null,
+        CancellationToken ct = default) =>
+        Task.FromResult(ImmutableArray<CorpusFunctionMatch>.Empty);
+
+    public Task<ImmutableDictionary<string, ImmutableArray<CorpusFunctionMatch>>> IdentifyFunctionsFromCorpusBatchAsync(
+        IEnumerable<(string Key, FunctionFingerprintSet Fingerprints)> functions,
+        CorpusLookupOptions? options = null,
+        CancellationToken ct = default) =>
+        Task.FromResult(ImmutableDictionary<string, ImmutableArray<CorpusFunctionMatch>>.Empty);
+}

src/BinaryIndex/StellaOps.BinaryIndex.WebService/Services/InMemoryDeltaSignatureRepository.cs

@@ -0,0 +1,494 @@
+using StellaOps.BinaryIndex.DeltaSig;
+using StellaOps.BinaryIndex.Persistence.Repositories;
+using System.Collections.Immutable;
+
+namespace StellaOps.BinaryIndex.WebService.Services;
+
+/// <summary>
+/// Deterministic fallback repository used when persistence-backed delta-signature
+/// storage is not configured in local/dev WebService startup.
+/// </summary>
+public sealed class InMemoryDeltaSignatureRepository : IDeltaSignatureRepository
+{
+    private readonly object _gate = new();
+    private readonly TimeProvider _timeProvider;
+    private readonly List<DeltaSignatureEntity> _signatures;
+    private readonly List<DeltaSigMatchEntity> _matches;
+
+    public InMemoryDeltaSignatureRepository(TimeProvider? timeProvider = null)
+    {
+        _timeProvider = timeProvider ?? TimeProvider.System;
+        var now = _timeProvider.GetUtcNow();
+
+        _signatures =
+        [
+            Signature(
+                id: Guid.Parse("11111111-1111-1111-1111-111111111111"),
+                cveId: "CVE-2023-0286",
+                packageName: "openssl",
+                symbolName: "tls1_process_heartbeat",
+                hashHex: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+                signatureState: "vulnerable",
+                now: now),
+            Signature(
+                id: Guid.Parse("22222222-2222-2222-2222-222222222222"),
+                cveId: "CVE-2023-0286",
+                packageName: "openssl",
+                symbolName: "tls1_process_heartbeat",
+                hashHex: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+                signatureState: "patched",
+                now: now),
+            Signature(
+                id: Guid.Parse("33333333-3333-3333-3333-333333333333"),
+                cveId: "CVE-2023-0286",
+                packageName: "openssl",
+                symbolName: "X509_VERIFY_PARAM_set1_policies",
+                hashHex: "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+                signatureState: "patched",
+                now: now),
+            Signature(
+                id: Guid.Parse("44444444-4444-4444-4444-444444444444"),
+                cveId: "CVE-2021-3156",
+                packageName: "sudo",
+                symbolName: "set_cmnd",
+                hashHex: "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
+                signatureState: "vulnerable",
+                now: now)
+        ];
+
+        _matches =
+        [
+            new DeltaSigMatchEntity
+            {
+                Id = Guid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"),
+                BinaryKey = "sha256:img-openssl-1",
+                BinarySha256 = "img-openssl-1",
+                CveId = "CVE-2023-0286",
+                SymbolName = "tls1_process_heartbeat",
+                MatchType = "exact",
+                Confidence = 0.95m,
+                MatchedState = "patched",
+                ScannedAt = now.AddMinutes(-1)
+            },
+            new DeltaSigMatchEntity
+            {
+                Id = Guid.Parse("bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"),
+                BinaryKey = "sha256:img-openssl-2",
+                BinarySha256 = "img-openssl-2",
+                CveId = "CVE-2023-0286",
+                SymbolName = "tls1_process_heartbeat",
+                MatchType = "exact",
+                Confidence = 0.93m,
+                MatchedState = "vulnerable",
+                ScannedAt = now.AddMinutes(-2)
+            },
+            new DeltaSigMatchEntity
+            {
+                Id = Guid.Parse("cccccccc-cccc-cccc-cccc-cccccccccccc"),
+                BinaryKey = "sha256:img-openssl-3",
+                BinarySha256 = "img-openssl-3",
+                CveId = "CVE-2023-0286",
+                SymbolName = "X509_VERIFY_PARAM_set1_policies",
+                MatchType = "heuristic",
+                Confidence = 0.71m,
+                MatchedState = "unknown",
+                ScannedAt = now.AddMinutes(-3)
+            },
+            new DeltaSigMatchEntity
+            {
+                Id = Guid.Parse("dddddddd-dddd-dddd-dddd-dddddddddddd"),
+                BinaryKey = "sha256:img-sudo-1",
+                BinarySha256 = "img-sudo-1",
+                CveId = "CVE-2021-3156",
+                SymbolName = "set_cmnd",
+                MatchType = "exact",
+                Confidence = 0.89m,
+                MatchedState = "vulnerable",
+                ScannedAt = now.AddMinutes(-4)
+            }
+        ];
+    }
+
+    public Task<DeltaSignatureEntity> CreateAsync(
+        DeltaSignatureEntity entity,
+        CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        var now = _timeProvider.GetUtcNow();
+        var created = entity with
+        {
+            Id = entity.Id == Guid.Empty ? Guid.NewGuid() : entity.Id,
+            CreatedAt = entity.CreatedAt == default ? now : entity.CreatedAt,
+            UpdatedAt = now
+        };
+
+        lock (_gate)
+        {
+            _signatures.Add(created);
+        }
+
+        return Task.FromResult(created);
+    }
+
+    public async Task<IReadOnlyList<DeltaSignatureEntity>> CreateBatchAsync(
+        IEnumerable<DeltaSignatureEntity> entities,
+        CancellationToken ct = default)
+    {
+        var created = new List<DeltaSignatureEntity>();
+        foreach (var entity in entities)
+        {
+            created.Add(await CreateAsync(entity, ct).ConfigureAwait(false));
+        }
+
+        return created;
+    }
+
+    public Task<DeltaSignatureEntity?> GetByIdAsync(
+        Guid id,
+        CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        lock (_gate)
+        {
+            return Task.FromResult(_signatures.FirstOrDefault(s => s.Id == id));
+        }
+    }
+
+    public Task<IReadOnlyList<DeltaSignatureEntity>> GetByCveAsync(
+        string cveId,
+        CancellationToken ct = default) =>
+        QueryAsync(
+            s => s.CveId.Equals(cveId, StringComparison.OrdinalIgnoreCase),
+            s => s.SymbolName,
+            ct);
+
+    public Task<IReadOnlyList<DeltaSignatureEntity>> GetByPackageAsync(
+        string packageName,
+        string? soname = null,
+        CancellationToken ct = default) =>
+        QueryAsync(
+            s => s.PackageName.Equals(packageName, StringComparison.OrdinalIgnoreCase) &&
+                 (soname is null || string.Equals(s.Soname, soname, StringComparison.OrdinalIgnoreCase)),
+            s => s.CveId,
+            ct);
+
+    public Task<IReadOnlyList<DeltaSignatureEntity>> GetByHashAsync(
+        string hashHex,
+        CancellationToken ct = default) =>
+        QueryAsync(
+            s => s.HashHex.Equals(hashHex, StringComparison.OrdinalIgnoreCase),
+            s => s.CveId,
+            ct);
+
+    public Task<IReadOnlyList<DeltaSignatureEntity>> GetForMatchingAsync(
+        string arch,
+        string abi,
+        IEnumerable<string> symbolNames,
+        CancellationToken ct = default)
+    {
+        var symbolSet = symbolNames
+            .Where(s => !string.IsNullOrWhiteSpace(s))
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        return QueryAsync(
+            s => s.Arch.Equals(arch, StringComparison.OrdinalIgnoreCase) &&
+                 s.Abi.Equals(abi, StringComparison.OrdinalIgnoreCase) &&
+                 symbolSet.Contains(s.SymbolName),
+            s => s.CveId,
+            ct);
+    }
+
+    public Task<IReadOnlyList<DeltaSignatureEntity>> GetAllMatchingAsync(
+        IReadOnlyList<string>? cveFilter = null,
+        string? packageFilter = null,
+        string? archFilter = null,
+        CancellationToken ct = default)
+    {
+        var cveSet = cveFilter is { Count: > 0 }
+            ? cveFilter.ToHashSet(StringComparer.OrdinalIgnoreCase)
+            : null;
+
+        return QueryAsync(
+            s =>
+                (cveSet is null || cveSet.Contains(s.CveId)) &&
+                (string.IsNullOrWhiteSpace(packageFilter) ||
+                 s.PackageName.Equals(packageFilter, StringComparison.OrdinalIgnoreCase)) &&
+                (string.IsNullOrWhiteSpace(archFilter) ||
+                 s.Arch.Equals(archFilter, StringComparison.OrdinalIgnoreCase)),
+            s => s.CveId,
+            ct);
+    }
+
+    public Task<DeltaSignatureEntity> UpdateAsync(
+        DeltaSignatureEntity entity,
+        CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        var now = _timeProvider.GetUtcNow();
+        var updated = entity with
+        {
+            Id = entity.Id == Guid.Empty ? Guid.NewGuid() : entity.Id,
+            CreatedAt = entity.CreatedAt == default ? now : entity.CreatedAt,
+            UpdatedAt = now
+        };
+
+        lock (_gate)
+        {
+            var index = _signatures.FindIndex(s => s.Id == updated.Id);
+            if (index >= 0)
+            {
+                _signatures[index] = updated;
+            }
+            else
+            {
+                _signatures.Add(updated);
+            }
+        }
+
+        return Task.FromResult(updated);
+    }
+
+    public Task<bool> DeleteAsync(
+        Guid id,
+        CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        lock (_gate)
+        {
+            var removed = _signatures.RemoveAll(s => s.Id == id);
+            return Task.FromResult(removed > 0);
+        }
+    }
+
+    public Task<IReadOnlyDictionary<string, int>> GetCountsByStateAsync(
+        CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+
+        lock (_gate)
+        {
+            var counts = _signatures
+                .GroupBy(s => NormalizeState(s.SignatureState))
+                .ToDictionary(g => g.Key, g => g.Count(), StringComparer.OrdinalIgnoreCase);
+            return Task.FromResult<IReadOnlyDictionary<string, int>>(counts);
+        }
+    }
+
+    public Task<PatchCoverageResult> GetPatchCoverageAsync(
+        IReadOnlyList<string>? cveFilter = null,
+        string? packageFilter = null,
+        int limit = 100,
+        int offset = 0,
+        CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+
+        var cveSet = cveFilter is { Count: > 0 }
+            ? cveFilter.ToHashSet(StringComparer.OrdinalIgnoreCase)
+            : null;
+
+        lock (_gate)
+        {
+            var grouped = _signatures
+                .Where(s =>
+                    (cveSet is null || cveSet.Contains(s.CveId)) &&
+                    (string.IsNullOrWhiteSpace(packageFilter) ||
+                     s.PackageName.Equals(packageFilter, StringComparison.OrdinalIgnoreCase)))
+                .GroupBy(s => new { s.CveId, s.PackageName })
+                .Select(g =>
+                {
+                    var vulnerableCount = g.Count(s => NormalizeState(s.SignatureState) == "vulnerable");
+                    var patchedCount = g.Count(s => NormalizeState(s.SignatureState) == "patched");
+                    var unknownCount = g.Count() - vulnerableCount - patchedCount;
+                    var denominator = vulnerableCount + patchedCount + unknownCount;
+                    var coverage = denominator == 0
+                        ? 0m
+                        : decimal.Round((decimal)patchedCount * 100m / denominator, 1);
+
+                    return new PatchCoverageEntry
+                    {
+                        CveId = g.Key.CveId,
+                        PackageName = g.Key.PackageName,
+                        VulnerableCount = vulnerableCount,
+                        PatchedCount = patchedCount,
+                        UnknownCount = unknownCount,
+                        SymbolCount = g.Select(x => x.SymbolName).Distinct(StringComparer.OrdinalIgnoreCase).Count(),
+                        CoveragePercent = coverage,
+                        LastUpdatedAt = g.Max(x => x.UpdatedAt)
+                    };
+                })
+                .OrderBy(e => e.CveId, StringComparer.OrdinalIgnoreCase)
+                .ToList();
+
+            return Task.FromResult(new PatchCoverageResult
+            {
+                Entries = grouped.Skip(offset).Take(limit).ToList(),
+                TotalCount = grouped.Count,
+                Offset = offset,
+                Limit = limit
+            });
+        }
+    }
+
+    public Task<PatchCoverageDetails?> GetPatchCoverageDetailsAsync(
+        string cveId,
+        CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+
+        lock (_gate)
+        {
+            var cveSignatures = _signatures
+                .Where(s => s.CveId.Equals(cveId, StringComparison.OrdinalIgnoreCase))
+                .ToList();
+
+            if (cveSignatures.Count == 0)
+            {
+                return Task.FromResult<PatchCoverageDetails?>(null);
+            }
+
+            var functions = cveSignatures
+                .GroupBy(s => new { s.SymbolName, s.Soname })
+                .Select(g =>
+                {
+                    var vulnerableCount = g.Count(s => NormalizeState(s.SignatureState) == "vulnerable");
+                    var patchedCount = g.Count(s => NormalizeState(s.SignatureState) == "patched");
+                    var unknownCount = g.Count() - vulnerableCount - patchedCount;
+
+                    return new FunctionCoverageEntry
+                    {
+                        SymbolName = g.Key.SymbolName,
+                        Soname = g.Key.Soname,
+                        VulnerableCount = vulnerableCount,
+                        PatchedCount = patchedCount,
+                        UnknownCount = unknownCount,
+                        HasDelta = vulnerableCount > 0 && patchedCount > 0
+                    };
+                })
+                .OrderBy(x => x.SymbolName, StringComparer.OrdinalIgnoreCase)
+                .ToList();
+
+            var totalVulnerable = functions.Sum(f => f.VulnerableCount);
+            var totalPatched = functions.Sum(f => f.PatchedCount);
+            var totalUnknown = functions.Sum(f => f.UnknownCount);
+            var total = totalVulnerable + totalPatched + totalUnknown;
+
+            return Task.FromResult<PatchCoverageDetails?>(new PatchCoverageDetails
+            {
+                CveId = cveId,
+                PackageName = cveSignatures[0].PackageName,
+                Functions = functions,
+                Summary = new PatchCoverageSummary
+                {
+                    TotalImages = total,
+                    VulnerableImages = totalVulnerable,
+                    PatchedImages = totalPatched,
+                    UnknownImages = totalUnknown,
+                    OverallCoverage = total == 0 ? 0m : decimal.Round((decimal)totalPatched * 100m / total, 1),
+                    SymbolCount = functions.Count,
+                    DeltaPairCount = functions.Count(f => f.HasDelta)
+                }
+            });
+        }
+    }
+
+    public Task<PatchMatchPage> GetMatchingImagesAsync(
+        string cveId,
+        string? symbolName = null,
+        string? matchState = null,
+        int limit = 50,
+        int offset = 0,
+        CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+
+        lock (_gate)
+        {
+            var filtered = _matches
+                .Where(m => m.CveId.Equals(cveId, StringComparison.OrdinalIgnoreCase))
+                .Where(m => string.IsNullOrWhiteSpace(symbolName) ||
+                            m.SymbolName.Equals(symbolName, StringComparison.OrdinalIgnoreCase))
+                .Where(m => string.IsNullOrWhiteSpace(matchState) ||
+                            NormalizeState(m.MatchedState) == NormalizeState(matchState))
+                .OrderByDescending(m => m.ScannedAt)
+                .ToList();
+
+            return Task.FromResult(new PatchMatchPage
+            {
+                Matches = filtered
+                    .Skip(offset)
+                    .Take(limit)
+                    .Select(m => new PatchMatchEntry
+                    {
+                        MatchId = m.Id,
+                        BinaryKey = m.BinaryKey,
+                        BinarySha256 = m.BinarySha256,
+                        SymbolName = m.SymbolName,
+                        MatchState = NormalizeState(m.MatchedState),
+                        Confidence = m.Confidence,
+                        ScanId = m.ScanId,
+                        ScannedAt = m.ScannedAt
+                    })
+                    .ToList(),
+                TotalCount = filtered.Count,
+                Offset = offset,
+                Limit = limit
+            });
+        }
+    }
+
+    private Task<IReadOnlyList<DeltaSignatureEntity>> QueryAsync(
+        Func<DeltaSignatureEntity, bool> predicate,
+        Func<DeltaSignatureEntity, string> orderBy,
+        CancellationToken ct)
+    {
+        ct.ThrowIfCancellationRequested();
+        lock (_gate)
+        {
+            return Task.FromResult<IReadOnlyList<DeltaSignatureEntity>>(
+                _signatures
+                    .Where(predicate)
+                    .OrderBy(orderBy, StringComparer.OrdinalIgnoreCase)
+                    .ThenBy(s => s.SymbolName, StringComparer.OrdinalIgnoreCase)
+                    .ThenBy(s => s.SignatureState, StringComparer.OrdinalIgnoreCase)
+                    .ToList());
+        }
+    }
+
+    private static string NormalizeState(string state) => state.Trim().ToLowerInvariant();
+
+    private static DeltaSignatureEntity Signature(
+        Guid id,
+        string cveId,
+        string packageName,
+        string symbolName,
+        string hashHex,
+        string signatureState,
+        DateTimeOffset now) =>
+        new()
+        {
+            Id = id,
+            CveId = cveId,
+            PackageName = packageName,
+            Soname = "libcrypto.so.3",
+            Arch = "x86_64",
+            Abi = "gnu",
+            RecipeId = "delta/v1",
+            RecipeVersion = "1.0.0",
+            SymbolName = symbolName,
+            Scope = ".text",
+            HashAlg = "sha256",
+            HashHex = hashHex,
+            SizeBytes = 128,
+            CfgBbCount = 6,
+            CfgEdgeHash = hashHex[..16],
+            ChunkHashes =
+            [
+                new ChunkHash(0, 64, hashHex[..16]),
+                new ChunkHash(64, 64, hashHex[16..32])
+            ],
+            SignatureState = signatureState,
+            CreatedAt = now,
+            UpdatedAt = now
+        };
+}

src/BinaryIndex/StellaOps.BinaryIndex.WebService/Services/InMemoryGoldenSetStore.cs

@@ -0,0 +1,425 @@
+using Microsoft.Extensions.Logging;
+using StellaOps.BinaryIndex.GoldenSet;
+using System.Collections.Immutable;
+using System.Globalization;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+
+namespace StellaOps.BinaryIndex.WebService.Services;
+
+/// <summary>
+/// Deterministic in-memory GoldenSet store used by WebService local/offline runtime.
+/// </summary>
+public sealed class InMemoryGoldenSetStore : IGoldenSetStore
+{
+    private readonly object _gate = new();
+    private readonly Dictionary<string, StoredRecord> _records = new(StringComparer.OrdinalIgnoreCase);
+    private readonly Dictionary<string, string> _idByDigest = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, List<GoldenSetAuditEntry>> _audit = new(StringComparer.OrdinalIgnoreCase);
+    private readonly TimeProvider _timeProvider;
+    private readonly ILogger<InMemoryGoldenSetStore> _logger;
+
+    public InMemoryGoldenSetStore(
+        TimeProvider? timeProvider = null,
+        ILogger<InMemoryGoldenSetStore>? logger = null)
+    {
+        _timeProvider = timeProvider ?? TimeProvider.System;
+        _logger = logger ?? Microsoft.Extensions.Logging.Abstractions.NullLogger<InMemoryGoldenSetStore>.Instance;
+    }
+
+    public Task<GoldenSetStoreResult> StoreAsync(
+        GoldenSetDefinition definition,
+        GoldenSetStatus status = GoldenSetStatus.Draft,
+        CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        ArgumentNullException.ThrowIfNull(definition);
+
+        if (string.IsNullOrWhiteSpace(definition.Id))
+        {
+            return Task.FromResult(GoldenSetStoreResult.Failed("Golden set id is required."));
+        }
+
+        var id = definition.Id.Trim();
+        var now = _timeProvider.GetUtcNow();
+        var digest = definition.ContentDigest ?? ComputeContentDigest(definition);
+        var normalizedDefinition = definition with { Id = id, ContentDigest = digest };
+
+        lock (_gate)
+        {
+            var wasUpdated = _records.TryGetValue(id, out var existing);
+            var createdAt = wasUpdated ? existing!.Stored.CreatedAt : now;
+
+            var stored = new StoredGoldenSet
+            {
+                Definition = normalizedDefinition,
+                Status = status,
+                CreatedAt = createdAt,
+                UpdatedAt = now
+            };
+
+            _records[id] = new StoredRecord(stored, digest);
+            _idByDigest[digest] = id;
+
+            AppendAudit(
+                id,
+                new GoldenSetAuditEntry
+                {
+                    Operation = wasUpdated ? "update" : "create",
+                    ActorId = string.IsNullOrWhiteSpace(definition.Metadata.AuthorId) ? "system" : definition.Metadata.AuthorId,
+                    Timestamp = now,
+                    OldStatus = wasUpdated ? existing!.Stored.Status : null,
+                    NewStatus = status,
+                    Comment = wasUpdated ? "Updated in-memory golden set entry." : "Created in-memory golden set entry."
+                });
+
+            return Task.FromResult(GoldenSetStoreResult.Succeeded(digest, wasUpdated));
+        }
+    }
+
+    public Task<GoldenSetDefinition?> GetByIdAsync(string goldenSetId, CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        ArgumentException.ThrowIfNullOrWhiteSpace(goldenSetId);
+
+        lock (_gate)
+        {
+            return Task.FromResult(
+                _records.TryGetValue(goldenSetId.Trim(), out var record)
+                    ? record.Stored.Definition
+                    : null);
+        }
+    }
+
+    public Task<GoldenSetDefinition?> GetByDigestAsync(string contentDigest, CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        ArgumentException.ThrowIfNullOrWhiteSpace(contentDigest);
+
+        lock (_gate)
+        {
+            if (!_idByDigest.TryGetValue(contentDigest.Trim(), out var id))
+            {
+                return Task.FromResult<GoldenSetDefinition?>(null);
+            }
+
+            return Task.FromResult(
+                _records.TryGetValue(id, out var record)
+                    ? record.Stored.Definition
+                    : null);
+        }
+    }
+
+    public Task<ImmutableArray<GoldenSetSummary>> ListAsync(
+        GoldenSetListQuery query,
+        CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        ArgumentNullException.ThrowIfNull(query);
+
+        lock (_gate)
+        {
+            IEnumerable<StoredRecord> records = _records.Values;
+
+            if (!string.IsNullOrWhiteSpace(query.ComponentFilter))
+            {
+                records = records.Where(x =>
+                    string.Equals(
+                        x.Stored.Definition.Component,
+                        query.ComponentFilter,
+                        StringComparison.OrdinalIgnoreCase));
+            }
+
+            if (query.StatusFilter.HasValue)
+            {
+                records = records.Where(x => x.Stored.Status == query.StatusFilter.Value);
+            }
+
+            if (query.TagsFilter is { IsDefaultOrEmpty: false })
+            {
+                var tags = query.TagsFilter.Value;
+                records = records.Where(x =>
+                    !x.Stored.Definition.Metadata.Tags.IsDefaultOrEmpty &&
+                    x.Stored.Definition.Metadata.Tags.Any(t =>
+                        tags.Any(filter => string.Equals(filter, t, StringComparison.OrdinalIgnoreCase))));
+            }
+
+            if (query.CreatedAfter.HasValue)
+            {
+                records = records.Where(x => x.Stored.CreatedAt >= query.CreatedAfter.Value);
+            }
+
+            if (query.CreatedBefore.HasValue)
+            {
+                records = records.Where(x => x.Stored.CreatedAt <= query.CreatedBefore.Value);
+            }
+
+            records = query.OrderBy switch
+            {
+                GoldenSetOrderBy.IdAsc => records.OrderBy(x => x.Stored.Definition.Id, StringComparer.OrdinalIgnoreCase),
+                GoldenSetOrderBy.IdDesc => records.OrderByDescending(x => x.Stored.Definition.Id, StringComparer.OrdinalIgnoreCase),
+                GoldenSetOrderBy.CreatedAtAsc => records.OrderBy(x => x.Stored.CreatedAt),
+                GoldenSetOrderBy.CreatedAtDesc => records.OrderByDescending(x => x.Stored.CreatedAt),
+                GoldenSetOrderBy.ComponentAsc => records
+                    .OrderBy(x => x.Stored.Definition.Component, StringComparer.OrdinalIgnoreCase)
+                    .ThenBy(x => x.Stored.Definition.Id, StringComparer.OrdinalIgnoreCase),
+                GoldenSetOrderBy.ComponentDesc => records
+                    .OrderByDescending(x => x.Stored.Definition.Component, StringComparer.OrdinalIgnoreCase)
+                    .ThenBy(x => x.Stored.Definition.Id, StringComparer.OrdinalIgnoreCase),
+                _ => records.OrderByDescending(x => x.Stored.CreatedAt)
+            };
+
+            var projected = records
+                .Skip(Math.Max(0, query.Offset))
+                .Take(Math.Max(1, query.Limit))
+                .Select(x => new GoldenSetSummary
+                {
+                    Id = x.Stored.Definition.Id,
+                    Component = x.Stored.Definition.Component,
+                    Status = x.Stored.Status,
+                    TargetCount = x.Stored.Definition.Targets.IsDefault ? 0 : x.Stored.Definition.Targets.Length,
+                    CreatedAt = x.Stored.CreatedAt,
+                    ReviewedAt = x.Stored.Definition.Metadata.ReviewedAt,
+                    ContentDigest = x.ContentDigest,
+                    Tags = x.Stored.Definition.Metadata.Tags
+                })
+                .ToImmutableArray();
+
+            return Task.FromResult(projected);
+        }
+    }
+
+    public Task UpdateStatusAsync(
+        string goldenSetId,
+        GoldenSetStatus status,
+        string? reviewedBy = null,
+        CancellationToken ct = default) =>
+        UpdateStatusAsync(
+            goldenSetId,
+            status,
+            reviewedBy ?? "system",
+            comment: string.Empty,
+            ct: ct);
+
+    public Task<GoldenSetStoreResult> UpdateStatusAsync(
+        string goldenSetId,
+        GoldenSetStatus status,
+        string actorId,
+        string comment,
+        CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        ArgumentException.ThrowIfNullOrWhiteSpace(goldenSetId);
+        ArgumentException.ThrowIfNullOrWhiteSpace(actorId);
+
+        var id = goldenSetId.Trim();
+        var now = _timeProvider.GetUtcNow();
+
+        lock (_gate)
+        {
+            if (!_records.TryGetValue(id, out var existing))
+            {
+                return Task.FromResult(GoldenSetStoreResult.Failed($"Golden set '{id}' was not found."));
+            }
+
+            var updatedMetadata = existing.Stored.Definition.Metadata with
+            {
+                ReviewedBy = actorId,
+                ReviewedAt = now
+            };
+
+            var updatedDefinition = existing.Stored.Definition with
+            {
+                Metadata = updatedMetadata
+            };
+
+            _records[id] = existing with
+            {
+                Stored = existing.Stored with
+                {
+                    Definition = updatedDefinition,
+                    Status = status,
+                    UpdatedAt = now
+                }
+            };
+
+            AppendAudit(
+                id,
+                new GoldenSetAuditEntry
+                {
+                    Operation = "status_update",
+                    ActorId = actorId,
+                    Timestamp = now,
+                    OldStatus = existing.Stored.Status,
+                    NewStatus = status,
+                    Comment = comment
+                });
+
+            return Task.FromResult(GoldenSetStoreResult.Succeeded(existing.ContentDigest, wasUpdated: true));
+        }
+    }
+
+    public Task<StoredGoldenSet?> GetAsync(string goldenSetId, CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        ArgumentException.ThrowIfNullOrWhiteSpace(goldenSetId);
+
+        lock (_gate)
+        {
+            return Task.FromResult(
+                _records.TryGetValue(goldenSetId.Trim(), out var record)
+                    ? record.Stored
+                    : null);
+        }
+    }
+
+    public Task<ImmutableArray<GoldenSetAuditEntry>> GetAuditLogAsync(
+        string goldenSetId,
+        CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        ArgumentException.ThrowIfNullOrWhiteSpace(goldenSetId);
+
+        lock (_gate)
+        {
+            if (!_audit.TryGetValue(goldenSetId.Trim(), out var entries))
+            {
+                return Task.FromResult(ImmutableArray<GoldenSetAuditEntry>.Empty);
+            }
+
+            return Task.FromResult(
+                entries
+                    .OrderByDescending(x => x.Timestamp)
+                    .ToImmutableArray());
+        }
+    }
+
+    public Task<ImmutableArray<GoldenSetDefinition>> GetByComponentAsync(
+        string component,
+        GoldenSetStatus? statusFilter = GoldenSetStatus.Approved,
+        CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        ArgumentException.ThrowIfNullOrWhiteSpace(component);
+
+        lock (_gate)
+        {
+            var definitions = _records.Values
+                .Where(x => string.Equals(
+                    x.Stored.Definition.Component,
+                    component,
+                    StringComparison.OrdinalIgnoreCase))
+                .Where(x => !statusFilter.HasValue || x.Stored.Status == statusFilter.Value)
+                .OrderBy(x => x.Stored.Definition.Id, StringComparer.OrdinalIgnoreCase)
+                .Select(x => x.Stored.Definition)
+                .ToImmutableArray();
+
+            return Task.FromResult(definitions);
+        }
+    }
+
+    public Task<bool> DeleteAsync(string goldenSetId, CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        ArgumentException.ThrowIfNullOrWhiteSpace(goldenSetId);
+
+        var id = goldenSetId.Trim();
+        var now = _timeProvider.GetUtcNow();
+
+        lock (_gate)
+        {
+            if (!_records.TryGetValue(id, out var existing))
+            {
+                return Task.FromResult(false);
+            }
+
+            _records[id] = existing with
+            {
+                Stored = existing.Stored with
+                {
+                    Status = GoldenSetStatus.Archived,
+                    UpdatedAt = now
+                }
+            };
+
+            AppendAudit(
+                id,
+                new GoldenSetAuditEntry
+                {
+                    Operation = "delete",
+                    ActorId = "system",
+                    Timestamp = now,
+                    OldStatus = existing.Stored.Status,
+                    NewStatus = GoldenSetStatus.Archived,
+                    Comment = "Archived via in-memory delete."
+                });
+
+            return Task.FromResult(true);
+        }
+    }
+
+    private void AppendAudit(string id, GoldenSetAuditEntry entry)
+    {
+        if (!_audit.TryGetValue(id, out var entries))
+        {
+            entries = [];
+            _audit[id] = entries;
+        }
+
+        entries.Add(entry);
+    }
+
+    private static string ComputeContentDigest(GoldenSetDefinition definition)
+    {
+        var canonical = new
+        {
+            id = definition.Id,
+            component = definition.Component,
+            targets = definition.Targets
+                .OrderBy(x => x.FunctionName, StringComparer.Ordinal)
+                .Select(t => new
+                {
+                    function = t.FunctionName,
+                    edges = t.Edges.Select(e => e.ToString()).OrderBy(x => x, StringComparer.Ordinal).ToArray(),
+                    sinks = t.Sinks.OrderBy(x => x, StringComparer.Ordinal).ToArray(),
+                    constants = t.Constants.OrderBy(x => x, StringComparer.Ordinal).ToArray(),
+                    taintInvariant = t.TaintInvariant,
+                    sourceFile = t.SourceFile,
+                    sourceLine = t.SourceLine
+                })
+                .ToArray(),
+            metadata = new
+            {
+                authorId = definition.Metadata.AuthorId,
+                createdAt = definition.Metadata.CreatedAt.ToUniversalTime().ToString("O", CultureInfo.InvariantCulture),
+                sourceRef = definition.Metadata.SourceRef,
+                reviewedBy = definition.Metadata.ReviewedBy,
+                reviewedAt = definition.Metadata.ReviewedAt?.ToUniversalTime().ToString("O", CultureInfo.InvariantCulture),
+                tags = definition.Metadata.Tags.OrderBy(x => x, StringComparer.Ordinal).ToArray(),
+                schemaVersion = definition.Metadata.SchemaVersion
+            },
+            witness = definition.Witness is null
+                ? null
+                : new
+                {
+                    arguments = definition.Witness.Arguments.ToArray(),
+                    invariant = definition.Witness.Invariant,
+                    pocFileRef = definition.Witness.PocFileRef
+                }
+        };
+
+        var json = JsonSerializer.Serialize(canonical, CanonicalJsonOptions);
+        var hash = SHA256.HashData(Encoding.UTF8.GetBytes(json));
+        return $"sha256:{Convert.ToHexStringLower(hash)}";
+    }
+
+    private static readonly JsonSerializerOptions CanonicalJsonOptions = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        WriteIndented = false,
+        DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull
+    };
+
+    private sealed record StoredRecord(StoredGoldenSet Stored, string ContentDigest);
+}

src/BinaryIndex/StellaOps.BinaryIndex.WebService/Services/InMemoryResolutionCacheService.cs

@@ -0,0 +1,179 @@
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using StellaOps.BinaryIndex.Cache;
+using StellaOps.BinaryIndex.Contracts.Resolution;
+using System.Text.RegularExpressions;
+
+namespace StellaOps.BinaryIndex.WebService.Services;
+
+/// <summary>
+/// Deterministic in-memory cache used when Redis is unavailable.
+/// </summary>
+public sealed class InMemoryResolutionCacheService : IResolutionCacheService
+{
+    private readonly object _gate = new();
+    private readonly Dictionary<string, CacheEntry> _entries = new(StringComparer.Ordinal);
+    private readonly ResolutionCacheOptions _options;
+    private readonly TimeProvider _timeProvider;
+    private readonly ILogger<InMemoryResolutionCacheService> _logger;
+
+    public InMemoryResolutionCacheService(
+        IOptions<ResolutionCacheOptions> options,
+        TimeProvider timeProvider,
+        ILogger<InMemoryResolutionCacheService> logger)
+    {
+        _options = options?.Value ?? throw new ArgumentNullException(nameof(options));
+        _timeProvider = timeProvider ?? throw new ArgumentNullException(nameof(timeProvider));
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    public Task<CachedResolution?> GetAsync(string cacheKey, CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        ArgumentException.ThrowIfNullOrWhiteSpace(cacheKey);
+
+        lock (_gate)
+        {
+            if (!_entries.TryGetValue(cacheKey, out var entry))
+            {
+                return Task.FromResult<CachedResolution?>(null);
+            }
+
+            var now = _timeProvider.GetUtcNow();
+            if (entry.ExpiresAt <= now)
+            {
+                _entries.Remove(cacheKey);
+                return Task.FromResult<CachedResolution?>(null);
+            }
+
+            return Task.FromResult<CachedResolution?>(entry.Value);
+        }
+    }
+
+    public Task SetAsync(string cacheKey, CachedResolution result, TimeSpan ttl, CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        ArgumentException.ThrowIfNullOrWhiteSpace(cacheKey);
+        ArgumentNullException.ThrowIfNull(result);
+
+        lock (_gate)
+        {
+            if (ttl <= TimeSpan.Zero)
+            {
+                _entries.Remove(cacheKey);
+                return Task.CompletedTask;
+            }
+
+            var now = _timeProvider.GetUtcNow();
+            _entries[cacheKey] = new CacheEntry(result, now + ttl);
+            return Task.CompletedTask;
+        }
+    }
+
+    public Task InvalidateByPatternAsync(string pattern, CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        ArgumentException.ThrowIfNullOrWhiteSpace(pattern);
+
+        var regex = ToPatternRegex(pattern);
+        lock (_gate)
+        {
+            var keys = _entries.Keys
+                .Where(key => regex.IsMatch(key))
+                .ToArray();
+
+            foreach (var key in keys)
+            {
+                _entries.Remove(key);
+            }
+
+            if (keys.Length > 0)
+            {
+                _logger.LogInformation(
+                    "Invalidated {Count} in-memory cache entries for pattern {Pattern}",
+                    keys.Length,
+                    pattern);
+            }
+        }
+
+        return Task.CompletedTask;
+    }
+
+    public string GenerateCacheKey(VulnResolutionRequest request)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+
+        var algorithm = DetermineAlgorithm(request);
+        var hash = ComputeIdentityHash(request);
+        var cveId = request.CveId ?? "all";
+        return $"{_options.KeyPrefix}:{algorithm}:{hash}:{cveId}";
+    }
+
+    private static string DetermineAlgorithm(VulnResolutionRequest request)
+    {
+        if (!string.IsNullOrWhiteSpace(request.BuildId))
+        {
+            return "build_id";
+        }
+
+        if (!string.IsNullOrWhiteSpace(request.Fingerprint))
+        {
+            return request.FingerprintAlgorithm ?? "combined";
+        }
+
+        if (!string.IsNullOrWhiteSpace(request.Hashes?.TextSha256))
+        {
+            return "text_sha256";
+        }
+
+        if (!string.IsNullOrWhiteSpace(request.Hashes?.FileSha256))
+        {
+            return "file_sha256";
+        }
+
+        return "package";
+    }
+
+    private static string ComputeIdentityHash(VulnResolutionRequest request)
+    {
+        if (!string.IsNullOrWhiteSpace(request.BuildId))
+        {
+            return request.BuildId;
+        }
+
+        if (!string.IsNullOrWhiteSpace(request.Fingerprint))
+        {
+            return ComputeShortHash(request.Fingerprint);
+        }
+
+        if (!string.IsNullOrWhiteSpace(request.Hashes?.TextSha256))
+        {
+            return request.Hashes.TextSha256;
+        }
+
+        if (!string.IsNullOrWhiteSpace(request.Hashes?.FileSha256))
+        {
+            return request.Hashes.FileSha256;
+        }
+
+        var key = $"{request.Package}:{request.DistroRelease ?? "unknown"}";
+        return ComputeShortHash(key);
+    }
+
+    private static string ComputeShortHash(string input)
+    {
+        var bytes = System.Text.Encoding.UTF8.GetBytes(input);
+        var hash = System.Security.Cryptography.SHA256.HashData(bytes);
+        return Convert.ToHexStringLower(hash)[..16];
+    }
+
+    private static Regex ToPatternRegex(string pattern)
+    {
+        var escaped = Regex.Escape(pattern)
+            .Replace("\\*", ".*", StringComparison.Ordinal)
+            .Replace("\\?", ".", StringComparison.Ordinal);
+        return new Regex($"^{escaped}$", RegexOptions.Compiled | RegexOptions.CultureInvariant);
+    }
+
+    private sealed record CacheEntry(CachedResolution Value, DateTimeOffset ExpiresAt);
+}

src/BinaryIndex/StellaOps.BinaryIndex.WebService/TASKS.md

@@ -5,6 +5,27 @@ Source of truth: `docs-archived/implplan/2025-12-29-csproj-audit/SPRINT_20251229
 
 | Task ID | Status | Notes |
 | --- | --- | --- |
+| QA-BINARYINDEX-VERIFY-029 | DONE | SPRINT_20260211_033 run-001: `patch-coverage-tracking` passed Tier 0/1/2 with patch-coverage controller behavioral evidence (including post-create coverage updates) and was moved to `docs/features/checked/binaryindex/patch-coverage-tracking.md`. |
+| QA-BINARYINDEX-VERIFY-028 | BLOCKED | SPRINT_20260211_033: `ml-function-embedding-service` is actively owned by another lane (`run-001` in progress); this lane terminalized collision as `skipped` (`owned_by_other_agent`) per FLOW 0.1. |
+| QA-BINARYINDEX-VERIFY-026 | DONE | SPRINT_20260211_033 run-002: `known-build-binary-catalog` passed Tier 0/1/2 with Build-ID/SHA256/assertion/cache/method-mapping behavioral evidence; dossier verified in `docs/features/checked/binaryindex/known-build-binary-catalog.md`. |
+| QA-BINARYINDEX-VERIFY-025 | DOING | SPRINT_20260211_033 run-001: claimed `ground-truth-corpus-infrastructure` for Tier 0/1/2 verification as next deterministic queued BinaryIndex feature. |
+| QA-BINARYINDEX-VERIFY-023 | BLOCKED | SPRINT_20260211_033: required module-local charters missing for Analysis/Analysis.Tests/GoldenSet.Tests paths; blocked per repo AGENTS rule 5. |
+| QA-BINARYINDEX-VERIFY-018 | DONE | SPRINT_20260211_033 run-001: `elf-normalization-and-delta-hashing` terminalized as `not_implemented` after Tier 0/1/2 parity evidence confirmed missing segment-level ELF normalization pipeline. |
+| QA-BINARYINDEX-VERIFY-017 | DONE | SPRINT_20260211_033 run-001: `disassembly-and-binary-analysis-pipeline` passed Tier 0/1/2 with Disassembly/Ghidra/Decompiler behavioral evidence and was moved to `docs/features/checked/binaryindex/`. |
+| QA-BINARYINDEX-VERIFY-016 | DONE | SPRINT_20260211_033 run-001: `delta-signature-predicates` passed Tier 0/1/2 with DeltaSig/VexBridge behavioral evidence and was moved to `docs/features/checked/binaryindex/`. |
+| QA-BINARYINDEX-VERIFY-015 | DONE | SPRINT_20260211_033 run-002: completed Tier 0/1/2 verification and terminalized `delta-signature-matching-and-patch-coverage-analysis` as `not_implemented` (missing `IDeltaSignatureRepository` wiring and IR-diff parity gaps). |
+| QA-BINARYINDEX-VERIFY-013 | DOING | SPRINT_20260211_030 run-001: claimed `call-ngram-fingerprinting-for-binary-similarity-analysis` for Tier 0/1/2 verification as next deterministic queued BinaryIndex feature. |
+| QA-BINARYINDEX-VERIFY-012 | DONE | SPRINT_20260211_030 run-001: `byte-level-binary-diffing-with-rolling-hash-windows` terminalized as `not_implemented` after Tier 0/1/2 parity review showed missing byte-range rolling-window and privacy/section behavior claims. |
+| QA-BINARYINDEX-VERIFY-011 | DONE | SPRINT_20260211_030 run-001: `binary-to-vex-claim-auto-generation` passed Tier 0/1/2 with VEX mapping/threshold/build-id/DSSE behavior evidence; dossier moved to `docs/features/checked/binaryindex/`. |
+| QA-BINARYINDEX-VERIFY-009 | BLOCKED | SPRINT_20260211_030: ownership collision for `binary-resolution-api-with-cache-layer`; this lane terminalized as `skipped` (`owned_by_other_agent`) per FLOW 0.1. |
+| QA-BINARYINDEX-VERIFY-008 | DONE | SPRINT_20260211_030 run-001: `binary-reachability-analysis` terminalized as `not_implemented` after Tier 0/1/2 verification and parity review of stubbed analysis/reachability paths. |
+| QA-BINARYINDEX-VERIFY-007 | DONE | SPRINT_20260211_030 run-001: `binary-proof-verification-pipeline` terminalized as `not_implemented` after Tier 0/1/2 verification and parity review of placeholder validation/matcher stages. |
+| QA-BINARYINDEX-VERIFY-001 | DONE | SPRINT_20260211_030 run-001/run-002: verified `binaryindex-ops-endpoints`; fixed DI startup blocker and completed Tier 0/1/2 with terminal `done`. |
+| QA-BINARYINDEX-VERIFY-002 | DONE | SPRINT_20260211_030 run-001: `binary-call-graph-extraction-and-reachability-analysis` terminalized as `not_implemented` after Tier 0/1/2 parity review. |
+| QA-BINARYINDEX-VERIFY-003 | DONE | SPRINT_20260211_030 run-001: `binary-identity-extraction` terminalized as `not_implemented` after Tier 0/1/2 parity review. |
+| QA-BINARYINDEX-VERIFY-004 | DONE | SPRINT_20260211_030 run-001: verified `binaryindex-ops-cli-commands`; Tier 0/1/2 passed with live CLI ops checks and semantic-flag evidence. |
+| QA-BINARYINDEX-VERIFY-005 | DONE | SPRINT_20260211_030 run-001: `binaryindex-user-configuration-system` terminalized as `not_implemented`; live ops config probe showed `StellaOps:BinaryIndex:*` overrides were not reflected in runtime config endpoint output. |
+| QA-BINARYINDEX-VERIFY-006 | DONE | SPRINT_20260211_030 run-001: `binary-intelligence-graph-binary-identity-indexing` terminalized as `not_implemented` after Tier 0/1/2 API parity verification (default runtime fallback + reachability wiring gaps). |
 | AUDIT-0129-M | DONE | Maintainability audit for StellaOps.BinaryIndex.WebService; revalidated 2026-01-06. |
 | AUDIT-0129-T | DONE | Test coverage audit for StellaOps.BinaryIndex.WebService; revalidated 2026-01-06. |
 | AUDIT-0129-A | TODO | Revalidated 2026-01-06; open findings pending apply. |

src/BinaryIndex/StellaOps.BinaryIndex.WebService/docs/qa/feature-checks/runs/binaryindex/vulnerable-binaries-database/run-001/tier1-build-out/StellaOps.BinaryIndex.WebService/StellaOps.Auth.ServerIntegration.xml

@@ -0,0 +1,304 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>StellaOps.Auth.ServerIntegration</name>
+    </assembly>
+    <members>
+        <member name="T:StellaOps.Auth.ServerIntegration.ServiceCollectionExtensions">
+            <summary>
+            Dependency injection helpers for configuring StellaOps resource server authentication.
+            </summary>
+        </member>
+        <member name="M:StellaOps.Auth.ServerIntegration.ServiceCollectionExtensions.AddStellaOpsResourceServerAuthentication(Microsoft.Extensions.DependencyInjection.IServiceCollection,Microsoft.Extensions.Configuration.IConfiguration,System.String,System.Action{StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions})">
+            <summary>
+            Registers JWT bearer authentication and related authorisation helpers using the provided configuration section.
+            </summary>
+            <param name="services">The service collection.</param>
+            <param name="configuration">Application configuration.</param>
+            <param name="configurationSection">
+            Optional configuration section path. Defaults to <c>Authority:ResourceServer</c>. Provide <c>null</c> to skip binding.
+            </param>
+            <param name="configure">Optional callback allowing additional mutation of <see cref="T:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions"/>.</param>
+        </member>
+        <member name="T:StellaOps.Auth.ServerIntegration.StellaOpsAuthorityConfigurationManager">
+            <summary>
+            Cached configuration manager for StellaOps Authority metadata and JWKS.
+            </summary>
+        </member>
+        <member name="T:StellaOps.Auth.ServerIntegration.StellaOpsAuthorizationPolicyBuilderExtensions">
+            <summary>
+            Extension methods for configuring StellaOps authorisation policies.
+            </summary>
+        </member>
+        <member name="M:StellaOps.Auth.ServerIntegration.StellaOpsAuthorizationPolicyBuilderExtensions.RequireStellaOpsScopes(Microsoft.AspNetCore.Authorization.AuthorizationPolicyBuilder,System.String[])">
+            <summary>
+            Requires the specified scopes using the StellaOps scope requirement.
+            </summary>
+        </member>
+        <member name="M:StellaOps.Auth.ServerIntegration.StellaOpsAuthorizationPolicyBuilderExtensions.AddStellaOpsScopePolicy(Microsoft.AspNetCore.Authorization.AuthorizationOptions,System.String,System.String[])">
+            <summary>
+            Registers a named policy that enforces the provided scopes.
+            </summary>
+        </member>
+        <member name="M:StellaOps.Auth.ServerIntegration.StellaOpsAuthorizationPolicyBuilderExtensions.AddStellaOpsScopeHandler(Microsoft.Extensions.DependencyInjection.IServiceCollection)">
+            <summary>
+            Adds the scope handler to the DI container.
+            </summary>
+        </member>
+        <member name="T:StellaOps.Auth.ServerIntegration.StellaOpsBypassEvaluator">
+            <summary>
+            Evaluates whether a request qualifies for network-based bypass.
+            </summary>
+        </member>
+        <member name="T:StellaOps.Auth.ServerIntegration.StellaOpsLocalHostnameExtensions">
+            <summary>
+            Provides two extension methods for the <c>.stella-ops.local</c> hostname convention:
+            <list type="bullet">
+              <item>
+                <see cref="M:StellaOps.Auth.ServerIntegration.StellaOpsLocalHostnameExtensions.TryAddStellaOpsLocalBinding(Microsoft.AspNetCore.Builder.WebApplicationBuilder,System.String)"/> — called on <see cref="T:Microsoft.AspNetCore.Builder.WebApplicationBuilder"/>
+                before <c>Build()</c>; binds both <c>https://{serviceName}.stella-ops.local</c> (port 443)
+                and <c>http://{serviceName}.stella-ops.local</c> (port 80).
+              </item>
+              <item>
+                <see cref="M:StellaOps.Auth.ServerIntegration.StellaOpsLocalHostnameExtensions.LogStellaOpsLocalHostname(Microsoft.AspNetCore.Builder.WebApplication,System.String)"/> — called on <see cref="T:Microsoft.AspNetCore.Builder.WebApplication"/>
+                after <c>Build()</c>; checks DNS for the friendly hostname and logs the result.
+              </item>
+            </list>
+            </summary>
+        </member>
+        <member name="F:StellaOps.Auth.ServerIntegration.StellaOpsLocalHostnameExtensions.LocalBindingBoundKey">
+            <summary>
+            Configuration key used to communicate local-binding status
+            from the builder phase to the app phase.
+            </summary>
+        </member>
+        <member name="F:StellaOps.Auth.ServerIntegration.StellaOpsLocalHostnameExtensions.LocalBindingServiceKey">
+            <summary>
+            Configuration key storing the service name for use in the app phase.
+            </summary>
+        </member>
+        <member name="M:StellaOps.Auth.ServerIntegration.StellaOpsLocalHostnameExtensions.TryAddStellaOpsLocalBinding(Microsoft.AspNetCore.Builder.WebApplicationBuilder,System.String)">
+            <summary>
+            Resolves <c>{serviceName}.stella-ops.local</c> to its dedicated loopback IP
+            (from the hosts file), then binds <c>https://{hostname}</c> (port 443) and
+            <c>http://{hostname}</c> (port 80) on that IP. Each service uses a unique
+            loopback address (e.g. 127.1.0.2) so ports never collide.
+            </summary>
+        </member>
+        <member name="M:StellaOps.Auth.ServerIntegration.StellaOpsLocalHostnameExtensions.TryAddStellaOpsSharedPort(Microsoft.AspNetCore.Builder.WebApplicationBuilder)">
+            <summary>
+            Backwards-compatible overload — reads the service name from configuration
+            set by <see cref="M:StellaOps.Auth.ServerIntegration.StellaOpsLocalHostnameExtensions.TryAddStellaOpsLocalBinding(Microsoft.AspNetCore.Builder.WebApplicationBuilder,System.String)"/>.
+            </summary>
+        </member>
+        <member name="M:StellaOps.Auth.ServerIntegration.StellaOpsLocalHostnameExtensions.LogStellaOpsLocalHostname(Microsoft.AspNetCore.Builder.WebApplication,System.String)">
+            <summary>
+            Registers a startup callback that checks DNS for
+            <c>{serviceName}.stella-ops.local</c> and logs the result.
+            Also warns if the local bindings were skipped.
+            </summary>
+        </member>
+        <member name="T:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions">
+            <summary>
+            Options controlling StellaOps resource server authentication.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions.Authority">
+            <summary>
+            Gets or sets the Authority (issuer) URL that exposes OpenID discovery.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions.MetadataAddress">
+            <summary>
+            Optional explicit OpenID Connect metadata address.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions.Audiences">
+            <summary>
+            Audiences accepted by the resource server (validated against the <c>aud</c> claim).
+            </summary>
+        </member>
+        <member name="P:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions.RequiredScopes">
+            <summary>
+            Scopes enforced by default authorisation policies.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions.RequiredTenants">
+            <summary>
+            Tenants permitted to access the resource server (empty list disables tenant checks).
+            </summary>
+        </member>
+        <member name="P:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions.BypassNetworks">
+            <summary>
+            Networks permitted to bypass authentication (used for trusted on-host automation).
+            </summary>
+        </member>
+        <member name="P:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions.RequireHttpsMetadata">
+            <summary>
+            Whether HTTPS metadata is required when communicating with Authority.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions.BackchannelTimeout">
+            <summary>
+            Back-channel timeout when fetching metadata/JWKS.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions.TokenClockSkew">
+            <summary>
+            Clock skew tolerated when validating tokens.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions.MetadataCacheLifetime">
+            <summary>
+            Lifetime for cached discovery/JWKS metadata before forcing a refresh.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions.AllowOfflineCacheFallback">
+            <summary>
+            Gets or sets a value indicating whether stale metadata/JWKS may be reused if Authority is unreachable.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions.OfflineCacheTolerance">
+            <summary>
+            Additional tolerance window during which stale metadata/JWKS may be reused when offline fallback is allowed.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions.AuthorityUri">
+            <summary>
+            Gets the canonical Authority URI (populated during validation).
+            </summary>
+        </member>
+        <member name="P:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions.NormalizedScopes">
+            <summary>
+            Gets the normalised scope list (populated during validation).
+            </summary>
+        </member>
+        <member name="P:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions.NormalizedTenants">
+            <summary>
+            Gets the normalised tenant list (populated during validation).
+            </summary>
+        </member>
+        <member name="P:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions.BypassMatcher">
+            <summary>
+            Gets the network matcher used for bypass checks (populated during validation).
+            </summary>
+        </member>
+        <member name="M:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerOptions.Validate">
+            <summary>
+            Validates provided configuration and normalises collections.
+            </summary>
+        </member>
+        <member name="T:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies">
+            <summary>
+            Named authorization policies for StellaOps observability and evidence resource servers.
+            </summary>
+        </member>
+        <member name="F:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies.ObservabilityRead">
+            <summary>
+            Observability dashboards/read-only access policy name.
+            </summary>
+        </member>
+        <member name="F:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies.ObservabilityIncident">
+            <summary>
+            Observability incident activation policy name.
+            </summary>
+        </member>
+        <member name="F:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies.TimelineRead">
+            <summary>
+            Timeline read policy name.
+            </summary>
+        </member>
+        <member name="F:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies.TimelineWrite">
+            <summary>
+            Timeline write policy name.
+            </summary>
+        </member>
+        <member name="F:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies.EvidenceCreate">
+            <summary>
+            Evidence create policy name.
+            </summary>
+        </member>
+        <member name="F:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies.EvidenceRead">
+            <summary>
+            Evidence read policy name.
+            </summary>
+        </member>
+        <member name="F:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies.EvidenceHold">
+            <summary>
+            Evidence hold policy name.
+            </summary>
+        </member>
+        <member name="F:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies.AttestRead">
+            <summary>
+            Attestation read policy name.
+            </summary>
+        </member>
+        <member name="F:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies.ExportViewer">
+            <summary>
+            Export viewer policy name.
+            </summary>
+        </member>
+        <member name="F:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies.ExportOperator">
+            <summary>
+            Export operator policy name.
+            </summary>
+        </member>
+        <member name="F:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies.ExportAdmin">
+            <summary>
+            Export admin policy name.
+            </summary>
+        </member>
+        <member name="F:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies.PacksRead">
+            <summary>
+            Pack read policy name.
+            </summary>
+        </member>
+        <member name="F:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies.PacksWrite">
+            <summary>
+            Pack write policy name.
+            </summary>
+        </member>
+        <member name="F:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies.PacksRun">
+            <summary>
+            Pack run policy name.
+            </summary>
+        </member>
+        <member name="F:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies.PacksApprove">
+            <summary>
+            Pack approval policy name.
+            </summary>
+        </member>
+        <member name="M:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies.AddObservabilityResourcePolicies(Microsoft.AspNetCore.Authorization.AuthorizationOptions)">
+            <summary>
+            Registers all observability, timeline, evidence, attestation, and export authorization policies.
+            </summary>
+        </member>
+        <member name="M:StellaOps.Auth.ServerIntegration.StellaOpsResourceServerPolicies.AddPacksResourcePolicies(Microsoft.AspNetCore.Authorization.AuthorizationOptions)">
+            <summary>
+            Registers Task Pack registry, execution, and approval authorization policies.
+            </summary>
+            <param name="options">The authorization options to update.</param>
+        </member>
+        <member name="T:StellaOps.Auth.ServerIntegration.StellaOpsScopeAuthorizationHandler">
+            <summary>
+            Handles <see cref="T:StellaOps.Auth.ServerIntegration.StellaOpsScopeRequirement"/> evaluation.
+            </summary>
+        </member>
+        <member name="T:StellaOps.Auth.ServerIntegration.StellaOpsScopeRequirement">
+            <summary>
+            Authorisation requirement enforcing StellaOps scope membership.
+            </summary>
+        </member>
+        <member name="M:StellaOps.Auth.ServerIntegration.StellaOpsScopeRequirement.#ctor(System.Collections.Generic.IEnumerable{System.String})">
+            <summary>
+            Initialises a new instance of the <see cref="T:StellaOps.Auth.ServerIntegration.StellaOpsScopeRequirement"/> class.
+            </summary>
+            <param name="scopes">Scopes that satisfy the requirement.</param>
+        </member>
+        <member name="P:StellaOps.Auth.ServerIntegration.StellaOpsScopeRequirement.RequiredScopes">
+            <summary>
+            Gets the required scopes.
+            </summary>
+        </member>
+    </members>
+</doc>

src/BinaryIndex/StellaOps.BinaryIndex.WebService/docs/qa/feature-checks/runs/binaryindex/vulnerable-binaries-database/run-001/tier1-build-out/StellaOps.BinaryIndex.WebService/StellaOps.BinaryIndex.Contracts.xml

@@ -0,0 +1,181 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>StellaOps.BinaryIndex.Contracts</name>
+    </assembly>
+    <members>
+        <member name="T:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionRequest">
+            <summary>
+            Request to resolve vulnerability status for a binary.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionRequest.Package">
+            <summary>
+            Package URL (PURL) or CPE identifier.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionRequest.FilePath">
+            <summary>
+            File path within container/filesystem.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionRequest.BuildId">
+            <summary>
+            ELF Build-ID, PE CodeView GUID, or Mach-O UUID.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionRequest.Hashes">
+            <summary>
+            Hash values for matching.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionRequest.Fingerprint">
+            <summary>
+            Fingerprint bytes (Base64-encoded).
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionRequest.FingerprintAlgorithm">
+            <summary>
+            Fingerprint algorithm if fingerprint provided (e.g., "combined", "tlsh", "ssdeep").
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionRequest.CveId">
+            <summary>
+            CVE to check (optional, for targeted queries). If not provided, checks all known CVEs.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionRequest.DistroRelease">
+            <summary>
+            Distro hint for fix status lookup (e.g., "debian:bookworm").
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionHashes">
+            <summary>
+            Hash values for binary matching.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionHashes.FileSha256">
+            <summary>SHA-256 hash of the entire file.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionHashes.TextSha256">
+            <summary>SHA-256 hash of the .text section.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionHashes.Blake3">
+            <summary>BLAKE3 hash (future-proof).</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionResponse">
+            <summary>
+            Response from vulnerability resolution.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionResponse.Package">
+            <summary>Package identifier from request.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionResponse.Status">
+            <summary>Resolution status.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionResponse.FixedVersion">
+            <summary>Version where fix was applied (if status is Fixed).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionResponse.Evidence">
+            <summary>Evidence supporting the resolution.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionResponse.AttestationDsse">
+            <summary>DSSE attestation envelope (Base64-encoded JSON).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionResponse.ResolvedAt">
+            <summary>Timestamp when resolution was computed.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionResponse.FromCache">
+            <summary>Whether result was served from cache.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.VulnResolutionResponse.CveId">
+            <summary>CVE ID if a specific CVE was queried.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionStatus">
+            <summary>
+            Resolution status enumeration.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionStatus.Fixed">
+            <summary>Vulnerability is fixed in this binary (backport detected).</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionStatus.Vulnerable">
+            <summary>Binary is vulnerable.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionStatus.NotAffected">
+            <summary>Binary is not affected by this CVE.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionStatus.Unknown">
+            <summary>Resolution status unknown.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionEvidence">
+            <summary>
+            Evidence supporting a resolution decision.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionEvidence.MatchType">
+            <summary>Match method used (build_id, fingerprint, hash_exact).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionEvidence.Confidence">
+            <summary>Confidence score (0.0-1.0).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionEvidence.DistroAdvisoryId">
+            <summary>Distro advisory ID (e.g., DSA-5343-1, RHSA-2024:1234).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionEvidence.PatchHash">
+            <summary>SHA-256 of the security patch.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionEvidence.MatchedFingerprintIds">
+            <summary>List of matched fingerprint IDs.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionEvidence.FunctionDiffSummary">
+            <summary>Summary of function-level differences.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionEvidence.SourcePackage">
+            <summary>Source package name.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.ResolutionEvidence.FixMethod">
+            <summary>Detection method (security_feed, changelog, patch_header).</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Contracts.Resolution.BatchVulnResolutionRequest">
+            <summary>
+            Batch request for resolving multiple vulnerabilities.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.BatchVulnResolutionRequest.Items">
+            <summary>List of resolution requests.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.BatchVulnResolutionRequest.Options">
+            <summary>Resolution options.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Contracts.Resolution.BatchResolutionOptions">
+            <summary>
+            Options for batch resolution.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.BatchResolutionOptions.BypassCache">
+            <summary>Bypass cache and perform fresh lookups.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.BatchResolutionOptions.IncludeDsseAttestation">
+            <summary>Include DSSE attestation in responses.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Contracts.Resolution.BatchVulnResolutionResponse">
+            <summary>
+            Response from batch vulnerability resolution.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.BatchVulnResolutionResponse.Results">
+            <summary>List of resolution results.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.BatchVulnResolutionResponse.TotalCount">
+            <summary>Total items processed.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.BatchVulnResolutionResponse.CacheHits">
+            <summary>Number of items served from cache.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Contracts.Resolution.BatchVulnResolutionResponse.ProcessingTimeMs">
+            <summary>Processing time in milliseconds.</summary>
+        </member>
+    </members>
+</doc>

src/BinaryIndex/StellaOps.BinaryIndex.WebService/docs/qa/feature-checks/runs/binaryindex/vulnerable-binaries-database/run-001/tier1-build-out/StellaOps.BinaryIndex.WebService/StellaOps.BinaryIndex.Disassembly.Abstractions.xml

@@ -0,0 +1,635 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>StellaOps.BinaryIndex.Disassembly.Abstractions</name>
+    </assembly>
+    <members>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.IDisassemblyPlugin">
+            <summary>
+            Abstraction over binary disassembly engine plugins.
+            Each plugin implements this interface to provide disassembly capabilities.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.IDisassemblyPlugin.Capabilities">
+            <summary>
+            Gets the capabilities of this disassembly plugin.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.IDisassemblyPlugin.LoadBinary(System.IO.Stream,System.Nullable{StellaOps.BinaryIndex.Disassembly.CpuArchitecture},System.Nullable{StellaOps.BinaryIndex.Disassembly.BinaryFormat})">
+            <summary>
+            Loads a binary from a stream and detects format/architecture.
+            </summary>
+            <param name="stream">The binary stream to load.</param>
+            <param name="archHint">Optional hint for architecture detection.</param>
+            <param name="formatHint">Optional hint for format detection.</param>
+            <returns>Binary information including format, architecture, and metadata.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.IDisassemblyPlugin.LoadBinary(System.ReadOnlySpan{System.Byte},System.Nullable{StellaOps.BinaryIndex.Disassembly.CpuArchitecture},System.Nullable{StellaOps.BinaryIndex.Disassembly.BinaryFormat})">
+            <summary>
+            Loads a binary from a byte array.
+            </summary>
+            <param name="bytes">The binary data.</param>
+            <param name="archHint">Optional hint for architecture detection.</param>
+            <param name="formatHint">Optional hint for format detection.</param>
+            <returns>Binary information including format, architecture, and metadata.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.IDisassemblyPlugin.GetCodeRegions(StellaOps.BinaryIndex.Disassembly.BinaryInfo)">
+            <summary>
+            Gets executable code regions (sections) from the binary.
+            </summary>
+            <param name="binary">The loaded binary information.</param>
+            <returns>Enumerable of code regions.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.IDisassemblyPlugin.GetSymbols(StellaOps.BinaryIndex.Disassembly.BinaryInfo)">
+            <summary>
+            Gets symbols (functions) from the binary.
+            </summary>
+            <param name="binary">The loaded binary information.</param>
+            <returns>Enumerable of symbol information.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.IDisassemblyPlugin.Disassemble(StellaOps.BinaryIndex.Disassembly.BinaryInfo,StellaOps.BinaryIndex.Disassembly.CodeRegion)">
+            <summary>
+            Disassembles a code region to instructions.
+            </summary>
+            <param name="binary">The loaded binary information.</param>
+            <param name="region">The code region to disassemble.</param>
+            <returns>Enumerable of disassembled instructions.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.IDisassemblyPlugin.Disassemble(StellaOps.BinaryIndex.Disassembly.BinaryInfo,System.UInt64,System.UInt64)">
+            <summary>
+            Disassembles starting at a specific address for a given length.
+            </summary>
+            <param name="binary">The loaded binary information.</param>
+            <param name="startAddress">Virtual address to start disassembly.</param>
+            <param name="length">Maximum number of bytes to disassemble.</param>
+            <returns>Enumerable of disassembled instructions.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.IDisassemblyPlugin.DisassembleSymbol(StellaOps.BinaryIndex.Disassembly.BinaryInfo,StellaOps.BinaryIndex.Disassembly.SymbolInfo)">
+            <summary>
+            Disassembles a specific symbol/function.
+            </summary>
+            <param name="binary">The loaded binary information.</param>
+            <param name="symbol">The symbol to disassemble.</param>
+            <returns>Enumerable of disassembled instructions.</returns>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.IDisassemblyPluginRegistry">
+            <summary>
+            Registry for disassembly plugins. Manages plugin discovery and selection.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.IDisassemblyPluginRegistry.Plugins">
+            <summary>
+            Gets all registered plugins.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.IDisassemblyPluginRegistry.FindPlugin(StellaOps.BinaryIndex.Disassembly.CpuArchitecture,StellaOps.BinaryIndex.Disassembly.BinaryFormat)">
+            <summary>
+            Finds the best plugin for the given architecture and format.
+            </summary>
+            <param name="architecture">Target CPU architecture.</param>
+            <param name="format">Target binary format.</param>
+            <returns>The best matching plugin, or null if none found.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.IDisassemblyPluginRegistry.FindPluginsForArchitecture(StellaOps.BinaryIndex.Disassembly.CpuArchitecture)">
+            <summary>
+            Finds all plugins that support the given architecture.
+            </summary>
+            <param name="architecture">Target CPU architecture.</param>
+            <returns>All matching plugins ordered by priority.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.IDisassemblyPluginRegistry.FindPluginsForFormat(StellaOps.BinaryIndex.Disassembly.BinaryFormat)">
+            <summary>
+            Finds all plugins that support the given format.
+            </summary>
+            <param name="format">Target binary format.</param>
+            <returns>All matching plugins ordered by priority.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.IDisassemblyPluginRegistry.GetPlugin(System.String)">
+            <summary>
+            Gets a plugin by its unique identifier.
+            </summary>
+            <param name="pluginId">The plugin identifier.</param>
+            <returns>The plugin if found, null otherwise.</returns>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.IDisassemblyService">
+            <summary>
+            Facade service for disassembly operations. Automatically selects the best plugin.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.IDisassemblyService.LoadBinary(System.IO.Stream,System.String)">
+            <summary>
+            Loads a binary and automatically selects the best plugin.
+            </summary>
+            <param name="stream">The binary stream to load.</param>
+            <param name="preferredPluginId">Optional preferred plugin ID.</param>
+            <returns>Binary information and the plugin used.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.IDisassemblyService.LoadBinary(System.ReadOnlySpan{System.Byte},System.String)">
+            <summary>
+            Loads a binary from bytes and automatically selects the best plugin.
+            </summary>
+            <param name="bytes">The binary data.</param>
+            <param name="preferredPluginId">Optional preferred plugin ID.</param>
+            <returns>Binary information and the plugin used.</returns>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.IDisassemblyService.Registry">
+            <summary>
+            Gets the plugin registry.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.BinaryFormat">
+            <summary>
+            Binary executable format.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.BinaryFormat.Unknown">
+            <summary>Unknown format.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.BinaryFormat.Raw">
+            <summary>Raw binary data (no format metadata).</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.BinaryFormat.ELF">
+            <summary>Executable and Linkable Format (Linux, BSD, etc.).</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.BinaryFormat.PE">
+            <summary>Portable Executable (Windows).</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.BinaryFormat.MachO">
+            <summary>Mach-O (macOS, iOS).</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.BinaryFormat.WASM">
+            <summary>WebAssembly module.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.BinaryInfo">
+            <summary>
+            Information about a loaded binary.
+            </summary>
+            <param name="Format">Binary format: ELF, PE, MachO, etc.</param>
+            <param name="Architecture">CPU architecture.</param>
+            <param name="Bitness">32 or 64 bit.</param>
+            <param name="Endianness">Byte order.</param>
+            <param name="Abi">Application binary interface hint (gnu, musl, msvc, darwin).</param>
+            <param name="EntryPoint">Entry point address if available.</param>
+            <param name="BuildId">Build identifier if present (e.g., GNU build-id).</param>
+            <param name="Metadata">Additional metadata from the binary.</param>
+            <param name="Handle">Internal handle for the disassembly engine (engine-specific).</param>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.BinaryInfo.#ctor(StellaOps.BinaryIndex.Disassembly.BinaryFormat,StellaOps.BinaryIndex.Disassembly.CpuArchitecture,System.Int32,StellaOps.BinaryIndex.Disassembly.Endianness,System.String,System.Nullable{System.UInt64},System.String,System.Collections.Generic.IReadOnlyDictionary{System.String,System.Object},System.Object)">
+            <summary>
+            Information about a loaded binary.
+            </summary>
+            <param name="Format">Binary format: ELF, PE, MachO, etc.</param>
+            <param name="Architecture">CPU architecture.</param>
+            <param name="Bitness">32 or 64 bit.</param>
+            <param name="Endianness">Byte order.</param>
+            <param name="Abi">Application binary interface hint (gnu, musl, msvc, darwin).</param>
+            <param name="EntryPoint">Entry point address if available.</param>
+            <param name="BuildId">Build identifier if present (e.g., GNU build-id).</param>
+            <param name="Metadata">Additional metadata from the binary.</param>
+            <param name="Handle">Internal handle for the disassembly engine (engine-specific).</param>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.BinaryInfo.Format">
+            <summary>Binary format: ELF, PE, MachO, etc.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.BinaryInfo.Architecture">
+            <summary>CPU architecture.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.BinaryInfo.Bitness">
+            <summary>32 or 64 bit.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.BinaryInfo.Endianness">
+            <summary>Byte order.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.BinaryInfo.Abi">
+            <summary>Application binary interface hint (gnu, musl, msvc, darwin).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.BinaryInfo.EntryPoint">
+            <summary>Entry point address if available.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.BinaryInfo.BuildId">
+            <summary>Build identifier if present (e.g., GNU build-id).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.BinaryInfo.Metadata">
+            <summary>Additional metadata from the binary.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.BinaryInfo.Handle">
+            <summary>Internal handle for the disassembly engine (engine-specific).</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.CodeRegion">
+            <summary>
+            Represents a code region (section) in a binary.
+            </summary>
+            <param name="Name">Section name: .text, .rodata, etc.</param>
+            <param name="VirtualAddress">Virtual address in memory.</param>
+            <param name="FileOffset">Offset in the binary file.</param>
+            <param name="Size">Size in bytes.</param>
+            <param name="IsExecutable">Whether the region contains executable code.</param>
+            <param name="IsReadable">Whether the region is readable.</param>
+            <param name="IsWritable">Whether the region is writable.</param>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.CodeRegion.#ctor(System.String,System.UInt64,System.UInt64,System.UInt64,System.Boolean,System.Boolean,System.Boolean)">
+            <summary>
+            Represents a code region (section) in a binary.
+            </summary>
+            <param name="Name">Section name: .text, .rodata, etc.</param>
+            <param name="VirtualAddress">Virtual address in memory.</param>
+            <param name="FileOffset">Offset in the binary file.</param>
+            <param name="Size">Size in bytes.</param>
+            <param name="IsExecutable">Whether the region contains executable code.</param>
+            <param name="IsReadable">Whether the region is readable.</param>
+            <param name="IsWritable">Whether the region is writable.</param>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.CodeRegion.Name">
+            <summary>Section name: .text, .rodata, etc.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.CodeRegion.VirtualAddress">
+            <summary>Virtual address in memory.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.CodeRegion.FileOffset">
+            <summary>Offset in the binary file.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.CodeRegion.Size">
+            <summary>Size in bytes.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.CodeRegion.IsExecutable">
+            <summary>Whether the region contains executable code.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.CodeRegion.IsReadable">
+            <summary>Whether the region is readable.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.CodeRegion.IsWritable">
+            <summary>Whether the region is writable.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.CpuArchitecture">
+            <summary>
+            CPU architecture identifier.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.CpuArchitecture.Unknown">
+            <summary>Unknown architecture.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.CpuArchitecture.X86">
+            <summary>Intel/AMD 32-bit x86.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.CpuArchitecture.X86_64">
+            <summary>Intel/AMD 64-bit x86-64 (amd64).</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.CpuArchitecture.ARM32">
+            <summary>ARM 32-bit (ARMv7).</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.CpuArchitecture.ARM64">
+            <summary>ARM 64-bit (AArch64/ARMv8).</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.CpuArchitecture.MIPS32">
+            <summary>MIPS 32-bit.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.CpuArchitecture.MIPS64">
+            <summary>MIPS 64-bit.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.CpuArchitecture.RISCV64">
+            <summary>RISC-V 64-bit.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.CpuArchitecture.PPC32">
+            <summary>PowerPC 32-bit.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.CpuArchitecture.PPC64">
+            <summary>PowerPC 64-bit.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.CpuArchitecture.SPARC">
+            <summary>SPARC.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.CpuArchitecture.SH4">
+            <summary>SuperH SH4.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.CpuArchitecture.AVR">
+            <summary>AVR microcontroller.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.CpuArchitecture.EVM">
+            <summary>Ethereum Virtual Machine.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.CpuArchitecture.WASM">
+            <summary>WebAssembly.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.DisassembledInstruction">
+            <summary>
+            A disassembled instruction.
+            </summary>
+            <param name="Address">Virtual address of the instruction.</param>
+            <param name="RawBytes">Raw bytes of the instruction.</param>
+            <param name="Mnemonic">Instruction mnemonic (e.g., MOV, ADD, JMP).</param>
+            <param name="OperandsText">Text representation of operands.</param>
+            <param name="Kind">Classification of the instruction.</param>
+            <param name="Operands">Parsed operands.</param>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.DisassembledInstruction.#ctor(System.UInt64,System.Collections.Immutable.ImmutableArray{System.Byte},System.String,System.String,StellaOps.BinaryIndex.Disassembly.InstructionKind,System.Collections.Immutable.ImmutableArray{StellaOps.BinaryIndex.Disassembly.Operand})">
+            <summary>
+            A disassembled instruction.
+            </summary>
+            <param name="Address">Virtual address of the instruction.</param>
+            <param name="RawBytes">Raw bytes of the instruction.</param>
+            <param name="Mnemonic">Instruction mnemonic (e.g., MOV, ADD, JMP).</param>
+            <param name="OperandsText">Text representation of operands.</param>
+            <param name="Kind">Classification of the instruction.</param>
+            <param name="Operands">Parsed operands.</param>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassembledInstruction.Address">
+            <summary>Virtual address of the instruction.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassembledInstruction.RawBytes">
+            <summary>Raw bytes of the instruction.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassembledInstruction.Mnemonic">
+            <summary>Instruction mnemonic (e.g., MOV, ADD, JMP).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassembledInstruction.OperandsText">
+            <summary>Text representation of operands.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassembledInstruction.Kind">
+            <summary>Classification of the instruction.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassembledInstruction.Operands">
+            <summary>Parsed operands.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.DisassemblyCapabilities">
+            <summary>
+            Describes the capabilities of a disassembly plugin.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyCapabilities.PluginId">
+            <summary>
+            The unique identifier of the plugin.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyCapabilities.Name">
+            <summary>
+            Display name of the disassembly engine.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyCapabilities.Version">
+            <summary>
+            Version of the underlying disassembly library.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyCapabilities.SupportedArchitectures">
+            <summary>
+            Supported CPU architectures.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyCapabilities.SupportedFormats">
+            <summary>
+            Supported binary formats.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyCapabilities.SupportsLifting">
+            <summary>
+            Whether the plugin supports lifting to intermediate representation.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyCapabilities.SupportsCfgRecovery">
+            <summary>
+            Whether the plugin supports control flow graph recovery.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyCapabilities.Priority">
+            <summary>
+            Priority for plugin selection when multiple plugins support the same arch/format.
+            Higher values indicate higher priority.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.DisassemblyCapabilities.SupportsArchitecture(StellaOps.BinaryIndex.Disassembly.CpuArchitecture)">
+            <summary>
+            Checks if this plugin supports the given architecture.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.DisassemblyCapabilities.SupportsFormat(StellaOps.BinaryIndex.Disassembly.BinaryFormat)">
+            <summary>
+            Checks if this plugin supports the given format.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.DisassemblyCapabilities.CanHandle(StellaOps.BinaryIndex.Disassembly.CpuArchitecture,StellaOps.BinaryIndex.Disassembly.BinaryFormat)">
+            <summary>
+            Checks if this plugin can handle the given architecture and format combination.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.Endianness">
+            <summary>
+            Byte order.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.Endianness.Little">
+            <summary>Little-endian (LSB first).</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.Endianness.Big">
+            <summary>Big-endian (MSB first).</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.InstructionKind">
+            <summary>
+            Classification of instruction types.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.InstructionKind.Unknown">
+            <summary>Unknown or unclassified instruction.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.InstructionKind.Arithmetic">
+            <summary>Arithmetic operation (ADD, SUB, MUL, DIV).</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.InstructionKind.Logic">
+            <summary>Logical operation (AND, OR, XOR, NOT).</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.InstructionKind.Move">
+            <summary>Data movement (MOV, PUSH, POP).</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.InstructionKind.Load">
+            <summary>Memory load operation.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.InstructionKind.Store">
+            <summary>Memory store operation.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.InstructionKind.Branch">
+            <summary>Unconditional branch (JMP).</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.InstructionKind.ConditionalBranch">
+            <summary>Conditional branch (JE, JNE, JL, etc.).</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.InstructionKind.Call">
+            <summary>Function call.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.InstructionKind.Return">
+            <summary>Function return.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.InstructionKind.Nop">
+            <summary>No operation.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.InstructionKind.Syscall">
+            <summary>System call.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.InstructionKind.Interrupt">
+            <summary>Software interrupt.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.InstructionKind.Compare">
+            <summary>Compare operation.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.InstructionKind.Shift">
+            <summary>Shift operation.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.InstructionKind.Vector">
+            <summary>Vector/SIMD operation.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.InstructionKind.FloatingPoint">
+            <summary>Floating point operation.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.Operand">
+            <summary>
+            An instruction operand.
+            </summary>
+            <param name="Type">Operand type.</param>
+            <param name="Text">Text representation.</param>
+            <param name="Value">Immediate value if applicable.</param>
+            <param name="Register">Register name if applicable.</param>
+            <param name="MemoryBase">Base register for memory operand.</param>
+            <param name="MemoryIndex">Index register for memory operand.</param>
+            <param name="MemoryScale">Scale factor for indexed memory operand.</param>
+            <param name="MemoryDisplacement">Displacement for memory operand.</param>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.Operand.#ctor(StellaOps.BinaryIndex.Disassembly.OperandType,System.String,System.Nullable{System.Int64},System.String,System.String,System.String,System.Nullable{System.Int32},System.Nullable{System.Int64})">
+            <summary>
+            An instruction operand.
+            </summary>
+            <param name="Type">Operand type.</param>
+            <param name="Text">Text representation.</param>
+            <param name="Value">Immediate value if applicable.</param>
+            <param name="Register">Register name if applicable.</param>
+            <param name="MemoryBase">Base register for memory operand.</param>
+            <param name="MemoryIndex">Index register for memory operand.</param>
+            <param name="MemoryScale">Scale factor for indexed memory operand.</param>
+            <param name="MemoryDisplacement">Displacement for memory operand.</param>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.Operand.Type">
+            <summary>Operand type.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.Operand.Text">
+            <summary>Text representation.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.Operand.Value">
+            <summary>Immediate value if applicable.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.Operand.Register">
+            <summary>Register name if applicable.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.Operand.MemoryBase">
+            <summary>Base register for memory operand.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.Operand.MemoryIndex">
+            <summary>Index register for memory operand.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.Operand.MemoryScale">
+            <summary>Scale factor for indexed memory operand.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.Operand.MemoryDisplacement">
+            <summary>Displacement for memory operand.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.OperandType">
+            <summary>
+            Type of operand.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.OperandType.Unknown">
+            <summary>Unknown operand type.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.OperandType.Register">
+            <summary>CPU register.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.OperandType.Immediate">
+            <summary>Immediate value.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.OperandType.Memory">
+            <summary>Memory reference.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.OperandType.Address">
+            <summary>Address/label.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.SymbolInfo">
+            <summary>
+            Information about a symbol in the binary.
+            </summary>
+            <param name="Name">Symbol name.</param>
+            <param name="Address">Virtual address of the symbol.</param>
+            <param name="Size">Size in bytes (0 if unknown).</param>
+            <param name="Type">Symbol type.</param>
+            <param name="Binding">Symbol binding.</param>
+            <param name="Section">Section containing the symbol.</param>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.SymbolInfo.#ctor(System.String,System.UInt64,System.UInt64,StellaOps.BinaryIndex.Disassembly.SymbolType,StellaOps.BinaryIndex.Disassembly.SymbolBinding,System.String)">
+            <summary>
+            Information about a symbol in the binary.
+            </summary>
+            <param name="Name">Symbol name.</param>
+            <param name="Address">Virtual address of the symbol.</param>
+            <param name="Size">Size in bytes (0 if unknown).</param>
+            <param name="Type">Symbol type.</param>
+            <param name="Binding">Symbol binding.</param>
+            <param name="Section">Section containing the symbol.</param>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.SymbolInfo.Name">
+            <summary>Symbol name.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.SymbolInfo.Address">
+            <summary>Virtual address of the symbol.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.SymbolInfo.Size">
+            <summary>Size in bytes (0 if unknown).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.SymbolInfo.Type">
+            <summary>Symbol type.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.SymbolInfo.Binding">
+            <summary>Symbol binding.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.SymbolInfo.Section">
+            <summary>Section containing the symbol.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.SymbolType">
+            <summary>
+            Type of symbol.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.SymbolType.Unknown">
+            <summary>Unknown or unspecified type.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.SymbolType.Function">
+            <summary>Function/procedure.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.SymbolType.Object">
+            <summary>Data object.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.SymbolType.Section">
+            <summary>Section symbol.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.SymbolType.File">
+            <summary>Source file name.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.SymbolType.Common">
+            <summary>Common block symbol.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.SymbolType.Tls">
+            <summary>Thread-local storage.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.SymbolBinding">
+            <summary>
+            Symbol binding/visibility.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.SymbolBinding.Unknown">
+            <summary>Unknown binding.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.SymbolBinding.Local">
+            <summary>Local symbol (not visible outside the object).</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.SymbolBinding.Global">
+            <summary>Global symbol (visible to other objects).</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.SymbolBinding.Weak">
+            <summary>Weak symbol (can be overridden).</summary>
+        </member>
+    </members>
+</doc>

src/BinaryIndex/StellaOps.BinaryIndex.WebService/docs/qa/feature-checks/runs/binaryindex/vulnerable-binaries-database/run-001/tier1-build-out/StellaOps.BinaryIndex.WebService/StellaOps.BinaryIndex.Disassembly.B2R2.xml

@@ -0,0 +1,258 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>StellaOps.BinaryIndex.Disassembly.B2R2</name>
+    </assembly>
+    <members>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2BinaryHandle">
+            <summary>
+            Internal handle for B2R2 binary data.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2BinaryHandle.#ctor(B2R2.FrontEnd.BinHandle,System.Byte[])">
+            <summary>
+            Internal handle for B2R2 binary data.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2DisassemblyPlugin">
+            <summary>
+            B2R2-based disassembly plugin supporting multiple architectures.
+            B2R2 is a pure .NET binary analysis framework supporting ELF, PE, and Mach-O
+            on x86, x86-64, ARM32, ARM64, MIPS, RISC-V, and more.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2DisassemblyPlugin.PluginId">
+            <summary>
+            Plugin identifier.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2DisassemblyPlugin.#ctor(Microsoft.Extensions.Logging.ILogger{StellaOps.BinaryIndex.Disassembly.B2R2.B2R2DisassemblyPlugin})">
+            <summary>
+            Creates a new B2R2 disassembly plugin.
+            </summary>
+            <param name="logger">Logger instance.</param>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2DisassemblyPlugin.Capabilities">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2DisassemblyPlugin.Disassemble(StellaOps.BinaryIndex.Disassembly.BinaryInfo,StellaOps.BinaryIndex.Disassembly.CodeRegion)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2DisassemblyPlugin.Disassemble(StellaOps.BinaryIndex.Disassembly.BinaryInfo,System.UInt64,System.UInt64)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2DisassemblyPlugin.DisassembleSymbol(StellaOps.BinaryIndex.Disassembly.BinaryInfo,StellaOps.BinaryIndex.Disassembly.SymbolInfo)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2DisassemblyPlugin.LoadBinary(System.IO.Stream,System.Nullable{StellaOps.BinaryIndex.Disassembly.CpuArchitecture},System.Nullable{StellaOps.BinaryIndex.Disassembly.BinaryFormat})">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2DisassemblyPlugin.LoadBinary(System.ReadOnlySpan{System.Byte},System.Nullable{StellaOps.BinaryIndex.Disassembly.CpuArchitecture},System.Nullable{StellaOps.BinaryIndex.Disassembly.BinaryFormat})">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2DisassemblyPlugin.GetCodeRegions(StellaOps.BinaryIndex.Disassembly.BinaryInfo)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2DisassemblyPlugin.GetSymbols(StellaOps.BinaryIndex.Disassembly.BinaryInfo)">
+            <inheritdoc />
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2IsaPoolStats">
+            <summary>
+            Per-ISA pool statistics.
+            </summary>
+            <param name="PooledCount">Number of lifters in pool for this ISA.</param>
+            <param name="ActiveCount">Number of lifters currently in use for this ISA.</param>
+            <param name="MaxPoolSize">Maximum pool size for this ISA.</param>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2IsaPoolStats.#ctor(System.Int32,System.Int32,System.Int32)">
+            <summary>
+            Per-ISA pool statistics.
+            </summary>
+            <param name="PooledCount">Number of lifters in pool for this ISA.</param>
+            <param name="ActiveCount">Number of lifters currently in use for this ISA.</param>
+            <param name="MaxPoolSize">Maximum pool size for this ISA.</param>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2IsaPoolStats.PooledCount">
+            <summary>Number of lifters in pool for this ISA.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2IsaPoolStats.ActiveCount">
+            <summary>Number of lifters currently in use for this ISA.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2IsaPoolStats.MaxPoolSize">
+            <summary>Maximum pool size for this ISA.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPool">
+            <summary>
+            Bounded pool of B2R2 lifters with warm preload per ISA.
+            Thread-safe and designed for reuse in high-throughput scenarios.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPool.#ctor(Microsoft.Extensions.Logging.ILogger{StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPool},Microsoft.Extensions.Options.IOptions{StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPoolOptions})">
+            <summary>
+            Creates a new B2R2 lifter pool.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPool.Acquire(B2R2.ISA)">
+            <summary>
+            Acquires a lifter for the specified ISA.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPool.Return(StellaOps.BinaryIndex.Disassembly.B2R2.PooledLifter,B2R2.ISA)">
+            <summary>
+            Returns a lifter to the pool.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPool.Dispose">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPool.GetStats">
+            <summary>
+            Gets the current pool statistics.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPool.WarmPool">
+            <summary>
+            Warms the pool by preloading lifters for common ISAs.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPoolOptions">
+            <summary>
+            Configuration options for the B2R2 lifter pool.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPoolOptions.SectionName">
+            <summary>
+            Configuration section name.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPoolOptions.MaxPoolSizePerIsa">
+            <summary>
+            Maximum number of pooled lifters per ISA.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPoolOptions.EnableWarmPreload">
+            <summary>
+            Whether to warm preload lifters for common ISAs at startup.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPoolOptions.WarmPreloadIsas">
+            <summary>
+            ISAs to warm preload at startup.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPoolOptions.AcquireTimeout">
+            <summary>
+            Timeout for acquiring a lifter from the pool.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPoolStats">
+            <summary>
+            Statistics for the B2R2 lifter pool.
+            </summary>
+            <param name="TotalPooledLifters">Total lifters currently in pool.</param>
+            <param name="TotalActiveLifters">Total lifters currently in use.</param>
+            <param name="IsWarm">Whether the pool has been warmed.</param>
+            <param name="IsaStats">Per-ISA pool statistics.</param>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPoolStats.#ctor(System.Int32,System.Int32,System.Boolean,System.Collections.Immutable.ImmutableDictionary{System.String,StellaOps.BinaryIndex.Disassembly.B2R2.B2R2IsaPoolStats})">
+            <summary>
+            Statistics for the B2R2 lifter pool.
+            </summary>
+            <param name="TotalPooledLifters">Total lifters currently in pool.</param>
+            <param name="TotalActiveLifters">Total lifters currently in use.</param>
+            <param name="IsWarm">Whether the pool has been warmed.</param>
+            <param name="IsaStats">Per-ISA pool statistics.</param>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPoolStats.TotalPooledLifters">
+            <summary>Total lifters currently in pool.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPoolStats.TotalActiveLifters">
+            <summary>Total lifters currently in use.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPoolStats.IsWarm">
+            <summary>Whether the pool has been warmed.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LifterPoolStats.IsaStats">
+            <summary>Per-ISA pool statistics.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LowUirLiftingService">
+            <summary>
+            B2R2 LowUIR adapter for the IR lifting service.
+            Maps B2R2 BinIR/LowUIR statements to the StellaOps IR model
+            with deterministic ordering and invariant formatting.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LowUirLiftingService.AdapterVersion">
+            <summary>
+            Version string for cache key generation.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LowUirLiftingService.SupportsArchitecture(StellaOps.BinaryIndex.Disassembly.CpuArchitecture)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LowUirLiftingService.LiftToIrAsync(System.Collections.Generic.IReadOnlyList{StellaOps.BinaryIndex.Disassembly.DisassembledInstruction},System.String,System.UInt64,StellaOps.BinaryIndex.Disassembly.CpuArchitecture,StellaOps.BinaryIndex.Semantic.LiftOptions,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2LowUirLiftingService.TransformToSsaAsync(StellaOps.BinaryIndex.Semantic.LiftedFunction,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2ServiceCollectionExtensions">
+            <summary>
+            Extension methods for registering the B2R2 disassembly plugin.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2ServiceCollectionExtensions.AddB2R2DisassemblyPlugin(Microsoft.Extensions.DependencyInjection.IServiceCollection)">
+            <summary>
+            Adds the B2R2 disassembly plugin to the service collection.
+            Provides multi-architecture disassembly (x86, x64, ARM32, ARM64, MIPS, RISC-V, etc.).
+            </summary>
+            <param name="services">The service collection.</param>
+            <returns>The service collection for chaining.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2ServiceCollectionExtensions.AddB2R2LifterPool(Microsoft.Extensions.DependencyInjection.IServiceCollection,Microsoft.Extensions.Configuration.IConfiguration)">
+            <summary>
+            Adds the B2R2 lifter pool to the service collection.
+            Provides pooled lifters with warm preload for improved performance.
+            </summary>
+            <param name="services">The service collection.</param>
+            <param name="configuration">Configuration for binding pool options.</param>
+            <returns>The service collection for chaining.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2ServiceCollectionExtensions.AddB2R2LowUirLiftingService(Microsoft.Extensions.DependencyInjection.IServiceCollection)">
+            <summary>
+            Adds the B2R2 LowUIR lifting service to the service collection.
+            Provides IR lifting with B2R2 LowUIR semantics.
+            </summary>
+            <param name="services">The service collection.</param>
+            <returns>The service collection for chaining.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.B2R2ServiceCollectionExtensions.AddB2R2Services(Microsoft.Extensions.DependencyInjection.IServiceCollection,Microsoft.Extensions.Configuration.IConfiguration)">
+            <summary>
+            Adds all B2R2 services to the service collection.
+            </summary>
+            <param name="services">The service collection.</param>
+            <param name="configuration">Configuration for binding options.</param>
+            <returns>The service collection for chaining.</returns>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.B2R2.PooledLifter">
+            <summary>
+            Pooled B2R2 BinHandle and LiftingUnit for reuse across calls.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.B2R2.PooledLifter.BinHandle">
+            <summary>
+            The B2R2 BinHandle for this lifter.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.B2R2.PooledLifter.LiftingUnit">
+            <summary>
+            The B2R2 LiftingUnit for this lifter.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.B2R2.PooledLifter.Dispose">
+            <summary>
+            Returns the lifter to the pool.
+            </summary>
+        </member>
+    </members>
+</doc>

src/BinaryIndex/StellaOps.BinaryIndex.WebService/docs/qa/feature-checks/runs/binaryindex/vulnerable-binaries-database/run-001/tier1-build-out/StellaOps.BinaryIndex.WebService/StellaOps.BinaryIndex.Disassembly.xml

@@ -0,0 +1,271 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>StellaOps.BinaryIndex.Disassembly</name>
+    </assembly>
+    <members>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.DisassemblyOptions">
+            <summary>
+            Configuration options for the disassembly service.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.DisassemblyOptions.SectionName">
+            <summary>
+            Configuration section name.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyOptions.PreferredPluginId">
+            <summary>
+            The preferred plugin ID to use for disassembly when multiple plugins are available.
+            If not set, the plugin with the highest priority for the given architecture/format is used.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyOptions.ArchitecturePreferences">
+            <summary>
+            Plugin-specific preferences by architecture.
+            Key: architecture name (e.g., "x86_64", "arm64"), Value: preferred plugin ID.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyOptions.MaxInstructionsPerRegion">
+            <summary>
+            Maximum instruction count to disassemble per region (prevents runaway disassembly).
+            Default: 1,000,000 instructions.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.DisassemblyPluginRegistry">
+            <summary>
+            Default implementation of the disassembly plugin registry.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.DisassemblyPluginRegistry.#ctor(System.Collections.Generic.IEnumerable{StellaOps.BinaryIndex.Disassembly.IDisassemblyPlugin},Microsoft.Extensions.Logging.ILogger{StellaOps.BinaryIndex.Disassembly.DisassemblyPluginRegistry})">
+            <summary>
+            Creates a new plugin registry with the given plugins.
+            </summary>
+            <param name="plugins">The registered plugins.</param>
+            <param name="logger">Logger instance.</param>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyPluginRegistry.Plugins">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.DisassemblyPluginRegistry.FindPlugin(StellaOps.BinaryIndex.Disassembly.CpuArchitecture,StellaOps.BinaryIndex.Disassembly.BinaryFormat)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.DisassemblyPluginRegistry.FindPluginsForArchitecture(StellaOps.BinaryIndex.Disassembly.CpuArchitecture)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.DisassemblyPluginRegistry.FindPluginsForFormat(StellaOps.BinaryIndex.Disassembly.BinaryFormat)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.DisassemblyPluginRegistry.GetPlugin(System.String)">
+            <inheritdoc />
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.DisassemblyQualityResult">
+            <summary>
+            Result of a disassembly operation with quality metrics.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyQualityResult.Binary">
+            <summary>
+            The loaded binary information.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyQualityResult.Plugin">
+            <summary>
+            The plugin that produced this result.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyQualityResult.CodeRegions">
+            <summary>
+            Discovered code regions.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyQualityResult.Symbols">
+            <summary>
+            Discovered symbols/functions.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyQualityResult.TotalInstructions">
+            <summary>
+            Total instructions disassembled across all regions.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyQualityResult.DecodedInstructions">
+            <summary>
+            Successfully decoded instructions count.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyQualityResult.FailedInstructions">
+            <summary>
+            Failed/invalid instruction count.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyQualityResult.Confidence">
+            <summary>
+            Confidence score (0.0-1.0) based on quality metrics.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyQualityResult.UsedFallback">
+            <summary>
+            Whether this result came from a fallback plugin.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyQualityResult.FallbackReason">
+            <summary>
+            Reason for fallback if applicable.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyQualityResult.DecodeSuccessRate">
+            <summary>
+            Decode success rate (DecodedInstructions / TotalInstructions).
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.DisassemblyService">
+            <summary>
+            Default implementation of the disassembly service facade.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.DisassemblyService.#ctor(StellaOps.BinaryIndex.Disassembly.IDisassemblyPluginRegistry,Microsoft.Extensions.Options.IOptions{StellaOps.BinaryIndex.Disassembly.DisassemblyOptions},Microsoft.Extensions.Logging.ILogger{StellaOps.BinaryIndex.Disassembly.DisassemblyService})">
+            <summary>
+            Creates a new disassembly service.
+            </summary>
+            <param name="registry">The plugin registry.</param>
+            <param name="options">Service options.</param>
+            <param name="logger">Logger instance.</param>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.DisassemblyService.Registry">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.DisassemblyService.LoadBinary(System.IO.Stream,System.String)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.DisassemblyService.LoadBinary(System.ReadOnlySpan{System.Byte},System.String)">
+            <inheritdoc />
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.DisassemblyServiceCollectionExtensions">
+            <summary>
+            Extension methods for configuring disassembly services.
+            </summary>
+            <summary>
+            Extension methods for configuring hybrid disassembly services.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.DisassemblyServiceCollectionExtensions.AddDisassemblyServices(Microsoft.Extensions.DependencyInjection.IServiceCollection,Microsoft.Extensions.Configuration.IConfiguration)">
+            <summary>
+            Adds the disassembly service infrastructure (registry and service facade).
+            Use AddXxxDisassemblyPlugin() methods to register actual plugins.
+            </summary>
+            <param name="services">The service collection.</param>
+            <param name="configuration">Optional configuration for binding options.</param>
+            <returns>The service collection for chaining.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.DisassemblyServiceCollectionExtensions.AddDisassemblyServices(Microsoft.Extensions.DependencyInjection.IServiceCollection,System.Action{StellaOps.BinaryIndex.Disassembly.DisassemblyOptions})">
+            <summary>
+            Adds the disassembly service infrastructure with options configuration action.
+            </summary>
+            <param name="services">The service collection.</param>
+            <param name="configure">Action to configure options.</param>
+            <returns>The service collection for chaining.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.DisassemblyServiceCollectionExtensions.AddHybridDisassemblyServices(Microsoft.Extensions.DependencyInjection.IServiceCollection,Microsoft.Extensions.Configuration.IConfiguration)">
+            <summary>
+            Adds the hybrid disassembly service with fallback logic between plugins.
+            This replaces the standard disassembly service with a hybrid version that
+            automatically falls back to secondary plugins when primary quality is low.
+            </summary>
+            <param name="services">The service collection.</param>
+            <param name="configuration">Configuration for binding options.</param>
+            <returns>The service collection for chaining.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.DisassemblyServiceCollectionExtensions.AddHybridDisassemblyServices(Microsoft.Extensions.DependencyInjection.IServiceCollection,System.Action{StellaOps.BinaryIndex.Disassembly.HybridDisassemblyOptions},System.Action{StellaOps.BinaryIndex.Disassembly.DisassemblyOptions})">
+            <summary>
+            Adds the hybrid disassembly service with configuration actions.
+            </summary>
+            <param name="services">The service collection.</param>
+            <param name="configureHybrid">Action to configure hybrid options.</param>
+            <param name="configureDisassembly">Optional action to configure standard options.</param>
+            <returns>The service collection for chaining.</returns>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.HybridDisassemblyOptions">
+            <summary>
+            Configuration options for hybrid disassembly with fallback logic.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Disassembly.HybridDisassemblyOptions.SectionName">
+            <summary>
+            Configuration section name.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.HybridDisassemblyOptions.PrimaryPluginId">
+            <summary>
+            Primary plugin ID to try first. If null, auto-selects highest priority plugin.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.HybridDisassemblyOptions.FallbackPluginId">
+            <summary>
+            Fallback plugin ID to use when primary fails quality threshold.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.HybridDisassemblyOptions.MinConfidenceThreshold">
+            <summary>
+            Minimum confidence score (0.0-1.0) required to accept primary plugin results.
+            If primary result confidence is below this, fallback is attempted.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.HybridDisassemblyOptions.MinFunctionCount">
+            <summary>
+            Minimum function discovery count. If primary finds fewer functions, fallback is attempted.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.HybridDisassemblyOptions.MinDecodeSuccessRate">
+            <summary>
+            Minimum instruction decode success rate (0.0-1.0).
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.HybridDisassemblyOptions.AutoFallbackOnUnsupported">
+            <summary>
+            Whether to automatically fallback when primary plugin doesn't support the architecture.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.HybridDisassemblyOptions.EnableFallback">
+            <summary>
+            Whether to enable hybrid fallback logic at all. If false, behaves like standard service.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.HybridDisassemblyOptions.PluginTimeoutSeconds">
+            <summary>
+            Timeout in seconds for each plugin attempt.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Disassembly.HybridDisassemblyService">
+            <summary>
+            Hybrid disassembly service that implements smart routing between plugins
+            with quality-based fallback logic (e.g., B2R2 primary -> Ghidra fallback).
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.HybridDisassemblyService.#ctor(StellaOps.BinaryIndex.Disassembly.IDisassemblyPluginRegistry,Microsoft.Extensions.Options.IOptions{StellaOps.BinaryIndex.Disassembly.HybridDisassemblyOptions},Microsoft.Extensions.Logging.ILogger{StellaOps.BinaryIndex.Disassembly.HybridDisassemblyService})">
+            <summary>
+            Creates a new hybrid disassembly service.
+            </summary>
+            <param name="registry">The plugin registry.</param>
+            <param name="options">Hybrid options.</param>
+            <param name="logger">Logger instance.</param>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Disassembly.HybridDisassemblyService.Registry">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.HybridDisassemblyService.LoadBinary(System.IO.Stream,System.String)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.HybridDisassemblyService.LoadBinary(System.ReadOnlySpan{System.Byte},System.String)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Disassembly.HybridDisassemblyService.LoadBinaryWithQuality(System.ReadOnlySpan{System.Byte},System.String)">
+            <summary>
+            Loads binary with quality assessment and returns detailed quality result.
+            </summary>
+            <param name="bytes">The binary data.</param>
+            <param name="preferredPluginId">Optional preferred plugin ID.</param>
+            <returns>A quality result with metrics and fallback info.</returns>
+        </member>
+    </members>
+</doc>

src/BinaryIndex/StellaOps.BinaryIndex.WebService/docs/qa/feature-checks/runs/binaryindex/vulnerable-binaries-database/run-001/tier1-build-out/StellaOps.BinaryIndex.WebService/StellaOps.BinaryIndex.Fingerprints.xml

@@ -0,0 +1,709 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>StellaOps.BinaryIndex.Fingerprints</name>
+    </assembly>
+    <members>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Generators.BasicBlockFingerprintGenerator">
+             <summary>
+             Generates fingerprints based on basic block hashing.
+            
+             Algorithm:
+             1. Disassemble function to basic blocks using IDisassemblyService
+             2. Normalize instructions (remove absolute addresses)
+             3. Extract CFG using CfgExtractor
+             4. Hash each basic block
+             5. Combine block hashes with CFG topology
+            
+             Produces a 16-byte fingerprint.
+             </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Generators.BasicBlockFingerprintGenerator.#ctor(Microsoft.Extensions.Logging.ILogger{StellaOps.BinaryIndex.Fingerprints.Generators.BasicBlockFingerprintGenerator},StellaOps.BinaryIndex.Disassembly.DisassemblyService,StellaOps.BinaryIndex.Normalization.NormalizationService)">
+            <summary>
+            Creates a new BasicBlockFingerprintGenerator with disassembly support.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Generators.BasicBlockFingerprintGenerator.#ctor(Microsoft.Extensions.Logging.ILogger{StellaOps.BinaryIndex.Fingerprints.Generators.BasicBlockFingerprintGenerator})">
+            <summary>
+            Creates a BasicBlockFingerprintGenerator without disassembly (falls back to heuristics).
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Generators.BasicBlockFingerprintGenerator.GenerateWithDisassemblyAsync(StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintInput,System.Threading.CancellationToken)">
+            <summary>
+            Generates fingerprint using proper disassembly and CFG extraction.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Generators.BasicBlockFingerprintGenerator.GenerateWithHeuristics(StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintInput)">
+            <summary>
+            Generates fingerprint using byte-level heuristics (fallback).
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Generators.BasicBlockFingerprintGenerator.IdentifyBasicBlocksHeuristic(System.Byte[],System.String)">
+            <summary>
+            Identifies basic blocks in the binary data using byte heuristics.
+            A basic block ends at: jump, call, return, or conditional branch.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Generators.BasicBlockFingerprintGenerator.CombineBlockHashes(System.Collections.Generic.List{System.Byte[]},System.Int32)">
+            <summary>
+            Combines block hashes with edge count to produce final fingerprint.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Generators.CombinedFingerprintGenerator">
+             <summary>
+             Combines multiple fingerprinting algorithms into an ensemble fingerprint.
+             Uses weighted combination of BasicBlock, ControlFlowGraph, and StringRefs.
+            
+             This provides the most robust fingerprint by combining structural and
+             semantic features from all algorithms.
+            
+             Produces a 48-byte fingerprint (16 + 32 + optional 16 for string refs).
+             </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Generators.ControlFlowGraphFingerprintGenerator">
+             <summary>
+             Generates fingerprints based on control flow graph structure.
+            
+             Algorithm:
+             1. Build CFG from disassembly
+             2. Extract graph properties (node count, edge count, cyclomatic complexity)
+             3. Compute structural hash (adjacency matrix or graph kernel)
+            
+             Resilient to instruction reordering, captures loop and branch structure.
+             Produces a 32-byte fingerprint.
+             </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Generators.ControlFlowGraphFingerprintGenerator.CfgNode">
+            <summary>
+            Represents a node in the control flow graph.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintInput">
+            <summary>
+            Input data for fingerprint generation.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintInput.BinaryData">
+            <summary>Raw binary data of the function or code section.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintInput.Architecture">
+            <summary>Target architecture (e.g., "x86_64", "aarch64").</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintInput.FunctionName">
+            <summary>Function name if known.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintInput.BaseAddress">
+            <summary>Base address for disassembly normalization.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintInput.CveId">
+            <summary>CVE identifier this fingerprint is for.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintInput.Component">
+            <summary>Component name (e.g., "openssl").</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintInput.SourceFile">
+            <summary>Source file path if known.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintInput.SourceLine">
+            <summary>Source line number if known.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintInput.Purl">
+            <summary>Package URL if known.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintOutput">
+            <summary>
+            Output from fingerprint generation.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintOutput.Hash">
+            <summary>Fingerprint hash bytes.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintOutput.FingerprintId">
+            <summary>Unique fingerprint identifier (hex-encoded).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintOutput.Algorithm">
+            <summary>Algorithm used for generation.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintOutput.Confidence">
+            <summary>Generation confidence score (0.0-1.0).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintOutput.Metadata">
+            <summary>Additional metadata from generation.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintMetadata">
+            <summary>
+            Additional metadata extracted during fingerprint generation.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintMetadata.BasicBlockCount">
+            <summary>Number of basic blocks in the function.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintMetadata.EdgeCount">
+            <summary>Number of edges in the control flow graph.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintMetadata.CyclomaticComplexity">
+            <summary>Cyclomatic complexity.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintMetadata.StringRefCount">
+            <summary>Number of string references.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintMetadata.InstructionCount">
+            <summary>Instruction count.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintMetadata.FunctionSize">
+            <summary>Function size in bytes.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Generators.IVulnFingerprintGenerator">
+            <summary>
+            Interface for vulnerability fingerprint generators.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Generators.IVulnFingerprintGenerator.Algorithm">
+            <summary>
+            Algorithm type produced by this generator.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Generators.IVulnFingerprintGenerator.GenerateAsync(StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintInput,System.Threading.CancellationToken)">
+            <summary>
+            Generates a fingerprint from the given input.
+            </summary>
+            <param name="input">Input data for fingerprint generation.</param>
+            <param name="ct">Cancellation token.</param>
+            <returns>Generated fingerprint output.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Generators.IVulnFingerprintGenerator.CanProcess(StellaOps.BinaryIndex.Fingerprints.Generators.FingerprintInput)">
+            <summary>
+            Checks if this generator can process the given input.
+            </summary>
+            <param name="input">Input to validate.</param>
+            <returns>True if the generator can process this input.</returns>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Generators.StringRefsFingerprintGenerator">
+             <summary>
+             Generates fingerprints based on string references in code.
+            
+             Algorithm:
+             1. Extract string constants referenced by function
+             2. Hash string content (normalized)
+             3. Include reference order/pattern
+            
+             Useful for error message patterns and version strings.
+             Produces a 16-byte fingerprint.
+             </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Generators.StringRefsFingerprintGenerator.ExtractStringReferences(System.Byte[])">
+            <summary>
+            Extracts ASCII/UTF-8 string references from binary data.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.IFingerprintRepository">
+            <summary>
+            Repository for vulnerable fingerprints.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.IFingerprintRepository.CreateAsync(StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint,System.Threading.CancellationToken)">
+            <summary>
+            Creates a new fingerprint record.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.IFingerprintRepository.GetByIdAsync(System.Guid,System.Threading.CancellationToken)">
+            <summary>
+            Gets a fingerprint by ID.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.IFingerprintRepository.GetByCveAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Gets all fingerprints for a CVE.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.IFingerprintRepository.SearchByHashAsync(System.Byte[],StellaOps.BinaryIndex.Fingerprints.Models.FingerprintAlgorithm,System.String,System.Threading.CancellationToken)">
+            <summary>
+            Searches for fingerprints by hash.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.IFingerprintRepository.UpdateValidationStatsAsync(System.Guid,StellaOps.BinaryIndex.Fingerprints.Models.FingerprintValidationStats,System.Threading.CancellationToken)">
+            <summary>
+            Updates validation statistics for a fingerprint.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.IFingerprintMatchRepository">
+            <summary>
+            Repository for fingerprint matches.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.IFingerprintMatchRepository.CreateAsync(StellaOps.BinaryIndex.Fingerprints.Models.FingerprintMatch,System.Threading.CancellationToken)">
+            <summary>
+            Creates a new match record.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.IFingerprintMatchRepository.GetByScanAsync(System.Guid,System.Threading.CancellationToken)">
+            <summary>
+            Gets all matches for a scan.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.IFingerprintMatchRepository.UpdateReachabilityAsync(System.Guid,StellaOps.BinaryIndex.Fingerprints.Models.ReachabilityStatus,System.Threading.CancellationToken)">
+            <summary>
+            Updates reachability status for a match.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Matching.FingerprintMatcher">
+            <summary>
+            Implementation of fingerprint matching using multiple similarity metrics.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Matching.FingerprintMatcher.CalculateBasicBlockSimilarity(System.Byte[],System.Byte[])">
+            <summary>
+            Calculates similarity using TLSH-like algorithm for basic blocks.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Matching.FingerprintMatcher.CalculateCfgSimilarity(System.Byte[],System.Byte[])">
+            <summary>
+            Calculates similarity for CFG fingerprints using structural comparison.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Matching.FingerprintMatcher.CalculateStringRefsSimilarity(System.Byte[],System.Byte[])">
+            <summary>
+            Calculates similarity for string reference fingerprints.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Matching.FingerprintMatcher.CalculateCombinedSimilarity(System.Byte[],System.Byte[])">
+            <summary>
+            Calculates similarity for combined fingerprints.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Matching.FingerprintMatcher.CalculateHashSimilarity(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte})">
+            <summary>
+            General hash similarity using normalized Hamming distance.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Matching.FingerprintMatchResult">
+            <summary>
+            Result of a fingerprint matching operation.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Matching.FingerprintMatchResult.IsMatch">
+            <summary>Whether a match was found.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Matching.FingerprintMatchResult.Similarity">
+            <summary>Similarity score (0.0-1.0).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Matching.FingerprintMatchResult.MatchedFingerprint">
+            <summary>Matched fingerprint if found.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Matching.FingerprintMatchResult.Confidence">
+            <summary>Match confidence score.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Matching.FingerprintMatchResult.Details">
+            <summary>Additional match details.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Matching.MatchDetails">
+            <summary>
+            Details about how a match was determined.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Matching.MatchDetails.MatchingAlgorithm">
+            <summary>Which algorithm found the match.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Matching.MatchDetails.BasicBlockSimilarity">
+            <summary>Basic block similarity if applicable.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Matching.MatchDetails.CfgSimilarity">
+            <summary>CFG similarity if applicable.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Matching.MatchDetails.StringRefsSimilarity">
+            <summary>String refs similarity if applicable.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Matching.MatchDetails.CandidatesEvaluated">
+            <summary>Number of candidate fingerprints evaluated.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Matching.MatchDetails.MatchTimeMs">
+            <summary>Time taken for matching in milliseconds.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Matching.MatchOptions">
+            <summary>
+            Options for fingerprint matching.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Matching.MatchOptions.MinSimilarity">
+            <summary>Minimum similarity threshold (0.0-1.0). Default 0.95.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Matching.MatchOptions.MaxCandidates">
+            <summary>Maximum candidates to evaluate. Default 100.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Matching.MatchOptions.Algorithms">
+            <summary>Algorithms to use for matching. Empty means all.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Matching.MatchOptions.RequireValidated">
+            <summary>Whether to require validation of matched fingerprint.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Matching.MatchOptions.Architecture">
+            <summary>Architecture filter. Null means any.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Matching.IFingerprintMatcher">
+            <summary>
+            Interface for fingerprint matching operations.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Matching.IFingerprintMatcher.MatchAsync(System.Byte[],StellaOps.BinaryIndex.Fingerprints.Matching.MatchOptions,System.Threading.CancellationToken)">
+            <summary>
+            Matches a fingerprint against the vulnerability database.
+            </summary>
+            <param name="fingerprint">Fingerprint to match.</param>
+            <param name="options">Matching options.</param>
+            <param name="ct">Cancellation token.</param>
+            <returns>Match result.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Matching.IFingerprintMatcher.MatchBatchAsync(System.Collections.Generic.IEnumerable{System.Byte[]},StellaOps.BinaryIndex.Fingerprints.Matching.MatchOptions,System.Threading.CancellationToken)">
+            <summary>
+            Matches multiple fingerprints in batch.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Matching.IFingerprintMatcher.CalculateSimilarity(System.Byte[],System.Byte[],StellaOps.BinaryIndex.Fingerprints.Models.FingerprintAlgorithm)">
+            <summary>
+            Calculates similarity between two fingerprints.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint">
+            <summary>
+            Represents a fingerprint of a vulnerable function.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.Id">
+            <summary>Unique fingerprint identifier</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.CveId">
+            <summary>CVE identifier</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.Component">
+            <summary>Component name (e.g., "openssl")</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.Purl">
+            <summary>Package URL (PURL) if applicable</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.Algorithm">
+            <summary>Fingerprinting algorithm used</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.FingerprintId">
+            <summary>Fingerprint identifier (hex string)</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.FingerprintHash">
+            <summary>Fingerprint hash bytes</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.Architecture">
+            <summary>Target architecture (e.g., "x86_64")</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.FunctionName">
+            <summary>Function name if known</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.SourceFile">
+            <summary>Source file if known</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.SourceLine">
+            <summary>Source line if known</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.SimilarityThreshold">
+            <summary>Similarity threshold for matching (0.0-1.0)</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.Confidence">
+            <summary>Confidence score (0.0-1.0)</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.Validated">
+            <summary>Whether this fingerprint has been validated</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.ValidationStats">
+            <summary>Validation statistics</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.VulnBuildRef">
+            <summary>Reference to vulnerable build artifact</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.FixedBuildRef">
+            <summary>Reference to fixed build artifact</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint.IndexedAt">
+            <summary>Timestamp when this fingerprint was indexed</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintAlgorithm">
+            <summary>
+            Fingerprinting algorithm types.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintAlgorithm.BasicBlock">
+            <summary>Basic block level fingerprinting</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintAlgorithm.ControlFlowGraph">
+            <summary>Control flow graph based</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintAlgorithm.StringRefs">
+            <summary>String reference based</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintAlgorithm.Combined">
+            <summary>Combined algorithm</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintValidationStats">
+            <summary>
+            Validation statistics for a fingerprint.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintValidationStats.TruePositives">
+            <summary>Number of true positive matches</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintValidationStats.FalsePositives">
+            <summary>Number of false positive matches</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintValidationStats.TrueNegatives">
+            <summary>Number of true negative non-matches</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintValidationStats.FalseNegatives">
+            <summary>Number of false negative non-matches</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintValidationStats.Precision">
+            <summary>Precision: TP / (TP + FP)</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintValidationStats.Recall">
+            <summary>Recall: TP / (TP + FN)</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintMatch">
+            <summary>
+            Represents a fingerprint match result.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintMatch.Id">
+            <summary>Match identifier</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintMatch.ScanId">
+            <summary>Scan identifier</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintMatch.Type">
+            <summary>Match type</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintMatch.BinaryKey">
+            <summary>Binary key that was matched</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintMatch.VulnerablePurl">
+            <summary>Vulnerable package PURL</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintMatch.VulnerableVersion">
+            <summary>Vulnerable version</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintMatch.MatchedFingerprintId">
+            <summary>Matched fingerprint ID</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintMatch.MatchedFunction">
+            <summary>Matched function name</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintMatch.Similarity">
+            <summary>Similarity score (0.0-1.0)</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintMatch.AdvisoryIds">
+            <summary>Associated advisory IDs (CVEs, etc.)</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintMatch.ReachabilityStatus">
+            <summary>Reachability status</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Models.FingerprintMatch.MatchedAt">
+            <summary>Timestamp when match occurred</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Models.MatchType">
+            <summary>
+            Match type enumeration.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Fingerprints.Models.MatchType.Fingerprint">
+            <summary>Match via fingerprint comparison</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Fingerprints.Models.MatchType.BuildId">
+            <summary>Match via Build-ID</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Fingerprints.Models.MatchType.HashExact">
+            <summary>Exact hash match</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Models.ReachabilityStatus">
+            <summary>
+            Reachability status for matched vulnerabilities.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Fingerprints.Models.ReachabilityStatus.Reachable">
+            <summary>Vulnerable function is reachable</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Fingerprints.Models.ReachabilityStatus.Unreachable">
+            <summary>Vulnerable function is unreachable</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Fingerprints.Models.ReachabilityStatus.Unknown">
+            <summary>Reachability unknown</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.Fingerprints.Models.ReachabilityStatus.Partial">
+            <summary>Partial reachability</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildRequest">
+            <summary>
+            Request for building reference binaries.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildRequest.CveId">
+            <summary>CVE identifier.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildRequest.Component">
+            <summary>Component name (e.g., "openssl").</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildRequest.RepoUrl">
+            <summary>Git repository URL.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildRequest.VulnerableRef">
+            <summary>Vulnerable commit or tag.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildRequest.FixedRef">
+            <summary>Fixed commit or tag.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildRequest.Architectures">
+            <summary>Target architectures.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildRequest.BuildCommand">
+            <summary>Build command template.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildRequest.TargetFunctions">
+            <summary>Function names to fingerprint (optional).</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildResult">
+            <summary>
+            Result of a reference build pipeline run.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildResult.Success">
+            <summary>Whether the pipeline succeeded.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildResult.Error">
+            <summary>Error message if failed.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildResult.Fingerprints">
+            <summary>Generated fingerprints.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildResult.VulnBuildPath">
+            <summary>Storage path for vulnerable build.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildResult.FixedBuildPath">
+            <summary>Storage path for fixed build.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildResult.BuildLog">
+            <summary>Build log.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Pipeline.BuildArtifact">
+            <summary>
+            Represents a built binary artifact.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.BuildArtifact.Path">
+            <summary>Path within build output.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.BuildArtifact.Content">
+            <summary>Binary content.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.BuildArtifact.Architecture">
+            <summary>Target architecture.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.BuildArtifact.IsVulnerable">
+            <summary>Whether this is the vulnerable or fixed version.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Pipeline.ExtractedFunction">
+            <summary>
+            Represents a function extracted from a binary for fingerprinting.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ExtractedFunction.Name">
+            <summary>Function name.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ExtractedFunction.Data">
+            <summary>Function binary data.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ExtractedFunction.Offset">
+            <summary>Start offset in original binary.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ExtractedFunction.Size">
+            <summary>Size in bytes.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ExtractedFunction.SourceFile">
+            <summary>Source file if known.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Fingerprints.Pipeline.ExtractedFunction.SourceLine">
+            <summary>Source line if known.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildPipeline">
+            <summary>
+            Pipeline for generating reference builds and extracting vulnerability fingerprints.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildPipeline.ExecuteAsync(StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildRequest,System.Threading.CancellationToken)">
+            <summary>
+            Executes the full reference build pipeline.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildPipeline.GenerateDifferentialFingerprintsAsync(StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildRequest,System.Collections.Generic.IReadOnlyList{StellaOps.BinaryIndex.Fingerprints.Pipeline.ExtractedFunction},System.Collections.Generic.IReadOnlyList{StellaOps.BinaryIndex.Fingerprints.Pipeline.ExtractedFunction},System.Threading.CancellationToken)">
+            <summary>
+            Generates differential fingerprints by comparing vulnerable and fixed versions.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildPipeline.FindChangedFunctions(System.Collections.Generic.IReadOnlyList{StellaOps.BinaryIndex.Fingerprints.Pipeline.ExtractedFunction},System.Collections.Generic.IReadOnlyList{StellaOps.BinaryIndex.Fingerprints.Pipeline.ExtractedFunction})">
+            <summary>
+            Finds functions that changed between vulnerable and fixed versions.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Pipeline.ReferenceBuildPipeline.StoreReferenceBuildAsync(System.String,System.Collections.Generic.IReadOnlyList{StellaOps.BinaryIndex.Fingerprints.Pipeline.BuildArtifact},System.String,System.Threading.CancellationToken)">
+            <summary>
+            Stores reference build artifacts to blob storage.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Storage.FingerprintBlobStorage">
+            <summary>
+            Blob storage implementation for fingerprints.
+            NOTE: This is a placeholder implementation showing deterministic storage paths.
+            Production implementation would use RustFS or S3-compatible storage with atomic writes.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Storage.FingerprintBlobStorage.StoreFingerprintAsync(StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint,System.Byte[],System.Threading.CancellationToken)">
+            <summary>
+            Stores fingerprint data to blob storage.
+            Layout: {BasePath}/{algorithm}/{prefix}/{fingerprint_id}.bin
+            where prefix is first 2 chars of fingerprint_id for sharding.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Storage.FingerprintBlobStorage.StoreReferenceBuildAsync(System.String,System.String,System.Byte[],System.Threading.CancellationToken)">
+            <summary>
+            Stores reference build artifacts.
+            Layout: {BasePath}/refbuilds/{cve_id}/{build_type}.tar.zst
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Fingerprints.Storage.IFingerprintBlobStorage">
+            <summary>
+            Interface for fingerprint blob storage.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Storage.IFingerprintBlobStorage.StoreFingerprintAsync(StellaOps.BinaryIndex.Fingerprints.Models.VulnFingerprint,System.Byte[],System.Threading.CancellationToken)">
+            <summary>
+            Stores fingerprint data to blob storage.
+            </summary>
+            <param name="fingerprint">Fingerprint metadata</param>
+            <param name="fullData">Full fingerprint data blob</param>
+            <param name="ct">Cancellation token</param>
+            <returns>Storage path</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Storage.IFingerprintBlobStorage.RetrieveFingerprintAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Retrieves fingerprint data from blob storage.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Storage.IFingerprintBlobStorage.StoreReferenceBuildAsync(System.String,System.String,System.Byte[],System.Threading.CancellationToken)">
+            <summary>
+            Stores a reference build artifact (vulnerable or fixed version).
+            </summary>
+            <param name="cveId">CVE identifier</param>
+            <param name="buildType">"vulnerable" or "fixed"</param>
+            <param name="buildArtifact">Build artifact data (tar.zst compressed)</param>
+            <param name="ct">Cancellation token</param>
+            <returns>Storage path</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Fingerprints.Storage.IFingerprintBlobStorage.RetrieveReferenceBuildAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Retrieves a reference build artifact.
+            </summary>
+        </member>
+    </members>
+</doc>

src/BinaryIndex/StellaOps.BinaryIndex.WebService/docs/qa/feature-checks/runs/binaryindex/vulnerable-binaries-database/run-001/tier1-build-out/StellaOps.BinaryIndex.WebService/StellaOps.BinaryIndex.FixIndex.xml

@@ -0,0 +1,904 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>StellaOps.BinaryIndex.FixIndex</name>
+    </assembly>
+    <members>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Models.FixEvidence">
+            <summary>
+            Evidence of a CVE fix in a distro package.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.FixEvidence.Distro">
+            <summary>Distro identifier (e.g., "debian", "ubuntu", "alpine")</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.FixEvidence.Release">
+            <summary>Release/codename (e.g., "bookworm", "jammy", "v3.19")</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.FixEvidence.SourcePkg">
+            <summary>Source package name</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.FixEvidence.CveId">
+            <summary>CVE identifier (e.g., "CVE-2024-1234")</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.FixEvidence.State">
+            <summary>Fix state</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.FixEvidence.FixedVersion">
+            <summary>Version where the fix was applied (if applicable)</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.FixEvidence.Method">
+            <summary>Method used to detect the fix</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.FixEvidence.Confidence">
+            <summary>Confidence score (0.0 - 1.0)</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.FixEvidence.Evidence">
+            <summary>Evidence payload for audit trail</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.FixEvidence.SnapshotId">
+            <summary>Corpus snapshot ID (if from snapshot ingestion)</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.FixEvidence.CreatedAt">
+            <summary>Timestamp when this evidence was created</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Models.FixEvidencePayload">
+            <summary>
+            Base class for evidence payloads.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Models.ChangelogEvidence">
+            <summary>
+            Evidence from changelog parsing.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.ChangelogEvidence.File">
+            <summary>Path to changelog file</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.ChangelogEvidence.Version">
+            <summary>Version from changelog entry</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.ChangelogEvidence.Excerpt">
+            <summary>Excerpt from changelog mentioning CVE</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.ChangelogEvidence.LineNumber">
+            <summary>Line number where CVE was mentioned</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Models.PatchHeaderEvidence">
+            <summary>
+            Evidence from patch header parsing.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.PatchHeaderEvidence.PatchPath">
+            <summary>Path to patch file</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.PatchHeaderEvidence.PatchSha256">
+            <summary>SHA-256 digest of patch file</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.PatchHeaderEvidence.HeaderExcerpt">
+            <summary>Excerpt from patch header</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Models.SecurityFeedEvidence">
+            <summary>
+            Evidence from official security feed.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.SecurityFeedEvidence.FeedId">
+            <summary>Feed identifier (e.g., "alpine-secfixes", "debian-oval")</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.SecurityFeedEvidence.EntryId">
+            <summary>Entry identifier within the feed</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Models.SecurityFeedEvidence.PublishedAt">
+            <summary>Published timestamp from feed</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Parsers.AlpineSecfixesParser">
+            <summary>
+            Parses Alpine APKBUILD secfixes section for CVE fix evidence.
+            </summary>
+            <remarks>
+            APKBUILD secfixes format:
+            # secfixes:
+            #   1.2.3-r0:
+            #     - CVE-2024-1234
+            #     - CVE-2024-1235
+            </remarks>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.AlpineSecfixesParser.SecfixesPatternRegex">
+            <remarks>
+            Pattern:<br/>
+            <code>^#\\s*secfixes:\\s*$</code><br/>
+            Options:<br/>
+            <code>RegexOptions.Multiline | RegexOptions.Compiled</code><br/>
+            Explanation:<br/>
+            <code>
+            ○ Match if at the beginning of a line.<br/>
+            ○ Match '#'.<br/>
+            ○ Match a whitespace character atomically any number of times.<br/>
+            ○ Match the string "secfixes:".<br/>
+            ○ Match a whitespace character greedily any number of times.<br/>
+            ○ Match if at the end of a line.<br/>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.AlpineSecfixesParser.VersionPatternRegex">
+            <remarks>
+            Pattern:<br/>
+            <code>^#\\s+([vV]?\\d[^\\s:]*):\\s*$</code><br/>
+            Options:<br/>
+            <code>RegexOptions.Compiled</code><br/>
+            Explanation:<br/>
+            <code>
+            ○ Match if at the beginning of the string.<br/>
+            ○ Match '#'.<br/>
+            ○ Match a whitespace character atomically at least once.<br/>
+            ○ 1st capture group.<br/>
+                ○ Match a character in the set [Vv] atomically, optionally.<br/>
+                ○ Match a Unicode digit.<br/>
+                ○ Match a character in the set [^:\s] atomically any number of times.<br/>
+            ○ Match ':'.<br/>
+            ○ Match a whitespace character greedily any number of times.<br/>
+            ○ Match if at the end of the string or if before an ending newline.<br/>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.AlpineSecfixesParser.CvePatternRegex">
+            <remarks>
+            Pattern:<br/>
+            <code>^#\\s+-\\s+(CVE-\\d{4}-\\d{4,7})(?:\\s|$)</code><br/>
+            Options:<br/>
+            <code>RegexOptions.Compiled</code><br/>
+            Explanation:<br/>
+            <code>
+            ○ Match if at the beginning of the string.<br/>
+            ○ Match '#'.<br/>
+            ○ Match a whitespace character atomically at least once.<br/>
+            ○ Match '-'.<br/>
+            ○ Match a whitespace character atomically at least once.<br/>
+            ○ 1st capture group.<br/>
+                ○ Match the string "CVE-".<br/>
+                ○ Match a Unicode digit exactly 4 times.<br/>
+                ○ Match '-'.<br/>
+                ○ Match a Unicode digit atomically at least 4 and at most 7 times.<br/>
+            ○ Match with 2 alternative expressions, atomically.<br/>
+                ○ Match a whitespace character.<br/>
+                ○ Match if at the end of the string or if before an ending newline.<br/>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.AlpineSecfixesParser.Parse(System.String,System.String,System.String,System.String)">
+            <summary>
+            Parses APKBUILD secfixes section for version-to-CVE mappings.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Parsers.DebianChangelogParser">
+            <summary>
+            Parses Debian/Ubuntu changelog files for CVE mentions.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.DebianChangelogParser.CvePatternRegex">
+            <remarks>
+            Pattern:<br/>
+            <code>\\bCVE-\\d{4}-\\d{4,7}\\b</code><br/>
+            Options:<br/>
+            <code>RegexOptions.Compiled</code><br/>
+            Explanation:<br/>
+            <code>
+            ○ Match if at a word boundary.<br/>
+            ○ Match the string "CVE-".<br/>
+            ○ Match a Unicode digit exactly 4 times.<br/>
+            ○ Match '-'.<br/>
+            ○ Match a Unicode digit atomically at least 4 and at most 7 times.<br/>
+            ○ Match if at a word boundary.<br/>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.DebianChangelogParser.EntryHeaderPatternRegex">
+            <remarks>
+            Pattern:<br/>
+            <code>^(\\S+)\\s+\\(([^)]+)\\)\\s+</code><br/>
+            Options:<br/>
+            <code>RegexOptions.Compiled</code><br/>
+            Explanation:<br/>
+            <code>
+            ○ Match if at the beginning of the string.<br/>
+            ○ 1st capture group.<br/>
+                ○ Match any character other than a whitespace character atomically at least once.<br/>
+            ○ Match a whitespace character atomically at least once.<br/>
+            ○ Match '('.<br/>
+            ○ 2nd capture group.<br/>
+                ○ Match a character other than ')' atomically at least once.<br/>
+            ○ Match ')'.<br/>
+            ○ Match a whitespace character atomically at least once.<br/>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.DebianChangelogParser.TrailerPatternRegex">
+            <remarks>
+            Pattern:<br/>
+            <code>^\\s+--\\s+</code><br/>
+            Options:<br/>
+            <code>RegexOptions.Compiled</code><br/>
+            Explanation:<br/>
+            <code>
+            ○ Match if at the beginning of the string.<br/>
+            ○ Match a whitespace character atomically at least once.<br/>
+            ○ Match the string "--".<br/>
+            ○ Match a whitespace character atomically at least once.<br/>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.DebianChangelogParser.ParseTopEntry(System.String,System.String,System.String,System.String)">
+            <summary>
+            Parses the top entry of a Debian changelog for CVE mentions.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Parsers.IChangelogParser">
+            <summary>
+            Interface for parsing changelogs for CVE fix evidence.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.IChangelogParser.ParseTopEntry(System.String,System.String,System.String,System.String)">
+            <summary>
+            Parses the top entry of a changelog for CVE mentions.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Parsers.IPatchParser">
+            <summary>
+            Interface for parsing patch files for CVE fix evidence.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.IPatchParser.ParsePatches(System.Collections.Generic.IEnumerable{System.ValueTuple{System.String,System.String,System.String}},System.String,System.String,System.String,System.String)">
+            <summary>
+            Parses patches for CVE mentions in headers.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Parsers.ISecfixesParser">
+            <summary>
+            Interface for parsing Alpine APKBUILD secfixes for CVE mappings.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.ISecfixesParser.Parse(System.String,System.String,System.String,System.String)">
+            <summary>
+            Parses APKBUILD secfixes section for version-to-CVE mappings.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Parsers.PatchHeaderParser">
+            <summary>
+            Parses patch headers (DEP-3 format) for CVE mentions.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.PatchHeaderParser.CvePatternRegex">
+            <remarks>
+            Pattern:<br/>
+            <code>\\bCVE-\\d{4}-\\d{4,7}\\b</code><br/>
+            Options:<br/>
+            <code>RegexOptions.Compiled</code><br/>
+            Explanation:<br/>
+            <code>
+            ○ Match if at a word boundary.<br/>
+            ○ Match the string "CVE-".<br/>
+            ○ Match a Unicode digit exactly 4 times.<br/>
+            ○ Match '-'.<br/>
+            ○ Match a Unicode digit atomically at least 4 and at most 7 times.<br/>
+            ○ Match if at a word boundary.<br/>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.PatchHeaderParser.ParsePatches(System.Collections.Generic.IEnumerable{System.ValueTuple{System.String,System.String,System.String}},System.String,System.String,System.String,System.String)">
+            <summary>
+            Parses patches for CVE mentions in headers.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Parsers.RpmChangelogParser">
+            <summary>
+            Parses RPM spec file changelog sections for CVE mentions.
+            </summary>
+            <remarks>
+            RPM changelog format:
+            %changelog
+            * Mon Jan 01 2024 Packager &lt;email&gt; - 1.2.3-4
+            - Fix CVE-2024-1234
+            </remarks>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.RpmChangelogParser.CvePatternRegex">
+            <remarks>
+            Pattern:<br/>
+            <code>\\bCVE-\\d{4}-\\d{4,7}\\b</code><br/>
+            Options:<br/>
+            <code>RegexOptions.Compiled</code><br/>
+            Explanation:<br/>
+            <code>
+            ○ Match if at a word boundary.<br/>
+            ○ Match the string "CVE-".<br/>
+            ○ Match a Unicode digit exactly 4 times.<br/>
+            ○ Match '-'.<br/>
+            ○ Match a Unicode digit atomically at least 4 and at most 7 times.<br/>
+            ○ Match if at a word boundary.<br/>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.RpmChangelogParser.EntryHeaderPatternRegex">
+            <remarks>
+            Pattern:<br/>
+            <code>^\\*\\s+\\w{3}\\s+\\w{3}\\s+\\d{1,2}\\s+\\d{4}\\s+(.+?)\\s+-\\s+(\\S+)</code><br/>
+            Options:<br/>
+            <code>RegexOptions.Compiled</code><br/>
+            Explanation:<br/>
+            <code>
+            ○ Match if at the beginning of the string.<br/>
+            ○ Match '*'.<br/>
+            ○ Match a whitespace character atomically at least once.<br/>
+            ○ Match a word character exactly 3 times.<br/>
+            ○ Match a whitespace character atomically at least once.<br/>
+            ○ Match a word character exactly 3 times.<br/>
+            ○ Match a whitespace character atomically at least once.<br/>
+            ○ Match a Unicode digit atomically at least 1 and at most 2 times.<br/>
+            ○ Match a whitespace character atomically at least once.<br/>
+            ○ Match a Unicode digit exactly 4 times.<br/>
+            ○ Match a whitespace character greedily at least once.<br/>
+            ○ 1st capture group.<br/>
+                ○ Match a character other than '\n' lazily at least once.<br/>
+            ○ Match a whitespace character atomically at least once.<br/>
+            ○ Match '-'.<br/>
+            ○ Match a whitespace character atomically at least once.<br/>
+            ○ 2nd capture group.<br/>
+                ○ Match any character other than a whitespace character atomically at least once.<br/>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.RpmChangelogParser.ChangelogStartPatternRegex">
+            <remarks>
+            Pattern:<br/>
+            <code>^%changelog\\s*$</code><br/>
+            Options:<br/>
+            <code>RegexOptions.IgnoreCase | RegexOptions.Compiled</code><br/>
+            Explanation:<br/>
+            <code>
+            ○ Match if at the beginning of the string.<br/>
+            ○ Match '%'.<br/>
+            ○ Match a character in the set [Cc].<br/>
+            ○ Match a character in the set [Hh].<br/>
+            ○ Match a character in the set [Aa].<br/>
+            ○ Match a character in the set [Nn].<br/>
+            ○ Match a character in the set [Gg].<br/>
+            ○ Match a character in the set [Ee].<br/>
+            ○ Match a character in the set [Ll].<br/>
+            ○ Match a character in the set [Oo].<br/>
+            ○ Match a character in the set [Gg].<br/>
+            ○ Match a whitespace character greedily any number of times.<br/>
+            ○ Match if at the end of the string or if before an ending newline.<br/>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.RpmChangelogParser.SectionStartPatternRegex">
+            <remarks>
+            Pattern:<br/>
+            <code>^%\\w+</code><br/>
+            Options:<br/>
+            <code>RegexOptions.Compiled</code><br/>
+            Explanation:<br/>
+            <code>
+            ○ Match if at the beginning of the string.<br/>
+            ○ Match '%'.<br/>
+            ○ Match a word character atomically at least once.<br/>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.RpmChangelogParser.ParseTopEntry(System.String,System.String,System.String,System.String)">
+            <summary>
+            Parses the top entry of an RPM spec changelog for CVE mentions.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Parsers.RpmChangelogParser.ParseAllEntries(System.String,System.String,System.String,System.String)">
+            <summary>
+            Parses the full RPM spec changelog for all CVE mentions with their versions.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Repositories.IFixIndexRepository">
+            <summary>
+            Repository interface for CVE fix index operations.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Repositories.IFixIndexRepository.GetFixStatusAsync(System.String,System.String,System.String,System.String,System.Threading.CancellationToken)">
+            <summary>
+            Gets the fix status for a specific CVE/package/distro combination.
+            </summary>
+            <param name="distro">Distribution (debian, ubuntu, alpine, rhel)</param>
+            <param name="release">Release codename (bookworm, jammy, v3.19)</param>
+            <param name="sourcePkg">Source package name</param>
+            <param name="cveId">CVE identifier</param>
+            <param name="cancellationToken">Cancellation token</param>
+            <returns>Fix status if found, null otherwise</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Repositories.IFixIndexRepository.GetFixStatusesForPackageAsync(System.String,System.String,System.String,System.Threading.CancellationToken)">
+            <summary>
+            Gets all fix statuses for a package.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Repositories.IFixIndexRepository.GetFixLocationsForCveAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Gets all known fix locations for a CVE across distros.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Repositories.IFixIndexRepository.UpsertAsync(StellaOps.BinaryIndex.FixIndex.Models.FixEvidence,System.Threading.CancellationToken)">
+            <summary>
+            Upserts a fix index entry.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Repositories.IFixIndexRepository.UpsertBatchAsync(System.Collections.Generic.IEnumerable{StellaOps.BinaryIndex.FixIndex.Models.FixEvidence},System.Threading.CancellationToken)">
+            <summary>
+            Batch upserts fix index entries.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Repositories.IFixIndexRepository.StoreEvidenceAsync(StellaOps.BinaryIndex.FixIndex.Models.FixEvidence,System.Threading.CancellationToken)">
+            <summary>
+            Stores fix evidence for audit trail.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Repositories.IFixIndexRepository.GetEvidenceAsync(System.Guid,System.Threading.CancellationToken)">
+            <summary>
+            Gets evidence by ID.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Repositories.IFixIndexRepository.DeleteBySnapshotAsync(System.Guid,System.Threading.CancellationToken)">
+            <summary>
+            Deletes all entries from a specific snapshot (for re-ingestion).
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Repositories.FixIndexEntry">
+            <summary>
+            Fix index entry from the database.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Repositories.FixEvidenceRecord">
+            <summary>
+            Fix evidence record from the database.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Services.FixIndexBuilder">
+            <summary>
+            Default implementation of <see cref="T:StellaOps.BinaryIndex.FixIndex.Services.IFixIndexBuilder"/>.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Services.FixIndexBuilder.BuildDebianIndexAsync(StellaOps.BinaryIndex.FixIndex.Services.DebianFixIndexRequest,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Services.FixIndexBuilder.BuildAlpineIndexAsync(StellaOps.BinaryIndex.FixIndex.Services.AlpineFixIndexRequest,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Services.FixIndexBuilder.BuildRpmIndexAsync(StellaOps.BinaryIndex.FixIndex.Services.RpmFixIndexRequest,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Services.IFixIndexBuilder">
+            <summary>
+            Interface for building the CVE fix index from various sources.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Services.IFixIndexBuilder.BuildDebianIndexAsync(StellaOps.BinaryIndex.FixIndex.Services.DebianFixIndexRequest,System.Threading.CancellationToken)">
+            <summary>
+            Builds fix index entries for a Debian/Ubuntu package.
+            </summary>
+            <param name="request">The Debian build request.</param>
+            <param name="cancellationToken">Cancellation token.</param>
+            <returns>Fix evidence entries.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Services.IFixIndexBuilder.BuildAlpineIndexAsync(StellaOps.BinaryIndex.FixIndex.Services.AlpineFixIndexRequest,System.Threading.CancellationToken)">
+            <summary>
+            Builds fix index entries for an Alpine package.
+            </summary>
+            <param name="request">The Alpine build request.</param>
+            <param name="cancellationToken">Cancellation token.</param>
+            <returns>Fix evidence entries.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.FixIndex.Services.IFixIndexBuilder.BuildRpmIndexAsync(StellaOps.BinaryIndex.FixIndex.Services.RpmFixIndexRequest,System.Threading.CancellationToken)">
+            <summary>
+            Builds fix index entries for an RPM package.
+            </summary>
+            <param name="request">The RPM build request.</param>
+            <param name="cancellationToken">Cancellation token.</param>
+            <returns>Fix evidence entries.</returns>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Services.DebianFixIndexRequest">
+            <summary>
+            Request for building Debian fix index.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.DebianFixIndexRequest.Distro">
+            <summary>Distribution (debian or ubuntu).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.DebianFixIndexRequest.Release">
+            <summary>Release codename (bookworm, jammy).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.DebianFixIndexRequest.SourcePkg">
+            <summary>Source package name.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.DebianFixIndexRequest.Changelog">
+            <summary>Changelog content.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.DebianFixIndexRequest.Patches">
+            <summary>Patches with path, content, and SHA-256.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.DebianFixIndexRequest.Version">
+            <summary>Package version for patch association.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.DebianFixIndexRequest.SnapshotId">
+            <summary>Corpus snapshot ID.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Services.AlpineFixIndexRequest">
+            <summary>
+            Request for building Alpine fix index.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.AlpineFixIndexRequest.Distro">
+            <summary>Distribution (always "alpine").</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.AlpineFixIndexRequest.Release">
+            <summary>Release (v3.19, edge).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.AlpineFixIndexRequest.SourcePkg">
+            <summary>Source package name.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.AlpineFixIndexRequest.ApkBuild">
+            <summary>APKBUILD file content.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.AlpineFixIndexRequest.SnapshotId">
+            <summary>Corpus snapshot ID.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Services.RpmFixIndexRequest">
+            <summary>
+            Request for building RPM fix index.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.RpmFixIndexRequest.Distro">
+            <summary>Distribution (rhel, fedora, centos, rocky, alma).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.RpmFixIndexRequest.Release">
+            <summary>Release version (9, 39, etc.).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.RpmFixIndexRequest.SourcePkg">
+            <summary>Source package name.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.RpmFixIndexRequest.SpecContent">
+            <summary>Spec file content.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.RpmFixIndexRequest.SnapshotId">
+            <summary>Corpus snapshot ID.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.FixIndex.Services.PatchFile">
+            <summary>
+            Represents a patch file with content.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.PatchFile.Path">
+            <summary>Relative path to the patch file.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.PatchFile.Content">
+            <summary>Content of the patch file.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.FixIndex.Services.PatchFile.Sha256">
+            <summary>SHA-256 hash of the patch content.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.SecfixesPatternRegex_0">
+            <summary>Custom <see cref="T:System.Text.RegularExpressions.Regex"/>-derived type for the SecfixesPatternRegex method.</summary>
+        </member>
+        <member name="F:System.Text.RegularExpressions.Generated.SecfixesPatternRegex_0.Instance">
+            <summary>Cached, thread-safe singleton instance.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.SecfixesPatternRegex_0.#ctor">
+            <summary>Initializes the instance.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.SecfixesPatternRegex_0.RunnerFactory">
+            <summary>Provides a factory for creating <see cref="T:System.Text.RegularExpressions.RegexRunner"/> instances to be used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.SecfixesPatternRegex_0.RunnerFactory.CreateInstance">
+            <summary>Creates an instance of a <see cref="T:System.Text.RegularExpressions.RegexRunner"/> used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.SecfixesPatternRegex_0.RunnerFactory.Runner">
+            <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.SecfixesPatternRegex_0.RunnerFactory.Runner.Scan(System.ReadOnlySpan{System.Char})">
+            <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.SecfixesPatternRegex_0.RunnerFactory.Runner.TryFindNextPossibleStartingPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if a possible match was found; false if no more matches are possible.</returns>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.SecfixesPatternRegex_0.RunnerFactory.Runner.TryMatchAtCurrentPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.VersionPatternRegex_1">
+            <summary>Custom <see cref="T:System.Text.RegularExpressions.Regex"/>-derived type for the VersionPatternRegex method.</summary>
+        </member>
+        <member name="F:System.Text.RegularExpressions.Generated.VersionPatternRegex_1.Instance">
+            <summary>Cached, thread-safe singleton instance.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.VersionPatternRegex_1.#ctor">
+            <summary>Initializes the instance.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.VersionPatternRegex_1.RunnerFactory">
+            <summary>Provides a factory for creating <see cref="T:System.Text.RegularExpressions.RegexRunner"/> instances to be used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.VersionPatternRegex_1.RunnerFactory.CreateInstance">
+            <summary>Creates an instance of a <see cref="T:System.Text.RegularExpressions.RegexRunner"/> used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.VersionPatternRegex_1.RunnerFactory.Runner">
+            <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.VersionPatternRegex_1.RunnerFactory.Runner.Scan(System.ReadOnlySpan{System.Char})">
+            <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.VersionPatternRegex_1.RunnerFactory.Runner.TryFindNextPossibleStartingPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if a possible match was found; false if no more matches are possible.</returns>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.VersionPatternRegex_1.RunnerFactory.Runner.TryMatchAtCurrentPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.CvePatternRegex_2">
+            <summary>Custom <see cref="T:System.Text.RegularExpressions.Regex"/>-derived type for the CvePatternRegex method.</summary>
+        </member>
+        <member name="F:System.Text.RegularExpressions.Generated.CvePatternRegex_2.Instance">
+            <summary>Cached, thread-safe singleton instance.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.CvePatternRegex_2.#ctor">
+            <summary>Initializes the instance.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.CvePatternRegex_2.RunnerFactory">
+            <summary>Provides a factory for creating <see cref="T:System.Text.RegularExpressions.RegexRunner"/> instances to be used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.CvePatternRegex_2.RunnerFactory.CreateInstance">
+            <summary>Creates an instance of a <see cref="T:System.Text.RegularExpressions.RegexRunner"/> used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.CvePatternRegex_2.RunnerFactory.Runner">
+            <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.CvePatternRegex_2.RunnerFactory.Runner.Scan(System.ReadOnlySpan{System.Char})">
+            <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.CvePatternRegex_2.RunnerFactory.Runner.TryFindNextPossibleStartingPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if a possible match was found; false if no more matches are possible.</returns>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.CvePatternRegex_2.RunnerFactory.Runner.TryMatchAtCurrentPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.CvePatternRegex_3">
+            <summary>Custom <see cref="T:System.Text.RegularExpressions.Regex"/>-derived type for the CvePatternRegex method.</summary>
+        </member>
+        <member name="F:System.Text.RegularExpressions.Generated.CvePatternRegex_3.Instance">
+            <summary>Cached, thread-safe singleton instance.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.CvePatternRegex_3.#ctor">
+            <summary>Initializes the instance.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.CvePatternRegex_3.RunnerFactory">
+            <summary>Provides a factory for creating <see cref="T:System.Text.RegularExpressions.RegexRunner"/> instances to be used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.CvePatternRegex_3.RunnerFactory.CreateInstance">
+            <summary>Creates an instance of a <see cref="T:System.Text.RegularExpressions.RegexRunner"/> used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.CvePatternRegex_3.RunnerFactory.Runner">
+            <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.CvePatternRegex_3.RunnerFactory.Runner.Scan(System.ReadOnlySpan{System.Char})">
+            <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.CvePatternRegex_3.RunnerFactory.Runner.TryFindNextPossibleStartingPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if a possible match was found; false if no more matches are possible.</returns>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.CvePatternRegex_3.RunnerFactory.Runner.TryMatchAtCurrentPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_4">
+            <summary>Custom <see cref="T:System.Text.RegularExpressions.Regex"/>-derived type for the EntryHeaderPatternRegex method.</summary>
+        </member>
+        <member name="F:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_4.Instance">
+            <summary>Cached, thread-safe singleton instance.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_4.#ctor">
+            <summary>Initializes the instance.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_4.RunnerFactory">
+            <summary>Provides a factory for creating <see cref="T:System.Text.RegularExpressions.RegexRunner"/> instances to be used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_4.RunnerFactory.CreateInstance">
+            <summary>Creates an instance of a <see cref="T:System.Text.RegularExpressions.RegexRunner"/> used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_4.RunnerFactory.Runner">
+            <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_4.RunnerFactory.Runner.Scan(System.ReadOnlySpan{System.Char})">
+            <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_4.RunnerFactory.Runner.TryFindNextPossibleStartingPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if a possible match was found; false if no more matches are possible.</returns>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_4.RunnerFactory.Runner.TryMatchAtCurrentPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.TrailerPatternRegex_5">
+            <summary>Custom <see cref="T:System.Text.RegularExpressions.Regex"/>-derived type for the TrailerPatternRegex method.</summary>
+        </member>
+        <member name="F:System.Text.RegularExpressions.Generated.TrailerPatternRegex_5.Instance">
+            <summary>Cached, thread-safe singleton instance.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.TrailerPatternRegex_5.#ctor">
+            <summary>Initializes the instance.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.TrailerPatternRegex_5.RunnerFactory">
+            <summary>Provides a factory for creating <see cref="T:System.Text.RegularExpressions.RegexRunner"/> instances to be used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.TrailerPatternRegex_5.RunnerFactory.CreateInstance">
+            <summary>Creates an instance of a <see cref="T:System.Text.RegularExpressions.RegexRunner"/> used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.TrailerPatternRegex_5.RunnerFactory.Runner">
+            <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.TrailerPatternRegex_5.RunnerFactory.Runner.Scan(System.ReadOnlySpan{System.Char})">
+            <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.TrailerPatternRegex_5.RunnerFactory.Runner.TryFindNextPossibleStartingPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if a possible match was found; false if no more matches are possible.</returns>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.TrailerPatternRegex_5.RunnerFactory.Runner.TryMatchAtCurrentPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_6">
+            <summary>Custom <see cref="T:System.Text.RegularExpressions.Regex"/>-derived type for the EntryHeaderPatternRegex method.</summary>
+        </member>
+        <member name="F:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_6.Instance">
+            <summary>Cached, thread-safe singleton instance.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_6.#ctor">
+            <summary>Initializes the instance.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_6.RunnerFactory">
+            <summary>Provides a factory for creating <see cref="T:System.Text.RegularExpressions.RegexRunner"/> instances to be used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_6.RunnerFactory.CreateInstance">
+            <summary>Creates an instance of a <see cref="T:System.Text.RegularExpressions.RegexRunner"/> used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_6.RunnerFactory.Runner">
+            <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_6.RunnerFactory.Runner.Scan(System.ReadOnlySpan{System.Char})">
+            <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_6.RunnerFactory.Runner.TryFindNextPossibleStartingPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if a possible match was found; false if no more matches are possible.</returns>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.EntryHeaderPatternRegex_6.RunnerFactory.Runner.TryMatchAtCurrentPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.ChangelogStartPatternRegex_7">
+            <summary>Custom <see cref="T:System.Text.RegularExpressions.Regex"/>-derived type for the ChangelogStartPatternRegex method.</summary>
+        </member>
+        <member name="F:System.Text.RegularExpressions.Generated.ChangelogStartPatternRegex_7.Instance">
+            <summary>Cached, thread-safe singleton instance.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.ChangelogStartPatternRegex_7.#ctor">
+            <summary>Initializes the instance.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.ChangelogStartPatternRegex_7.RunnerFactory">
+            <summary>Provides a factory for creating <see cref="T:System.Text.RegularExpressions.RegexRunner"/> instances to be used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.ChangelogStartPatternRegex_7.RunnerFactory.CreateInstance">
+            <summary>Creates an instance of a <see cref="T:System.Text.RegularExpressions.RegexRunner"/> used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.ChangelogStartPatternRegex_7.RunnerFactory.Runner">
+            <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.ChangelogStartPatternRegex_7.RunnerFactory.Runner.Scan(System.ReadOnlySpan{System.Char})">
+            <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.ChangelogStartPatternRegex_7.RunnerFactory.Runner.TryFindNextPossibleStartingPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if a possible match was found; false if no more matches are possible.</returns>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.ChangelogStartPatternRegex_7.RunnerFactory.Runner.TryMatchAtCurrentPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.SectionStartPatternRegex_8">
+            <summary>Custom <see cref="T:System.Text.RegularExpressions.Regex"/>-derived type for the SectionStartPatternRegex method.</summary>
+        </member>
+        <member name="F:System.Text.RegularExpressions.Generated.SectionStartPatternRegex_8.Instance">
+            <summary>Cached, thread-safe singleton instance.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.SectionStartPatternRegex_8.#ctor">
+            <summary>Initializes the instance.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.SectionStartPatternRegex_8.RunnerFactory">
+            <summary>Provides a factory for creating <see cref="T:System.Text.RegularExpressions.RegexRunner"/> instances to be used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.SectionStartPatternRegex_8.RunnerFactory.CreateInstance">
+            <summary>Creates an instance of a <see cref="T:System.Text.RegularExpressions.RegexRunner"/> used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.SectionStartPatternRegex_8.RunnerFactory.Runner">
+            <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.SectionStartPatternRegex_8.RunnerFactory.Runner.Scan(System.ReadOnlySpan{System.Char})">
+            <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.SectionStartPatternRegex_8.RunnerFactory.Runner.TryFindNextPossibleStartingPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if a possible match was found; false if no more matches are possible.</returns>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.SectionStartPatternRegex_8.RunnerFactory.Runner.TryMatchAtCurrentPosition(System.ReadOnlySpan{System.Char})">
+            <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
+            <param name="inputSpan">The text being scanned by the regular expression.</param>
+            <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
+        </member>
+        <member name="T:System.Text.RegularExpressions.Generated.Utilities">
+            <summary>Helper methods used by generated <see cref="T:System.Text.RegularExpressions.Regex"/>-derived implementations.</summary>
+        </member>
+        <member name="F:System.Text.RegularExpressions.Generated.Utilities.s_defaultTimeout">
+            <summary>Default timeout value set in <see cref="T:System.AppContext"/>, or <see cref="F:System.Text.RegularExpressions.Regex.InfiniteMatchTimeout"/> if none was set.</summary>
+        </member>
+        <member name="F:System.Text.RegularExpressions.Generated.Utilities.s_hasTimeout">
+            <summary>Whether <see cref="F:System.Text.RegularExpressions.Generated.Utilities.s_defaultTimeout"/> is non-infinite.</summary>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.Utilities.IsBoundaryWordChar(System.Char)">
+            <summary>Determines whether the specified index is a boundary word character.</summary>
+            <remarks>This is the same as \w plus U+200C ZERO WIDTH NON-JOINER and U+200D ZERO WIDTH JOINER.</remarks>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.Utilities.IsPostWordCharBoundary(System.ReadOnlySpan{System.Char},System.Int32)">
+            <summary>Determines whether the specified index is a boundary.</summary>
+            <remarks>This variant is only employed when the previous character has already been validated as a word character.</remarks>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.Utilities.IsPreWordCharBoundary(System.ReadOnlySpan{System.Char},System.Int32)">
+            <summary>Determines whether the specified index is a boundary.</summary>
+            <remarks>This variant is only employed when the subsequent character will separately be validated as a word character.</remarks>
+        </member>
+        <member name="M:System.Text.RegularExpressions.Generated.Utilities.IsWordChar(System.Char)">
+            <summary>Determines whether the character is part of the [\w] set.</summary>
+        </member>
+        <member name="F:System.Text.RegularExpressions.Generated.Utilities.WordCategoriesMask">
+            <summary>Provides a mask of Unicode categories that combine to form [\w].</summary>
+        </member>
+        <member name="P:System.Text.RegularExpressions.Generated.Utilities.WordCharBitmap">
+            <summary>Gets a bitmap for whether each character 0 through 127 is in [\w]</summary>
+        </member>
+        <member name="F:System.Text.RegularExpressions.Generated.Utilities.s_indexOfString_2F93FE89B97147CEC70A0EB0ACFDB2E4BA07C5F0174666AF09DD4CE814752C02">
+            <summary>Supports searching for the string "CVE-".</summary>
+        </member>
+    </members>
+</doc>

src/BinaryIndex/StellaOps.BinaryIndex.WebService/docs/qa/feature-checks/runs/binaryindex/vulnerable-binaries-database/run-001/tier1-build-out/StellaOps.BinaryIndex.WebService/StellaOps.BinaryIndex.Persistence.xml

@@ -0,0 +1,815 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>StellaOps.BinaryIndex.Persistence</name>
+    </assembly>
+    <members>
+        <member name="T:StellaOps.BinaryIndex.Persistence.BinaryIndexDbContext">
+            <summary>
+            Database context for BinaryIndex with tenant isolation.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.BinaryIndexDbContext.OpenConnectionAsync(System.Threading.CancellationToken)">
+            <summary>
+            Opens a connection with the tenant context set for RLS.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.BinaryIndexMigrationRunner">
+            <summary>
+            Runs embedded SQL migrations for the binaries schema.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.BinaryIndexMigrationRunner.MigrateAsync(System.Threading.CancellationToken)">
+            <summary>
+            Applies all embedded migrations to the database.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.BinaryIdentityRepository">
+            <summary>
+            Repository implementation for binary identity operations.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.CorpusSnapshotRepository">
+            <summary>
+            Repository for corpus snapshots.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureRepository">
+            <summary>
+            PostgreSQL repository implementation for delta signatures.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureRepository.CreateAsync(StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureEntity,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureRepository.CreateBatchAsync(System.Collections.Generic.IEnumerable{StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureEntity},System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureRepository.GetByIdAsync(System.Guid,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureRepository.GetByCveAsync(System.String,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureRepository.GetByPackageAsync(System.String,System.String,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureRepository.GetByHashAsync(System.String,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureRepository.GetForMatchingAsync(System.String,System.String,System.Collections.Generic.IEnumerable{System.String},System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureRepository.GetAllMatchingAsync(System.Collections.Generic.IReadOnlyList{System.String},System.String,System.String,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureRepository.UpdateAsync(StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureEntity,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureRepository.DeleteAsync(System.Guid,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureRepository.GetCountsByStateAsync(System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureRepository.GetPatchCoverageAsync(System.Collections.Generic.IReadOnlyList{System.String},System.String,System.Int32,System.Int32,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureRepository.GetPatchCoverageDetailsAsync(System.String,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureRepository.GetMatchingImagesAsync(System.String,System.String,System.String,System.Int32,System.Int32,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureRepository.DeltaSignatureRow">
+            <summary>
+            Internal row type for Dapper mapping.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.FingerprintRepository">
+            <summary>
+            Repository implementation for vulnerable fingerprints.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.FingerprintMatchRepository">
+            <summary>
+            Repository implementation for fingerprint matches.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.FixIndexRepository">
+            <summary>
+            PostgreSQL implementation of <see cref="T:StellaOps.BinaryIndex.FixIndex.Repositories.IFixIndexRepository"/>.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.FixIndexRepository.GetFixStatusAsync(System.String,System.String,System.String,System.String,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.FixIndexRepository.GetFixStatusesForPackageAsync(System.String,System.String,System.String,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.FixIndexRepository.GetFixLocationsForCveAsync(System.String,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.FixIndexRepository.UpsertAsync(StellaOps.BinaryIndex.FixIndex.Models.FixEvidence,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.FixIndexRepository.UpsertBatchAsync(System.Collections.Generic.IEnumerable{StellaOps.BinaryIndex.FixIndex.Models.FixEvidence},System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.FixIndexRepository.StoreEvidenceAsync(StellaOps.BinaryIndex.FixIndex.Models.FixEvidence,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.FixIndexRepository.GetEvidenceAsync(System.Guid,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.FixIndexRepository.DeleteBySnapshotAsync(System.Guid,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.FunctionCorpusRepository">
+            <summary>
+            PostgreSQL repository for function corpus data.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.IRawDocumentRepository">
+            <summary>
+            Repository for raw document storage (immutable, append-only).
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.IRawDocumentRepository.GetByDigestAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Get a raw document by digest.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.IRawDocumentRepository.ExistsAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Check if a document exists by digest.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.IRawDocumentRepository.GetPendingParseAsync(System.String,System.Int32,System.Threading.CancellationToken)">
+            <summary>
+            Get documents pending parse.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.IRawDocumentRepository.GetPendingMapAsync(System.String,System.Int32,System.Threading.CancellationToken)">
+            <summary>
+            Get documents pending map.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.IRawDocumentRepository.InsertAsync(StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.RawDocumentEntity,System.Threading.CancellationToken)">
+            <summary>
+            Insert a new raw document (append-only).
+            </summary>
+            <returns>True if inserted, false if already exists.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.IRawDocumentRepository.UpdateStatusAsync(System.String,System.String,System.Threading.CancellationToken)">
+            <summary>
+            Update document status.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.IRawDocumentRepository.GetCountByStatusAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Get document count by source and status.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.RawDocumentEntity">
+            <summary>
+            Raw document entity.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.DocumentStatus">
+            <summary>
+            Document status values.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISecurityPairRepository">
+            <summary>
+            Repository for security pair (pre/post CVE binary) management.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISecurityPairRepository.GetByIdAsync(System.Guid,System.Threading.CancellationToken)">
+            <summary>
+            Get a security pair by ID.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISecurityPairRepository.GetByCveAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Get security pairs by CVE ID.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISecurityPairRepository.GetByPackageAsync(System.String,System.String,System.Threading.CancellationToken)">
+            <summary>
+            Get security pairs by package.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISecurityPairRepository.GetPendingVerificationAsync(System.Int32,System.Threading.CancellationToken)">
+            <summary>
+            Get pairs pending verification.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISecurityPairRepository.UpsertAsync(StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SecurityPairEntity,System.Threading.CancellationToken)">
+            <summary>
+            Create or update a security pair.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISecurityPairRepository.UpdateVerificationStatusAsync(System.Guid,System.String,System.Threading.CancellationToken)">
+            <summary>
+            Update verification status.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISecurityPairRepository.LinkObservationsAsync(System.Guid,System.String,System.String,System.Threading.CancellationToken)">
+            <summary>
+            Link observations to a pair.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISecurityPairRepository.GetLinkedPairsAsync(System.Int32,System.Threading.CancellationToken)">
+            <summary>
+            Get pairs with linked observations for validation.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SecurityPairEntity">
+            <summary>
+            Security pair entity.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.VerificationStatus">
+            <summary>
+            Verification status values.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISourceStateRepository">
+            <summary>
+            Repository for source sync state and cursor management.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISourceStateRepository.GetAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Get state for a source.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISourceStateRepository.GetAllAsync(System.Threading.CancellationToken)">
+            <summary>
+            Get states for all sources.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISourceStateRepository.UpdateAsync(StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SourceStateEntity,System.Threading.CancellationToken)">
+            <summary>
+            Update sync state and cursor position.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISourceStateRepository.TrySetSyncingAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Set sync status (for concurrent sync protection).
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISourceStateRepository.ClearSyncingAsync(System.String,System.String,System.Threading.CancellationToken)">
+            <summary>
+            Clear syncing status.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISourceStateRepository.IncrementCountsAsync(System.String,System.Int32,System.Int32,System.Threading.CancellationToken)">
+            <summary>
+            Increment document and observation counts.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SourceStateEntity">
+            <summary>
+            Source state entity.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SyncStatus">
+            <summary>
+            Sync status values.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISymbolObservationRepository">
+            <summary>
+            Repository for symbol observation persistence.
+            Follows immutable, append-only pattern with supersession.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISymbolObservationRepository.GetByIdAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Get an observation by its ID.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISymbolObservationRepository.GetByDebugIdAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Get observations by debug ID.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISymbolObservationRepository.GetLatestByDebugIdAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Get the latest observation for a debug ID (considering supersession).
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISymbolObservationRepository.GetByPackageAsync(System.String,System.String,System.String,System.Threading.CancellationToken)">
+            <summary>
+            Get observations by package.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISymbolObservationRepository.GetExistingContentHashAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Check if content hash already exists (for idempotency).
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISymbolObservationRepository.InsertAsync(StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolObservationEntity,System.Threading.CancellationToken)">
+            <summary>
+            Insert a new observation (append-only).
+            </summary>
+            <returns>True if inserted, false if identical observation already exists.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISymbolObservationRepository.SearchBySymbolNameAsync(System.String,System.Int32,System.Threading.CancellationToken)">
+            <summary>
+            Search observations by symbol name.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISymbolObservationRepository.GetCountBySourceAsync(System.Threading.CancellationToken)">
+            <summary>
+            Get observation count by source.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolObservationEntity">
+            <summary>
+            Symbol observation entity.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISymbolSourceRepository">
+            <summary>
+            Repository for symbol source management.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISymbolSourceRepository.GetAllAsync(System.Threading.CancellationToken)">
+            <summary>
+            Get all registered symbol sources.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISymbolSourceRepository.GetByIdAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Get a symbol source by ID.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISymbolSourceRepository.GetEnabledAsync(System.Threading.CancellationToken)">
+            <summary>
+            Get all enabled symbol sources.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISymbolSourceRepository.UpsertAsync(StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolSourceEntity,System.Threading.CancellationToken)">
+            <summary>
+            Register or update a symbol source.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.ISymbolSourceRepository.SetEnabledAsync(System.String,System.Boolean,System.Threading.CancellationToken)">
+            <summary>
+            Enable or disable a symbol source.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolSourceEntity">
+            <summary>
+            Symbol source entity.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.RawDocumentRepository">
+            <summary>
+            Repository implementation for raw document storage (immutable, append-only).
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.RawDocumentRepository.GetByDigestAsync(System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.RawDocumentRepository.ExistsAsync(System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.RawDocumentRepository.GetPendingParseAsync(System.String,System.Int32,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.RawDocumentRepository.GetPendingMapAsync(System.String,System.Int32,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.RawDocumentRepository.InsertAsync(StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.RawDocumentEntity,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.RawDocumentRepository.UpdateStatusAsync(System.String,System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.RawDocumentRepository.GetCountByStatusAsync(System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SecurityPairRepository">
+            <summary>
+            Repository implementation for security pair (pre/post CVE binary) management.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SecurityPairRepository.GetByIdAsync(System.Guid,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SecurityPairRepository.GetByCveAsync(System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SecurityPairRepository.GetByPackageAsync(System.String,System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SecurityPairRepository.GetPendingVerificationAsync(System.Int32,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SecurityPairRepository.UpsertAsync(StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SecurityPairEntity,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SecurityPairRepository.UpdateVerificationStatusAsync(System.Guid,System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SecurityPairRepository.LinkObservationsAsync(System.Guid,System.String,System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SecurityPairRepository.GetLinkedPairsAsync(System.Int32,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SourceStateRepository">
+            <summary>
+            Repository implementation for source sync state and cursor management.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SourceStateRepository.GetAsync(System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SourceStateRepository.GetAllAsync(System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SourceStateRepository.UpdateAsync(StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SourceStateEntity,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SourceStateRepository.TrySetSyncingAsync(System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SourceStateRepository.ClearSyncingAsync(System.String,System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SourceStateRepository.IncrementCountsAsync(System.String,System.Int32,System.Int32,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolObservationRepository">
+            <summary>
+            Repository implementation for symbol observation persistence.
+            Follows immutable, append-only pattern with supersession.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolObservationRepository.GetByIdAsync(System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolObservationRepository.GetByDebugIdAsync(System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolObservationRepository.GetLatestByDebugIdAsync(System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolObservationRepository.GetByPackageAsync(System.String,System.String,System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolObservationRepository.GetExistingContentHashAsync(System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolObservationRepository.InsertAsync(StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolObservationEntity,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolObservationRepository.SearchBySymbolNameAsync(System.String,System.Int32,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolObservationRepository.GetCountBySourceAsync(System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolSourceRepository">
+            <summary>
+            Repository implementation for symbol source management.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolSourceRepository.GetAllAsync(System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolSourceRepository.GetByIdAsync(System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolSourceRepository.GetEnabledAsync(System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolSourceRepository.UpsertAsync(StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolSourceEntity,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.GroundTruth.SymbolSourceRepository.SetEnabledAsync(System.String,System.Boolean,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.IBinaryIdentityRepository">
+            <summary>
+            Repository for binary identity operations.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IBinaryIdentityRepository.GetByBuildIdAsync(System.String,System.String,System.Threading.CancellationToken)">
+            <summary>
+            Gets a binary identity by its Build-ID.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IBinaryIdentityRepository.GetByKeyAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Gets a binary identity by its key.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IBinaryIdentityRepository.GetByFileSha256Async(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Gets a binary identity by its file SHA-256 hash.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IBinaryIdentityRepository.UpsertAsync(StellaOps.BinaryIndex.Core.Models.BinaryIdentity,System.Threading.CancellationToken)">
+            <summary>
+            Upserts a binary identity.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IBinaryIdentityRepository.GetBatchAsync(System.Collections.Generic.IEnumerable{System.String},System.Threading.CancellationToken)">
+            <summary>
+            Gets multiple binary identities by their keys.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.IDeltaSignatureRepository">
+            <summary>
+            Repository interface for delta signatures.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IDeltaSignatureRepository.CreateAsync(StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureEntity,System.Threading.CancellationToken)">
+            <summary>
+            Creates a new delta signature.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IDeltaSignatureRepository.CreateBatchAsync(System.Collections.Generic.IEnumerable{StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureEntity},System.Threading.CancellationToken)">
+            <summary>
+            Creates multiple delta signatures in a batch.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IDeltaSignatureRepository.GetByIdAsync(System.Guid,System.Threading.CancellationToken)">
+            <summary>
+            Gets a delta signature by ID.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IDeltaSignatureRepository.GetByCveAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Gets delta signatures by CVE ID.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IDeltaSignatureRepository.GetByPackageAsync(System.String,System.String,System.Threading.CancellationToken)">
+            <summary>
+            Gets delta signatures by package name.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IDeltaSignatureRepository.GetByHashAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Gets delta signatures by hash.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IDeltaSignatureRepository.GetForMatchingAsync(System.String,System.String,System.Collections.Generic.IEnumerable{System.String},System.Threading.CancellationToken)">
+            <summary>
+            Gets delta signatures for matching by architecture and symbols.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IDeltaSignatureRepository.GetAllMatchingAsync(System.Collections.Generic.IReadOnlyList{System.String},System.String,System.String,System.Threading.CancellationToken)">
+            <summary>
+            Gets all delta signatures matching the specified filters.
+            Used for vulnerability lookup with flexible filtering.
+            </summary>
+            <param name="cveFilter">Optional CVE IDs to filter.</param>
+            <param name="packageFilter">Optional package name to filter.</param>
+            <param name="archFilter">Optional architecture to filter.</param>
+            <param name="ct">Cancellation token.</param>
+            <returns>Matching delta signature entities.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IDeltaSignatureRepository.UpdateAsync(StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureEntity,System.Threading.CancellationToken)">
+            <summary>
+            Updates a delta signature.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IDeltaSignatureRepository.DeleteAsync(System.Guid,System.Threading.CancellationToken)">
+            <summary>
+            Deletes a delta signature.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IDeltaSignatureRepository.GetCountsByStateAsync(System.Threading.CancellationToken)">
+            <summary>
+            Gets the count of signatures by state.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IDeltaSignatureRepository.GetPatchCoverageAsync(System.Collections.Generic.IReadOnlyList{System.String},System.String,System.Int32,System.Int32,System.Threading.CancellationToken)">
+            <summary>
+            Gets aggregated patch coverage statistics by CVE.
+            Returns summary counts of vulnerable/patched/unknown states per CVE.
+            </summary>
+            <param name="cveFilter">Optional CVE IDs to filter.</param>
+            <param name="packageFilter">Optional package name filter.</param>
+            <param name="limit">Maximum number of CVEs to return (default 100).</param>
+            <param name="offset">Offset for pagination.</param>
+            <param name="ct">Cancellation token.</param>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IDeltaSignatureRepository.GetPatchCoverageDetailsAsync(System.String,System.Threading.CancellationToken)">
+            <summary>
+            Gets detailed patch coverage for a specific CVE with function-level breakdown.
+            </summary>
+            <param name="cveId">CVE identifier.</param>
+            <param name="ct">Cancellation token.</param>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.IDeltaSignatureRepository.GetMatchingImagesAsync(System.String,System.String,System.String,System.Int32,System.Int32,System.Threading.CancellationToken)">
+            <summary>
+            Gets paginated list of images/binaries matching a specific CVE and symbol.
+            </summary>
+            <param name="cveId">CVE identifier.</param>
+            <param name="symbolName">Optional symbol name filter.</param>
+            <param name="matchState">Optional state filter (vulnerable/patched/unknown).</param>
+            <param name="limit">Maximum results.</param>
+            <param name="offset">Pagination offset.</param>
+            <param name="ct">Cancellation token.</param>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageResult">
+            <summary>
+            Result of patch coverage aggregation query.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageResult.Entries">
+            <summary>Coverage entries by CVE.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageResult.TotalCount">
+            <summary>Total number of CVEs matching filter.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageResult.Offset">
+            <summary>Offset used for pagination.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageResult.Limit">
+            <summary>Limit used for pagination.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageEntry">
+            <summary>
+            Patch coverage summary for a single CVE.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageEntry.CveId">
+            <summary>CVE identifier.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageEntry.PackageName">
+            <summary>Primary package name.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageEntry.VulnerableCount">
+            <summary>Number of images with vulnerable state.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageEntry.PatchedCount">
+            <summary>Number of images with patched state.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageEntry.UnknownCount">
+            <summary>Number of images with unknown state.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageEntry.SymbolCount">
+            <summary>Total number of distinct symbols tracked.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageEntry.CoveragePercent">
+            <summary>Patch coverage percentage (0-100).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageEntry.LastUpdatedAt">
+            <summary>When this CVE's signatures were last updated.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageDetails">
+            <summary>
+            Detailed patch coverage for a CVE with function-level breakdown.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageDetails.CveId">
+            <summary>CVE identifier.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageDetails.PackageName">
+            <summary>Primary package name.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageDetails.Functions">
+            <summary>Function-level breakdown.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageDetails.Summary">
+            <summary>Summary statistics.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.FunctionCoverageEntry">
+            <summary>
+            Coverage entry for a single function/symbol.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.FunctionCoverageEntry.SymbolName">
+            <summary>Symbol/function name.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.FunctionCoverageEntry.Soname">
+            <summary>Shared object name (soname).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.FunctionCoverageEntry.VulnerableCount">
+            <summary>Number of vulnerable matches.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.FunctionCoverageEntry.PatchedCount">
+            <summary>Number of patched matches.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.FunctionCoverageEntry.UnknownCount">
+            <summary>Number of unknown matches.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.FunctionCoverageEntry.HasDelta">
+            <summary>Whether vulnerable and patched signatures exist.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageSummary">
+            <summary>
+            Summary statistics for patch coverage.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageSummary.TotalImages">
+            <summary>Total images analyzed.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageSummary.VulnerableImages">
+            <summary>Total vulnerable images.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageSummary.PatchedImages">
+            <summary>Total patched images.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageSummary.UnknownImages">
+            <summary>Total unknown images.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageSummary.OverallCoverage">
+            <summary>Overall coverage percentage.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageSummary.SymbolCount">
+            <summary>Number of distinct symbols.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchCoverageSummary.DeltaPairCount">
+            <summary>Number of symbols with delta pairs.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.PatchMatchPage">
+            <summary>
+            Paginated list of matching images.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchMatchPage.Matches">
+            <summary>Matching image entries.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchMatchPage.TotalCount">
+            <summary>Total count matching filter.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchMatchPage.Offset">
+            <summary>Offset used.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchMatchPage.Limit">
+            <summary>Limit used.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.PatchMatchEntry">
+            <summary>
+            Single image match entry.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchMatchEntry.MatchId">
+            <summary>Match ID.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchMatchEntry.BinaryKey">
+            <summary>Binary key (image digest or path).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchMatchEntry.BinarySha256">
+            <summary>Binary SHA-256 hash.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchMatchEntry.SymbolName">
+            <summary>Matched symbol name.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchMatchEntry.MatchState">
+            <summary>Match state (vulnerable/patched/unknown).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchMatchEntry.Confidence">
+            <summary>Match confidence (0-1).</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchMatchEntry.ScanId">
+            <summary>Scan ID that produced this match.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.Persistence.Repositories.PatchMatchEntry.ScannedAt">
+            <summary>When the match was recorded.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureEntity">
+            <summary>
+            Entity representing a persisted delta signature.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSignatureEntity.ToSymbolSignature">
+            <summary>
+            Converts to a DeltaSig model SymbolSignature.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Repositories.DeltaSigMatchEntity">
+            <summary>
+            Entity representing a persisted match result.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.Persistence.Services.BinaryVulnerabilityService">
+            <summary>
+            Implementation of binary vulnerability lookup service.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Services.BinaryVulnerabilityService.LookupByDeltaSignatureAsync(System.IO.Stream,StellaOps.BinaryIndex.Core.Services.DeltaSigLookupOptions,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Services.BinaryVulnerabilityService.LookupBySymbolHashAsync(System.String,System.String,StellaOps.BinaryIndex.Core.Services.DeltaSigLookupOptions,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Services.BinaryVulnerabilityService.IdentifyFunctionFromCorpusAsync(StellaOps.BinaryIndex.Core.Services.FunctionFingerprintSet,StellaOps.BinaryIndex.Core.Services.CorpusLookupOptions,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.Persistence.Services.BinaryVulnerabilityService.IdentifyFunctionsFromCorpusBatchAsync(System.Collections.Generic.IEnumerable{System.ValueTuple{System.String,StellaOps.BinaryIndex.Core.Services.FunctionFingerprintSet}},StellaOps.BinaryIndex.Core.Services.CorpusLookupOptions,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+    </members>
+</doc>

src/BinaryIndex/StellaOps.BinaryIndex.WebService/docs/qa/feature-checks/runs/binaryindex/vulnerable-binaries-database/run-001/tier1-build-out/StellaOps.BinaryIndex.WebService/StellaOps.BinaryIndex.VexBridge.xml

@@ -0,0 +1,270 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>StellaOps.BinaryIndex.VexBridge</name>
+    </assembly>
+    <members>
+        <member name="T:StellaOps.BinaryIndex.VexBridge.BinaryMatchEvidenceSchema">
+            <summary>
+            Constants and schema definitions for binary match evidence in VEX observations.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.VexBridge.BinaryMatchEvidenceSchema.EvidenceType">
+            <summary>Evidence type identifier for binary fingerprint matches.</summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.VexBridge.BinaryMatchEvidenceSchema.SchemaVersion">
+            <summary>Schema version for evidence payloads.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.VexBridge.BinaryMatchEvidenceSchema.Fields">
+            <summary>Evidence field names.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.VexBridge.BinaryMatchEvidenceSchema.MatchTypes">
+            <summary>Match type values.</summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.VexBridge.BinaryMatchEvidenceSchema.ValidateEvidence(System.Text.Json.Nodes.JsonObject,System.String@)">
+            <summary>
+            Validates an evidence payload against the expected schema.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.VexBridge.BinaryMatchEvidenceSchema.CreateEvidence(System.String,System.String,System.String,System.String,System.String,System.Nullable{System.Decimal},System.String,System.String,System.String,System.String,System.Nullable{System.Decimal},System.String,System.String,System.String,System.String,System.Nullable{System.DateTimeOffset})">
+            <summary>
+            Creates an evidence JSON object from the provided parameters.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.VexBridge.IDsseSigningAdapter">
+            <summary>
+            Adapter interface for DSSE signing operations.
+            Abstracts the Attestor signing service for VexBridge use.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.VexBridge.IDsseSigningAdapter.SignAsync(System.Byte[],System.String,System.Threading.CancellationToken)">
+            <summary>
+            Sign a payload and return a DSSE envelope.
+            </summary>
+            <param name="payload">The payload bytes to sign.</param>
+            <param name="payloadType">The DSSE payload type URI.</param>
+            <param name="ct">Cancellation token.</param>
+            <returns>DSSE envelope as JSON bytes.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.VexBridge.IDsseSigningAdapter.VerifyAsync(System.Byte[],System.Threading.CancellationToken)">
+            <summary>
+            Verify a DSSE envelope signature.
+            </summary>
+            <param name="envelope">The DSSE envelope bytes.</param>
+            <param name="ct">Cancellation token.</param>
+            <returns>True if signature is valid.</returns>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.IDsseSigningAdapter.SigningKeyId">
+            <summary>
+            Get the key ID used for signing.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.IDsseSigningAdapter.IsAvailable">
+            <summary>
+            Check if signing is available.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.VexBridge.DsseEnvelopeResult">
+            <summary>
+            DSSE envelope result with metadata.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.DsseEnvelopeResult.Envelope">
+            <summary>The DSSE envelope as JSON string.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.DsseEnvelopeResult.KeyId">
+            <summary>The signing key ID used.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.DsseEnvelopeResult.EnvelopeHash">
+            <summary>SHA-256 hash of the envelope.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.DsseEnvelopeResult.SignedAt">
+            <summary>Timestamp when signed.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.VexBridge.IVexEvidenceGenerator">
+            <summary>
+            Generates VEX observations from binary vulnerability match results.
+            Bridges the gap between binary fingerprint analysis and VEX decision flow.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.VexBridge.IVexEvidenceGenerator.GenerateFromBinaryMatchAsync(StellaOps.BinaryIndex.Core.Services.BinaryVulnMatch,StellaOps.BinaryIndex.Core.Models.BinaryIdentity,StellaOps.BinaryIndex.Core.Services.FixStatusResult,StellaOps.BinaryIndex.VexBridge.VexGenerationContext,System.Threading.CancellationToken)">
+            <summary>
+            Generate a VEX observation from a binary vulnerability match.
+            </summary>
+            <param name="match">The binary vulnerability match result.</param>
+            <param name="identity">The binary identity being analyzed.</param>
+            <param name="fixStatus">Optional fix status from the fix index.</param>
+            <param name="context">Generation context with tenant and scan metadata.</param>
+            <param name="ct">Cancellation token.</param>
+            <returns>A VEX observation ready for Excititor persistence.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.VexBridge.IVexEvidenceGenerator.GenerateBatchAsync(System.Collections.Generic.IEnumerable{StellaOps.BinaryIndex.VexBridge.BinaryMatchWithContext},System.Threading.CancellationToken)">
+            <summary>
+            Batch generation of VEX observations for scan performance.
+            </summary>
+            <param name="matches">Collection of matches with their context.</param>
+            <param name="ct">Cancellation token.</param>
+            <returns>List of VEX observations in deterministic order.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.VexBridge.IVexEvidenceGenerator.GenerateObservationId(System.String,System.String,System.String,System.String)">
+            <summary>
+            Generate observation ID deterministically for replay/idempotency.
+            </summary>
+            <param name="tenantId">Tenant identifier.</param>
+            <param name="cveId">CVE identifier.</param>
+            <param name="productKey">PURL or product key.</param>
+            <param name="scanId">Scan identifier.</param>
+            <returns>Deterministic UUID5-based observation ID.</returns>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.VexBridge.VexGenerationContext">
+            <summary>
+            Context for VEX observation generation.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexGenerationContext.TenantId">
+            <summary>Tenant identifier.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexGenerationContext.ScanId">
+            <summary>Scan identifier for traceability.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexGenerationContext.ProductKey">
+            <summary>Product key, typically a PURL.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexGenerationContext.DistroRelease">
+            <summary>Optional distro release identifier (e.g., "debian:bookworm").</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexGenerationContext.SignWithDsse">
+            <summary>Whether to sign the observation with DSSE. Default true.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexGenerationContext.ProviderId">
+            <summary>Provider ID for the VEX observation. Defaults to "stellaops.binaryindex".</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexGenerationContext.StreamId">
+            <summary>Stream ID for the VEX observation. Defaults to "binary_resolution".</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexGenerationContext.EvidenceVersion">
+            <summary>Optional version for the resolution evidence.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.VexBridge.BinaryMatchWithContext">
+            <summary>
+            Wrapper for a binary match with its full context.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.BinaryMatchWithContext.Match">
+            <summary>The binary vulnerability match.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.BinaryMatchWithContext.Identity">
+            <summary>The binary identity being analyzed.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.BinaryMatchWithContext.FixStatus">
+            <summary>Optional fix status from the fix index.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.BinaryMatchWithContext.Context">
+            <summary>Generation context.</summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.VexBridge.ServiceCollectionExtensions">
+            <summary>
+            Extension methods for registering VexBridge services.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.VexBridge.ServiceCollectionExtensions.AddBinaryVexBridge(Microsoft.Extensions.DependencyInjection.IServiceCollection,Microsoft.Extensions.Configuration.IConfiguration)">
+            <summary>
+            Adds VEX Bridge services for converting binary matches to VEX observations.
+            </summary>
+            <param name="services">The service collection.</param>
+            <param name="configuration">Configuration containing VexBridge section.</param>
+            <returns>The service collection for chaining.</returns>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.VexBridge.ServiceCollectionExtensions.AddBinaryVexBridge(Microsoft.Extensions.DependencyInjection.IServiceCollection,System.Action{StellaOps.BinaryIndex.VexBridge.VexBridgeOptions})">
+            <summary>
+            Adds VEX Bridge services with custom options configuration.
+            </summary>
+            <param name="services">The service collection.</param>
+            <param name="configureOptions">Action to configure options.</param>
+            <returns>The service collection for chaining.</returns>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.VexBridge.VexBridgeOptions">
+            <summary>
+            Configuration options for the VEX Bridge.
+            </summary>
+        </member>
+        <member name="F:StellaOps.BinaryIndex.VexBridge.VexBridgeOptions.SectionName">
+            <summary>Configuration section name.</summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexBridgeOptions.SignWithDsse">
+            <summary>
+            Whether to sign generated VEX observations with DSSE.
+            Default: true
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexBridgeOptions.DsseKeyId">
+            <summary>
+            Key ID to use for DSSE signing.
+            If null, uses the default attestor key.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexBridgeOptions.DefaultProviderId">
+            <summary>
+            Default provider ID for generated observations.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexBridgeOptions.DefaultStreamId">
+            <summary>
+            Default stream ID for generated observations.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexBridgeOptions.MinConfidenceThreshold">
+            <summary>
+            Minimum confidence threshold for creating observations.
+            Matches below this threshold will be skipped.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexBridgeOptions.IncludeFunctionEvidence">
+            <summary>
+            Whether to include function-level evidence when available.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexBridgeOptions.MaxBatchSize">
+            <summary>
+            Maximum number of observations to generate in a single batch.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexBridgeOptions.ObservationIdNamespace">
+            <summary>
+            Namespace UUID for generating deterministic observation IDs.
+            Default: StellaOps BinaryIndex namespace.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexBridgeOptions.IncludeExternalLinks">
+            <summary>
+            Whether to include external reference links (e.g., NVD) in linksets.
+            </summary>
+        </member>
+        <member name="P:StellaOps.BinaryIndex.VexBridge.VexBridgeOptions.NvdCveBaseUrl">
+            <summary>
+            Base URL for CVE references when external links are enabled.
+            </summary>
+        </member>
+        <member name="T:StellaOps.BinaryIndex.VexBridge.VexEvidenceGenerator">
+            <summary>
+            Generates VEX observations from binary vulnerability matches.
+            Maps FixState to VexClaimStatus with appropriate justifications.
+            Supports optional DSSE signing for attestable proofs.
+            </summary>
+        </member>
+        <member name="M:StellaOps.BinaryIndex.VexBridge.VexEvidenceGenerator.GenerateFromBinaryMatchAsync(StellaOps.BinaryIndex.Core.Services.BinaryVulnMatch,StellaOps.BinaryIndex.Core.Models.BinaryIdentity,StellaOps.BinaryIndex.Core.Services.FixStatusResult,StellaOps.BinaryIndex.VexBridge.VexGenerationContext,System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.VexBridge.VexEvidenceGenerator.GenerateBatchAsync(System.Collections.Generic.IEnumerable{StellaOps.BinaryIndex.VexBridge.BinaryMatchWithContext},System.Threading.CancellationToken)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.VexBridge.VexEvidenceGenerator.GenerateObservationId(System.String,System.String,System.String,System.String)">
+            <inheritdoc />
+        </member>
+        <member name="M:StellaOps.BinaryIndex.VexBridge.VexEvidenceGenerator.GenerateUuid5(System.Guid,System.String)">
+            <summary>
+            Generate a UUID v5 (name-based, SHA-1) from namespace and name.
+            </summary>
+        </member>
+    </members>
+</doc>

src/BinaryIndex/StellaOps.BinaryIndex.WebService/docs/qa/feature-checks/runs/binaryindex/vulnerable-binaries-database/run-001/tier1-build-out/StellaOps.BinaryIndex.WebService/StellaOps.BinaryIndex.WebService.runtimeconfig.json

@@ -0,0 +1,20 @@
+{
+  "runtimeOptions": {
+    "tfm": "net10.0",
+    "frameworks": [
+      {
+        "name": "Microsoft.NETCore.App",
+        "version": "10.0.0"
+      },
+      {
+        "name": "Microsoft.AspNetCore.App",
+        "version": "10.0.0"
+      }
+    ],
+    "configProperties": {
+      "System.GC.Server": true,
+      "System.Reflection.Metadata.MetadataUpdater.IsSupported": false,
+      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false
+    }
+  }
+}

src/BinaryIndex/StellaOps.BinaryIndex.WebService/docs/qa/feature-checks/runs/binaryindex/vulnerable-binaries-database/run-001/tier1-build-out/StellaOps.BinaryIndex.WebService/StellaOps.BinaryIndex.WebService.staticwebassets.endpoints.json

@@ -0,0 +1 @@
+{"Version":1,"ManifestType":"Build","Endpoints":[]}

src/BinaryIndex/StellaOps.BinaryIndex.WebService/docs/qa/feature-checks/runs/binaryindex/vulnerable-binaries-database/run-001/tier1-build-out/StellaOps.BinaryIndex.WebService/StellaOps.Cryptography.PluginLoader.xml

@@ -0,0 +1,221 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>StellaOps.Cryptography.PluginLoader</name>
+    </assembly>
+    <members>
+        <member name="T:StellaOps.Cryptography.PluginLoader.CryptoPluginConfiguration">
+            <summary>
+            Configuration for crypto plugin loading and selection.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginConfiguration.ManifestPath">
+            <summary>
+            Path to the plugin manifest JSON file.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginConfiguration.DiscoveryMode">
+            <summary>
+            Plugin discovery mode: "explicit" (only load configured plugins) or "auto" (load all compatible plugins).
+            Default: "explicit" for production safety.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginConfiguration.Enabled">
+            <summary>
+            List of plugins to enable with optional priority and options overrides.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginConfiguration.Disabled">
+            <summary>
+            List of plugin IDs or patterns to explicitly disable.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginConfiguration.FailOnMissingPlugin">
+            <summary>
+            Fail application startup if a configured plugin cannot be loaded.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginConfiguration.RequireAtLeastOne">
+            <summary>
+            Require at least one crypto provider to be successfully loaded.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginConfiguration.Compliance">
+            <summary>
+            Compliance profile configuration.
+            </summary>
+        </member>
+        <member name="T:StellaOps.Cryptography.PluginLoader.EnabledPluginEntry">
+            <summary>
+            Configuration entry for an enabled plugin.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.EnabledPluginEntry.Id">
+            <summary>
+            Plugin identifier from the manifest.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.EnabledPluginEntry.Priority">
+            <summary>
+            Priority override for this plugin (higher = preferred).
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.EnabledPluginEntry.Options">
+            <summary>
+            Plugin-specific options (e.g., enginePath for OpenSSL GOST).
+            </summary>
+        </member>
+        <member name="T:StellaOps.Cryptography.PluginLoader.CryptoComplianceConfiguration">
+            <summary>
+            Compliance profile configuration for regional crypto requirements.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoComplianceConfiguration.ProfileId">
+            <summary>
+            Compliance profile identifier (e.g., "gost", "fips", "eidas", "sm").
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoComplianceConfiguration.StrictValidation">
+            <summary>
+            Enable strict validation (reject algorithms not compliant with profile).
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoComplianceConfiguration.EnforceJurisdiction">
+            <summary>
+            Enforce jurisdiction filtering (only load plugins for specified jurisdictions).
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoComplianceConfiguration.AllowedJurisdictions">
+            <summary>
+            Allowed jurisdictions (e.g., ["russia"], ["eu"], ["world"]).
+            </summary>
+        </member>
+        <member name="T:StellaOps.Cryptography.PluginLoader.CryptoPluginLoader">
+            <summary>
+            Loads crypto provider plugins dynamically based on manifest and configuration.
+            </summary>
+        </member>
+        <member name="M:StellaOps.Cryptography.PluginLoader.CryptoPluginLoader.#ctor(StellaOps.Cryptography.PluginLoader.CryptoPluginConfiguration,Microsoft.Extensions.Logging.ILogger{StellaOps.Cryptography.PluginLoader.CryptoPluginLoader},System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:StellaOps.Cryptography.PluginLoader.CryptoPluginLoader"/> class.
+            </summary>
+            <param name="configuration">Plugin configuration.</param>
+            <param name="logger">Optional logger instance.</param>
+            <param name="pluginDirectory">Optional plugin directory path. Defaults to application base directory.</param>
+        </member>
+        <member name="M:StellaOps.Cryptography.PluginLoader.CryptoPluginLoader.LoadProviders">
+            <summary>
+            Loads all configured crypto providers.
+            </summary>
+            <returns>Collection of loaded provider instances.</returns>
+        </member>
+        <member name="T:StellaOps.Cryptography.PluginLoader.CryptoPluginLoader.PluginAssemblyLoadContext">
+            <summary>
+            AssemblyLoadContext for plugin isolation.
+            </summary>
+        </member>
+        <member name="T:StellaOps.Cryptography.PluginLoader.CryptoPluginLoadException">
+            <summary>
+            Exception thrown when a crypto plugin fails to load.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginLoadException.PluginId">
+            <summary>
+            Gets the identifier of the plugin that failed to load, if known.
+            </summary>
+        </member>
+        <member name="M:StellaOps.Cryptography.PluginLoader.CryptoPluginLoadException.#ctor(System.String,System.String,System.Exception)">
+            <summary>
+            Initializes a new instance of the <see cref="T:StellaOps.Cryptography.PluginLoader.CryptoPluginLoadException"/> class.
+            </summary>
+            <param name="message">Error message.</param>
+            <param name="pluginId">Plugin identifier, or null if unknown.</param>
+            <param name="innerException">Inner exception, or null.</param>
+        </member>
+        <member name="T:StellaOps.Cryptography.PluginLoader.CryptoPluginManifest">
+            <summary>
+            Root manifest structure declaring available crypto plugins.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginManifest.Schema">
+            <summary>
+            Gets or inits the JSON schema URI for manifest validation.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginManifest.Version">
+            <summary>
+            Gets or inits the manifest version.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginManifest.Plugins">
+            <summary>
+            Gets or inits the list of available crypto plugin descriptors.
+            </summary>
+        </member>
+        <member name="T:StellaOps.Cryptography.PluginLoader.CryptoPluginDescriptor">
+            <summary>
+            Describes a single crypto plugin with its capabilities and metadata.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginDescriptor.Id">
+            <summary>
+            Unique plugin identifier (e.g., "openssl.gost", "cryptopro.gost").
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginDescriptor.Name">
+            <summary>
+            Human-readable plugin name.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginDescriptor.Assembly">
+            <summary>
+            Assembly file name containing the provider implementation.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginDescriptor.Type">
+            <summary>
+            Fully-qualified type name of the ICryptoProvider implementation.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginDescriptor.Capabilities">
+            <summary>
+            Capabilities supported by this plugin (e.g., "signing:ES256", "hashing:SHA256").
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginDescriptor.Jurisdiction">
+            <summary>
+            Jurisdiction/region where this plugin is applicable (e.g., "russia", "china", "eu", "world").
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginDescriptor.Compliance">
+            <summary>
+            Compliance standards supported (e.g., "GOST", "FIPS-140-3", "eIDAS").
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginDescriptor.Platforms">
+            <summary>
+            Supported platforms (e.g., "linux", "windows", "osx").
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginDescriptor.Priority">
+            <summary>
+            Priority for provider resolution (higher = preferred). Default: 50.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginDescriptor.Options">
+            <summary>
+            Default options for plugin initialization.
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginDescriptor.ConditionalCompilation">
+            <summary>
+            Conditional compilation symbol required for this plugin (e.g., "STELLAOPS_CRYPTO_PRO").
+            </summary>
+        </member>
+        <member name="P:StellaOps.Cryptography.PluginLoader.CryptoPluginDescriptor.EnabledByDefault">
+            <summary>
+            Whether this plugin is enabled by default. Default: true.
+            </summary>
+        </member>
+    </members>
+</doc>

src/BinaryIndex/StellaOps.BinaryIndex.WebService/docs/qa/feature-checks/runs/binaryindex/vulnerable-binaries-database/run-001/tier1-build-out/StellaOps.BinaryIndex.WebService/appsettings.Development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Debug",
+      "Microsoft.AspNetCore": "Information"
+    }
+  }
+}

src/BinaryIndex/StellaOps.BinaryIndex.WebService/docs/qa/feature-checks/runs/binaryindex/vulnerable-binaries-database/run-001/tier1-build-out/StellaOps.BinaryIndex.WebService/appsettings.json

@@ -0,0 +1,33 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*",
+  "ConnectionStrings": {
+    "Redis": "localhost:6379"
+  },
+  "Resolution": {
+    "DefaultCacheTtl": "04:00:00",
+    "MaxBatchSize": 500,
+    "EnableDsseByDefault": true,
+    "MinConfidenceThreshold": 0.70
+  },
+  "ResolutionCache": {
+    "FixedTtl": "24:00:00",
+    "VulnerableTtl": "04:00:00",
+    "UnknownTtl": "01:00:00",
+    "KeyPrefix": "resolution",
+    "EnableEarlyExpiry": true,
+    "EarlyExpiryFactor": 0.1
+  },
+  "VexBridge": {
+    "SignWithDsse": true,
+    "DefaultProviderId": "stellaops.binaryindex",
+    "DefaultStreamId": "binary_resolution",
+    "MinConfidenceThreshold": 0.70,
+    "MaxBatchSize": 1000
+  }
+}