feat: V12 API modernization, AOT-safe assembly config, V10→V11 migration, and full coverage

[glennawatson]

Summary

This PR is the V12 modernization pass for Akavache. The end-user surface is the four breaking-change sections below plus a migration guide; the rest — analyzer sweep, polyfills, cross-TFM build plumbing, test rewrite, coverage config — is consolidated under Maintainer notes.

1. Reflection-based assembly discovery is deprecated — the builder no longer probes Assembly.GetEntryAssembly() at construction time. There is a new AOT-safe fluent API.
2. A real V10→V11 migration pipeline — if you have an existing pre-V11 Akavache cache on disk, you can now read it and pull the contents into the V11 store without a custom migration script.
3. Required application name on CacheDatabase.Initialize / CreateBuilder — the old parameterless overloads are marked [Obsolete].
4. AOT-safe JsonTypeInfo serialization — exposed via extension methods in Akavache.SystemTextJson.Bson, so Akavache.Core itself stays serializer-agnostic and Newtonsoft-only consumers do not transitively pull in System.Text.Json.

A full user-facing migration walkthrough lives in docs/migration-v11-to-v12.md.

---

1. Reflection is out — use WithExecutingAssembly instead

What changed. IAkavacheInstance.ExecutingAssembly, ExecutingAssemblyName and Version are now [Obsolete]. The AkavacheBuilder constructor no longer calls Assembly.GetEntryAssembly() / Assembly.GetExecutingAssembly() / GetCustomAttribute<AssemblyFileVersionAttribute>(). By default these properties now return:

• ExecutingAssembly → Akavache's own assembly (a sentinel)
• ExecutingAssemblyName → null
• Version → null

Why. Reflection-based assembly discovery does not reliably yield the caller's assembly in trimmed or NativeAOT-published apps — the entry assembly can go missing, attributes can be trimmed, and the resulting cache paths shift at runtime. Worse, relying on Assembly.GetEntryAssembly() adds a hidden reflection pin point that blocks trimming.

What to do. If your app reads any of those three properties, stop reading them from Akavache and hold your own Assembly reference instead:

var myAssembly = typeof(MyApp).Assembly;
var name       = myAssembly.GetName().Name;
var version    = myAssembly.GetName().Version;

If you want Akavache itself to track the value (so it flows through anything that still reads IAkavacheInstance), use the new AOT-safe fluent method on the builder:

CacheDatabase.CreateBuilder("MyApp")
    .WithSerializer<SystemJsonSerializer>()
    .WithExecutingAssembly(typeof(MyApp).Assembly) // AOT-safe — caller-owned reference
    .WithSqliteProvider()
    .WithSqliteDefaults()
    .Build();

Because the assembly reference is caller-owned, there is no runtime reflection discovery at all. WithExecutingAssembly reads the name and AssemblyFileVersionAttribute off the instance you pass, which is trim/AOT-safe.

The old behaviour is still available behind the legacy AssemblyInfoHelper (also marked [Obsolete]), but nothing in the builder calls it by default anymore.

---

2. V10 → V11 migration

Akavache V11 changed the on-disk format — the old sqlite3 CacheElement table layout was replaced by the new CacheEntry schema, and the per-cache file names changed. If you ship V11+ to users who already have V10 data on disk, you need to migrate it.

What ships in this PR.

• A dedicated Akavache.V10toV11 project with a V10MigrationService that knows how to read the legacy CacheElement / CacheIndex tables and project them into the new shape.
• An IAkavacheBuilder.WithV10ToV11Migration(...) extension that wires the migration into the builder pipeline so it runs the first time the V11 cache is opened.
• Support for reading legacy V10 bytes in-place inside SqliteBlobCache / EncryptedSqliteBlobCache via TryGetLegacyValueAsync, so keys that never got migrated still resolve against the legacy table as a fallback.

How to opt in. If your app used V10 Akavache before upgrading, add the V10→V11 migration step when configuring the builder:

using Akavache.V10toV11;

CacheDatabase.CreateBuilder("MyApp")
    .WithSerializer<SystemJsonSerializer>()
    .WithV10ToV11Migration()   // reads legacy CacheElement rows on first open
    .WithSqliteProvider()
    .WithSqliteDefaults()
    .Build();

On first open, the migration service:

1. Opens the legacy V10 cache files at the same on-disk locations they lived at before (governed by FileLocationOption.Legacy if your app is using the legacy directory layout).
2. Reads the CacheElement rows plus the old file-name map.
3. Writes each entry into the new V11 CacheEntry table on the corresponding V11 cache, preserving keys, expiration, and type metadata.
4. Leaves the legacy file in place. Any keys that weren't copied are still readable through the TryGetLegacyValueAsync fallback inside SqliteBlobCache / EncryptedSqliteBlobCache.

Migration characteristics.

• Safe on failure. If reading a V10 row throws, the migration moves on and the row remains accessible via the in-process legacy fallback.
• Idempotent. Re-running WithV10ToV11Migration() on an already-migrated store is a no-op.
• Encrypted caches. The EncryptedSqlite3 flavour migrates the same way — you pass the V10 password through the same builder path.
• Timing. The migration runs at builder Build() time, synchronously from the caller's perspective, so it completes before your app starts hitting the cache for reads.

---

3. Required application name

CacheDatabase.Initialize<T>() and CacheDatabase.CreateBuilder() now require an explicit applicationName argument. The old parameterless CreateBuilder() overload is marked [Obsolete] but still compiles.

// V11 style (still works, but deprecated)
CacheDatabase.CreateBuilder();

// V12 style (required)
CacheDatabase.CreateBuilder("MyApp");
CacheDatabase.Initialize<SystemJsonSerializer>("MyApp");

This is the single biggest source of cache-path drift between reflection-based builds and NativeAOT — being explicit kills the ambiguity entirely.

---

4. AOT-safe JsonTypeInfo serialization lives in Akavache.SystemTextJson.Bson

ISerializer in Akavache.Core deliberately stays serializer-agnostic. It does not know about System.Text.Json and does not declare any JsonTypeInfo<T> overloads. The base interface is just the two reflection-based members:

[RequiresUnreferencedCode("...")]
[RequiresDynamicCode("...")]
T? Deserialize<T>(byte[] bytes);

[RequiresUnreferencedCode("...")]
[RequiresDynamicCode("...")]
byte[] Serialize<T>(T item);

The AOT-safe JsonTypeInfo<T> path is provided by extension methods that ship in Akavache.SystemTextJson.Bson (which transitively brings in Akavache.SystemTextJson). Importing using Akavache.SystemTextJson; gives you:

using Akavache.SystemTextJson;

// Call site looks identical to an instance method:
var bytes  = serializer.Serialize(myModel, AppJsonContext.Default.MyModel);
var result = serializer.Deserialize<MyModel>(bytes, AppJsonContext.Default.MyModel);

Under the hood the extension methods type-check the runtime serializer:

• SystemJsonSerializer → routes to its static DeserializeAot / SerializeAot methods (pure JsonTypeInfo path, no reflection)
• SystemJsonBsonSerializer → routes through the same path (BSON cannot be AOT-encoded, so the AOT overload emits plain JSON bytes)
• Any other ISerializer (for example Newtonsoft-backed) → throws NotSupportedException. Use the non-typed Deserialize<T>(byte[]) / Serialize<T>(T) overloads on Newtonsoft.

This indirection keeps Akavache.Core free of a hard dependency on System.Text.Json, so Newtonsoft-only consumers do not transitively pull it in.

---

Other user-visible changes

• SystemTextJson.Bson split out into its own Akavache.SystemTextJson.Bson NuGet package. If you were using SystemJsonBsonSerializer from Akavache.SystemTextJson, switch your package reference.
• ISerializer.Deserialize(byte[], Type) was reverted. The non-generic overload is gone — use Deserialize<T>(byte[]).
• SerializerExtensions.Get(IBlobCache, string, Type) (the reflection-based variant) was removed.
• CheckpointMode enum added for explicit control over SQLite WAL checkpoint strategy.
• New IAkavacheConnection / IAkavacheTransaction abstractions let you drive SqliteBlobCache / EncryptedSqliteBlobCache with a custom backing connection instead of the default SqliteAkavacheConnection / SqliteAkavacheTransaction implementations shipped in Akavache.Sqlite3.
• Lock primitives upgraded to System.Threading.Lock on net9+. AkavacheBuilder, InMemoryBlobCacheBase, and NewtonsoftSerializer use C# 13's Lock type under #if NET9_0_OR_GREATER, which lets the JIT use tighter lock-acquire codegen than the legacy object-monitor path on those targets. NewtonsoftSerializer additionally stops locking on the user-supplied JsonSerializerSettings and uses a private lock object instead.
• MAUI sample XAML compiles with x:DataType so MAUI's compiled-bindings analyzer is happy (no more XC0022 warnings on MainPage.xaml / EditTodoPage.xaml).
• WPF and MAUI sample value converters return Binding.DoNothing / BindableProperty.UnsetValue from ConvertBack instead of throwing — the canonical one-way-converter idiom that the binding engine recognises without exception round-tripping.

---

Maintainer notes

Test count and coverage

Test count is up from ~1600 to 3940 across net8.0 and net9.0, with 0 skipped tests (down from 14 skipped — the chronically-flaky DateTimeSerializationShouldBeConsistentAndAccurate parameterised test and the duplicated SettingsStorageTests are gone). Production assemblies sit at 100% line / 100% branch coverage: 4438/4438 lines, 1714/1714 branches across Akavache.Core, Akavache.Drawing, Akavache.EncryptedSqlite3, Akavache.NewtonsoftJson, Akavache.Settings, Akavache.Sqlite3, Akavache.SystemTextJson, and Akavache.SystemTextJson.Bson.

Most of the new coverage came from extracting previously-private helpers (SqliteBlobCache.ToExpiryValue, GetOrCreateHttpService, TryGetLegacyValueAsync, InitializeDatabase; BitmapImageExtensions.ThrowOnBadImageBuffer / ThrowOnNullOrBadImageBuffer / BytesToImage; UniversalSerializer.CastAsDateTime / CastAsDateTimeOffset / FindKeyCandidates / TryDeserializeCandidate; the JsonTypeInfo dispatch helpers; etc.) to internal static methods with explicit parameters and adding direct unit tests for each. UniversalSerializerTests was moved into the shared CacheDatabaseState NotInParallel group to fix a pre-existing flaky race against the builder-extension tests that also mutate UniversalSerializer._registeredSerializerFactories.

VSTest → Microsoft.Testing.Platform (MTP) + TUnit

• The entire test suite runs on Microsoft.Testing.Platform with TUnit instead of VSTest/xUnit. TestingPlatformDotnetTestSupport is enabled in Directory.Build.props, MTP is discovered via src/global.json, and src/tests.runsettings was deleted (legacy VSTest file).
• Test isolation for anything touching CacheDatabase / AppLocator uses a shared AkavacheTestExecutor base together with TUnit's [NotInParallel("CacheDatabaseState")] so cross-test global-state mutation is serialized. Previously this was handled ad-hoc and leaked.
• Native-SQLite tests use in-memory databases by default and are individually gated with NotInParallel groups — no disk contention.
• A new TaskAssertionExtensions.ShouldThrowAsync<TException>(this Task) helper lets tests assert that a task faults with a specific exception without going through TUnit's Assert.That<T>(Func<Task<T?>>) overload (which fails to unify Task<T> with Task<T?> for non-nullable T and produces CS8619). The five test files exercising SQLite / encrypted / in-memory disposed-state and arg-validation paths use this helper end-to-end, so the suite builds clean with WarningsAsErrors for nullability.
• InMemoryBlobCacheBaseTests consistently uses await using var cache = CreateCache(); instead of try { … } finally { await cache.DisposeAsync(); }.
• Test-stub Assembly.GetCustomAttributes overrides return a typed static Attribute[] field — not a collection-expression literal [] — because the return type is object[] and [] would be inferred as object[], which breaks the framework's internal cast in CustomAttributeExtensions.GetCustomAttribute<T>(Assembly).
• ConcurrencyTests is a sealed instance-method test class (TUnit's source generator instantiates fixtures, so static test methods would fail at codegen time).

Code coverage configuration (src/testconfig.json)

The previous testconfig.json used invalid top-level keys (platform, extensions[]) that are not part of the Microsoft.Testing.Platform schema and were silently ignored. The file has been rewritten to use the documented codeCoverage.Configuration.CodeCoverage schema with Attributes.Exclude for:

• System.CodeDom.Compiler.GeneratedCodeAttribute
• System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute
• System.Diagnostics.DebuggerHiddenAttribute
• System.Diagnostics.DebuggerNonUserCodeAttribute

This correctly excludes source-generator output (notably RegexGenerator.g.cs from [GeneratedRegex]) from the coverage numerator and denominator. ModulePaths.Include / Exclude are intentionally not specified: per the docs, empty Include clauses imply all, and MTP's default IncludeTestAssembly: false already drops the test assemblies without any custom filter.

Cross-TFM build plumbing

• <EnableWindowsTargeting>true</EnableWindowsTargeting> added to Directory.Build.props. Combined with dropping the IsOsPlatform('Windows') guard on AkavacheWindowsDesktopTargets, this lets Linux / macOS CI and developer machines build net462 / net472 / net481 and net8.0/9.0/10.0-windows10.0.19041.0 TFMs, mirroring ReactiveUI's setup. Previously those targets only compiled on Windows runners, so TFM-specific regressions surfaced only at PR time.
• Akavache.Core/Polyfills ships typed stand-ins for RequiresUnreferencedCodeAttribute, RequiresDynamicCodeAttribute, DoesNotReturnAttribute, NotNullAttribute, UnconditionalSuppressMessageAttribute, and CallerArgumentExpressionAttribute, gated #if !NET. InternalsVisibleTo is set for every satellite assembly, so Akavache.NewtonsoftJson / SystemTextJson / SystemTextJson.Bson / Sqlite3 / Settings / V10toV11 can apply [RequiresUnreferencedCode] and friends unconditionally — the old #if NET6_0_OR_GREATER gates around every AOT-annotated method are gone (six duplicated method declarations removed from Akavache.NewtonsoftJson/AkavacheBuilderExtensions.cs alone).
• HashCode polyfill (Akavache.Core/Polyfills/HashCode.cs, #if NETFRAMEWORK) — xxHash32-based with Combine<T1..T4> and AddBytes(ReadOnlySpan<byte>). Size.GetHashCode, LoginInfo, and CacheEntry hash through it. The polyfill uses RandomNumberGenerator.Create() for the per-process seed (not System.Random, to satisfy CA5394) and its ToHashCode is marked readonly.

Source-generator regex split

DateTimeHelpers.Iso8601Regex() and SystemJsonBsonSerializer.GetDateRegex() both use [GeneratedRegex] on net7+, which doesn't exist on net462 / net472 / net481 / netstandard2.0. Each has been split into two sibling partial files — *.Regex.SourceGen.cs (#if NET7_0_OR_GREATER, [GeneratedRegex] partial method) and *.Regex.NetFramework.cs (#if !NET7_0_OR_GREATER, static readonly Regex field + body method returning it) — so the main file stays TFM-clean and callers are unchanged.

Netfx API parity fixes

Everything the netfx TFMs needed now that they actually compile cross-platform:

• UniversalSerializer: ArgumentNullException.ThrowIfNull replaced with ArgumentExceptionHelper.ThrowIfNull (the BCL method is net6+). The "..."-quoted string trimming path stopped using string.StartsWith(char) + range indexer [1..^1] (both net6+) and uses index access + Substring instead.
• RequestCache.GetOrCreateRequest: the 3-argument ConcurrentDictionary.GetOrAdd(key, factory, arg) overload is net-core-only — replaced with the 2-argument overload that closes over fetchFunc directly. Same visible behaviour.
• InMemoryBlobCacheBase.VacuumExpiredEntries / CollectExpiredKeys and SqliteBlobCache.TryGetLegacyValueAsync drop the in DateTimeOffset parameter modifier (RCS1242 — DateTimeOffset is not a readonly struct, so in forces defensive copies at every member access).
• Akavache.Settings/AkavacheBuilderExtensions.GetLoadedSettingsStore: Dictionary<TKey,TValue>.GetValueOrDefault is net6+ → switched to TryGetValue(..., out var) ? value : null.
• HttpService.ProcessWebResponse: decorated with [SuppressMessage("Style", "IDE0200", ...)] — the lambda around ReadAsByteArrayAsync() cannot be collapsed to a method group because net6+ adds a CancellationToken overload that makes the method group ambiguous at the Observable.FromAsync call site.
• BinaryHelpers XML doc: cref <see cref="BinaryPrimitives"/> → plain <c>System.Buffers.Binary.BinaryPrimitives</c> (net472/net481 don't ship the type, so the cref won't resolve).
• samples/AkavacheTodoMaui/MauiProgram.cs: explicit using Microsoft.Extensions.Logging; so builder.Logging.AddDebug() resolves on net10.0-android, where the implicit-usings machinery doesn't pull it in.
• Empty-body polyfill attributes (DoesNotReturnAttribute, NotNullAttribute) use the class Foo : Attribute; shorthand (RCS1251).
• RequiresDynamicCodeAttribute polyfill's ctor has a <param name="message"> doc (SA1611).

Layout, analyzer enforcement, and code modernisation

• Source tree restructured into src/tests/, src/benchmarks/, src/samples/, src/compat/ subfolders. Akavache.slnx, csproj ProjectReference paths, codecov.yml, and CLAUDE.md updated. BENCHMARK_REPORT.md and PERFORMANCE_SUMMARY.md live under docs/.
• .editorconfig enforces the full Microsoft Code Analysis catalogue as error: CA Design / Performance / Reliability / Usage / Security / Maintainability / Globalization / Interoperability / Naming, plus SYSLIB0xxx runtime obsoletions and SYSLIB1xxx source-generator diagnostics.
• IDE language / naming / miscellaneous style rules are enforced as error. <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild> in Directory.Build.props runs them at compile time.
• Roslynator simplification, code-quality, performance, maintainability, and documentation categories are enforced as error. Rules with a CA / SA equivalent are routed to none with # handled by … comments so we never double-report.
• A curated ReSharper / Rider inspection set (~95 rules) at the bottom of .editorconfig is mapped 1:1 to the CA / SA / RCS / IDE rules where an equivalent exists, and disables the inspections that flag deliberate access-modifier or naming choices.
• Test-only .editorconfig overrides in src/tests/: IDE0200 (TUnit Assert.That(...).Throws<T>() requires the explicit lambda — the method-group overload binds to a different Assert.That that does not invoke the delegate), RCS1079 (test fakes deliberately throw NotImplementedException), RCS1223 (no DebuggerDisplay on test fixtures).

Code modernisation sweep

With the analyzer catalogue promoted to error, the whole codebase was pulled forward to modern C#:

• Collection expressions ([..xs], []) replace .ToArray() / .ToList() / Array.Empty<T>() where it compiles cleanly — except on the test stub classes mentioned above where the inferred type matters.
• static lambdas on every anonymous function that captures nothing (IDE0320 enforced — ~250 call sites updated).
• C# 13 field keyword for lazy-init property backing storage. SqliteBlobCache.HttpService is the canonical example: get => field ??= new HttpService(); with no manual backing field.
• await using declarations replace await using (var x = ...) { ... } blocks where the scope allows.
• Simplified Equals / GetHashCode on CacheEntry and LoginInfo — ReferenceEquals short-circuits, HashCode.AddBytes(ReadOnlySpan<byte>), and a private ValueEquals helper for byte-array content equality.
• File-scoped namespaces throughout.
• Pattern matching (is not, property patterns, is { Version: var v }) replaces nested null checks and as + null checks.
• Compound assignments (+=, ??=), inferred tuple member names, and target-typed new().
• Dead defensive code removed. SecureBlobCacheWrapper.Dispose / DisposeAsync no longer guard against inner is not IDisposable / IAsyncDisposable. Those checks were statically unreachable because IBlobCache : IDisposable, IAsyncDisposable — the compiler already enforces both interfaces on any inner the wrapper sees.
• UniversalSerializer.TryBasicJsonDeserialization<T> restored to its original string/int/bool-only surface. An earlier refactor silently added double / long cases that were never covered by tests and broke TryBasicJsonDeserializationShouldReturnDefaultForDoubleType, which asserted that doubles return default(double).
• PreserveAttribute and its tests are removed; SqliteBlobCache no longer references it.
• ArgumentExceptionHelper, DateTimeHelpers, AkavacheBuilder.ApplyForcedDateTimeKind, and InMemoryBlobCacheBase.ForcedDateTimeKind setter use the early-return form (RCS1208).
• Assembly.Location replaced with AppContext.BaseDirectory plus AssemblyFileVersionAttribute — trim/AOT-friendly and works on single-file publish.

Test plan

• CI green on net462, net472, net481, net6.0, net8.0, net9.0, net10.0
• Akavache.Tests passes (3940 tests, 0 failures, 0 skipped) on a fresh checkout
• Akavache.Settings.Tests passes on a fresh checkout
• Coverage run (dotnet test -- --coverage --coverage-output-format cobertura) reports 100% line / 100% branch (4438/4438 / 1714/1714) across production assemblies
• Manual smoke test: load a V10 on-disk cache in a sample app with .WithV10ToV11Migration() and confirm legacy keys resolve
• Manual smoke test: publish the AkavacheTodoMaui sample with NativeAOT and confirm cache paths are stable without ExecutingAssembly being touched

[Copilot]

Pull request overview

Note

Copilot was unable to run its full agentic suite in this review.

This PR modernizes Akavache for a V12 release by removing implicit reflection-based assembly discovery in favor of explicit/AOT-safe configuration, introducing a V10→V11 migration pipeline, and expanding/strengthening test coverage across core and extension packages.

Changes:

• Adds AOT-safe builder/config APIs (explicit applicationName, explicit executing assembly, connection abstractions) and updates related call sites.
• Introduces new packages/abstractions (e.g., Akavache.SystemTextJson.Bson, IAkavacheConnection/IAkavacheTransaction) and refactors internals for testability.
• Expands tests significantly and adjusts parallelization/isolation to reduce flakiness.

Reviewed changes

Copilot reviewed 89 out of 119 changed files in this pull request and generated 4 comments.

Show a summary per file

File	Description
src/Akavache.Tests/RequestCacheTests.cs	Adds coverage for in-flight request tracking/removal and disables parallel execution for isolation.
src/Akavache.Tests/RelativeTimeExtensionsTests.cs	Adds broad coverage for TimeSpan-based extension overloads and null-guard branches.
src/Akavache.Tests/PreserveAttributeTests.cs	Adds targeted unit tests for the internal PreserveAttribute surface.
src/Akavache.Tests/NewtonsoftJsonBuilderExtensionsTests.cs	Adds tests for Newtonsoft builder extensions and factory lambda execution coverage.
src/Akavache.Tests/NewtonsoftDateTimeContractResolverTests.cs	Adds tests for contract resolver converter behavior and recursion guard.
src/Akavache.Tests/Mocks/SerializerTestModel.cs	Adds a shared model to support serializer tests.
src/Akavache.Tests/Mocks/SerializerTestContext.cs	Adds source-gen JsonSerializerContext for AOT-style serializer tests.
src/Akavache.Tests/Mocks/InMemoryAkavacheTransaction.cs	Adds in-memory transaction mock for connection abstraction tests.
src/Akavache.Tests/Mocks/InMemoryAkavacheConnection.cs	Adds in-memory connection mock (incl. failure simulation) for sqlite cache logic tests.
src/Akavache.Tests/LoginInfoTests.cs	Adds constructor coverage for LoginInfo.
src/Akavache.Tests/LoginExtensionsTests.cs	Adds coverage for GetLogin null-deserialization branch.
src/Akavache.Tests/LegacyFileLocationTests.cs	Disables parallel execution for shared CacheDatabase state scenarios.
src/Akavache.Tests/ISerializerDefaultMethodTests.cs	Adds tests asserting default interface method behavior for new JsonTypeInfo overloads.
src/Akavache.Tests/HttpExtensionsTests.cs	Adds tests for HTTP extension argument validation and stream error paths.
src/Akavache.Tests/Executors/AkavacheTestExecutor.cs	Adds a test executor that resets global Akavache/Splat state for isolation.
src/Akavache.Tests/DownloadUrlExtensionsTests.cs	Updates initialization to require application name; disables parallel execution.
src/Akavache.Tests/BinaryHelpersTests.cs	Adds unit tests for BinaryHelpers little-endian decoders.
src/Akavache.Tests/BackwardCompatibilityTests.cs	Updates initialization API usage and disables parallel execution for global state.
src/Akavache.Tests/AssemblyInfoHelperTests.cs	Adds coverage for the obsolete reflection-based assembly helper.
src/Akavache.Tests/Akavache.Tests.csproj	Adds CS0618 suppression and TUnit executor usings; adds new project references.
src/Akavache.SystemTextJson/SystemJsonBsonSerializer.cs	Removes BSON serializer from base STJ package (split into dedicated project).
src/Akavache.SystemTextJson/AkavacheBuilderExtensions.cs	Registers serializers with UniversalSerializer and removes BSON builder APIs from this package.
src/Akavache.SystemTextJson/Akavache.SystemTextJson.csproj	Removes Newtonsoft deps and exposes internals to tests/BSON package.
src/Akavache.SystemTextJson.Bson/SystemJsonBsonSerializer.cs	Introduces BSON serializer implementation in the split package.
src/Akavache.SystemTextJson.Bson/AkavacheBuilderExtensions.cs	Adds builder extensions for configuring BSON serializer usage.
src/Akavache.SystemTextJson.Bson/Akavache.SystemTextJson.Bson.csproj	Adds new BSON project with Newtonsoft.Json.Bson dependencies.
src/Akavache.Sqlite3/SqliteAkavacheTransaction.cs	Adds sqlite implementation of the new transaction abstraction.
src/Akavache.Sqlite3/SqliteAkavacheConnection.cs	Adds sqlite implementation of the new connection abstraction and legacy V10 reads.
src/Akavache.Sqlite3/AkavacheBuilderExtensions.cs	Refactors sqlite cache creation and exposes internals for testing/migration.
src/Akavache.Sqlite3/Akavache.Sqlite3.csproj	Adds InternalsVisibleTo for migration project.
src/Akavache.Settings/Akavache.Settings.csproj	Adds InternalsVisibleTo for test projects.
src/Akavache.Settings.Tests/SettingsCacheTests.cs	Updates nullability annotations for applicationName pass-through.
src/Akavache.Settings.Tests/SettingsBaseFallbackTests.cs	Updates nullability annotations for applicationName pass-through.
src/Akavache.Settings.Tests/EncryptedSettingsCacheTests.cs	Updates nullability; adjusts expectations for obsolete assembly metadata defaults.
src/Akavache.Settings.Tests/AkavacheBuilderExtensionsTests.cs	Updates nullability annotations for applicationName pass-through.
src/Akavache.Settings.Tests/Akavache.Settings.Tests.csproj	Adds CS0618 suppression.
src/Akavache.NewtonsoftJson/NewtonsoftSerializer.cs	Refactors BSON/JSON fallback paths and exposes internals for tests.
src/Akavache.NewtonsoftJson/NewtonsoftDateTimeTickConverter.cs	Simplifies DateTime kind switch logic/comments.
src/Akavache.NewtonsoftJson/NewtonsoftDateTimeOffsetTickConverter.cs	Refactors object-token reading via JObject and exposes helper for tests.
src/Akavache.NewtonsoftJson/AkavacheBuilderExtensions.cs	Registers Newtonsoft serializers with UniversalSerializer.
src/Akavache.NewtonsoftJson/Akavache.NewtonsoftJson.csproj	Adds InternalsVisibleTo for tests.
src/Akavache.EncryptedSqlite3/Akavache.EncryptedSqlite3.csproj	Adds InternalsVisibleTo; includes new connection/transaction compilation units.
src/Akavache.Drawing/ImageCacheExtensions.cs	Replaces ad-hoc null checks with shared argument helper; refactors image buffer validation call.
src/Akavache.Drawing/BitmapImageExtensions.cs	Refactors image buffer validation into internal helpers and improves docs.
src/Akavache.Drawing/Akavache.Drawing.csproj	Adds InternalsVisibleTo for tests.
src/Akavache.Core/SerializerExtensions.cs	Removes reflection-based APIs and standardizes null-guards; extracts ShouldRefetchCachedValue.
src/Akavache.Core/RelativeTimeExtensions.cs	Standardizes null-guards via helper and expands method bodies for testability.
src/Akavache.Core/Polyfills/UnconditionalSuppressMessageAttribute.cs	Adds polyfill to enable consistent attribute usage on older TFMs.
src/Akavache.Core/Polyfills/RequiresUnreferencedCodeAttribute.cs	Adds polyfill to enable consistent attribute usage on older TFMs.
src/Akavache.Core/Polyfills/RequiresDynamicCodeAttribute.cs	Adds polyfill to enable consistent attribute usage on older TFMs.
src/Akavache.Core/InMemoryBlobCacheBase.cs	Extracts vacuum logic into internal static helpers for isolated testing.
src/Akavache.Core/ImageExtensions.cs	Standardizes null-guards and consolidates image buffer validation helpers.
src/Akavache.Core/ISerializer.cs	Adds JsonTypeInfo overloads as default interface methods for AOT-friendly usage.
src/Akavache.Core/IAkavacheTransaction.cs	Adds new transaction abstraction for backend implementations.
src/Akavache.Core/IAkavacheInstance.cs	Obsoletes assembly metadata properties and documents sentinel defaults.
src/Akavache.Core/IAkavacheConnection.cs	Adds new async connection abstraction and operational methods (checkpoint/compact/etc.).
src/Akavache.Core/IAkavacheBuilder.cs	Adds WithExecutingAssembly and updates serializer API surface docs.
src/Akavache.Core/HttpService.cs	Extracts request/response helpers and opens MakeWebRequest for testing.
src/Akavache.Core/Helpers/DateTimeHelpers.cs	Extracts DateTime conversion/recovery logic for shared reuse and testing.
src/Akavache.Core/Helpers/BinaryHelpers.cs	Adds endian-explicit binary read helpers for legacy framework support.
src/Akavache.Core/Helpers/AssemblyInfoHelper.cs	Adds obsolete reflection-based assembly helper retained for compat.
src/Akavache.Core/Helpers/ArgumentExceptionHelper.cs	Adds shared argument validation helper for consistent guard patterns.
src/Akavache.Core/Core/SecurityUtilities.cs	Removes redundant empty-name checks (relies on existing guards).
src/Akavache.Core/Core/RequestCache.cs	Exposes internal removal helper for tests.
src/Akavache.Core/Core/AkavacheBuilder.cs	Removes reflection-based discovery defaults; adds explicit executing assembly config and testable internals.
src/Akavache.Core/CheckpointMode.cs	Adds public enum for checkpoint strength abstraction.
src/Akavache.Core/CacheDatabase.cs	Requires explicit application name on initialization/builder creation; improves nullability invariants.
src/Akavache.Core/Akavache.csproj	Adds InternalsVisibleTo for migration project.
src/Akavache.Benchmarks.V10/Akavache.Benchmarks.V10.csproj	Marks benchmarks as not AOT-compatible and disables trim/AOT analyzers.
docs/migration-v11-to-v12.md	Adds v11→v12 migration documentation, including package split and serializer API changes.
README.md	Adds link to the new v11→v12 migration guide and clarifies v10→v11 wording.

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 100.00%. Comparing base (ec39b90) to head (14c47fe).
⚠️ Report is 2 commits behind head on main.

Additional details and impacted files

@@             Coverage Diff              @@
##             main     #1178       +/-   ##
============================================
+ Coverage   56.34%   100.00%   +43.65%     
============================================
  Files          34        41        +7     
  Lines        3143      2864      -279     
  Branches      739       506      -233     
============================================
+ Hits         1771      2864     +1093     
+ Misses       1116         0     -1116     
+ Partials      256         0      -256     

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

[azure-pipelines]

Azure Pipelines:
1 pipeline(s) were filtered out due to trigger conditions.